Cell_KokamNMC.hpp

Go to the documentation of this file.

/*
 * Cell_KokamNMC.hpp
 *
 * One of the child classes of Cell which implements a real cell.
 * The cycling parameters are for a high power 18650 NMC cell manufactured by Kokam.
 * 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.
 */
 
#pragma once
 
#include "State_SPM.hpp"
#include "Cell_SPM.hpp"
#include "param/param_default.hpp"
#include "../../utility/utility.hpp"
 
#include <cmath>
#include <iostream>
#include <array>
 
namespace slide {
class Cell_KokamNMC : public Cell_SPM
{
public:
  Cell_KokamNMC(Model_SPM *, int verbosei);
  Cell_KokamNMC(Model_SPM *, DEG_ID &, int verbosei);
};
 
 
inline Cell_KokamNMC::Cell_KokamNMC(Model_SPM *MM, int verbosei)
  : Cell_SPM(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
   */
 
  Cmaxpos = 51385; 
  Cmaxneg = 30555; 
  C_elec = 1000;   
 
  n = 1;
 
  setCapacity(16); 
 
  T_ref = PhyConst::Kelvin + 25;
  T_env = PhyConst::Kelvin + 25;
  Qch = 90; 
  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.0982;
 
  sparam = param::def::StressParam_Kokam;
 
  kp = 5e-11; 
  kp_T = 58000;
  kn = 1.7640e-11; 
  kn_T = 20000;
  Dp_T = 29000;
  Dn_T = 35000 / 5.0; // #TODO Ask Jorn why SLIDE didn't have 5.0
 
  M = MM;
  checkModelparam(); 
 
  double Rdc = 0.0102; 
 
  double fp{ 0.689332 }, fn{ 0.479283 }; 
 
 
  st.T() = 25.0_degC; 
 
 
  st.delta() = 1e-9; 
 
  st.LLI() = 0;                   
  st.Dp() = 8e-14;                
  st.Dn() = 7e-14;                
  st.thickp() = 70e-6;            
  st.thickn() = 73.5e-6;          
  st.ep() = 0.5;                  
  st.en() = 0.5;                  
  st.ap() = 3 * st.ep() / geo.Rp; 
  st.an() = 3 * st.en() / geo.Rn; 
 
  st.CS() = 0.01 * st.an() * geo.elec_surf * st.thickn(); 
 
  st.rDCp() = 2.8e-3;
  st.rDCn() = 2.8e-3;
  st.rDCcc() = 232.5e-6; 
 
  st.delta_pl() = 0; 
 
  s_ini = st; 
 
  try {
    validState(st, s_ini);
  } 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_Kokam;
 
  csparam.CS1alpha = 4.25e-5;
  csparam.CS2alpha = 6.3e-7;
  csparam.CS3alpha = 2.31e-16;
  csparam.CS4alpha = 4.3306e-8;
  csparam.CS4Amax = 5 * getAnodeSurface(); 
  csparam.CS5k = 1e-18;
  csparam.CS5k_T = -127040;
  csparam.CS_diffusion = 2;
 
  OCVnmc = 4.1;
  lam_p = param::def::LAMparam_Kokam;
 
  npl = 1;
  alphapl = 1;
  OCVpl = 0;
  rhopl = 10000e3;
  pl_p.pl1k = 4.5e-10;
  pl_p.pl1k_T = -2.014008e5;
 
  deg_id.SEI_id.add_model(0); 
  deg_id.SEI_porosity = 0;    
 
  deg_id.CS_id.add_model(0); 
  deg_id.CS_diffusion = 0;   
 
  deg_id.LAM_id.add_model(0); 
  deg_id.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_KokamNMC::Cell_KokamNMC(Model_SPM *M_, DEG_ID &deg_id_, int verbosei) : Cell_KokamNMC(M_, verbosei)
{
  /*
   * constructor to initialise the degradation parameters
   *
   * IN
   * M      structure of the type Model, with the matrices of spatial discretisation for solid diffusion
   * degid  structure of the type DEG_ID, with the identifications of which degradation model(s) to use
   */
 
  deg_id = deg_id_; // #TODO deg_id_ was not being assigned. I assigned now check if it is correct behaviour.
  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