Upload 48 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+app/sentiment/faiss_index.idx filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system deps if needed later (optional)
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "backend.app.main:app", "--host", "0.0.0.0", "--port", "7860"]

Procfile

@@ -0,0 +1 @@
+web: uvicorn app.main:app --host 0.0.0.0 --port 8000

__init__.py

@@ -0,0 +1 @@
+

app/data/CATHODES_DATASET.csv

@@ -0,0 +1,26 @@
+Material_ID,Material_Name,Formula,Structure,Formation Energy (eV/atom),Conductivity(S/cm) ,Activation_Energy_eV,Sigma0 (S/cm),Measurement_Temperature (K),Band Gap (eV),Na_content,N_content,V_content,C_content,Cr_content,Co_content,Mn_content,Fe_content,F_content,Ni_content,Ti_content,P_content,O_content,Type,Electronegativity_Na,Electronegativity_Cr,Electronegativity_V,Electronegativity_Co,Electronegativity_Mn,Electronegativity_Fe,Electronegativity_F,Electronegativity_Ni,Electronegativity_Ti,Electronegativity_P,Electronegativity_O,Electronegativity_C,Electronegativity_N,Ionic_radii_Na,Ionic_radii_V,Ionic_radii_Cr,Ionic_radii_Co,Ionic_radii_Mn,Ionic_radii_Fe,Ionic_radii_F,Ionic_radii_Ni,Ionic_radii_Ti,Ionic_radii_P,Ionic_radii_O,Ionic_radii_C,Ionic_radii_N,Theoretical Capacity (mAh/g),Practical Capacity (mAh/g),Average Voltage (V),Practical Energy Density (Wh/kg),Material Mass (g/mol),Cycle Life to 80% Capacity (cycles),Capacity Retention after 100 Cycles (%),Capacity Retention after 200 Cycles (%),Capacity Retention after 500 Cycles (%),Degradation Rate (%/cycle),C-rate,Voltage Window Lower (V),Voltage Window Upper (V),Power Density (W/kg),Maximum Discharge Current (A/g),Voltage at High C-rate (V),Internal Resistance (Ω),Internal Impedance (S/cm),Capacity at Temperature (mAh/g),Thermal Stability Onset (°C),Ionic Conductivity of Electrolyte (mS/cm),plateau voltage charge ,plateau voltage discharge,knee point charge,knee point discharge,Coulombic Efficiency (%),Charge Time (h),Discharge Time (h),dQ/dV Peak Position Charge (V),dQ/dV Peak Position Discharge (V) 
+mp-1179963,Sodium Chromium Oxide,NaCrO2,Hexagonal,-1.136,1.7 × 10⁻⁷ ,0.4,1 × 10⁻³,323,0.71,1,0,0,0,1,0,0,0,0,0,0,0,2,Cathode,0.93,1.66,0,0,0,0,0,0,0,0,3.44,0,0,1.02,0,0.615,0,0,0,0,0,0,0,1.4,0,0,125,110,2.72,177,105.98,1000,90,83,74,0.06,1,2,3.6,150,0.05,2.7,50,2 × 10⁻⁴,103.6 ,250,1.2,3,2.9,3.2,2.7,98.2,2,2,3,2.93
+mp-18245,Sodium Cobalt Phosphate,NaCoPO4,Orthorhombic,-2.31,1.0 × 10⁻⁷,0.73,1.6 × 10⁻³ ,323,2.2,1,0,0,0,0,1,0,0,0,0,0,1,4,Cathode,0.93,0,0,1.88,0,0,0,0,0,2.19,3.44,0,0,1.02,0,0,0.745,0,0,0,0,0,0.17,1.4,0,0,106,85,3.1,132,164.89,500,88,80,70,0.09,1,2,4,120,0.05,2.7,60,2 × 10⁻⁴,84,250,1.2,3.3,3.1,3.4,2.8,98,2,2,3.3,3.1
+mp-18245,Sodium Cobalt Phosphate,NaCoPO4,Orthorhombic,-2.31,2.5 × 10⁻⁶,0.73,1.6 × 10⁻³ ,423,2.2,1,0,0,0,0,1,0,0,0,0,0,1,4,Cathode,0.93,0,0,1.88,0,0,0,0,0,2.19,3.44,0,0,1.02,0,0,0.745,0,0,0,0,0,0.17,1.4,0,0,106,82,3.1,128,164.89,480,86,77,68,0.1,1,2,4,115,0.05,2.6,62,2 × 10⁻⁴,81,250,1.2,3.3,3.1,3.4,2.8,97.5,2,2,3.3,3.1
+mp-18245,Sodium Cobalt Phosphate,NaCoPO4,Orthorhombic,-2.31,1.0 × 10⁻⁵,0.73,1.6 × 10⁻³ ,523,2.2,1,0,0,0,0,1,0,0,0,0,0,1,4,Cathode,0.93,0,0,1.88,0,0,0,0,0,2.19,3.44,0,0,1.02,0,0,0.745,0,0,0,0,0,0.17,1.4,0,0,106,78,3.1,122,164.89,450,84,74,65,0.12,1,2,4,110,0.05,2.5,65,2 × 10⁻⁴,77,250,1.2,3.3,3.1,3.4,2.8,97,2,2,3.3,3.1
+mp-776388,Sodium Nickel Phosphate,NaNiPO₄,Orthorhombic,-2.306,1 × 10⁻⁷,0.75, 1.6 × 10⁻³,323,3.34,1,0,0,0,0,0,0,0,0,1,0,1,4,Cathode,0.93,0,0,0,0,0,0,1.91,0,2.19,3.44,0,0,1.02,0,0,0,0,0,0,0.69,0,0.17,1.4,0,0,128,110,3.3,363,164.67,1000,97,95,92,0.01,1,2,4,120,0.05,2.8,50,2 × 10⁻⁴,109,250,1.2,3.4,3.2,3.5,2.9,99.5,2,2,3.4,3.2
+mp-776388,Sodium Nickel Phosphate,NaNiPO₄,Orthorhombic,-2.306,1 × 10⁻⁶,0.75, 1.6 × 10⁻³,423,3.34,1,0,0,0,0,0,0,0,0,1,0,1,4,Cathode,0.93,0,0,0,0,0,0,1.91,0,2.19,3.44,0,0,1.02,0,0,0,0,0,0,0.69,0,0.17,1.4,0,0,128,105,3.3,315,164.67,900,95,91,85,0.02,1,2,4,115,0.05,2.7,52,2 × 10⁻⁴,104,250,1.2,3.4,3.2,3.5,2.9,99.2,2,2,3.4,3.2
+mp-776388,Sodium Nickel Phosphate,NaNiPO₄,Orthorhombic,-2.306,1 × 10⁻⁵,0.75, 1.6 × 10⁻³,523,3.34,1,0,0,0,0,0,0,0,0,1,0,1,4,Cathode,0.93,0,0,0,0,0,0,1.91,0,2.19,3.44,0,0,1.02,0,0,0,0,0,0,0.69,0,0.17,1.4,0,0,128,98,3.3,294,164.67,800,92,87,80,0.025,1,2,4,110,0.05,2.6,54,2 × 10⁻⁴,97,250,1.2,3.4,3.2,3.5,2.9,99,2,2,3.4,3.2
+mp-19226,Sodium Iron Phosphate (maricite),NaFePO₄,Orthorhombic,–2.411,1.0 × 10⁻⁹,1.5,2.0 × 10⁻⁴,323,1.26,1,0,0,0,0,0,0,1,0,0,0,1,4,Cathode,0.93,0,0,0,0,1.83,0,0,0,2.19,3.44,0,0,1.02,0,0,0,0,0.78,0,0,0,0.17,1.4,0,0,154,142,2.95,169,157.75,950,95,90,84,0.03,1,1.5,4.5,170,0.05,2.6,60,2 × 10⁻⁴,141,250,1.2,2.89,3.06,3.12,2.83,98.5,2,2,2.6,2.1
+mp-19226,Sodium Iron Phosphate (maricite),NaFePO₄,Orthorhombic,–2.411,1.0 × 10⁻⁸,1.5,2.0 × 10⁻⁴,423,1.26,1,0,0,0,0,0,0,1,0,0,0,1,4,Cathode,0.93,0,0,0,0,1.83,0,0,0,2.19,3.44,0,0,1.02,0,0,0,0,0.78,0,0,0,0.17,1.4,0,0,154,135,2.93,158,157.75,900,93,88,80,0.04,1,1.5,4.5,160,0.05,2.5,62,2 × 10⁻⁴,134,250,1.2,2.87,3.03,3.1,2.8,98.2,2,2,2.6,2.1
+mp-19226,Sodium Iron Phosphate (maricite),NaFePO₄,Orthorhombic,–2.411,1.0 × 10⁻⁷,1.5,2.0 × 10⁻⁴,523,1.26,1,0,0,0,0,0,0,1,0,0,0,1,4,Cathode,0.93,0,0,0,0,1.83,0,0,0,2.19,3.44,0,0,1.02,0,0,0,0,0.78,0,0,0,0.17,1.4,0,0,154,128,2.9,148,157.75,850,90,85,75,0.05,1,1.5,4.5,150,0.05,2.4,65,2 × 10⁻⁴,127,250,1.2,2.85,3,3.08,2.75,98,2,2,2.6,2.1
+mp-775855,Sodium Manganese Phosphate,NaMnPO4,Orthorhombic,"	–2.572",1.0 × 10⁻⁸,1.1,1.0 × 10⁻³,323,3.26,1,0,0,0,0,0,1,0,0,0,0,1,4,Cathode,0.93,0,0,0,1.55,0,0,0,0,2.19,3.44,0,0,1.02,0,0,0,0.83,0,0,0,0,0.17,1.4,0,0,155,90,3.6,162,180.87,800,92,85,75,0.06,1,2,4.2,120,0.05,2.8,55,2 × 10⁻⁴,89,250,1.2,3.7,3.5,3.9,2.7,98.5,2,2,3.7,3.5
+mp-775855,Sodium Manganese Phosphate,NaMnPO4,Orthorhombic,–2.572,1.0 × 10⁻⁷,1.1,1.0 × 10⁻³,423,3.26,1,0,0,0,0,0,1,0,0,0,0,1,4,Cathode,0.93,0,0,0,1.55,0,0,0,0,2.19,3.44,0,0,1.02,0,0,0,0.83,0,0,0,0,0.17,1.4,0,0,155,85,3.6,153,180.87,700,90,82,70,0.07,1,2,4.2,110,0.05,2.7,58,2 × 10⁻⁴,84,250,1.2,3.7,3.5,3.9,2.7,98.2,2,2,3.7,3.5
+mp-775855,Sodium Manganese Phosphate,NaMnPO4,Orthorhombic,–2.572,1.0 × 10⁻⁶,1.1,1.0 × 10⁻³,523,3.26,1,0,0,0,0,0,1,0,0,0,0,1,4,Cathode,0.93,0,0,0,1.55,0,0,0,0,2.19,3.44,0,0,1.02,0,0,0,0.83,0,0,0,0,0.17,1.4,0,0,155,80,3.6,144,180.87,600,88,78,65,0.08,1,2,4.2,105,0.05,2.6,60,2 × 10⁻⁴,79,250,1.2,3.7,3.5,3.9,2.7,98,2,2,3.7,3.5
+mp-776557,Sodium Vanadium Phosphate,Na₃V₂(PO₄)₃,Monoclinic,–2.675,1.1 × 10⁻³,0.32,1.6 × 10⁻³,323,1.92,3,0,2,0,0,0,0,0,0,0,0,3,12,Cathode,0.93,0,1.63,0,0,0,0,0,0,2.19,3.44,0,0,1.02,0.64,0,0,0,0,0,0,0,0.17,1.4,0,0,117.6,107,3.4,225,435.81,5000,98,96,92,0.01,1,2,3.8,3504,2,2.8,40,2 × 10⁻⁴,106,250,1.2,3.4,3.3,3.6,2.7,98.7,1.5,1.5,3.4,3.3
+mp-776557,Sodium Vanadium Phosphate,Na₃V₂(PO₄)₃,Monoclinic,–2.675,2.2 × 10⁻³,0.32,1.6 × 10⁻³,423,1.92,3,0,2,0,0,0,0,0,0,0,0,3,12,Cathode,0.93,0,1.63,0,0,0,0,0,0,2.19,3.44,0,0,1.02,0.64,0,0,0,0,0,0,0,0.17,1.4,0,0,117.6,102,3.4,214,435.81,4000,97,95,90,0.01,1,2,3.8,3200,2,2.7,38,2 × 10⁻⁴,101,250,1.2,3.4,3.3,3.6,2.7,98.5,1.5,1.5,3.4,3.3
+mp-776557,Sodium Vanadium Phosphate,Na₃V₂(PO₄)₃,Monoclinic,–2.675,3.5 × 10⁻³,0.32,1.6 × 10⁻³,523,1.92,3,0,2,0,0,0,0,0,0,0,0,3,12,Cathode,0.93,0,1.63,0,0,0,0,0,0,2.19,3.44,0,0,1.02,0.64,0,0,0,0,0,0,0,0.17,1.4,0,0,117.6,97,3.4,204,435.81,3000,95,92,87,0.012,1,2,3.8,2900,2,2.6,36,2 × 10⁻⁴,96,250,1.2,3.4,3.3,3.6,2.7,98.2,1.5,1.5,3.4,3.3
+mp-19226,Sodium Iron Phosphate,NaFePO₄,Orthorhombic,–2.411,1.0 × 10⁻⁹,1.5,2.0 × 10⁻⁴,323,1.26,1,0,0,0,0,0,0,1,0,0,0,1,4,Cathode,0.93,0,0,0,0,1.83,0,0,0,2.19,3.44,0,0,1.02,0,0,0,0,0.78,0,0,0,0.17,1.4,0,0,154,142,2.95,169,157.75,950,95,90,84,0.03,1,1.5,4.5,170,0.05,2.6,60,2 × 10⁻⁴,141,250,1.2,2.89,3.06,3.12,2.83,98.5,2,2,2.6,2.1
+mp-19226,Sodium Iron Phosphate,NaFePO₄,Orthorhombic,–2.411,1.0 × 10⁻⁸,1.5,2.0 × 10⁻⁴,423,1.26,1,0,0,0,0,0,0,1,0,0,0,1,4,Cathode,0.93,0,0,0,0,1.83,0,0,0,2.19,3.44,0,0,1.02,0,0,0,0,0.78,0,0,0,0.17,1.4,0,0,154,130,2.92,153,157.75,850,92,87,78,0.05,1,1.5,4.5,150,0.05,2.5,62,2 × 10⁻⁴,129,250,1.2,2.87,3.03,3.1,2.8,98.2,2,2,2.6,2.1
+mp-19226,Sodium Iron Phosphate,NaFePO₄,Orthorhombic,–2.411,1.0 × 10⁻⁷,1.5,2.0 × 10⁻⁴,523,1.26,1,0,0,0,0,0,0,1,0,0,0,1,4,Cathode,0.93,0,0,0,0,1.83,0,0,0,2.19,3.44,0,0,1.02,0,0,0,0,0.78,0,0,0,0.17,1.4,0,0,154,125,2.88,140,157.75,800,88,80,70,0.08,1,1.5,4.5,130,0.05,2.3,65,2 × 10⁻⁴,124,250,1.2,2.85,3,3.08,2.75,98,2,2,2.6,2.1
+mp-1194940,Sodium Iron Fluorophosphate,Na₂FePO₄F,Orthorhombic,–2.537,1.1 × 10⁻³,0.6,1.6 × 10⁻³,323,3.53,2,0,0,0,0,0,0,1,1,0,0,1,4,Cathode,0.93,0,0,0,0,1.83,3.98,0,0,2.19,3.44,0,0,1.02,0,0,0,0,0.78,1.33,0,0,0.17,1.4,0,0,124,117,3,351,207.81,2000,98,96,92,0.01,1,2,4.5,760,2,2.7,40,2 × 10⁻⁴,116,250,1.2,3.05,2.92,3.2,2.7,99.5,2,2,3.05,2.92
+mp-1194940,Sodium Iron Fluorophosphate,Na₂FePO₄F,Orthorhombic,–2.537,2.7 × 10⁻⁶,0.6,1.6 × 10⁻³,423,3.53,2,0,0,0,0,0,0,1,1,0,0,1,4,Cathode,0.93,0,0,0,0,1.83,3.98,0,0,2.19,3.44,0,0,1.02,0,0,0,0,0.78,1.33,0,0,0.17,1.4,0,0,124,110,3,330,207.81,1800,97,95,90,0.01,1,2,4.5,700,2,2.6,42,2 × 10⁻⁴,109,250,1.2,3.05,2.92,3.2,2.7,99.4,2,2,3.05,2.92
+mp-1194940,Sodium Iron Fluorophosphate,Na₂FePO₄F,Orthorhombic,–2.537,4.5 × 10⁻⁶,0.6,1.6 × 10⁻³,523,3.53,2,0,0,0,0,0,0,1,1,0,0,1,4,Cathode,0.93,0,0,0,0,1.83,3.98,0,0,2.19,3.44,0,0,1.02,0,0,0,0,0.78,1.33,0,0,0.17,1.4,0,0,124,102,3,306,207.81,1500,95,92,87,0.013,1,2,4.5,650,2,2.5,45,2 × 10⁻⁴,101,250,1.2,3.05,2.92,3.2,2.7,99.2,2,2,3.05,2.92
+mp-694937,Sodium Vanadium Phosphate Fluoride,Na₃V₂P₂O₈F₃,Orthorhombic,–2.823,1.1 × 10⁻³,0.32,1.6 × 10⁻³,323,2.27,3,0,2,0,0,0,0,0,3,0,0,2,8,Cathode,0.93,0,1.63,0,0,0,3.98,0,0,2.19,3.44,0,0,1.02,0.64,0,0,0,0,1.33,0,0,0.17,1.4,0,0,128,114,3.8,433,441.75,2000,98,96,92,0.01,1,2,4.3,800,2,3.2,40,2 × 10⁻⁴,113,250,1.2,4,3.5,4.2,3.2,99.5,2,2,4,3.5
+mp-694937,Sodium Vanadium Phosphate Fluoride,Na₃V₂P₂O₈F₃,Orthorhombic,–2.823,2.2 × 10⁻³,0.32,1.6 × 10⁻³,423,2.27,3,0,2,0,0,0,0,0,3,0,0,2,8,Cathode,0.93,0,1.63,0,0,0,3.98,0,0,2.19,3.44,0,0,1.02,0.64,0,0,0,0,1.33,0,0,0.17,1.4,0,0,128,109,3.8,415,441.75,1800,97,95,90,0.01,1,2,4.3,780,2,3.1,42,2 × 10⁻⁴,108,250,1.2,4,3.5,4.2,3.2,99.3,2,2,4,3.5
+mp-694937,Sodium Vanadium Phosphate Fluoride,Na₃V₂P₂O₈F₃,Orthorhombic,–2.823,3.5 × 10⁻³,0.32,1.6 × 10⁻³,523,2.27,3,0,2,0,0,0,0,0,3,0,0,2,8,Cathode,0.93,0,1.63,0,0,0,3.98,0,0,2.19,3.44,0,0,1.02,0.64,0,0,0,0,1.33,0,0,0.17,1.4,0,0,128,104,3.8,395,441.75,1500,96,94,88,0.012,1,2,4.3,750,2,3,44,2 × 10⁻⁴,103,250,1.2,4,3.5,4.2,3.2,99.1,2,2,4,3.5

