Cell_SPM.hpp

Go to the documentation of this file.

/*
 * Cell_SPM.hpp
 *
 * Header file for the parent Class for all Cells.
 *
 * It also defines a number of structs:
 *      DEG_ID      settings about which degradation models should be used for the simulations
 *      SEIparam    fitting parameters of the various models for SEI growth
 *      CSparam     fitting parameters of the various models for crach growth on the surface of the electrodes
 *      LAMparam    fitting parameters of the various models for loss of active material
 *      PLparam     fitting parameters of the various models for lithium plating
 *
 * Copyright (c) 2019, The Chancellor, Masters and Scholars of the University
 * of Oxford, VITO nv, and the 'Slide' Developers.
 * See the licence file LICENCE.txt for more information.
 */
 
#pragma once
 
#include "State_SPM.hpp" 
#include "Model_SPM.hpp" 
#include "param/param_SPM.hpp"
#include "../Cell.hpp"
#include "../../utility/utility.hpp"   // Do not remove they are required in cpp files.
#include "../../settings/settings.hpp" // Do not remove they are required in cpp files.
#include "../../types/OCVcurves.hpp"
 
#include <vector>
#include <array>
#include <iostream>
#include <memory>
 
namespace slide {
 
void validState(State_SPM &s, State_SPM &s_ini);
 
class Cell_SPM : public Cell
{
public:
  DEG_ID deg_id; 
  using sigma_type = std::array<double, settings::nch + 2>;
 
protected:                 
  State_SPM st{}, s_ini{}; 
 
  double Cmaxpos{ 51385 }; 
  double Cmaxneg{ 30555 }; 
  double C_elec{ 1000 };   
 
  double n{ 1 }; 
 
  double kp{ 5e-11 };      
  double kp_T{ 58000 };    
  double kn{ 1.7640e-11 }; 
  double kn_T{ 20000 };    
  double Dp_T{ 29000 };         
  double Dn_T{ 35000.0 / 5.0 }; 
 
  double Therm_Qgen{};             
  double Therm_Qgentot{};          
  double Therm_time{};             
  double T_env{ settings::T_ENV }; 
  double T_ref{ 25.0_degC };       
 
  double Qch{ 45 };   
  double rho{ 1626 }; 
  double Cp{ 750 };   
 
  param::Geometry_SPM geo{};
 
  param::StressParam sparam{ param::def::StressParam_Kokam }; 
 
  double rsei{ 2037.4 * 50 }; 
  double nsei{ 1 };           
  double alphasei{ 1 };       
  double OCVsei{ 0.4 };       
  double rhosei{ 100e3 };     
  double c_elec0{ 4.541e-3 }; 
  double Vmain{ 13 };         
  double Vsei{ 64.39 };       
 
  param::SEIparam sei_p{ param::def::SEIparam_Kokam }; 
 
  param::CSparam csparam{}; 
 
  double OCVnmc{ 4.1 };                                
  param::LAMparam lam_p{ param::def::LAMparam_Kokam }; 
 
  double npl{ 1 };      
  double alphapl{ 1 };  
  double OCVpl{ 0 };    
  double rhopl{ 10e6 }; 
  param::PLparam pl_p;  
 
  Model_SPM *M{ Model_SPM::makeModel() };
 
  OCVcurves OCV_curves;
 
  bool Vcell_valid{ false };
 
  std::pair<double, double> calcSurfaceConcentration(double jp, double jn, double Dpt, double Dnt);
  std::pair<double, double> calcOverPotential(double cps, double cns, double i_app); 
 
  inline double calcArrheniusCoeff() { return (1 / T_ref - 1 / st.T()) / PhyConst::Rg; } 
 
  std::array<double, 2> calcDiffConstant(); 
  std::array<double, 3> calcMolarFlux();    
 
 
  void SEI(double OCVnt, double etan, double *isei, double *den);                                                                             
  void CS(double OCVnt, double etan, double *isei_multiplyer, double *dCS, double *dDn);                                                      
  void LAM(bool critical, double zp_surf, double etap, double *dthickp, double *dthickn, double *dap, double *dan, double *dep, double *den); 
  double LiPlating(double OCVnt, double etan);
 
  void dState_diffusion(bool print, State_SPM &d_state);   
  void dState_thermal(bool print, double &dQgen);          
  void dState_degradation(bool print, State_SPM &d_state); 
  void dState_all(bool print, State_SPM &d_state);         
 
  double thermalModel_cell();
  double thermalModel_coupled(int Nneighb, double Tneighb[], double Kneighb[], double Aneighb[], double tim);
 
