Cell_LGChemNMC.hpp

Go to the documentation of this file.

/*
 * Cell_LGChemNMC.cpp
 *
 * One of the child classes that implements a real cell.
 * The cycling parameters are for a high energy 18650 NMC cell manufactured by LG Chem.
 * The degradation parameters are set such that each mechanism clearly affects the battery life (which is not the case in reality).
 *
 * 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.
 */
 
#include "Cell_SPM.hpp"
#include "../../utility/utility.hpp"
#include "param/param_default.hpp"
 
#include <cmath>
#include <iostream>
 
namespace slide {
class Cell_LGChemNMC : public Cell_SPM
{
public:
  Cell_LGChemNMC(Model_SPM *, int verbosei); 
  Cell_LGChemNMC(Model_SPM *M, DEG_ID &, int verbosei);
};
 
 
inline Cell_LGChemNMC::Cell_LGChemNMC(Model_SPM *MM, int verbosei)
  : Cell_SPM(OCVcurves::makeOCVcurves(cellType::LGChemNMC)) 
{
  /* OCVcurves::makeOCVcurves(cellType::KokamNMC)
   * Standard constructor to initialise the battery parameters
   *
   * IN
   * M          structure of the type Model, with the matrices of spatial discretisation for solid diffusion
   * verbosei       integer indicating how verbose the simulation has to be.
   *                The higher the number, the more output there is.
   *                Recommended value is 1, only use higher values for debugging
   *                From 4 (and above) there will be too much info printed to follow what is going on, but this might be useful for debugging to find where the error is and why it is happening
   *                    0   almost no messages are printed, only in case of critical errors related to illegal parameters
   *                    1   error messages are printed in case of critical errors which might crash the simulation
   *                    2   all error messages are printed, whether the simulation can recover from the errors or not
   *                    3   on top of the output from 2, a message is printed every time a function in the Cycler and BasicCycler is started and terminated
   *                    4   on top of the output from 3, the high-level flow of the program in the Cycler is printed (e.g. 'we are going to discharge the cell')
   *                    5   on top of the output from 4, the low-level flow of the program in the BasicCycler is printed (e.g. 'in time step 101, the voltage is 3.65V')
   *                    6   on top of the output from 5, we also print details of the nonlinear search for the current needed to do a CV phase
   *                    7   on top of the output from 6, a message is printed every time a function in the Cell is started and terminated
   *
   * THROWS
   * 110    the matrices for the solid diffusion discretisation, produced by MATLAB, are wrong
   * 111    the OCV curves are too long
   */
 
  Cmaxpos = 51385; 
  Cmaxneg = 30555; 
  C_elec = 1000;   
 
  n = 1;
 
  setCapacity(3.5);
  // Vmax = 4.2;   //!< value for an NMC/C cell
  // Vmin = 2.7;   //!< value for an NMC/C cell
  // dIcell = 1.0; //!< ramp at 1A
  // dt_I = 1e-2;  //!< ramp at 10ms so changing the current goes fast
  //               //!< now changing the current takes 0.01 second per A
 
  T_ref = PhyConst::Kelvin + 25;
  T_env = PhyConst::Kelvin + 25;
  Qch = 40; 
  rho = 1626;
  Cp = 750;
 
  geo.L = 1.6850e-4;
  geo.Rp = 8.5e-6;  
  geo.Rn = 1.25e-5; 
  geo.SAV = 252.9915;
  geo.elec_surf = 0.132360185255877;
 
  sparam = param::def::StressParam_LGCChemNMC;
 
  kp = 0.9e-12; 
  kp_T = 58000;
  kn = 4e-10; 
  kn_T = 20000;
  Dp_T = 29000;
  Dn_T = 35000; // #TODO Ask Jorn why SLIDE didn't have 5.0
 
  M = MM;
  checkModelparam(); 
 
  State_SPM::z_type up, un;
  double fp, fn, T, delta;                                                                          
  double Rdc = 0.0102;                                                                              
  fp = 0.651673;                                                                                    
  fn = 0.297109;                                                                                    
  T = 25_degC;                                                                                      
  delta = 1e-9;                                                                                     
  LLI = 0;                                                                                          
  thickp = 70e-6;                                                                                   
  thickn = 1.170972150305478e-4;                                                                    
  ep = 0.5;                                                                                         
  en = 0.5;                                                                                         
  ap = 3 * ep / geo.Rp;                                                                             
  an = 3 * en / geo.Rn;                                                                             
  CS = 0.01 * an * geo.elec_surf * thickn;                                                          
  Dp = 1e-14;                                                                                       
  Dn = 3e-14;                                                                                       
  R = Rdc * ((thickp * ap * geo.elec_surf + thickn * an * geo.elec_surf) / 2);                      
  delta_pl = 0;                                                                                     
  s_ini.initialise(up, un, T, delta, LLI, thickp, thickn, ep, en, ap, an, CS, Dp, Dn, R, delta_pl); 
  st = s_ini;                                                                                       
 
  try {
    validState();
  } catch (int e) {
    std::cout << "Error in State::initialise, one of the states has an illegal value, throwing an error\n";
    throw 12;
  }
  setC(fp, fn); 
 
  nsei = 1;
  alphasei = 1;
  OCVsei = 0.4;
  rhosei = 100e3;
  rsei = 2037.4;
  Vmain = 13.0;
  Vsei = 64.39;
  c_elec0 = 4.541e-3;
 
  sei_p = param::def::SEIparam_LGCChemNMC;
 
  csparam.CS1alpha = 7.5e-4;
  csparam.CS2alpha = 7.5e-7;
  csparam.CS3alpha = 3.75e-15;
  csparam.CS4alpha = 7.44e-8;
  csparam.CS4Amax = 5 * getAnodeSurface(); 
  csparam.CS5k = 1e-15;
  csparam.CS5k_T = 130000;
  csparam.CS_diffusion = 2;
 
  OCVnmc = 4.1;
  lam_p = param::def::LAMparam_LGCChemNMC;
 
  npl = 1;
  alphapl = 1;
  OCVpl = 0;
  rhopl = 10000e3;
  pl_p.pl1k = 2.25e-8;
  pl_p.pl1k_T = -1.0070e5;
 
  deg.SEI_id.add_model(0); 
  deg.SEI_porosity = 0;    
 
  deg.CS_id.add_model(0); 
  deg.CS_diffusion = 0;   
 
  deg.LAM_id.add_model(0); 
  deg.pl_id = 0;           
 
  for (auto cs_id : deg_id.CS_id)
    sparam.s_dai = sparam.s_dai || cs_id == 2;
 
  for (auto lam_id : deg_id.LAM_id)
    sparam.s_dai = sparam.s_dai || lam_id == 1;
 
  for (auto cs_id : deg_id.CS_id)
    sparam.s_lares = sparam.s_lares || cs_id == 1;
}
 
inline Cell_LGChemNMC::Cell_LGChemNMC(Model_SPM *M, DEG_ID &deg_id, int verbosei) : Cell_LGChemNMC(M, verbosei)
{
  /*
   * constructor to initialise the degradation parameters
   *
   * IN
   * M      structure of the type Model, with the matrices of the state space model for solid diffusion
   * degid  structure of the type DEG_ID, with the identifications of which degradation model(s) to use
   */
 
  for (auto cs_id : deg_id.CS_id)
    sparam.s_dai = sparam.s_dai || cs_id == 2;
 
  for (auto lam_id : deg_id.LAM_id)
    sparam.s_dai = sparam.s_dai || lam_id == 1;
 
  for (auto cs_id : deg_id.CS_id)
    sparam.s_lares = sparam.s_lares || cs_id == 1;
}
}; // namespace slide