app/logic/calc_a.py

@@ -0,0 +1,218 @@
+import pandas as pd
+import google.generativeai as genai
+import os
+import faiss
+from openai import OpenAI
+import json
+import numpy as np
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Fixed hard carbon anode properties
+V_ANODE_MIN = 0.01
+V_ANODE_MAX = 2.0
+V_ANODE_MID = 0.1       # plateau midpoint
+C_SPEC_ANODE = 300      # mAh/g
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+csv_path = os.path.join(BASE_DIR, "..", "data", "CATHODES_DATASET.csv")
+csv_path = os.path.abspath(csv_path)
+
+# Load cathode dataset once (adjust path if needed)
+df_base = pd.read_csv(csv_path)
+
+genai.configure(api_key="AIzaSyBwMSL341arzL_FxPzy_DvhDl4Jc46DlaY")
+model = genai.GenerativeModel("gemini-2.5-pro")
+
+# Rename columns after loading
+df_base = df_base.rename(columns={
+    "Practical Capacity (mAh/g)": "C_spec_cathode",
+    "Voltage Window Lower (V)": "V_cathode_min",
+    "Voltage Window Upper (V)": "V_cathode_max",
+    "plateau voltage discharge": "V_cathode_mid"
+})
+
+def query_faiss_index(query_text, 
+                      faiss_index_path=None,
+                      metadata_path=None,
+                      openai_api_key="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",
+                      top_k=5):
+    client = OpenAI(api_key=openai_api_key)
+
+    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+    if faiss_index_path is None:
+        faiss_index_path = os.path.join(BASE_DIR, "../sentiment/faiss_index.idx")
+    if metadata_path is None:
+        metadata_path = os.path.join(BASE_DIR, "../sentiment/metadata.json")
+
+    # Load index and metadata
+    index = faiss.read_index(faiss_index_path)
+    with open(metadata_path, "r", encoding="utf-8") as f:
+        metadata = json.load(f)
+
+    # Get embedding for query
+    response = client.embeddings.create(
+        input=query_text.lower(),
+        model="text-embedding-3-large"
+    )
+    query_embedding = response.data[0].embedding
+    query_embedding_np = np.array([query_embedding]).astype("float32")
+    faiss.normalize_L2(query_embedding_np)
+
+    # Search index
+    distances, indices = index.search(query_embedding_np, top_k)
+    results = []
+    for dist, idx in zip(distances[0], indices[0]):
+        meta = metadata[idx]
+        results.append({
+            "score": float(dist),
+            "source_pdf": meta["source_pdf"],
+            "page": meta["page"],
+            "chunk_index": meta["chunk_index"],
+            "text_snippet": meta["text"]
+        })
+
+    logger.info(f"Query: {query_text}")
+    logger.info(f"Embedding length: {len(query_embedding)}")
+    logger.info(f"Index dimension: {index.d}")
+    logger.info(f"Index contains: {index.ntotal} vectors")
+    logger.info(f"Distances: {distances}")
+    logger.info(f"Indices: {indices}")
+    logger.info(f"Metadata size: {len(metadata)}")
+        
+    return results
+
+def calculate_capacity(cathode_name: str, L_anode: float, L_cathode: float,
+                       M_total: float, t_total: float, C_rate: float):
+    df = df_base.copy()
+    df = df[df["Material_Name"] == cathode_name]
+
+    if df.empty:
+        raise ValueError(f"Cathode '{cathode_name}' not found in dataset.")
+
+    df["C_spec_anode"] = C_SPEC_ANODE
+    df["L_anode"] = L_anode
+    df["L_cathode"] = L_cathode
+
+    # Areal capacities
+    df["Q_anode"] = C_SPEC_ANODE * L_anode / 1000
+    df["Q_cathode"] = df["C_spec_cathode"] * L_cathode / 1000
+    df["Q_full"] = df[["Q_anode", "Q_cathode"]].min(axis=1)
+
+    # Base cell capacities
+    df["Areal_Capacity_cell"] = df["Q_full"]
+    df["Specific_Capacity_cell"] = df["Q_full"] / ((L_anode + L_cathode) / 1000)
+
+    # Nominal voltage
+    df["V_nominal"] = df["V_cathode_mid"] - V_ANODE_MID
+
+    # Energy densities
+    df["Gravimetric_Energy_Density"] = (1000 * df["Q_full"] * df["V_nominal"]) / M_total
+    df["Volumetric_Energy_Density"] = (df["Q_full"] * df["V_nominal"] * 1000) / t_total
+
+    # Voltage window
+    df["V_cell_max"] = df["V_cathode_max"] - V_ANODE_MIN
+    df["V_cell_min"] = df["V_cathode_min"] - V_ANODE_MAX
+    df["Voltage_Window"] = df["V_cell_max"] - df["V_cell_min"]
+
+    # Specific power
+    df["Specific_Power"] = df["Gravimetric_Energy_Density"] * C_rate
+
+    result = {
+        "Cathode": cathode_name,
+        "Anode": "Hard Carbon",
+        "Q_areal": float(df["Q_full"].values[0]),
+        "Q_specific": float(df["Specific_Capacity_cell"].values[0]),
+        "Gravimetric_Energy_Density": float(df["Gravimetric_Energy_Density"].values[0]),
+        "Volumetric_Energy_Density": float(df["Volumetric_Energy_Density"].values[0]),
+        "V_nominal": float(df["V_nominal"].values[0]),
+        "Voltage_Window": float(df["Voltage_Window"].values[0]),
+        "Specific_Power": float(df["Specific_Power"].values[0])
+    }
+
+    query_text = (
+        f"Sodium-ion battery with hard carbon anode and cathode {cathode_name}. "
+    )
+
+    faiss_results = query_faiss_index(query_text, top_k=5)
+
+    try:
+        prompt = f"""
+        Remove the underscores and .pdf from the source_pdf field in the RAG section below and put it as References at the end of the explanation.
+        You are to explain the results of the calculations of a sodium-ion full cell battery using hard carbon and {cathode_name}. You are a RAG system  that takes information only from the RAG section below.
+        And respond with extensive/long explanation in a scientific way and straight to the point without any additional text. Do not include opinions just explanations
+        of the results of the calculations.
+        Lastly shortly analyze the performance of the full cell battery.
+
+        Below are the formulas used to compute key metrics. After reviewing them, interpret the calculated results:
+
+        **Fixed Anode Parameters:**
+        - Specific Capacity of Anode (C_SPEC_ANODE): 300 mAh/g
+        - Voltage Window: 0.01 V to 2.0 V
+        - Plateau Midpoint Voltage (V_ANODE_MID): 0.1 V
+
+        **Formulas Used:**
+
+        1. **Areal Capacity (mAh/cm²):**
+        - Q_anode = C_SPEC_ANODE × L_anode / 1000  
+        - Q_cathode = C_spec_cathode × L_cathode / 1000  
+        - Q_full = min(Q_anode, Q_cathode)
+
+        2. **Specific Capacity (mAh/g):**  
+        - Q_specific = Q_full / ((L_anode + L_cathode) / 1000)
+
+        3. **Nominal Voltage (V):**
+        - V_nominal = V_cathode_mid - V_ANODE_MID
+
+        4. **Gravimetric Energy Density (Wh/kg):**  
+        - GED = 1000 × Q_full × V_nominal / M_total
+
+        5. **Volumetric Energy Density (Wh/L):**  
+        - VED = Q_full × V_nominal × 1000 / t_total
+
+        6. **Voltage Window (V):**  
+        - V_cell_max = V_cathode_max - 0.01  
+        - V_cell_min = V_cathode_min - 2.0  
+        - Voltage_Window = V_cell_max - V_cell_min
+
+        7. **Specific Power (W/kg):**
+        - P = V_nominal × Q_full × 1000 × C_rate / 3600
+
+        **Inputs Provided:**
+        - Cathode material: {cathode_name}
+        - L_anode (mg/cm²): {L_anode}
+        - L_cathode (mg/cm²): {L_cathode}
+        - M_total (mg): {M_total}
+        - t_total (mm): {t_total}
+        - C_rate: {C_rate}
+
+        **Calculated Results:**
+        ```json
+        {result }
+        ```
+        Remove the underscores and .pdf from the source_pdf field in the RAG section below and put it as References at the end of the explanation. Do not include the PDF file name directly in the explanation.
+        At the end of the explanation, list the full source_pdf file names used as references.
+        RAG Section, use only the information from this section to explain the results:
+        {json.dumps(faiss_results, indent=2)}
+        """
+        logger.info("Generated prompt for Gemini model: %s", prompt.strip())
+        gemini_response = model.generate_content(prompt)
+
+        if gemini_response.candidates:
+            parts = gemini_response.candidates[0].content.parts
+            explanation = " ".join(
+                p.text for p in parts if hasattr(p, "text") and p.text
+            )
+        else:
+            explanation = "Gemini returned no candidates."
+
+        result["Gemini_Explanation"] = explanation.strip()
+
+    except Exception as e:
+        result["Gemini_Explanation"] = f"Gemini error: {str(e)}"
+   
+
+    return result

