Component.hpp

Go to the documentation of this file.

#ifndef _COMPONENT_HPP_INC_
#define _COMPONENT_HPP_INC_
#include "Maths/DynamicMatrix.hpp"
#include "CircuitElements/ElementsRegexBuilder.h"
#include <regex>
#include <algorithm>
#include <map>
 
template<typename T>
struct Component;
 
template<typename T>
struct Stamp {
    size_t sizeG_A;
    size_t sizeG_D;
 
    Matrix<T> G;
    Matrix<T> s;
 
    Stamp(size_t _sizeG_A, size_t _sizeG_D)
        : sizeG_A(_sizeG_A), sizeG_D(_sizeG_D),
          G(_sizeG_A + _sizeG_D, _sizeG_A + _sizeG_D, 0),
          s(_sizeG_A + _sizeG_D, 1, 0) {
    }
 
    void clear() {
        G.fill(0);
        s.fill(0);
    }
 
    void add(const Stamp<T> & rhs) {
        G.add(rhs.G, G);
        s.add(rhs.s, s);
    }
 
    void addStaticStamp(const std::shared_ptr<Component<T> > & rhs) {
        rhs->addStaticStampTo(*this);
    }
 
    void addDynamicStamp(const std::shared_ptr<Component<T> > & rhs,
                         const Matrix<T> & solutionMatrix,
                         const size_t currentSolutionIndex, T timestep) {
        rhs->addDynamicStampTo(*this, solutionMatrix, currentSolutionIndex,
                               timestep);
    }
 
    void addNonLinearStamp(const std::shared_ptr<Component<T> > & rhs,
                           const Matrix<T> & solutionMatrix,
                           const size_t currentSolutionIndex, T timestep = 0) {
        rhs->addNonLinearStampTo(*this, solutionMatrix, currentSolutionIndex,
                                 timestep);
    }
 
    void
    addDCAnalysisStamp(const std::shared_ptr<Component<T> > & rhs,
                       const Matrix<T> & solutionMatrix, const size_t numCurrents) {
        rhs->addDCAnalysisStampTo(*this, solutionMatrix, numCurrents);
    }
 
    Matrix<T> solve() {
        return G.leftDivide(s);
    }
};
 
template<typename T>
struct CircuitElements;
template<typename T>
struct Component {
    std::string designator = "";
 
    virtual void addStaticStampTo(Stamp<T> & destination) const {
    }
 
    virtual void
    addDynamicStampTo(Stamp<T> & destination, const Matrix<T> & solutionMatrix,
                      const size_t currentSolutionIndex, T timestep) const {
    }
 
    virtual void
    addNonLinearStampTo(Stamp<T> & destination, const Matrix<T> & solutionMatrix,
                        const size_t currentSolutionIndex, T timestep = 0) const {
        throw std::exception("not implemented");
    }
 
    virtual void updateStoredState(const Matrix<T> & solutionMatrix,
                                   const size_t currentSolutionIndex, T timestep,
                                   size_t numCurrents) {
    }
 
    virtual void
    addDCAnalysisStampTo(Stamp<T> & destination, const Matrix<T> & solutionVector,
                         size_t numCurrents) const {
        throw std::exception("not implemented");
    }
 
    virtual void updateDCStoredState(const Matrix<T> & solutionVector,
                                     size_t sizeG_A, size_t numCurrents) {
    }
 
    virtual void setTimestep(T timestep) {
    }
 
    static void
    addToElements(const std::string & line, CircuitElements<T> & elements,
                  size_t & numNodes, size_t & numCurrents, size_t & numDCCurrents) {
        throw std::exception("not implemented");
    }
 
    virtual ~Component() {};
};
 
#endif