SystemTopology.h

/* 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 <algorithm>
#include <vector>
 
#include <dpsim-models/SimNode.h>
#include <dpsim-models/SimPowerComp.h>
#include <dpsim-models/TopologicalPowerComp.h>
 
#ifdef WITH_GRAPHVIZ
#include <dpsim-models/Graph.h>
#endif
 
namespace CPS {
class SystemTopology {
public:
  using Ptr = std::shared_ptr<SystemTopology>;
 
  Matrix mFrequencies;
  TopologicalNode::List mNodes;
  IdentifiedObject::List mComponents;
  IdentifiedObject::List mTearComponents;
  std::map<TopologicalNode::Ptr, TopologicalPowerComp::List> mComponentsAtNode;
 
  // #### Deprecated ####
  // Better use mFrequencies
  Real mSystemFrequency;
  Real mSystemOmega;
 
  SystemTopology() {}
 
  SystemTopology(Real frequency)
      : mFrequencies(initFrequency(frequency)), mSystemFrequency(frequency),
        mSystemOmega(2 * PI * frequency) {}
 
  SystemTopology(Real frequency, IdentifiedObject::List components)
      : SystemTopology(frequency) {
    mComponents = components;
  }
 
  SystemTopology(Real frequency, TopologicalNode::List nodes,
                 IdentifiedObject::List components)
      : SystemTopology(frequency) {
    addNodes(nodes);
    addComponents(components);
    componentsAtNodeList();
  }
 
  SystemTopology(Real frequency, Matrix frequencies,
                 TopologicalNode::List nodes, IdentifiedObject::List components)
      : mFrequencies(frequencies), mSystemFrequency(frequency),
        mSystemOmega(2 * PI * frequency) {
    addNodes(nodes);
    addComponents(components);
    componentsAtNodeList();
  }
 
  Matrix initFrequency(Real frequency) const;
 
  void reset();
 
  // #### Add Objects to SystemTopology ####
 
  void addNode(TopologicalNode::Ptr topNode);
 
  void addNodeAt(TopologicalNode::Ptr topNode, UInt index);
 
  void addNodes(const TopologicalNode::List &topNodes);
 
  void addComponent(IdentifiedObject::Ptr component);
 
  template <typename VarType>
  void connectComponentToNodes(typename SimPowerComp<VarType>::Ptr component,
                               typename SimNode<VarType>::List simNodes);
 
  void componentsAtNodeList();
 
  void addComponents(const IdentifiedObject::List &components);
 
  void initWithPowerflow(const SystemTopology &systemPF, CPS::Domain domain);
 
  void addTearComponent(IdentifiedObject::Ptr component);
 
  void addTearComponents(const IdentifiedObject::List &components);
 
  // #### Get Objects from SystemTopology ####
 
  template <typename Type> typename std::shared_ptr<Type> node(UInt index);
 
  template <typename Type>
  typename std::shared_ptr<Type> node(std::string_view name);
 
  template <typename Type>
  typename std::shared_ptr<Type> component(const String &name) {
    for (auto comp : mComponents) {
      if (comp->name() == name) {
        auto comp2 = std::dynamic_pointer_cast<Type>(comp);
        if (comp2)
          return comp2;
        else
          return nullptr;
      }
    }
    return nullptr;
  }
 
  std::map<String, String, std::less<>> listIdObjects() const;
 
  // #### Operations on the SystemTopology ####
 
  void multiply(Int numberCopies);
 
  void removeComponent(const String &name);
 
  template <typename VarType>
  int checkTopologySubnets(
      std::unordered_map<typename CPS::SimNode<VarType>::Ptr, int> &subnet);
 
  template <typename VarType>
  void splitSubnets(std::vector<CPS::SystemTopology> &splitSystems);
 
#ifdef WITH_GRAPHVIZ
  Graph::Graph topologyGraph();
  String render();
  void renderToFile(String filename);
#endif
 
private:
  template <typename VarType> void multiplyPowerComps(Int numberCopies);
};
} // namespace CPS