app/logic/calc_b.py

@@ -0,0 +1,206 @@
+import numpy as np
+from typing import Dict, List
+import google.generativeai as genai
+import faiss
+from openai import OpenAI
+import json
+import os
+import pandas as pd
+
+genai.configure(api_key="AIzaSyBwMSL341arzL_FxPzy_DvhDl4Jc46DlaY")
+model = genai.GenerativeModel("gemini-2.5-pro")
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+csv_path = os.path.join(BASE_DIR, "..", "data", "CATHODES_DATASET.csv")
+csv_path = os.path.abspath(csv_path)
+
+df_base = pd.read_csv(csv_path)
+
+def query_faiss_index(query_text, 
+                      faiss_index_path=None,
+                      metadata_path=None,
+                      openai_api_key="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",
+                      top_k=5):
+    client = OpenAI(api_key=openai_api_key)
+
+    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+    if faiss_index_path is None:
+        faiss_index_path = os.path.join(BASE_DIR, "../sentiment/faiss_index.idx")
+    if metadata_path is None:
+        metadata_path = os.path.join(BASE_DIR, "../sentiment/metadata.json")
+
+    # Load index and metadata
+    index = faiss.read_index(faiss_index_path)
+    with open(metadata_path, "r", encoding="utf-8") as f:
+        metadata = json.load(f)
+
+    # Get embedding for query
+    response = client.embeddings.create(
+        input=query_text.lower(),
+        model="text-embedding-3-large"
+    )
+    query_embedding = response.data[0].embedding
+    query_embedding_np = np.array([query_embedding]).astype("float32")
+    faiss.normalize_L2(query_embedding_np)
+
+    # Search index
+    distances, indices = index.search(query_embedding_np, top_k)
+    results = []
+    for dist, idx in zip(distances[0], indices[0]):
+        meta = metadata[idx]
+        results.append({
+            "score": float(dist),
+            "source_pdf": meta["source_pdf"],
+            "page": meta["page"],
+            "chunk_index": meta["chunk_index"],
+            "text_snippet": meta["text"]
+        })
+    return results
+
+def calculate_vq_dqdv(V: List[float], I: float, t: List[float]) -> Dict[str, List[float]]:
+    V_arr = np.array(V, dtype=float)
+    t_arr = np.array(t, dtype=float)
+    Q_arr = I * t_arr
+    dQ = np.gradient(Q_arr)
+    dV = np.gradient(V_arr)
+    with np.errstate(divide='ignore', invalid='ignore'):
+        dQdV = np.where(dV!=0, dQ/dV, 0.0)
+    return {"Q": Q_arr.tolist(), "V": V_arr.tolist(), "dQdV": dQdV.tolist()}
+
+def calculate_rate_capability(
+    Q_nominal: float,
+    C_rates: List[float],
+    t_discharge: List[float]
+) -> Dict[str, List[float]]:
+    # Convert to arrays
+    C = np.array(C_rates, dtype=float)
+    t = np.array(t_discharge, dtype=float)
+
+    # Validation
+    if C.shape != t.shape:
+        raise ValueError("C_rates and t_discharge must have same length")
+
+    # Q_Ci = C_i * Q_nominal * t_i
+    Q_ci = C * Q_nominal * t
+    return {"C_rates": C.tolist(), "Q_Ci": Q_ci.tolist()}
+
+
+def calculate_cccv_time(
+    Q_nominal: float,
+    I_lim: float,
+    alpha: float,
+    I_end: float,
+    tau: float
+) -> float:
+    """
+    t_charge = t_CC + t_CV
+             = (alpha * Q_nominal)/I_lim + tau * ln(I_lim/I_end)
+    """
+    # CC time:
+    t_CC = (alpha * Q_nominal) / I_lim
+    # CV time:
+    t_CV = tau * np.log(I_lim / I_end)
+    return float(t_CC + t_CV)
+
+def calculate_diffusion(
+    L: float,
+    tau_pulse: float,
+    delta_E_tau: List[float],
+    delta_E_s: List[float]
+) -> Dict[str, List[float]]:
+    """
+    D_i = (π/4) * (L^2 / τ_pulse) * (ΔEτ_i / ΔEs_i)^2
+    """
+    Δτ = np.array(delta_E_tau, dtype=float)
+    Δs = np.array(delta_E_s, dtype=float)
+    # avoid divide‑by‑zero
+    ratio2 = np.where(Δs != 0, (Δτ / Δs)**2, 0.0)
+    D = (np.pi / 4) * (L**2 / tau_pulse) * ratio2
+    return {"D": D.tolist()}
+
+def calculate_all_b(cathode_name: str, input_data: Dict) -> Dict:
+    # 1) V–Q & dQ/dV
+    vq = calculate_vq_dqdv(
+        V=input_data["V"],
+        I=input_data["I"],
+        t=input_data["t"]
+    )
+
+    # 2) Rate capability
+    rate = calculate_rate_capability(
+        input_data["Q_nominal"],
+        input_data["C_rates"],
+        input_data["t_discharge"]
+    )
+
+    # 3) CC–CV charge time
+    t_charge = calculate_cccv_time(
+        Q_nominal = input_data["Q_nominal_mAh"],
+        I_lim     = input_data["I_lim"],
+        alpha     = input_data["alpha"],
+        I_end     = input_data["I_end"],
+        tau       = input_data["tau"]
+    )
+
+    diffusion = calculate_diffusion(
+        L           = input_data["L"],
+        tau_pulse   = input_data["tau_pulse"],
+        delta_E_tau = input_data["delta_E_tau"],
+        delta_E_s   = input_data["delta_E_s"]
+    )
+
+    query_text = (
+        f"Sodium-ion battery with hard carbon anode and cathode {cathode_name}. "
+    )
+
+    faiss_results = query_faiss_index(query_text, top_k=5)
+
+    prompt = f"""
+        Remove the underscores and .pdf from the source_pdf field in the RAG section below and put it as References at the end of the explanation.
+        You are to explain the results of the calculations of a sodium-ion full cell battery using hard carbon and {cathode_name}. You are a RAG system  that takes information only from the RAG section below.
+        And respond with extensive/long explanation in a scientific way and straight to the point without any additional text. Do not include opinions just explanations
+        of the results of the calculations.
+        Lastly shortly analyze the performance of the full cell battery.
+
+        1. **V–Q curve**: {vq['Q']} vs {vq['V']}
+        2. **dQ/dV curve**: {vq['dQdV']}
+        3. **Rate capability test**:
+            - C-rates: {rate['C_rates']}
+            - Discharge capacities: {rate['Q_Ci']}
+        4. **CC–CV charging time**: {t_charge:.2f} seconds
+        5. **Diffusion coefficients** (D): {diffusion['D']}
+
+        Please comment on:
+        - Whether the electrode is rate-limited
+        - Diffusion characteristics
+        - Fast-charging behavior
+        - Any obvious limitations or strengths
+
+        Remove the underscores and .pdf from the source_pdf field in the RAG section below and put it as References at the end of the explanation. Do not include the PDF file name directly in the explanation.
+        At the end of the explanation, list the full source_pdf file names used as references.
+        RAG Section, use only the information from this section to explain the results:
+        {json.dumps(faiss_results, indent=2)}
+            """
+
+    try:
+        gemini_response = model.generate_content(prompt)
+    
+        if gemini_response.candidates:
+            parts = gemini_response.candidates[0].content.parts
+            gemini_text = " ".join(
+                p.text for p in parts if hasattr(p, "text") and p.text
+            )
+        else:
+            gemini_text = "Gemini returned no candidates."
+    
+    except Exception as e:
+        gemini_text = f"Gemini analysis failed: {str(e)}"
+
+    return {
+      "vq_curve":        vq,
+      "rate_capability": rate,
+      "cccv_time_s":     t_charge,
+      "diffusion_D":     diffusion["D"],
+      "Gemini_Explanation": gemini_text
+    }

