Simulation.h

// SPDX-License-Identifier: Apache-2.0
 
#pragma once
 
#include "dpsim/MNASolverFactory.h"
#include <vector>
 
#include <dpsim-models/Attribute.h>
#include <dpsim-models/Definitions.h>
#include <dpsim-models/Logger.h>
#include <dpsim-models/SimNode.h>
#include <dpsim-models/SystemTopology.h>
#include <dpsim/Config.h>
#include <dpsim/DataLogger.h>
#include <dpsim/Event.h>
#include <dpsim/Interface.h>
#include <dpsim/Scheduler.h>
#include <dpsim/Solver.h>
 
#ifdef WITH_GRAPHVIZ
#include <dpsim-models/Graph.h>
#endif
 
namespace DPsim {
class CommandLineArgs;

class Simulation : public CPS::AttributeList {
public:
  typedef std::shared_ptr<Simulation> Ptr;

  const CPS::Attribute<String>::Ptr mName;
  String mSolverPluginName;
  const CPS::Attribute<Real>::Ptr mFinalTime;
  const CPS::Attribute<Real>::Ptr mTimeStep;
 
  const CPS::Attribute<Bool>::Ptr mPFKeepLastSolution;

  const CPS::Attribute<Real>::Ptr mPFBaseApparentPowerFallback;

  const CPS::Attribute<CPS::UInt>::Ptr mPFMaxIterations;

  const CPS::Attribute<Bool>::Ptr mPFSolverUseSparse;

  const CPS::Attribute<Bool>::Ptr mPFEnforceReactiveLimits;

  const CPS::Attribute<Real>::Ptr mPFBaseVoltageLooseTolerance;

  const CPS::Attribute<Real>::Ptr mPFBaseVoltageStrictTolerance;

  const CPS::Attribute<Bool>::Ptr mSplitSubnets;

  const CPS::Attribute<Bool>::Ptr mSteadyStateInit;
 
protected:
  Real mTime = 0;
  Int mTimeStepCount = 0;
  EventQueue mEvents;
  CPS::SystemTopology mSystem;

  std::chrono::time_point<std::chrono::steady_clock> mSimulationStartTimePoint;
  std::chrono::time_point<std::chrono::steady_clock> mSimulationEndTimePoint;
  std::chrono::duration<double> mSimulationCalculationTime;
 
  // #### Logging ####
  CPS::Logger::Level mLogLevel;
  std::vector<Real> mStepTimes;
  Bool mLogStepTimes = true;
 
  // #### Solver Settings ####
  CPS::Domain mDomain = CPS::Domain::DP;
  Solver::Type mSolverType = Solver::Type::MNA;
  Solver::Behaviour mSolverBehaviour = Solver::Behaviour::Simulation;
  Solver::List mSolvers;
  DirectLinearSolverImpl mDirectImpl = DirectLinearSolverImpl::Undef;
  DirectLinearSolverConfiguration mDirectLinearSolverConfiguration;
  Bool mInitFromNodesAndTerminals = true;
  Bool mSystemMatrixRecomputation = false;
  Bool mStateSpaceExtraction = false;

  CPS::IdentifiedObject::List mTearComponents = CPS::IdentifiedObject::List();
  Bool mFreqParallel = false;
  Bool mInitialized = false;
 
  // #### Initialization ####
  Real mSteadStIniTimeLimit = 10;
  Real mSteadStIniAccLimit = 0.0001;
 
  // #### Task dependencies und scheduling ####
  std::shared_ptr<Scheduler> mScheduler;
  CPS::Task::List mTasks;
  Scheduler::Edges mTaskInEdges, mTaskOutEdges;

  std::vector<Interface::Ptr> mInterfaces;
 
  struct LoggerMapping {
    DataLogger::Ptr logger;
    UInt downsampling;
  };

  DataLoggerInterface::List mLoggers;

  void create();
  template <typename VarType> void createSolvers();
  template <typename VarType> void createMNASolver();
  void prepSchedule();

  int mMaxIterations = 10;
 
public:
  CPS::Logger::Log mLog;

  Simulation(String name, CommandLineArgs &args);

  Simulation(String name,
             CPS::Logger::Level logLevel = CPS::Logger::Level::info);

  virtual ~Simulation() {}
 
  // #### Simulation Settings ####
  void setSystem(const CPS::SystemTopology &system) { mSystem = system; }
  void setTimeStep(Real timeStep) { **mTimeStep = timeStep; }
  void setFinalTime(Real finalTime) { **mFinalTime = finalTime; }
  void setDomain(CPS::Domain domain = CPS::Domain::DP) { mDomain = domain; }
  void setSolverType(Solver::Type solverType = Solver::Type::MNA) {
    mSolverType = solverType;
  }
  void setSolverAndComponentBehaviour(Solver::Behaviour behaviour) {
    mSolverBehaviour = behaviour;
  }

