Cell_ECM.hpp

Go to the documentation of this file.

/*
 * Cell_ECM.hpp
 *
 *  Created on: 17 Dec 2019
 *   Author(s): Jorn Reniers, Volkan Kumtepeli
 */
 
#pragma once
 
#include "../Cell.hpp"
#include "State_ECM.hpp"
#include "../../utility/utility.hpp"
#include "../../settings/settings.hpp"
 
#include <cstring>
#include <cassert>
#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <array>
 
namespace slide {
 
template <size_t N_RC = 1>
class Cell_ECM : public Cell
{
 
protected:
  State_ECM<N_RC> st{ settings::T_ENV, 0.5 }; 
 
  std::array<double, N_RC> Rp{}, inv_tau{}; // inv_tau = 1/(RC). All initialised zero.
  // double Rp{ 15.8e-3 }, Cp{ 38e3 }; //!< parallel resistance and capacitance
  XYdata_ff OCV;      
  double Rdc{ 2e-3 }; 
 
public:
  Cell_ECM();
  Cell_ECM(double capin, double SOCin);
  Cell_ECM(double capin, double SOCin, double Rdc_, std::array<double, N_RC> Rp_, std::array<double, N_RC> inv_tau_);
 
  Cell_ECM(std::string IDi, double capin, double SOCin, double Rdc_, std::array<double, N_RC> Rp_, std::array<double, N_RC> inv_tau_)
    : Cell_ECM(capin, SOCin, Rdc_, Rp_, inv_tau_)
  {
    ID = std::move(IDi);
  }
 
 
  Cell_ECM(std::string IDi, double capin, double SOCin)
    : Cell_ECM(capin, SOCin)
  {
    ID = std::move(IDi);
  }
 
  Cell_ECM(std::string IDi) : Cell_ECM() { ID = std::move(IDi); }
 
  inline double I() const override { return st.I(); }
  inline double getIr() { return st.Ir(); } 
  inline double SOC() override { return st.SOC(); }
  inline double T() override { return st.T(); }
 
  std::span<double> viewStates() override { return std::span<double>(st.begin(), st.end()); }
  void getStates(getStates_t s) override { s.insert(s.end(), st.begin(), st.end()); }
 
  auto &getStateObj() { return st; }
 
  double V() override; 
  Status setStates(setStates_t s, bool checkStates = true, bool print = true) override;
 
  double getRtot() override { return Rdc; } 
  double getThotSpot() override { return T(); }
  double getThermalSurface() override { return 0; };                                        
  double getOCV() override { return OCV.interp(st.SOC(), settings::printBool::printCrit); } // Linear interpolation #TODO add a OCV model.
 
  Status setSOC(double SOCnew, bool checkV = true, bool print = true) override;
  Status setCurrent(double Inew, bool checkV = true, bool print = true) override;
  Status setVoltage(double Vnew, bool checkI = true, bool print = true) override;
 
  inline void setT(double Tnew) override { st.T() = Tnew; }
 
  virtual bool validStates(bool print = true) override;
  void timeStep_CC(double dt, int steps = 1) override;
 
  ThroughputData getThroughputs() override { return { st.time(), st.Ah(), st.Wh() }; }
 