app/logic/calc_c.py

@@ -0,0 +1,272 @@
+import numpy as np
+import scipy
+from scipy.signal import savgol_filter
+from typing import Dict, List
+import matplotlib.pyplot as plt
+import io
+import base64
+import google.generativeai as genai
+import faiss
+from openai import OpenAI
+import json
+import os
+import pandas as pd
+
+genai.configure(api_key="AIzaSyBwMSL341arzL_FxPzy_DvhDl4Jc46DlaY")
+model = genai.GenerativeModel("gemini-2.5-flash")
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+csv_path = os.path.join(BASE_DIR, "..", "data", "CATHODES_DATASET.csv")
+csv_path = os.path.abspath(csv_path)
+
+df_base = pd.read_csv(csv_path)
+
+def query_faiss_index(query_text, 
+                      faiss_index_path=None,
+                      metadata_path=None,
+                      openai_api_key="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",
+                      top_k=5):
+    client = OpenAI(api_key=openai_api_key)
+
+    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+    if faiss_index_path is None:
+        faiss_index_path = os.path.join(BASE_DIR, "../sentiment/faiss_index.idx")
+    if metadata_path is None:
+        metadata_path = os.path.join(BASE_DIR, "../sentiment/metadata.json")
+
+    # Load index and metadata
+    index = faiss.read_index(faiss_index_path)
+    with open(metadata_path, "r", encoding="utf-8") as f:
+        metadata = json.load(f)
+
+    # Get embedding for query
+    response = client.embeddings.create(
+        input=query_text.lower(),
+        model="text-embedding-3-large"
+    )
+    query_embedding = response.data[0].embedding
+    query_embedding_np = np.array([query_embedding]).astype("float32")
+    faiss.normalize_L2(query_embedding_np)
+
+    # Search index
+    distances, indices = index.search(query_embedding_np, top_k)
+    results = []
+    for dist, idx in zip(distances[0], indices[0]):
+        meta = metadata[idx]
+        results.append({
+            "score": float(dist),
+            "source_pdf": meta["source_pdf"],
+            "page": meta["page"],
+            "chunk_index": meta["chunk_index"],
+            "text_snippet": meta["text"]
+        })
+    return results
+
+
+def calculate_cv(input_data: Dict) -> Dict:
+    V_start = input_data["V_start"]
+    V_switch = input_data["V_switch"]
+    scan_rate = input_data["scan_rate"]
+    dt = input_data["dt"]
+    sigma = input_data["sigma"]
+    E0 = input_data["E0"]
+    Ip = input_data["Ip"]
+
+    # --- Time & Voltage Arrays ---
+    t_up = np.arange(0, (V_switch - V_start) / scan_rate, dt)
+    t_down = np.arange(0, (V_switch - V_start) / scan_rate, dt)
+    V_up = V_start + scan_rate * t_up
+    V_down = V_switch - scan_rate * t_down
+    V = np.concatenate([V_up, V_down])
+
+    # --- Simulated CV current ---
+    I_ox = Ip * np.exp(-((V - E0) ** 2) / (2 * sigma ** 2))
+    I_red = -Ip * np.exp(-((V - (E0 - 0.06)) ** 2) / (2 * sigma ** 2))
+    I = I_ox + I_red
+
+    # --- Peak Analysis ---
+    idx_ox = np.argmax(I)
+    idx_red = np.argmin(I)
+    V_ox = float(V[idx_ox])
+    V_red = float(V[idx_red])
+    delta_V_peak = V_ox - V_red
+
+    # --- Integrated Charge (Coulombs) ---
+    # ∫ I dt = ∫ I dV × (1/scan_rate)  ⇒ simps(I, V) / scan_rate
+    Q = float(scipy.integrate.simpson(I, V) / scan_rate)
+
+    return {
+        "t": np.concatenate([t_up, t_down]).tolist(),
+        "V": V.tolist(),
+        "I": I.tolist(),
+        "V_ox": V_ox,
+        "V_red": V_red,
+        "delta_V_peak": delta_V_peak,
+        "Q_integrated": Q
+    }
+
+def calculate_eis(data: Dict) -> Dict:
+    freqs = np.array(data["frequencies"], dtype=float)
+    Rs, Rct, Cdl, sigma_w = data["Rs"], data["Rct"], data["Cdl"], data["sigma_w"]
+    omega = 2*np.pi*freqs
+    j     = 1j
+
+    # Warburg impedance
+    Zw = sigma_w*(1 - j)/np.sqrt(omega)
+
+    # Admittances
+    Y_Rct = 1/Rct
+    Y_Cdl = j * omega * Cdl
+    Y_W   = 1/Zw
+
+    Y_par     = Y_Rct + Y_Cdl + Y_W
+    Z_parallel= 1/Y_par
+    Z_total   = Rs + Z_parallel
+
+    # Return real & imag parts separately
+    return {
+        "frequencies": freqs.tolist(),
+        "Z_real":      np.real(Z_total).tolist(),
+        "Z_imag":      np.imag(Z_total).tolist()
+    }
+
+def compute_d2QdV2(
+    V: List[float],
+    Q: List[float],
+    window: int = 21,
+    poly: int = 3
+) -> Dict[str, List[float]]:
+    V = np.array(V, dtype=float)
+    Q = np.array(Q, dtype=float)
+
+    # Ensure monotonic V
+    if not np.all(np.diff(V) > 0):
+        idx = np.argsort(V)
+        V = V[idx]
+        Q = Q[idx]
+
+    # Smooth and differentiate
+    Qs = savgol_filter(Q, window_length=window, polyorder=poly)
+    dQdV   = np.gradient(Qs, V)
+    d2QdV2 = np.gradient(dQdV, V)
+
+    return {"dQdV": dQdV.tolist(), "d2QdV2": d2QdV2.tolist()}
+
+def plot_cv(V, I):
+    fig, ax = plt.subplots()
+    ax.plot(V, I, color='blue')
+    ax.set_title("Cyclic Voltammetry")
+    ax.set_xlabel("Voltage (V)")
+    ax.set_ylabel("Current (A)")
+    ax.grid(True)
+    return fig_to_base64(fig)
+
+def plot_eis(Z_real, Z_imag):
+    fig, ax = plt.subplots()
+    ax.plot(Z_real, -np.array(Z_imag), 'o-', color='green')
+    ax.set_title("Nyquist Plot (EIS)")
+    ax.set_xlabel("Z' (Ω)")
+    ax.set_ylabel("-Z'' (Ω)")
+    ax.grid(True)
+    return fig_to_base64(fig)
+
+def plot_dqdv(V, dQdV, d2QdV2):
+    fig, ax = plt.subplots()
+    ax.plot(V, dQdV, label="dQ/dV", color='orange')
+    ax.plot(V, d2QdV2, label="d²Q/dV²", color='red')
+    ax.set_title("Q–V Derivatives")
+    ax.set_xlabel("Voltage (V)")
+    ax.set_ylabel("Derivative")
+    ax.legend()
+    ax.grid(True)
+    return fig_to_base64(fig)
+
+def fig_to_base64(fig):
+    buf = io.BytesIO()
+    fig.savefig(buf, format="png", bbox_inches="tight")
+    buf.seek(0)
+    img_base64 = base64.b64encode(buf.read()).decode("utf-8")
+    plt.close(fig)
+    return img_base64
+
+def image_to_part(base64_str: str) -> dict:
+    return {
+        "inline_data": {
+            "mime_type": "image/png",
+            "data": base64_str
+        }
+    }
+
+def analyze_plots_with_gemini(cv_img: str, eis_img: str, qv_img: str, cathode_name: str, faiss_results: list) -> str:
+    prompt = (
+        f"""Remove the underscores and .pdf from the source_pdf field in the RAG section below and put it as References at the end of the explanation.
+        You are to explain the results of the calculations of a sodium-ion full cell battery using hard carbon and {cathode_name}. You are a RAG system  that takes information only from the RAG section below.
+        And respond with extensive/long explanation in a scientific way and straight to the point without any additional text. Do not include opinions just explanations
+        of the results of the calculations.
+        Lastly shortly analyze the performance of the full cell battery.
+
+        These are three plots from sodium-ion battery electrochemical analysis.
+        Please summarize the main features observed in:
+        1. Cyclic Voltammetry (CV)
+        2. Electrochemical Impedance Spectroscopy (EIS)
+        3. Q–V and d²Q/dV² analysis
+        Include observations on redox peaks, charge transfer resistance, and plateau features.
+        
+        Remove the underscores and .pdf from the source_pdf field in the RAG section below and put it as References at the end of the explanation. Do not include the PDF file name directly in the explanation.
+        At the end of the explanation, list the full source_pdf file names used as references.
+        RAG Section, use only the information from this section to explain the results:
+        {json.dumps(faiss_results, indent=2)}"""
+    )
+
+    try:
+        response = model.generate_content([
+            prompt,
+            image_to_part(cv_img),
+            image_to_part(eis_img),
+            image_to_part(qv_img),
+        ])
+
+        if response.candidates:
+            parts = response.candidates[0].content.parts
+            text_output = " ".join(
+                p.text for p in parts if hasattr(p, "text") and p.text
+            )
+            return text_output.strip()
+        else:
+            return "Gemini returned no candidates."
+
+    except Exception as e:
+        return f"Error from Gemini API: {e}"
+
+def calculate_all_c(cathode_name: str, input_data: Dict) -> Dict:
+
+    query_text = (
+        f"Sodium-ion battery with hard carbon anode and cathode {cathode_name}. "
+    )
+
+    faiss_results = query_faiss_index(query_text, top_k=5)
+
+    cv  = calculate_cv(input_data)
+    eis = calculate_eis(input_data)
+    deriv = compute_d2QdV2(
+        V      = input_data["V_qv"],
+        Q      = input_data["Q_qv"],
+        window = input_data["window"],
+        poly   = input_data["poly"]
+    )
+
+    cv_plot  = plot_cv(cv["V"], cv["I"])
+    eis_plot = plot_eis(eis["Z_real"], eis["Z_imag"])
+    qv_plot  = plot_dqdv(input_data["V_qv"], deriv["dQdV"], deriv["d2QdV2"])
+
+    summary = analyze_plots_with_gemini(cv_plot, eis_plot, qv_plot, cathode_name, faiss_results)
+
+    return {
+        "plots": {
+            "cv_plot":  cv_plot,
+            "eis_plot": eis_plot,
+            "qv_plot":  qv_plot,
+        },
+        "Gemini_Explanation": summary
+    }

