Element.h

Go to the documentation of this file.

 
#ifndef ELEMENT_H
#define ELEMENT_H
 
#include "../Constants.h"
#include "../Solver/Helper_Functions/Helper_Functions.h"
 
class Bus; // Forward declaration of Bus class
 
class Element {
public:
    Element(const std::string& symbol, const std::string& location, int inputPins, int outputPins)
        : element_symbol(symbol), element_location(location), input_pins(inputPins), output_pins(outputPins) {
        Y_matrix = createZeroMatrix(2*inputPins, 2*outputPins);
    }
 
    virtual ~Element();
 
    int getInputPins() const { return input_pins; }
 
    int getOutputPins() const { return output_pins; }
 
    void setInputPins(int pins) { input_pins = pins; }
 
    void setOutputPins(int pins) { output_pins = pins; }
 
    void setTransformation(bool flag) { transformation = flag; }
 
    std::string getElementSymbol() const { return element_symbol; }
 
    std::vector<Bus*> getBuses();
 
    int getBusIndex(Bus* bus) {
        auto it = connections.find(bus);
        if (it != connections.end()) {
            return it->second; // Return the index of the bus in the connections map
        }
        return -1; // Return -1 if the bus is not found
    }
 
    Bus* getOtherBus(Bus*);
 
    const std::map<Bus*, int>& getConnections() const { return connections; }
 
    std::map<Bus*, int> getConnections() { return connections; }
 
    string getElementLocation() const { return element_location; }
    
 
    void attachBus(Bus*, int);
 
    void printElementInfo() const {
        std::cout << "Element Symbol: " << element_symbol
            << ", Input Pins: " << input_pins
            << ", Output Pins: " << output_pins << std::endl;
    }
 
    virtual void printElementValues();
 
    void writeFile(double start_frequency, double end_frequency, int number_of_points);
 
    void plotYParameters(double start_frequency, double end_frequency, int number_of_points);
 
    virtual void plotEigenvalues() { 
        cout << "Eigenvalue plotting is not available for the linear element." << endl;
    };
 
    virtual void plotParticipationFactors() {
        cout << "Participation factors plotting is not available for the linear element." << endl;
    };
 
    virtual std::vector<std::vector<complex<double>>> compute_y_parameters(double frequency);
 
    virtual DenseMatrix get_y_parameters() { return Y_matrix; }; 
 
    virtual std::vector<std::vector<complex<double>>> apply_transformation(std::vector<std::vector<complex<double>>>& Y1, std::vector<std::vector<complex<double>>>& Y2);
 
    virtual void writeMNAmatrix(SymEngine::DenseMatrix&, std::unordered_map<Bus*, int>&, int, std::map<Element*, std::vector<RCP<const Basic>>>&) {};
 
    virtual int getNumberOfInternalStates() const { return 0; }
 
    virtual int getNumberOfPlantStates() const {
        return getNumberOfInternalStates();   // default: full state count
    }
 
    virtual std::vector<MatrixXcd> simulateInputStep(
        const std::vector<MatrixXcd>& states, int nKeep) const {
        return {};
    }
 
    virtual std::vector<RCP<const Basic>> getVirtualInputSymbols() const { return {}; }
 
    virtual map_basic_basic getParameterSubstitutions() const {return {}; }
 
    virtual void computePowerFlow(std::map<std::string, double>& branchData,
        std::map<std::string, double>& globalParams) const {
    }
 
    std::map<std::string, double> getOPFInfo() const {
        return element_OPF_info;
    }
 
    void setOPFInfo(std::map<std::string, double>& info) { element_OPF_info = info; }
 
protected:
    bool transformation = false; // Flag to indicate if a transformation is applied (e.g. three-phase to dq-frame)
 
    std::string element_symbol; // Element symbol (e.g., R, L, C)
    std::string element_location; // Element location (it can be AC1,2,... or DC1,2,... or PEC1,2,...)
    int input_pins; // Number of input pins/phases
    int output_pins;  // Number of output pins/phases
    std::map<Bus* , int> connections; // Map of bus connections to the element's terminal
    std::map<std::string, double> element_OPF_info = {};
 
    DenseMatrix Y_matrix; // Y-parameter matrix representing the admittance of the element
};
 
 
#endif // ELEMENT_H