MNASolver.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 <bitset>
#include <iostream>
#include <list>
#include <unordered_map>
#include <vector>
 
#include <dpsim-models/AttributeList.h>
#include <dpsim-models/SimPowerComp.h>
#include <dpsim-models/SimSignalComp.h>
#include <dpsim-models/Solver/MNAInterface.h>
#include <dpsim-models/Solver/MNASwitchInterface.h>
#include <dpsim-models/Solver/MNASyncGenInterface.h>
#include <dpsim-models/Solver/MNAVariableCompInterface.h>
#include <dpsim/Config.h>
#include <dpsim/DataLogger.h>
#include <dpsim/MNAStateSpaceExtractor.h>
#include <dpsim/Solver.h>
 
/* std::size_t is the largest data type. No container can store
 * more than std::size_t elements. Define the number of switches
 * as the log_2 of this value so that we end up with maximally
 * std::size_t matrices. The overhead of statically defining this
 * value should be minimal.
 **/
#define SWITCH_NUM sizeof(std::size_t) * 8
 
namespace DPsim {
template <typename VarType> class MnaSolver : public Solver {
protected:
  // #### General simulation settings ####
  CPS::Domain mDomain;
  UInt mNumNodes = 0;
  UInt mNumNetNodes = 0;
  UInt mNumVirtualNodes = 0;
  UInt mNumMatrixNodeIndices = 0;
  UInt mNumNetMatrixNodeIndices = 0;
  UInt mNumVirtualMatrixNodeIndices = 0;
  UInt mNumHarmMatrixNodeIndices = 0;
  UInt mNumTotalMatrixNodeIndices = 0;
  std::vector<std::pair<UInt, UInt>> mListVariableSystemMatrixEntries;

  CPS::SystemTopology mSystem;
  typename CPS::SimNode<VarType>::List mNodes;
 
  // #### MNA specific attributes ####
  CPS::MNAInterface::List mMNAComponents;
  CPS::MNASwitchInterface::List mSwitches;
  CPS::MNAInterface::List mMNAIntfSwitches;
  CPS::SimSignalComp::List mSimSignalComps;
  std::bitset<SWITCH_NUM> mCurrentSwitchStatus;
  CPS::MNASyncGenInterface::List mSyncGen;

  Matrix mRightSideVector;
  std::vector<const Matrix *> mRightVectorStamps;
 
  // #### MNA specific attributes related to harmonics / additional frequencies ####
  std::vector<Matrix> mRightSideVectorHarm;
 
  // #### MNA specific attributes related to system recomputation
  Int mNumRecomputations = 0;
  CPS::MNAVariableCompInterface::List mVariableComps;
  CPS::MNAInterface::List mMNAIntfVariableComps;
 
  // #### Attributes related to switching ####
  UInt mSwitchTimeIndex = 0;
  std::vector<SwitchConfiguration> mSwitchEvents;
  void updateSwitchStatus();
 
  // #### Attributes related to logging ####
  Int mLastLogTimeStep = 0;
  std::shared_ptr<DataLogger> mLeftVectorLog;
  std::shared_ptr<DataLogger> mRightVectorLog;

  std::vector<Real> mFactorizeTimes;
  std::vector<Real> mSolveTimes;
  std::vector<Real> mRecomputationTimes;
 
  // #### State-space extraction ####
  Bool mStateSpaceExtraction = false;

  MNAStateSpaceExtractor::Ptr mStateSpaceExtractor;

  MnaSolver(String name, CPS::Domain domain = CPS::Domain::DP,
            CPS::Logger::Level logLevel = CPS::Logger::Level::info);

  void initializeComponents();
  virtual void initializeSystem();
  void initializeSystemWithParallelFrequencies();
  void initializeSystemWithPrecomputedMatrices();
  void initializeSystemWithVariableMatrix();
  void initializeStateSpaceExtractor();
  void identifyTopologyObjects();
  void resolveSystemMatrixRecomputationMode();
  void assignMatrixNodeIndices();
  void collectVirtualNodes();
  // TODO: check if this works with AC sources
  void steadyStateInitialization();

  void createEmptyVectors();
  virtual void createEmptySystemMatrix() = 0;
  virtual void switchedMatrixEmpty(std::size_t index) = 0;
  virtual void switchedMatrixEmpty(std::size_t swIdx, Int freqIdx) = 0;
  virtual void switchedMatrixStamp(
      std::size_t index,
      std::vector<std::shared_ptr<CPS::MNAInterface>> &comp) = 0;
  virtual void switchedMatrixStamp(std::size_t swIdx, Int freqIdx,
                                   CPS::MNAInterface::List &components,
                                   CPS::MNASwitchInterface::List &switches) {}

  Bool hasVariableComponentChanged();
 
  // #### Methods to implement for system recomputation over time ####
  virtual void stampVariableSystemMatrix() = 0;
  virtual void solveWithSystemMatrixRecomputation(Real time,
                                                  Int timeStepCount) = 0;
  virtual std::shared_ptr<CPS::Task> createSolveTaskRecomp() = 0;

  virtual void logSystemMatrices() = 0;

  virtual std::shared_ptr<CPS::Task> createSolveTask() = 0;
  virtual std::shared_ptr<CPS::Task> createLogTask() = 0;
  virtual std::shared_ptr<CPS::Task> createSolveTaskHarm(UInt freqIdx) = 0;
  virtual std::shared_ptr<CPS::Task> createStateSpaceExtractionTask() = 0;
 
  // #### Scheduler Task Methods ####
  virtual void solve(Real time, Int timeStepCount) = 0;
  virtual void solveWithHarmonics(Real time, Int timeStepCount,
                                  Int freqIdx) = 0;
  virtual void log(Real time, Int timeStepCount) override;
 
public:
  CPS::Attribute<Matrix>::Ptr mLeftSideVector;

  std::vector<CPS::Attribute<Matrix>::Ptr> mLeftSideVectorHarm;

  virtual ~MnaSolver() {
    if (mSystemMatrixRecomputationEnabled)
      SPDLOG_LOGGER_INFO(mSLog, "Number of system matrix recomputations: {:}",
                         mNumRecomputations);
  };

  virtual void initialize() override;
 
  // #### Setter and Getter ####
  virtual void setSystem(const CPS::SystemTopology &system) override;
  Matrix &leftSideVector() { return **mLeftSideVector; }
  Matrix &rightSideVector() { return mRightSideVector; }
  virtual CPS::Task::List getTasks() override;

  void doStateSpaceExtraction(Bool value = true);

  const MNAStateSpaceExtractor &getStateSpaceExtractor() const;
};
} // namespace DPsim