Cell.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "cell_limits.hpp"
#include "../settings/settings.hpp"
#include "../StorageUnit.hpp"
#include "../types/Histogram.hpp"
#include "../types/data_storage/CellData.hpp"
#include "../types/Status.hpp"
#include "../utility/utility.hpp"
 
#include <cassert>
#include <iostream>
#include <fstream>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <span>
 
namespace slide {
 
class Cell : public StorageUnit
{
protected:
  double capNom{ 16 }; 
 
  CellData<settings::DATASTORE_CELL> cellData; 
 
public:
  constexpr static CellLimits limits{ defaultCellLimits }; // Default cell limits. #TODO make it changable.
 
  Cell() : StorageUnit("cell") {}
 
  Cell(const std::string &ID_) : StorageUnit(ID_) {}
  virtual ~Cell() = default;
 
  double Cap() const final override { return capNom; }
  void setCapacity(double capacity) { capNom = capacity; }
 
  constexpr double Vmin() const override { return limits.Vmin; }
  constexpr double VMIN() const override { return limits.VMIN; }
  constexpr double VMAX() const override { return limits.VMAX; }
  constexpr double Vmax() const override { return limits.Vmax; }
  constexpr double Tmax() { return limits.Tmax; }
  constexpr double Tmin() { return limits.Tmin; }
 
  double getVhigh() final { return V(); } 
  double getVlow() final { return V(); }  
 
  virtual Status setSOC(double SOCnew, bool checkV = true, bool print = true) = 0;
  virtual double SOC() = 0;
  virtual double getThotSpot() override { return T(); }
  size_t getNcells() override final { return 1; } 
 
  virtual Status checkCurrent(bool checkV, bool print) noexcept
  {
    double v;
    Status Vstatus = checkV ? checkVoltage(v, print) : Status::Success;
    return Vstatus;
  }
 
  virtual Status checkVoltage(double &v, bool print) noexcept override { return free::check_voltage(v, *this); }
 
 
 
  virtual double thermalModel(int Nneighb, double Tneighb[], double Kneighb[], double Aneighb[], double tim) override
  {
    return T();
  }
 
  virtual void storeData() override { cellData.storeData(*this); }                                  
  virtual void writeData(const std::string &prefix) override { cellData.writeData(*this, prefix); } // #TODO *this may be Cell not actual type.
 
  virtual ThroughputData getThroughputs() { return {}; }
 
  virtual std::array<double, 4> getVariations() const noexcept { return {}; } // #TODO will be deleted in future.
};
 
} // namespace slide