  void setDirectLinearSolverImplementation(DirectLinearSolverImpl directImpl) {
    mDirectImpl = directImpl;
  }
  void setDirectLinearSolverConfiguration(
      const DirectLinearSolverConfiguration &configuration) {
    mDirectLinearSolverConfiguration = configuration;
  }
  void setMaxNumberOfIterations(int maxIterations) {
    mMaxIterations = maxIterations;
  }
  void doInitFromNodesAndTerminals(Bool f = true) {
    mInitFromNodesAndTerminals = f;
  }
  void doSplitSubnets(Bool splitSubnets = true) {
    **mSplitSubnets = splitSubnets;
  }
  void setTearingComponents(CPS::IdentifiedObject::List tearComponents =
                                CPS::IdentifiedObject::List()) {
    mTearComponents = tearComponents;
  }
  void setScheduler(const std::shared_ptr<Scheduler> &scheduler) {
    mScheduler = scheduler;
  }

  void doFrequencyParallelization(Bool value) { mFreqParallel = value; }
  void doSystemMatrixRecomputation(Bool value) {
    mSystemMatrixRecomputation = value;
  }
  void doStateSpaceExtraction(Bool value = true) {
    mStateSpaceExtraction = value;
  }

  void setLogStepTimes(Bool f) { mLogStepTimes = f; }
 
  // #### Initialization ####
  void doSteadyStateInit(Bool f) { **mSteadyStateInit = f; }
  void setSteadStIniTimeLimit(Real v) { mSteadStIniTimeLimit = v; }
  void setSteadStIniAccLimit(Real v) { mSteadStIniAccLimit = v; }
 
  void setPFKeepLastSolution(Bool value);
 
  Bool getPFKeepLastSolution() const;
 
  void setPFBaseApparentPowerFallback(Real value);
 
  Real getPFBaseApparentPowerFallback() const;
 
  void setPFMaxIterations(CPS::UInt value);
 
  CPS::UInt getPFMaxIterations() const;
 
  void setPFSolverUseSparse(Bool value);
 
  Bool getPFSolverUseSparse() const;
 
  void setPFSolverEnforceReactiveLimits(Bool value);
 
  Bool getPFSolverEnforceReactiveLimits() const;
 
  void setPFSolverBaseVoltageLooseTolerance(Real tolerance);
 
  Real getPFSolverBaseVoltageLooseTolerance() const;
 
  void setPFSolverBaseVoltageStrictTolerance(Real tolerance);
 
  Real getPFSolverBaseVoltageStrictTolerance() const;
 
  // #### Simulation Control ####
  void initialize();
  void start();
  void stop();
  Real next();
  void run();
  virtual Real step();
  void sync() const;
  void schedule();

  void addEvent(Event::Ptr e) { mEvents.addEvent(e); }
  void addLogger(DataLoggerInterface::Ptr logger) {
    mLoggers.push_back(logger);
  }

  void logStepTimes(String logName);
  void checkForOverruns(String logName);

  void logLUTimes();

  void addInterface(Interface::Ptr eint) {
    eint->setLogger(mLog);
    mInterfaces.push_back(eint);
  }
 
#ifdef WITH_GRAPHVIZ
  CPS::Graph::Graph dependencyGraph();
#endif
 
  // #### Getter ####
  String name() const { return **mName; }
  Real time() const { return mTime; }
  Real finalTime() const { return **mFinalTime; }
  Int timeStepCount() const { return mTimeStepCount; }
  Real timeStep() const { return **mTimeStep; }
  DataLogger::List &loggers() { return mLoggers; }
  std::shared_ptr<Scheduler> scheduler() { return mScheduler; }
  std::vector<Real> &stepTimes() { return mStepTimes; }
  const MNAStateSpaceExtractor &
  getStateSpaceExtractor(UInt solverIndex = 0) const;
 
  // #### Set component attributes during simulation ####
  // void setIdObjAttr(const String &comp, const String &attr, Real value);
  // void setIdObjAttr(const String &comp, const String &attr, Complex value);
 
  // #### Get component attributes during simulation ####
  CPS::AttributeBase::Ptr getIdObjAttribute(const String &comp,
                                            const String &attr);
 
  void logIdObjAttribute(const String &comp, const String &attr);
  void logAttribute(String name, CPS::AttributeBase::Ptr attr);
};
} // namespace DPsim