  double var_cap{ 1 };    
  double var_R{ 1 };      
  double var_degSEI{ 1 }; 
  double var_degLAM{ 1 }; 
 
public:
  Cell_SPM(OCVcurves OCV_curves_) : OCV_curves(OCV_curves_) {}
  Cell_SPM(std::string IDi, const DEG_ID &degid, double capf, double resf, double degfsei, double degflam);
 
  Cell_SPM(); 
 
  Cell_SPM(Model_SPM *M_ptr) : M(M_ptr) {}
 
  double T() noexcept override { return st.T(); }   
  double getTenv() const noexcept { return T_env; } 
 
  Status setCurrent(double Inew, bool checkV = true, bool print = true) override;
  Status setSOC(double SOCnew, bool checkV = true, bool print = true) override;
 
  auto &getStateObj() { return st; }
  auto setStateObj(State_SPM &st_new)
  {
    st = st_new;
    Vcell_valid = false;
  }
 
  std::array<double, 4> getVariations() const noexcept override { return { var_cap, var_R, var_degSEI, var_degLAM }; } // #TODO : deprecated will be deleted.
 
  void getTemperatures(double *Tenv, double *Tref) noexcept 
  {
    /*
     * Function to get the environmental and reference temperatures
     * OUT
     * Tenv     environmental temperature [K]
     * Tref     reference temperature [K] at which cell parameters are measured
     */
    *Tenv = T_env;
    *Tref = T_ref;
  }
 
  double getThermalSurface() override;
  double thermalModel(int Nneighb, double Tneighb[], double Kneighb[], double Aneighb[], double tim) override;
  double thermal_getTotalHeat(); 
 
 
  double getRdc() noexcept; 
  double getRtot() override { return getRdc(); }
 
  double getAnodeSurface() noexcept { return st.an() * st.thickn() * geo.elec_surf; } 
 
  double I() const override { return st.I(); } 
  double V() override;
 
  bool getCSurf(double &cps, double &cns, bool print);                                                                           
  void getC(double cp[], double cn[]) noexcept;                                                                                  
  int getVoltage(bool print, double *V, double *OCVp, double *OCVn, double *etap, double *etan, double *Rdrop, double *Temp);    
  int getVoltage_ne(bool print, double *V, double *OCVp, double *OCVn, double *etap, double *etan, double *Rdrop, double *Temp); 
 
  void getDaiStress(double *sigma_p, double *sigma_n, sigma_type &sigma_r_p, sigma_type &sigma_r_n, sigma_type &sigma_t_p, sigma_type &sigma_t_n, sigma_type &sigma_h_p, sigma_type &sigma_h_n) noexcept; 
  void updateDaiStress() noexcept;                                                                                                                                                                        
  void getLaresgoitiStress(bool print, double *sigma_n);                                                                                                                                                  
  void updateLaresgoitiStress(bool print);                                                                                                                                                                
 
  void setT(double T) override; 
  void setTenv(double Tenv);    
  void setC(double cp0, double cn0); 
  void peekVoltage(double I); 
 
 
  ThroughputData getThroughputs() override { return { st.time(), st.Ah(), st.Wh() }; }
 
  void overwriteCharacterisationStates(double Dpi, double Dni, double ri)
  {
    st.overwriteCharacterisationStates(Dpi, Dni, ri);
    s_ini.overwriteCharacterisationStates(Dpi, Dni, ri);
  }
 
  void overwriteGeometricStates(double thickpi, double thickni, double epi, double eni, double api, double ani)
  {
    st.overwriteGeometricStates(thickpi, thickni, epi, eni, api, ani);
    s_ini.overwriteGeometricStates(thickpi, thickni, epi, eni, api, ani);
  }
 
 
 
 
 
  State_SPM::states_type dState(bool print, State_SPM &d_state);
 
  void checkModelparam(); 
 
 
  void getStates(getStates_t s) override { s.insert(s.end(), st.begin(), st.end()); } 
  std::span<double> viewStates() override { return std::span<double>(st.begin(), st.end()); }
  double getOCV() override;
  Status setStates(setStates_t sSpan, bool checkV, bool print) override;
  bool validStates(bool print = true) override;
  inline double SOC() override { return st.SOC(); }
  void timeStep_CC(double dt, int steps = 1) override;
 
  Cell_SPM *copy() override { return new Cell_SPM(*this); }
  void ETI(bool print, double dti, bool blockDegradation); 
 
  void setOCVcurve(const std::string &namepos, const std::string &nameneg);                                         
  void setInitialConcentration(double cmaxp, double cmaxn, double lifracp, double lifracn);                         
  void setGeometricParameters(double capnom, double elec_surf, double ep, double en, double thickp, double thickn); 
 
  void setCharacterisationParam(double Dp, double Dn, double kp, double kn, double Rdc); 
};
} // namespace slide