Solver.h

Go to the documentation of this file.

/* Copyright 2017-2021 Institute for Automation of Complex Power Systems,
 *                     EONERC, RWTH Aachen University
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 *********************************************************************************/
 
#pragma once
 
#include <iostream>
#include <list>
#include <vector>
 
#include <dpsim-models/Logger.h>
#include <dpsim-models/SystemTopology.h>
#include <dpsim-models/Task.h>
#include <dpsim/Config.h>
#include <dpsim/Definitions.h>
#include <dpsim/DirectLinearSolverConfiguration.h>
 
namespace DPsim {
struct SwitchConfiguration {
  Real switchTime;
  UInt systemIndex;
};

class Solver {
public:
  typedef std::shared_ptr<Solver> Ptr;
  typedef std::vector<Ptr> List;
 
  enum Behaviour { Initialization, Simulation };

  enum class SystemMatrixRecomputationMode {
    Auto,
    Enabled,
    Disabled
  };
 
protected:
  String mName;
  CPS::Logger::Level mLogLevel;
  Bool mLogSolveTimes = true;
  CPS::Logger::Log mSLog;
  Real mTimeStep;
  Bool mFrequencyParallel = false;
 
  // #### Initialization ####
  Real mSteadStIniTimeLimit = 10;
  Real mSteadStIniAccLimit = 0.0001;
  Bool mSteadyStateInit = false;
  Bool mIsInInitialization = false;
  Bool mInitFromNodesAndTerminals = true;
  SystemMatrixRecomputationMode mSystemMatrixRecomputationMode =
      SystemMatrixRecomputationMode::Auto;
  Bool mSystemMatrixRecomputationEnabled = false;

  Behaviour mBehaviour = Solver::Behaviour::Simulation;
 
public:
  Solver(String name, CPS::Logger::Level logLevel)
      : mName(name), mLogLevel(logLevel),
        mSLog(CPS::Logger::get(name + "_Solver", logLevel,
                               CPS::Logger::Level::warn)) {}
 
  virtual ~Solver() {}
 
  // #### Solver settings ####
  enum class Type { MNA, DAE, NRP };
  void setTimeStep(Real timeStep) { mTimeStep = timeStep; }
  void doFrequencyParallelization(Bool freqParallel) {
    mFrequencyParallel = freqParallel;
  }

  virtual void setSystem(const CPS::SystemTopology &system) {}
  void setSystemMatrixRecomputationMode(SystemMatrixRecomputationMode mode) {
    mSystemMatrixRecomputationMode = mode;
  }

  void doSystemMatrixRecomputation(Bool value) {
    setSystemMatrixRecomputationMode(
        value ? SystemMatrixRecomputationMode::Enabled
              : SystemMatrixRecomputationMode::Disabled);
  }
 
  void setLogSolveTimes(Bool value) { mLogSolveTimes = value; }
 
  // #### Initialization ####
  virtual void initialize() {}
  void doSteadyStateInit(Bool f) { mSteadyStateInit = f; }
  void setSteadStIniTimeLimit(Real v) { mSteadStIniTimeLimit = v; }
  void setSteadStIniAccLimit(Real v) { mSteadStIniAccLimit = v; }
  virtual void setSolverAndComponentBehaviour(Solver::Behaviour behaviour) {}
  void doInitFromNodesAndTerminals(Bool f) { mInitFromNodesAndTerminals = f; }
  virtual void
  setDirectLinearSolverConfiguration(DirectLinearSolverConfiguration &) {
    // not every derived class has a linear solver configuration option
  }

  virtual void logLUTimes() {
    // no default implementation for all types of solvers
  }
 
  // #### Simulation ####
  virtual CPS::Task::List getTasks() = 0;
  virtual void log(Real time, Int timeStepCount){};

  int mMaxIterations = 10;
  void setMaxNumberOfIterations(int maxIterations) {
    mMaxIterations = maxIterations;
  }
};
} // namespace DPsim