app/logic/calc_d.py

@@ -0,0 +1,220 @@
+from typing import Dict, Tuple
+import google.generativeai as genai
+import json
+import faiss
+from openai import OpenAI
+import numpy as np
+import os
+import pandas as pd
+
+genai.configure(api_key="AIzaSyBwMSL341arzL_FxPzy_DvhDl4Jc46DlaY")
+model = genai.GenerativeModel("gemini-2.5-pro")
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+csv_path = os.path.join(BASE_DIR, "..", "data", "CATHODES_DATASET.csv")
+csv_path = os.path.abspath(csv_path)
+
+# Load cathode dataset once (adjust path if needed)
+df_base = pd.read_csv(csv_path)
+
+def query_faiss_index(query_text, 
+                      faiss_index_path=None,
+                      metadata_path=None,
+                      openai_api_key="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",
+                      top_k=5):
+    client = OpenAI(api_key=openai_api_key)
+
+    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+    if faiss_index_path is None:
+        faiss_index_path = os.path.join(BASE_DIR, "../sentiment/faiss_index.idx")
+    if metadata_path is None:
+        metadata_path = os.path.join(BASE_DIR, "../sentiment/metadata.json")
+
+                        
+    # Load index and metadata
+    index = faiss.read_index(faiss_index_path)
+    with open(metadata_path, "r", encoding="utf-8") as f:
+        metadata = json.load(f)
+
+    # Get embedding for query
+    response = client.embeddings.create(
+        input=query_text.lower(),
+        model="text-embedding-3-large"
+    )
+    query_embedding = response.data[0].embedding
+    query_embedding_np = np.array([query_embedding]).astype("float32")
+    faiss.normalize_L2(query_embedding_np)
+
+    # Search index
+    distances, indices = index.search(query_embedding_np, top_k)
+    results = []
+    for dist, idx in zip(distances[0], indices[0]):
+        meta = metadata[idx]
+        results.append({
+            "score": float(dist),
+            "source_pdf": meta["source_pdf"],
+            "page": meta["page"],
+            "chunk_index": meta["chunk_index"],
+            "text_snippet": meta["text"]
+        })
+    return results
+
+def calculate_np_ratio(
+    Q_anode_raw: float,
+    m_anode: float,
+    SEI_loss_fraction: float,
+    Q_cathode_raw: float,
+    m_cathode: float,
+    vacancy_loss_fraction: float
+) -> float:
+    """
+    N/P = (Q_anode_raw * m_anode * (1 - SEI_loss)) /
+          (Q_cathode_raw * m_cathode * (1 - vacancy_loss))
+    """
+    Q_anode_usable = Q_anode_raw * m_anode * (1 - SEI_loss_fraction)
+    Q_cathode_usable = Q_cathode_raw * m_cathode * (1 - vacancy_loss_fraction)
+    return Q_anode_usable / Q_cathode_usable
+
+def recommended_mass_loading_areal(
+    Q_areal: float,
+    Q_anode: float,
+    Q_cathode: float,
+    NP_ratio: float
+) -> Tuple[float, float]:
+    """
+    Returns (m_cathode_mg_cm2, m_anode_mg_cm2)
+    """
+    m_cathode = Q_areal / Q_cathode
+    m_anode   = (Q_areal / Q_anode) * NP_ratio
+    # convert g/cm² → mg/cm²
+    return m_cathode * 1000, m_anode * 1000
+
+def calculate_first_cycle_ce(
+    Q_charge_anode: float,
+    Q_discharge_anode: float,
+    Q_charge_cathode: float,
+    Q_discharge_cathode: float,
+    Q_charge_full: float,
+    Q_discharge_full: float
+) -> Dict[str, float]:
+    ce_anode  = (Q_discharge_anode / Q_charge_anode) * 100
+    ce_cathode= (Q_discharge_cathode / Q_charge_cathode) * 100
+    ce_full   = (Q_discharge_full    / Q_charge_full)    * 100
+    return {
+        "CE_anode (%)": ce_anode,
+        "CE_cathode (%)": ce_cathode,
+        "CE_full_cell (%)": ce_full
+    }
+
+def estimate_irreversible_na_loss(
+    Q_charge_full: float,
+    Q_discharge_full: float
+) -> float:
+    """
+    Irreversible Na⁺ loss per gram (mAh/g) on first cycle
+    """
+    return Q_charge_full - Q_discharge_full
+
+def generate_gemini_insight(input_data: Dict, results: Dict, faiss_results: list, cathode_name: str) -> str:
+    prompt = f"""Remove the underscores and .pdf from the source_pdf field in the RAG section below and put it as References at the end of the explanation.
+    You are to explain the results of the calculations of a sodium-ion full cell battery using hard carbon and {cathode_name}. You are a RAG system that takes information only from the RAG section below.
+    Respond with an EXTENSIVE/LONG EXPLANATIONS, scientific, and straight-to-the-point explanation without any additional opinions, explaining only the results of the calculations.
+    Lastly, briefly analyze the performance of the full cell battery.
+    
+    ### Input Data:
+    {json.dumps(input_data, indent=2)}
+    
+    ### Calculated Results:
+    {json.dumps(results, indent=2)}
+    
+    ### Formulas Used:
+        - N/P Ratio = (Q_anode_raw × m_anode × (1 − SEI_loss_fraction)) ÷ (Q_cathode_raw × m_cathode × (1 − vacancy_loss_fraction))\n"
+        - Mass Loading Areal (mg/cm²):\n"
+            - m_cathode = Q_areal ÷ Q_cathode
+            - m_anode = (Q_areal ÷ Q_anode) × N/P Ratio
+        - First Cycle Coulombic Efficiency (CE):
+            - CE_anode = (Q_discharge_anode ÷ Q_charge_anode) × 100
+            - CE_cathode = (Q_discharge_cathode ÷ Q_charge_cathode) × 100
+            - CE_full = (Q_discharge_full ÷ Q_charge_full) × 100
+        - Irreversible Na⁺ Loss = Q_charge_full − Q_discharge_full
+    
+    Remove the underscores and .pdf from the source_pdf field in the RAG section below and put it as References at the end of the explanation.
+    Do not include the PDF file name directly in the explanation.
+    At the end of the explanation, list the full source_pdf file names used as references.
+    
+    RAG Section, use only the information from this section to explain the results:
+    {json.dumps(faiss_results, indent=2)}
+    """
+    try:
+        response = model.generate_content(prompt)
+
+        if response.candidates:
+            parts = response.candidates[0].content.parts
+            text_output = " ".join(
+                p.text for p in parts if hasattr(p, "text") and p.text
+            )
+            return text_output.strip()
+        else:
+            return "Gemini returned no candidates."
+
+    except Exception as e:
+        return f"Gemini Error: {str(e)}"
+
+def calculate_all_d(cathode_name: str, input_data: Dict) -> Dict:
+    # 1) N/P ratio
+    np_ratio = calculate_np_ratio(
+        Q_anode_raw = input_data["Q_anode_raw"],
+        m_anode = input_data["m_anode"],
+        SEI_loss_fraction = input_data["SEI_loss_fraction"],
+        Q_cathode_raw = input_data["Q_cathode_raw"],
+        m_cathode = input_data["m_cathode"],
+        vacancy_loss_fraction = input_data["vacancy_loss_fraction"]
+    )
+
+    # 2) Recommended mass loading
+    m_cathode_mg_cm2, m_anode_mg_cm2 = recommended_mass_loading_areal(
+        Q_areal = input_data["Q_areal"],
+        Q_anode = input_data["Q_anode_raw"],
+        Q_cathode = input_data["Q_cathode_raw"],
+        NP_ratio = np_ratio
+    )
+
+    # 3) First‑cycle CE
+    ce = calculate_first_cycle_ce(
+        Q_charge_anode = input_data["Q_charge_anode"],
+        Q_discharge_anode = input_data["Q_discharge_anode"],
+        Q_charge_cathode = input_data["Q_charge_cathode"],
+        Q_discharge_cathode = input_data["Q_discharge_cathode"],
+        Q_charge_full = input_data["Q_charge_full"],
+        Q_discharge_full = input_data["Q_discharge_full"]
+    )
+
+    # 4) Irreversible Na⁺ loss
+    ir_loss = estimate_irreversible_na_loss(
+        Q_charge_full = input_data["Q_charge_full"],
+        Q_discharge_full = input_data["Q_discharge_full"]
+    )
+
+
+    results = {
+        "NP_ratio": np_ratio,
+        "m_cathode_mg_per_cm2": m_cathode_mg_cm2,
+        "m_anode_mg_per_cm2": m_anode_mg_cm2,
+        **ce,
+        "Irreversible_Na_loss (mAh/g)": ir_loss
+    }
+
+    query_text = (
+        f"Sodium-ion battery with hard carbon anode and cathode {cathode_name}. "
+    )
+
+    faiss_results = query_faiss_index(query_text, top_k=5)
+
+    # 5) Generate Gemini insight
+    gemini_summary = generate_gemini_insight(input_data, results, faiss_results, cathode_name)
+
+    return {
+        "results": results,
+        "Gemini_Explanation": gemini_summary
+    }