  Cell_ECM<N_RC> *copy() override { return new Cell_ECM<N_RC>(*this); }
};
 
// Implementation:
 
template <size_t N_RC>
inline Cell_ECM<N_RC>::Cell_ECM()
{
  ID = "Cell_ECM<" + std::to_string(N_RC) + ">";
  capNom = 16;
  OCV.x = slide::linspace_fix(0.0, 1.0, 3);
  OCV.y = slide::linspace_fix(VMIN(), VMAX(), 3);
 
  if constexpr (N_RC >= 1) {
    constexpr double Cp0 = 38e3; // first parallel capacitance
    Rp[0] = 15.8e-3;             // fist parallel (polarisation) resistance default value.
    inv_tau[0] = 1.0 / (Rp[0] * Cp0);
  }
 
  if constexpr (N_RC == 2) {
    Rp[1] = 2.5e-3; // second parallel (polarisation) resistance default value.
    inv_tau[1] = 1.0 / 100.0;
  }
 
  OCV.check_is_fixed();
  cellData.initialise(*this);
}
 
template <size_t N_RC>
inline Cell_ECM<N_RC>::Cell_ECM(double capin, double SOCin) : Cell_ECM()
{
  if (!free::check_SOC(SOCin)) throw 10;
 
  st.SOC() = SOCin;
  setCapacity(capin);
}
 
template <size_t N_RC>
inline Cell_ECM<N_RC>::Cell_ECM(double capin, double SOCin, double Rdc_,
                                std::array<double, N_RC> Rp_,
                                std::array<double, N_RC> inv_tau_)
  : Cell_ECM(capin, SOCin)
{
  Rdc = Rdc_;
  Rp = Rp_;
  inv_tau = inv_tau_;
}
 
 
template <size_t N_RC>
inline Status Cell_ECM<N_RC>::setCurrent(double Inew, bool checkV, bool print)
{
  const double Iold = I();
  st.I() = Inew;
 
  const auto status = checkCurrent(checkV, print);
 
  if (isStatusBad(status))
    st.I() = Iold;
 
  return status;
}
 
template <size_t N_RC>
inline Status Cell_ECM<N_RC>::setVoltage(double Vnew, bool checkI, bool print)
{
  const double Iold = st.I();
  // #TODO check if V is sensible here.
 
  const double ocv = getOCV();
  double v_now = ocv - Vnew;
 
  for (size_t i{}; i < N_RC; i++)
    v_now -= Rp[i] * st.Ir(i);
 
  const auto Inew = v_now / Rdc;
 
  st.I() = Inew;
 
  const auto status = checkCurrent(checkI, print);
 
  if (isStatusBad(status))
    st.I() = Iold;
 
  return status;
}
 
template <size_t N_RC>
inline Status Cell_ECM<N_RC>::setSOC(double SOCnew, bool checkV, bool print) 
{
  if (!free::check_SOC(SOCnew))
    return Status::SOC_limits_violation;
 
  const double SOCold = st.SOC();
 
  st.SOC() = SOCnew;
 
  if (checkV) {
    double v;
    const auto status = checkVoltage(v, print); 
 
    if (isStatusBad(status))
      st.SOC() = SOCold; 
 
    return status;
  }
 
  return Status::Success;
}
 
template <size_t N_RC>
inline double Cell_ECM<N_RC>::V()
{
  const bool verb = settings::printBool::printCrit; 
  try {
    const double ocv = getOCV();
    double v_now = ocv - Rdc * st.I();
 
    for (size_t i{}; i < N_RC; i++)
      v_now -= Rp[i] * st.Ir(i);
 
    return v_now;
  } catch (int e) {
    if (verb)
      std::cerr << "ERROR in Cell_ECM::getV when getting the OCV.\n";
    return 0;
  }
}
 
template <size_t N_RC>
inline Status Cell_ECM<N_RC>::setStates(setStates_t s, bool checkV, bool print)
{
  /*
   */
  const auto st_old = st; 
 
  std::copy(s.begin(), s.begin() + st.size(), st.begin()); 
  s = s.last(s.size() - st.size());                        
 
  const Status status = free::check_Cell_states(*this, checkV);
 
  if (isStatusBad(status))
    st = st_old; 
 
  return status;
}
 
template <size_t N_RC>
inline bool Cell_ECM<N_RC>::validStates(bool print)
{
  /*
   * note: does NOT check the voltage, only whether all fields are in the allowed range
   * throws
   * 10 invalid array (wrong length)
   */
 
  const bool verb = print && (settings::printBool::printCrit); 
 
 
  bool range = free::check_SOC(SOC());
 
  if (T() < Tmin() || T() > Tmax()) {
    if (verb)
      std::cerr << "ERROR in Cell_ECM::validState, T is outside of the range, "
                << Tmin() << " <= T <= " << Tmax()
                << ", value is " << T() << '\n';
    range = false;
  }
 
  return range;
}
 
template <size_t N_RC>
inline void Cell_ECM<N_RC>::timeStep_CC(double dt, int nstep)
{
  /*
   *    take a time step of dt seconds while keeping the current constant
   */
  if (dt < 0) {
    if constexpr (settings::printBool::printCrit)
      std::cerr << "ERROR in Cell_ECM::timeStep_CC, the time step dt must be "
                << "0 or positive, but has value " << dt << '\n';
    throw 10;
  }
 
  const auto dth = dt / 3600.0;
  for (int t = 0; t < nstep; t++) {
    const auto dAh = st.I() * dth;
    st.SOC() -= dAh / Cap();
 
    for (size_t i{}; i < N_RC; i++) // dIr/dt = (I - Ir)/(RC)
      st.Ir(i) += dt * inv_tau[i] * (st.I() - st.Ir(i));
 
    if constexpr (settings::data::storeCumulativeData) {
      st.time() += dt;
      st.Ah() += std::abs(dAh);
      st.Wh() += std::abs(dAh * V());
    }
  }
}
 
using Cell_Bucket = Cell_ECM<0>;
 
} // namespace slide