SystemTopology.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 <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);
 
  void removeNode(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