app/logic/calc_e.py

@@ -0,0 +1,236 @@
+import matplotlib.pyplot as plt
+import io
+import base64
+from typing import Dict, List
+import math
+import google.generativeai as genai
+import json
+import faiss
+from openai import OpenAI
+import numpy as np
+import os
+import pandas as pd
+
+genai.configure(api_key="AIzaSyBwMSL341arzL_FxPzy_DvhDl4Jc46DlaY")
+model = genai.GenerativeModel("gemini-2.5-pro")
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+csv_path = os.path.join(BASE_DIR, "..", "data", "CATHODES_DATASET.csv")
+csv_path = os.path.abspath(csv_path)
+
+# Load cathode dataset once (adjust path if needed)
+df_base = pd.read_csv(csv_path)
+
+def query_faiss_index(query_text, 
+                      faiss_index_path=None,
+                      metadata_path=None,
+                      openai_api_key="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",
+                      top_k=5):
+    client = OpenAI(api_key=openai_api_key)
+
+    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+    if faiss_index_path is None:
+        faiss_index_path = os.path.join(BASE_DIR, "../sentiment/faiss_index.idx")
+    if metadata_path is None:
+        metadata_path = os.path.join(BASE_DIR, "../sentiment/metadata.json")
+      
+                        # Load index and metadata
+    index = faiss.read_index(faiss_index_path)
+    with open(metadata_path, "r", encoding="utf-8") as f:
+        metadata = json.load(f)
+
+    # Get embedding for query
+    response = client.embeddings.create(
+        input=query_text.lower(),
+        model="text-embedding-3-large"
+    )
+    query_embedding = response.data[0].embedding
+    query_embedding_np = np.array([query_embedding]).astype("float32")
+    faiss.normalize_L2(query_embedding_np)
+
+    # Search index
+    distances, indices = index.search(query_embedding_np, top_k)
+    results = []
+    for dist, idx in zip(distances[0], indices[0]):
+        meta = metadata[idx]
+        results.append({
+            "score": float(dist),
+            "source_pdf": meta["source_pdf"],
+            "page": meta["page"],
+            "chunk_index": meta["chunk_index"],
+            "text_snippet": meta["text"]
+        })
+    return results
+
+def plot_capacity_fade(cycle_numbers: List[int], Q_discharge_list: List[float]) -> str:
+    # Creates a capacity‐fade plot and returns it as a base64‐encoded PNG.
+    plt.figure(figsize=(8, 5))
+    plt.plot(cycle_numbers, Q_discharge_list, marker='o', linestyle='-')
+    plt.title("Capacity-Fade Trajectory")
+    plt.xlabel("Cycle Number")
+    plt.ylabel("Discharge Capacity (mAh/g)")
+    plt.grid(True)
+    plt.tight_layout()
+
+    # Save figure to a PNG in memory
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    plt.close()
+    buf.seek(0)
+
+    # Encode PNG to base64 for JSON transport
+    img_b64 = base64.b64encode(buf.read()).decode('utf-8')
+    return img_b64
+
+def plot_impedance_growth(
+    cycle_numbers: List[int],
+    impedance_list: List[float],
+    parameter_name: str = "Rct"
+) -> str:
+    # Creates impedance growth plot and returns a base64-encoded PNG.
+
+    plt.figure(figsize=(8, 5))
+    plt.plot(cycle_numbers, impedance_list, marker='s', linestyle='-', color='darkred')
+    plt.title(f"Impedance Growth Trajectory: {parameter_name} vs Cycle")
+    plt.xlabel("Cycle Number")
+    plt.ylabel(f"{parameter_name} (Ω)")
+    plt.grid(True)
+    plt.tight_layout()
+
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    plt.close()
+    buf.seek(0)
+
+    return base64.b64encode(buf.read()).decode('utf-8')
+
+def calculate_calendar_ageing(input_data: Dict) -> Dict:
+    T_C = input_data["temperature_C"]
+    SOC = input_data["SOC_fraction"]
+    t_hours = input_data["storage_time_hours"]
+    Q0 = input_data["initial_capacity_mAh"]
+
+    # Empirical constants
+    k = 1e-7
+    n = 0.6
+    Ea = 40000  # J/mol
+    R = 8.314  # J/mol·K
+
+    T_K = T_C + 273.15
+    arrh = math.exp(-Ea / (R * T_K))
+
+    delta_Q = Q0 * k * (t_hours ** n) * arrh * (1 + 2 * (SOC - 0.5) ** 2)
+    frac = delta_Q / Q0
+
+    return {"delta_Q_mAh": delta_Q, "fractional_capacity_loss": frac}
+
+def estimate_cycle_life_80(k: float, b: float) -> float:
+    if k <= 0 or b <= 0:
+        raise ValueError("k and b must be positive")
+    return (0.2 / k) ** (1 / b)
+
+def image_to_part(base64_str: str) -> dict:
+    return {
+        "inline_data": {
+            "mime_type": "image/png",
+            "data": base64_str
+        }
+    }
+
+def extract_gemini_text(response) -> str:
+    if not response.candidates:
+        return "Gemini returned no candidates."
+    parts = response.candidates[0].content.parts
+    texts = []
+    for p in parts:
+        if hasattr(p, "text"):
+            if isinstance(p.text, str):
+                texts.append(p.text)
+            elif hasattr(p.text, "text"):
+                texts.append(p.text.text)
+    return " ".join(texts).strip()
+
+def analyze_ageing_with_gemini(
+    input_data: Dict,
+    results: Dict,
+    fade_img_b64: str,
+    imp_img_b64: str,
+    cathode_name: str,
+    faiss_results: List[Dict]
+) -> str:
+    prompt = prompt = f"""
+    Remove the underscores and .pdf from the source_pdf field in the RAG section below and put it as References at the end of the explanation.
+    You are to explain the results of the calculations of a sodium-ion full cell battery using hard carbon and {cathode_name}. You are a RAG system that takes information only from the RAG section below.
+    Respond with extensive/long explanation in a scientific way and straight to the point without any additional text. Do not include opinions, just explanations of the results.
+    
+    Lastly, briefly analyze the performance of the full cell battery.
+    Explain the results and plots provided, sticking strictly to scientific explanation.
+    Focus on capacity fade, impedance growth, calendar ageing, and cycle life estimation.
+    
+    ### Input Data and Numeric Results:
+    {json.dumps({'input_data': input_data, 'results': results}, indent=2)}
+    
+    ### Plots:
+    1. Capacity-Fade Trajectory
+    2. Impedance Growth Trajectory
+    
+    Remove the underscores and .pdf from the source_pdf field in the RAG section below and put it as References at the end of the explanation.
+    Do not include the PDF file name directly in the explanation.
+    At the end of the explanation, list the full source_pdf file names used as references.
+    
+    RAG Section (use only this information to explain the results):
+    {json.dumps(faiss_results, indent=2)}
+    """
+
+    response = model.generate_content([
+        prompt,
+        image_to_part(fade_img_b64),
+        image_to_part(imp_img_b64),
+    ])
+
+    return extract_gemini_text(response)
+
+def calculate_all_e(cathode_name: str, input_data: Dict) -> Dict:
+    # Simply produce the plot
+    fade_img = plot_capacity_fade(
+        cycle_numbers   = input_data["cycle_numbers"],
+        Q_discharge_list= input_data["Q_discharge_list"]
+    )
+    # Impedance growth plot
+    imp_img = plot_impedance_growth(
+        cycle_numbers = input_data["cycle_numbers_imp"],
+        impedance_list= input_data["impedance_list"],
+        parameter_name= input_data.get("parameter_name", "Rct")
+    )
+    cal = calculate_calendar_ageing(input_data)
+    N80 = estimate_cycle_life_80(
+        k=input_data["k_fade"],
+        b=input_data["b_fade"]
+    )
+    results = {
+        "delta_Q_mAh": cal["delta_Q_mAh"],
+        "fractional_capacity_loss": cal["fractional_capacity_loss"],
+        "cycle_life_80": N80
+    }
+
+    query_text = (
+        f"Sodium-ion battery with hard carbon anode and cathode {cathode_name}. "
+    )
+
+    faiss_results = query_faiss_index(query_text, top_k=5)
+
+    gemini_summary = analyze_ageing_with_gemini(
+        input_data=input_data,
+        results=results,
+        fade_img_b64=fade_img,
+        imp_img_b64=imp_img,
+        cathode_name=cathode_name,
+        faiss_results=faiss_results
+    )
+    return {
+        **results,
+        "capacity_fade_png": fade_img,
+        "impedance_growth_png": imp_img,
+        "Gemini_Explanation": gemini_summary
+    }

