Circuit.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Representation of electric circuit of overhead wires
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#ifdef HAVE_EIGEN
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4127 4464 5031)
#endif
// avoid warnings in clang
#ifdef __clang__
#pragma clang system_header
#endif
#include <Eigen/Dense>
#include <Eigen/Geometry>
#include <Eigen/Sparse>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif
 
#include "Element.h"
 
// ===========================================================================
// class declarations
// ===========================================================================
class Node;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class Circuit {
 
public:
    static void enforceCurrentLimits(const bool val) {
        myCurrentLimits = val;
    }
 
private:
 
    std::vector<Node*>* nodes;
    std::vector<Element*>* elements;
    std::vector<Element*>* voltageSources;
 
    int lastId;
    bool iscleaned;
 
    double circuitCurrentLimit;
 
    double alphaBest;
 
    static bool myCurrentLimits;
public:
    enum alphaFlag {
        ALPHA_NOT_APPLIED = 0,
        ALPHA_CURRENT_LIMITS,
        ALPHA_VOLTAGE_LIMITS,
        ALPHA_NOT_CONVERGING
    };
private:
    alphaFlag alphaReason;
 
public:
    Node* getNode(std::string name);
    Element* getElement(std::string name);
    Node* getNode(int id);
    Element* getVoltageSource(int id);
    std::vector<Element*>* getCurrentSources();
 
    double getTotalPowerOfCircuitSources();
    double getTotalCurrentOfCircuitSources();
    std::string& getCurrentsOfCircuitSource(std::string& currents);
 
    void lock();
    void unlock();
 
    double getAlphaBest() {
        return alphaBest;
    }
 
    alphaFlag getAlphaReason() {
        return alphaReason;
    }
 
private:
 
    Element* getElement(int id);
    /*
    *    detects removable nodes = sets node variable "isremovable" to true if node is removable and adds id of such node to "removable_ids" vector
    *    node is denoted as removable if it is connected just to 2 elements and both of them are resistor
    *    the reason is that in such case there are two serial resistor and we can only sum their resistance value
    *
    *    "removable_ids" vector is sort from the least to the greatest
    */
    void detectRemovableNodes(std::vector<int>* removable_ids);
 
    void deployResults(double* vals, std::vector<int>* removable_ids);
 
#ifdef HAVE_EIGEN
    /*
    *    creates all of the equations that represent the circuit
    *    in the form Ax = B(1/x) where A and B are matrices
    *    @param eqn : A
    *    @param vals : B
    */
    bool createEquationsNRmethod(double*& eqs, double*& vals, std::vector<int>* removable_ids);
 
    /*
    *    creates the nodal equation of the node 'node' GV = I
    *    in the form Ax = B(1/x) where A is a matrix with one row
    *    @param node : the node to be analyzed
    *    @param eqn : A
    *    @param val : B
    */
    bool createEquationNRmethod(Node* node, double* eqn, double& val, std::vector<int>* removable_ids);
 
    bool createEquation(Element* vsource, double* eqn, double& val);
 
    /*
     *    removes the "colToRemove"-th column from matrix "matrix"
     */
    void removeColumn(Eigen::MatrixXd& matrix, const int colToRemove);
 
    /*
     * solves the system of nonlinear equations Ax = B(1/x)
     * @param eqn : A
     * @param vals : B
     */
    bool solveEquationsNRmethod(double* eqn, double* vals, std::vector<int>*);
 
    bool _solveNRmethod();
 
#endif
public:
 
    // a Constructor, same functionality as "init" functions
    Circuit();
    // RICE_CHECK: Is this a traction substation current limit, global for all substations?
    Circuit(double currentLimit);
 
    // adds an element with name "name", type "type" and value "value" to positive node "pNode" and negative node "nNode""
    Element* addElement(std::string name, double value, Node* pNode, Node* nNode, Element::ElementType et);
 
    void eraseElement(Element* element);
 
    // adds a node with name "name"
    Node* addNode(std::string name);
 
    // erases a node with name "name"
    void eraseNode(Node* node);
 
    // gets current through element "name"
    double getCurrent(std::string name);
 
    // gets voltage across element or node "name"
    double getVoltage(std::string name);
 
    // gets the resistance of an element.
    double getResistance(std::string name);
 
    // gets the number of voltage sources in the circuit.
    int getNumVoltageSources();
 
    // checks if the circuit's connections are correct.
    bool checkCircuit(std::string substationId = "");
 
#ifdef HAVE_EIGEN
    // solves the circuit and deploys the results
    bool solve();
#endif
 
    // cleans up after superposition.
    void cleanUpSP();
 
    //replaces unusedNode with newNode everywhere in the circuit, modifies the ids of other nodes and elements, decreases the id by one and deletes unusedNode
    void replaceAndDeleteNode(Node* unusedNode, Node* newNode);
 
    // returns lastId
    int getLastId() {
        return lastId;
    };
 
    // decreases lastId by one
    void decreaseLastId() {
        lastId--;
    };
 
    void setCurrentLimit(double myCurrentLimit) {
        circuitCurrentLimit = myCurrentLimit;
    };
 
    double getCurrentLimit() {
        return circuitCurrentLimit;
    };
};