State_SPM.hpp

Go to the documentation of this file.

/*
 * State_SPM.hpp
 *
 * Implements a class State which defines the state-variables of a cell for the state-space model formulation
 *
 *  Created on: 12 Apr 2022
 *   Author(s): Jorn Reniers, Volkan Kumtepeli
 */
 
#pragma once
 
#include "../../settings/settings.hpp"
#include "../../types/State.hpp"
 
#include <cstdlib>
#include <array>
#include <span>
 
namespace slide {
class State_SPM : public State<29> 
{
public:
  constexpr static auto nch = settings::nch;
 
  enum Index : size_t 
  {
    i_I,
    i_V,
    i_T,                 
    i_delta,             
    i_LLI,               
    i_thickp,            
    i_thickn,            
    i_ep,                
    i_en,                
    i_ap,                
    i_an,                
    i_CS,                
    i_Dp,                
    i_Dn,                
    i_delta_pl,          
    i_zp,                
    i_zn = i_zp + nch,   
    i_rDCp = i_zn + nch, 
    i_rDCn,              
    i_rDCcc,             
    i_SOC,
    N_states,
    N_save = i_zp 
  };
 
  /* (OLD NOTE) Note on ri:
   * this is the resistance times the electrode surface, averaged between both electrodes.
   * The total cell resistance is (see Cell::getR() ): r /( (thickp*ap*elec_surf + thickn*an*elec_surf)/2 )
   *    with r the resistance times the average electrode surface
   *         thicki the thickness of electrode i
   *         ai the specific surface area of electrode i
   *         elec_surf the geometric surface area of the electrode (height of the electrode * width of the electrode)
   * so if the measured DC resistance of the cell is R, the value of r can be calculated using:
   *         ri = R * ( (thickp*ap*elec_surf + thickn*an*elec_surf)/2 )
   */
 
  using z_type = std::array<value_type, nch>;
  using states_type = std::array<value_type, N_states>;
 
 
  inline auto &zp(size_t i) { return (*this)[i_zp + i]; } 
  inline auto &zn(size_t i) { return (*this)[i_zn + i]; } 
  inline auto &z(size_t i) { return (*this)[i_zp + i]; }  
 
  inline auto zp() { return std::span<double>(&zp(0), &zn(0)); }
  inline auto zn() { return std::span<double>(&zn(0), &zn(0) + nch); }
  inline auto z() { return std::span<double>(&zp(0), &zn(0) + nch); }
 
 
  inline auto &T() { return (*this)[i_T]; }               
  inline auto &delta() { return (*this)[i_delta]; }       
  inline auto &LLI() { return (*this)[i_LLI]; }           
  inline auto &thickp() { return (*this)[i_thickp]; }     
  inline auto &thickn() { return (*this)[i_thickn]; }     
  inline auto &ep() { return (*this)[i_ep]; }             
  inline auto &en() { return (*this)[i_en]; }             
  inline auto &ap() { return (*this)[i_ap]; }             
  inline auto &an() { return (*this)[i_an]; }             
  inline auto &CS() { return (*this)[i_CS]; }             
  inline auto &Dp() { return (*this)[i_Dp]; }             
  inline auto &Dn() { return (*this)[i_Dn]; }             
  inline auto &rDCp() { return (*this)[i_rDCp]; }         
  inline auto &rDCn() { return (*this)[i_rDCn]; }         
  inline auto &rDCcc() { return (*this)[i_rDCcc]; }       
  inline auto &delta_pl() { return (*this)[i_delta_pl]; } 
  inline auto &SOC() { return (*this)[i_SOC]; }           
  inline auto &I() { return (*this)[i_I]; }               
  inline auto &V() { return (*this)[i_V]; }               
 
  void overwriteGeometricStates(double thickpi, double thickni, double epi, double eni, double api, double ani); 
  void overwriteCharacterisationStates(double Dpi, double Dni, double ri);                                       
 
  std::span<double> viewGeometricStates() { return std::span<double>(&delta(), &delta_pl() + 1); } 
 
  // Const methods:
 
  inline auto I() const { return (*this)[i_I]; } 
};
 
inline void State_SPM::overwriteGeometricStates(double thickpi, double thickni, double epi, double eni, double api, double ani)
{
  /*
   * Function to overwrite the geometric parameters of the state.
   * It also overwrites the initial states, so use it with extreme caution.
   * It should only be called when you are parametrising a cell (determineCharacterisation.cpp), never while cycling a cell.
   *
   * IN
   * thickpi    thickness of the cathode [m]
   * thickni    thickness of the anode [m]
   * epi        volume fraction of active material in the cathode [-]
   * eni        volume fraction of active material in the anode [-]
   * api        effective surface area of the porous cathode [m2 m-3]
   * ani        effective surface area of the porous anode [m2 m-3]
   */
 
  this->thickp() = thickpi;
  this->thickn() = thickni;
  this->ep() = epi;
  this->en() = eni;
  this->ap() = api;
  this->an() = ani;
}
 
inline void State_SPM::overwriteCharacterisationStates(double Dpi, double Dni, double ri)
{
  /*
   * Function to overwrite the parameters related to the characterisation of the cell.
   * The states and initial states are overwritten so use this function with caution.
   * It should only be called when you are parametrising a cell (determineCharacterisation.cpp), never while cycling a cell.
   *
   * IN
   * Dpi    diffusion constant of the cathode at rate temperature [m s-1]
   * Dni    diffusion constant of the anode at rate temperature [m s-1]
   * r  specific resistance of the combined electrodes [Ohm m2]
   */
 
  this->Dp() = Dpi;
  this->Dn() = Dni;
  this->rDCp() = ri; 
  this->rDCn() = ri;
}
} // namespace slide