app/main.py

@@ -0,0 +1,24 @@
+from fastapi import FastAPI
+from .routes import route_a
+from .routes import route_b
+from .routes import route_c
+from .routes import route_d
+from .routes import route_e
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI(title="Battery Simulation API", version="1.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Register each route group
+app.include_router(route_a.router, tags=["Core Steady-State Cell Specs (A)"])
+app.include_router(route_b.router, prefix="/b", tags=["B: Dynamic performance curves"])
+app.include_router(route_c.router, prefix="/c", tags=["C: Electrochemical signatures"])
+app.include_router(route_d.router, prefix="/d", tags=["D: Balancing & first-cycle losses"])
+app.include_router(route_e.router, prefix="/e", tags=["E: Ageing & durability forecasts"])

app/models/model_a.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+class MassLoadingInput(BaseModel):
+    cathode_name: str   # Default value for cathode name
+    L_anode: float      # g/cm²
+    L_cathode: float    # g/cm²
+    M_total: float      # g
+    t_total: float      # cm
+    C_rate: float

app/models/model_b.py

@@ -0,0 +1,29 @@
+from typing import List
+from pydantic import BaseModel, Field
+
+class AllBInput(BaseModel):
+    cathode_name: str
+    # ─── V–Q & dQ/dV inputs ───────────────────────────────────────
+    V: List[float] = Field(..., description="Measured voltage at each time step (V)")
+    I: float       = Field(..., description="Applied current (mA/g)")
+    t: List[float] = Field(..., description="Time array matching V (h or s)")
+
+    # ─── Rate capability inputs ───────────────────────────────────
+    Q_nominal: float = Field(..., description="Nominal low‑rate capacity (mAh/g)") 
+    C_rates: List[float] = Field(..., description="List of C‑rates (e.g. [0.1,0.5,1,2,5])")
+    t_discharge: List[float] = Field(..., description="Discharge times at each C‑rate (hours)")
+
+    # ─── CC–CV charge time inputs ────────────────────────────────
+    Q_nominal_mAh: float = Field(..., description="Nominal cell capacity (mAh or Ah)")
+    I_lim: float = Field(..., description="Constant current limit during CC (A or mA)")
+    alpha: float = Field(..., description="Fraction of total capacity charged at CC (0.0–1.0)")
+    I_end: float = Field(..., description="End‐of‐charge current for CV termination (A or mA)")
+    tau: float = Field(..., description="Time constant for CV current decay (seconds)")
+
+    # ─── GITT‑style diffusion inputs ───────────────────────────────
+    L:               float       = Field(..., description="Diffusion length (cm)")
+    tau_pulse:       float       = Field(..., description="Pulse duration τ (s)")
+    delta_E_tau:     List[float] = Field(..., description="Voltage change during pulse ΔEτ (V)")
+    delta_E_s:       List[float] = Field(..., description="Steady‑state voltage change ΔEs (V)")
+
+

app/models/model_c.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel, Field
+from typing import List
+
+class CVInput(BaseModel):
+    cathode_name: str
+    V_start:   float = Field(..., description="Starting voltage (V)")
+    V_switch:  float = Field(..., description="Switch voltage (V)")
+    scan_rate: float = Field(..., description="Sweep rate (V/s)")
+    dt:        float = Field(..., description="Time step (s)")
+    sigma:     float = Field(..., description="Gaussian peak width (V)")
+    E0:        float = Field(..., description="Redox mid‑potential (V)")
+    Ip:        float = Field(..., description="Peak current magnitude (A)")
+
+    # EIS inputs
+    frequencies: List[float] = Field(..., description="Frequencies (Hz)")
+    Rs:          float       = Field(..., description="Solution resistance (Ohm)")
+    Rct:         float       = Field(..., description="Charge‐transfer resistance (Ohm)")
+    Cdl:         float       = Field(..., description="Double‐layer capacitance (F)")
+    sigma_w:     float       = Field(..., description="Warburg coefficient (Ω·s^(-1/2))")
+
+    # Q–V derivative inputs
+    V_qv:       List[float] = Field(..., description="Voltage array for Q–V curve (monotonic)")
+    Q_qv:       List[float] = Field(..., description="Capacity array aligned with V_qv")
+    window:     int         = Field(21,    description="Savitzky–Golay window length (odd)")
+    poly:       int         = Field(3,     description="Savitzky–Golay polynomial order")
+
+    

app/models/model_d.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel, Field
+
+class NPCalcInput(BaseModel):
+    cathode_name: str
+    Q_anode_raw: float = Field(..., description="Specific capacity of anode (mAh/g)")
+    m_anode: float = Field(..., description="Anode active mass (g or mg/cm²)")
+    SEI_loss_fraction: float = Field(..., description="Fractional SEI loss (e.g. 0.1 for 10%)")
+    Q_cathode_raw: float = Field(..., description="Specific capacity of cathode (mAh/g)")
+    m_cathode: float = Field(..., description="Cathode active mass (g or mg/cm²)")
+    vacancy_loss_fraction: float = Field(..., description="Fractional vacancy loss in cathode")
+
+    # recommended loading
+    Q_areal: float = Field(..., description="Target full‑cell areal capacity (mAh/cm²)")
+
+    # — new CE inputs —
+    Q_charge_anode: float = Field(..., description="Anode charge capacity (mAh)")
+    Q_discharge_anode: float = Field(..., description="Anode discharge capacity (mAh)")
+    Q_charge_cathode: float = Field(..., description="Cathode charge capacity (mAh)")
+    Q_discharge_cathode: float = Field(..., description="Cathode discharge capacity (mAh)")
+    Q_charge_full: float = Field(..., description="Full‑cell charge capacity (mAh)")
+    Q_discharge_full: float = Field(..., description="Full‑cell discharge capacity (mAh)")

app/models/model_e.py

@@ -0,0 +1,21 @@
+from typing import List
+from pydantic import BaseModel, Field
+
+class CapacityFadeInput(BaseModel):
+    cathode_name: str
+    cycle_numbers: List[int] = Field(..., description="List of cycle numbers")
+    Q_discharge_list: List[float] = Field(..., description="List of discharge capacities (mAh/g)")
+
+# New impedance growth inputs:
+    cycle_numbers_imp: List[int] = Field(..., description="List of cycle numbers for impedance growth plot")
+    impedance_list: List[float] = Field(..., description="List of impedance values (Ω)")
+    parameter_name: str = Field("Rct", description="Parameter name for impedance (e.g., 'Rct')")
+
+    # Calendar ageing inputs
+    temperature_C:        float = Field(..., description="Storage temperature in °C")
+    SOC_fraction:         float = Field(..., description="State of charge (0–1)")
+    storage_time_hours:   float = Field(..., description="Storage time in hours")
+    initial_capacity_mAh: float = Field(..., description="Initial full‑cell capacity (mAh)")
+
+    k_fade: float = Field(..., description="Capacity fade constant k for cycle-life estimation")
+    b_fade: float = Field(..., description="Exponent b for cycle-life estimation (0.3–0.7)")

app/routes/route_a.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter
+from ..models.model_a import MassLoadingInput
+from ..logic.calc_a import calculate_capacity
+
+router = APIRouter()
+
+@router.post("/calculate/capacity")
+def calculate(input: MassLoadingInput):
+    return {"results": calculate_capacity(
+        cathode_name=input.cathode_name,
+        L_anode   = input.L_anode,
+        L_cathode = input.L_cathode,
+        M_total   = input.M_total,
+        t_total   = input.t_total,
+        C_rate    = input.C_rate
+    )}
+

app/routes/route_b.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter, HTTPException
+from ..models.model_b import AllBInput
+from ..logic.calc_b import calculate_all_b
+
+router = APIRouter()
+
+@router.post("/calculate/all")
+def calculate_b(input: AllBInput):
+    cathode_name = input.cathode_name
+    # 1) V–Q / dQdV arrays
+    if len(input.V) != len(input.t):
+        raise HTTPException(400, "V and t must be same length")
+
+    # 2) Rate‑capability arrays
+    if len(input.C_rates) != len(input.t_discharge):
+        raise HTTPException(400, "C_rates and t_discharge must be same length")
+
+    # 3) GITT‑diffusion arrays
+    if len(input.delta_E_tau) != len(input.delta_E_s):
+        raise HTTPException(400, "delta_E_tau and delta_E_s must be same length")
+
+    # All validations passed, compute everything
+    return calculate_all_b(cathode_name, input.dict())

app/routes/route_c.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter, HTTPException
+from ..models.model_c import CVInput
+from ..logic.calc_c   import calculate_all_c
+
+router = APIRouter()
+
+@router.post("/calculate/c")
+def calc_c(input: CVInput):
+    cathode_name = input.cathode_name
+    # Q–V match check
+    if len(input.V_qv) != len(input.Q_qv):
+        raise HTTPException(400, "V_qv and Q_qv must have the same length")
+
+    return calculate_all_c(cathode_name, input.dict())

app/routes/route_d.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+from ..models.model_d import NPCalcInput
+from ..logic.calc_d   import calculate_all_d
+
+router = APIRouter()
+
+@router.post("/calculate/d")
+def calc_d(input: NPCalcInput):
+    cathode_name = input.cathode_name
+    return calculate_all_d(cathode_name, input.dict())

app/routes/route_e.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter, HTTPException
+from ..models.model_e import CapacityFadeInput
+from ..logic.calc_e   import calculate_all_e
+
+router = APIRouter()
+
+@router.post("/calculate/e")
+async def calc_e(input: CapacityFadeInput):
+    cathode_name=input.cathode_name
+    if len(input.cycle_numbers) != len(input.Q_discharge_list):
+        raise HTTPException(400, "cycle_numbers and Q_discharge_list must match length")
+    if len(input.cycle_numbers_imp) != len(input.impedance_list):
+        raise HTTPException(400, "cycle_numbers_imp and impedance_list must match length")
+    if not (0 <= input.SOC_fraction <= 1):
+        raise HTTPException(400, "SOC_fraction must be between 0 and 1")
+    if input.k_fade <= 0 or input.b_fade <= 0:
+        raise HTTPException(400, "k_fade and b_fade must be positive")
+    return calculate_all_e(cathode_name, input.dict())

app/sentiment/faiss_index.idx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8edf86598d5dd13cf1f4d960d6e785e6406d705d7522c2c41f99216769c486fe
+size 19992621

app/sentiment/process.py

@@ -0,0 +1,141 @@
+import os
+import fitz
+import nltk
+import json
+import faiss
+import numpy as np
+from openai import OpenAI
+import time
+
+nltk.download("punkt")
+
+PDF_FOLDER = "backend/app/sentiment/pds"
+FAISS_INDEX_PATH = "backend/app/sentiment/faiss_index.idx"
+METADATA_PATH = "backend/app/sentiment/metadata.json"
+EMBEDDING_MODEL = "text-embedding-ada-002"
+OVERLAP_TOKENS = 50
+CHUNK_SIZE_TOKENS = 200
+
+OPENAI_API_KEY='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'
+client = OpenAI(api_key=OPENAI_API_KEY)
+
+def extract_text_by_page(pdf_path):
+    """Extract text from each page of PDF separately (for metadata)."""
+    doc = fitz.open(pdf_path)
+    pages_text = []
+    for page in doc:
+        text = page.get_text()
+        pages_text.append(text)
+    return pages_text
+
+def tokenize_text(text):
+    """Tokenize text into tokens using nltk sentence tokenizer + split."""
+    sentences = nltk.sent_tokenize(text)
+    tokens = []
+    for sentence in sentences:
+        tokens.extend(sentence.split())
+    return tokens
+
+def detokenize_tokens(tokens):
+    """Convert tokens back to text."""
+    return " ".join(tokens)
+
+def chunk_tokens(tokens, chunk_size=CHUNK_SIZE_TOKENS, overlap=OVERLAP_TOKENS):
+    """Chunk tokens into overlapping chunks."""
+    chunks = []
+    start = 0
+    while start < len(tokens):
+        end = start + chunk_size
+        chunk = tokens[start:end]
+        chunks.append(chunk)
+        if end >= len(tokens):
+            break
+        start = end - overlap
+    return chunks
+
+def get_embedding(text):
+    response = client.embeddings.create(
+        input=text,
+        model="text-embedding-3-large"
+    )
+    return response.data[0].embedding
+
+def build_index_and_save():
+    all_embeddings = []
+    metadata = []
+
+    print("Reading PDFs and chunking text...")
+
+    for filename in os.listdir(PDF_FOLDER):
+        if not filename.lower().endswith(".pdf"):
+            continue
+        pdf_path = os.path.join(PDF_FOLDER, filename)
+        print(f"Processing {filename}")
+        pages = extract_text_by_page(pdf_path)
+        for page_num, page_text in enumerate(pages):
+            page_text = page_text.lower().strip()
+            tokens = tokenize_text(page_text)
+            chunks_tokens = chunk_tokens(tokens)
+            for i, chunk_tokens_ in enumerate(chunks_tokens):
+                chunk_text = detokenize_tokens(chunk_tokens_)
+                chunk_text = chunk_text.lower()
+
+                embedding = get_embedding(chunk_text)
+                all_embeddings.append(embedding)
+
+                metadata.append({
+                    "source_pdf": filename,
+                    "page": page_num,
+                    "chunk_index": i,
+                    "text": chunk_text[:500]
+                })
+
+                if len(all_embeddings) % 50 == 0:
+                    save_index_and_metadata(all_embeddings, metadata)
+
+    save_index_and_metadata(all_embeddings, metadata)
+    print("Index build completed.")
+
+def save_index_and_metadata(embeddings, metadata):
+    dimension = len(embeddings[0])
+    print(f"Saving index with {len(embeddings)} vectors...")
+    embeddings_np = np.array(embeddings).astype("float32")
+
+    faiss.normalize_L2(embeddings_np)
+
+    index = faiss.IndexFlatIP(dimension)
+    index.add(embeddings_np)
+    faiss.write_index(index, FAISS_INDEX_PATH)
+
+    with open(METADATA_PATH, "w", encoding="utf-8") as f:
+        json.dump(metadata, f, ensure_ascii=False, indent=2)
+
+def load_index_and_metadata():
+    index = faiss.read_index(FAISS_INDEX_PATH)
+    with open(METADATA_PATH, "r", encoding="utf-8") as f:
+        metadata = json.load(f)
+    return index, metadata
+
+def query_index(query, top_k=5):
+    index, metadata = load_index_and_metadata()
+    query = query.lower()
+    query_embedding = get_embedding(query)
+    query_embedding_np = np.array([query_embedding]).astype("float32")
+    faiss.normalize_L2(query_embedding_np)
+
+    distances, indices = index.search(query_embedding_np, top_k)
+    results = []
+    for dist, idx in zip(distances[0], indices[0]):
+        meta = metadata[idx]
+        results.append({
+            "score": float(dist),
+            "source_pdf": meta["source_pdf"],
+            "page": meta["page"],
+            "chunk_index": meta["chunk_index"],
+            "text_snippet": meta["text"]
+        })
+    return results
+
+if __name__ == "__main__":
+    build_index_and_save()
+    print("\nQuery results:")

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn
+google-generativeai
+openai
+faiss-cpu
+numpy
+scipy
+matplotlib
+pandas
+base64io
+requests
+python-dotenv