Module.hpp

Go to the documentation of this file.

/*
 * Module.hpp
 *
 *  Created on: 29 Nov 2019
 *   Author(s): Jorn Reniers, Volkan Kumtepeli
 */
 
#pragma once
 
#include "../StorageUnit.hpp"
#include "../cooling/cooling.hpp"
#include "../types/State.hpp"
#include "../settings/settings.hpp"
#include "../utility/utility.hpp"
 
 
#include <vector>
#include <cstdlib>
#include <memory>
#include <iostream>
#include <span>
 
 
namespace slide {
struct ModuleThermalParam
{
  double k_cell2cell{ 5 };                             
  double A{ 0.0042 * 10 * settings::MODULE_NSUs_MAX }; 
  double Qcontact{ 0 };                                
  double time{ 0 };                                    
};
 
class Module : public StorageUnit
{
 
public:
  using SU_t = Deep_ptr<StorageUnit>; // #TODO in future it should store directly storage unit itself.
  using SUs_t = std::vector<SU_t>;
  using SUs_span_t = std::span<SU_t>;
  using CoolSystem_t = Deep_ptr<CoolSystem>;
 
protected:
  SUs_t SUs;
  std::vector<double> Rcontact; 
 
  CoolSystem_t cool{ nullptr }; 
  ModuleThermalParam therm;
 
  size_t Ncells;               
  double Vmodule{ 0 };         
  bool Vmodule_valid{ false }; 
  bool par{ true };            
 
  State<0, settings::data::N_CumulativeModule> st_module;
  std::vector<double> data; 
 
 
  size_t calculateNcells() override
  {
    /*  return the number of cells connected to this module
     *  e.g. if this module has 3 child-modules, each with 2 cells.
     *  then getNSUs = 3 but getNcells = 6
     */
    return Ncells = transform_sum(SUs, free::get_Ncells<SU_t>);
  }
 
  double thermalModel_cell();
  double thermalModel_coupled(int Nneighbours, double Tneighbours[], double Kneighbours[], double Aneighb[], double tim);
 
public:
  Module() : StorageUnit("Module") {}
  Module(std::string_view ID_) : StorageUnit(ID_) {}
  Module(std::string_view ID_, double Ti, bool print, bool pari, int Ncells, int coolControl, int cooltype);
  Module(std::string_view ID_, double Ti, bool print, bool pari, int Ncells, CoolSystem_t &&coolControlPtr, int cooltype);
 
  size_t getNSUs() { return SUs.size(); } 
  SUs_t &getSUs() { return SUs; }
 
  const auto &operator[](size_t i) const { return SUs[i]; }
  auto &operator[](size_t i) { return SUs[i]; }
 
  virtual Status checkVoltage(double &v, bool print) noexcept override; 
  double getVhigh() override;                                           
  double getVlow() override;                                            
  void getStates(getStates_t &s) override;                              
                                                                        //  [s0 s1 s2 ... sn T], where s1 = cells[0].getStates()
 
  //    int Vstatus
 
  virtual bool validStates(bool print = true) override; 
  virtual Status setStates(setStates_t s, bool checkV = true, bool print = true) override;
 
  double T() override { return cool->T(); } 
 
  double getThermalSurface() override { return therm.A; };
  double getCoolingLoad(); 
  double thermalModel(int Nneighbours, double Tneighbours[], double Kneighbours[], double Aneighb[], double tim) override;
 
  virtual void setSUs(SUs_span_t c, bool checkCells = true, bool print = true);
 
  CoolSystem *getCoolSystem() { return cool.get(); }
 
  void setRcontact(std::span<double> Rc) 
  {
    /*
     * Set the contact resistance of each cell.
     * In parallel modules, this is the 'horizontal' resistance through which all currents of the cells 'behind it' goes.
     */
    assert(Rc.size() == getNSUs());
    Rcontact.resize(Rc.size());
    std::copy(Rc.begin(), Rc.end(), Rcontact.begin());
    Vmodule_valid = false; 
  }
 
  virtual Module *copy() override = 0;
 
  void storeData() override
  {
    for (const auto &SU : SUs) 
      SU->storeData();
 
    cool->storeData(getNcells());
 
    if constexpr (settings::DATASTORE_MODULE >= settings::moduleDataStorageLevel::storeTimeData) 
      data.insert(data.end(), { st_module.Ah(), st_module.Wh(), st_module.time(), I(), V(), T() });
  }
 
  void writeData(const std::string &prefix) override
  {
    for (const auto &SU : SUs) 
      SU->writeData(prefix);
 
 
    if constexpr (settings::DATASTORE_MODULE >= settings::moduleDataStorageLevel::storeTimeData) 
    {
      std::string name = prefix + "_" + getFullID() + "_ModuleData.csv"; 
 
      std::ofstream file(name, std::ios_base::app); // #TODO if first time open + header, if not append.
 
      if (!file.is_open()) {
        std::cerr << "ERROR in Module::writeData, could not open file " << name << '\n';
        throw 11;
      }
 
      free::write_data(file, data, 6);
 
      file.close();
    }
 
#if 0 
            cool->writeData(prefix + '_' + getFullID()); 
#endif
  }
 
  void setBlockDegAndTherm(bool block)
  {
    for (auto &SU : SUs)
      SU->setBlockDegAndTherm(block);
 
    blockDegAndTherm = block;
  }
 
  /*****************************************************************
   * Set the temperature of the coolant in this module.
   * Note that it does NOT immediately change the temperatures of the child-SUs.
   * That is done by the thermal model over time
   *****************************************************************/
  void setT(double Tnew) override { cool->setT(Tnew); } 
 
  /*****************************************************************
   * return the number of cells connected to this module
   * e.g. if this module has 3 child-modules, each with 2 cells.
   * then getNSUs = 3 but getNcells = 6
   *****************************************************************/
  size_t getNcells() override { return Ncells; }
 
  double getThotSpot() override 
  {
    double Thot = cool->T();
    for (const auto &SU : SUs)
      Thot = std::max(Thot, SU->getThotSpot());
 
    return Thot;
  }
};
} // namespace slide