CircuitElements.hpp

Go to the documentation of this file.

#ifndef _CIRCUITELEMENTS_HPP_INC_
#define _CIRCUITELEMENTS_HPP_INC_
#include "CircuitElements/Resistor.hpp"
#include "CircuitElements/Capacitor.hpp"
#include "CircuitElements/NLCapacitor.hpp"
#include "CircuitElements/Inductor.hpp"
#include "CircuitElements/VoltageSource.hpp"
#include "CircuitElements/SinusoidalVoltageSource.hpp"
#include "CircuitElements/TimeSeriesVoltageSource.hpp"
#include "CircuitElements/CurrentSource.hpp"
#include "CircuitElements/BJT.hpp"
#include "CircuitElements/Diode.hpp"
#include "CircuitElements/SParameterBlock.hpp"
#include "CircuitElements/SParameterBlockVF.hpp"
#include "CircuitElements/NLNMOS.hpp"
#include "CircuitElements/NLCurrentSource.hpp"
 
#ifdef WITH_MATLAB
#include "MatlabEngine.hpp"
#include "MatlabDataArray.hpp"
#endif
 
enum class SolutionStage {
    StaticSolution = 0,
    DynamicSolution = 1,
    NonLinearSolution = 2
};
 
enum class ComponentType {
    Resistor,
    Capacitor,
    Inductor,
    VoltageSource,
    CurrentSource,
    BJT,
    Diode
};
 
 
template<typename T>
struct CircuitElements {
    Stamp<T> staticStamp;
    Stamp<T> dynamicStamp;
    Stamp<T> nonLinearStamp;
    Stamp<T> dcStamp;
 
#ifdef WITH_MATLAB
    std::shared_ptr<matlab::engine::MATLABEngine> matlabEngine;
#endif
 
    std::vector<std::shared_ptr<Component<T> > > staticElements;
    std::vector<std::shared_ptr<Component<T> > > dynamicElements;
    std::vector<std::shared_ptr<Component<T> > > nonLinearElements;
 
    bool staticStampIsFresh = false;
    bool dynamicStampIsFresh = false;
    bool nonLinearStampIsFresh = false;
 
    std::multimap<size_t, std::shared_ptr<Component<T> > > nodeComponentMap;
 
    CircuitElements(size_t numNodes = 0, size_t numCurrents = 0,
                    size_t numDCCurrents = 0)
        : staticStamp(numNodes, numCurrents), dynamicStamp(numNodes, numCurrents),
          nonLinearStamp(numNodes, numCurrents),
          dcStamp(numNodes, numCurrents + numDCCurrents) {
    }
 
    void
    setNewStampSize(size_t numNodes, size_t numCurrents, size_t numDCCurrents = 0) {
        staticStamp = Stamp<T>(numNodes, numCurrents);
        dynamicStamp = Stamp<T>(numNodes, numCurrents);
        nonLinearStamp = Stamp<T>(numNodes, numCurrents);
        dcStamp = Stamp<T>(numNodes, numCurrents + numDCCurrents);
        staticStampIsFresh = false;
        dynamicStampIsFresh = false;
        nonLinearStampIsFresh = false;
    }
 
    Stamp<T> & generateStaticStamp() {
        staticStamp.clear();
 
        for (const auto & component : staticElements) {
            staticStamp.addStaticStamp(component);
        }
 
        for (const auto & component : dynamicElements) {
            staticStamp.addStaticStamp(component);
        }
 
        for (const auto & component : nonLinearElements) {
            staticStamp.addStaticStamp(component);
        }
 
        staticStampIsFresh = true;
        return staticStamp;
    }
 
    Stamp<T> & generateDynamicStamp(const Matrix<T> & solutionMatrix,
                                    const size_t currentSolutionIndex, T timestep) {
        if (!staticStampIsFresh) {
            generateStaticStamp();
        }
        dynamicStamp = staticStamp;
 
        for (const auto & component : dynamicElements) {
            dynamicStamp.addDynamicStamp(component, solutionMatrix,
                                         currentSolutionIndex, timestep);
        }
 
        for (const auto & component : nonLinearElements) {
            dynamicStamp.addDynamicStamp(component, solutionMatrix,
                                         currentSolutionIndex, timestep);
        }
 
        dynamicStampIsFresh = true;
        return dynamicStamp;
    }
 
    Stamp<T> &
    generateNonLinearStamp(const Matrix<T> & solutionMatrix,
                           const size_t currentSolutionIndex, T timestep) {
        if (!dynamicStampIsFresh) {
            generateDynamicStamp(solutionMatrix, currentSolutionIndex, timestep);
        }
        nonLinearStamp = dynamicStamp;
 
        for (const auto & component : nonLinearElements) {
            nonLinearStamp.addNonLinearStamp(component, solutionMatrix,
                                             currentSolutionIndex, timestep);
        }
 
        nonLinearStampIsFresh = true;
        return nonLinearStamp;
    }
 
    Stamp<T> &
    generateCompleteStamp(SolutionStage stage, const Matrix<T> & solutionMatrix,
                          const size_t currentSolutionIndex, T timestep) {
        switch (stage) {
            case SolutionStage::StaticSolution:
                if (!staticStampIsFresh) {
                    generateStaticStamp()
                }
                return staticStamp;
                break;
 
            case SolutionStage::DynamicSolution:
                if (!dynamicStampIsFresh) {
                    generateDynamicStamp(solutionMatrix, currentSolutionIndex,
                                         timestep)
                }
                return dynamicStamp;
                break;
 
            case SolutionStage::NonLinearSolution:
                if (!nonLinearStampIsFresh) {
                    generateNonLinearStamp(solutionMatrix, currentSolutionIndex,
                                           timestep)
                }
                return nonLinearStamp;
                break;
        }
    }
 
    Stamp<T> &
    generateDCStamp(const Matrix<T> & solutionVector, size_t numCurrents) {
        dcStamp.clear();
 
        for (const auto & component : staticElements) {
            dcStamp.addDCAnalysisStamp(component, solutionVector, numCurrents);
        }
 
        for (const auto & component : dynamicElements) {
            dcStamp.addDCAnalysisStamp(component, solutionVector, numCurrents);
        }
 
        for (const auto & component : nonLinearElements) {
            dcStamp.addDCAnalysisStamp(component, solutionVector, numCurrents);
        }
 
        return dcStamp;
    }
 
    void updateTimeStep(const Matrix<T> & solutionMatrix,
                        const size_t currentSolutionIndex, T timestep) {
        dynamicStampIsFresh = false;
        nonLinearStampIsFresh = false;
        for (const auto & component : dynamicElements) {
            component->updateStoredState(solutionMatrix, currentSolutionIndex,
                                         timestep, staticStamp.sizeG_A);
        }
        for (const auto & component : nonLinearElements) {
            component->updateStoredState(solutionMatrix, currentSolutionIndex,
                                         timestep, staticStamp.sizeG_A);
        }
    }
 
    void updateDCStoredState(const Matrix<T> & solutionVector, size_t numCurrents) {
        for (const auto & component : staticElements) {
            component->updateDCStoredState(solutionVector, dcStamp.sizeG_A,
                                           numCurrents);
        }
        for (const auto & component : dynamicElements) {
            component->updateDCStoredState(solutionVector, dcStamp.sizeG_A,
                                           numCurrents);
        }
        for (const auto & component : nonLinearElements) {
            component->updateDCStoredState(solutionVector, dcStamp.sizeG_A,
                                           numCurrents);
        }
    }
};
 
#endif