StorageUnit.hpp

Go to the documentation of this file.

/*
 * StorageUnit.hpp
 *
 * parent class for all cells and modules, interface (ie only defines very general functions)
 *
 *  Created on: 9 Dec 2019
 *   Author(s): Jorn Reniers, Volkan Kumtepeli
 *
 */
 
#pragma once
 
#include "settings/settings.hpp"
#include "types/Status.hpp"
#include "types/Deep_ptr.hpp"
#include "utility/free_functions.hpp"
 
#include <string>
#include <cstdlib>
#include <vector>
#include <span>
#include <string_view>
#include <utility>
 
namespace slide {
class StorageUnit
{
protected:
  std::string ID{ "StorageUnit" };           
  StorageUnit *parent{ nullptr };            
  bool blockDegAndTherm{ false };            
  using setStates_t = std::span<double> &;   
  using getStates_t = std::vector<double> &; 
  using viewStates_t = std::span<double>;
  virtual size_t calculateNcells() { return 0; }
 
public:
  StorageUnit() = default;
  StorageUnit(std::string_view ID_) : ID(ID_) {}
  StorageUnit(std::string_view ID_, StorageUnit *parent_, bool blockDegAndTherm_)
    : ID(ID_), parent(parent_), blockDegAndTherm(blockDegAndTherm_) {}
 
  virtual ~StorageUnit() = default;
  const std::string &getID() { return ID; }
  void setID(std::string IDi) { ID = std::move(IDi); }
 
  virtual std::string getFullID() { return (parent != nullptr) ? parent->getFullID() + "_" + getID() : getID(); }
 
  virtual double Cap() const = 0; //
 
  auto *getParent() { return parent; };
 
  virtual double I() const = 0; //
  virtual double getRtot() = 0;
  virtual size_t getNcells() = 0; 
 
  inline bool isCharging() { return I() < 0; }    
  inline bool isDischarging() { return I() > 0; } 
 
  virtual void getStates(getStates_t s) = 0;       
  virtual viewStates_t viewStates() { return {}; } 
  void setBlockDegAndTherm(bool block) { blockDegAndTherm = block; }
  virtual void setParent(StorageUnit *p) { parent = p; }                             
  virtual Status setCurrent(double Inew, bool checkV = true, bool print = true) = 0; //
  virtual Status setVoltage(double Vnew, bool checkI = true, bool print = true)
  {
    return free::setVoltage_iterative(this, Vnew);
  }
 
 
  virtual Status setStates(setStates_t s, bool checkStates = true, bool print = true) = 0; 
 
  virtual void backupStates() {}  
  virtual void restoreStates() {} 
 
  virtual double getOCV() = 0;
  virtual double V() = 0;                                          
  virtual Status checkVoltage(double &v, bool print) noexcept = 0; 
  virtual double getVhigh() = 0;                                   
  virtual double getVlow() = 0;                                    
 
  virtual double Vmin() const = 0; 
  virtual double VMIN() const = 0; 
  virtual double Vmax() const = 0; 
  virtual double VMAX() const = 0; 
 
  virtual double T() = 0;
  virtual double getThotSpot() = 0;                                                                               
  virtual double getThermalSurface() = 0;                                                                         
  virtual double thermalModel(int Nneighb, double Tneighb[], double Kneighb[], double Aneighb[], double tim) = 0; 
  virtual void setT(double Tnew) = 0;
 
  virtual bool validStates(bool print = true) = 0;        
  virtual StorageUnit *copy() = 0;                        
  virtual void timeStep_CC(double dt, int steps = 1) = 0; 
 
  virtual void storeData() = 0;
  virtual void writeData(const std::string &prefix) = 0;
};
 
// Free functions:
// template <typename T, typename... Args>
// auto make_SU(Args &&...args) { return Deep_ptr<StorageUnit>(new T(std::forward<Args>(args)...)); }
 
template <typename T, typename... Args>
auto make_SU(Args &&...args)
{
  return Deep_ptr<StorageUnit>(std::unique_ptr<T>(new T(std::forward<Args>(args)...)));
}
 
} // namespace slide