From 7ff09073459904d88ed06af0a912f22dfedaf101 Mon Sep 17 00:00:00 2001 From: Canfirat98 Date: Fri, 28 Apr 2023 13:16:32 +0200 Subject: [PATCH 1/6] First implementation of class SimulationParameters Signed-off-by: Canfirat98 --- dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp | 3 + dpsim/include/dpsim/DiakopticsSolver.h | 1 + dpsim/include/dpsim/MNASolver.h | 8 + dpsim/include/dpsim/PFSolver.h | 2 +- dpsim/include/dpsim/Simulation.h | 61 +-- dpsim/include/dpsim/Solver.h | 53 +-- dpsim/include/dpsim/SolverParameters.h | 55 +++ dpsim/include/dpsim/SolverParametersDAE.h | 50 +++ dpsim/include/dpsim/SolverParametersMNA.h | 110 +++++ dpsim/include/dpsim/SolverParametersNRP.h | 50 +++ dpsim/src/CMakeLists.txt | 2 + dpsim/src/DiakopticsSolver.cpp | 2 +- dpsim/src/MNASolver.cpp | 481 +++++++++++---------- dpsim/src/Simulation.cpp | 56 ++- dpsim/src/SolverParameters.cpp | 31 ++ dpsim/src/SolverParametersMNA.cpp | 25 ++ examples/Notebooks/Circuits/CS_R2CL.ipynb | 2 +- 17 files changed, 662 insertions(+), 330 deletions(-) create mode 100644 dpsim/include/dpsim/SolverParameters.h create mode 100644 dpsim/include/dpsim/SolverParametersDAE.h create mode 100644 dpsim/include/dpsim/SolverParametersMNA.h create mode 100644 dpsim/include/dpsim/SolverParametersNRP.h create mode 100644 dpsim/src/SolverParameters.cpp create mode 100644 dpsim/src/SolverParametersMNA.cpp diff --git a/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp b/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp index a83fc348bf..c4d20e852a 100644 --- a/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp @@ -14,6 +14,8 @@ using namespace CPS::EMT::Ph1; int main(int argc, char* argv[]) { // Define simulation scenario + + SolverParametersMNA S_MNA; Real timeStep = 1e-4; Real finalTime = 1e-3; String simName = "EMT_CS_RL1"; @@ -50,6 +52,7 @@ int main(int argc, char* argv[]) { sim.setFinalTime(finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, S_MNA); sim.run(); diff --git a/dpsim/include/dpsim/DiakopticsSolver.h b/dpsim/include/dpsim/DiakopticsSolver.h index 47122ccc82..4406237f81 100644 --- a/dpsim/include/dpsim/DiakopticsSolver.h +++ b/dpsim/include/dpsim/DiakopticsSolver.h @@ -13,6 +13,7 @@ #include #include #include +#include #include diff --git a/dpsim/include/dpsim/MNASolver.h b/dpsim/include/dpsim/MNASolver.h index 8c748732fc..128d25038d 100644 --- a/dpsim/include/dpsim/MNASolver.h +++ b/dpsim/include/dpsim/MNASolver.h @@ -16,6 +16,8 @@ #include #include +#include +#include #include #include #include @@ -59,6 +61,10 @@ namespace DPsim { /// List of index pairs of varying matrix entries std::vector> mListVariableSystemMatrixEntries; + + using Solver::mSolverParams; + + /// System topology CPS::SystemTopology mSystem; /// List of simulation nodes @@ -211,6 +217,8 @@ namespace DPsim { Matrix& rightSideVector() { return mRightSideVector; } /// virtual CPS::Task::List getTasks() override; + /// + SolverParametersMNA* getMNAParameters() { return std::dynamic_pointer_cast(mSolverParams); } }; } diff --git a/dpsim/include/dpsim/PFSolver.h b/dpsim/include/dpsim/PFSolver.h index bfd00048a9..87ff0040e0 100644 --- a/dpsim/include/dpsim/PFSolver.h +++ b/dpsim/include/dpsim/PFSolver.h @@ -146,7 +146,7 @@ namespace DPsim { /// Allows to modify the powerflow bus type of a specific component void modifyPowerFlowBusComponent(CPS::String name, CPS::PowerflowBusType powerFlowBusType); /// set solver and component to initialization or simulation behaviour - void setSolverAndComponentBehaviour(Solver::Behaviour behaviour) override; + void setSolverAndComponentBehaviour(Solver::Behaviour behaviour); class SolveTask : public CPS::Task { public: diff --git a/dpsim/include/dpsim/Simulation.h b/dpsim/include/dpsim/Simulation.h index 9e50411f64..76438138d0 100644 --- a/dpsim/include/dpsim/Simulation.h +++ b/dpsim/include/dpsim/Simulation.h @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -44,16 +45,7 @@ namespace DPsim { /// Simulation timestep const CPS::Attribute::Ptr mTimeStep; - /// Determines if the network should be split - /// into subnetworks at decoupling lines. - /// If the system is split, each subsystem is - /// solved by a dedicated MNA solver. - const CPS::Attribute::Ptr mSplitSubnets; - /// Determines if steady-state initialization - /// should be executed prior to the simulation. - /// By default the initialization is disabled. - const CPS::Attribute::Ptr mSteadyStateInit; protected: /// Time variable that is incremented at every step @@ -84,35 +76,19 @@ namespace DPsim { /// Solver::Type mSolverType = Solver::Type::MNA; /// - Solver::Behaviour mSolverBehaviour = Solver::Behaviour::Simulation; - /// Solver::List mSolvers; /// - DirectLinearSolverImpl mDirectImpl = DirectLinearSolverImpl::Undef; - /// DirectLinearSolverConfiguration mDirectLinearSolverConfiguration; /// - Bool mInitFromNodesAndTerminals = true; - /// Enable recomputation of system matrix during simulation - Bool mSystemMatrixRecomputation = false; + SolverParameters* mSolverParams; + /// If tearing components exist, the Diakoptics /// solver is selected automatically. CPS::IdentifiedObject::List mTearComponents = CPS::IdentifiedObject::List(); - /// Determines if the system matrix is split into - /// several smaller matrices, one for each frequency. - /// This can only be done if the network is composed - /// of linear components that do no create cross - /// frequency coupling. - Bool mFreqParallel = false; /// Bool mInitialized = false; - // #### Initialization #### - /// steady state initialization time limit - Real mSteadStIniTimeLimit = 10; - /// steady state initialization accuracy limit - Real mSteadStIniAccLimit = 0.0001; // #### Task dependencies und scheduling #### /// Scheduler used for task scheduling @@ -173,38 +149,25 @@ namespace DPsim { void setDomain(CPS::Domain domain = CPS::Domain::DP) { mDomain = domain; } /// void setSolverType(Solver::Type solverType = Solver::Type::MNA) { mSolverType = solverType; } - /// set solver and component to initialization or simulation behaviour - void setSolverAndComponentBehaviour(Solver::Behaviour behaviour) { mSolverBehaviour = behaviour; } - /// - void setDirectLinearSolverImplementation(DirectLinearSolverImpl directImpl) { mDirectImpl = directImpl; } /// void setDirectLinearSolverConfiguration(const DirectLinearSolverConfiguration& configuration) { mDirectLinearSolverConfiguration = configuration; } /// - void setMaxNumberOfIterations(int maxIterations) {mMaxIterations = maxIterations;} - /// - void doInitFromNodesAndTerminals(Bool f = true) { mInitFromNodesAndTerminals = f; } - /// - void doSplitSubnets(Bool splitSubnets = true) { **mSplitSubnets = splitSubnets; } - /// void setTearingComponents(CPS::IdentifiedObject::List tearComponents = CPS::IdentifiedObject::List()) { mTearComponents = tearComponents; } + /// + void setSimulationParameters(CPS::Real a, CPS::Real b) {} + /// + void setSolverParameters(CPS::Domain domain, Solver::Type type, SolverParameters& solverParameters); + + /// Set the scheduling method void setScheduler(const std::shared_ptr &scheduler) { mScheduler = scheduler; } - /// Compute phasors of different frequencies in parallel - void doFrequencyParallelization(Bool value) { mFreqParallel = value; } - /// - void doSystemMatrixRecomputation(Bool value) { mSystemMatrixRecomputation = value; } - - // #### Initialization #### - /// activate steady state initialization - void doSteadyStateInit(Bool f) { **mSteadyStateInit = f; } - /// set steady state initialization time limit - void setSteadStIniTimeLimit(Real v) { mSteadStIniTimeLimit = v; } - /// set steady state initialization accuracy limit - void setSteadStIniAccLimit(Real v) { mSteadStIniAccLimit = v; } + + + // #### Simulation Control #### /// Create solver instances etc. diff --git a/dpsim/include/dpsim/Solver.h b/dpsim/include/dpsim/Solver.h index 61af394571..25c0d1b628 100644 --- a/dpsim/include/dpsim/Solver.h +++ b/dpsim/include/dpsim/Solver.h @@ -9,16 +9,20 @@ #pragma once #include +#include #include #include #include +#include #include #include #include #include #include +using namespace std; + namespace DPsim { /// Holds switching time and which system should be activated. struct SwitchConfiguration { @@ -41,28 +45,16 @@ namespace DPsim { CPS::Logger::Level mLogLevel; /// Logger CPS::Logger::Log mSLog; + /// Solver Parameters + SolverParameters* mSolverParams; /// Time step for fixed step solvers Real mTimeStep; - /// Activates parallelized computation of frequencies - Bool mFrequencyParallel = false; - + // #### Initialization #### - /// steady state initialization time limit - Real mSteadStIniTimeLimit = 10; - /// steady state initialization accuracy limit - Real mSteadStIniAccLimit = 0.0001; - /// Activates steady state initialization - Bool mSteadyStateInit = false; - /// Determines if solver is in initialization phase, which requires different behavior - Bool mIsInInitialization = false; - /// Activates powerflow initialization - /// If this is false, all voltages are initialized with zero - Bool mInitFromNodesAndTerminals = true; /// Enable recomputation of system matrix during simulation Bool mSystemMatrixRecomputation = false; - - /// Solver behaviour initialization or simulation - Behaviour mBehaviour = Solver::Behaviour::Simulation; + /// Determines if solver is in initialization phase, which requires different behavior + Bool mIsInInitialization = false; public: @@ -74,41 +66,26 @@ namespace DPsim { virtual ~Solver() { } + // #### Solver settings #### /// Solver types: /// Modified Nodal Analysis, Differential Algebraic, Newton Raphson enum class Type { MNA, DAE, NRP }; /// - void setTimeStep(Real timeStep) { - mTimeStep = timeStep; - } - /// - void doFrequencyParallelization(Bool freqParallel) { - mFrequencyParallel = freqParallel; - } /// virtual void setSystem(const CPS::SystemTopology &system) {} /// + void setTimeStep(Real timeStep) { mTimeStep = timeStep; } + /// void doSystemMatrixRecomputation(Bool value) { mSystemMatrixRecomputation = value; } + void setSolverParameters(SolverParameters& solverParameters){ mSolverParams = &solverParameters; } + // #### Initialization #### /// virtual void initialize() {} /// activate steady state initialization - void doSteadyStateInit(Bool f) { mSteadyStateInit = f; } - /// set steady state initialization time limit - void setSteadStIniTimeLimit(Real v) { mSteadStIniTimeLimit = v; } - /// set steady state initialization accuracy limit - void setSteadStIniAccLimit(Real v) { mSteadStIniAccLimit = v; } - /// set solver and component to initialization or simulation behaviour - virtual void setSolverAndComponentBehaviour(Solver::Behaviour behaviour) {} - /// activate powerflow initialization - void doInitFromNodesAndTerminals(Bool f) { mInitFromNodesAndTerminals = f; } - /// set direct linear solver configuration (only available in MNA for now) - virtual void setDirectLinearSolverConfiguration(DirectLinearSolverConfiguration&) - { - // not every derived class has a linear solver configuration option - } + /// log LU decomposition times, if applicable virtual void logLUTimes() { diff --git a/dpsim/include/dpsim/SolverParameters.h b/dpsim/include/dpsim/SolverParameters.h new file mode 100644 index 0000000000..05cfaa7a52 --- /dev/null +++ b/dpsim/include/dpsim/SolverParameters.h @@ -0,0 +1,55 @@ + +/* 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 +#include +#include + +#include +#include +#include +#include +#include +#include + +namespace DPsim { + + /// Base class for more specific solvers such as MNA, ODE or IDA. + class SolverParameters{ + protected: + /// Time step for fixed step solvers + const CPS::Attribute::Ptr mTimeStep; + + // #### Initialization #### + + /// If this is false, all voltages are initialized with zero + Bool mInitFromNodesAndTerminals = true; + + public: + + SolverParameters() {} + + virtual ~SolverParameters() { } + + void setTimeStep(Real timeStep) { **mTimeStep = timeStep; } + + // #### Initialization #### + /// activate powerflow initialization + void setInitFromNodesAndTerminals(Bool f) { mInitFromNodesAndTerminals = f; } + + + // #### Getter #### + Bool getTimeStep() {return **mTimeStep;} + + Bool getInitFromNodesAndTerminals() {return mInitFromNodesAndTerminals;} + + }; +} diff --git a/dpsim/include/dpsim/SolverParametersDAE.h b/dpsim/include/dpsim/SolverParametersDAE.h new file mode 100644 index 0000000000..92c8f9df97 --- /dev/null +++ b/dpsim/include/dpsim/SolverParametersDAE.h @@ -0,0 +1,50 @@ +// Attribute und Funktionen in einem anderen Branch + +#pragma once + +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace CPS; +using namespace DPsim; + +/* std::size_t is the largest data type. No container can store + * more than std::size_t elements. Define the number of switches + * as the log_2 of this value so that we end up with maximally + * std::size_t matrices. The overhead of statically defining this + * value should be minimal. + **/ +#define SWITCH_NUM sizeof(std::size_t)*8 + +namespace DPsim { + /// Solver class using Modified Nodal Analysis (MNA). + class SolverParametersDAE : public SolverParameters { + protected: + // #### General simulation settings #### + /// Simulation domain, which can be dynamic phasor (DP) or EMT + + + + public: + + /// Destructor + virtual ~SolverParametersDAE() {}; + + + }; +} diff --git a/dpsim/include/dpsim/SolverParametersMNA.h b/dpsim/include/dpsim/SolverParametersMNA.h new file mode 100644 index 0000000000..72106348eb --- /dev/null +++ b/dpsim/include/dpsim/SolverParametersMNA.h @@ -0,0 +1,110 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* std::size_t is the largest data type. No container can store + * more than std::size_t elements. Define the number of switches + * as the log_2 of this value so that we end up with maximally + * std::size_t matrices. The overhead of statically defining this + * value should be minimal. + **/ +#define SWITCH_NUM sizeof(std::size_t)*8 + +namespace DPsim { + /// Solver class using Modified Nodal Analysis (MNA). + class SolverParametersMNA : public SolverParameters { + protected: + // #### General simulation settings #### + /// Simulation domain, which can be dynamic phasor (DP) or EMT + CPS::Domain mDomain; + + Solver::Behaviour mSolverBehaviour = Solver::Behaviour::Simulation; + + /// Determines if the network should be split + /// into subnetworks at decoupling lines. + /// If the system is split, each subsystem is + /// solved by a dedicated MNA solver. + const CPS::Attribute::Ptr mSplitSubnets; + + /// Determines if the system matrix is split into + /// several smaller matrices, one for each frequency. + /// This can only be done if the network is composed + /// of linear components that do no create cross + /// frequency coupling. + Bool mFreqParallel = false; + + /// Enable recomputation of system matrix during simulation + Bool mSystemMatrixRecomputation = false; + + /// Determines if steady-state initialization + /// should be executed prior to the simulation. + /// By default the initialization is disabled. + const CPS::Attribute::Ptr mSteadyStateInit; + + // #### Initialization #### + /// steady state initialization time limit + Real mSteadStIniTimeLimit = 10; + /// steady state initialization accuracy limit + Real mSteadStIniAccLimit = 0.0001; + + DirectLinearSolverImpl mDirectImpl = DirectLinearSolverImpl::Undef; + + + + + public: + + SolverParametersMNA() {} + + /// Destructor + virtual ~SolverParametersMNA() {}; + + // #### Simulation Settings #### + /// + void setDomain(CPS::Domain domain = CPS::Domain::DP) { mDomain = domain; } + + void setSolverAndComponentBehaviour(Solver::Behaviour behaviour) { mSolverBehaviour = behaviour; } + /// + void doSplitSubnets(Bool splitSubnets = true) { **mSplitSubnets = splitSubnets; } + /// + /// Compute phasors of different frequencies in parallel + void doFrequencyParallelization(Bool value) { mFreqParallel = value; } + /// + void doSystemMatrixRecomputation(Bool value) { mSystemMatrixRecomputation = value; } + /// + void setDirectLinearSolverImplementation(DirectLinearSolverImpl directImpl) { mDirectImpl = directImpl; } + + + // #### Initialization #### + /// activate steady state initialization + void doSteadyStateInit(Bool f) { **mSteadyStateInit = f; } + /// set steady state initialization time limit + void setSteadStIniTimeLimit(Real v) { mSteadStIniTimeLimit = v; } + /// set steady state initialization accuracy limit + void setSteadStIniAccLimit(Real v) { mSteadStIniAccLimit = v; } + + // #### Getter #### + CPS::Bool getSplitSubnets() const { return **mSplitSubnets; } + CPS::Bool getFreqParallel() const { return mFreqParallel; } + CPS::Bool getSystemMatrixRecomputation() const { return mSystemMatrixRecomputation; } + CPS::Bool getSteadyStateInit() const { return **mSteadyStateInit; } + CPS::Real getSteadyStateInitTimeLimit() const { return mSteadStIniTimeLimit; } + CPS::Real getSteadyStateInitAccLimit() const { return mSteadStIniAccLimit; } + }; +} diff --git a/dpsim/include/dpsim/SolverParametersNRP.h b/dpsim/include/dpsim/SolverParametersNRP.h new file mode 100644 index 0000000000..fc396b837d --- /dev/null +++ b/dpsim/include/dpsim/SolverParametersNRP.h @@ -0,0 +1,50 @@ +// Attribute und Funktionen in einem anderen Branch + +#pragma once + +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace CPS; +using namespace DPsim; + +/* std::size_t is the largest data type. No container can store + * more than std::size_t elements. Define the number of switches + * as the log_2 of this value so that we end up with maximally + * std::size_t matrices. The overhead of statically defining this + * value should be minimal. + **/ +#define SWITCH_NUM sizeof(std::size_t)*8 + +namespace DPsim { + /// Solver class using Modified Nodal Analysis (MNA). + class SolverParametersNRP : public SolverParameters { + protected: + // #### General simulation settings #### + /// Simulation domain, which can be dynamic phasor (DP) or EMT + + + + public: + + /// Destructor + virtual ~SolverParametersNRP() {}; + + + }; +} diff --git a/dpsim/src/CMakeLists.txt b/dpsim/src/CMakeLists.txt index 195dc5c08e..23c8079c82 100644 --- a/dpsim/src/CMakeLists.txt +++ b/dpsim/src/CMakeLists.txt @@ -19,6 +19,8 @@ set(DPSIM_SOURCES ThreadListScheduler.cpp DiakopticsSolver.cpp Interface.cpp + SolverParameters.cpp + SolverParametersMNA.cpp ) list(APPEND DPSIM_LIBRARIES diff --git a/dpsim/src/DiakopticsSolver.cpp b/dpsim/src/DiakopticsSolver.cpp index bed9e6e2cc..eeeac6852c 100644 --- a/dpsim/src/DiakopticsSolver.cpp +++ b/dpsim/src/DiakopticsSolver.cpp @@ -26,7 +26,7 @@ DiakopticsSolver::DiakopticsSolver(String name, Solver(name, logLevel), mMappedTearCurrents(AttributeStatic::make()), mOrigLeftSideVector(AttributeStatic::make()) { - mTimeStep = timeStep; + mSolverParams->mTimeStep= timeStep; // Raw source and solution vector logging mLeftVectorLog = std::make_shared(name + "_LeftVector", logLevel != CPS::Logger::Level::off); diff --git a/dpsim/src/MNASolver.cpp b/dpsim/src/MNASolver.cpp index d5a5df8a46..79a4e660c0 100644 --- a/dpsim/src/MNASolver.cpp +++ b/dpsim/src/MNASolver.cpp @@ -8,6 +8,8 @@ #include +#include +#include #include #include @@ -16,14 +18,24 @@ using namespace CPS; namespace DPsim { +/*CPS::Bool mSolverParamsMNA->getFreqParallel() = mSolverParamsMNA->getFreqParallel(); +CPS::Bool mSolverParamsMNA->getInitFromNodesAndTerminals() = mSolverParamsMNA->getInitFromNodesAndTerminals(); +CPS::Bool mSolverParamsMNA->getSplitSubnets() = mSolverParamsMNA->getSplitSubnets(); + +CPS::Bool mSolverParamsMNA->getTimeStep() = mSolverParamsMNA->getTimeStep(); +CPS::Bool mSolverParamsMNA->getSystemMatrixRecomputation() = mSolverParamsMNA->getSystemMatrixRecomputation(); +CPS::Real mSolverParamsMNA->getSteadyStateInitTimeLimit() = mSolverParamsMNA->getSteadyStateInitTimeLimit();*/ + template MnaSolver::MnaSolver(String name, CPS::Domain domain, CPS::Logger::Level logLevel) : Solver(name, logLevel), mDomain(domain) { - + // Raw source and solution vector logging mLeftVectorLog = std::make_shared(name + "_LeftVector", logLevel != CPS::Logger::Level::off); mRightVectorLog = std::make_shared(name + "_RightVector", logLevel != CPS::Logger::Level::off); + + } template @@ -35,66 +47,69 @@ template void MnaSolver::initialize() { // TODO: check that every system matrix has the same dimensions SPDLOG_LOGGER_INFO(mSLog, "---- Start initialization ----"); - - // Register attribute for solution vector - ///FIXME: This is kinda ugly... At least we should somehow unify mLeftSideVector and mLeftSideVectorHarm. - // Best case we have some kind of sub-attributes for attribute vectors / tensor attributes... - if (mFrequencyParallel) { - SPDLOG_LOGGER_INFO(mSLog, "Computing network harmonics in parallel."); - for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { - mLeftSideVectorHarm.push_back(AttributeStatic::make()); + SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + + if (mSolverParamsMNA != nullptr) { + // Register attribute for solution vector + ///FIXME: This is kinda ugly... At least we should somehow unify mLeftSideVector and mLeftSideVectorHarm. + // Best case we have some kind of sub-attributes for attribute vectors / tensor attributes... + if ( mSolverParamsMNA->getFreqParallel()) { + SPDLOG_LOGGER_INFO(mSLog, "Computing network harmonics in parallel."); + for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { + mLeftSideVectorHarm.push_back(AttributeStatic::make()); + } + } + else { + mLeftSideVector = AttributeStatic::make(); } - } - else { - mLeftSideVector = AttributeStatic::make(); - } - SPDLOG_LOGGER_INFO(mSLog, "-- Process topology"); - for (auto comp : mSystem.mComponents) - SPDLOG_LOGGER_INFO(mSLog, "Added {:s} '{:s}' to simulation.", comp->type(), comp->name()); + SPDLOG_LOGGER_INFO(mSLog, "-- Process topology"); + for (auto comp : mSystem.mComponents) + SPDLOG_LOGGER_INFO(mSLog, "Added {:s} '{:s}' to simulation.", comp->type(), comp->name()); - // Otherwise LU decomposition will fail - if (mSystem.mComponents.size() == 0) - throw SolverException(); + // Otherwise LU decomposition will fail + if (mSystem.mComponents.size() == 0) + throw SolverException(); - // We need to differentiate between power and signal components and - // ground nodes should be ignored. - identifyTopologyObjects(); - // These steps complete the network information. - collectVirtualNodes(); - assignMatrixNodeIndices(); + // We need to differentiate between power and signal components and + // ground nodes should be ignored. + identifyTopologyObjects(); + // These steps complete the network information. + collectVirtualNodes(); + assignMatrixNodeIndices(); - SPDLOG_LOGGER_INFO(mSLog, "-- Create empty MNA system matrices and vectors"); - createEmptyVectors(); - createEmptySystemMatrix(); + SPDLOG_LOGGER_INFO(mSLog, "-- Create empty MNA system matrices and vectors"); + createEmptyVectors(); + createEmptySystemMatrix(); - // Initialize components from powerflow solution and - // calculate MNA specific initialization values. - initializeComponents(); + // Initialize components from powerflow solution and + // calculate MNA specific initialization values. + initializeComponents(); - if (mSteadyStateInit) { - mIsInInitialization = true; - steadyStateInitialization(); - } - mIsInInitialization = false; + if (mSteadyStateInit) { + mIsInInitialization = true; + steadyStateInitialization(); + } + mIsInInitialization = false; - // Some components feature a different behaviour for simulation and initialization - for (auto comp : mSystem.mComponents) { - auto powerComp = std::dynamic_pointer_cast(comp); - if (powerComp) powerComp->setBehaviour(TopologicalPowerComp::Behaviour::MNASimulation); + // Some components feature a different behaviour for simulation and initialization + for (auto comp : mSystem.mComponents) { + auto powerComp = std::dynamic_pointer_cast(comp); + if (powerComp) powerComp->setBehaviour(TopologicalPowerComp::Behaviour::MNASimulation); - auto sigComp = std::dynamic_pointer_cast(comp); - if (sigComp) sigComp->setBehaviour(SimSignalComp::Behaviour::Simulation); - } + auto sigComp = std::dynamic_pointer_cast(comp); + if (sigComp) sigComp->setBehaviour(SimSignalComp::Behaviour::Simulation); + } - // Initialize system matrices and source vector. - initializeSystem(); + // Initialize system matrices and source vector. + initializeSystem(); - SPDLOG_LOGGER_INFO(mSLog, "--- Initialization finished ---"); - SPDLOG_LOGGER_INFO(mSLog, "--- Initial system matrices and vectors ---"); - logSystemMatrices(); + SPDLOG_LOGGER_INFO(mSLog, "--- Initialization finished ---"); + SPDLOG_LOGGER_INFO(mSLog, "--- Initial system matrices and vectors ---"); + logSystemMatrices(); - mSLog->flush(); + mSLog->flush(); + } } template <> @@ -104,30 +119,33 @@ void MnaSolver::initializeComponents() { CPS::MNAInterface::List allMNAComps; allMNAComps.insert(allMNAComps.end(), mMNAComponents.begin(), mMNAComponents.end()); allMNAComps.insert(allMNAComps.end(), mMNAIntfVariableComps.begin(), mMNAIntfVariableComps.end()); + SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + + if (mSolverParamsMNA != nullptr) { + for (auto comp : allMNAComps) { + auto pComp = std::dynamic_pointer_cast>(comp); + if (!pComp) continue; + pComp->checkForUnconnectedTerminals(); + if (mSolverParamsMNA->getInitFromNodesAndTerminals()) + pComp->initializeFromNodesAndTerminals(mSystem.mSystemFrequency); + } - for (auto comp : allMNAComps) { - auto pComp = std::dynamic_pointer_cast>(comp); - if (!pComp) continue; - pComp->checkForUnconnectedTerminals(); - if (mInitFromNodesAndTerminals) - pComp->initializeFromNodesAndTerminals(mSystem.mSystemFrequency); - } - - // Initialize signal components. - for (auto comp : mSimSignalComps) - comp->initialize(mSystem.mSystemOmega, mTimeStep); + // Initialize signal components. + for (auto comp : mSimSignalComps) + comp->initialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep()); - // Initialize MNA specific parts of components. - for (auto comp : allMNAComps) { - comp->mnaInitialize(mSystem.mSystemOmega, mTimeStep, mLeftSideVector); - const Matrix& stamp = comp->getRightVector()->get(); - if (stamp.size() != 0) { - mRightVectorStamps.push_back(&stamp); + // Initialize MNA specific parts of components. + for (auto comp : allMNAComps) { + comp->mnaInitialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep(), mLeftSideVector); + const Matrix& stamp = comp->getRightVector()->get(); + if (stamp.size() != 0) { + mRightVectorStamps.push_back(&stamp); + } } - } - for (auto comp : mMNAIntfSwitches) - comp->mnaInitialize(mSystem.mSystemOmega, mTimeStep, mLeftSideVector); + for (auto comp : mMNAIntfSwitches) + comp->mnaInitialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep(), mLeftSideVector); + } } template <> @@ -137,46 +155,49 @@ void MnaSolver::initializeComponents() { CPS::MNAInterface::List allMNAComps; allMNAComps.insert(allMNAComps.end(), mMNAComponents.begin(), mMNAComponents.end()); allMNAComps.insert(allMNAComps.end(), mMNAIntfVariableComps.begin(), mMNAIntfVariableComps.end()); + SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + + if (mSolverParamsMNA != nullptr) { + // Initialize power components with frequencies and from powerflow results + for (auto comp : allMNAComps) { + auto pComp = std::dynamic_pointer_cast>(comp); + if (!pComp) continue; + pComp->checkForUnconnectedTerminals(); + if (mSolverParamsMNA->getInitFromNodesAndTerminals()) + pComp->initializeFromNodesAndTerminals(mSystem.mSystemFrequency); + } - // Initialize power components with frequencies and from powerflow results - for (auto comp : allMNAComps) { - auto pComp = std::dynamic_pointer_cast>(comp); - if (!pComp) continue; - pComp->checkForUnconnectedTerminals(); - if (mInitFromNodesAndTerminals) - pComp->initializeFromNodesAndTerminals(mSystem.mSystemFrequency); - } - - // Initialize signal components. - for (auto comp : mSimSignalComps) - comp->initialize(mSystem.mSystemOmega, mTimeStep); + // Initialize signal components. + for (auto comp : mSimSignalComps) + comp->initialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep()); - SPDLOG_LOGGER_INFO(mSLog, "-- Initialize MNA properties of components"); - if (mFrequencyParallel) { - // Initialize MNA specific parts of components. - for (auto comp : mMNAComponents) { + SPDLOG_LOGGER_INFO(mSLog, "-- Initialize MNA properties of components"); + if (mSolverParamsMNA->getFreqParallel()) { // Initialize MNA specific parts of components. - comp->mnaInitializeHarm(mSystem.mSystemOmega, mTimeStep, mLeftSideVectorHarm); - const Matrix& stamp = comp->getRightVector()->get(); - if (stamp.size() != 0) mRightVectorStamps.push_back(&stamp); - } - // Initialize nodes - for (UInt nodeIdx = 0; nodeIdx < mNodes.size(); ++nodeIdx) { - mNodes[nodeIdx]->mnaInitializeHarm(mLeftSideVectorHarm); - } - } - else { - // Initialize MNA specific parts of components. - for (auto comp : allMNAComps) { - comp->mnaInitialize(mSystem.mSystemOmega, mTimeStep, mLeftSideVector); - const Matrix& stamp = comp->getRightVector()->get(); - if (stamp.size() != 0) { - mRightVectorStamps.push_back(&stamp); + for (auto comp : mMNAComponents) { + // Initialize MNA specific parts of components. + comp->mnaInitializeHarm(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep(), mLeftSideVectorHarm); + const Matrix& stamp = comp->getRightVector()->get(); + if (stamp.size() != 0) mRightVectorStamps.push_back(&stamp); + } + // Initialize nodes + for (UInt nodeIdx = 0; nodeIdx < mNodes.size(); ++nodeIdx) { + mNodes[nodeIdx]->mnaInitializeHarm(mLeftSideVectorHarm); } } + else { + // Initialize MNA specific parts of components. + for (auto comp : allMNAComps) { + comp->mnaInitialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep(), mLeftSideVector); + const Matrix& stamp = comp->getRightVector()->get(); + if (stamp.size() != 0) { + mRightVectorStamps.push_back(&stamp); + } + } - for (auto comp : mMNAIntfSwitches) - comp->mnaInitialize(mSystem.mSystemOmega, mTimeStep, mLeftSideVector); + for (auto comp : mMNAIntfSwitches) + comp->mnaInitialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep(), mLeftSideVector); + } } } @@ -184,19 +205,21 @@ template void MnaSolver::initializeSystem() { SPDLOG_LOGGER_INFO(mSLog, "-- Initialize MNA system matrices and source vector"); mRightSideVector.setZero(); + SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + if (mSolverParamsMNA != nullptr) { + // just a sanity check in case we change the static + // initialization of the switch number in the future + if (mSwitches.size() > sizeof(std::size_t)*8) { + throw SystemError("Too many Switches."); + } - // just a sanity check in case we change the static - // initialization of the switch number in the future - if (mSwitches.size() > sizeof(std::size_t)*8) { - throw SystemError("Too many Switches."); + if (mSolverParamsMNA->getFreqParallel()) + initializeSystemWithParallelFrequencies(); + else if (mSolverParamsMNA->getSystemMatrixRecomputation()) + initializeSystemWithVariableMatrix(); + else + initializeSystemWithPrecomputedMatrices(); } - - if (mFrequencyParallel) - initializeSystemWithParallelFrequencies(); - else if (mSystemMatrixRecomputation) - initializeSystemWithVariableMatrix(); - else - initializeSystemWithPrecomputedMatrices(); } template @@ -378,15 +401,19 @@ void MnaSolver::createEmptyVectors() { template<> void MnaSolver::createEmptyVectors() { - if (mFrequencyParallel) { - for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { - mRightSideVectorHarm.push_back(Matrix::Zero(2*(mNumMatrixNodeIndices), 1)); - mLeftSideVectorHarm.push_back(AttributeStatic::make(Matrix::Zero(2*(mNumMatrixNodeIndices), 1))); + SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + + if (mSolverParamsMNA != nullptr) { + if (mSolverParamsMNA->getFreqParallel()) { + for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { + mRightSideVectorHarm.push_back(Matrix::Zero(2*(mNumMatrixNodeIndices), 1)); + mLeftSideVectorHarm.push_back(AttributeStatic::make(Matrix::Zero(2*(mNumMatrixNodeIndices), 1))); + } + } + else { + mRightSideVector = Matrix::Zero(2*(mNumMatrixNodeIndices + mNumHarmMatrixNodeIndices), 1); + **mLeftSideVector = Matrix::Zero(2*(mNumMatrixNodeIndices + mNumHarmMatrixNodeIndices), 1); } - } - else { - mRightSideVector = Matrix::Zero(2*(mNumMatrixNodeIndices + mNumHarmMatrixNodeIndices), 1); - **mLeftSideVector = Matrix::Zero(2*(mNumMatrixNodeIndices + mNumHarmMatrixNodeIndices), 1); } } @@ -446,136 +473,142 @@ void MnaSolver::collectVirtualNodes() { template void MnaSolver::steadyStateInitialization() { SPDLOG_LOGGER_INFO(mSLog, "--- Run steady-state initialization ---"); + SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + + if (mSolverParamsMNA != nullptr) { + DataLogger initLeftVectorLog(mName + "_InitLeftVector", mLogLevel != CPS::Logger::Level::off); + DataLogger initRightVectorLog(mName + "_InitRightVector", mLogLevel != CPS::Logger::Level::off); + + TopologicalPowerComp::Behaviour initBehaviourPowerComps = TopologicalPowerComp::Behaviour::Initialization; + SimSignalComp::Behaviour initBehaviourSignalComps = SimSignalComp::Behaviour::Initialization; + + // TODO: enable use of timestep distinct from simulation timestep + Real initTimeStep = mSolverParamsMNA->getTimeStep(); + Int timeStepCount = 0; + Real time = 0; + Real maxDiff = 1.0; + Real max = 1.0; + Matrix diff = Matrix::Zero(2 * mNumNodes, 1); + Matrix prevLeftSideVector = Matrix::Zero(2 * mNumNodes, 1); + + SPDLOG_LOGGER_INFO(mSLog, "Time step is {:f}s for steady-state initialization", initTimeStep); + + for (auto comp : mSystem.mComponents) { + auto powerComp = std::dynamic_pointer_cast(comp); + if (powerComp) powerComp->setBehaviour(initBehaviourPowerComps); - DataLogger initLeftVectorLog(mName + "_InitLeftVector", mLogLevel != CPS::Logger::Level::off); - DataLogger initRightVectorLog(mName + "_InitRightVector", mLogLevel != CPS::Logger::Level::off); - - TopologicalPowerComp::Behaviour initBehaviourPowerComps = TopologicalPowerComp::Behaviour::Initialization; - SimSignalComp::Behaviour initBehaviourSignalComps = SimSignalComp::Behaviour::Initialization; + auto sigComp = std::dynamic_pointer_cast(comp); + if (sigComp) sigComp->setBehaviour(initBehaviourSignalComps); + } - // TODO: enable use of timestep distinct from simulation timestep - Real initTimeStep = mTimeStep; + initializeSystem(); + logSystemMatrices(); - Int timeStepCount = 0; - Real time = 0; - Real maxDiff = 1.0; - Real max = 1.0; - Matrix diff = Matrix::Zero(2 * mNumNodes, 1); - Matrix prevLeftSideVector = Matrix::Zero(2 * mNumNodes, 1); + // Use sequential scheduler + SequentialScheduler sched; + CPS::Task::List tasks; + Scheduler::Edges inEdges, outEdges; - SPDLOG_LOGGER_INFO(mSLog, "Time step is {:f}s for steady-state initialization", initTimeStep); + for (auto node : mNodes) { + for (auto task : node->mnaTasks()) + tasks.push_back(task); + } + for (auto comp : mMNAComponents) { + for (auto task : comp->mnaTasks()) { + tasks.push_back(task); + } + } + // TODO signal components should be moved out of MNA solver + for (auto comp : mSimSignalComps) { + for (auto task : comp->getTasks()) { + tasks.push_back(task); + } + } + tasks.push_back(createSolveTask()); - for (auto comp : mSystem.mComponents) { - auto powerComp = std::dynamic_pointer_cast(comp); - if (powerComp) powerComp->setBehaviour(initBehaviourPowerComps); + sched.resolveDeps(tasks, inEdges, outEdges); + sched.createSchedule(tasks, inEdges, outEdges); - auto sigComp = std::dynamic_pointer_cast(comp); - if (sigComp) sigComp->setBehaviour(initBehaviourSignalComps); - } + while (time < mSolverParamsMNA->getSteadyStateInitTimeLimit()) { + // Reset source vector + mRightSideVector.setZero(); - initializeSystem(); - logSystemMatrices(); + sched.step(time, timeStepCount); - // Use sequential scheduler - SequentialScheduler sched; - CPS::Task::List tasks; - Scheduler::Edges inEdges, outEdges; + if (mDomain == CPS::Domain::EMT) { + initLeftVectorLog.logEMTNodeValues(time, leftSideVector()); + initRightVectorLog.logEMTNodeValues(time, rightSideVector()); + } + else { + initLeftVectorLog.logPhasorNodeValues(time, leftSideVector()); + initRightVectorLog.logPhasorNodeValues(time, rightSideVector()); + } - for (auto node : mNodes) { - for (auto task : node->mnaTasks()) - tasks.push_back(task); - } - for (auto comp : mMNAComponents) { - for (auto task : comp->mnaTasks()) { - tasks.push_back(task); - } - } - // TODO signal components should be moved out of MNA solver - for (auto comp : mSimSignalComps) { - for (auto task : comp->getTasks()) { - tasks.push_back(task); + // Calculate new simulation time + time = time + initTimeStep; + ++timeStepCount; + + // Calculate difference + diff = prevLeftSideVector - **mLeftSideVector; + prevLeftSideVector = **mLeftSideVector; + maxDiff = diff.lpNorm(); + max = (**mLeftSideVector).lpNorm(); + // If difference is smaller than some epsilon, break + if ((maxDiff / max) < mSolverParamsMNA->getSteadyStateInitAccLimit()) + break; } - } - tasks.push_back(createSolveTask()); - sched.resolveDeps(tasks, inEdges, outEdges); - sched.createSchedule(tasks, inEdges, outEdges); + SPDLOG_LOGGER_INFO(mSLog, "Max difference: {:f} or {:f}% at time {:f}", maxDiff, maxDiff / max, time); - while (time < mSteadStIniTimeLimit) { - // Reset source vector + // Reset system for actual simulation mRightSideVector.setZero(); - sched.step(time, timeStepCount); - - if (mDomain == CPS::Domain::EMT) { - initLeftVectorLog.logEMTNodeValues(time, leftSideVector()); - initRightVectorLog.logEMTNodeValues(time, rightSideVector()); - } - else { - initLeftVectorLog.logPhasorNodeValues(time, leftSideVector()); - initRightVectorLog.logPhasorNodeValues(time, rightSideVector()); - } - - // Calculate new simulation time - time = time + initTimeStep; - ++timeStepCount; - - // Calculate difference - diff = prevLeftSideVector - **mLeftSideVector; - prevLeftSideVector = **mLeftSideVector; - maxDiff = diff.lpNorm(); - max = (**mLeftSideVector).lpNorm(); - // If difference is smaller than some epsilon, break - if ((maxDiff / max) < mSteadStIniAccLimit) - break; + SPDLOG_LOGGER_INFO(mSLog, "--- Finished steady-state initialization ---"); } - - SPDLOG_LOGGER_INFO(mSLog, "Max difference: {:f} or {:f}% at time {:f}", maxDiff, maxDiff / max, time); - - // Reset system for actual simulation - mRightSideVector.setZero(); - - SPDLOG_LOGGER_INFO(mSLog, "--- Finished steady-state initialization ---"); } template Task::List MnaSolver::getTasks() { Task::List l; + SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); - for (auto comp : mMNAComponents) { - for (auto task : comp->mnaTasks()) { - l.push_back(task); + if (mSolverParamsMNA != nullptr) { + for (auto comp : mMNAComponents) { + for (auto task : comp->mnaTasks()) { + l.push_back(task); + } } - } - for (auto comp : mMNAIntfSwitches) { - for (auto task : comp->mnaTasks()) { - l.push_back(task); + for (auto comp : mMNAIntfSwitches) { + for (auto task : comp->mnaTasks()) { + l.push_back(task); + } } - } - for (auto node : mNodes) { - for (auto task : node->mnaTasks()) - l.push_back(task); - } - // TODO signal components should be moved out of MNA solver - for (auto comp : mSimSignalComps) { - for (auto task : comp->getTasks()) { - l.push_back(task); + for (auto node : mNodes) { + for (auto task : node->mnaTasks()) + l.push_back(task); } - } - if (mFrequencyParallel) { - for (UInt i = 0; i < mSystem.mFrequencies.size(); ++i) - l.push_back(createSolveTaskHarm(i)); - } else if (mSystemMatrixRecomputation) { - for (auto comp : this->mMNAIntfVariableComps) { - for (auto task : comp->mnaTasks()) + // TODO signal components should be moved out of MNA solver + for (auto comp : mSimSignalComps) { + for (auto task : comp->getTasks()) { l.push_back(task); + } + } + if (mSolverParamsMNA->getFreqParallel()) { + for (UInt i = 0; i < mSystem.mFrequencies.size(); ++i) + l.push_back(createSolveTaskHarm(i)); + } else if (mSolverParamsMNA->getSystemMatrixRecomputation()) { + for (auto comp : this->mMNAIntfVariableComps) { + for (auto task : comp->mnaTasks()) + l.push_back(task); + } + l.push_back(createSolveTaskRecomp()); + } else { + l.push_back(createSolveTask()); + l.push_back(createLogTask()); } - l.push_back(createSolveTaskRecomp()); - } else { - l.push_back(createSolveTask()); - l.push_back(createLogTask()); } return l; + } diff --git a/dpsim/src/Simulation.cpp b/dpsim/src/Simulation.cpp index a1c94d00c0..ab37b97941 100644 --- a/dpsim/src/Simulation.cpp +++ b/dpsim/src/Simulation.cpp @@ -6,6 +6,10 @@ #include #include +#include +#include +#include +#include #include #include #include @@ -32,8 +36,6 @@ Simulation::Simulation(String name, Logger::Level logLevel) : mName(AttributeStatic::make(name)), mFinalTime(AttributeStatic::make(0.001)), mTimeStep(AttributeStatic::make(0.001)), - mSplitSubnets(AttributeStatic::make(true)), - mSteadyStateInit(AttributeStatic::make(false)), mLogLevel(logLevel) { create(); } @@ -43,15 +45,36 @@ Simulation::Simulation(String name, CommandLineArgs& args) : mSolverPluginName(args.solverPluginName), mFinalTime(AttributeStatic::make(args.duration)), mTimeStep(AttributeStatic::make(args.timeStep)), - mSplitSubnets(AttributeStatic::make(true)), - mSteadyStateInit(AttributeStatic::make(false)), mLogLevel(args.logLevel), mDomain(args.solver.domain), - mSolverType(args.solver.type), - mDirectImpl(args.directImpl) { + mSolverType(args.solver.type) { create(); } +void Simulation::setSolverParameters(CPS::Domain domain, Solver::Type type, SolverParameters& solverParameters) +{ + mDomain = domain; + if ((typeid(solverParameters) == typeid(SolverParametersMNA)) && (type == Solver::Type::MNA)) { + cout << "Object is of type SolverParametersMNA" << endl; + mSolverParams = &solverParameters; + mSolverType = Solver::Type::MNA; + } + else if ((typeid(solverParameters) == typeid(SolverParametersDAE)) && (type == Solver::Type::DAE)) { + cout << "Object is of type SolverParametersMNA" << endl; + mSolverParams = &solverParameters; + mSolverType = Solver::Type::DAE; + } + else if ((typeid(solverParameters) == typeid(SolverParametersNRP)) && (type == Solver::Type::NRP)) { + cout << "Object is of type SolverParametersMNA" << endl; + mSolverParams = &solverParameters; + mSolverType = Solver::Type::NRP; + } + else { + cout << "Object is of unknown type" << endl; + mSolverParams = &solverParameters; + } +} + void Simulation::create() { // Logging mLog = Logger::get(**mName, mLogLevel, std::max(Logger::Level::info, mLogLevel)); @@ -131,7 +154,7 @@ void Simulation::createMNASolver() { std::vector subnets; // The Diakoptics solver splits the system at a later point. // That is why the system is not split here if tear components exist. - if (**mSplitSubnets && mTearComponents.size() == 0) + if (**(*mSolverParams.mSplitSubnets) && mTearComponents.size() == 0) mSystem.splitSubnets(subnets); else subnets.push_back(mSystem); @@ -151,16 +174,17 @@ void Simulation::createMNASolver() { // Default case with lu decomposition from mna factory solver = MnaSolverFactory::factory(**mName + copySuffix, mDomain, mLogLevel, mDirectImpl, mSolverPluginName); - solver->setTimeStep(**mTimeStep); - solver->doSteadyStateInit(**mSteadyStateInit); - solver->doFrequencyParallelization(mFreqParallel); - solver->setSteadStIniTimeLimit(mSteadStIniTimeLimit); - solver->setSteadStIniAccLimit(mSteadStIniAccLimit); + //solver->setTimeStep(**mTimeStep); + solver->setSolverParameters(*mSolverParams); + //solver->doSteadyStateInit(**mSteadyStateInit); + //solver->doFrequencyParallelization(mFreqParallel); + //solver->setSteadStIniTimeLimit(mSteadStIniTimeLimit); + //solver->setSteadStIniAccLimit(mSteadStIniAccLimit); solver->setSystem(subnets[net]); - solver->setSolverAndComponentBehaviour(mSolverBehaviour); - solver->doInitFromNodesAndTerminals(mInitFromNodesAndTerminals); - solver->doSystemMatrixRecomputation(mSystemMatrixRecomputation); - solver->setDirectLinearSolverConfiguration(mDirectLinearSolverConfiguration); + //solver->setSolverAndComponentBehaviour(mSolverBehaviour); + //solver->doInitFromNodesAndTerminals(mInitFromNodesAndTerminals); + //solver->doSystemMatrixRecomputation(mSystemMatrixRecomputation); + //solver->setDirectLinearSolverConfiguration(mDirectLinearSolverConfiguration); solver->initialize(); solver->setMaxNumberOfIterations(mMaxIterations); } diff --git a/dpsim/src/SolverParameters.cpp b/dpsim/src/SolverParameters.cpp new file mode 100644 index 0000000000..c68bf863d4 --- /dev/null +++ b/dpsim/src/SolverParameters.cpp @@ -0,0 +1,31 @@ +// SPDX-License-Identifier: Apache-2.0 + +#include +#include +#include +#include + + +#include +#include +#include + +#include + +#ifdef WITH_CIM + #include +#endif + +#ifdef WITH_SUNDIALS + #include + #include + #include +#endif + +using namespace CPS; +using namespace DPsim; + + +// Constructor +SolverParameters::SolverParameters(){} + diff --git a/dpsim/src/SolverParametersMNA.cpp b/dpsim/src/SolverParametersMNA.cpp new file mode 100644 index 0000000000..e16b2a72c5 --- /dev/null +++ b/dpsim/src/SolverParametersMNA.cpp @@ -0,0 +1,25 @@ +#include +#include +#include +#include + + +#include +#include +#include + +#include + +#ifdef WITH_CIM + #include +#endif + +#ifdef WITH_SUNDIALS + #include + #include + #include +#endif + +using namespace CPS; +using namespace DPsim; + diff --git a/examples/Notebooks/Circuits/CS_R2CL.ipynb b/examples/Notebooks/Circuits/CS_R2CL.ipynb index 7496d77402..1b84bd0f49 100644 --- a/examples/Notebooks/Circuits/CS_R2CL.ipynb +++ b/examples/Notebooks/Circuits/CS_R2CL.ipynb @@ -383,7 +383,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.9" + "version": "3.9.13" }, "tests": { "skip": false From 6f66dbdd7e0bbdb52706432bf92f091269efc20e Mon Sep 17 00:00:00 2001 From: Martin Moraga Date: Tue, 2 May 2023 13:46:47 +0200 Subject: [PATCH 2/6] Move DirectLinearSolverImpl to Definitions.f Signed-off-by: Martin Moraga --- .../include/dpsim-models/Definitions.h | 2 + .../cxx/CIM/DP_WSCC9bus_SGReducedOrderVBR.cpp | 2 +- .../cxx/CIM/EMT_WSCC-9bus_FullOrderSG.cpp | 2 +- dpsim/examples/cxx/CIM/EMT_WSCC-9bus_VBR.cpp | 2 +- .../CIM/EMT_WSCC9bus_SGReducedOrderVBR.cpp | 2 +- .../cxx/CIM/SP_WSCC9bus_SGReducedOrderVBR.cpp | 2 +- .../Circuits/DP_ReducedOrderSG_SMIB_Fault.cpp | 2 +- .../DP_ReducedOrderSG_VBR_Load_Fault.cpp | 2 +- dpsim/include/dpsim/MNASolverDirect.h | 16 ++---- dpsim/include/dpsim/MNASolverFactory.h | 50 +++++++++---------- dpsim/include/dpsim/SolverParameters.h | 11 +--- dpsim/include/dpsim/SolverParametersMNA.h | 30 ++--------- dpsim/include/dpsim/Utils.h | 7 +-- dpsim/src/MNASolverDirect.cpp | 12 ++--- dpsim/src/Utils.cpp | 18 +++---- 15 files changed, 61 insertions(+), 99 deletions(-) diff --git a/dpsim-models/include/dpsim-models/Definitions.h b/dpsim-models/include/dpsim-models/Definitions.h index 5d133673d9..283678893e 100644 --- a/dpsim-models/include/dpsim-models/Definitions.h +++ b/dpsim-models/include/dpsim-models/Definitions.h @@ -110,6 +110,8 @@ namespace CPS { enum class PowerflowBusType { PV, PQ, VD, None }; enum class GeneratorType {PVNode, IdealVoltageSource, IdealCurrentSource, TransientStability, FullOrder, FullOrderVBR, SG6aOrderVBR, SG6bOrderVBR, SG4OrderVBR, SG3OrderVBR, SG4OrderPCM, SG4OrderTPM, SG6OrderPCM, None}; enum class SGOrder {SG3Order, SG4Order, SG6aOrder, SG6bOrder}; + enum DirectLinearSolverImpl{Undef = 0, KLU, SparseLU, DenseLU, CUDADense, CUDASparse, CUDAMagma, Plugin }; + // ### Exceptions ### class Exception : public std::exception { }; diff --git a/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderVBR.cpp b/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderVBR.cpp index 84ff3df067..3b9179a820 100644 --- a/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderVBR.cpp +++ b/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderVBR.cpp @@ -29,7 +29,7 @@ int main(int argc, char *argv[]) { String faultBusName= "BUS6"; Real inertiaScalingFactor = 1.0; String logDirectory = "logs"; - DirectLinearSolverImpl implementation = DirectLinearSolverImpl::SparseLU; + CPS::DirectLinearSolverImpl implementation = CPS::DirectLinearSolverImpl::SparseLU; // Find CIM files std::list filenames; diff --git a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_FullOrderSG.cpp b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_FullOrderSG.cpp index 72424e32e3..725d2f133f 100644 --- a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_FullOrderSG.cpp +++ b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_FullOrderSG.cpp @@ -103,7 +103,7 @@ int main(int argc, char *argv[]) { sim.setSystem(sys); sim.setDomain(Domain::EMT); sim.setSolverType(Solver::Type::MNA); - sim.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + sim.setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); sim.setTimeStep(timeStep); sim.setFinalTime(finalTime); sim.addLogger(logger); diff --git a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_VBR.cpp b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_VBR.cpp index c686614adf..523521ee7f 100644 --- a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_VBR.cpp +++ b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_VBR.cpp @@ -20,7 +20,7 @@ int main(int argc, char *argv[]) { String simName = "EMT_WSCC-9bus_VBR"; Real timeStep; Real finalTime; - DirectLinearSolverImpl implementation = DirectLinearSolverImpl::SparseLU; + CPS::DirectLinearSolverImpl implementation = CPS::DirectLinearSolverImpl::SparseLU; // Find CIM files std::list filenames; diff --git a/dpsim/examples/cxx/CIM/EMT_WSCC9bus_SGReducedOrderVBR.cpp b/dpsim/examples/cxx/CIM/EMT_WSCC9bus_SGReducedOrderVBR.cpp index 95ceb78115..3caf872f9c 100644 --- a/dpsim/examples/cxx/CIM/EMT_WSCC9bus_SGReducedOrderVBR.cpp +++ b/dpsim/examples/cxx/CIM/EMT_WSCC9bus_SGReducedOrderVBR.cpp @@ -29,7 +29,7 @@ int main(int argc, char *argv[]) { String faultBusName= "BUS6"; Real inertiaScalingFactor = 1.0; String logDirectory = "logs"; - DirectLinearSolverImpl implementation = DirectLinearSolverImpl::SparseLU; + CPS::DirectLinearSolverImpl implementation = CPS::DirectLinearSolverImpl::SparseLU; // Find CIM files std::list filenames; diff --git a/dpsim/examples/cxx/CIM/SP_WSCC9bus_SGReducedOrderVBR.cpp b/dpsim/examples/cxx/CIM/SP_WSCC9bus_SGReducedOrderVBR.cpp index 655749b08a..aeb5f6692c 100644 --- a/dpsim/examples/cxx/CIM/SP_WSCC9bus_SGReducedOrderVBR.cpp +++ b/dpsim/examples/cxx/CIM/SP_WSCC9bus_SGReducedOrderVBR.cpp @@ -161,7 +161,7 @@ int main(int argc, char *argv[]) { sim.setTimeStep(timeStep); sim.setFinalTime(finalTime); sim.doSystemMatrixRecomputation(true); - sim.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + sim.setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); sim.addLogger(logger); // Optionally add switch event diff --git a/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_SMIB_Fault.cpp index 93188b502a..55c1b04bf7 100644 --- a/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_SMIB_Fault.cpp @@ -171,7 +171,7 @@ int main(int argc, char* argv[]) { simDP.setTimeStep(timeStep); simDP.setFinalTime(finalTime); simDP.setDomain(Domain::DP); - simDP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + simDP.setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); simDP.addLogger(loggerDP); simDP.doSystemMatrixRecomputation(true); diff --git a/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_VBR_Load_Fault.cpp b/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_VBR_Load_Fault.cpp index 47fa7d7cd3..cdbbd8528b 100644 --- a/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_VBR_Load_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_VBR_Load_Fault.cpp @@ -151,7 +151,7 @@ int main(int argc, char* argv[]) { simDP.setTimeStep(timeStep); simDP.setFinalTime(finalTime); simDP.setDomain(Domain::DP); - simDP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + simDP.setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); simDP.addLogger(loggerDP); simDP.doSystemMatrixRecomputation(true); diff --git a/dpsim/include/dpsim/MNASolverDirect.h b/dpsim/include/dpsim/MNASolverDirect.h index 1df04ac95a..c60485daa5 100644 --- a/dpsim/include/dpsim/MNASolverDirect.h +++ b/dpsim/include/dpsim/MNASolverDirect.h @@ -16,6 +16,7 @@ #include #include +#include #include #include #include @@ -44,17 +45,6 @@ namespace DPsim { - enum DirectLinearSolverImpl{ - Undef = 0, - KLU, - SparseLU, - DenseLU, - CUDADense, - CUDASparse, - CUDAMagma, - Plugin - }; - /// Solver class using Modified Nodal Analysis (MNA). template class MnaSolverDirect : public MnaSolver { @@ -74,7 +64,7 @@ namespace DPsim { /// LU factorization of variable system matrix std::shared_ptr mDirectLinearSolverVariableSystemMatrix; /// LU factorization indicator - DirectLinearSolverImpl mImplementationInUse; + CPS::DirectLinearSolverImpl mImplementationInUse; /// LU factorization configuration DirectLinearSolverConfiguration mConfigurationInUse; @@ -160,7 +150,7 @@ namespace DPsim { virtual ~MnaSolverDirect() = default; /// Sets the linear solver to "implementation" and creates an object - void setDirectLinearSolverImplementation(DirectLinearSolverImpl implementation); + void setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl implementation); /// Sets the linear solver configuration void setDirectLinearSolverConfiguration(DirectLinearSolverConfiguration& configuration); diff --git a/dpsim/include/dpsim/MNASolverFactory.h b/dpsim/include/dpsim/MNASolverFactory.h index 3c381eebd5..9881ff1a63 100644 --- a/dpsim/include/dpsim/MNASolverFactory.h +++ b/dpsim/include/dpsim/MNASolverFactory.h @@ -36,24 +36,24 @@ class MnaSolverFactory { public: /// MNA implementations supported by this compilation - static const std::vector mSupportedSolverImpls(void) { - static std::vector ret = { + static const std::vector mSupportedSolverImpls(void) { + static std::vector ret = { #ifdef WITH_MNASOLVERPLUGIN - DirectLinearSolverImpl::Plugin, + CPS::DirectLinearSolverImpl::Plugin, #endif //WITH_MNASOLVERPLUGIN #ifdef WITH_CUDA - DirectLinearSolverImpl::CUDADense, + CPS::DirectLinearSolverImpl::CUDADense, #ifdef WITH_CUDA_SPARSE #endif // WITH_CUDA_SPARSE - DirectLinearSolverImpl::CUDASparse, + CPS::DirectLinearSolverImpl::CUDASparse, #ifdef WITH_MAGMA - DirectLinearSolverImpl::CUDAMagma, + CPS::DirectLinearSolverImpl::CUDAMagma, #endif // WITH_MAGMA #endif // WITH_CUDA - DirectLinearSolverImpl::DenseLU, - DirectLinearSolverImpl::SparseLU, + CPS::DirectLinearSolverImpl::DenseLU, + CPS::DirectLinearSolverImpl::SparseLU, #ifdef WITH_KLU - DirectLinearSolverImpl::KLU + CPS::DirectLinearSolverImpl::KLU #endif //WITH_KLU }; return ret; @@ -64,12 +64,12 @@ class MnaSolverFactory { static std::shared_ptr> factory(String name, CPS::Domain domain = CPS::Domain::DP, CPS::Logger::Level logLevel = CPS::Logger::Level::info, - DirectLinearSolverImpl implementation = DirectLinearSolverImpl::SparseLU, + CPS::DirectLinearSolverImpl implementation = CPS::DirectLinearSolverImpl::SparseLU, String pluginName = "plugin.so") { //To avoid regression we use SparseLU in case of undefined implementation - if (implementation == DirectLinearSolverImpl::Undef) { - implementation = DirectLinearSolverImpl::SparseLU; + if (implementation == CPS::DirectLinearSolverImpl::Undef) { + implementation = CPS::DirectLinearSolverImpl::SparseLU; } CPS::Logger::Log log = CPS::Logger::get("MnaSolverFactory", CPS::Logger::Level::info, CPS::Logger::Level::info); @@ -77,58 +77,58 @@ class MnaSolverFactory { /* TODO: have only one "solver" object of type MnaSolverDirect and only use setDirectLinearSolverImplementation in the switch-case. * This is not done now, since MnaSolverDirect and MnaSolver are distinct classes - and someone might add another subclass of MnaSolver * to the project (MnaSolverIterative?). It is planned to merge MnaSolverDirect and MnaSolver anyway, so this won't happen. */ - case DirectLinearSolverImpl::SparseLU: + case CPS::DirectLinearSolverImpl::SparseLU: { log->info("creating SparseLUAdapter solver implementation"); std::shared_ptr> sparseSolver = std::make_shared>(name, domain, logLevel); - sparseSolver->setDirectLinearSolverImplementation(DirectLinearSolverImpl::SparseLU); + sparseSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); return sparseSolver; } - case DirectLinearSolverImpl::DenseLU: + case CPS::DirectLinearSolverImpl::DenseLU: { log->info("creating DenseLUAdapter solver implementation"); std::shared_ptr> denseSolver = std::make_shared>(name, domain, logLevel); - denseSolver->setDirectLinearSolverImplementation(DirectLinearSolverImpl::DenseLU); + denseSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::DenseLU); return denseSolver; } #ifdef WITH_KLU - case DirectLinearSolverImpl::KLU: + case CPS::DirectLinearSolverImpl::KLU: { log->info("creating KLUAdapter solver implementation"); std::shared_ptr> kluSolver = std::make_shared>(name, domain, logLevel); - kluSolver->setDirectLinearSolverImplementation(DirectLinearSolverImpl::KLU); + kluSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::KLU); return kluSolver; } #endif #ifdef WITH_CUDA - case DirectLinearSolverImpl::CUDADense: + case CPS::DirectLinearSolverImpl::CUDADense: { log->info("creating GpuDenseAdapter solver implementation"); std::shared_ptr> gpuDenseSolver = std::make_shared>(name, domain, logLevel); - gpuDenseSolver->setDirectLinearSolverImplementation(DirectLinearSolverImpl::CUDADense); + gpuDenseSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::CUDADense); return gpuDenseSolver; } #ifdef WITH_CUDA_SPARSE - case DirectLinearSolverImpl::CUDASparse: + case CPS::DirectLinearSolverImpl::CUDASparse: { log->info("creating GpuSparseAdapter solver implementation"); std::shared_ptr> gpuSparseSolver = std::make_shared>(name, domain, logLevel); - gpuSparseSolver->setDirectLinearSolverImplementation(DirectLinearSolverImpl::CUDASparse); + gpuSparseSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::CUDASparse); return gpuSparseSolver; } #endif #ifdef WITH_MAGMA - case DirectLinearSolverImpl::CUDAMagma: + case CPS::DirectLinearSolverImpl::CUDAMagma: { log->info("creating GpuMagmaAdapter solver implementation"); std::shared_ptr> gpuMagmaSolver = std::make_shared>(name, domain, logLevel); - gpuMagmaSolver->setDirectLinearSolverImplementation(DirectLinearSolverImpl::CUDAMagma); + gpuMagmaSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::CUDAMagma); return gpuMagmaSolver; } #endif #endif #ifdef WITH_MNASOLVERPLUGIN - case DirectLinearSolverImpl::Plugin: + case CPS::DirectLinearSolverImpl::Plugin: log->info("creating Plugin solver implementation"); return std::make_shared>(pluginName, name, domain, logLevel); #endif diff --git a/dpsim/include/dpsim/SolverParameters.h b/dpsim/include/dpsim/SolverParameters.h index 05cfaa7a52..fe5ae6e397 100644 --- a/dpsim/include/dpsim/SolverParameters.h +++ b/dpsim/include/dpsim/SolverParameters.h @@ -8,17 +8,8 @@ *********************************************************************************/ #pragma once - -#include -#include -#include - #include -#include -#include -#include -#include -#include +#include namespace DPsim { diff --git a/dpsim/include/dpsim/SolverParametersMNA.h b/dpsim/include/dpsim/SolverParametersMNA.h index 72106348eb..912fe98e0c 100644 --- a/dpsim/include/dpsim/SolverParametersMNA.h +++ b/dpsim/include/dpsim/SolverParametersMNA.h @@ -1,30 +1,8 @@ #pragma once -#include -#include -#include -#include -#include - -#include - -#include +#include +#include #include -#include -#include -#include -#include -#include -#include -#include - -/* std::size_t is the largest data type. No container can store - * more than std::size_t elements. Define the number of switches - * as the log_2 of this value so that we end up with maximally - * std::size_t matrices. The overhead of statically defining this - * value should be minimal. - **/ -#define SWITCH_NUM sizeof(std::size_t)*8 namespace DPsim { /// Solver class using Modified Nodal Analysis (MNA). @@ -63,7 +41,7 @@ namespace DPsim { /// steady state initialization accuracy limit Real mSteadStIniAccLimit = 0.0001; - DirectLinearSolverImpl mDirectImpl = DirectLinearSolverImpl::Undef; + CPS::DirectLinearSolverImpl mDirectImpl = CPS::DirectLinearSolverImpl::Undef; @@ -88,7 +66,7 @@ namespace DPsim { /// void doSystemMatrixRecomputation(Bool value) { mSystemMatrixRecomputation = value; } /// - void setDirectLinearSolverImplementation(DirectLinearSolverImpl directImpl) { mDirectImpl = directImpl; } + void setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl directImpl) { mDirectImpl = directImpl; } // #### Initialization #### diff --git a/dpsim/include/dpsim/Utils.h b/dpsim/include/dpsim/Utils.h index f2f745a0d4..8a45c98644 100644 --- a/dpsim/include/dpsim/Utils.h +++ b/dpsim/include/dpsim/Utils.h @@ -19,6 +19,7 @@ #include #include +#include #include #include #include @@ -62,7 +63,7 @@ class CommandLineArgs { Bool si = false, CPS::Domain sd = CPS::Domain::DP, Solver::Type st = Solver::Type::MNA, - DirectLinearSolverImpl mi = DirectLinearSolverImpl::SparseLU, + CPS::DirectLinearSolverImpl mi = CPS::DirectLinearSolverImpl::SparseLU, String spn = "plugin.so", String params = "default.json" ); @@ -80,7 +81,7 @@ class CommandLineArgs { Bool si = false, CPS::Domain sd = CPS::Domain::DP, Solver::Type st = Solver::Type::MNA, - DirectLinearSolverImpl mi = DirectLinearSolverImpl::SparseLU, + CPS::DirectLinearSolverImpl mi = CPS::DirectLinearSolverImpl::SparseLU, String spn = "plugin.so" ); @@ -106,7 +107,7 @@ class CommandLineArgs { CPS::Domain domain; Solver::Type type; } solver; - DPsim::DirectLinearSolverImpl directImpl; + CPS::DirectLinearSolverImpl directImpl; String solverPluginName; DPsim::Timer::StartClock::time_point startTime; diff --git a/dpsim/src/MNASolverDirect.cpp b/dpsim/src/MNASolverDirect.cpp index bb5e4adba5..5fa1c40791 100644 --- a/dpsim/src/MNASolverDirect.cpp +++ b/dpsim/src/MNASolverDirect.cpp @@ -390,23 +390,23 @@ template std::shared_ptr MnaSolverDirect::createDirectSolverImplementation(CPS::Logger::Log mSLog) { switch(this->mImplementationInUse) { - case DirectLinearSolverImpl::DenseLU: + case CPS::DirectLinearSolverImpl::DenseLU: return std::make_shared(mSLog); - case DirectLinearSolverImpl::SparseLU: + case CPS::DirectLinearSolverImpl::SparseLU: return std::make_shared(mSLog); #ifdef WITH_KLU - case DirectLinearSolverImpl::KLU: + case CPS::DirectLinearSolverImpl::KLU: return std::make_shared(mSLog); #endif #ifdef WITH_CUDA - case DirectLinearSolverImpl::CUDADense: + case CPS::DirectLinearSolverImpl::CUDADense: return std::make_shared(mSLog); #ifdef WITH_CUDA_SPARSE - case DirectLinearSolverImpl::CUDASparse: + case CPS::DirectLinearSolverImpl::CUDASparse: return std::make_shared(mSLog); #endif #ifdef WITH_MAGMA - case DirectLinearSolverImpl::CUDAMagma: + case CPS::DirectLinearSolverImpl::CUDAMagma: return std::make_shared(mSLog); #endif #endif diff --git a/dpsim/src/Utils.cpp b/dpsim/src/Utils.cpp index 047aee2890..b1982b3201 100644 --- a/dpsim/src/Utils.cpp +++ b/dpsim/src/Utils.cpp @@ -35,7 +35,7 @@ CommandLineArgs::CommandLineArgs(int argc, char *argv[], Bool si, CPS::Domain sd, Solver::Type st, - DirectLinearSolverImpl mi, + CPS::DirectLinearSolverImpl mi, String spn, String ps ) : @@ -91,7 +91,7 @@ CommandLineArgs::CommandLineArgs( Bool si, CPS::Domain sd, Solver::Type st, - DirectLinearSolverImpl mi, + CPS::DirectLinearSolverImpl mi, String spn ) : mProgramName("dpsim"), @@ -235,19 +235,19 @@ void CommandLineArgs::parseArguments(int argc, char *argv[]) case 'U': { String arg = optarg; if (arg == "DenseLU") { - directImpl = DirectLinearSolverImpl::DenseLU; + directImpl = CPS::DirectLinearSolverImpl::DenseLU; } else if (arg == "SparseLU") { - directImpl = DirectLinearSolverImpl::SparseLU; + directImpl = CPS::DirectLinearSolverImpl::SparseLU; } else if (arg == "KLU") { - directImpl = DirectLinearSolverImpl::KLU; + directImpl = CPS::DirectLinearSolverImpl::KLU; } else if (arg == "CUDADense") { - directImpl = DirectLinearSolverImpl::CUDADense; + directImpl = CPS::DirectLinearSolverImpl::CUDADense; } else if (arg == "CUDASparse") { - directImpl = DirectLinearSolverImpl::CUDASparse; + directImpl = CPS::DirectLinearSolverImpl::CUDASparse; } else if (arg == "CUDAMagma") { - directImpl = DirectLinearSolverImpl::CUDAMagma; + directImpl = CPS::DirectLinearSolverImpl::CUDAMagma; } else if (arg == "Plugin") { - directImpl = DirectLinearSolverImpl::Plugin; + directImpl = CPS::DirectLinearSolverImpl::Plugin; } else { throw std::invalid_argument("Invalid value for --solver-mna-impl"); } From 94eb90ed7b87b9fbf54116c887067ca7ae1c2045 Mon Sep 17 00:00:00 2001 From: Canfirat98 Date: Fri, 5 May 2023 14:37:00 +0200 Subject: [PATCH 3/6] Solve errors in last in first implementation of SolverParameters Signed-off-by: Canfirat98 --- dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp | 4 +- dpsim/include/dpsim/MNASolver.h | 5 +- dpsim/include/dpsim/MNASolverDirect.h | 8 +- dpsim/include/dpsim/PFSolver.h | 3 + dpsim/include/dpsim/Simulation.h | 4 +- dpsim/include/dpsim/Solver.h | 4 +- dpsim/include/dpsim/SolverParameters.h | 12 +-- dpsim/include/dpsim/SolverParametersMNA.h | 12 ++- dpsim/src/CMakeLists.txt | 2 - dpsim/src/DiakopticsSolver.cpp | 2 +- dpsim/src/MNASolver.cpp | 20 ++-- dpsim/src/MNASolverDirect.cpp | 107 +++++++++++---------- dpsim/src/PFSolver.cpp | 8 +- dpsim/src/Simulation.cpp | 86 +++++++++-------- dpsim/src/SolverParameters.cpp | 31 ------ dpsim/src/SolverParametersMNA.cpp | 25 ----- 16 files changed, 152 insertions(+), 181 deletions(-) delete mode 100644 dpsim/src/SolverParameters.cpp delete mode 100644 dpsim/src/SolverParametersMNA.cpp diff --git a/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp b/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp index c4d20e852a..c836c35ded 100644 --- a/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp @@ -15,7 +15,7 @@ using namespace CPS::EMT::Ph1; int main(int argc, char* argv[]) { // Define simulation scenario - SolverParametersMNA S_MNA; + std::shared_ptr mna_parameter = std::make_shared(); Real timeStep = 1e-4; Real finalTime = 1e-3; String simName = "EMT_CS_RL1"; @@ -52,7 +52,7 @@ int main(int argc, char* argv[]) { sim.setFinalTime(finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); - sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, S_MNA); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, mna_parameter); sim.run(); diff --git a/dpsim/include/dpsim/MNASolver.h b/dpsim/include/dpsim/MNASolver.h index 128d25038d..e0123d7a03 100644 --- a/dpsim/include/dpsim/MNASolver.h +++ b/dpsim/include/dpsim/MNASolver.h @@ -217,8 +217,9 @@ namespace DPsim { Matrix& rightSideVector() { return mRightSideVector; } /// virtual CPS::Task::List getTasks() override; - /// - SolverParametersMNA* getMNAParameters() { return std::dynamic_pointer_cast(mSolverParams); } + /// Gets Solver Parameters for Modified Nodal Analysis (MNA) + std::shared_ptr getMNAParameters() { return std::dynamic_pointer_cast(mSolverParams); } + }; } diff --git a/dpsim/include/dpsim/MNASolverDirect.h b/dpsim/include/dpsim/MNASolverDirect.h index c60485daa5..f655c205a1 100644 --- a/dpsim/include/dpsim/MNASolverDirect.h +++ b/dpsim/include/dpsim/MNASolverDirect.h @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -68,6 +69,7 @@ namespace DPsim { /// LU factorization configuration DirectLinearSolverConfiguration mConfigurationInUse; + using Solver::mSolverParams; using MnaSolver::mSwitches; using MnaSolver::mMNAIntfSwitches; using MnaSolver::mMNAComponents; @@ -82,9 +84,7 @@ namespace DPsim { using MnaSolver::mIsInInitialization; using MnaSolver::mRightSideVectorHarm; using MnaSolver::mLeftSideVectorHarm; - using MnaSolver::mFrequencyParallel; using MnaSolver::mSLog; - using MnaSolver::mSystemMatrixRecomputation; using MnaSolver::hasVariableComponentChanged; using MnaSolver::mNumRecomputations; using MnaSolver::mSyncGen; @@ -160,6 +160,10 @@ namespace DPsim { /// ### SynGen Interface ### int mIter = 0; + + /// Gets Solver Parameters for Modified Nodal Analysis (MNA) + std::shared_ptr getMNAParameters() { return std::dynamic_pointer_cast(mSolverParams); } + // #### MNA Solver Tasks #### /// diff --git a/dpsim/include/dpsim/PFSolver.h b/dpsim/include/dpsim/PFSolver.h index 87ff0040e0..58b36fc1f1 100644 --- a/dpsim/include/dpsim/PFSolver.h +++ b/dpsim/include/dpsim/PFSolver.h @@ -13,6 +13,7 @@ #include #include +#include #include "dpsim-models/SystemTopology.h" #include "dpsim-models/Components.h" @@ -147,6 +148,8 @@ namespace DPsim { void modifyPowerFlowBusComponent(CPS::String name, CPS::PowerflowBusType powerFlowBusType); /// set solver and component to initialization or simulation behaviour void setSolverAndComponentBehaviour(Solver::Behaviour behaviour); + /// Gets Solver Parameters for Modified Nodal Analysis (MNA) + std::shared_ptr getMNAParameters() { return std::dynamic_pointer_cast(mSolverParams); } class SolveTask : public CPS::Task { public: diff --git a/dpsim/include/dpsim/Simulation.h b/dpsim/include/dpsim/Simulation.h index 76438138d0..7654137a89 100644 --- a/dpsim/include/dpsim/Simulation.h +++ b/dpsim/include/dpsim/Simulation.h @@ -80,7 +80,7 @@ namespace DPsim { /// DirectLinearSolverConfiguration mDirectLinearSolverConfiguration; /// - SolverParameters* mSolverParams; + std::shared_ptr mSolverParams; /// If tearing components exist, the Diakoptics @@ -158,7 +158,7 @@ namespace DPsim { /// void setSimulationParameters(CPS::Real a, CPS::Real b) {} /// - void setSolverParameters(CPS::Domain domain, Solver::Type type, SolverParameters& solverParameters); + void setSolverParameters(CPS::Domain domain, Solver::Type type, std::shared_ptr &solverParameters); /// Set the scheduling method diff --git a/dpsim/include/dpsim/Solver.h b/dpsim/include/dpsim/Solver.h index 25c0d1b628..2d00b65c94 100644 --- a/dpsim/include/dpsim/Solver.h +++ b/dpsim/include/dpsim/Solver.h @@ -46,7 +46,7 @@ namespace DPsim { /// Logger CPS::Logger::Log mSLog; /// Solver Parameters - SolverParameters* mSolverParams; + std::shared_ptr mSolverParams; /// Time step for fixed step solvers Real mTimeStep; @@ -79,7 +79,7 @@ namespace DPsim { /// void doSystemMatrixRecomputation(Bool value) { mSystemMatrixRecomputation = value; } - void setSolverParameters(SolverParameters& solverParameters){ mSolverParams = &solverParameters; } + void setSolverParameters(std::shared_ptr &solverParameters){ mSolverParams = solverParameters; } // #### Initialization #### /// diff --git a/dpsim/include/dpsim/SolverParameters.h b/dpsim/include/dpsim/SolverParameters.h index fe5ae6e397..73232f52e3 100644 --- a/dpsim/include/dpsim/SolverParameters.h +++ b/dpsim/include/dpsim/SolverParameters.h @@ -15,22 +15,22 @@ namespace DPsim { /// Base class for more specific solvers such as MNA, ODE or IDA. class SolverParameters{ - protected: + public: /// Time step for fixed step solvers - const CPS::Attribute::Ptr mTimeStep; + Real mTimeStep; // #### Initialization #### /// If this is false, all voltages are initialized with zero Bool mInitFromNodesAndTerminals = true; - - public: + + SolverParameters() {} virtual ~SolverParameters() { } - void setTimeStep(Real timeStep) { **mTimeStep = timeStep; } + void setTimeStep(Real timeStep) { mTimeStep = timeStep; } // #### Initialization #### /// activate powerflow initialization @@ -38,7 +38,7 @@ namespace DPsim { // #### Getter #### - Bool getTimeStep() {return **mTimeStep;} + Real getTimeStep() {return mTimeStep;} Bool getInitFromNodesAndTerminals() {return mInitFromNodesAndTerminals;} diff --git a/dpsim/include/dpsim/SolverParametersMNA.h b/dpsim/include/dpsim/SolverParametersMNA.h index 912fe98e0c..98b9259aa3 100644 --- a/dpsim/include/dpsim/SolverParametersMNA.h +++ b/dpsim/include/dpsim/SolverParametersMNA.h @@ -4,10 +4,13 @@ #include #include +// using namespace CPS; + + namespace DPsim { /// Solver class using Modified Nodal Analysis (MNA). class SolverParametersMNA : public SolverParameters { - protected: + public: // #### General simulation settings #### /// Simulation domain, which can be dynamic phasor (DP) or EMT CPS::Domain mDomain; @@ -46,9 +49,12 @@ namespace DPsim { - public: + - SolverParametersMNA() {} + SolverParametersMNA(): + mSplitSubnets(CPS::AttributeStatic::make(true)), + mSteadyStateInit(CPS::AttributeStatic::make(false)) { + } /// Destructor virtual ~SolverParametersMNA() {}; diff --git a/dpsim/src/CMakeLists.txt b/dpsim/src/CMakeLists.txt index 23c8079c82..195dc5c08e 100644 --- a/dpsim/src/CMakeLists.txt +++ b/dpsim/src/CMakeLists.txt @@ -19,8 +19,6 @@ set(DPSIM_SOURCES ThreadListScheduler.cpp DiakopticsSolver.cpp Interface.cpp - SolverParameters.cpp - SolverParametersMNA.cpp ) list(APPEND DPSIM_LIBRARIES diff --git a/dpsim/src/DiakopticsSolver.cpp b/dpsim/src/DiakopticsSolver.cpp index eeeac6852c..1139086586 100644 --- a/dpsim/src/DiakopticsSolver.cpp +++ b/dpsim/src/DiakopticsSolver.cpp @@ -26,7 +26,7 @@ DiakopticsSolver::DiakopticsSolver(String name, Solver(name, logLevel), mMappedTearCurrents(AttributeStatic::make()), mOrigLeftSideVector(AttributeStatic::make()) { - mSolverParams->mTimeStep= timeStep; + mTimeStep= timeStep; // Raw source and solution vector logging mLeftVectorLog = std::make_shared(name + "_LeftVector", logLevel != CPS::Logger::Level::off); diff --git a/dpsim/src/MNASolver.cpp b/dpsim/src/MNASolver.cpp index 79a4e660c0..0feeccd12b 100644 --- a/dpsim/src/MNASolver.cpp +++ b/dpsim/src/MNASolver.cpp @@ -47,8 +47,8 @@ template void MnaSolver::initialize() { // TODO: check that every system matrix has the same dimensions SPDLOG_LOGGER_INFO(mSLog, "---- Start initialization ----"); - SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); - + auto mSolverParamsMNA = getMNAParameters(); + if (mSolverParamsMNA != nullptr) { // Register attribute for solution vector ///FIXME: This is kinda ugly... At least we should somehow unify mLeftSideVector and mLeftSideVectorHarm. @@ -86,7 +86,7 @@ void MnaSolver::initialize() { // calculate MNA specific initialization values. initializeComponents(); - if (mSteadyStateInit) { + if (mSolverParamsMNA->getSteadyStateInit()) { mIsInInitialization = true; steadyStateInitialization(); } @@ -119,7 +119,7 @@ void MnaSolver::initializeComponents() { CPS::MNAInterface::List allMNAComps; allMNAComps.insert(allMNAComps.end(), mMNAComponents.begin(), mMNAComponents.end()); allMNAComps.insert(allMNAComps.end(), mMNAIntfVariableComps.begin(), mMNAIntfVariableComps.end()); - SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + auto mSolverParamsMNA = getMNAParameters(); if (mSolverParamsMNA != nullptr) { for (auto comp : allMNAComps) { @@ -155,7 +155,7 @@ void MnaSolver::initializeComponents() { CPS::MNAInterface::List allMNAComps; allMNAComps.insert(allMNAComps.end(), mMNAComponents.begin(), mMNAComponents.end()); allMNAComps.insert(allMNAComps.end(), mMNAIntfVariableComps.begin(), mMNAIntfVariableComps.end()); - SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + auto mSolverParamsMNA = getMNAParameters(); if (mSolverParamsMNA != nullptr) { // Initialize power components with frequencies and from powerflow results @@ -205,7 +205,7 @@ template void MnaSolver::initializeSystem() { SPDLOG_LOGGER_INFO(mSLog, "-- Initialize MNA system matrices and source vector"); mRightSideVector.setZero(); - SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + auto mSolverParamsMNA = getMNAParameters(); if (mSolverParamsMNA != nullptr) { // just a sanity check in case we change the static // initialization of the switch number in the future @@ -401,8 +401,8 @@ void MnaSolver::createEmptyVectors() { template<> void MnaSolver::createEmptyVectors() { - SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); - + auto mSolverParamsMNA = getMNAParameters(); + if (mSolverParamsMNA != nullptr) { if (mSolverParamsMNA->getFreqParallel()) { for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { @@ -473,7 +473,7 @@ void MnaSolver::collectVirtualNodes() { template void MnaSolver::steadyStateInitialization() { SPDLOG_LOGGER_INFO(mSLog, "--- Run steady-state initialization ---"); - SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + auto mSolverParamsMNA = getMNAParameters(); if (mSolverParamsMNA != nullptr) { DataLogger initLeftVectorLog(mName + "_InitLeftVector", mLogLevel != CPS::Logger::Level::off); @@ -570,7 +570,7 @@ void MnaSolver::steadyStateInitialization() { template Task::List MnaSolver::getTasks() { Task::List l; - SolverParametersMNA* mSolverParamsMNA = getMNAParameters(); + auto mSolverParamsMNA = getMNAParameters(); if (mSolverParamsMNA != nullptr) { for (auto comp : mMNAComponents) { diff --git a/dpsim/src/MNASolverDirect.cpp b/dpsim/src/MNASolverDirect.cpp index 5fa1c40791..b4c0a99eb4 100644 --- a/dpsim/src/MNASolverDirect.cpp +++ b/dpsim/src/MNASolverDirect.cpp @@ -149,43 +149,49 @@ void MnaSolverDirect::recomputeSystemMatrix(Real time) { template<> void MnaSolverDirect::createEmptySystemMatrix() { - if (mSwitches.size() > SWITCH_NUM) - throw SystemError("Too many Switches."); - - if (mSystemMatrixRecomputation) { - mBaseSystemMatrix = SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices); - mVariableSystemMatrix = SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices); - } else { - for (std::size_t i = 0; i < (1ULL << mSwitches.size()); i++){ - auto bit = std::bitset(i); - mSwitchedMatrices[bit].push_back(SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices)); - mDirectLinearSolvers[bit].push_back(createDirectSolverImplementation(mSLog)); + auto mSolverParamsMNA = getMNAParameters(); + if (mSolverParamsMNA != nullptr) { + if (mSwitches.size() > SWITCH_NUM) + throw SystemError("Too many Switches."); + + if (mSolverParamsMNA->mSystemMatrixRecomputation) { + mBaseSystemMatrix = SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices); + mVariableSystemMatrix = SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices); + } else { + for (std::size_t i = 0; i < (1ULL << mSwitches.size()); i++){ + auto bit = std::bitset(i); + mSwitchedMatrices[bit].push_back(SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices)); + mDirectLinearSolvers[bit].push_back(createDirectSolverImplementation(mSLog)); + } } } } template<> void MnaSolverDirect::createEmptySystemMatrix() { - if (mSwitches.size() > SWITCH_NUM) - throw SystemError("Too many Switches."); - - if (mFrequencyParallel) { - for (UInt i = 0; i < std::pow(2,mSwitches.size()); ++i) { - for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { + auto mSolverParamsMNA = getMNAParameters(); + if (mSolverParamsMNA != nullptr) { + if (mSwitches.size() > SWITCH_NUM) + throw SystemError("Too many Switches."); + + if (mSolverParamsMNA->mFreqParallel) { + for (UInt i = 0; i < std::pow(2,mSwitches.size()); ++i) { + for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { + auto bit = std::bitset(i); + mSwitchedMatrices[bit].push_back(SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices))); + mDirectLinearSolvers[bit].push_back(createDirectSolverImplementation(mSLog)); + } + } + } else if (mSolverParamsMNA->mSystemMatrixRecomputation) { + mBaseSystemMatrix = SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices)); + mVariableSystemMatrix = SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices)); + } else { + for (std::size_t i = 0; i < (1ULL << mSwitches.size()); i++) { auto bit = std::bitset(i); - mSwitchedMatrices[bit].push_back(SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices))); + mSwitchedMatrices[bit].push_back(SparseMatrix(2*(mNumTotalMatrixNodeIndices), 2*(mNumTotalMatrixNodeIndices))); mDirectLinearSolvers[bit].push_back(createDirectSolverImplementation(mSLog)); } } - } else if (mSystemMatrixRecomputation) { - mBaseSystemMatrix = SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices)); - mVariableSystemMatrix = SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices)); - } else { - for (std::size_t i = 0; i < (1ULL << mSwitches.size()); i++) { - auto bit = std::bitset(i); - mSwitchedMatrices[bit].push_back(SparseMatrix(2*(mNumTotalMatrixNodeIndices), 2*(mNumTotalMatrixNodeIndices))); - mDirectLinearSolvers[bit].push_back(createDirectSolverImplementation(mSLog)); - } } } @@ -305,34 +311,37 @@ void MnaSolverDirect::solveWithHarmonics(Real time, Int timeStepCount, template void MnaSolverDirect::logSystemMatrices() { - if (mFrequencyParallel) { - for (UInt i = 0; i < mSwitchedMatrices[std::bitset(0)].size(); ++i) { - SPDLOG_LOGGER_INFO(mSLog, "System matrix for frequency: {:d} \n{:s}", i, Logger::matrixToString(mSwitchedMatrices[std::bitset(0)][i])); - } + auto mSolverParamsMNA = getMNAParameters(); + if (mSolverParamsMNA != nullptr) { + if (mSolverParamsMNA->mFreqParallel) { + for (UInt i = 0; i < mSwitchedMatrices[std::bitset(0)].size(); ++i) { + SPDLOG_LOGGER_INFO(mSLog, "System matrix for frequency: {:d} \n{:s}", i, Logger::matrixToString(mSwitchedMatrices[std::bitset(0)][i])); + } - for (UInt i = 0; i < mRightSideVectorHarm.size(); ++i) { - SPDLOG_LOGGER_INFO(mSLog, "Right side vector for frequency: {:d} \n{:s}", i, Logger::matrixToString(mRightSideVectorHarm[i])); - } + for (UInt i = 0; i < mRightSideVectorHarm.size(); ++i) { + SPDLOG_LOGGER_INFO(mSLog, "Right side vector for frequency: {:d} \n{:s}", i, Logger::matrixToString(mRightSideVectorHarm[i])); + } - } - else if (mSystemMatrixRecomputation) { - SPDLOG_LOGGER_INFO(mSLog, "Summarizing matrices: "); - SPDLOG_LOGGER_INFO(mSLog, "Base matrix with only static elements: {}", Logger::matrixToString(mBaseSystemMatrix)); - SPDLOG_LOGGER_INFO(mSLog, "Initial system matrix with variable elements {}", Logger::matrixToString(mVariableSystemMatrix)); - SPDLOG_LOGGER_INFO(mSLog, "Right side vector: {}", Logger::matrixToString(mRightSideVector)); - } else { - if (mSwitches.size() < 1) { - SPDLOG_LOGGER_INFO(mSLog, "System matrix: \n{}", mSwitchedMatrices[std::bitset(0)][0]); } - else { - SPDLOG_LOGGER_INFO(mSLog, "Initial switch status: {:s}", mCurrentSwitchStatus.to_string()); + else if (mSolverParamsMNA->mSystemMatrixRecomputation) { + SPDLOG_LOGGER_INFO(mSLog, "Summarizing matrices: "); + SPDLOG_LOGGER_INFO(mSLog, "Base matrix with only static elements: {}", Logger::matrixToString(mBaseSystemMatrix)); + SPDLOG_LOGGER_INFO(mSLog, "Initial system matrix with variable elements {}", Logger::matrixToString(mVariableSystemMatrix)); + SPDLOG_LOGGER_INFO(mSLog, "Right side vector: {}", Logger::matrixToString(mRightSideVector)); + } else { + if (mSwitches.size() < 1) { + SPDLOG_LOGGER_INFO(mSLog, "System matrix: \n{}", mSwitchedMatrices[std::bitset(0)][0]); + } + else { + SPDLOG_LOGGER_INFO(mSLog, "Initial switch status: {:s}", mCurrentSwitchStatus.to_string()); - for (auto sys : mSwitchedMatrices) { - SPDLOG_LOGGER_INFO(mSLog, "Switching System matrix {:s} \n{:s}", - sys.first.to_string(), Logger::matrixToString(sys.second[0])); + for (auto sys : mSwitchedMatrices) { + SPDLOG_LOGGER_INFO(mSLog, "Switching System matrix {:s} \n{:s}", + sys.first.to_string(), Logger::matrixToString(sys.second[0])); + } } + SPDLOG_LOGGER_INFO(mSLog, "Right side vector: \n{}", mRightSideVector); } - SPDLOG_LOGGER_INFO(mSLog, "Right side vector: \n{}", mRightSideVector); } } diff --git a/dpsim/src/PFSolver.cpp b/dpsim/src/PFSolver.cpp index aeea54d6b2..480f9cd6e3 100644 --- a/dpsim/src/PFSolver.cpp +++ b/dpsim/src/PFSolver.cpp @@ -65,6 +65,7 @@ void PFSolver::assignMatrixNodeIndices() { } void PFSolver::initializeComponents(){ + std::shared_ptr mSolverParamsMNA = getMNAParameters(); for (auto comp : mSystem.mComponents) { std::dynamic_pointer_cast>(comp)->updateMatrixNodeIndices(); } @@ -73,7 +74,7 @@ void PFSolver::initializeComponents(){ for (auto comp : mSystem.mComponents) { auto pComp = std::dynamic_pointer_cast>(comp); if (!pComp) continue; - if (mInitFromNodesAndTerminals) + if (mSolverParamsMNA->mInitFromNodesAndTerminals) pComp->initializeFromNodesAndTerminals(mSystem.mSystemFrequency); } @@ -298,8 +299,9 @@ void PFSolver::modifyPowerFlowBusComponent(CPS::String name, CPS::PowerflowBusTy } void PFSolver::setSolverAndComponentBehaviour(Solver::Behaviour behaviour) { - mBehaviour = behaviour; - if (mBehaviour == Behaviour::Initialization) { + std::shared_ptr mSolverParamsMNA = getMNAParameters(); + mSolverParamsMNA->mSolverBehaviour = behaviour; + if (mSolverParamsMNA->mSolverBehaviour == Behaviour::Initialization) { SPDLOG_LOGGER_INFO(mSLog, "-- Set solver behaviour to Initialization"); // TODO: solver setting specific to initialization (e.g. one single PF run) diff --git a/dpsim/src/Simulation.cpp b/dpsim/src/Simulation.cpp index ab37b97941..61306be864 100644 --- a/dpsim/src/Simulation.cpp +++ b/dpsim/src/Simulation.cpp @@ -51,27 +51,27 @@ Simulation::Simulation(String name, CommandLineArgs& args) : create(); } -void Simulation::setSolverParameters(CPS::Domain domain, Solver::Type type, SolverParameters& solverParameters) +void Simulation::setSolverParameters(CPS::Domain domain, Solver::Type type, std::shared_ptr &solverParameters) { mDomain = domain; if ((typeid(solverParameters) == typeid(SolverParametersMNA)) && (type == Solver::Type::MNA)) { cout << "Object is of type SolverParametersMNA" << endl; - mSolverParams = &solverParameters; + mSolverParams = solverParameters; mSolverType = Solver::Type::MNA; } else if ((typeid(solverParameters) == typeid(SolverParametersDAE)) && (type == Solver::Type::DAE)) { cout << "Object is of type SolverParametersMNA" << endl; - mSolverParams = &solverParameters; + mSolverParams = solverParameters; mSolverType = Solver::Type::DAE; } else if ((typeid(solverParameters) == typeid(SolverParametersNRP)) && (type == Solver::Type::NRP)) { cout << "Object is of type SolverParametersMNA" << endl; - mSolverParams = &solverParameters; + mSolverParams = solverParameters; mSolverType = Solver::Type::NRP; } else { cout << "Object is of unknown type" << endl; - mSolverParams = &solverParameters; + mSolverParams = solverParameters; } } @@ -124,8 +124,9 @@ void Simulation::createSolvers() { #endif /* WITH_SUNDIALS */ case Solver::Type::NRP: solver = std::make_shared(**mName, mSystem, **mTimeStep, mLogLevel); - solver->doInitFromNodesAndTerminals(mInitFromNodesAndTerminals); - solver->setSolverAndComponentBehaviour(mSolverBehaviour); + solver->setSolverParameters(mSolverParams); + //solver->doInitFromNodesAndTerminals(mInitFromNodesAndTerminals); + //solver->setSolverAndComponentBehaviour(mSolverBehaviour); solver->initialize(); mSolvers.push_back(solver); break; @@ -154,41 +155,44 @@ void Simulation::createMNASolver() { std::vector subnets; // The Diakoptics solver splits the system at a later point. // That is why the system is not split here if tear components exist. - if (**(*mSolverParams.mSplitSubnets) && mTearComponents.size() == 0) - mSystem.splitSubnets(subnets); - else - subnets.push_back(mSystem); - - for (UInt net = 0; net < subnets.size(); ++net) { - String copySuffix; - if (subnets.size() > 1) - copySuffix = "_" + std::to_string(net); - - // TODO: In the future, here we could possibly even use different - // solvers for different subnets if deemed useful - if (mTearComponents.size() > 0) { - // Tear components available, use diakoptics - solver = std::make_shared>(**mName, - subnets[net], mTearComponents, **mTimeStep, mLogLevel); - } else { - // Default case with lu decomposition from mna factory - solver = MnaSolverFactory::factory(**mName + copySuffix, mDomain, - mLogLevel, mDirectImpl, mSolverPluginName); - //solver->setTimeStep(**mTimeStep); - solver->setSolverParameters(*mSolverParams); - //solver->doSteadyStateInit(**mSteadyStateInit); - //solver->doFrequencyParallelization(mFreqParallel); - //solver->setSteadStIniTimeLimit(mSteadStIniTimeLimit); - //solver->setSteadStIniAccLimit(mSteadStIniAccLimit); - solver->setSystem(subnets[net]); - //solver->setSolverAndComponentBehaviour(mSolverBehaviour); - //solver->doInitFromNodesAndTerminals(mInitFromNodesAndTerminals); - //solver->doSystemMatrixRecomputation(mSystemMatrixRecomputation); - //solver->setDirectLinearSolverConfiguration(mDirectLinearSolverConfiguration); - solver->initialize(); - solver->setMaxNumberOfIterations(mMaxIterations); + std::shared_ptr mSolverParamsMNA = std::dynamic_pointer_cast(mSolverParams); + if (mSolverParamsMNA != nullptr) { + if ( mSolverParamsMNA->getSplitSubnets() && mTearComponents.size() == 0) + mSystem.splitSubnets(subnets); + else + subnets.push_back(mSystem); + + for (UInt net = 0; net < subnets.size(); ++net) { + String copySuffix; + if (subnets.size() > 1) + copySuffix = "_" + std::to_string(net); + + // TODO: In the future, here we could possibly even use different + // solvers for different subnets if deemed useful + if (mTearComponents.size() > 0) { + // Tear components available, use diakoptics + solver = std::make_shared>(**mName, + subnets[net], mTearComponents, **mTimeStep, mLogLevel); + } else { + // Default case with lu decomposition from mna factory + solver = MnaSolverFactory::factory(**mName + copySuffix, mDomain, + mLogLevel, mSolverParamsMNA->mDirectImpl, mSolverPluginName); + solver->setTimeStep(**mTimeStep); + solver->setSolverParameters(mSolverParams); + //solver->doSteadyStateInit(**mSteadyStateInit); + //solver->doFrequencyParallelization(mFreqParallel); + //solver->setSteadStIniTimeLimit(mSteadStIniTimeLimit); + //solver->setSteadStIniAccLimit(mSteadStIniAccLimit); + solver->setSystem(subnets[net]); + //solver->setSolverAndComponentBehaviour(mSolverBehaviour); + //solver->doInitFromNodesAndTerminals(mInitFromNodesAndTerminals); + //solver->doSystemMatrixRecomputation(mSystemMatrixRecomputation); + //solver->setDirectLinearSolverConfiguration(mDirectLinearSolverConfiguration); + solver->initialize(); + solver->setMaxNumberOfIterations(mMaxIterations); + } + mSolvers.push_back(solver); } - mSolvers.push_back(solver); } } diff --git a/dpsim/src/SolverParameters.cpp b/dpsim/src/SolverParameters.cpp deleted file mode 100644 index c68bf863d4..0000000000 --- a/dpsim/src/SolverParameters.cpp +++ /dev/null @@ -1,31 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 - -#include -#include -#include -#include - - -#include -#include -#include - -#include - -#ifdef WITH_CIM - #include -#endif - -#ifdef WITH_SUNDIALS - #include - #include - #include -#endif - -using namespace CPS; -using namespace DPsim; - - -// Constructor -SolverParameters::SolverParameters(){} - diff --git a/dpsim/src/SolverParametersMNA.cpp b/dpsim/src/SolverParametersMNA.cpp deleted file mode 100644 index e16b2a72c5..0000000000 --- a/dpsim/src/SolverParametersMNA.cpp +++ /dev/null @@ -1,25 +0,0 @@ -#include -#include -#include -#include - - -#include -#include -#include - -#include - -#ifdef WITH_CIM - #include -#endif - -#ifdef WITH_SUNDIALS - #include - #include - #include -#endif - -using namespace CPS; -using namespace DPsim; - From 817f68f6f50e7ce08521f9e5acaec9bf92e5a5cc Mon Sep 17 00:00:00 2001 From: Canfirat98 Date: Tue, 23 May 2023 11:42:51 +0200 Subject: [PATCH 4/6] Add SolverParameters to Python bind Signed-off-by: Canfirat98 --- dpsim/src/pybind/main.cpp | 37 +++- examples/Notebooks/Circuits/CS_R2CL.ipynb | 251 +++++++++++++++++++--- 2 files changed, 255 insertions(+), 33 deletions(-) diff --git a/dpsim/src/pybind/main.cpp b/dpsim/src/pybind/main.cpp index 03de1e88d9..f2091fba80 100644 --- a/dpsim/src/pybind/main.cpp +++ b/dpsim/src/pybind/main.cpp @@ -17,6 +17,8 @@ #include #include +#include +#include #include #include @@ -65,6 +67,31 @@ PYBIND11_MODULE(dpsimpy, m) { addAttributes(m); + py::class_(m, "SolverParameters") + .def(py::init<>()) + .def("set_time_step", &DPsim::SolverParameters::setTimeStep) + .def("set_init_from_nodes_and_terminals", &DPsim::SolverParameters::setInitFromNodesAndTerminals) + .def("get_time_step", &DPsim::SolverParameters::getTimeStep) + .def("get_init_from_nodes_and_terminals", &DPsim::SolverParameters::getInitFromNodesAndTerminals); + + py::class_(m, "SolverParametersMNA") + .def(py::init<>()) + .def("set_domain", &DPsim::SolverParametersMNA::setDomain) + .def("set_solver_and_component_behaviour", &DPsim::SolverParametersMNA::setSolverAndComponentBehaviour) + .def("do_split_subnets", &DPsim::SolverParametersMNA::doSplitSubnets) + .def("do_frequency_parallelization", &DPsim::SolverParametersMNA::doFrequencyParallelization) + .def("do_system_matrix_recomputation", &DPsim::SolverParametersMNA::doSystemMatrixRecomputation) + .def("set_direct_linear_solver_implementation", &DPsim::SolverParametersMNA::setDirectLinearSolverImplementation) + .def("do_steady_state_init", &DPsim::SolverParametersMNA::doSteadyStateInit) + .def("set_stead_st_ini_time_limit", &DPsim::SolverParametersMNA::setSteadStIniTimeLimit) + .def("set_stead_st_ini_acc_limit", &DPsim::SolverParametersMNA::setSteadStIniAccLimit) + .def("get_split_subnets", &DPsim::SolverParametersMNA::getSplitSubnets) + .def("get_freq_parallel", &DPsim::SolverParametersMNA::getFreqParallel) + .def("get_system_matrix_recomputation", &DPsim::SolverParametersMNA::getSystemMatrixRecomputation) + .def("get_steady_state_init", &DPsim::SolverParametersMNA::getSteadyStateInit) + .def("get_steady_state_init_time_limit", &DPsim::SolverParametersMNA::getSteadyStateInitTimeLimit) + .def("get_steady_state_init_acc_limit", &DPsim::SolverParametersMNA::getSteadyStateInitAccLimit); + py::class_(m, "DirectLinearSolverConfiguration") .def(py::init<>()) .def("set_fill_in_reduction_method", &DPsim::DirectLinearSolverConfiguration::setFillInReductionMethod) @@ -86,20 +113,16 @@ PYBIND11_MODULE(dpsimpy, m) { .def("run", &DPsim::Simulation::run) .def("set_solver", &DPsim::Simulation::setSolverType) .def("set_domain", &DPsim::Simulation::setDomain) + .def("set_simulation_parameters", &DPsim::Simulation::setSimulationParameters, "a"_a,"b"_a) + .def("set_solver_parameters", &DPsim::Simulation::setSolverParameters, "domain"_a, "type"_a, "solverParameters"_a) .def("start", &DPsim::Simulation::start) .def("next", &DPsim::Simulation::next) .def("get_idobj_attr", &DPsim::Simulation::getIdObjAttribute, "comp"_a, "attr"_a) .def("add_interface", &DPsim::Simulation::addInterface, "interface"_a) .def("log_idobj_attribute", &DPsim::Simulation::logIdObjAttribute, "comp"_a, "attr"_a) .def("log_attribute", &DPsim::Simulation::logAttribute, "name"_a, "attr"_a) - .def("do_init_from_nodes_and_terminals", &DPsim::Simulation::doInitFromNodesAndTerminals) - .def("do_system_matrix_recomputation", &DPsim::Simulation::doSystemMatrixRecomputation) - .def("do_steady_state_init", &DPsim::Simulation::doSteadyStateInit) - .def("do_frequency_parallelization", &DPsim::Simulation::doFrequencyParallelization) .def("set_tearing_components", &DPsim::Simulation::setTearingComponents) .def("add_event", &DPsim::Simulation::addEvent) - .def("set_solver_component_behaviour", &DPsim::Simulation::setSolverAndComponentBehaviour) - .def("set_direct_solver_implementation", &DPsim::Simulation::setDirectLinearSolverImplementation) .def("set_direct_linear_solver_configuration", &DPsim::Simulation::setDirectLinearSolverConfiguration) .def("log_lu_times", &DPsim::Simulation::logLUTimes); @@ -205,6 +228,7 @@ PYBIND11_MODULE(dpsimpy, m) { .value("DAE", DPsim::Solver::Type::DAE) .value("NRP", DPsim::Solver::Type::NRP); + /* py::enum_(m, "DirectLinearSolverImpl") .value("Undef", DPsim::DirectLinearSolverImpl::Undef) .value("DenseLU", DPsim::DirectLinearSolverImpl::DenseLU) @@ -213,6 +237,7 @@ PYBIND11_MODULE(dpsimpy, m) { .value("CUDADense", DPsim::DirectLinearSolverImpl::CUDADense) .value("CUDASparse", DPsim::DirectLinearSolverImpl::CUDASparse) .value("CUDAMagma", DPsim::DirectLinearSolverImpl::CUDAMagma); + */ py::enum_(m, "scaling_method") .value("no_scaling", DPsim::SCALING_METHOD::NO_SCALING) diff --git a/examples/Notebooks/Circuits/CS_R2CL.ipynb b/examples/Notebooks/Circuits/CS_R2CL.ipynb index 1b84bd0f49..836c422d95 100644 --- a/examples/Notebooks/Circuits/CS_R2CL.ipynb +++ b/examples/Notebooks/Circuits/CS_R2CL.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -27,11 +27,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Unable to load a custom holder type from a default-holder instance", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/mmo-cya/dpsim/examples/Notebooks/Circuits/CS_R2CL.ipynb Cell 4\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 48\u001b[0m sim\u001b[39m.\u001b[39mset_time_step(\u001b[39m0.0001\u001b[39m)\n\u001b[1;32m 49\u001b[0m sim\u001b[39m.\u001b[39mset_final_time(\u001b[39m0.1\u001b[39m)\n\u001b[0;32m---> 50\u001b[0m sim\u001b[39m.\u001b[39;49mset_solver_parameters(dpsimpy\u001b[39m.\u001b[39;49mDomain\u001b[39m.\u001b[39;49mEMT, dpsimpy\u001b[39m.\u001b[39;49mSolver\u001b[39m.\u001b[39;49mMNA, mna_parameter)\n", + "\u001b[0;31mRuntimeError\u001b[0m: Unable to load a custom holder type from a default-holder instance" + ] + } + ], "source": [ "# DPsim EMT simulation\n", + "import sys\n", + "sys.path.insert(0,'/home/mmo-cya/dpsim/build')\n", "import dpsimpy\n", "\n", "name = 'EMT_CS_R2CL'\n", @@ -71,16 +85,19 @@ "logger.log_attribute('cs.i_intf', 'i_intf', cs)\n", "logger.log_attribute('c_1.i_intf', 'i_intf', c1)\n", "\n", + "mna_parameter = dpsimpy.SolverParametersMNA()\n", + "\n", "sim = dpsimpy.Simulation(name)\n", "sim.set_domain(dpsimpy.Domain.EMT)\n", "sim.set_system(system)\n", "sim.set_time_step(0.0001)\n", - "sim.set_final_time(0.1)" + "sim.set_final_time(0.1)\n", + "sim.set_solver_parameters(dpsimpy.Domain.EMT, dpsimpy.Solver.MNA, mna_parameter)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -98,9 +115,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/EMT_CS_R2CL.csv\n", + "column number: 4\n", + "results length: 1000\n", + "real column names: ['c_1.i_intf', 'cs.i_intf', 'n1.v', 'n2.v']\n", + "complex column names: []\n" + ] + } + ], "source": [ "# read EMT results\n", "work_dir = 'logs/'\n", @@ -112,9 +141,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAATQ0lEQVR4nO3df5BV5Z3n8fc3/BCVFAgyTOTCds+GyYqaMOsVk+yQTcUg6DqS2iERNDWUZsvKDys1OzEJWWMGyWYrpibjVMpkN5QZQ5kaIUPVVKi4G0QSak1CZWxMxhEdRlR2bMgYbCh3XUKE7Hf/6GPTNBfp5t7u2zfP+1V1q895nuee+z1Pdfenz497OzITSVK53tDuAiRJ7WUQSFLhDAJJKpxBIEmFMwgkqXAT213A2bjwwguzq6ur3WVIUkfZtWvXS5k5a2h7RwZBV1cXPT097S5DkjpKRPyvRu2eGpKkwhkEklQ4g0CSCmcQSFLhDAJJKpxBIEmFMwgkqXAGgSQVziCQpMIZBJJUOINAkgpnEEhS4QwCSSqcQSBJhTMIJKlwBoEkFc4gkKTCGQSSVDiDQJIKZxBIUuEMAkkqnEEgSYUzCCSpcAaBJBXOIJCkwrUkCCJiWUTsiYi9EbGmQf85EbGp6v9JRHQN6Z8XEa9ExO2tqEeSNHxNB0FETAC+ClwDLABWRcSCIcM+BBzOzDcD9wB3D+n/c+B/NFuLJGnkWnFEsAjYm5nPZearwEZg+ZAxy4EN1fJm4KqICICIeB/wPLC7BbVIkkaoFUEwB3hh0Hpv1dZwTGYeB14GZkbEVODTwF1nepGIuDUieiKi5+DBgy0oW5IE7b9YvBa4JzNfOdPAzFyfmfXMrM+aNWv0K5OkQkxswTb2A3MHrdeqtkZjeiNiIjAN6AOuBFZExJeA6cD/i4ijmXlvC+qSJA1DK4LgMWB+RHTT/wt/JXDjkDFbgNXATmAF8P3MTGDxawMiYi3wiiEgSWOr6SDIzOMRcRuwFZgA/GVm7o6IdUBPZm4BvgE8EBF7gUP0h4UkaRyI/j/MO0u9Xs+enp52lyFJHSUidmVmfWh7uy8WS5LazCCQpMIZBJJUOINAkgpnEEhS4QwCSSqcQSBJhTMIJKlwBoEkFc4gkKTCGQSSVDiDQJIKZxBIUuEMAkkqnEEgSYUzCCSpcAaBJBXOIJCkwhkEklQ4g0CSCmcQSFLhDAJJKpxBIEmFMwgkqXAGgSQVziCQpMIZBJJUOINAkgpnEEhS4QwCSSpcS4IgIpZFxJ6I2BsRaxr0nxMRm6r+n0REV9W+JCJ2RcTfV1/f04p6JEnD13QQRMQE4KvANcACYFVELBgy7EPA4cx8M3APcHfV/hLwB5l5GbAaeKDZeiRJI9OKI4JFwN7MfC4zXwU2AsuHjFkObKiWNwNXRURk5k8z80DVvhs4NyLOaUFNkqRhakUQzAFeGLTeW7U1HJOZx4GXgZlDxvwh8Hhm/qoFNUmShmliuwsAiIhL6D9ddPXrjLkVuBVg3rx5Y1SZJP3ma8URwX5g7qD1WtXWcExETASmAX3Veg34G+CPMvPZ071IZq7PzHpm1mfNmtWCsiVJ0JogeAyYHxHdETEZWAlsGTJmC/0XgwFWAN/PzIyI6cBDwJrM/FELapEkjVDTQVCd878N2Ao8DXw7M3dHxLqIuL4a9g1gZkTsBf4EeO0W09uANwOfi4ifVY/farYmSdLwRWa2u4YRq9fr2dPT0+4yJKmjRMSuzKwPbfedxZJUOINAkgpnEEhS4QwCSSqcQSBJhTMIJKlwBoEkFc4gkKTCGQSSVDiDQJIKZxBIUuEMAkkqnEEgSYUzCCSpcAaBJBXOIJCkwhkEklQ4g0CSCmcQSFLhDAJJKpxBIEmFMwgkqXAGgSQVziCQpMIZBJJUOINAkgpnEEhS4QwCSSqcQSBJhTMIJKlwBoEkFa4lQRARyyJiT0TsjYg1DfrPiYhNVf9PIqJrUN9nqvY9EbG0FfVIkoav6SCIiAnAV4FrgAXAqohYMGTYh4DDmflm4B7g7uq5C4CVwCXAMuBr1fYkSWNkYgu2sQjYm5nPAUTERmA58NSgMcuBtdXyZuDeiIiqfWNm/gp4PiL2Vtvb+bqveOCnsHZaC0qXJLXi1NAc4IVB671VW8MxmXkceBmYOcznAhARt0ZET0T0tKBmSVKlFUcEYyIz1wPrAer1erLWPJCkEbkrGja34ohgPzB30Hqtams4JiImAtOAvmE+V5I0iloRBI8B8yOiOyIm03/xd8uQMVuA1dXyCuD7mZlV+8rqrqJuYD7wty2oSZI0TE2fGsrM4xFxG7AVmAD8ZWbujoh1QE9mbgG+ATxQXQw+RH9YUI37Nv0Xlo8DH8vMXzdbkyRp+KL/D/POUq/Xs6fHawSSNBIRsSsz60PbfWexJBXOIJCkwhkEklQ4g0CSCmcQSFLhDAJJKpxBIEmFMwgkqXAGgSQVziCQpMIZBJJUOINAkgpnEEhS4QwCSSqcQSBJhTMIJKlwBoEkFc4gkKTCGQSSVDiDQJIKZxBIUuEMAkkqnEEgSYUzCCSpcAaBJBXOIJCkwhkEklQ4g0CSCmcQSFLhDAJJKlxTQRARMyJiW0Q8U3294DTjVldjnomI1VXbeRHxUET8Q0TsjogvNlOLJOnsNHtEsAbYnpnzge3V+kkiYgbwp8CVwCLgTwcFxp9l5r8Cfg/4NxFxTZP1SJJGqNkgWA5sqJY3AO9rMGYpsC0zD2XmYWAbsCwzj2TmDwAy81XgcaDWZD2SpBFqNghmZ+bPq+V/BmY3GDMHeGHQem/VNiAipgN/QP9RhSRpDE0804CIeAT47QZddwxeycyMiBxpARExEXgQ+EpmPvc6424FbgWYN2/eSF9GknQaZwyCzHzv6foi4sWIeFNm/jwi3gT8osGw/cC7B63XgB2D1tcDz2TmX5yhjvXVWOr1+ogDR5LUWLOnhrYAq6vl1cB3GozZClwdERdUF4mvrtqIiP8MTAP+uMk6JElnqdkg+CKwJCKeAd5brRMR9Yi4DyAzDwGfBx6rHusy81BE1Og/vbQAeDwifhYR/6HJeiRJIxSZnXeWpV6vZ09PT7vLkKSOEhG7MrM+tN13FktS4QwCSSqcQSBJhTMIJKlwBoEkFc4gkKTCGQSSVDiDQJIKZxBIUuEMAkkqnEEgSYUzCCSpcAaBJBXOIJCkwhkEklQ4g0CSCmcQSFLhDAJJKpxBIEmFMwgkqXAGgSQVziCQpMIZBJJUOINAkgpnEEhS4QwCSSrcxHYXIEnDcezYMXp7ezl69Gi7Sxn3pkyZQq1WY9KkScMabxBI6gi9vb288Y1vpKuri4hodznjVmbS19dHb28v3d3dw3qOp4YkdYSjR48yc+ZMQ+AMIoKZM2eO6MjJIJDUMQyB4RnpPBkEklS4poIgImZExLaIeKb6esFpxq2uxjwTEasb9G+JiCebqUWSRts73/nOgeUNGzYwf/585s+fz4YNGwba77jjDubOncvUqVNPu51vfvObzJo1i4ULFw48nnrqKfbt20dE8NnPfnZg7EsvvcSkSZO47bbb+MIXvjAwfsKECQPLX/nKV5rbscw86wfwJWBNtbwGuLvBmBnAc9XXC6rlCwb1/3vgr4Anh/u6l19+eUoqy1NPPdXuEgb09fVld3d39vX15aFDh7K7uzsPHTqUmZk7d+7MAwcO5Pnnn3/a599///35sY997JT2559/Pru7u3PhwoUDbV/72tfybW972ynjX2/7mY3nC+jJBr9Tm71raDnw7mp5A7AD+PSQMUuBbZl5CCAitgHLgAcjYirwJ8CtwLebrEVSIbrWPDQq2933xX/3uv1Tp07llVdeYevWrSxZsoQZM2YAsGTJEr73ve+xatUq3v72tzdVw3nnncfFF19MT08P9XqdTZs28YEPfIADBw40td3X02wQzM7Mn1fL/wzMbjBmDvDCoPXeqg3g88CXgSNneqGIuJX+wGDevHlnW68kNW3//v3MnTt3YL1Wq7F///4RbWPTpk388Ic/HFjfuXPnwPLKlSvZuHEjs2fPZsKECVx00UXtDYKIeAT47QZddwxeycyMiBzuC0fEQuBfZuZ/jIiuM43PzPXAeoB6vT7s15H0m+dMf7l3ghtuuIF77723Yd+yZcu48847mT17NjfccMOo13LGi8WZ+d7MvLTB4zvAixHxJoDq6y8abGI/MHfQeq1qewdQj4h9wA+B342IHc3tjiSNvjlz5vDCCydOdPT29jJnzpzXecbITJ48mcsvv5wvf/nLrFixomXbPZ1mbx/dArx2F9Bq4DsNxmwFro6IC6q7iq4Gtmbmf83MizKzC/h94B8z891N1iNJo27p0qU8/PDDHD58mMOHD/Pwww+zdOnSlr7GJz7xCe6+++6B6xCjqdkg+CKwJCKeAd5brRMR9Yi4D6C6SPx54LHqse61C8eS1IlmzJjBnXfeyRVXXMEVV1zB5z73uYFf2J/61Keo1WocOXKEWq3G2rVrG25j06ZNJ90++uMf//ik/ksuuYTVq0+5235URP8dRZ2lXq9nT09Pu8uQNIaefvppLr744naX0TEazVdE7MrM+tCxvrNYkgpnEEhS4QwCSSqcQSBJhTMIJKlwBoEkFc4gkKRhGvwx1MuWLWP69Olcd911J4256aabeMtb3sKll17KLbfcwrFjx07Zzo4dO5g2bdpJ7yN45JFHgP5/KvPBD35wYOzx48eZNWsW1113Hffff//A+MmTJ3PZZZexcOFC1qxZ09R++T+LJWmYBr/p65Of/CRHjhzh61//+kljbrrpJr71rW8BcOONN3LffffxkY985JRtLV68mO9+97untJ9//vk8+eST/PKXv+Tcc89l27ZtAx9fcfPNN3PzzTcD0NXVxQ9+8AMuvPDCpvfLIJDUedZOG6Xtvvy63a99DDXAVVddxY4dO04Zc+211w4sL1q0iN7e3hGXce211/LQQw+xYsUKHnzwQVatWsWjjz464u0Ml6eGJGkUHDt2jAceeIBly5Y17H/00UdPOjX07LPPDvS99jHUR48e5YknnuDKK68c1Vo9IpDUec7wl/t48NGPfpR3vetdLF68uGH/6U4NAbz1rW9l3759PPjggycdYYwWg0CSWuyuu+7i4MGDp1w/GInrr7+e22+/nR07dtDX19fC6k5lEEhSC913331s3bqV7du384Y3nP3Z91tuuYXp06dz2WWXNbwW0UpeI5Cks7B48WLe//73s337dmq1Glu3bgXgwx/+MC+++CLveMc7WLhwIevWrWv4/KHXCDZv3nxSf61W4+Mf//io7wf4MdSSOoQfQz0yfgy1JGnYDAJJKpxBIKljdOKp7HYY6TwZBJI6wpQpU+jr6zMMziAz6evrY8qUKcN+jrePSuoItVqN3t5eDh482O5Sxr0pU6ZQq9WGPd4gkNQRJk2aRHd3d7vL+I3kqSFJKpxBIEmFMwgkqXAd+c7iiPg/wJ521zFOXAi81O4ixgnn4gTn4gTn4oR/kZmzhjZ26sXiPY3eJl2iiOhxLvo5Fyc4Fyc4F2fmqSFJKpxBIEmF69QgWN/uAsYR5+IE5+IE5+IE5+IMOvJisSSpdTr1iECS1CIGgSQVblwFQUQsi4g9EbE3ItY06D8nIjZV/T+JiK5BfZ+p2vdExNIxLXwUnO1cRMSSiNgVEX9ffX3PmBffYs18X1T98yLilYi4fcyKHiVN/oy8NSJ2RsTu6vtj+B9POQ418TMyKSI2VHPwdER8ZsyLH28yc1w8gAnAs8DvAJOBvwMWDBnzUeC/VcsrgU3V8oJq/DlAd7WdCe3epzbNxe8BF1XLlwL7270/7ZqLQf2bgb8Gbm/3/rTx+2Ii8ATwtmp9ZsE/IzcCG6vl84B9QFe796mdj/F0RLAI2JuZz2Xmq8BGYPmQMcuBDdXyZuCqiIiqfWNm/ioznwf2VtvrVGc9F5n508w8ULXvBs6NiHPGpOrR0cz3BRHxPuB5+uei0zUzF1cDT2Tm3wFkZl9m/nqM6h4NzcxFAudHxETgXOBV4H+PTdnj03gKgjnAC4PWe6u2hmMy8zjwMv1/2QznuZ2kmbkY7A+BxzPzV6NU51g467mIiKnAp4G7xqDOsdDM98XvAhkRWyPi8Yj41BjUO5qamYvNwP8Ffg78E/BnmXlotAsezzr1IyZ0BhFxCXA3/X8JlmotcE9mvlIdIJRsIvD7wBXAEWB7ROzKzO3tLastFgG/Bi4CLgAejYhHMvO59pbVPuPpiGA/MHfQeq1qazimOqybBvQN87mdpJm5ICJqwN8Af5SZz456taOrmbm4EvhSROwD/hj4TxFx2yjXO5qamYte4H9m5kuZeQT478C/HvWKR08zc3Ej8L3MPJaZvwB+BBT9WUTjKQgeA+ZHRHdETKb/4s6WIWO2AKur5RXA97P/is8WYGV1l0A3MB/42zGqezSc9VxExHTgIWBNZv5orAoeRWc9F5m5ODO7MrML+Avgv2TmvWNU92ho5mdkK3BZRJxX/VL8t8BTY1T3aGhmLv4JeA9ARJwPvB34hzGperxq99XqwQ/gWuAf6b8b4I6qbR1wfbU8hf67P/bS/4v+dwY9947qeXuAa9q9L+2aC+Cz9J///Nmgx2+1e3/a9X0xaBtr6fC7hpqdC+CD9F80fxL4Urv3pV1zAUyt2nfTH4afbPe+tPvhR0xIUuHG06khSVIbGASSVDiDQJIKZxBIUuEMAkkqnEEgSYUzCCSpcP8fbBE9KVJYN3EAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "v1_emt = 'n1.v'\n", "v2_emt = 'n2.v'\n", @@ -140,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -192,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -201,7 +255,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -210,9 +264,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/DP_CS_R2CL.csv\n", + "column number: 4\n", + "results length: 1000\n", + "real column names: []\n", + "complex column names: ['c_1.i_intf', 'cs.i_intf', 'n1.v', 'n2.v']\n" + ] + } + ], "source": [ "# read DP results\n", "work_dir = 'logs/'\n", @@ -227,9 +293,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "v1_dp = 'n1.v_shift'\n", "v2_dp = 'n2.v_shift'\n", @@ -255,9 +346,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "column number: 4\n", + "results length: 1001\n", + "real column names: ['v1', 'v2', 'i12', 'i34']\n", + "complex column names: []\n" + ] + } + ], "source": [ "# read Simulink log file\n", "import os\n", @@ -275,9 +377,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "v1_sl = 'v1'\n", "v2_sl = 'v2'\n", @@ -303,9 +430,58 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# plot v1\n", "pt.plot_timeseries(1, ts_dpsim_emt[v1_emt])\n", @@ -330,9 +506,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total RMSE of Simulink reference and DPsim EMT: 3.64741\n", + "Total RMSE of Simulink reference and DPsim DP: 3.64741\n" + ] + } + ], "source": [ "# calculate the RMSE between Simulink (ts_sl) and EMT (ts_dpsim_emt)\n", "err_sl_emt = 0\n", @@ -351,9 +536,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/mmo-cya/dpsim/examples/Notebooks/Circuits/CS_R2CL.ipynb Cell 21\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[39massert\u001b[39;00m err_sl_emt \u001b[39m<\u001b[39m \u001b[39m0.1\u001b[39m\n\u001b[1;32m 2\u001b[0m \u001b[39massert\u001b[39;00m err_sl_dp \u001b[39m<\u001b[39m \u001b[39m0.1\u001b[39m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], "source": [ "assert err_sl_emt < 0.1\n", "assert err_sl_dp < 0.1" From a2e685950eaa214380143dc9d4715f809802461c Mon Sep 17 00:00:00 2001 From: Martin Moraga Date: Thu, 25 May 2023 15:07:42 +0200 Subject: [PATCH 5/6] fix some small errors and move member mSolverParams from Solver to subclasses Signed-off-by: Martin Moraga --- dpsim/include/dpsim/MNASolver.h | 15 +- dpsim/include/dpsim/MNASolverDirect.h | 3 +- dpsim/include/dpsim/MNASolverFactory.h | 25 +- dpsim/include/dpsim/MNASolverPlugin.h | 3 + dpsim/include/dpsim/PFSolver.h | 6 +- dpsim/include/dpsim/PFSolverPowerPolar.h | 2 +- dpsim/include/dpsim/Simulation.h | 26 +- dpsim/include/dpsim/Solver.h | 5 - dpsim/include/dpsim/SolverParameters.h | 13 +- dpsim/include/dpsim/SolverParametersMNA.h | 34 +- dpsim/include/dpsim/SolverParametersNRP.h | 5 - dpsim/src/MNASolver.cpp | 472 ++++++++++------------ dpsim/src/MNASolverDirect.cpp | 113 +++--- dpsim/src/MNASolverPlugin.cpp | 6 +- dpsim/src/PFSolver.cpp | 11 +- dpsim/src/PFSolverPowerPolar.cpp | 4 +- dpsim/src/Simulation.cpp | 132 +++--- dpsim/src/pybind/main.cpp | 10 +- examples/Notebooks/Circuits/CS_R2CL.ipynb | 305 +++----------- examples/Notebooks/Circuits/VS_RL1.ipynb | 6 + 20 files changed, 485 insertions(+), 711 deletions(-) diff --git a/dpsim/include/dpsim/MNASolver.h b/dpsim/include/dpsim/MNASolver.h index e0123d7a03..2833213192 100644 --- a/dpsim/include/dpsim/MNASolver.h +++ b/dpsim/include/dpsim/MNASolver.h @@ -15,10 +15,9 @@ #include #include +#include #include #include -#include -#include #include #include #include @@ -39,6 +38,9 @@ namespace DPsim { template class MnaSolver : public Solver { protected: + /// ### Solver Parameters + std::shared_ptr mSolverParams; + // #### General simulation settings #### /// Simulation domain, which can be dynamic phasor (DP) or EMT CPS::Domain mDomain; @@ -61,10 +63,6 @@ namespace DPsim { /// List of index pairs of varying matrix entries std::vector> mListVariableSystemMatrixEntries; - - using Solver::mSolverParams; - - /// System topology CPS::SystemTopology mSystem; /// List of simulation nodes @@ -129,6 +127,7 @@ namespace DPsim { /// Constructor should not be called by users but by Simulation MnaSolver(String name, CPS::Domain domain = CPS::Domain::DP, + std::shared_ptr solverParams = SolverParametersMNA(), CPS::Logger::Level logLevel = CPS::Logger::Level::info); /// Initialization of individual components @@ -217,9 +216,5 @@ namespace DPsim { Matrix& rightSideVector() { return mRightSideVector; } /// virtual CPS::Task::List getTasks() override; - /// Gets Solver Parameters for Modified Nodal Analysis (MNA) - std::shared_ptr getMNAParameters() { return std::dynamic_pointer_cast(mSolverParams); } - - }; } diff --git a/dpsim/include/dpsim/MNASolverDirect.h b/dpsim/include/dpsim/MNASolverDirect.h index f655c205a1..07b6a690f8 100644 --- a/dpsim/include/dpsim/MNASolverDirect.h +++ b/dpsim/include/dpsim/MNASolverDirect.h @@ -69,7 +69,7 @@ namespace DPsim { /// LU factorization configuration DirectLinearSolverConfiguration mConfigurationInUse; - using Solver::mSolverParams; + using MnaSolver::mSolverParams; using MnaSolver::mSwitches; using MnaSolver::mMNAIntfSwitches; using MnaSolver::mMNAComponents; @@ -144,6 +144,7 @@ namespace DPsim { /// sovlerImpl: choose the most advanced solver implementation available by default MnaSolverDirect(String name, CPS::Domain domain = CPS::Domain::DP, + std::shared_ptr solverParams = SolverParametersMNA(), CPS::Logger::Level logLevel = CPS::Logger::Level::info); /// Destructor diff --git a/dpsim/include/dpsim/MNASolverFactory.h b/dpsim/include/dpsim/MNASolverFactory.h index 9881ff1a63..0966816e7c 100644 --- a/dpsim/include/dpsim/MNASolverFactory.h +++ b/dpsim/include/dpsim/MNASolverFactory.h @@ -63,31 +63,32 @@ class MnaSolverFactory { template static std::shared_ptr> factory(String name, CPS::Domain domain = CPS::Domain::DP, + std::shared_ptr solverParams = SolverParametersMNA(), CPS::Logger::Level logLevel = CPS::Logger::Level::info, - CPS::DirectLinearSolverImpl implementation = CPS::DirectLinearSolverImpl::SparseLU, String pluginName = "plugin.so") { //To avoid regression we use SparseLU in case of undefined implementation - if (implementation == CPS::DirectLinearSolverImpl::Undef) { - implementation = CPS::DirectLinearSolverImpl::SparseLU; - } + if (solverParams->mDirectImpl == CPS::DirectLinearSolverImpl::Undef) + solverParams->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + + // CPS::Logger::Log log = CPS::Logger::get("MnaSolverFactory", CPS::Logger::Level::info, CPS::Logger::Level::info); - switch(implementation) { + switch(solverParams->mDirectImpl) { /* TODO: have only one "solver" object of type MnaSolverDirect and only use setDirectLinearSolverImplementation in the switch-case. * This is not done now, since MnaSolverDirect and MnaSolver are distinct classes - and someone might add another subclass of MnaSolver * to the project (MnaSolverIterative?). It is planned to merge MnaSolverDirect and MnaSolver anyway, so this won't happen. */ case CPS::DirectLinearSolverImpl::SparseLU: { log->info("creating SparseLUAdapter solver implementation"); - std::shared_ptr> sparseSolver = std::make_shared>(name, domain, logLevel); + std::shared_ptr> sparseSolver = std::make_shared>(name, domain, solverParams, logLevel); sparseSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); return sparseSolver; } case CPS::DirectLinearSolverImpl::DenseLU: { log->info("creating DenseLUAdapter solver implementation"); - std::shared_ptr> denseSolver = std::make_shared>(name, domain, logLevel); + std::shared_ptr> denseSolver = std::make_shared>(name, domain, solverParams, logLevel); denseSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::DenseLU); return denseSolver; } @@ -95,7 +96,7 @@ class MnaSolverFactory { case CPS::DirectLinearSolverImpl::KLU: { log->info("creating KLUAdapter solver implementation"); - std::shared_ptr> kluSolver = std::make_shared>(name, domain, logLevel); + std::shared_ptr> kluSolver = std::make_shared>(name, domain, solverParams, logLevel); kluSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::KLU); return kluSolver; } @@ -104,7 +105,7 @@ class MnaSolverFactory { case CPS::DirectLinearSolverImpl::CUDADense: { log->info("creating GpuDenseAdapter solver implementation"); - std::shared_ptr> gpuDenseSolver = std::make_shared>(name, domain, logLevel); + std::shared_ptr> gpuDenseSolver = std::make_shared>(name, domain, solverParams, logLevel); gpuDenseSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::CUDADense); return gpuDenseSolver; } @@ -112,7 +113,7 @@ class MnaSolverFactory { case CPS::DirectLinearSolverImpl::CUDASparse: { log->info("creating GpuSparseAdapter solver implementation"); - std::shared_ptr> gpuSparseSolver = std::make_shared>(name, domain, logLevel); + std::shared_ptr> gpuSparseSolver = std::make_shared>(name, domain, solverParams, logLevel); gpuSparseSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::CUDASparse); return gpuSparseSolver; } @@ -121,7 +122,7 @@ class MnaSolverFactory { case CPS::DirectLinearSolverImpl::CUDAMagma: { log->info("creating GpuMagmaAdapter solver implementation"); - std::shared_ptr> gpuMagmaSolver = std::make_shared>(name, domain, logLevel); + std::shared_ptr> gpuMagmaSolver = std::make_shared>(name, domain, solverParams, logLevel); gpuMagmaSolver->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::CUDAMagma); return gpuMagmaSolver; } @@ -130,7 +131,7 @@ class MnaSolverFactory { #ifdef WITH_MNASOLVERPLUGIN case CPS::DirectLinearSolverImpl::Plugin: log->info("creating Plugin solver implementation"); - return std::make_shared>(pluginName, name, domain, logLevel); + return std::make_shared>(pluginName, name, domain, solverParams, logLevel); #endif default: throw CPS::SystemError("unsupported MNA implementation."); diff --git a/dpsim/include/dpsim/MNASolverPlugin.h b/dpsim/include/dpsim/MNASolverPlugin.h index c3e47fea10..edf15b607d 100644 --- a/dpsim/include/dpsim/MNASolverPlugin.h +++ b/dpsim/include/dpsim/MNASolverPlugin.h @@ -10,6 +10,8 @@ #include #include +#include + namespace DPsim { @@ -30,6 +32,7 @@ namespace DPsim { MnaSolverPlugin(String pluginName, String name, CPS::Domain domain = CPS::Domain::DP, + std::shared_ptr solverParams = SolverParametersMNA(), CPS::Logger::Level logLevel = CPS::Logger::Level::info); virtual ~MnaSolverPlugin(); diff --git a/dpsim/include/dpsim/PFSolver.h b/dpsim/include/dpsim/PFSolver.h index 58b36fc1f1..d58f21cefa 100644 --- a/dpsim/include/dpsim/PFSolver.h +++ b/dpsim/include/dpsim/PFSolver.h @@ -21,6 +21,9 @@ namespace DPsim { /// Solver class using the nonlinear powerflow (PF) formulation. class PFSolver: public Solver { protected: + /// ### Solver Parameters + std::shared_ptr mSolverParams; + /// Number of PQ nodes UInt mNumPQBuses = 0; /// Number of PV nodes @@ -138,6 +141,7 @@ namespace DPsim { PFSolver(CPS::String name, CPS::SystemTopology system, Real timeStep, + std::shared_ptr solverParams, CPS::Logger::Level logLevel); /// virtual ~PFSolver() { }; @@ -149,7 +153,7 @@ namespace DPsim { /// set solver and component to initialization or simulation behaviour void setSolverAndComponentBehaviour(Solver::Behaviour behaviour); /// Gets Solver Parameters for Modified Nodal Analysis (MNA) - std::shared_ptr getMNAParameters() { return std::dynamic_pointer_cast(mSolverParams); } + //std::shared_ptr getMNAParameters() { return std::dynamic_pointer_cast(mSolverParams); } class SolveTask : public CPS::Task { public: diff --git a/dpsim/include/dpsim/PFSolverPowerPolar.h b/dpsim/include/dpsim/PFSolverPowerPolar.h index 2b56c9b3d6..65cb047eec 100644 --- a/dpsim/include/dpsim/PFSolverPowerPolar.h +++ b/dpsim/include/dpsim/PFSolverPowerPolar.h @@ -67,7 +67,7 @@ namespace DPsim { void calculateNodalInjection(); public: /// Constructor to be used in simulation examples. - PFSolverPowerPolar(CPS::String name, const CPS::SystemTopology &system, CPS::Real timeStep, CPS::Logger::Level logLevel); + PFSolverPowerPolar(CPS::String name, const CPS::SystemTopology &system, CPS::Real timeStep, std::shared_ptr solverParams, CPS::Logger::Level logLevel); /// virtual ~PFSolverPowerPolar() { }; }; diff --git a/dpsim/include/dpsim/Simulation.h b/dpsim/include/dpsim/Simulation.h index 7654137a89..f9fc46c54f 100644 --- a/dpsim/include/dpsim/Simulation.h +++ b/dpsim/include/dpsim/Simulation.h @@ -2,21 +2,22 @@ #pragma once -#include "dpsim/MNASolverFactory.h" #include #include #include +#include #include #include #include #include +#include #include +#include #include #include #include -#include -#include + #include #ifdef WITH_GRAPHVIZ @@ -146,27 +147,28 @@ namespace DPsim { /// void setFinalTime(Real finalTime) { **mFinalTime = finalTime; } /// + void setSimulationParameters(CPS::Real timeStep, CPS::Real finalTime) { + **mTimeStep = timeStep; + **mFinalTime = finalTime; + } + /// void setDomain(CPS::Domain domain = CPS::Domain::DP) { mDomain = domain; } /// void setSolverType(Solver::Type solverType = Solver::Type::MNA) { mSolverType = solverType; } /// - void setDirectLinearSolverConfiguration(const DirectLinearSolverConfiguration& configuration) { mDirectLinearSolverConfiguration = configuration; } + void setSolverParameters(CPS::Domain domain = CPS::Domain::DP, Solver::Type type = Solver::Type::MNA, + std::shared_ptr solverParameters = nullptr); + /// + void setDirectLinearSolverConfiguration(const DirectLinearSolverConfiguration& configuration) { mDirectLinearSolverConfiguration = configuration; } /// void setTearingComponents(CPS::IdentifiedObject::List tearComponents = CPS::IdentifiedObject::List()) { mTearComponents = tearComponents; } - /// - void setSimulationParameters(CPS::Real a, CPS::Real b) {} - /// - void setSolverParameters(CPS::Domain domain, Solver::Type type, std::shared_ptr &solverParameters); - - + /// Set the scheduling method void setScheduler(const std::shared_ptr &scheduler) { mScheduler = scheduler; } - - // #### Simulation Control #### diff --git a/dpsim/include/dpsim/Solver.h b/dpsim/include/dpsim/Solver.h index 2d00b65c94..b59a9f2c91 100644 --- a/dpsim/include/dpsim/Solver.h +++ b/dpsim/include/dpsim/Solver.h @@ -14,7 +14,6 @@ #include #include -#include #include #include #include @@ -45,8 +44,6 @@ namespace DPsim { CPS::Logger::Level mLogLevel; /// Logger CPS::Logger::Log mSLog; - /// Solver Parameters - std::shared_ptr mSolverParams; /// Time step for fixed step solvers Real mTimeStep; @@ -78,8 +75,6 @@ namespace DPsim { void setTimeStep(Real timeStep) { mTimeStep = timeStep; } /// void doSystemMatrixRecomputation(Bool value) { mSystemMatrixRecomputation = value; } - - void setSolverParameters(std::shared_ptr &solverParameters){ mSolverParams = solverParameters; } // #### Initialization #### /// diff --git a/dpsim/include/dpsim/SolverParameters.h b/dpsim/include/dpsim/SolverParameters.h index 73232f52e3..0b60ced8db 100644 --- a/dpsim/include/dpsim/SolverParameters.h +++ b/dpsim/include/dpsim/SolverParameters.h @@ -17,7 +17,7 @@ namespace DPsim { class SolverParameters{ public: /// Time step for fixed step solvers - Real mTimeStep; + Real mTimeStep = 0.001; // #### Initialization #### @@ -25,22 +25,17 @@ namespace DPsim { Bool mInitFromNodesAndTerminals = true; - + public: SolverParameters() {} virtual ~SolverParameters() { } - void setTimeStep(Real timeStep) { mTimeStep = timeStep; } - - // #### Initialization #### + // #### Setters #### /// activate powerflow initialization void setInitFromNodesAndTerminals(Bool f) { mInitFromNodesAndTerminals = f; } - // #### Getter #### - Real getTimeStep() {return mTimeStep;} - + /// Bool getInitFromNodesAndTerminals() {return mInitFromNodesAndTerminals;} - }; } diff --git a/dpsim/include/dpsim/SolverParametersMNA.h b/dpsim/include/dpsim/SolverParametersMNA.h index 98b9259aa3..5b65816519 100644 --- a/dpsim/include/dpsim/SolverParametersMNA.h +++ b/dpsim/include/dpsim/SolverParametersMNA.h @@ -1,11 +1,7 @@ #pragma once -#include -#include #include - -// using namespace CPS; - +#include namespace DPsim { /// Solver class using Modified Nodal Analysis (MNA). @@ -15,13 +11,14 @@ namespace DPsim { /// Simulation domain, which can be dynamic phasor (DP) or EMT CPS::Domain mDomain; + // Solver::Behaviour mSolverBehaviour = Solver::Behaviour::Simulation; /// Determines if the network should be split /// into subnetworks at decoupling lines. /// If the system is split, each subsystem is /// solved by a dedicated MNA solver. - const CPS::Attribute::Ptr mSplitSubnets; + Bool mSplitSubnets = false; /// Determines if the system matrix is split into /// several smaller matrices, one for each frequency. @@ -33,28 +30,21 @@ namespace DPsim { /// Enable recomputation of system matrix during simulation Bool mSystemMatrixRecomputation = false; + // #### Initialization #### /// Determines if steady-state initialization /// should be executed prior to the simulation. /// By default the initialization is disabled. - const CPS::Attribute::Ptr mSteadyStateInit; - - // #### Initialization #### + Bool mSteadyStateInit = false; /// steady state initialization time limit Real mSteadStIniTimeLimit = 10; /// steady state initialization accuracy limit Real mSteadStIniAccLimit = 0.0001; + /// CPS::DirectLinearSolverImpl mDirectImpl = CPS::DirectLinearSolverImpl::Undef; - - - - - - SolverParametersMNA(): - mSplitSubnets(CPS::AttributeStatic::make(true)), - mSteadyStateInit(CPS::AttributeStatic::make(false)) { - } + public: + SolverParametersMNA() { } /// Destructor virtual ~SolverParametersMNA() {}; @@ -65,7 +55,7 @@ namespace DPsim { void setSolverAndComponentBehaviour(Solver::Behaviour behaviour) { mSolverBehaviour = behaviour; } /// - void doSplitSubnets(Bool splitSubnets = true) { **mSplitSubnets = splitSubnets; } + void doSplitSubnets(Bool splitSubnets = true) { mSplitSubnets = splitSubnets; } /// /// Compute phasors of different frequencies in parallel void doFrequencyParallelization(Bool value) { mFreqParallel = value; } @@ -77,17 +67,17 @@ namespace DPsim { // #### Initialization #### /// activate steady state initialization - void doSteadyStateInit(Bool f) { **mSteadyStateInit = f; } + void doSteadyStateInit(Bool f) { mSteadyStateInit = f; } /// set steady state initialization time limit void setSteadStIniTimeLimit(Real v) { mSteadStIniTimeLimit = v; } /// set steady state initialization accuracy limit void setSteadStIniAccLimit(Real v) { mSteadStIniAccLimit = v; } // #### Getter #### - CPS::Bool getSplitSubnets() const { return **mSplitSubnets; } + CPS::Bool getSplitSubnets() const { return mSplitSubnets; } CPS::Bool getFreqParallel() const { return mFreqParallel; } CPS::Bool getSystemMatrixRecomputation() const { return mSystemMatrixRecomputation; } - CPS::Bool getSteadyStateInit() const { return **mSteadyStateInit; } + CPS::Bool getSteadyStateInit() const { return mSteadyStateInit; } CPS::Real getSteadyStateInitTimeLimit() const { return mSteadStIniTimeLimit; } CPS::Real getSteadyStateInitAccLimit() const { return mSteadStIniAccLimit; } }; diff --git a/dpsim/include/dpsim/SolverParametersNRP.h b/dpsim/include/dpsim/SolverParametersNRP.h index fc396b837d..c2765e52a8 100644 --- a/dpsim/include/dpsim/SolverParametersNRP.h +++ b/dpsim/include/dpsim/SolverParametersNRP.h @@ -38,13 +38,8 @@ namespace DPsim { // #### General simulation settings #### /// Simulation domain, which can be dynamic phasor (DP) or EMT - - public: - /// Destructor virtual ~SolverParametersNRP() {}; - - }; } diff --git a/dpsim/src/MNASolver.cpp b/dpsim/src/MNASolver.cpp index 0feeccd12b..616e83315e 100644 --- a/dpsim/src/MNASolver.cpp +++ b/dpsim/src/MNASolver.cpp @@ -9,7 +9,6 @@ #include #include -#include #include #include @@ -18,24 +17,19 @@ using namespace CPS; namespace DPsim { -/*CPS::Bool mSolverParamsMNA->getFreqParallel() = mSolverParamsMNA->getFreqParallel(); -CPS::Bool mSolverParamsMNA->getInitFromNodesAndTerminals() = mSolverParamsMNA->getInitFromNodesAndTerminals(); -CPS::Bool mSolverParamsMNA->getSplitSubnets() = mSolverParamsMNA->getSplitSubnets(); - -CPS::Bool mSolverParamsMNA->getTimeStep() = mSolverParamsMNA->getTimeStep(); -CPS::Bool mSolverParamsMNA->getSystemMatrixRecomputation() = mSolverParamsMNA->getSystemMatrixRecomputation(); -CPS::Real mSolverParamsMNA->getSteadyStateInitTimeLimit() = mSolverParamsMNA->getSteadyStateInitTimeLimit();*/ - template -MnaSolver::MnaSolver(String name, CPS::Domain domain, CPS::Logger::Level logLevel) : +MnaSolver::MnaSolver(String name, CPS::Domain domain, + std::shared_ptr solverParams, CPS::Logger::Level logLevel) : Solver(name, logLevel), mDomain(domain) { - + + // + mSolverParams = solverParams; + // Raw source and solution vector logging mLeftVectorLog = std::make_shared(name + "_LeftVector", logLevel != CPS::Logger::Level::off); mRightVectorLog = std::make_shared(name + "_RightVector", logLevel != CPS::Logger::Level::off); - } template @@ -47,69 +41,66 @@ template void MnaSolver::initialize() { // TODO: check that every system matrix has the same dimensions SPDLOG_LOGGER_INFO(mSLog, "---- Start initialization ----"); - auto mSolverParamsMNA = getMNAParameters(); - - if (mSolverParamsMNA != nullptr) { - // Register attribute for solution vector - ///FIXME: This is kinda ugly... At least we should somehow unify mLeftSideVector and mLeftSideVectorHarm. - // Best case we have some kind of sub-attributes for attribute vectors / tensor attributes... - if ( mSolverParamsMNA->getFreqParallel()) { - SPDLOG_LOGGER_INFO(mSLog, "Computing network harmonics in parallel."); - for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { - mLeftSideVectorHarm.push_back(AttributeStatic::make()); - } - } - else { - mLeftSideVector = AttributeStatic::make(); + + // Register attribute for solution vector + ///FIXME: This is kinda ugly... At least we should somehow unify mLeftSideVector and mLeftSideVectorHarm. + // Best case we have some kind of sub-attributes for attribute vectors / tensor attributes... + if ( mSolverParams->getFreqParallel()) { + SPDLOG_LOGGER_INFO(mSLog, "Computing network harmonics in parallel."); + for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { + mLeftSideVectorHarm.push_back(AttributeStatic::make()); } + } + else { + mLeftSideVector = AttributeStatic::make(); + } - SPDLOG_LOGGER_INFO(mSLog, "-- Process topology"); - for (auto comp : mSystem.mComponents) - SPDLOG_LOGGER_INFO(mSLog, "Added {:s} '{:s}' to simulation.", comp->type(), comp->name()); + SPDLOG_LOGGER_INFO(mSLog, "-- Process topology"); + for (auto comp : mSystem.mComponents) + SPDLOG_LOGGER_INFO(mSLog, "Added {:s} '{:s}' to simulation.", comp->type(), comp->name()); - // Otherwise LU decomposition will fail - if (mSystem.mComponents.size() == 0) - throw SolverException(); + // Otherwise LU decomposition will fail + if (mSystem.mComponents.size() == 0) + throw SolverException(); - // We need to differentiate between power and signal components and - // ground nodes should be ignored. - identifyTopologyObjects(); - // These steps complete the network information. - collectVirtualNodes(); - assignMatrixNodeIndices(); + // We need to differentiate between power and signal components and + // ground nodes should be ignored. + identifyTopologyObjects(); + // These steps complete the network information. + collectVirtualNodes(); + assignMatrixNodeIndices(); - SPDLOG_LOGGER_INFO(mSLog, "-- Create empty MNA system matrices and vectors"); - createEmptyVectors(); - createEmptySystemMatrix(); + SPDLOG_LOGGER_INFO(mSLog, "-- Create empty MNA system matrices and vectors"); + createEmptyVectors(); + createEmptySystemMatrix(); - // Initialize components from powerflow solution and - // calculate MNA specific initialization values. - initializeComponents(); + // Initialize components from powerflow solution and + // calculate MNA specific initialization values. + initializeComponents(); - if (mSolverParamsMNA->getSteadyStateInit()) { - mIsInInitialization = true; - steadyStateInitialization(); - } - mIsInInitialization = false; + if (mSolverParams->getSteadyStateInit()) { + mIsInInitialization = true; + steadyStateInitialization(); + } + mIsInInitialization = false; - // Some components feature a different behaviour for simulation and initialization - for (auto comp : mSystem.mComponents) { - auto powerComp = std::dynamic_pointer_cast(comp); - if (powerComp) powerComp->setBehaviour(TopologicalPowerComp::Behaviour::MNASimulation); + // Some components feature a different behaviour for simulation and initialization + for (auto comp : mSystem.mComponents) { + auto powerComp = std::dynamic_pointer_cast(comp); + if (powerComp) powerComp->setBehaviour(TopologicalPowerComp::Behaviour::MNASimulation); - auto sigComp = std::dynamic_pointer_cast(comp); - if (sigComp) sigComp->setBehaviour(SimSignalComp::Behaviour::Simulation); - } + auto sigComp = std::dynamic_pointer_cast(comp); + if (sigComp) sigComp->setBehaviour(SimSignalComp::Behaviour::Simulation); + } - // Initialize system matrices and source vector. - initializeSystem(); + // Initialize system matrices and source vector. + initializeSystem(); - SPDLOG_LOGGER_INFO(mSLog, "--- Initialization finished ---"); - SPDLOG_LOGGER_INFO(mSLog, "--- Initial system matrices and vectors ---"); - logSystemMatrices(); + SPDLOG_LOGGER_INFO(mSLog, "--- Initialization finished ---"); + SPDLOG_LOGGER_INFO(mSLog, "--- Initial system matrices and vectors ---"); + logSystemMatrices(); - mSLog->flush(); - } + mSLog->flush(); } template <> @@ -119,33 +110,30 @@ void MnaSolver::initializeComponents() { CPS::MNAInterface::List allMNAComps; allMNAComps.insert(allMNAComps.end(), mMNAComponents.begin(), mMNAComponents.end()); allMNAComps.insert(allMNAComps.end(), mMNAIntfVariableComps.begin(), mMNAIntfVariableComps.end()); - auto mSolverParamsMNA = getMNAParameters(); - if (mSolverParamsMNA != nullptr) { - for (auto comp : allMNAComps) { - auto pComp = std::dynamic_pointer_cast>(comp); - if (!pComp) continue; - pComp->checkForUnconnectedTerminals(); - if (mSolverParamsMNA->getInitFromNodesAndTerminals()) - pComp->initializeFromNodesAndTerminals(mSystem.mSystemFrequency); - } + for (auto comp : allMNAComps) { + auto pComp = std::dynamic_pointer_cast>(comp); + if (!pComp) continue; + pComp->checkForUnconnectedTerminals(); + if (mSolverParams->getInitFromNodesAndTerminals()) + pComp->initializeFromNodesAndTerminals(mSystem.mSystemFrequency); + } - // Initialize signal components. - for (auto comp : mSimSignalComps) - comp->initialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep()); + // Initialize signal components. + for (auto comp : mSimSignalComps) + comp->initialize(mSystem.mSystemOmega, mTimeStep); - // Initialize MNA specific parts of components. - for (auto comp : allMNAComps) { - comp->mnaInitialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep(), mLeftSideVector); - const Matrix& stamp = comp->getRightVector()->get(); - if (stamp.size() != 0) { - mRightVectorStamps.push_back(&stamp); - } + // Initialize MNA specific parts of components. + for (auto comp : allMNAComps) { + comp->mnaInitialize(mSystem.mSystemOmega, mTimeStep, mLeftSideVector); + const Matrix& stamp = comp->getRightVector()->get(); + if (stamp.size() != 0) { + mRightVectorStamps.push_back(&stamp); } - - for (auto comp : mMNAIntfSwitches) - comp->mnaInitialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep(), mLeftSideVector); } + + for (auto comp : mMNAIntfSwitches) + comp->mnaInitialize(mSystem.mSystemOmega, mTimeStep, mLeftSideVector); } template <> @@ -155,49 +143,46 @@ void MnaSolver::initializeComponents() { CPS::MNAInterface::List allMNAComps; allMNAComps.insert(allMNAComps.end(), mMNAComponents.begin(), mMNAComponents.end()); allMNAComps.insert(allMNAComps.end(), mMNAIntfVariableComps.begin(), mMNAIntfVariableComps.end()); - auto mSolverParamsMNA = getMNAParameters(); - if (mSolverParamsMNA != nullptr) { - // Initialize power components with frequencies and from powerflow results - for (auto comp : allMNAComps) { - auto pComp = std::dynamic_pointer_cast>(comp); - if (!pComp) continue; - pComp->checkForUnconnectedTerminals(); - if (mSolverParamsMNA->getInitFromNodesAndTerminals()) - pComp->initializeFromNodesAndTerminals(mSystem.mSystemFrequency); - } + // Initialize power components with frequencies and from powerflow results + for (auto comp : allMNAComps) { + auto pComp = std::dynamic_pointer_cast>(comp); + if (!pComp) continue; + pComp->checkForUnconnectedTerminals(); + if (mSolverParams->getInitFromNodesAndTerminals()) + pComp->initializeFromNodesAndTerminals(mSystem.mSystemFrequency); + } - // Initialize signal components. - for (auto comp : mSimSignalComps) - comp->initialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep()); + // Initialize signal components. + for (auto comp : mSimSignalComps) + comp->initialize(mSystem.mSystemOmega, mTimeStep); - SPDLOG_LOGGER_INFO(mSLog, "-- Initialize MNA properties of components"); - if (mSolverParamsMNA->getFreqParallel()) { + SPDLOG_LOGGER_INFO(mSLog, "-- Initialize MNA properties of components"); + if (mSolverParams->getFreqParallel()) { + // Initialize MNA specific parts of components. + for (auto comp : mMNAComponents) { // Initialize MNA specific parts of components. - for (auto comp : mMNAComponents) { - // Initialize MNA specific parts of components. - comp->mnaInitializeHarm(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep(), mLeftSideVectorHarm); - const Matrix& stamp = comp->getRightVector()->get(); - if (stamp.size() != 0) mRightVectorStamps.push_back(&stamp); - } - // Initialize nodes - for (UInt nodeIdx = 0; nodeIdx < mNodes.size(); ++nodeIdx) { - mNodes[nodeIdx]->mnaInitializeHarm(mLeftSideVectorHarm); - } + comp->mnaInitializeHarm(mSystem.mSystemOmega, mTimeStep, mLeftSideVectorHarm); + const Matrix& stamp = comp->getRightVector()->get(); + if (stamp.size() != 0) mRightVectorStamps.push_back(&stamp); } - else { - // Initialize MNA specific parts of components. - for (auto comp : allMNAComps) { - comp->mnaInitialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep(), mLeftSideVector); - const Matrix& stamp = comp->getRightVector()->get(); - if (stamp.size() != 0) { - mRightVectorStamps.push_back(&stamp); - } + // Initialize nodes + for (UInt nodeIdx = 0; nodeIdx < mNodes.size(); ++nodeIdx) { + mNodes[nodeIdx]->mnaInitializeHarm(mLeftSideVectorHarm); + } + } + else { + // Initialize MNA specific parts of components. + for (auto comp : allMNAComps) { + comp->mnaInitialize(mSystem.mSystemOmega, mTimeStep, mLeftSideVector); + const Matrix& stamp = comp->getRightVector()->get(); + if (stamp.size() != 0) { + mRightVectorStamps.push_back(&stamp); } - - for (auto comp : mMNAIntfSwitches) - comp->mnaInitialize(mSystem.mSystemOmega, mSolverParamsMNA->getTimeStep(), mLeftSideVector); } + + for (auto comp : mMNAIntfSwitches) + comp->mnaInitialize(mSystem.mSystemOmega, mTimeStep, mLeftSideVector); } } @@ -205,21 +190,19 @@ template void MnaSolver::initializeSystem() { SPDLOG_LOGGER_INFO(mSLog, "-- Initialize MNA system matrices and source vector"); mRightSideVector.setZero(); - auto mSolverParamsMNA = getMNAParameters(); - if (mSolverParamsMNA != nullptr) { - // just a sanity check in case we change the static - // initialization of the switch number in the future - if (mSwitches.size() > sizeof(std::size_t)*8) { - throw SystemError("Too many Switches."); - } - if (mSolverParamsMNA->getFreqParallel()) - initializeSystemWithParallelFrequencies(); - else if (mSolverParamsMNA->getSystemMatrixRecomputation()) - initializeSystemWithVariableMatrix(); - else - initializeSystemWithPrecomputedMatrices(); + // just a sanity check in case we change the static + // initialization of the switch number in the future + if (mSwitches.size() > sizeof(std::size_t)*8) { + throw SystemError("Too many Switches."); } + + if (mSolverParams->getFreqParallel()) + initializeSystemWithParallelFrequencies(); + else if (mSolverParams->getSystemMatrixRecomputation()) + initializeSystemWithVariableMatrix(); + else + initializeSystemWithPrecomputedMatrices(); } template @@ -401,20 +384,17 @@ void MnaSolver::createEmptyVectors() { template<> void MnaSolver::createEmptyVectors() { - auto mSolverParamsMNA = getMNAParameters(); - if (mSolverParamsMNA != nullptr) { - if (mSolverParamsMNA->getFreqParallel()) { - for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { - mRightSideVectorHarm.push_back(Matrix::Zero(2*(mNumMatrixNodeIndices), 1)); - mLeftSideVectorHarm.push_back(AttributeStatic::make(Matrix::Zero(2*(mNumMatrixNodeIndices), 1))); - } - } - else { - mRightSideVector = Matrix::Zero(2*(mNumMatrixNodeIndices + mNumHarmMatrixNodeIndices), 1); - **mLeftSideVector = Matrix::Zero(2*(mNumMatrixNodeIndices + mNumHarmMatrixNodeIndices), 1); + if (mSolverParams->getFreqParallel()) { + for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { + mRightSideVectorHarm.push_back(Matrix::Zero(2*(mNumMatrixNodeIndices), 1)); + mLeftSideVectorHarm.push_back(AttributeStatic::make(Matrix::Zero(2*(mNumMatrixNodeIndices), 1))); } } + else { + mRightSideVector = Matrix::Zero(2*(mNumMatrixNodeIndices + mNumHarmMatrixNodeIndices), 1); + **mLeftSideVector = Matrix::Zero(2*(mNumMatrixNodeIndices + mNumHarmMatrixNodeIndices), 1); + } } template @@ -473,142 +453,136 @@ void MnaSolver::collectVirtualNodes() { template void MnaSolver::steadyStateInitialization() { SPDLOG_LOGGER_INFO(mSLog, "--- Run steady-state initialization ---"); - auto mSolverParamsMNA = getMNAParameters(); - if (mSolverParamsMNA != nullptr) { - DataLogger initLeftVectorLog(mName + "_InitLeftVector", mLogLevel != CPS::Logger::Level::off); - DataLogger initRightVectorLog(mName + "_InitRightVector", mLogLevel != CPS::Logger::Level::off); + DataLogger initLeftVectorLog(mName + "_InitLeftVector", mLogLevel != CPS::Logger::Level::off); + DataLogger initRightVectorLog(mName + "_InitRightVector", mLogLevel != CPS::Logger::Level::off); - TopologicalPowerComp::Behaviour initBehaviourPowerComps = TopologicalPowerComp::Behaviour::Initialization; - SimSignalComp::Behaviour initBehaviourSignalComps = SimSignalComp::Behaviour::Initialization; + TopologicalPowerComp::Behaviour initBehaviourPowerComps = TopologicalPowerComp::Behaviour::Initialization; + SimSignalComp::Behaviour initBehaviourSignalComps = SimSignalComp::Behaviour::Initialization; - // TODO: enable use of timestep distinct from simulation timestep - Real initTimeStep = mSolverParamsMNA->getTimeStep(); - Int timeStepCount = 0; - Real time = 0; - Real maxDiff = 1.0; - Real max = 1.0; - Matrix diff = Matrix::Zero(2 * mNumNodes, 1); - Matrix prevLeftSideVector = Matrix::Zero(2 * mNumNodes, 1); + // TODO: enable use of timestep distinct from simulation timestep + Real initTimeStep = mTimeStep; + Int timeStepCount = 0; + Real time = 0; + Real maxDiff = 1.0; + Real max = 1.0; + Matrix diff = Matrix::Zero(2 * mNumNodes, 1); + Matrix prevLeftSideVector = Matrix::Zero(2 * mNumNodes, 1); - SPDLOG_LOGGER_INFO(mSLog, "Time step is {:f}s for steady-state initialization", initTimeStep); + SPDLOG_LOGGER_INFO(mSLog, "Time step is {:f}s for steady-state initialization", initTimeStep); - for (auto comp : mSystem.mComponents) { - auto powerComp = std::dynamic_pointer_cast(comp); - if (powerComp) powerComp->setBehaviour(initBehaviourPowerComps); + for (auto comp : mSystem.mComponents) { + auto powerComp = std::dynamic_pointer_cast(comp); + if (powerComp) powerComp->setBehaviour(initBehaviourPowerComps); - auto sigComp = std::dynamic_pointer_cast(comp); - if (sigComp) sigComp->setBehaviour(initBehaviourSignalComps); - } + auto sigComp = std::dynamic_pointer_cast(comp); + if (sigComp) sigComp->setBehaviour(initBehaviourSignalComps); + } - initializeSystem(); - logSystemMatrices(); + initializeSystem(); + logSystemMatrices(); - // Use sequential scheduler - SequentialScheduler sched; - CPS::Task::List tasks; - Scheduler::Edges inEdges, outEdges; + // Use sequential scheduler + SequentialScheduler sched; + CPS::Task::List tasks; + Scheduler::Edges inEdges, outEdges; - for (auto node : mNodes) { - for (auto task : node->mnaTasks()) - tasks.push_back(task); - } - for (auto comp : mMNAComponents) { - for (auto task : comp->mnaTasks()) { - tasks.push_back(task); - } + for (auto node : mNodes) { + for (auto task : node->mnaTasks()) + tasks.push_back(task); + } + for (auto comp : mMNAComponents) { + for (auto task : comp->mnaTasks()) { + tasks.push_back(task); } - // TODO signal components should be moved out of MNA solver - for (auto comp : mSimSignalComps) { - for (auto task : comp->getTasks()) { - tasks.push_back(task); - } + } + // TODO signal components should be moved out of MNA solver + for (auto comp : mSimSignalComps) { + for (auto task : comp->getTasks()) { + tasks.push_back(task); } - tasks.push_back(createSolveTask()); - - sched.resolveDeps(tasks, inEdges, outEdges); - sched.createSchedule(tasks, inEdges, outEdges); + } + tasks.push_back(createSolveTask()); - while (time < mSolverParamsMNA->getSteadyStateInitTimeLimit()) { - // Reset source vector - mRightSideVector.setZero(); + sched.resolveDeps(tasks, inEdges, outEdges); + sched.createSchedule(tasks, inEdges, outEdges); - sched.step(time, timeStepCount); + while (time < mSolverParams->getSteadyStateInitTimeLimit()) { + // Reset source vector + mRightSideVector.setZero(); - if (mDomain == CPS::Domain::EMT) { - initLeftVectorLog.logEMTNodeValues(time, leftSideVector()); - initRightVectorLog.logEMTNodeValues(time, rightSideVector()); - } - else { - initLeftVectorLog.logPhasorNodeValues(time, leftSideVector()); - initRightVectorLog.logPhasorNodeValues(time, rightSideVector()); - } + sched.step(time, timeStepCount); - // Calculate new simulation time - time = time + initTimeStep; - ++timeStepCount; - - // Calculate difference - diff = prevLeftSideVector - **mLeftSideVector; - prevLeftSideVector = **mLeftSideVector; - maxDiff = diff.lpNorm(); - max = (**mLeftSideVector).lpNorm(); - // If difference is smaller than some epsilon, break - if ((maxDiff / max) < mSolverParamsMNA->getSteadyStateInitAccLimit()) - break; + if (mDomain == CPS::Domain::EMT) { + initLeftVectorLog.logEMTNodeValues(time, leftSideVector()); + initRightVectorLog.logEMTNodeValues(time, rightSideVector()); } + else { + initLeftVectorLog.logPhasorNodeValues(time, leftSideVector()); + initRightVectorLog.logPhasorNodeValues(time, rightSideVector()); + } + + // Calculate new simulation time + time = time + initTimeStep; + ++timeStepCount; + + // Calculate difference + diff = prevLeftSideVector - **mLeftSideVector; + prevLeftSideVector = **mLeftSideVector; + maxDiff = diff.lpNorm(); + max = (**mLeftSideVector).lpNorm(); + // If difference is smaller than some epsilon, break + if ((maxDiff / max) < mSolverParams->getSteadyStateInitAccLimit()) + break; + } - SPDLOG_LOGGER_INFO(mSLog, "Max difference: {:f} or {:f}% at time {:f}", maxDiff, maxDiff / max, time); + SPDLOG_LOGGER_INFO(mSLog, "Max difference: {:f} or {:f}% at time {:f}", maxDiff, maxDiff / max, time); - // Reset system for actual simulation - mRightSideVector.setZero(); + // Reset system for actual simulation + mRightSideVector.setZero(); - SPDLOG_LOGGER_INFO(mSLog, "--- Finished steady-state initialization ---"); - } + SPDLOG_LOGGER_INFO(mSLog, "--- Finished steady-state initialization ---"); } template Task::List MnaSolver::getTasks() { Task::List l; - auto mSolverParamsMNA = getMNAParameters(); - if (mSolverParamsMNA != nullptr) { - for (auto comp : mMNAComponents) { - for (auto task : comp->mnaTasks()) { - l.push_back(task); - } + for (auto comp : mMNAComponents) { + for (auto task : comp->mnaTasks()) { + l.push_back(task); } - for (auto comp : mMNAIntfSwitches) { - for (auto task : comp->mnaTasks()) { - l.push_back(task); - } + } + for (auto comp : mMNAIntfSwitches) { + for (auto task : comp->mnaTasks()) { + l.push_back(task); } - for (auto node : mNodes) { - for (auto task : node->mnaTasks()) - l.push_back(task); + } + for (auto node : mNodes) { + for (auto task : node->mnaTasks()) + l.push_back(task); + } + // TODO signal components should be moved out of MNA solver + for (auto comp : mSimSignalComps) { + for (auto task : comp->getTasks()) { + l.push_back(task); } - // TODO signal components should be moved out of MNA solver - for (auto comp : mSimSignalComps) { - for (auto task : comp->getTasks()) { + } + if (mSolverParams->getFreqParallel()) { + for (UInt i = 0; i < mSystem.mFrequencies.size(); ++i) + l.push_back(createSolveTaskHarm(i)); + } else if (mSolverParams->getSystemMatrixRecomputation()) { + for (auto comp : this->mMNAIntfVariableComps) { + for (auto task : comp->mnaTasks()) l.push_back(task); - } - } - if (mSolverParamsMNA->getFreqParallel()) { - for (UInt i = 0; i < mSystem.mFrequencies.size(); ++i) - l.push_back(createSolveTaskHarm(i)); - } else if (mSolverParamsMNA->getSystemMatrixRecomputation()) { - for (auto comp : this->mMNAIntfVariableComps) { - for (auto task : comp->mnaTasks()) - l.push_back(task); - } - l.push_back(createSolveTaskRecomp()); - } else { - l.push_back(createSolveTask()); - l.push_back(createLogTask()); } + l.push_back(createSolveTaskRecomp()); + } else { + l.push_back(createSolveTask()); + l.push_back(createLogTask()); } + return l; - } diff --git a/dpsim/src/MNASolverDirect.cpp b/dpsim/src/MNASolverDirect.cpp index b4c0a99eb4..e8fffa0b88 100644 --- a/dpsim/src/MNASolverDirect.cpp +++ b/dpsim/src/MNASolverDirect.cpp @@ -15,7 +15,10 @@ using namespace CPS; namespace DPsim { template -MnaSolverDirect::MnaSolverDirect(String name, CPS::Domain domain, CPS::Logger::Level logLevel) : MnaSolver(name, domain, logLevel) { +MnaSolverDirect::MnaSolverDirect(String name, CPS::Domain domain, + std::shared_ptr solverParams, CPS::Logger::Level logLevel) : + MnaSolver(name, domain, solverParams, logLevel) { + mImplementationInUse = DirectLinearSolverImpl::SparseLU; } @@ -149,49 +152,43 @@ void MnaSolverDirect::recomputeSystemMatrix(Real time) { template<> void MnaSolverDirect::createEmptySystemMatrix() { - auto mSolverParamsMNA = getMNAParameters(); - if (mSolverParamsMNA != nullptr) { - if (mSwitches.size() > SWITCH_NUM) - throw SystemError("Too many Switches."); - - if (mSolverParamsMNA->mSystemMatrixRecomputation) { - mBaseSystemMatrix = SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices); - mVariableSystemMatrix = SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices); - } else { - for (std::size_t i = 0; i < (1ULL << mSwitches.size()); i++){ - auto bit = std::bitset(i); - mSwitchedMatrices[bit].push_back(SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices)); - mDirectLinearSolvers[bit].push_back(createDirectSolverImplementation(mSLog)); - } + if (mSwitches.size() > SWITCH_NUM) + throw SystemError("Too many Switches."); + + if (std::dynamic_pointer_cast(mSolverParams)->mSystemMatrixRecomputation) { + mBaseSystemMatrix = SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices); + mVariableSystemMatrix = SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices); + } else { + for (std::size_t i = 0; i < (1ULL << mSwitches.size()); i++){ + auto bit = std::bitset(i); + mSwitchedMatrices[bit].push_back(SparseMatrix(mNumMatrixNodeIndices, mNumMatrixNodeIndices)); + mDirectLinearSolvers[bit].push_back(createDirectSolverImplementation(mSLog)); } } } template<> void MnaSolverDirect::createEmptySystemMatrix() { - auto mSolverParamsMNA = getMNAParameters(); - if (mSolverParamsMNA != nullptr) { - if (mSwitches.size() > SWITCH_NUM) - throw SystemError("Too many Switches."); - - if (mSolverParamsMNA->mFreqParallel) { - for (UInt i = 0; i < std::pow(2,mSwitches.size()); ++i) { - for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { - auto bit = std::bitset(i); - mSwitchedMatrices[bit].push_back(SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices))); - mDirectLinearSolvers[bit].push_back(createDirectSolverImplementation(mSLog)); - } - } - } else if (mSolverParamsMNA->mSystemMatrixRecomputation) { - mBaseSystemMatrix = SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices)); - mVariableSystemMatrix = SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices)); - } else { - for (std::size_t i = 0; i < (1ULL << mSwitches.size()); i++) { + if (mSwitches.size() > SWITCH_NUM) + throw SystemError("Too many Switches."); + + if (mSolverParams->mFreqParallel) { + for (UInt i = 0; i < std::pow(2,mSwitches.size()); ++i) { + for(Int freq = 0; freq < mSystem.mFrequencies.size(); ++freq) { auto bit = std::bitset(i); - mSwitchedMatrices[bit].push_back(SparseMatrix(2*(mNumTotalMatrixNodeIndices), 2*(mNumTotalMatrixNodeIndices))); + mSwitchedMatrices[bit].push_back(SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices))); mDirectLinearSolvers[bit].push_back(createDirectSolverImplementation(mSLog)); } } + } else if (std::dynamic_pointer_cast(mSolverParams)->mSystemMatrixRecomputation) { + mBaseSystemMatrix = SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices)); + mVariableSystemMatrix = SparseMatrix(2*(mNumMatrixNodeIndices), 2*(mNumMatrixNodeIndices)); + } else { + for (std::size_t i = 0; i < (1ULL << mSwitches.size()); i++) { + auto bit = std::bitset(i); + mSwitchedMatrices[bit].push_back(SparseMatrix(2*(mNumTotalMatrixNodeIndices), 2*(mNumTotalMatrixNodeIndices))); + mDirectLinearSolvers[bit].push_back(createDirectSolverImplementation(mSLog)); + } } } @@ -311,37 +308,33 @@ void MnaSolverDirect::solveWithHarmonics(Real time, Int timeStepCount, template void MnaSolverDirect::logSystemMatrices() { - auto mSolverParamsMNA = getMNAParameters(); - if (mSolverParamsMNA != nullptr) { - if (mSolverParamsMNA->mFreqParallel) { - for (UInt i = 0; i < mSwitchedMatrices[std::bitset(0)].size(); ++i) { - SPDLOG_LOGGER_INFO(mSLog, "System matrix for frequency: {:d} \n{:s}", i, Logger::matrixToString(mSwitchedMatrices[std::bitset(0)][i])); - } - - for (UInt i = 0; i < mRightSideVectorHarm.size(); ++i) { - SPDLOG_LOGGER_INFO(mSLog, "Right side vector for frequency: {:d} \n{:s}", i, Logger::matrixToString(mRightSideVectorHarm[i])); - } + if (mSolverParams->mFreqParallel) { + for (UInt i = 0; i < mSwitchedMatrices[std::bitset(0)].size(); ++i) { + SPDLOG_LOGGER_INFO(mSLog, "System matrix for frequency: {:d} \n{:s}", i, Logger::matrixToString(mSwitchedMatrices[std::bitset(0)][i])); + } + for (UInt i = 0; i < mRightSideVectorHarm.size(); ++i) { + SPDLOG_LOGGER_INFO(mSLog, "Right side vector for frequency: {:d} \n{:s}", i, Logger::matrixToString(mRightSideVectorHarm[i])); } - else if (mSolverParamsMNA->mSystemMatrixRecomputation) { - SPDLOG_LOGGER_INFO(mSLog, "Summarizing matrices: "); - SPDLOG_LOGGER_INFO(mSLog, "Base matrix with only static elements: {}", Logger::matrixToString(mBaseSystemMatrix)); - SPDLOG_LOGGER_INFO(mSLog, "Initial system matrix with variable elements {}", Logger::matrixToString(mVariableSystemMatrix)); - SPDLOG_LOGGER_INFO(mSLog, "Right side vector: {}", Logger::matrixToString(mRightSideVector)); - } else { - if (mSwitches.size() < 1) { - SPDLOG_LOGGER_INFO(mSLog, "System matrix: \n{}", mSwitchedMatrices[std::bitset(0)][0]); - } - else { - SPDLOG_LOGGER_INFO(mSLog, "Initial switch status: {:s}", mCurrentSwitchStatus.to_string()); + } + else if (mSolverParams->mSystemMatrixRecomputation) { + SPDLOG_LOGGER_INFO(mSLog, "Summarizing matrices: "); + SPDLOG_LOGGER_INFO(mSLog, "Base matrix with only static elements: {}", Logger::matrixToString(mBaseSystemMatrix)); + SPDLOG_LOGGER_INFO(mSLog, "Initial system matrix with variable elements {}", Logger::matrixToString(mVariableSystemMatrix)); + SPDLOG_LOGGER_INFO(mSLog, "Right side vector: {}", Logger::matrixToString(mRightSideVector)); + } else { + if (mSwitches.size() < 1) { + SPDLOG_LOGGER_INFO(mSLog, "System matrix: \n{}", mSwitchedMatrices[std::bitset(0)][0]); + } + else { + SPDLOG_LOGGER_INFO(mSLog, "Initial switch status: {:s}", mCurrentSwitchStatus.to_string()); - for (auto sys : mSwitchedMatrices) { - SPDLOG_LOGGER_INFO(mSLog, "Switching System matrix {:s} \n{:s}", - sys.first.to_string(), Logger::matrixToString(sys.second[0])); - } + for (auto sys : mSwitchedMatrices) { + SPDLOG_LOGGER_INFO(mSLog, "Switching System matrix {:s} \n{:s}", + sys.first.to_string(), Logger::matrixToString(sys.second[0])); } - SPDLOG_LOGGER_INFO(mSLog, "Right side vector: \n{}", mRightSideVector); } + SPDLOG_LOGGER_INFO(mSLog, "Right side vector: \n{}", mRightSideVector); } } diff --git a/dpsim/src/MNASolverPlugin.cpp b/dpsim/src/MNASolverPlugin.cpp index f132b195e4..749d0e72cc 100644 --- a/dpsim/src/MNASolverPlugin.cpp +++ b/dpsim/src/MNASolverPlugin.cpp @@ -18,9 +18,9 @@ namespace DPsim { template MnaSolverPlugin::MnaSolverPlugin(String pluginName, - String name, - CPS::Domain domain, CPS::Logger::Level logLevel) : - MnaSolverDirect(name, domain, logLevel), + String name, CPS::Domain domain, + std::shared_ptr solverParams, CPS::Logger::Level logLevel) : + MnaSolverDirect(name, domain, solverParams, logLevel), mPluginName(pluginName), mPlugin(nullptr), mDlHandle(nullptr) diff --git a/dpsim/src/PFSolver.cpp b/dpsim/src/PFSolver.cpp index 480f9cd6e3..47d3b16e1f 100644 --- a/dpsim/src/PFSolver.cpp +++ b/dpsim/src/PFSolver.cpp @@ -13,10 +13,11 @@ using namespace DPsim; using namespace CPS; -PFSolver::PFSolver(CPS::String name, CPS::SystemTopology system, CPS::Real timeStep, CPS::Logger::Level logLevel) : +PFSolver::PFSolver(CPS::String name, CPS::SystemTopology system, CPS::Real timeStep, std::shared_ptr solverParams, CPS::Logger::Level logLevel) : Solver(name + "_PF", logLevel) { mSystem = system; mTimeStep = timeStep; + mSolverParams = solverParams; } void PFSolver::initialize(){ @@ -65,7 +66,6 @@ void PFSolver::assignMatrixNodeIndices() { } void PFSolver::initializeComponents(){ - std::shared_ptr mSolverParamsMNA = getMNAParameters(); for (auto comp : mSystem.mComponents) { std::dynamic_pointer_cast>(comp)->updateMatrixNodeIndices(); } @@ -74,7 +74,7 @@ void PFSolver::initializeComponents(){ for (auto comp : mSystem.mComponents) { auto pComp = std::dynamic_pointer_cast>(comp); if (!pComp) continue; - if (mSolverParamsMNA->mInitFromNodesAndTerminals) + if (mSolverParams->mInitFromNodesAndTerminals) pComp->initializeFromNodesAndTerminals(mSystem.mSystemFrequency); } @@ -299,9 +299,8 @@ void PFSolver::modifyPowerFlowBusComponent(CPS::String name, CPS::PowerflowBusTy } void PFSolver::setSolverAndComponentBehaviour(Solver::Behaviour behaviour) { - std::shared_ptr mSolverParamsMNA = getMNAParameters(); - mSolverParamsMNA->mSolverBehaviour = behaviour; - if (mSolverParamsMNA->mSolverBehaviour == Behaviour::Initialization) { + mSolverParams->mSolverBehaviour = behaviour; + if (mSolverParams->mSolverBehaviour == Behaviour::Initialization) { SPDLOG_LOGGER_INFO(mSLog, "-- Set solver behaviour to Initialization"); // TODO: solver setting specific to initialization (e.g. one single PF run) diff --git a/dpsim/src/PFSolverPowerPolar.cpp b/dpsim/src/PFSolverPowerPolar.cpp index 0fd371e1b2..c2d49f9615 100644 --- a/dpsim/src/PFSolverPowerPolar.cpp +++ b/dpsim/src/PFSolverPowerPolar.cpp @@ -11,8 +11,8 @@ using namespace DPsim; using namespace CPS; -PFSolverPowerPolar::PFSolverPowerPolar(CPS::String name, const CPS::SystemTopology &system, CPS::Real timeStep, CPS::Logger::Level logLevel) - : PFSolver(name, system, timeStep, logLevel){ } +PFSolverPowerPolar::PFSolverPowerPolar(CPS::String name, const CPS::SystemTopology &system, CPS::Real timeStep, std::shared_ptr solverParams, CPS::Logger::Level logLevel) + : PFSolver(name, system, timeStep, solverParams, logLevel){ } void PFSolverPowerPolar::generateInitialSolution(Real time, bool keep_last_solution) { resize_sol(mSystem.mNodes.size()); diff --git a/dpsim/src/Simulation.cpp b/dpsim/src/Simulation.cpp index 61306be864..902146f400 100644 --- a/dpsim/src/Simulation.cpp +++ b/dpsim/src/Simulation.cpp @@ -51,28 +51,54 @@ Simulation::Simulation(String name, CommandLineArgs& args) : create(); } -void Simulation::setSolverParameters(CPS::Domain domain, Solver::Type type, std::shared_ptr &solverParameters) +void Simulation::setSolverParameters(CPS::Domain domain, Solver::Type type, std::shared_ptr solverParameters) { mDomain = domain; - if ((typeid(solverParameters) == typeid(SolverParametersMNA)) && (type == Solver::Type::MNA)) { - cout << "Object is of type SolverParametersMNA" << endl; - mSolverParams = solverParameters; - mSolverType = Solver::Type::MNA; + mSolverType = Solver::Type::MNA; + if (mSolverType == Solver::Type::MNA) { + if (solverParameters==nullptr) { + mSolverParams = std::make_shared(); + return; + } else if (std::dynamic_pointer_cast(solverParameters)) { + mSolverParams = solverParameters; + return; + } + else { + std::stringstream ss; + ss << "Type of SolverParameters has to be SolverParametersMNA!!"; + throw std::invalid_argument(ss.str()); + } } - else if ((typeid(solverParameters) == typeid(SolverParametersDAE)) && (type == Solver::Type::DAE)) { - cout << "Object is of type SolverParametersMNA" << endl; - mSolverParams = solverParameters; - mSolverType = Solver::Type::DAE; + + if (mSolverType == Solver::Type::DAE) { + if (solverParameters==nullptr) { + mSolverParams = std::make_shared(); + return; + } else if (std::dynamic_pointer_cast(solverParameters)) { + mSolverParams = solverParameters; + return; + } + else { + std::stringstream ss; + ss << "Type of SolverParameters has to be SolverParametersDAE!!"; + throw std::invalid_argument(ss.str()); + } } - else if ((typeid(solverParameters) == typeid(SolverParametersNRP)) && (type == Solver::Type::NRP)) { - cout << "Object is of type SolverParametersMNA" << endl; - mSolverParams = solverParameters; - mSolverType = Solver::Type::NRP; + + if (mSolverType == Solver::Type::NRP) { + if (solverParameters==nullptr) { + mSolverParams = std::make_shared(); + return; + } else if (std::dynamic_pointer_cast(solverParameters)) { + mSolverParams = solverParameters; + return; + } + else { + std::stringstream ss; + ss << "Type of SolverParameters has to be SolverParametersNRP!!"; + throw std::invalid_argument(ss.str()); + } } - else { - cout << "Object is of unknown type" << endl; - mSolverParams = solverParameters; - } } void Simulation::create() { @@ -89,7 +115,6 @@ void Simulation::initialize() { return; mSolvers.clear(); - switch (mDomain) { case Domain::SP: // Treat SP as DP @@ -123,10 +148,8 @@ void Simulation::createSolvers() { break; #endif /* WITH_SUNDIALS */ case Solver::Type::NRP: - solver = std::make_shared(**mName, mSystem, **mTimeStep, mLogLevel); - solver->setSolverParameters(mSolverParams); - //solver->doInitFromNodesAndTerminals(mInitFromNodesAndTerminals); - //solver->setSolverAndComponentBehaviour(mSolverBehaviour); + solver = std::make_shared(**mName, mSystem, **mTimeStep, + std::dynamic_pointer_cast(mSolverParams), mLogLevel); solver->initialize(); mSolvers.push_back(solver); break; @@ -155,44 +178,33 @@ void Simulation::createMNASolver() { std::vector subnets; // The Diakoptics solver splits the system at a later point. // That is why the system is not split here if tear components exist. - std::shared_ptr mSolverParamsMNA = std::dynamic_pointer_cast(mSolverParams); - if (mSolverParamsMNA != nullptr) { - if ( mSolverParamsMNA->getSplitSubnets() && mTearComponents.size() == 0) - mSystem.splitSubnets(subnets); - else - subnets.push_back(mSystem); - - for (UInt net = 0; net < subnets.size(); ++net) { - String copySuffix; - if (subnets.size() > 1) - copySuffix = "_" + std::to_string(net); - - // TODO: In the future, here we could possibly even use different - // solvers for different subnets if deemed useful - if (mTearComponents.size() > 0) { - // Tear components available, use diakoptics - solver = std::make_shared>(**mName, - subnets[net], mTearComponents, **mTimeStep, mLogLevel); - } else { - // Default case with lu decomposition from mna factory - solver = MnaSolverFactory::factory(**mName + copySuffix, mDomain, - mLogLevel, mSolverParamsMNA->mDirectImpl, mSolverPluginName); - solver->setTimeStep(**mTimeStep); - solver->setSolverParameters(mSolverParams); - //solver->doSteadyStateInit(**mSteadyStateInit); - //solver->doFrequencyParallelization(mFreqParallel); - //solver->setSteadStIniTimeLimit(mSteadStIniTimeLimit); - //solver->setSteadStIniAccLimit(mSteadStIniAccLimit); - solver->setSystem(subnets[net]); - //solver->setSolverAndComponentBehaviour(mSolverBehaviour); - //solver->doInitFromNodesAndTerminals(mInitFromNodesAndTerminals); - //solver->doSystemMatrixRecomputation(mSystemMatrixRecomputation); - //solver->setDirectLinearSolverConfiguration(mDirectLinearSolverConfiguration); - solver->initialize(); - solver->setMaxNumberOfIterations(mMaxIterations); - } - mSolvers.push_back(solver); + if ( std::dynamic_pointer_cast(mSolverParams)->getSplitSubnets() && mTearComponents.size() == 0) + mSystem.splitSubnets(subnets); + else + subnets.push_back(mSystem); + + for (UInt net = 0; net < subnets.size(); ++net) { + String copySuffix; + if (subnets.size() > 1) + copySuffix = "_" + std::to_string(net); + + // TODO: In the future, here we could possibly even use different + // solvers for different subnets if deemed useful + if (mTearComponents.size() > 0) { + // Tear components available, use diakoptics + solver = std::make_shared>(**mName, + subnets[net], mTearComponents, **mTimeStep, mLogLevel); + } else { + // Default case with lu decomposition from mna factory + solver = MnaSolverFactory::factory(**mName + copySuffix, + mDomain, std::dynamic_pointer_cast(mSolverParams), + mLogLevel, mSolverPluginName); + solver->setTimeStep(**mTimeStep); + solver->setSystem(subnets[net]); + solver->initialize(); + solver->setMaxNumberOfIterations(mMaxIterations); } + mSolvers.push_back(solver); } } @@ -361,6 +373,7 @@ Graph::Graph Simulation::dependencyGraph() { void Simulation::start() { SPDLOG_LOGGER_INFO(mLog, "Initialize simulation: {}", **mName); + mLog->flush(); if (!mInitialized) initialize(); @@ -393,7 +406,6 @@ void Simulation::stop() { lg->close(); SPDLOG_LOGGER_INFO(mLog, "Simulation finished."); - mLog->flush(); } Real Simulation::next() { diff --git a/dpsim/src/pybind/main.cpp b/dpsim/src/pybind/main.cpp index f2091fba80..4532de5fde 100644 --- a/dpsim/src/pybind/main.cpp +++ b/dpsim/src/pybind/main.cpp @@ -67,14 +67,12 @@ PYBIND11_MODULE(dpsimpy, m) { addAttributes(m); - py::class_(m, "SolverParameters") + py::class_>(m, "SolverParameters") .def(py::init<>()) - .def("set_time_step", &DPsim::SolverParameters::setTimeStep) .def("set_init_from_nodes_and_terminals", &DPsim::SolverParameters::setInitFromNodesAndTerminals) - .def("get_time_step", &DPsim::SolverParameters::getTimeStep) .def("get_init_from_nodes_and_terminals", &DPsim::SolverParameters::getInitFromNodesAndTerminals); - py::class_(m, "SolverParametersMNA") + py::class_>(m, "SolverParametersMNA", py::multiple_inheritance()) .def(py::init<>()) .def("set_domain", &DPsim::SolverParametersMNA::setDomain) .def("set_solver_and_component_behaviour", &DPsim::SolverParametersMNA::setSolverAndComponentBehaviour) @@ -108,13 +106,13 @@ PYBIND11_MODULE(dpsimpy, m) { .def("name", &DPsim::Simulation::name) .def("set_time_step", &DPsim::Simulation::setTimeStep) .def("set_final_time", &DPsim::Simulation::setFinalTime) + .def("set_simulation_parameters", &DPsim::Simulation::setSimulationParameters, "time_step"_a, "final_time"_a) .def("add_logger", &DPsim::Simulation::addLogger) .def("set_system", &DPsim::Simulation::setSystem) .def("run", &DPsim::Simulation::run) .def("set_solver", &DPsim::Simulation::setSolverType) .def("set_domain", &DPsim::Simulation::setDomain) - .def("set_simulation_parameters", &DPsim::Simulation::setSimulationParameters, "a"_a,"b"_a) - .def("set_solver_parameters", &DPsim::Simulation::setSolverParameters, "domain"_a, "type"_a, "solverParameters"_a) + .def("set_solver_parameters", &DPsim::Simulation::setSolverParameters, "domain"_a, "type"_a, "solverParameters"_a=nullptr) .def("start", &DPsim::Simulation::start) .def("next", &DPsim::Simulation::next) .def("get_idobj_attr", &DPsim::Simulation::getIdObjAttribute, "comp"_a, "attr"_a) diff --git a/examples/Notebooks/Circuits/CS_R2CL.ipynb b/examples/Notebooks/Circuits/CS_R2CL.ipynb index 836c422d95..3192189ce6 100644 --- a/examples/Notebooks/Circuits/CS_R2CL.ipynb +++ b/examples/Notebooks/Circuits/CS_R2CL.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -9,16 +10,22 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import villas.dataprocessing.readtools as rt\n", "import villas.dataprocessing.plottools as pt\n", - "from villas.dataprocessing.timeseries import TimeSeries as ts" + "from villas.dataprocessing.timeseries import TimeSeries as ts\n", + "\n", + "import sys\n", + "sys.path.insert(0,'/home/mmo/git/Can/dpsim/build')\n", + "sys.path.remove('/home/mmo/git/lund-anm-control')\n", + "import dpsimpy" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -27,27 +34,23 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": {}, "outputs": [ { - "ename": "RuntimeError", - "evalue": "Unable to load a custom holder type from a default-holder instance", + "ename": "ValueError", + "evalue": "Type of SolverParameters has to be SolverParametersMNA!!", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/home/mmo-cya/dpsim/examples/Notebooks/Circuits/CS_R2CL.ipynb Cell 4\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 48\u001b[0m sim\u001b[39m.\u001b[39mset_time_step(\u001b[39m0.0001\u001b[39m)\n\u001b[1;32m 49\u001b[0m sim\u001b[39m.\u001b[39mset_final_time(\u001b[39m0.1\u001b[39m)\n\u001b[0;32m---> 50\u001b[0m sim\u001b[39m.\u001b[39;49mset_solver_parameters(dpsimpy\u001b[39m.\u001b[39;49mDomain\u001b[39m.\u001b[39;49mEMT, dpsimpy\u001b[39m.\u001b[39;49mSolver\u001b[39m.\u001b[39;49mMNA, mna_parameter)\n", - "\u001b[0;31mRuntimeError\u001b[0m: Unable to load a custom holder type from a default-holder instance" + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/mmo/git/Can/dpsim/examples/Notebooks/Circuits/CS_R2CL.ipynb Cell 4\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 41\u001b[0m sim\u001b[39m.\u001b[39mset_system(system)\n\u001b[1;32m 42\u001b[0m sim\u001b[39m.\u001b[39mset_simulation_parameters(time_step\u001b[39m=\u001b[39m\u001b[39m0.0001\u001b[39m, final_time\u001b[39m=\u001b[39m\u001b[39m0.1\u001b[39m)\n\u001b[0;32m---> 43\u001b[0m sim\u001b[39m.\u001b[39;49mset_solver_parameters(dpsimpy\u001b[39m.\u001b[39;49mDomain\u001b[39m.\u001b[39;49mEMT, dpsimpy\u001b[39m.\u001b[39;49mSolver\u001b[39m.\u001b[39;49mMNA)\n\u001b[1;32m 44\u001b[0m sim\u001b[39m.\u001b[39madd_logger(logger)\n", + "\u001b[0;31mValueError\u001b[0m: Type of SolverParameters has to be SolverParametersMNA!!" ] } ], "source": [ "# DPsim EMT simulation\n", - "import sys\n", - "sys.path.insert(0,'/home/mmo-cya/dpsim/build')\n", - "import dpsimpy\n", - "\n", "name = 'EMT_CS_R2CL'\n", "\n", "# Nodes\n", @@ -56,24 +59,24 @@ "n2 = dpsimpy.emt.SimNode('n2')\n", "\n", "# Components\n", - "cs = dpsimpy.emt.ph1.CurrentSource('cs')\n", + "cs = dpsimpy.emt.ph1.CurrentSource('cs', dpsimpy.LogLevel.info)\n", "cs.I_ref = complex(10, 0)\n", "cs.f_src = 50\n", - "r1 = dpsimpy.emt.ph1.Resistor('r_1')\n", + "r1 = dpsimpy.emt.ph1.Resistor('r_1', dpsimpy.LogLevel.info)\n", "r1.R = 1\n", - "c1 = dpsimpy.emt.ph1.Capacitor('c_1')\n", + "c1 = dpsimpy.emt.ph1.Capacitor('c_1', dpsimpy.LogLevel.info)\n", "c1.C = 0.001\n", - "l1 = dpsimpy.emt.ph1.Inductor('l_1')\n", + "l1 = dpsimpy.emt.ph1.Inductor('l_1', dpsimpy.LogLevel.info)\n", "l1.L = 0.001\n", - "r2 = dpsimpy.emt.ph1.Resistor('r_2')\n", + "r2 = dpsimpy.emt.ph1.Resistor('r_2', dpsimpy.LogLevel.info)\n", "r2.R = 1\n", "\n", "# Connections\n", "cs.connect([gnd, n1])\n", "r1.connect([n1, gnd])\n", - "c1.connect([n1, n2]);\n", - "l1.connect([n2, gnd]);\n", - "r2.connect([n2, gnd]);\n", + "c1.connect([n1, n2])\n", + "l1.connect([n2, gnd])\n", + "r2.connect([n2, gnd])\n", "\n", "# Define system topology\n", "system = dpsimpy.SystemTopology(50, [gnd, n1, n2], [cs, r1, c1, l1, r2])\n", @@ -85,28 +88,17 @@ "logger.log_attribute('cs.i_intf', 'i_intf', cs)\n", "logger.log_attribute('c_1.i_intf', 'i_intf', c1)\n", "\n", - "mna_parameter = dpsimpy.SolverParametersMNA()\n", - "\n", - "sim = dpsimpy.Simulation(name)\n", - "sim.set_domain(dpsimpy.Domain.EMT)\n", + "#\n", + "sim = dpsimpy.Simulation(name, dpsimpy.LogLevel.info)\n", "sim.set_system(system)\n", - "sim.set_time_step(0.0001)\n", - "sim.set_final_time(0.1)\n", - "sim.set_solver_parameters(dpsimpy.Domain.EMT, dpsimpy.Solver.MNA, mna_parameter)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ + "sim.set_simulation_parameters(time_step=0.0001, final_time=0.1)\n", + "sim.set_solver_parameters(type=dpsimpy.Domain.EMT, domain=dpsimpy.Solver.MNA)\n", "sim.add_logger(logger)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -115,21 +107,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "logs/EMT_CS_R2CL.csv\n", - "column number: 4\n", - "results length: 1000\n", - "real column names: ['c_1.i_intf', 'cs.i_intf', 'n1.v', 'n2.v']\n", - "complex column names: []\n" - ] - } - ], + "outputs": [], "source": [ "# read EMT results\n", "work_dir = 'logs/'\n", @@ -141,34 +121,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "v1_emt = 'n1.v'\n", "v2_emt = 'n2.v'\n", @@ -186,6 +141,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -194,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -237,16 +193,19 @@ "logger.log_attribute('cs.i_intf', 'i_intf', cs)\n", "logger.log_attribute('c_1.i_intf', 'i_intf', c1)\n", "\n", + "# \n", + "mna_parameters = dpsimpy.SolverParametersMNA()\n", + "\n", + "#\n", "sim = dpsimpy.Simulation(name)\n", "sim.set_system(system)\n", - "sim.set_domain(dpsimpy.Domain.DP)\n", - "sim.set_time_step(0.0001)\n", - "sim.set_final_time(0.1)" + "sim.set_simulation_parameters(time_step=0.0001, final_time=0.1)\n", + "sim.set_solver_parameters(dpsimpy.Domain.DP, dpsimpy.Solver.MNA, mna_parameters)" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -255,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -264,21 +223,9 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "logs/DP_CS_R2CL.csv\n", - "column number: 4\n", - "results length: 1000\n", - "real column names: []\n", - "complex column names: ['c_1.i_intf', 'cs.i_intf', 'n1.v', 'n2.v']\n" - ] - } - ], + "outputs": [], "source": [ "# read DP results\n", "work_dir = 'logs/'\n", @@ -293,34 +240,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "v1_dp = 'n1.v_shift'\n", "v2_dp = 'n2.v_shift'\n", @@ -338,6 +260,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -346,20 +269,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "column number: 4\n", - "results length: 1001\n", - "real column names: ['v1', 'v2', 'i12', 'i34']\n", - "complex column names: []\n" - ] - } - ], + "outputs": [], "source": [ "# read Simulink log file\n", "import os\n", @@ -377,34 +289,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "v1_sl = 'v1'\n", "v2_sl = 'v2'\n", @@ -422,6 +309,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -430,58 +318,9 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# plot v1\n", "pt.plot_timeseries(1, ts_dpsim_emt[v1_emt])\n", @@ -506,18 +345,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total RMSE of Simulink reference and DPsim EMT: 3.64741\n", - "Total RMSE of Simulink reference and DPsim DP: 3.64741\n" - ] - } - ], + "outputs": [], "source": [ "# calculate the RMSE between Simulink (ts_sl) and EMT (ts_dpsim_emt)\n", "err_sl_emt = 0\n", @@ -536,32 +366,13 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/home/mmo-cya/dpsim/examples/Notebooks/Circuits/CS_R2CL.ipynb Cell 21\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[39massert\u001b[39;00m err_sl_emt \u001b[39m<\u001b[39m \u001b[39m0.1\u001b[39m\n\u001b[1;32m 2\u001b[0m \u001b[39massert\u001b[39;00m err_sl_dp \u001b[39m<\u001b[39m \u001b[39m0.1\u001b[39m\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "assert err_sl_emt < 0.1\n", "assert err_sl_dp < 0.1" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/examples/Notebooks/Circuits/VS_RL1.ipynb b/examples/Notebooks/Circuits/VS_RL1.ipynb index d41f6a1114..c408a908b9 100644 --- a/examples/Notebooks/Circuits/VS_RL1.ipynb +++ b/examples/Notebooks/Circuits/VS_RL1.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -20,6 +21,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -71,6 +73,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -159,6 +162,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -249,6 +253,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -290,6 +295,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ From 78345022e91fd402113146cb3733c0e5d6a09a3a Mon Sep 17 00:00:00 2001 From: Martin Moraga Date: Wed, 5 Jul 2023 11:05:16 +0200 Subject: [PATCH 6/6] use SolverParameters in all examples Signed-off-by: Martin Moraga --- .../cxx/CIM/CIGRE_MV_PowerFlowTest.cpp | 10 +- .../CIGRE_MV_PowerFlowTest_LoadProfiles.cpp | 14 +-- dpsim/examples/cxx/CIM/DP_CIGRE_MV_withDG.cpp | 26 +++--- .../CIM/DP_CIGRE_MV_withDG_withLoadStep.cpp | 25 +++-- .../cxx/CIM/DP_CIGRE_MV_withoutDG.cpp | 28 ++++-- .../examples/cxx/CIM/DP_WSCC-9bus_IdealVS.cpp | 21 +++-- .../CIM/DP_WSCC9bus_SGReducedOrderIter.cpp | 22 +++-- .../cxx/CIM/DP_WSCC9bus_SGReducedOrderVBR.cpp | 24 +++-- .../examples/cxx/CIM/EMT_CIGRE_MV_withDG.cpp | 26 +++--- .../CIM/EMT_CIGRE_MV_withDG_withLoadStep.cpp | 26 ++++-- .../cxx/CIM/EMT_CIGRE_MV_withoutDG.cpp | 30 +++--- .../cxx/CIM/EMT_WSCC-9bus_FullOrderSG.cpp | 27 +++--- .../cxx/CIM/EMT_WSCC-9bus_IdealCS.cpp | 11 ++- .../cxx/CIM/EMT_WSCC-9bus_IdealVS.cpp | 13 +-- dpsim/examples/cxx/CIM/EMT_WSCC-9bus_VBR.cpp | 28 +++--- .../CIM/EMT_WSCC9bus_SGReducedOrderVBR.cpp | 27 ++++-- .../cxx/CIM/IEEE_LV_PowerFlowTest.cpp | 12 ++- dpsim/examples/cxx/CIM/PF_CIGRE_MV_withDG.cpp | 17 ++-- .../cxx/CIM/SP_WSCC-9bus_CIM_Dyn_Switch.cpp | 10 +- .../cxx/CIM/SP_WSCC9bus_SGReducedOrderVBR.cpp | 33 ++++--- .../cxx/CIM/Slack_TrafoTapChanger_Load.cpp | 14 +-- dpsim/examples/cxx/CIM/Slack_Trafo_Load.cpp | 15 +-- dpsim/examples/cxx/CIM/WSCC-9bus_CIM.cpp | 24 +++-- dpsim/examples/cxx/CIM/WSCC-9bus_CIM_Dyn.cpp | 10 +- .../cxx/CIM/WSCC-9bus_CIM_Dyn_Switch.cpp | 10 +- .../cxx/Circuits/DP_Basics_DP_Sims.cpp | 20 ++-- .../cxx/Circuits/DP_Basics_EMT_Sims.cpp | 9 +- .../cxx/Circuits/DP_DecouplingLine.cpp | 9 +- dpsim/examples/cxx/Circuits/DP_Diakoptics.cpp | 12 +-- .../cxx/Circuits/DP_EMT_RL_SourceStep.cpp | 6 +- dpsim/examples/cxx/Circuits/DP_PiLine.cpp | 9 +- .../Circuits/DP_ReducedOrderSG_SMIB_Fault.cpp | 3 +- .../DP_ReducedOrderSG_VBR_Load_Fault.cpp | 3 +- ..._SMIB_ReducedOrderSGIterative_LoadStep.cpp | 3 +- .../DP_SMIB_ReducedOrderSG_LoadStep.cpp | 31 ++++--- .../DP_Slack_PiLine_PQLoad_with_PF_Init.cpp | 15 +-- .../DP_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp | 17 ++-- .../DP_Slack_PiLine_VSI_with_PF_Init.cpp | 16 ++-- .../Circuits/DP_SynGenTrStab_3Bus_Fault.cpp | 14 ++- .../DP_SynGenTrStab_3Bus_SteadyState.cpp | 3 +- .../Circuits/DP_SynGenTrStab_SMIB_Fault.cpp | 26 +++--- .../DP_SynGenTrStab_SMIB_SteadyState.cpp | 20 ++-- dpsim/examples/cxx/Circuits/DP_VSI.cpp | 3 +- dpsim/examples/cxx/Circuits/DP_VS_RL1.cpp | 3 +- dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp | 7 +- dpsim/examples/cxx/Circuits/EMT_Circuits.cpp | 15 +-- .../examples/cxx/Circuits/EMT_DP_SP_Slack.cpp | 15 +-- .../EMT_DP_SP_Slack_PiLine_PQLoad_FM.cpp | 23 ++--- ...k_PiLine_PQLoad_FrequencyRamp_CosineFM.cpp | 23 ++--- .../examples/cxx/Circuits/EMT_DP_SP_Trafo.cpp | 18 ++-- .../cxx/Circuits/EMT_DP_SP_VS_Init.cpp | 24 ++--- .../cxx/Circuits/EMT_DP_SP_VS_RLC.cpp | 27 ++---- dpsim/examples/cxx/Circuits/EMT_PiLine.cpp | 6 +- .../EMT_ReducedOrderSG_SMIB_Fault.cpp | 28 +++--- .../EMT_ReducedOrderSG_VBR_Load_Fault.cpp | 15 +-- .../cxx/Circuits/EMT_ResVS_RL_Switch.cpp | 3 +- ..._SMIB_ReducedOrderSGIterative_LoadStep.cpp | 28 +++--- .../EMT_SMIB_ReducedOrderSG_LoadStep.cpp | 27 +++--- .../EMT_Slack_PiLine_PQLoad_with_PF_Init.cpp | 16 ++-- ...EMT_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp | 16 ++-- .../EMT_Slack_PiLine_VSI_with_PF_Init.cpp | 16 ++-- .../EMT_SynGen4OrderIter_SMIB_Fault.cpp | 28 +++--- ...DQ7odTrapez_DP_SynGenTrStab_SMIB_Fault.cpp | 13 ++- ...7odTrapez_OperationalParams_SMIB_Fault.cpp | 13 +-- ...onalParams_SMIB_Fault_JsonSyngenParams.cpp | 10 +- .../EMT_SynGenDQ7odTrapez_SMIB_Fault.cpp | 13 +-- .../Circuits/EMT_SynGenTrStab_SMIB_Fault.cpp | 13 +-- .../EMT_SynGenTrStab_SMIB_SteadyState.cpp | 13 +-- ...SynGenVBR_OperationalParams_SMIB_Fault.cpp | 26 +++--- .../cxx/Circuits/EMT_SynGenVBR_SMIB_Fault.cpp | 26 +++--- .../cxx/Circuits/PF_Slack_PiLine_PQLoad.cpp | 13 +-- .../Circuits/SP_ReducedOrderSG_SMIB_Fault.cpp | 24 +++-- .../SP_ReducedOrderSG_VBR_Load_Fault.cpp | 15 +-- .../SP_SMIB_ReducedOrderSG_LoadStep.cpp | 26 ++++-- .../SP_Slack_PiLine_PQLoad_with_PF_Init.cpp | 13 +-- .../SP_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp | 12 ++- .../SP_Slack_PiLine_VSI_with_PF_Init.cpp | 13 +-- .../Circuits/SP_SynGenTrStab_3Bus_Fault.cpp | 32 ++++--- .../SP_SynGenTrStab_3Bus_SteadyState.cpp | 13 +-- .../Circuits/SP_SynGenTrStab_SMIB_Fault.cpp | 26 +++--- ...SynGenTrStab_SMIB_Fault_KundurExample1.cpp | 27 +++--- .../SP_SynGenTrStab_SMIB_SteadyState.cpp | 13 +-- .../DP_EMT_SynGenDq7odODE_LoadStep.cpp | 16 +++- .../DP_EMT_SynGenDq7odODE_SteadyState.cpp | 13 ++- .../DP_EMT_SynGenDq7odODE_ThreePhFault.cpp | 12 ++- .../cxx/Components/DP_Inverter_Grid.cpp | 12 ++- .../DP_Inverter_Grid_Parallel_FreqSplit.cpp | 13 ++- .../DP_Inverter_Grid_Sequential_FreqSplit.cpp | 12 ++- dpsim/include/dpsim/MNASolver.h | 2 +- dpsim/include/dpsim/MNASolverDirect.h | 2 +- dpsim/include/dpsim/MNASolverFactory.h | 2 +- dpsim/include/dpsim/MNASolverPlugin.h | 2 +- dpsim/src/Simulation.cpp | 8 +- examples/Notebooks/Circuits/CS_R2CL.ipynb | 93 +++++++++++++------ 94 files changed, 901 insertions(+), 700 deletions(-) diff --git a/dpsim/examples/cxx/CIM/CIGRE_MV_PowerFlowTest.cpp b/dpsim/examples/cxx/CIM/CIGRE_MV_PowerFlowTest.cpp index 7e16a07f67..7be2862308 100644 --- a/dpsim/examples/cxx/CIM/CIGRE_MV_PowerFlowTest.cpp +++ b/dpsim/examples/cxx/CIM/CIGRE_MV_PowerFlowTest.cpp @@ -46,14 +46,16 @@ int main(int argc, char** argv){ logger->logAttribute(node->name() + ".V", node->attribute("v")); } + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); + solverParameters->setInitFromNodesAndTerminals(true); + Simulation sim(simName, Logger::Level::info); sim.setSystem(system); sim.setTimeStep(1); sim.setFinalTime(1); - sim.setDomain(Domain::SP); - sim.setSolverType(Solver::Type::NRP); - sim.setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); - sim.doInitFromNodesAndTerminals(true); + sim.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/CIGRE_MV_PowerFlowTest_LoadProfiles.cpp b/dpsim/examples/cxx/CIM/CIGRE_MV_PowerFlowTest_LoadProfiles.cpp index 5b1a4f3244..204fccd186 100644 --- a/dpsim/examples/cxx/CIM/CIGRE_MV_PowerFlowTest_LoadProfiles.cpp +++ b/dpsim/examples/cxx/CIM/CIGRE_MV_PowerFlowTest_LoadProfiles.cpp @@ -128,14 +128,16 @@ int main(int argc, char** argv){ } } + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); + solverParameters->setInitFromNodesAndTerminals(true); + + // Simulation sim(simName, Logger::Level::info); sim.setSystem(system); - sim.setTimeStep(time_step); - sim.setFinalTime(time_end); - sim.setDomain(Domain::SP); - sim.setSolverType(Solver::Type::NRP); - sim.setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); - sim.doInitFromNodesAndTerminals(true); + sim.setSimulationParameters(time_end, time_end); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withDG.cpp b/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withDG.cpp index e14036d037..8dca6960b7 100644 --- a/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withDG.cpp +++ b/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withDG.cpp @@ -61,15 +61,17 @@ int main(int argc, char** argv){ loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); } + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + // run powerflow Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(1); simPF.setFinalTime(2); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -106,15 +108,17 @@ int main(int argc, char** argv){ auto pv = systemDP.component>(pv_name); Examples::Grids::CIGREMV::logPVAttributes(logger, pv); + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSteadyStateInit(steadyStateInit); + + // Simulation sim(simName, Logger::Level::debug); sim.setSystem(systemDP); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::DP); - sim.setSolverType(Solver::Type::MNA); - sim.doInitFromNodesAndTerminals(true); - - sim.doSteadyStateInit(steadyStateInit); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withDG_withLoadStep.cpp b/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withDG_withLoadStep.cpp index a692cb6516..fbb287f45f 100644 --- a/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withDG_withLoadStep.cpp +++ b/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withDG_withLoadStep.cpp @@ -57,15 +57,17 @@ int main(int argc, char** argv){ loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); } + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + // run powerflow Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(1); simPF.setFinalTime(2); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + sim.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -108,14 +110,17 @@ int main(int argc, char** argv){ // load step sized in absolute terms std::shared_ptr loadStepEvent = Examples::Events::createEventAddPowerConsumption("N11", 2-timeStep, 1500.0e3, systemDP, Domain::DP, logger); + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSystemMatrixRecomputation(false); + solverParameterDP->doSteadyStateInit(true); + Simulation sim(simName, Logger::Level::debug); sim.setSystem(systemDP); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::DP); - sim.setSolverType(Solver::Type::MNA); - sim.doInitFromNodesAndTerminals(true); - sim.doSteadyStateInit(false); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); sim.addLogger(logger); sim.addEvent(loadStepEvent); diff --git a/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withoutDG.cpp b/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withoutDG.cpp index e234a579b9..48f5173719 100644 --- a/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withoutDG.cpp +++ b/dpsim/examples/cxx/CIM/DP_CIGRE_MV_withoutDG.cpp @@ -56,14 +56,18 @@ int main(int argc, char** argv){ { loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); } + + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + + // Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(1); simPF.setFinalTime(2); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -93,14 +97,18 @@ int main(int argc, char** argv){ logger->logAttribute(comp->name() + ".I", comp->attribute("i_intf")); } + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSystemMatrixRecomputation(false); + solverParameterDP->doSteadyStateInit(steadyStateInit); + + // Simulation sim(simName, Logger::Level::debug); sim.setSystem(systemDP); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::DP); - sim.setSolverType(Solver::Type::MNA); - sim.doInitFromNodesAndTerminals(true); - sim.doSteadyStateInit(steadyStateInit); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterSP); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/DP_WSCC-9bus_IdealVS.cpp b/dpsim/examples/cxx/CIM/DP_WSCC-9bus_IdealVS.cpp index 2c09f11ab1..92e3d96844 100644 --- a/dpsim/examples/cxx/CIM/DP_WSCC-9bus_IdealVS.cpp +++ b/dpsim/examples/cxx/CIM/DP_WSCC-9bus_IdealVS.cpp @@ -55,15 +55,17 @@ int main(int argc, char *argv[]) { loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); } + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + // run powerflow Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(finalTime); simPF.setFinalTime(2*finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -92,11 +94,16 @@ int main(int argc, char *argv[]) { logger->logAttribute(comp->name() + ".I", comp->attribute("i_intf")); } + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + + // Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setDomain(Domain::DP); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderIter.cpp b/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderIter.cpp index d7e049571b..2b776c6a7c 100644 --- a/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderIter.cpp +++ b/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderIter.cpp @@ -97,15 +97,17 @@ int main(int argc, char *argv[]) { for (auto node : systemPF.mNodes) loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + // run powerflow Simulation simPF(simNamePF, logLevel); simPF.setSystem(systemPF); simPF.setTimeStep(finalTime); simPF.setFinalTime(2*finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -165,13 +167,15 @@ int main(int argc, char *argv[]) { } } + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + + // Simulation sim(simName, logLevel); sim.setSystem(sys); - sim.setDomain(Domain::DP); - sim.setSolverType(Solver::Type::MNA); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + sim.setSimulationParameters(timeStep, finalTime); + simSP.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); sim.addLogger(logger); // Optionally add switch event diff --git a/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderVBR.cpp b/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderVBR.cpp index 3b9179a820..d3edfc33fd 100644 --- a/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderVBR.cpp +++ b/dpsim/examples/cxx/CIM/DP_WSCC9bus_SGReducedOrderVBR.cpp @@ -100,15 +100,17 @@ int main(int argc, char *argv[]) { for (auto node : systemPF.mNodes) loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + // run powerflow Simulation simPF(simNamePF, logLevel); simPF.setSystem(systemPF); simPF.setTimeStep(finalTime); simPF.setFinalTime(2*finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -161,14 +163,16 @@ int main(int argc, char *argv[]) { } } + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(implementation); + solverParameterDP->doSystemMatrixRecomputation(true); + Simulation sim(simName, logLevel); sim.setSystem(sys); - sim.setDomain(Domain::DP); - sim.setSolverType(Solver::Type::MNA); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.doSystemMatrixRecomputation(true); - sim.setDirectLinearSolverImplementation(implementation); + simSP.setSimulationParameters(timeStep, finalTime); + simSP.setSolverParameters(Domain::SP, Solver::Type::MNA, solverParameterDP); sim.addLogger(logger); // Optionally add switch event diff --git a/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withDG.cpp b/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withDG.cpp index c5827d1278..58196ec749 100644 --- a/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withDG.cpp +++ b/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withDG.cpp @@ -54,19 +54,19 @@ int main(int argc, char** argv){ // define logging auto loggerPF = DPsim::DataLogger::make(simNamePF); for (auto node : systemPF.mNodes) - { loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); - } + + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); // run powerflow Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(1); simPF.setFinalTime(2); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -100,14 +100,16 @@ int main(int argc, char** argv){ auto pv = systemEMT.component>("pv_N11"); Examples::Grids::CIGREMV::logPVAttributes(logger, pv); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSteadyStateInit(false); + Simulation sim(simName, Logger::Level::debug); sim.setSystem(systemEMT); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::EMT); - sim.setSolverType(Solver::Type::MNA); - sim.doInitFromNodesAndTerminals(true); - sim.doSteadyStateInit(false); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withDG_withLoadStep.cpp b/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withDG_withLoadStep.cpp index d9555a00bf..5a1af5196e 100644 --- a/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withDG_withLoadStep.cpp +++ b/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withDG_withLoadStep.cpp @@ -58,15 +58,17 @@ int main(int argc, char** argv){ loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); } + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + // run powerflow Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(1); simPF.setFinalTime(2); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -101,15 +103,19 @@ int main(int argc, char** argv){ Examples::Grids::CIGREMV::logPVAttributes(logger, pv); std::shared_ptr loadStepEvent = Examples::Events::createEventAddPowerConsumption3Ph("N11", 2-timeStep, 1500.0e3, systemEMT, Domain::EMT, logger); + + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSteadyStateInit(false); + + // Simulation sim(simName, Logger::Level::debug); sim.setSystem(systemEMT); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::EMT); - sim.setSolverType(Solver::Type::MNA); - sim.doInitFromNodesAndTerminals(true); + simSP.setSimulationParameters(timeStep, finalTime); + simSP.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addEvent(loadStepEvent); - sim.doSteadyStateInit(false); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withoutDG.cpp b/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withoutDG.cpp index 09ae1173bd..bc057bf90d 100644 --- a/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withoutDG.cpp +++ b/dpsim/examples/cxx/CIM/EMT_CIGRE_MV_withoutDG.cpp @@ -50,18 +50,19 @@ int main(int argc, char** argv){ auto loggerPF = DPsim::DataLogger::make(simNamePF); for (auto node : systemPF.mNodes) - { loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); - } + + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); + Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(1); simPF.setFinalTime(2); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); - simPF.doSteadyStateInit(false); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -89,14 +90,17 @@ int main(int argc, char** argv){ logger->logAttribute(comp->name() + ".I", comp->attribute("i_intf")); } + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSteadyStateInit(false); + + // Simulation sim(simName, Logger::Level::debug); sim.setSystem(systemEMT); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::EMT); - sim.setSolverType(Solver::Type::MNA); - sim.doInitFromNodesAndTerminals(true); - sim.doSteadyStateInit(false); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_FullOrderSG.cpp b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_FullOrderSG.cpp index 725d2f133f..9e05844440 100644 --- a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_FullOrderSG.cpp +++ b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_FullOrderSG.cpp @@ -51,19 +51,20 @@ int main(int argc, char *argv[]) { // define logging auto loggerPF = DPsim::DataLogger::make(simNamePF); for (auto node : systemPF.mNodes) - { loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); - } + + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); // run powerflow Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(finalTime); simPF.setFinalTime(2*finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -99,13 +100,17 @@ int main(int argc, char *argv[]) { logger->logAttribute(comp->name() + ".I", comp->attribute("i_intf")); } + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSteadyStateInit(false); + + // Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setDomain(Domain::EMT); - sim.setSolverType(Solver::Type::MNA); - sim.setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_IdealCS.cpp b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_IdealCS.cpp index 4784ee3b42..22be98ba37 100644 --- a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_IdealCS.cpp +++ b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_IdealCS.cpp @@ -55,15 +55,18 @@ int main(int argc, char *argv[]) { loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); } + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); + // run powerflow Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(finalTime); simPF.setFinalTime(2*finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_IdealVS.cpp b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_IdealVS.cpp index 91d036b73f..52503b43dc 100644 --- a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_IdealVS.cpp +++ b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_IdealVS.cpp @@ -51,19 +51,20 @@ int main(int argc, char *argv[]) { // define logging auto loggerPF = DPsim::DataLogger::make(simNamePF); for (auto node : systemPF.mNodes) - { loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); - } + + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); // run powerflow Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(finalTime); simPF.setFinalTime(2*finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_VBR.cpp b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_VBR.cpp index 523521ee7f..e69fc65dc4 100644 --- a/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_VBR.cpp +++ b/dpsim/examples/cxx/CIM/EMT_WSCC-9bus_VBR.cpp @@ -54,19 +54,20 @@ int main(int argc, char *argv[]) { // define logging auto loggerPF = DPsim::DataLogger::make(simNamePF); for (auto node : systemPF.mNodes) - { loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); - } + + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); // run powerflow Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(finalTime); simPF.setFinalTime(2*finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -105,14 +106,17 @@ int main(int argc, char *argv[]) { } } + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(implementation); + solverParameterEMT->doSteadyStateInit(false); + solverParameterEMT->doSystemMatrixRecomputation(true); + // Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setDomain(Domain::EMT); - sim.setSolverType(Solver::Type::MNA); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.doSystemMatrixRecomputation(true); - sim.setDirectLinearSolverImplementation(implementation); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/EMT_WSCC9bus_SGReducedOrderVBR.cpp b/dpsim/examples/cxx/CIM/EMT_WSCC9bus_SGReducedOrderVBR.cpp index 3caf872f9c..e2edee755d 100644 --- a/dpsim/examples/cxx/CIM/EMT_WSCC9bus_SGReducedOrderVBR.cpp +++ b/dpsim/examples/cxx/CIM/EMT_WSCC9bus_SGReducedOrderVBR.cpp @@ -97,15 +97,18 @@ int main(int argc, char *argv[]) { for (auto node : systemPF.mNodes) loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); + // run powerflow Simulation simPF(simNamePF, logLevel); simPF.setSystem(systemPF); simPF.setTimeStep(finalTime); simPF.setFinalTime(2*finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -158,14 +161,18 @@ int main(int argc, char *argv[]) { } } + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(implementation); + solverParameterEMT->doSteadyStateInit(false); + solverParameterEMT->doSystemMatrixRecomputation(true); + + // Simulation sim(simName, logLevel); sim.setSystem(sys); - sim.setDomain(Domain::EMT); - sim.setSolverType(Solver::Type::MNA); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.doSystemMatrixRecomputation(true); - sim.setDirectLinearSolverImplementation(implementation); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); // Optionally add switch event diff --git a/dpsim/examples/cxx/CIM/IEEE_LV_PowerFlowTest.cpp b/dpsim/examples/cxx/CIM/IEEE_LV_PowerFlowTest.cpp index d5ffef0dbe..6b99e41894 100644 --- a/dpsim/examples/cxx/CIM/IEEE_LV_PowerFlowTest.cpp +++ b/dpsim/examples/cxx/CIM/IEEE_LV_PowerFlowTest.cpp @@ -46,14 +46,18 @@ int main(int argc, char** argv){ logger->logAttribute(node->name() + ".V", node->attribute("v")); } + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); + + // Simulation sim(simName, Logger::Level::debug); sim.setSystem(system); sim.setTimeStep(1); sim.setFinalTime(1); - sim.setDomain(Domain::SP); - sim.setSolverType(Solver::Type::NRP); - sim.setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); - sim.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/PF_CIGRE_MV_withDG.cpp b/dpsim/examples/cxx/CIM/PF_CIGRE_MV_withDG.cpp index c4dbbd73af..fd351b69c8 100644 --- a/dpsim/examples/cxx/CIM/PF_CIGRE_MV_withDG.cpp +++ b/dpsim/examples/cxx/CIM/PF_CIGRE_MV_withDG.cpp @@ -46,16 +46,19 @@ int main(int argc, char** argv){ auto loggerPF = DPsim::DataLogger::make(simName); for (auto node : system.mNodes) - { loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); - } + + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); + + // Simulation simPF(simName, Logger::Level::debug); simPF.setSystem(system); - simPF.setTimeStep(timeStep); - simPF.setFinalTime(finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSimulationParameters(timeStep, finalTime); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); } diff --git a/dpsim/examples/cxx/CIM/SP_WSCC-9bus_CIM_Dyn_Switch.cpp b/dpsim/examples/cxx/CIM/SP_WSCC-9bus_CIM_Dyn_Switch.cpp index 62b8759953..2e0fae2765 100644 --- a/dpsim/examples/cxx/CIM/SP_WSCC-9bus_CIM_Dyn_Switch.cpp +++ b/dpsim/examples/cxx/CIM/SP_WSCC-9bus_CIM_Dyn_Switch.cpp @@ -72,14 +72,18 @@ int main(int argc, char *argv[]) { logger->logAttribute("P_elec_2", sys.component("GEN2")->attribute("P_elec")); logger->logAttribute("P_elec_3", sys.component("GEN3")->attribute("P_elec")); + // set solver parameters + auto solverParameterSP = std::make_shared(); + solverParameterSP->setInitFromNodesAndTerminals(true); + solverParameterSP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterSP->doSteadyStateInit(false); + // Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); sim.setTimeStep(0.0001); sim.setFinalTime(2); - sim.setDomain(Domain::SP); - sim.setSolverType(Solver::Type::MNA); - sim.doInitFromNodesAndTerminals(true); + sim.setSolverParameters(Domain::SP, Solver::Type::MNA, solverParameterSP); auto swEvent1 = SwitchEvent::make(0.2-0.0001, sw, true); //auto swEvent2 = SwitchEvent::make(0.07, sw, false); diff --git a/dpsim/examples/cxx/CIM/SP_WSCC9bus_SGReducedOrderVBR.cpp b/dpsim/examples/cxx/CIM/SP_WSCC9bus_SGReducedOrderVBR.cpp index aeb5f6692c..7299d03f6f 100644 --- a/dpsim/examples/cxx/CIM/SP_WSCC9bus_SGReducedOrderVBR.cpp +++ b/dpsim/examples/cxx/CIM/SP_WSCC9bus_SGReducedOrderVBR.cpp @@ -92,17 +92,20 @@ int main(int argc, char *argv[]) { // define logging auto loggerPF = DPsim::DataLogger::make(simNamePF); for (auto node : systemPF.mNodes) - loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); + loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); + + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); // run powerflow Simulation simPF(simNamePF, logLevel); simPF.setSystem(systemPF); simPF.setTimeStep(finalTime); simPF.setFinalTime(2*finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -141,8 +144,8 @@ int main(int argc, char *argv[]) { // Logging // log node voltage auto logger = DataLogger::make(simName, true, logDownSampling); - for (auto node : sys.mNodes) - logger->logAttribute(node->name() + ".V", node->attribute("v")); + for (auto node : sys.mNodes) + logger->logAttribute(node->name() + ".V", node->attribute("v")); // log generator vars for (auto comp : sys.mComponents) { @@ -154,14 +157,18 @@ int main(int argc, char *argv[]) { } } + // set solver parameters + auto solverParameterSP = std::make_shared(); + solverParameterSP->setInitFromNodesAndTerminals(true); + solverParameterSP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterSP->doSteadyStateInit(false); + solverParameterSP->doSystemMatrixRecomputation(true); + + // Simulation sim(simName, logLevel); sim.setSystem(sys); - sim.setDomain(Domain::SP); - sim.setSolverType(Solver::Type::MNA); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.doSystemMatrixRecomputation(true); - sim.setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::SP, Solver::Type::MNA, solverParameterSP); sim.addLogger(logger); // Optionally add switch event diff --git a/dpsim/examples/cxx/CIM/Slack_TrafoTapChanger_Load.cpp b/dpsim/examples/cxx/CIM/Slack_TrafoTapChanger_Load.cpp index bc22228600..30fb189067 100644 --- a/dpsim/examples/cxx/CIM/Slack_TrafoTapChanger_Load.cpp +++ b/dpsim/examples/cxx/CIM/Slack_TrafoTapChanger_Load.cpp @@ -42,18 +42,20 @@ int main(int argc, char** argv){ auto logger = DPsim::DataLogger::make(simName); for (auto node : system.mNodes) - { logger->logAttribute(node->name() + ".V", node->attribute("v")); - } + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); + + // Simulation sim(simName, Logger::Level::debug); sim.setSystem(system); sim.setTimeStep(1); sim.setFinalTime(1); - sim.setDomain(Domain::SP); - sim.setSolverType(Solver::Type::NRP); - sim.setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); - sim.doInitFromNodesAndTerminals(true); + sim.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/CIM/Slack_Trafo_Load.cpp b/dpsim/examples/cxx/CIM/Slack_Trafo_Load.cpp index 865c1df0fb..5f98a0caf8 100644 --- a/dpsim/examples/cxx/CIM/Slack_Trafo_Load.cpp +++ b/dpsim/examples/cxx/CIM/Slack_Trafo_Load.cpp @@ -42,20 +42,21 @@ int main(int argc, char** argv){ auto logger = DPsim::DataLogger::make(simName); for (auto node : system.mNodes) - { logger->logAttribute(node->name() + ".V", node->attribute("v")); - } + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); + + // Simulation sim(simName, Logger::Level::debug); sim.setSystem(system); sim.setTimeStep(1); sim.setFinalTime(1); - sim.setDomain(Domain::SP); - sim.setSolverType(Solver::Type::NRP); - sim.setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); - sim.doInitFromNodesAndTerminals(true); + sim.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); sim.addLogger(logger); - sim.run(); return 0; diff --git a/dpsim/examples/cxx/CIM/WSCC-9bus_CIM.cpp b/dpsim/examples/cxx/CIM/WSCC-9bus_CIM.cpp index 386e159442..1742bef370 100644 --- a/dpsim/examples/cxx/CIM/WSCC-9bus_CIM.cpp +++ b/dpsim/examples/cxx/CIM/WSCC-9bus_CIM.cpp @@ -51,19 +51,20 @@ int main(int argc, char *argv[]) { // define logging auto loggerPF = DPsim::DataLogger::make(simNamePF); for (auto node : systemPF.mNodes) - { loggerPF->logAttribute(node->name() + ".V", node->attribute("v")); - } + + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(true); + solverParameters->doSteadyStateInit(false); // run powerflow Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(finalTime); simPF.setFinalTime(2*finalTime); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(true); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -92,13 +93,20 @@ int main(int argc, char *argv[]) { logger->logAttribute(comp->name() + ".I", comp->attribute("i_intf")); } + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSteadyStateInit(true); + + // Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setDomain(Domain::DP); sim.setTimeStep(timeStep); sim.setFinalTime(finalTime); - sim.doSteadyStateInit(true); sim.addLogger(logger); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); sim.run(); return 0; diff --git a/dpsim/examples/cxx/CIM/WSCC-9bus_CIM_Dyn.cpp b/dpsim/examples/cxx/CIM/WSCC-9bus_CIM_Dyn.cpp index 692781d74e..57a77c2726 100644 --- a/dpsim/examples/cxx/CIM/WSCC-9bus_CIM_Dyn.cpp +++ b/dpsim/examples/cxx/CIM/WSCC-9bus_CIM_Dyn.cpp @@ -51,13 +51,19 @@ int main(int argc, char *argv[]) { logger->logAttribute("wr_2", sys.component("GEN2")->attribute("w_r")); logger->logAttribute("wr_3", sys.component("GEN3")->attribute("w_r")); + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSteadyStateInit(true); + + // Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setDomain(Domain::DP); sim.setTimeStep(0.0001); sim.setFinalTime(2); - sim.doSteadyStateInit(true); sim.addLogger(logger); + sim.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); sim.run(); //std::ofstream ofTopo("topology_graph.svg"); diff --git a/dpsim/examples/cxx/CIM/WSCC-9bus_CIM_Dyn_Switch.cpp b/dpsim/examples/cxx/CIM/WSCC-9bus_CIM_Dyn_Switch.cpp index dda9618cea..c88bb92d1c 100644 --- a/dpsim/examples/cxx/CIM/WSCC-9bus_CIM_Dyn_Switch.cpp +++ b/dpsim/examples/cxx/CIM/WSCC-9bus_CIM_Dyn_Switch.cpp @@ -58,14 +58,18 @@ int main(int argc, char *argv[]) { logger->logAttribute("wr_2", sys.component("GEN2")->attribute("w_r")); logger->logAttribute("wr_3", sys.component("GEN3")->attribute("w_r")); + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSteadyStateInit(false); + // Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); sim.setTimeStep(0.0001); sim.setFinalTime(2); - sim.setDomain(Domain::DP); - sim.setSolverType(Solver::Type::MNA); - sim.doInitFromNodesAndTerminals(true); + sim.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); auto swEvent1 = SwitchEvent::make(0.2, sw, true); //auto swEvent2 = SwitchEvent::make(0.07, sw, false); diff --git a/dpsim/examples/cxx/Circuits/DP_Basics_DP_Sims.cpp b/dpsim/examples/cxx/Circuits/DP_Basics_DP_Sims.cpp index 0a1c06058b..a011121266 100644 --- a/dpsim/examples/cxx/Circuits/DP_Basics_DP_Sims.cpp +++ b/dpsim/examples/cxx/Circuits/DP_Basics_DP_Sims.cpp @@ -69,12 +69,9 @@ void DP_VS_RL_f60_largeTs() { Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.initialize(); - sim.addLogger(logger); - sim.run(); } @@ -119,8 +116,7 @@ void DP_VS_RL_f60_vlargeTs() { Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.initialize(); sim.addLogger(logger); @@ -169,8 +165,7 @@ void DP_VS_RL_f60() { Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.initialize(); sim.addLogger(logger); @@ -219,8 +214,7 @@ void DP_VS_RL_f500_largeTs() { Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.initialize(); sim.addLogger(logger); @@ -269,8 +263,7 @@ void DP_VS_RL_f500_ph500() { Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.initialize(); sim.addLogger(logger); @@ -319,8 +312,7 @@ void DP_VS_RL_f500() { Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.initialize(); sim.addLogger(logger); diff --git a/dpsim/examples/cxx/Circuits/DP_Basics_EMT_Sims.cpp b/dpsim/examples/cxx/Circuits/DP_Basics_EMT_Sims.cpp index bed049f5fc..5cae35ef64 100644 --- a/dpsim/examples/cxx/Circuits/DP_Basics_EMT_Sims.cpp +++ b/dpsim/examples/cxx/Circuits/DP_Basics_EMT_Sims.cpp @@ -63,8 +63,7 @@ void EMT_VS_RL_f60_largeTs() { Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.initialize(); @@ -114,8 +113,7 @@ void EMT_VS_RL_f60() { Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.initialize(); @@ -165,8 +163,7 @@ void EMT_VS_RL_f500() { Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.initialize(); diff --git a/dpsim/examples/cxx/Circuits/DP_DecouplingLine.cpp b/dpsim/examples/cxx/Circuits/DP_DecouplingLine.cpp index 617ed7573a..e9b10edcdc 100644 --- a/dpsim/examples/cxx/Circuits/DP_DecouplingLine.cpp +++ b/dpsim/examples/cxx/Circuits/DP_DecouplingLine.cpp @@ -61,8 +61,7 @@ void simElements() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -111,8 +110,7 @@ void simDecoupling() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -161,8 +159,7 @@ void simDecouplingEMT() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(CPS::Domain::EMT); sim.addLogger(logger); diff --git a/dpsim/examples/cxx/Circuits/DP_Diakoptics.cpp b/dpsim/examples/cxx/Circuits/DP_Diakoptics.cpp index 452655cc10..f9b70b301a 100644 --- a/dpsim/examples/cxx/Circuits/DP_Diakoptics.cpp +++ b/dpsim/examples/cxx/Circuits/DP_Diakoptics.cpp @@ -61,8 +61,7 @@ void DP_VS_CS_R4() { Simulation sim(simName); sim.setSystem(sys); sim.setTearingComponents(sys.mTearComponents); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -118,8 +117,7 @@ void DP_VS_CS_R4_Diakoptics() { Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); sim.setTearingComponents(sys.mTearComponents); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -174,8 +172,7 @@ void DP_VS_R2L3() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -232,8 +229,7 @@ void DP_VS_R2L3_Diakoptics() { Simulation sim(simName); sim.setSystem(sys); sim.setTearingComponents(sys.mTearComponents); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/Circuits/DP_EMT_RL_SourceStep.cpp b/dpsim/examples/cxx/Circuits/DP_EMT_RL_SourceStep.cpp index 34214dd333..a93e1bc18e 100644 --- a/dpsim/examples/cxx/Circuits/DP_EMT_RL_SourceStep.cpp +++ b/dpsim/examples/cxx/Circuits/DP_EMT_RL_SourceStep.cpp @@ -46,8 +46,7 @@ static void DP_RL_SourceStep(Real timeStep, Real finalTime, Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -89,8 +88,7 @@ static void EMT_RL_SourceStep(Real timeStep, Real finalTime, Simulation sim(simName); sim.setSystem(sys); sim.setDomain(CPS::Domain::EMT); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/Circuits/DP_PiLine.cpp b/dpsim/examples/cxx/Circuits/DP_PiLine.cpp index 1231a6598e..f8ee1dd045 100644 --- a/dpsim/examples/cxx/Circuits/DP_PiLine.cpp +++ b/dpsim/examples/cxx/Circuits/DP_PiLine.cpp @@ -72,8 +72,7 @@ void simElements() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -122,8 +121,7 @@ void simPiLine() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -168,8 +166,7 @@ void simPiLineDiakoptics() { Simulation sim(simName); sim.setSystem(sys); sim.setTearingComponents(sys.mTearComponents); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_SMIB_Fault.cpp index 55c1b04bf7..acf3134333 100644 --- a/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_SMIB_Fault.cpp @@ -168,8 +168,7 @@ int main(int argc, char* argv[]) { Simulation simDP(simNameDP, logLevel); simDP.doInitFromNodesAndTerminals(true); simDP.setSystem(systemDP); - simDP.setTimeStep(timeStep); - simDP.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); simDP.setDomain(Domain::DP); simDP.setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); simDP.addLogger(loggerDP); diff --git a/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_VBR_Load_Fault.cpp b/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_VBR_Load_Fault.cpp index cdbbd8528b..d7daef2cdb 100644 --- a/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_VBR_Load_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/DP_ReducedOrderSG_VBR_Load_Fault.cpp @@ -148,8 +148,7 @@ int main(int argc, char* argv[]) { Simulation simDP(simNameDP, logLevel); simDP.doInitFromNodesAndTerminals(true); simDP.setSystem(systemDP); - simDP.setTimeStep(timeStep); - simDP.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); simDP.setDomain(Domain::DP); simDP.setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); simDP.addLogger(loggerDP); diff --git a/dpsim/examples/cxx/Circuits/DP_SMIB_ReducedOrderSGIterative_LoadStep.cpp b/dpsim/examples/cxx/Circuits/DP_SMIB_ReducedOrderSGIterative_LoadStep.cpp index b969105100..9c450bafd5 100644 --- a/dpsim/examples/cxx/Circuits/DP_SMIB_ReducedOrderSGIterative_LoadStep.cpp +++ b/dpsim/examples/cxx/Circuits/DP_SMIB_ReducedOrderSGIterative_LoadStep.cpp @@ -196,8 +196,7 @@ int main(int argc, char* argv[]) { Simulation simDP(simNameDP, logLevel); simDP.doInitFromNodesAndTerminals(true); simDP.setSystem(systemDP); - simDP.setTimeStep(timeStep); - simDP.setFinalTime(finalTime); + simDP.setSimulationParameters(timeStepDP, finalTimeDP); simDP.setDomain(Domain::DP); simDP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); simDP.addLogger(logger); diff --git a/dpsim/examples/cxx/Circuits/DP_SMIB_ReducedOrderSG_LoadStep.cpp b/dpsim/examples/cxx/Circuits/DP_SMIB_ReducedOrderSG_LoadStep.cpp index 94f604c0d3..1bb1756d75 100644 --- a/dpsim/examples/cxx/Circuits/DP_SMIB_ReducedOrderSG_LoadStep.cpp +++ b/dpsim/examples/cxx/Circuits/DP_SMIB_ReducedOrderSG_LoadStep.cpp @@ -22,6 +22,8 @@ int main(int argc, char* argv[]) { String simName = "DP_SMIB_ReducedOrderSG_VBR_LoadStep"; Real timeStep = 100e-6; Real finalTime = 35; + Real timeStepPF = 0.1; + Real finalTimePF = 0.1; // Default configuration String sgType = defaultConfig.sgType; @@ -98,15 +100,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, logLevel); simPF.setSystem(systemPF); - simPF.setTimeStep(0.1); - simPF.setFinalTime(0.1); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -171,18 +174,22 @@ int main(int argc, char* argv[]) { // load step event std::shared_ptr loadStepEvent = Examples::Events::createEventAddPowerConsumption("n1DP", std::round(loadStepEventTime/timeStep)*timeStep, gridParams.loadStepActivePower, systemDP, Domain::DP, logger); + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSystemMatrixRecomputation(true); + + // Simulation simDP(simNameDP, logLevel); - simDP.doInitFromNodesAndTerminals(true); simDP.setSystem(systemDP); - simDP.setTimeStep(timeStep); - simDP.setFinalTime(finalTime); - simDP.setDomain(Domain::DP); - simDP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + simDP.setSimulationParameters(timeStep, finalTime); + simDP.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); simDP.addLogger(logger); - simDP.doSystemMatrixRecomputation(true); // Events simDP.addEvent(loadStepEvent); + // Run Simulation simDP.run(); } diff --git a/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_PQLoad_with_PF_Init.cpp b/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_PQLoad_with_PF_Init.cpp index 9a13838376..2f2b7ff01a 100644 --- a/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_PQLoad_with_PF_Init.cpp +++ b/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_PQLoad_with_PF_Init.cpp @@ -71,15 +71,17 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -128,8 +130,7 @@ int main(int argc, char* argv[]) { // Simulation Simulation sim(simNameDP, Logger::Level::debug); sim.setSystem(systemDP); - sim.setTimeStep(timeStepDP); - sim.setFinalTime(finalTimeDP); + sim.setSimulationParameters(timeStepDP, finalTimeDP); sim.setDomain(Domain::DP); sim.addLogger(loggerDP); //sim.addEvent(loadStepEvent); diff --git a/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp b/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp index 06e10c1979..81ebafe564 100644 --- a/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp +++ b/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp @@ -74,15 +74,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -137,11 +138,9 @@ int main(int argc, char* argv[]) { // Simulation Simulation sim(simNameDP, Logger::Level::debug); sim.setSystem(systemDP); - sim.setTimeStep(timeStepDP); - sim.setFinalTime(finalTimeDP); + sim.setSimulationParameters(timeStepDP, finalTimeDP); sim.setDomain(Domain::DP); // sim.addEvent(loadStepEvent); - sim.addLogger(loggerDP); sim.run(); diff --git a/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_VSI_with_PF_Init.cpp b/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_VSI_with_PF_Init.cpp index dd3ff4d82e..8a177cee23 100644 --- a/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_VSI_with_PF_Init.cpp +++ b/dpsim/examples/cxx/Circuits/DP_Slack_PiLine_VSI_with_PF_Init.cpp @@ -74,15 +74,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -136,8 +137,7 @@ int main(int argc, char* argv[]) { // Simulation Simulation sim(simNameDP, Logger::Level::debug); sim.setSystem(systemDP); - sim.setTimeStep(timeStepDP); - sim.setFinalTime(finalTimeDP); + sim.setSimulationParameters(timeStepDP, finalTimeDP); sim.setDomain(Domain::DP); // sim.addEvent(loadStepEvent); sim.addLogger(loggerDP); diff --git a/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_3Bus_Fault.cpp b/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_3Bus_Fault.cpp index 0cb3fcbc10..8fd14f3a02 100644 --- a/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_3Bus_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_3Bus_Fault.cpp @@ -198,14 +198,18 @@ void DP_SynGenTrStab_3Bus_Fault(String simName, Real timeStep, Real finalTime, b loggerDP->logAttribute("P_elec1", gen1DP->attribute("P_elec")); loggerDP->logAttribute("P_elec2", gen2DP->attribute("P_elec")); + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSystemMatrixRecomputation(true); + + // Simulation simDP(simNameDP, Logger::Level::debug); simDP.setSystem(systemDP); - simDP.setTimeStep(timeStep); - simDP.setFinalTime(finalTime); - simDP.setDomain(Domain::DP); + simDP.setSimulationParameters(timeStep, finalTime); + simDP.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); simDP.addLogger(loggerDP); - simDP.doSystemMatrixRecomputation(true); - simDP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); // Events if (startFaultEvent){ diff --git a/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_3Bus_SteadyState.cpp b/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_3Bus_SteadyState.cpp index eb68eb086c..dd69f9b9a7 100644 --- a/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_3Bus_SteadyState.cpp +++ b/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_3Bus_SteadyState.cpp @@ -171,8 +171,7 @@ void DP_SynGenTrStab_3Bus_SteadyState(String simName, Real timeStep, Real finalT Simulation sim(simNameDP, Logger::Level::debug); sim.setSystem(systemDP); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + simDP.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::DP); sim.addLogger(loggerDP); diff --git a/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_SMIB_Fault.cpp index 1e140642ed..9814eaf727 100644 --- a/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_SMIB_Fault.cpp @@ -67,15 +67,16 @@ void DP_1ph_SynGenTrStab_Fault(String simName, Real timeStep, Real finalTime, bo loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simDP.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -147,15 +148,18 @@ void DP_1ph_SynGenTrStab_Fault(String simName, Real timeStep, Real finalTime, bo loggerDP->logAttribute("v_slack", extnetDP->attribute("v_intf")); loggerDP->logAttribute("i_slack", extnetDP->attribute("i_intf")); + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setInitFromNodesAndTerminals(true); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSystemMatrixRecomputation(true); + // Simulation simDP(simNameDP, Logger::Level::debug); simDP.setSystem(systemDP); - simDP.setTimeStep(timeStep); - simDP.setFinalTime(finalTime); - simDP.setDomain(Domain::DP); + simDP.setSimulationParameters(timeStep, finalTime); + simDP.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); simDP.addLogger(loggerDP); - simDP.doSystemMatrixRecomputation(true); - simDP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); // Events if (startFaultEvent){ diff --git a/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_SMIB_SteadyState.cpp b/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_SMIB_SteadyState.cpp index d432c908fc..6220ef1c1d 100644 --- a/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_SMIB_SteadyState.cpp +++ b/dpsim/examples/cxx/Circuits/DP_SynGenTrStab_SMIB_SteadyState.cpp @@ -57,15 +57,16 @@ void DP_1ph_SynGenTrStab_SteadyState(String simName, Real timeStep, Real finalTi loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -123,15 +124,12 @@ void DP_1ph_SynGenTrStab_SteadyState(String simName, Real timeStep, Real finalTi loggerDP->logAttribute("v_slack", extnetDP->attribute("v_intf")); loggerDP->logAttribute("i_slack", extnetDP->attribute("i_intf")); - - + // Simulation simDP(simNameDP, Logger::Level::debug); simDP.setSystem(systemDP); - simDP.setTimeStep(timeStep); - simDP.setFinalTime(finalTime); + simDP.setSimulationParameters(timeStep, finalTime); simDP.setDomain(Domain::DP); simDP.addLogger(loggerDP); - simDP.run(); } diff --git a/dpsim/examples/cxx/Circuits/DP_VSI.cpp b/dpsim/examples/cxx/Circuits/DP_VSI.cpp index 7b62e36049..a47c3c8fc5 100644 --- a/dpsim/examples/cxx/Circuits/DP_VSI.cpp +++ b/dpsim/examples/cxx/Circuits/DP_VSI.cpp @@ -151,8 +151,7 @@ void DP_Ph1_VSI2_4bus_SampleGrid() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/Circuits/DP_VS_RL1.cpp b/dpsim/examples/cxx/Circuits/DP_VS_RL1.cpp index c6dee917b8..6e34e03f46 100644 --- a/dpsim/examples/cxx/Circuits/DP_VS_RL1.cpp +++ b/dpsim/examples/cxx/Circuits/DP_VS_RL1.cpp @@ -48,8 +48,7 @@ int main(int argc, char* argv[]) { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp b/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp index c836c35ded..9ceb88a413 100644 --- a/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_CS_RL1.cpp @@ -48,12 +48,9 @@ int main(int argc, char* argv[]) { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::EMT); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA); sim.addLogger(logger); - sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, mna_parameter); - sim.run(); return 0; diff --git a/dpsim/examples/cxx/Circuits/EMT_Circuits.cpp b/dpsim/examples/cxx/Circuits/EMT_Circuits.cpp index 5035e3c14d..1aa5f98bab 100644 --- a/dpsim/examples/cxx/Circuits/EMT_Circuits.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_Circuits.cpp @@ -117,8 +117,7 @@ void EMT_CS_R2CL() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); @@ -221,8 +220,7 @@ void EMT_VS_CS_R4_DC() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); @@ -276,8 +274,7 @@ void EMT_VS_R2L3() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); @@ -392,8 +389,7 @@ void EMT_Ph3_VS_R2L3() { sim.setSystem(sys); sim.addLogger(logger); sim.setDomain(Domain::EMT); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.run(); } @@ -445,8 +441,7 @@ void EMT_Ph3_VS_RC1() { sim.setSystem(sys); sim.addLogger(logger); sim.setDomain(Domain::EMT); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.run(); } diff --git a/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack.cpp b/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack.cpp index ea43659880..17001af4fd 100644 --- a/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack.cpp @@ -42,8 +42,7 @@ void simElementsSP1ph() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -118,8 +117,7 @@ void simElementsDP1ph() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -156,8 +154,7 @@ void simComponentDP1ph() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -195,8 +192,7 @@ void simElementsEMT3ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); sim.run(); @@ -234,8 +230,7 @@ void simComponentEMT3ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack_PiLine_PQLoad_FM.cpp b/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack_PiLine_PQLoad_FM.cpp index d8280e0fe1..3fb9937371 100644 --- a/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack_PiLine_PQLoad_FM.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack_PiLine_PQLoad_FM.cpp @@ -63,15 +63,16 @@ void powerFlow(SystemTopology& systemPF) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); } @@ -122,10 +123,8 @@ void simulateDP(SystemTopology& systemPF, String waveform) { // Simulation Simulation sim(simNameDP, Logger::Level::debug); sim.setSystem(systemDP); - sim.setTimeStep(timeStepDP); - sim.setFinalTime(finalTimeDP); + sim.setSimulationParameters(timeStepDP, finalTimeDP); sim.setDomain(Domain::DP); - sim.addLogger(loggerDP); sim.run(); } @@ -175,8 +174,7 @@ void simulateSP(SystemTopology& systemPF, String waveform) { // Simulation Simulation sim(simNameSP, Logger::Level::debug); sim.setSystem(systemSP); - sim.setTimeStep(timeStepSP); - sim.setFinalTime(finalTimeSP); + sim.setSimulationParameters(timeStepSP, finalTimeSP); sim.setDomain(Domain::SP); sim.addLogger(loggerSP); @@ -234,8 +232,7 @@ void simulateEMT(SystemTopology& systemPF, String waveform) { // Simulation Simulation sim(simNameEMT, Logger::Level::debug); sim.setSystem(systemEMT); - sim.setTimeStep(timeStepEMT); - sim.setFinalTime(finalTimeEMT); + sim.setSimulationParameters(timeStepEMT, finalTimeEMT); sim.setDomain(Domain::EMT); sim.addLogger(loggerEMT); //sim.addEvent(loadStepEvent); diff --git a/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack_PiLine_PQLoad_FrequencyRamp_CosineFM.cpp b/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack_PiLine_PQLoad_FrequencyRamp_CosineFM.cpp index 6fa561ad6a..6a44506857 100644 --- a/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack_PiLine_PQLoad_FrequencyRamp_CosineFM.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_DP_SP_Slack_PiLine_PQLoad_FrequencyRamp_CosineFM.cpp @@ -63,15 +63,16 @@ void powerFlow(SystemTopology& systemPF) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); } @@ -122,8 +123,7 @@ void simulateDP(SystemTopology& systemPF, String waveform) { // Simulation Simulation sim(simNameDP, Logger::Level::debug); sim.setSystem(systemDP); - sim.setTimeStep(timeStepDP); - sim.setFinalTime(finalTimeDP); + sim.setSimulationParameters(timeStepDP, finalTimeDP); sim.setDomain(Domain::DP); sim.addLogger(loggerDP); @@ -175,10 +175,8 @@ void simulateSP(SystemTopology& systemPF, String waveform) { // Simulation Simulation sim(simNameSP, Logger::Level::debug); sim.setSystem(systemSP); - sim.setTimeStep(timeStepSP); - sim.setFinalTime(finalTimeSP); + sim.setSimulationParameters(timeStepSP, finalTimeSP); sim.setDomain(Domain::SP); - sim.addLogger(loggerSP); sim.run(); } @@ -233,8 +231,7 @@ void simulateEMT(SystemTopology& systemPF, String waveform) { // Simulation Simulation sim(simNameEMT, Logger::Level::debug); sim.setSystem(systemEMT); - sim.setTimeStep(timeStepEMT); - sim.setFinalTime(finalTimeEMT); + sim.setSimulationParameters(timeStepEMT, finalTimeEMT); sim.setDomain(Domain::EMT); sim.addLogger(loggerEMT); //sim.addEvent(loadStepEvent); diff --git a/dpsim/examples/cxx/Circuits/EMT_DP_SP_Trafo.cpp b/dpsim/examples/cxx/Circuits/EMT_DP_SP_Trafo.cpp index 14808c9d38..a1e6019f3d 100644 --- a/dpsim/examples/cxx/Circuits/EMT_DP_SP_Trafo.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_DP_SP_Trafo.cpp @@ -76,8 +76,7 @@ void simTrafoElementsSP1ph() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::SP); sim.addLogger(logger); @@ -129,8 +128,7 @@ void simTrafoSP1ph() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::SP); sim.addLogger(logger); @@ -201,8 +199,7 @@ void simTrafoElementsDP1ph() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::DP); sim.addLogger(logger); @@ -254,8 +251,7 @@ void simTrafoDP1ph() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::DP); sim.addLogger(logger); @@ -326,8 +322,7 @@ void simTrafoElementsEMT3ph() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); @@ -379,8 +374,7 @@ void simTrafoEMT3ph() { Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); diff --git a/dpsim/examples/cxx/Circuits/EMT_DP_SP_VS_Init.cpp b/dpsim/examples/cxx/Circuits/EMT_DP_SP_VS_Init.cpp index 54b97b057c..ab1fc79cf8 100644 --- a/dpsim/examples/cxx/Circuits/EMT_DP_SP_VS_Init.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_DP_SP_VS_Init.cpp @@ -38,8 +38,7 @@ void vsSetParamsDP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::DP); sim.addLogger(logger); sim.run(); @@ -72,8 +71,7 @@ void vsSetParamsSP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::SP); sim.addLogger(logger); sim.run(); @@ -142,8 +140,7 @@ void vsSetAttrDP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::DP); sim.addLogger(logger); sim.run(); @@ -178,8 +175,7 @@ void vsSetAttrSP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::SP); sim.addLogger(logger); sim.run(); @@ -214,8 +210,7 @@ void vsSetAttrEMT3ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); sim.run(); @@ -250,8 +245,7 @@ void vsSetFromNodeDP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::DP); sim.addLogger(logger); sim.run(); @@ -286,8 +280,7 @@ void vsSetFromNodeSP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::SP); sim.addLogger(logger); sim.run(); @@ -322,8 +315,7 @@ void vsSetFromNodeEMT3ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/Circuits/EMT_DP_SP_VS_RLC.cpp b/dpsim/examples/cxx/Circuits/EMT_DP_SP_VS_RLC.cpp index 4a2993b3b9..0a60e88508 100644 --- a/dpsim/examples/cxx/Circuits/EMT_DP_SP_VS_RLC.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_DP_SP_VS_RLC.cpp @@ -43,8 +43,7 @@ void voltageSourceResistorEMT3ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); sim.run(); @@ -82,8 +81,7 @@ void voltageSourceResistorDP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::DP); sim.addLogger(logger); sim.run(); @@ -121,8 +119,7 @@ void voltageSourceResistorSP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::SP); sim.addLogger(logger); sim.run(); @@ -167,8 +164,7 @@ void voltageSourceInductorEMT3ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); sim.run(); @@ -213,8 +209,7 @@ void voltageSourceInductorDP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::DP); sim.addLogger(logger); sim.run(); @@ -259,8 +254,7 @@ void voltageSourceInductorSP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::SP); sim.addLogger(logger); sim.run(); @@ -305,8 +299,7 @@ void voltageSourceCapacitorEMT3ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(logger); sim.run(); @@ -351,8 +344,7 @@ void voltageSourceCapacitorDP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::DP); sim.addLogger(logger); sim.run(); @@ -397,8 +389,7 @@ void voltageSourceCapacitorSP1ph() { // Simulation Simulation sim(simName); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::SP); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/Circuits/EMT_PiLine.cpp b/dpsim/examples/cxx/Circuits/EMT_PiLine.cpp index 43d76fb2c5..4f7d7da969 100644 --- a/dpsim/examples/cxx/Circuits/EMT_PiLine.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_PiLine.cpp @@ -74,8 +74,7 @@ void simElements() { Simulation sim(simName, Logger::Level::debug); sim.setSystem(sys); sim.setDomain(Domain::EMT); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); @@ -126,8 +125,7 @@ void simPiLine() { Simulation sim(simName, Logger::Level::debug); sim.setSystem(sys); sim.setDomain(Domain::EMT); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/Circuits/EMT_ReducedOrderSG_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/EMT_ReducedOrderSG_SMIB_Fault.cpp index 697fd0914d..b5fd7c8f12 100644 --- a/dpsim/examples/cxx/Circuits/EMT_ReducedOrderSG_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_ReducedOrderSG_SMIB_Fault.cpp @@ -56,6 +56,8 @@ int main(int argc, char* argv[]) { // ----- POWERFLOW FOR INITIALIZATION ----- String simNamePF = simName + "_PF"; Logger::setLogDir("logs/" + simNamePF); + Real timeStepPF = 0.1; + Real finalTimePF = 0.1; // Components auto n1PF = SimNode::make("n1", PhaseType::Single); @@ -93,14 +95,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::off); simPF.setSystem(systemPF); - simPF.setTimeStep(0.1); - simPF.setFinalTime(0.1); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -176,16 +180,18 @@ int main(int argc, char* argv[]) { loggerEMT->logAttribute("Idq0", genEMT->attribute("Idq0")); loggerEMT->logAttribute("Edq0", genEMT->attribute("Edq0_t")); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSystemMatrixRecomputation(true); + // Configure simulation Simulation simEMT(simNameEMT, logLevel); - simEMT.doInitFromNodesAndTerminals(true); simEMT.setSystem(systemEMT); - simEMT.setTimeStep(timeStep); - simEMT.setFinalTime(finalTime); - simEMT.setDomain(Domain::EMT); - simEMT.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + simEMT.setSimulationParameters(timeStep, finalTime); + simEMT.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); simEMT.addLogger(loggerEMT); - simEMT.doSystemMatrixRecomputation(true); // Events auto sw1 = SwitchEvent3Ph::make(startTimeFault, fault, true); diff --git a/dpsim/examples/cxx/Circuits/EMT_ReducedOrderSG_VBR_Load_Fault.cpp b/dpsim/examples/cxx/Circuits/EMT_ReducedOrderSG_VBR_Load_Fault.cpp index c6e90b5af6..997f2e2a99 100644 --- a/dpsim/examples/cxx/Circuits/EMT_ReducedOrderSG_VBR_Load_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_ReducedOrderSG_VBR_Load_Fault.cpp @@ -148,15 +148,18 @@ int main(int argc, char* argv[]) { loggerEMT->logAttribute("Tm", turbineGovernorEMT->attribute("Tm")); } + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSystemMatrixRecomputation(true); + + // Simulation simEMT(simNameEMT, logLevel); - simEMT.doInitFromNodesAndTerminals(true); simEMT.setSystem(systemEMT); - simEMT.setTimeStep(timeStep); - simEMT.setFinalTime(finalTime); - simEMT.setDomain(Domain::EMT); - simEMT.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + simEMT.setSimulationParameters(timeStep, finalTime); + simEMT.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); simEMT.addLogger(loggerEMT); - simEMT.doSystemMatrixRecomputation(true); // Events auto sw1 = SwitchEvent3Ph::make(startTimeFault, fault, true); diff --git a/dpsim/examples/cxx/Circuits/EMT_ResVS_RL_Switch.cpp b/dpsim/examples/cxx/Circuits/EMT_ResVS_RL_Switch.cpp index 72e588e064..5e3628a4e0 100644 --- a/dpsim/examples/cxx/Circuits/EMT_ResVS_RL_Switch.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_ResVS_RL_Switch.cpp @@ -47,8 +47,7 @@ int main(int argc, char* argv[]) { Simulation sim(simName, Logger::Level::info); sim.setSystem(system1); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.setSolverType(Solver::Type::MNA); sim.addSystemTopology(system2); diff --git a/dpsim/examples/cxx/Circuits/EMT_SMIB_ReducedOrderSGIterative_LoadStep.cpp b/dpsim/examples/cxx/Circuits/EMT_SMIB_ReducedOrderSGIterative_LoadStep.cpp index d1f97617b9..9fdf4dd352 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SMIB_ReducedOrderSGIterative_LoadStep.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SMIB_ReducedOrderSGIterative_LoadStep.cpp @@ -21,6 +21,8 @@ int main(int argc, char* argv[]) { String simName = "EMT_SMIB_ReducedOrderSGIterative_LoadStep"; Real timeStep = 10e-6; Real finalTime = 35; + Real timeStepPF = 0.1; + Real finalTimePF = 0.1; // Default configuration Real loadStepEventTime = defaultConfig.loadStepEventTime; @@ -106,15 +108,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, logLevel); simPF.setSystem(systemPF); - simPF.setTimeStep(0.1); - simPF.setFinalTime(0.1); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -187,13 +190,16 @@ int main(int argc, char* argv[]) { // load step event std::shared_ptr loadStepEvent = Examples::Events::createEventAddPowerConsumption3Ph("n1EMT", std::round(loadStepEventTime/timeStep)*timeStep, gridParams.loadStepActivePower, systemEMT, Domain::EMT, logger); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + + // Simulation simEMT(simNameEMT, logLevel); - simEMT.doInitFromNodesAndTerminals(true); simEMT.setSystem(systemEMT); - simEMT.setTimeStep(timeStep); - simEMT.setFinalTime(finalTime); - simEMT.setDomain(Domain::EMT); - simEMT.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + simEMT.setSimulationParameters(timeStep, finalTime); + simEMT.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); simEMT.addLogger(logger); // Events diff --git a/dpsim/examples/cxx/Circuits/EMT_SMIB_ReducedOrderSG_LoadStep.cpp b/dpsim/examples/cxx/Circuits/EMT_SMIB_ReducedOrderSG_LoadStep.cpp index 57f86ab872..749f604836 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SMIB_ReducedOrderSG_LoadStep.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SMIB_ReducedOrderSG_LoadStep.cpp @@ -94,15 +94,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, logLevel); simPF.setSystem(systemPF); - simPF.setTimeStep(0.1); - simPF.setFinalTime(0.1); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -173,15 +174,17 @@ int main(int argc, char* argv[]) { // load step event std::shared_ptr loadStepEvent = Examples::Events::createEventAddPowerConsumption3Ph("n1EMT", std::round(loadStepEventTime/timeStep)*timeStep, gridParams.loadStepActivePower, systemEMT, Domain::EMT, logger); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSystemMatrixRecomputation(true); + Simulation simEMT(simNameEMT, logLevel); - simEMT.doInitFromNodesAndTerminals(true); simEMT.setSystem(systemEMT); - simEMT.setTimeStep(timeStep); - simEMT.setFinalTime(finalTime); - simEMT.setDomain(Domain::EMT); - simEMT.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + simEMT.setSimulationParameters(timeStep, finalTime); + simEMT.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); simEMT.addLogger(logger); - simEMT.doSystemMatrixRecomputation(true); // Events simEMT.addEvent(loadStepEvent); diff --git a/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_PQLoad_with_PF_Init.cpp b/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_PQLoad_with_PF_Init.cpp index 649cdfb0a4..8ef2671e7a 100644 --- a/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_PQLoad_with_PF_Init.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_PQLoad_with_PF_Init.cpp @@ -72,15 +72,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v2", n2PF->attribute("v")); loggerPF->logAttribute("i12", linePF->attribute("i_intf")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -129,8 +130,7 @@ int main(int argc, char* argv[]) { // Simulation Simulation sim(simNameEMT, Logger::Level::debug); sim.setSystem(systemEMT); - sim.setTimeStep(timeStepEMT); - sim.setFinalTime(finalTimeEMT); + sim.setSimulationParameters(timeStepEMT, finalTimeEMT); sim.setDomain(Domain::EMT); sim.addLogger(loggerEMT); //sim.addEvent(loadStepEvent); diff --git a/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp b/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp index b5016728cd..070f2f5d94 100644 --- a/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp @@ -74,15 +74,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -136,8 +137,7 @@ int main(int argc, char* argv[]) { // Simulation Simulation sim(simNameEMT, Logger::Level::debug); sim.setSystem(systemEMT); - sim.setTimeStep(timeStepEMT); - sim.setFinalTime(finalTimeEMT); + sim.setSimulationParameters(timeStep, finalTime); sim.setDomain(Domain::EMT); sim.addLogger(loggerEMT); // sim.addEvent(loadStepEvent); diff --git a/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_VSI_with_PF_Init.cpp b/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_VSI_with_PF_Init.cpp index b70927eb5b..510a3a0638 100644 --- a/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_VSI_with_PF_Init.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_Slack_PiLine_VSI_with_PF_Init.cpp @@ -74,15 +74,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -134,8 +135,7 @@ int main(int argc, char* argv[]) { // Simulation Simulation sim(simNameEMT, Logger::Level::debug); sim.setSystem(systemEMT); - sim.setTimeStep(timeStepEMT); - sim.setFinalTime(finalTimeEMT); + sim.setSimulationParameters(timeStepEMT, finalTimeEMT); sim.setDomain(Domain::EMT); sim.addLogger(loggerEMT); // sim.addEvent(loadStepEvent); diff --git a/dpsim/examples/cxx/Circuits/EMT_SynGen4OrderIter_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/EMT_SynGen4OrderIter_SMIB_Fault.cpp index 609741218e..c57cc72d0e 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SynGen4OrderIter_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SynGen4OrderIter_SMIB_Fault.cpp @@ -34,6 +34,8 @@ void EMT_3ph_4OrderSynGenIter(String simName, Real timeStep, Real finalTime, Rea // // ----- POWERFLOW FOR INITIALIZATION ----- String simNamePF = simName + "_PF"; Logger::setLogDir("logs/" + simNamePF); + Real timeStepPF = 0.1; + Real finalTimePF = 0.1; // Components auto n1PF = SimNode::make("n1", PhaseType::Single); @@ -69,14 +71,15 @@ void EMT_3ph_4OrderSynGenIter(String simName, Real timeStep, Real finalTime, Rea loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); - simPF.setSystem(systemPF); - simPF.setTimeStep(0.1); - simPF.setFinalTime(0.1); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -155,14 +158,17 @@ void EMT_3ph_4OrderSynGenIter(String simName, Real timeStep, Real finalTime, Rea loggerEMT->logAttribute("Edq0", genEMT->attribute("Edq0_t")); loggerEMT->logAttribute("NIterations", genEMT->attribute("NIterations")); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSystemMatrixRecomputation(true); + Simulation simEMT(simNameEMT, logLevel); - simEMT.doInitFromNodesAndTerminals(true); simEMT.setSystem(systemEMT); - simEMT.setTimeStep(timeStep); - simEMT.setFinalTime(finalTime); - simEMT.setDomain(Domain::EMT); + simEMT.setSimulationParameters(timeStep, finalTime); + simDP.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterEMT); simEMT.addLogger(loggerEMT); - simEMT.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); // Events auto sw1 = SwitchEvent3Ph::make(startTimeFault, fault, true); diff --git a/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_DP_SynGenTrStab_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_DP_SynGenTrStab_SMIB_Fault.cpp index 718836a460..b27455d375 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_DP_SynGenTrStab_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_DP_SynGenTrStab_SMIB_Fault.cpp @@ -310,14 +310,17 @@ void DP_1ph_SynGenTrStab_Fault(Real timeStep, Real finalTime, bool startFaultEve logger->logAttribute("delta_r", gen->attribute("delta_r")); logger->logAttribute("Ep", gen->attribute("Ep_mag")); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSystemMatrixRecomputation(true); + Simulation sim(simName, Logger::Level::debug); sim.setSystem(system); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::DP); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); - sim.doSystemMatrixRecomputation(true); - sim.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); // Events if (startFaultEvent){ diff --git a/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_OperationalParams_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_OperationalParams_SMIB_Fault.cpp index 066ee67328..4b05a1da62 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_OperationalParams_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_OperationalParams_SMIB_Fault.cpp @@ -143,15 +143,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v_gen", genPF->attribute("v_intf")); loggerPF->logAttribute("ig", genPF->attribute("i_intf")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_OperationalParams_SMIB_Fault_JsonSyngenParams.cpp b/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_OperationalParams_SMIB_Fault_JsonSyngenParams.cpp index 368b2e0ce9..b44dab23b3 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_OperationalParams_SMIB_Fault_JsonSyngenParams.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_OperationalParams_SMIB_Fault_JsonSyngenParams.cpp @@ -107,15 +107,17 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v_gen", genPF->attribute("v_intf")); loggerPF->logAttribute("ig", genPF->attribute("i_intf")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); simPF.setTimeStep(1.0); simPF.setFinalTime(2.0); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_SMIB_Fault.cpp index 18b1c52454..62c3ed6391 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SynGenDQ7odTrapez_SMIB_Fault.cpp @@ -97,15 +97,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v_gen", genPF->attribute("v_intf")); loggerPF->logAttribute("ig", genPF->attribute("i_intf")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/Circuits/EMT_SynGenTrStab_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/EMT_SynGenTrStab_SMIB_Fault.cpp index 228bdee887..7f1877f506 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SynGenTrStab_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SynGenTrStab_SMIB_Fault.cpp @@ -89,15 +89,16 @@ void EMT_1ph_SynGenTrStab_Fault(String simName, Real timeStep, Real finalTime, b loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/Circuits/EMT_SynGenTrStab_SMIB_SteadyState.cpp b/dpsim/examples/cxx/Circuits/EMT_SynGenTrStab_SMIB_SteadyState.cpp index 2f5714e8b7..566a1eb19b 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SynGenTrStab_SMIB_SteadyState.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SynGenTrStab_SMIB_SteadyState.cpp @@ -85,15 +85,16 @@ void EMT_1ph_SynGenTrStab_SteadyState(String simName, Real timeStep, Real finalT loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/Circuits/EMT_SynGenVBR_OperationalParams_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/EMT_SynGenVBR_OperationalParams_SMIB_Fault.cpp index 500de213e7..7fddd89ff1 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SynGenVBR_OperationalParams_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SynGenVBR_OperationalParams_SMIB_Fault.cpp @@ -91,15 +91,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v_gen", genPF->attribute("v_intf")); loggerPF->logAttribute("ig", genPF->attribute("i_intf")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -163,15 +164,18 @@ int main(int argc, char* argv[]) { // Events auto sw1 = SwitchEvent3Ph::make(startTimeFault, fault, true); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSystemMatrixRecomputation(true); + // Simulation Simulation sim(simName, Logger::Level::debug); sim.setSystem(system); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::EMT); + simEMT.setSimulationParameters(timeStep, finalTime); + simEMT.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); sim.addEvent(sw1); - sim.doSystemMatrixRecomputation(true); - sim.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); sim.run(); } diff --git a/dpsim/examples/cxx/Circuits/EMT_SynGenVBR_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/EMT_SynGenVBR_SMIB_Fault.cpp index b293db6bcb..5b7db56904 100644 --- a/dpsim/examples/cxx/Circuits/EMT_SynGenVBR_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/EMT_SynGenVBR_SMIB_Fault.cpp @@ -91,15 +91,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v_gen", genPF->attribute("v_intf")); loggerPF->logAttribute("ig", genPF->attribute("i_intf")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -163,15 +164,18 @@ int main(int argc, char* argv[]) { // Events auto sw1 = SwitchEvent3Ph::make(startTimeFault, fault, true); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(true); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSystemMatrixRecomputation(true); + // Simulation Simulation sim(simName, Logger::Level::debug); sim.setSystem(system); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::EMT); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); sim.addEvent(sw1); - sim.doSystemMatrixRecomputation(true); - sim.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); sim.run(); } diff --git a/dpsim/examples/cxx/Circuits/PF_Slack_PiLine_PQLoad.cpp b/dpsim/examples/cxx/Circuits/PF_Slack_PiLine_PQLoad.cpp index 9f4d8615d4..c5751eb682 100644 --- a/dpsim/examples/cxx/Circuits/PF_Slack_PiLine_PQLoad.cpp +++ b/dpsim/examples/cxx/Circuits/PF_Slack_PiLine_PQLoad.cpp @@ -56,15 +56,16 @@ int main(int argc, char* argv[]) { logger->logAttribute("v1", n1->attribute("v")); logger->logAttribute("v2", n2->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation sim(simName, Logger::Level::debug); sim.setSystem(systemPF); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::SP); - sim.setSolverType(Solver::Type::NRP); - sim.setSolverAndComponentBehaviour(Solver::Behaviour::Simulation); - sim.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); sim.addLogger(logger); sim.run(); } diff --git a/dpsim/examples/cxx/Circuits/SP_ReducedOrderSG_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/SP_ReducedOrderSG_SMIB_Fault.cpp index 966675f796..f5b532a7aa 100644 --- a/dpsim/examples/cxx/Circuits/SP_ReducedOrderSG_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/SP_ReducedOrderSG_SMIB_Fault.cpp @@ -109,14 +109,17 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, logLevel); simPF.setSystem(systemPF); simPF.setTimeStep(0.1); simPF.setFinalTime(0.1); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -221,15 +224,18 @@ int main(int argc, char* argv[]) { loggerSP->logAttribute("Tm", turbineGovernorSP->attribute("Tm")); } + // set solver parameters + auto solverParameterSP = std::make_shared(); + solverParameterSP->setInitFromNodesAndTerminals(true); + solverParameterSP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterSP->doSystemMatrixRecomputation(true); + + // Simulation simSP(simNameSP, logLevel); - simSP.doInitFromNodesAndTerminals(true); simSP.setSystem(systemSP); - simSP.setTimeStep(timeStep); - simSP.setFinalTime(finalTime); - simSP.setDomain(Domain::SP); - simSP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + simSP.setSimulationParameters(timeStep, finalTime); + simSP.setSolverParameters(Domain::SP, Solver::Type::MNA, solverParameterSP); simSP.addLogger(loggerSP); - simSP.doSystemMatrixRecomputation(true); // Events auto sw1 = SwitchEvent::make(startTimeFault, fault, true); diff --git a/dpsim/examples/cxx/Circuits/SP_ReducedOrderSG_VBR_Load_Fault.cpp b/dpsim/examples/cxx/Circuits/SP_ReducedOrderSG_VBR_Load_Fault.cpp index fbbdb3751c..926bb68e80 100644 --- a/dpsim/examples/cxx/Circuits/SP_ReducedOrderSG_VBR_Load_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/SP_ReducedOrderSG_VBR_Load_Fault.cpp @@ -150,15 +150,18 @@ int main(int argc, char* argv[]) { loggerSP->logAttribute("Tm", turbineGovernorSP->attribute("Tm")); } + // set solver parameters + auto solverParameterSP = std::make_shared(); + solverParameterSP->setInitFromNodesAndTerminals(true); + solverParameterSP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterSP->doSystemMatrixRecomputation(true); + + // Simulation simSP(simNameSP, logLevel); - simSP.doInitFromNodesAndTerminals(true); simSP.setSystem(systemSP); - simSP.setTimeStep(timeStep); - simSP.setFinalTime(finalTime); - simSP.setDomain(Domain::SP); - simSP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + simSP.setSimulationParameters(timeStep, finalTime); + simSP.setSolverParameters(Domain::SP, Solver::Type::MNA, solverParameterSP); simSP.addLogger(loggerSP); - simSP.doSystemMatrixRecomputation(true); // Events auto sw1 = SwitchEvent::make(startTimeFault, fault, true); diff --git a/dpsim/examples/cxx/Circuits/SP_SMIB_ReducedOrderSG_LoadStep.cpp b/dpsim/examples/cxx/Circuits/SP_SMIB_ReducedOrderSG_LoadStep.cpp index f0647d65ab..a92778436a 100644 --- a/dpsim/examples/cxx/Circuits/SP_SMIB_ReducedOrderSG_LoadStep.cpp +++ b/dpsim/examples/cxx/Circuits/SP_SMIB_ReducedOrderSG_LoadStep.cpp @@ -93,15 +93,17 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, logLevel); simPF.setSystem(systemPF); simPF.setTimeStep(0.1); simPF.setFinalTime(0.1); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -162,18 +164,22 @@ int main(int argc, char* argv[]) { logger->logAttribute(genSP->name() + ".omega", genSP->attribute("w_r")); logger->logAttribute(genSP->name() + ".delta", genSP->attribute("delta")); - // load step event + // load step event std::shared_ptr loadStepEvent = Examples::Events::createEventAddPowerConsumption("n1SP", std::round(loadStepEventTime/timeStep)*timeStep, gridParams.loadStepActivePower, systemSP, Domain::SP, logger); + // set solver parameters + auto solverParameterSP = std::make_shared(); + solverParameterSP->setInitFromNodesAndTerminals(true); + solverParameterSP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterSP->doSystemMatrixRecomputation(true); + + // Simulation simSP(simNameSP, logLevel); simSP.doInitFromNodesAndTerminals(true); simSP.setSystem(systemSP); - simSP.setTimeStep(timeStep); - simSP.setFinalTime(finalTime); - simSP.setDomain(Domain::SP); - simSP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); + simSP.setSimulationParameters(timeStep, finalTime); + simSP.setSolverParameters(Domain::SP, Solver::Type::MNA, solverParameterSP); simSP.addLogger(logger); - simSP.doSystemMatrixRecomputation(true); // Events simSP.addEvent(loadStepEvent); diff --git a/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_PQLoad_with_PF_Init.cpp b/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_PQLoad_with_PF_Init.cpp index d49a10b5f2..ea84d44c82 100644 --- a/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_PQLoad_with_PF_Init.cpp +++ b/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_PQLoad_with_PF_Init.cpp @@ -70,15 +70,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp b/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp index 0b33856f7a..d23160dc9e 100644 --- a/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp +++ b/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_VSI_Ramp_with_PF_Init.cpp @@ -74,14 +74,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_VSI_with_PF_Init.cpp b/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_VSI_with_PF_Init.cpp index e3b47c855e..b1a174ff51 100644 --- a/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_VSI_with_PF_Init.cpp +++ b/dpsim/examples/cxx/Circuits/SP_Slack_PiLine_VSI_with_PF_Init.cpp @@ -74,15 +74,16 @@ int main(int argc, char* argv[]) { loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_3Bus_Fault.cpp b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_3Bus_Fault.cpp index b16c3611aa..f6f3c997a6 100644 --- a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_3Bus_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_3Bus_Fault.cpp @@ -85,15 +85,16 @@ void SP_SynGenTrStab_3Bus_Fault(String simName, Real timeStep, Real finalTime, b loggerPF->logAttribute("v_bus2", n2PF->attribute("v")); loggerPF->logAttribute("v_bus3", n3PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -198,16 +199,19 @@ void SP_SynGenTrStab_3Bus_Fault(String simName, Real timeStep, Real finalTime, b loggerSP->logAttribute("P_elec1", gen1SP->attribute("P_elec")); loggerSP->logAttribute("P_elec2", gen2SP->attribute("P_elec")); + // set solver parameters + auto solverParameterSP = std::make_shared(); + solverParameterSP->setInitFromNodesAndTerminals(true); + solverParameterSP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterSP->doSystemMatrixRecomputation(true); + + // Simulation simSP(simNameSP, Logger::Level::debug); simSP.setSystem(systemSP); - simSP.setTimeStep(timeStep); - simSP.setFinalTime(finalTime); - simSP.setDomain(Domain::SP); - simSP.addLogger(loggerSP); - simSP.doSystemMatrixRecomputation(true); - simSP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); - - // Events + simSP.setSimulationParameters(timeStep, finalTime); + simSP.setSolverParameters(Domain::SP, Solver::Type::MNA, solverParameterSP); + + // Events if (startFaultEvent){ auto sw1 = SwitchEvent::make(startTimeFault, faultSP, true); diff --git a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_3Bus_SteadyState.cpp b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_3Bus_SteadyState.cpp index 941f7337ac..a699ce73ed 100644 --- a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_3Bus_SteadyState.cpp +++ b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_3Bus_SteadyState.cpp @@ -74,15 +74,16 @@ void SP_SynGenTrStab_3Bus_SteadyState(String simName, Real timeStep, Real finalT loggerPF->logAttribute("v_bus2", n2PF->attribute("v")); loggerPF->logAttribute("v_bus3", n3PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_Fault.cpp b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_Fault.cpp index 22a5e40f5f..8edb09276e 100644 --- a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_Fault.cpp +++ b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_Fault.cpp @@ -67,15 +67,16 @@ void SP_1ph_SynGenTrStab_Fault(String simName, Real timeStep, Real finalTime, bo loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -147,15 +148,18 @@ void SP_1ph_SynGenTrStab_Fault(String simName, Real timeStep, Real finalTime, bo loggerSP->logAttribute("v_slack", extnetSP->attribute("v_intf")); loggerSP->logAttribute("i_slack", extnetSP->attribute("i_intf")); + // set solver parameters + auto solverParameterSP = std::make_shared(); + solverParameterSP->setInitFromNodesAndTerminals(true); + solverParameterSP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterSP->doSystemMatrixRecomputation(true); + // Simulation simSP(simNameSP, Logger::Level::debug); simSP.setSystem(systemSP); - simSP.setTimeStep(timeStep); - simSP.setFinalTime(finalTime); - simSP.setDomain(Domain::SP); + simSP.setSimulationParameters(timeStep, finalTime); + simSP.setSolverParameters(Domain::SP, Solver::Type::MNA, solverParameterSP); simSP.addLogger(loggerSP); - simSP.doSystemMatrixRecomputation(true); - simSP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); // Events if (startFaultEvent){ diff --git a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_Fault_KundurExample1.cpp b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_Fault_KundurExample1.cpp index 4cb7f1a3b3..4afff42dfe 100644 --- a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_Fault_KundurExample1.cpp +++ b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_Fault_KundurExample1.cpp @@ -115,15 +115,16 @@ void SP_1ph_SynGenTrStab_Fault(String simName, Real timeStep, Real finalTime, Re loggerPF->logAttribute("v2", n2PF->attribute("v")); loggerPF->logAttribute("v3", n3PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); @@ -207,14 +208,18 @@ void SP_1ph_SynGenTrStab_Fault(String simName, Real timeStep, Real finalTime, Re loggerSP->logAttribute("v_slack", extnetSP->attribute("v_intf")); loggerSP->logAttribute("i_slack", extnetSP->attribute("i_intf")); + // set solver parameters + auto solverParameterSP = std::make_shared(); + solverParameterSP->setInitFromNodesAndTerminals(true); + solverParameterSP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + //solverParameterSP->doSystemMatrixRecomputation(true); + + // Simulation simSP(simNameSP, Logger::Level::debug); simSP.setSystem(systemSP); - simSP.setTimeStep(timeStep); - simSP.setFinalTime(finalTime); - simSP.setDomain(Domain::SP); + simSP.setSimulationParameters(timeStep, finalTime); + simSP.setSolverParameters(Domain::SP, Solver::Type::MNA, solverParameterSP); simSP.addLogger(loggerSP); - // simSP.doSystemMatrixRecomputation(true); - simSP.setDirectLinearSolverImplementation(DPsim::DirectLinearSolverImpl::SparseLU); // Events auto sw1 = SwitchEvent::make(std::round(startTimeFault/timeStep)*timeStep, faultSP, true); diff --git a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_SteadyState.cpp b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_SteadyState.cpp index 738af2d60c..384c0400f3 100644 --- a/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_SteadyState.cpp +++ b/dpsim/examples/cxx/Circuits/SP_SynGenTrStab_SMIB_SteadyState.cpp @@ -57,15 +57,16 @@ void SP_1ph_SynGenTrStab_SteadyState(String simName, Real timeStep, Real finalTi loggerPF->logAttribute("v1", n1PF->attribute("v")); loggerPF->logAttribute("v2", n2PF->attribute("v")); + // set solver parameters + auto solverParameters = std::make_shared(); + solverParameters->setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); + solverParameters->setInitFromNodesAndTerminals(false); + // Simulation Simulation simPF(simNamePF, Logger::Level::debug); simPF.setSystem(systemPF); - simPF.setTimeStep(timeStepPF); - simPF.setFinalTime(finalTimePF); - simPF.setDomain(Domain::SP); - simPF.setSolverType(Solver::Type::NRP); - simPF.setSolverAndComponentBehaviour(Solver::Behaviour::Initialization); - simPF.doInitFromNodesAndTerminals(false); + simPF.setSimulationParameters(timeStepPF, finalTimePF); + simPF.setSolverParameters(Domain::SP, Solver::Type::NRP, solverParameters); simPF.addLogger(loggerPF); simPF.run(); diff --git a/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_LoadStep.cpp b/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_LoadStep.cpp index cb45219851..b4fbf94418 100644 --- a/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_LoadStep.cpp +++ b/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_LoadStep.cpp @@ -131,20 +131,26 @@ void EMT_SynGenDq7odODE_LoadStep(Real timeStep, Real finalTime, Real breakerClos res->connect({CPS::EMT::SimNode::GND, n1}); fault->connect({CPS::EMT::SimNode::GND, n1}); + // auto sys = SystemTopology(60, SystemNodeList{n1}, SystemComponentList{gen, res, fault}); - // Logging + // Logging auto logger = DataLogger::make(simName); logger->logAttribute("v1", n1->attribute("v")); logger->logAttribute("i_gen", gen->attribute("i_intf")); logger->logAttribute("wr_gen", gen->attribute("w_r")); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(false); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSteadyStateInit(true); + + // Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::EMT); - sim.doInitFromNodesAndTerminals(false); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); // Events diff --git a/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_SteadyState.cpp b/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_SteadyState.cpp index 65fdee8fe0..1c0890a2c2 100644 --- a/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_SteadyState.cpp +++ b/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_SteadyState.cpp @@ -118,12 +118,17 @@ void EMT_SynGenDq7odODE_SteadyState(Real timeStep, Real finalTime) { logger->logAttribute("v1", n1->attribute("v")); logger->logAttribute("i_load", res->attribute("i_intf")); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(false); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSteadyStateInit(true); + + // Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::EMT); - sim.doInitFromNodesAndTerminals(false); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); sim.run(); diff --git a/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_ThreePhFault.cpp b/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_ThreePhFault.cpp index 8e403a9978..7a72a0d359 100644 --- a/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_ThreePhFault.cpp +++ b/dpsim/examples/cxx/Components/DP_EMT_SynGenDq7odODE_ThreePhFault.cpp @@ -137,12 +137,16 @@ void EMT_SynGenDq7odODE_ThreePhFault(Real timeStep, Real finalTime, String exten logger->logAttribute("i_gen", gen->attribute("i_intf")); logger->logAttribute("wr_gen", gen->attribute("w_r")); + // set solver parameters + auto solverParameterEMT = std::make_shared(); + solverParameterEMT->setInitFromNodesAndTerminals(false); + solverParameterEMT->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterEMT->doSteadyStateInit(true); + Simulation sim(simName, Logger::Level::info); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.setDomain(Domain::EMT); - sim.doInitFromNodesAndTerminals(false); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::EMT, Solver::Type::MNA, solverParameterEMT); sim.addLogger(logger); // Events diff --git a/dpsim/examples/cxx/Components/DP_Inverter_Grid.cpp b/dpsim/examples/cxx/Components/DP_Inverter_Grid.cpp index 25bc40a055..c77c1922a0 100644 --- a/dpsim/examples/cxx/Components/DP_Inverter_Grid.cpp +++ b/dpsim/examples/cxx/Components/DP_Inverter_Grid.cpp @@ -77,12 +77,20 @@ int main(int argc, char* argv[]) { SystemNodeList{ n1, n2, n3, n4, n5 }, SystemComponentList{ inv, r1, l1, r2, l2, c1, rc, grid }); + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSteadyStateInit(true); + solverParameterDP->doFrequencyParallelization(true); + + // Simulation sim(simName, level); sim.setSystem(sys); sim.setTimeStep(timeStep); sim.setFinalTime(finalTime); - sim.doFrequencyParallelization(false); - + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); + // Logging auto logger = DataLogger::make(simName); logger->logAttribute("v1", n1->attribute("v"), 1, 9); diff --git a/dpsim/examples/cxx/Components/DP_Inverter_Grid_Parallel_FreqSplit.cpp b/dpsim/examples/cxx/Components/DP_Inverter_Grid_Parallel_FreqSplit.cpp index 80049bd4fa..4c350da9ad 100644 --- a/dpsim/examples/cxx/Components/DP_Inverter_Grid_Parallel_FreqSplit.cpp +++ b/dpsim/examples/cxx/Components/DP_Inverter_Grid_Parallel_FreqSplit.cpp @@ -85,11 +85,18 @@ int main(int argc, char* argv[]) { SystemNodeList{ n1, n2, n3, n4, n5 }, SystemComponentList{ inv, r1, l1, r2, l2, c1, rc, grid }); + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSteadyStateInit(true); + solverParameterDP->doFrequencyParallelization(true); + + // Simulation sim(simName, level); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.doFrequencyParallelization(true); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); + if (threads > 0) { auto scheduler = std::make_shared(threads); sim.setScheduler(scheduler); diff --git a/dpsim/examples/cxx/Components/DP_Inverter_Grid_Sequential_FreqSplit.cpp b/dpsim/examples/cxx/Components/DP_Inverter_Grid_Sequential_FreqSplit.cpp index 68e3ccf306..4a910c684f 100644 --- a/dpsim/examples/cxx/Components/DP_Inverter_Grid_Sequential_FreqSplit.cpp +++ b/dpsim/examples/cxx/Components/DP_Inverter_Grid_Sequential_FreqSplit.cpp @@ -83,11 +83,17 @@ int main(int argc, char* argv[]) { SystemNodeList{ n1, n2, n3, n4, n5 }, SystemComponentList{ inv, r1, l1, r2, l2, c1, rc, grid }); + // set solver parameters + auto solverParameterDP = std::make_shared(); + solverParameterDP->setDirectLinearSolverImplementation(CPS::DirectLinearSolverImpl::SparseLU); + solverParameterDP->doSteadyStateInit(true); + solverParameterDP->doFrequencyParallelization(true); + + // Simulation sim(simName, level); sim.setSystem(sys); - sim.setTimeStep(timeStep); - sim.setFinalTime(finalTime); - sim.doFrequencyParallelization(true); + sim.setSimulationParameters(timeStep, finalTime); + sim.setSolverParameters(Domain::DP, Solver::Type::MNA, solverParameterDP); sim.run(); sim.logStepTimes(simName + "_step_times"); diff --git a/dpsim/include/dpsim/MNASolver.h b/dpsim/include/dpsim/MNASolver.h index 2833213192..bf3edbd3a6 100644 --- a/dpsim/include/dpsim/MNASolver.h +++ b/dpsim/include/dpsim/MNASolver.h @@ -127,7 +127,7 @@ namespace DPsim { /// Constructor should not be called by users but by Simulation MnaSolver(String name, CPS::Domain domain = CPS::Domain::DP, - std::shared_ptr solverParams = SolverParametersMNA(), + std::shared_ptr solverParams = std::make_shared(), CPS::Logger::Level logLevel = CPS::Logger::Level::info); /// Initialization of individual components diff --git a/dpsim/include/dpsim/MNASolverDirect.h b/dpsim/include/dpsim/MNASolverDirect.h index 07b6a690f8..ec67833a3e 100644 --- a/dpsim/include/dpsim/MNASolverDirect.h +++ b/dpsim/include/dpsim/MNASolverDirect.h @@ -144,7 +144,7 @@ namespace DPsim { /// sovlerImpl: choose the most advanced solver implementation available by default MnaSolverDirect(String name, CPS::Domain domain = CPS::Domain::DP, - std::shared_ptr solverParams = SolverParametersMNA(), + std::shared_ptr solverParams = std::make_shared(), CPS::Logger::Level logLevel = CPS::Logger::Level::info); /// Destructor diff --git a/dpsim/include/dpsim/MNASolverFactory.h b/dpsim/include/dpsim/MNASolverFactory.h index 0966816e7c..595a996f20 100644 --- a/dpsim/include/dpsim/MNASolverFactory.h +++ b/dpsim/include/dpsim/MNASolverFactory.h @@ -63,7 +63,7 @@ class MnaSolverFactory { template static std::shared_ptr> factory(String name, CPS::Domain domain = CPS::Domain::DP, - std::shared_ptr solverParams = SolverParametersMNA(), + std::shared_ptr solverParams = std::make_shared(), CPS::Logger::Level logLevel = CPS::Logger::Level::info, String pluginName = "plugin.so") { diff --git a/dpsim/include/dpsim/MNASolverPlugin.h b/dpsim/include/dpsim/MNASolverPlugin.h index edf15b607d..0f8dd8127a 100644 --- a/dpsim/include/dpsim/MNASolverPlugin.h +++ b/dpsim/include/dpsim/MNASolverPlugin.h @@ -32,7 +32,7 @@ namespace DPsim { MnaSolverPlugin(String pluginName, String name, CPS::Domain domain = CPS::Domain::DP, - std::shared_ptr solverParams = SolverParametersMNA(), + std::shared_ptr solverParams = std::make_shared(), CPS::Logger::Level logLevel = CPS::Logger::Level::info); virtual ~MnaSolverPlugin(); diff --git a/dpsim/src/Simulation.cpp b/dpsim/src/Simulation.cpp index 902146f400..bb71b0c281 100644 --- a/dpsim/src/Simulation.cpp +++ b/dpsim/src/Simulation.cpp @@ -54,7 +54,7 @@ Simulation::Simulation(String name, CommandLineArgs& args) : void Simulation::setSolverParameters(CPS::Domain domain, Solver::Type type, std::shared_ptr solverParameters) { mDomain = domain; - mSolverType = Solver::Type::MNA; + mSolverType = type; if (mSolverType == Solver::Type::MNA) { if (solverParameters==nullptr) { mSolverParams = std::make_shared(); @@ -87,15 +87,17 @@ void Simulation::setSolverParameters(CPS::Domain domain, Solver::Type type, std: if (mSolverType == Solver::Type::NRP) { if (solverParameters==nullptr) { - mSolverParams = std::make_shared(); + //mSolverParams = std::make_shared(); + mSolverParams = std::make_shared(); return; - } else if (std::dynamic_pointer_cast(solverParameters)) { + } else if (std::dynamic_pointer_cast(solverParameters)) { mSolverParams = solverParameters; return; } else { std::stringstream ss; ss << "Type of SolverParameters has to be SolverParametersNRP!!"; + ss << "Type of SolverParameters has to be SolverParametersMNA!!"; throw std::invalid_argument(ss.str()); } } diff --git a/examples/Notebooks/Circuits/CS_R2CL.ipynb b/examples/Notebooks/Circuits/CS_R2CL.ipynb index 3192189ce6..dcbd485446 100644 --- a/examples/Notebooks/Circuits/CS_R2CL.ipynb +++ b/examples/Notebooks/Circuits/CS_R2CL.ipynb @@ -34,21 +34,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Type of SolverParameters has to be SolverParametersMNA!!", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/home/mmo/git/Can/dpsim/examples/Notebooks/Circuits/CS_R2CL.ipynb Cell 4\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 41\u001b[0m sim\u001b[39m.\u001b[39mset_system(system)\n\u001b[1;32m 42\u001b[0m sim\u001b[39m.\u001b[39mset_simulation_parameters(time_step\u001b[39m=\u001b[39m\u001b[39m0.0001\u001b[39m, final_time\u001b[39m=\u001b[39m\u001b[39m0.1\u001b[39m)\n\u001b[0;32m---> 43\u001b[0m sim\u001b[39m.\u001b[39;49mset_solver_parameters(dpsimpy\u001b[39m.\u001b[39;49mDomain\u001b[39m.\u001b[39;49mEMT, dpsimpy\u001b[39m.\u001b[39;49mSolver\u001b[39m.\u001b[39;49mMNA)\n\u001b[1;32m 44\u001b[0m sim\u001b[39m.\u001b[39madd_logger(logger)\n", - "\u001b[0;31mValueError\u001b[0m: Type of SolverParameters has to be SolverParametersMNA!!" - ] - } - ], + "outputs": [], "source": [ "# DPsim EMT simulation\n", "name = 'EMT_CS_R2CL'\n", @@ -92,24 +80,55 @@ "sim = dpsimpy.Simulation(name, dpsimpy.LogLevel.info)\n", "sim.set_system(system)\n", "sim.set_simulation_parameters(time_step=0.0001, final_time=0.1)\n", - "sim.set_solver_parameters(type=dpsimpy.Domain.EMT, domain=dpsimpy.Solver.MNA)\n", + "sim.set_solver_parameters(domain=dpsimpy.Domain.EMT, type=dpsimpy.Solver.MNA)\n", "sim.add_logger(logger)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[10:15:42.451547 EMT_CS_R2CL info] Initialize simulation: EMT_CS_R2CL\n", + "[10:15:42.451822 MnaSolverFactory info] creating SparseLUAdapter solver implementation\n", + "[10:15:42.452777 EMT_CS_R2CL info] Scheduling tasks.\n", + "[10:15:42.453154 EMT_CS_R2CL info] Scheduling done.\n", + "[10:15:42.453158 EMT_CS_R2CL info] Opening interfaces.\n", + "[10:15:42.453159 EMT_CS_R2CL info] Start synchronization with remotes on interfaces\n", + "[10:15:42.453161 EMT_CS_R2CL info] Synchronized simulation start with remotes\n", + "[10:15:42.453164 EMT_CS_R2CL info] Start simulation: EMT_CS_R2CL\n", + "[10:15:42.453167 EMT_CS_R2CL info] Time step: 1.000000e-04\n", + "[10:15:42.453169 EMT_CS_R2CL info] Final time: 1.000000e-01\n", + "[10:15:42.502338 EMT_CS_R2CL info] Simulation calculation time: 0.049163\n", + "[10:15:42.502364 EMT_CS_R2CL info] Simulation finished.\n" + ] + } + ], "source": [ "sim.run()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "logs/EMT_CS_R2CL.csv\n", + "column number: 4\n", + "results length: 1000\n", + "real column names: ['c_1.i_intf', 'cs.i_intf', 'n1.v', 'n2.v']\n", + "complex column names: []\n" + ] + } + ], "source": [ "# read EMT results\n", "work_dir = 'logs/'\n", @@ -121,9 +140,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABnTElEQVR4nO29d5hkVZ3//zpV1dU55zA5MHkGmIEhDBIGCZJEorKCqCwq67qGNWB23a/603XXDSKiiIpEJQ4ZyWkYmDzD5NQ55658fn+ce6uqezpUuLe6b/V9P08/davq1q3T7zrnfs4nCyklNmzYsGFj+sIx2QOwYcOGDRuTC1sQ2LBhw8Y0hy0IbNiwYWOawxYENmzYsDHNYQsCGzZs2JjmcE32ABJBWVmZnD179mQPw4YNGzYshffee69dSlk+8nVLCoLZs2ezadOmyR6GDRs2bFgKQogjo71um4Zs2LBhY5rDFgQ2bNiwMc1hCwIbNmzYmOawBYENGzZsTHPYgsCGDRs2pjkMEQRCiN8LIVqFEDuiXisRQjwvhNinPRaP8dkbtXP2CSFuNGI8NmzYsGEjdhilEfwBuHDEa98AXpRSLgBe1J4PgxCiBPgecCpwCvC9sQSGDRs2bNhIHKHQ2JWmDckjkFK+KoSYPeLly4GzteN7gJeBr4845wLgeSllJ4AQ4nmUQLlvvO9r6vHQM+inMCcjuYFbGE9sbeTxrY3UFWdz2znzKc3LnOwhTRqe3t7EI5sbqCnK5gvnzKc8f/py8dzOZh5+r57Kgiz+6dz5VBRkTfaQJg1//6CFB949RlleJredO5/qwuzJHtKk4ZW9bfzoyV1jvm9mQlmllLJJO24GKkc5pxY4FvW8XnvtOAghbgFuAXBXzeea37zFI184nRy3JXPiksLvXj807Ed9bV87f/3c6RRmTz/B+Ke3DvOdx3aGn7+yt41HPn86RTnuSRzV5OCBd4/y9b9uDz9/eW8rj37+jGm5Sfjb+/V8+cGt4ecvfdDKo7edQUX+9BOMT2xt5J/u2zzuOSlxFkvV/SapDjhSyjullKullKszXQ72tPTx82f3GjRC6+BAWz//76ndANx2znzmV+Sxv7WfXzy3Z5JHlnoc7RjkR08qLj539jwWVeVzqH2Anzz9wSSPLPVo7B7ie48rgXjLWXNZWlPAsc4hfrxh9ySPLPVo6fXw7UeVu/LTZ85hZV0hjT0efvDE2DvidEV7v5dvPaI2B58/e96Y55kpCFqEENUA2mPrKOc0ADOintdpr42LGSU5CAF/fvsITT1DhgzWKvivF/YRCEmuXT2Dr15wAv/78ZNwaFwc6xyc7OGlFL/6+z58wRAfPbGWr1+4iP/9xEm4HIIHNh3jUPvAZA8vpfifl/bj8Yf4yPJqvnXxYn79iZNxOx38bXMDe1v6Jnt4KcWvXz7AoC/I+sWVfOeSJfz6hpPJynCwYVsTOxp6Jnt4KcVvXz1InyfAWQvL+doFJ4x5npmC4HFAjwK6EXhslHOeBT4shCjWnMQf1l4bF9kZTi5aVoUvGOK+jccmOj1t0Nbn5ekdTTgEfHH9AgBOqMrnspU1hCT88a3DkzvAFKJ70McTWxsB+JLGxbzyPK48qRYp4Z43D0/i6FKLPo+fRzer/dO/nK+4mFmawzVr6gC4+43DkzW0lGPQF+Cv79UDES5qirL5+CmzgOnFhccf5MFN6v74L+sXIIQY81yjwkfvA94CThBC1AshPg38BDhfCLEPWK89RwixWghxF4DmJP4R8K7290PdcTwRPnGq+mEf2VzPdOm7/NB7x/AHJecuqqC2KOL4+uTpswF4dEsjwXEiA9IJD79XjzcQ4qyF5cwqzQ2//snTZgPw+NZGAsHQJI0utXh0cwODviBr55YwvyI//PqNGhdPbmvEGwhO0uhSiye2NtLnDXDSzCKW1hSGX7/xdHW/eHpHEx7/9ODi6R1NdA36WVZbwKoZReOea4ggkFJeL6WsllJmSCnrpJS/k1J2SCnPk1IukFKu12/wUspNUsrPRH3291LK+drf3bF+59q5pVQVZHGsc4h3D3cZ8W9MeTy1Xfner10zc9jrJ84ooq44m7Y+L5sOxyRHLQ+di+vWzBj2+tKaAuaW59I54OPtg9ODiw1hLobPiwWV+SyqyqfPE+CN/e2TMbSUY8P2ZuB4LmaV5rKyrpBBX5CX94xmpU4/bNimuLh2zcxxtQGwcGax0yG4dGU1AC/sbpnk0ZiPpp4hdjT0kp3hZN2CsmHvCSH4yArFhX6DTGe09XnZfKwbt8vBhxYOL60uhOCS5YqLDdsbJ2N4KUX3oI93D3fhcgjOWVRx3PuXaPPiyW3pPy/6PH7eOtCOQ8B5i4/n4iPTiIshX5DX97cB8OElowVsDodlBQHAOSeoH/uVPW2TPBLz8cJutYs5a2EZWRnO496/cGkVAC9NAy5e+qAVKeGMeaXkZh4fPnzBMo2LD9rS3mz40p5WgiHJqXNLRg0fvlDj4pU9beMmFKUDXt3bjj8oOXlW8aghsxcuVYLglb1taW9CfX1/Ox5/iJV1hVTGkEtiaUFw8uxictxO9rT0pX30kC7szls0unRfUVdEQZaLo52DaR899MpexcW5i0fnYnFVAaW5bpp7PRxoS+/oIX1enDvGvJhXnkdVQRYdAz4+aE7v6KFX9qrN0lhczCzNYWZJDn2eANvTPHpoIi5GwtKCINPl5PR5ykzy2r70tYGGQpJNR5S9+7R5paOe43SI8HvpbA+WUrJR84OcNnd0LhwOwenz1bx480D6cgGE/WNjcSGE4IzpxsUYawQIc5HOawTg3UMTcxENSwsCgLVzSwDS2km6v62f7kE/VQVZ1BWPnSYfnuQHOlI1tJTjSMcgbX1eSnPdzCvPHfO8M6aBUGzoHqKhe4j8LBcnVOWPed4Z89Ofi7Y+L4faB8jOcLK0pmDM83Qu0lko9gz62dPSh9vpYEVd4cQfIA0EwerZmiA4kr6RQxsPKSG3Zk7JuN7/tdqu8L00Foq6NrB6dnFsXBzpSls/gb75WT2rGKcjNi7S1U+gc3HSrCIynGPf1k6do7jYfLQ7bf0EuvVg5YzCUf2Jo8HygmBpTQFZGQ4Otg3QOeCb7OGYgne1Sb5m9viFWeeX55Gf6aKxx0NLrycVQ0s53tWForYBGAuzSnMozsmgvd9HfVd6+o/0DcLqCbioLsyisiCTXk+AQx3p6TMJbxBmjc9FeX4mM0qyGfQF0zbjOrJZGp+LaFheEGQ4HaysKwLUjicdsUmzfU5083M4BCu1xJHNR7tNHtXkQNf8JuJCCMGJM5Xg3Hys2+xhTQr0eXHKnBi4mKFxka7zIkYugOnDxXQSBEB4wW+v757cgZiAtj4vDd1D5LqdnFA5th1Yh55BuPlY+gnFnkE/h9oHyHQ5WDKOHVhHmIuj6cfFoC/A3tY+XA7B8tqJ7cCrZhYB6cmFNxBkd1MvQjBhBi2k97wIBEPhekonzYy9tUtaCALdObSjsXeSR2I8djaqH3VJTQGOcezAOk7UFvzWNNwF72xSXCyqyh/XDqwjnbnY3dSLlDC/Ii8mO/CJ2s1vaxpulvY29xMISeaU5Y6aVzIS4XmRhlwcaBvAGwhRV5wdV7+WtBAEy7QdkX7TTCfs1IRbdN2U8aBzsauxN+2cpLt0LmLYAQMs0zj7oLkv7Zyk+rxYFiMXOmd7m/vxp1kNJn3dL4txjSyuLsAh1E0z3eoOxcuFjrQQBLNKcsjLdNHS66W93zvZwzEU+s0vFlMIQEV+JiW5bno9ARp70sthHBGKsXFRnOumqiCLQV+QI2mWZLezIT4u8jJdzCzJwRcMcTDNkuzinRdZGU7mlucRDEn2tfSbObSUI14udKSFIHA4BIurlf18Z5qZh3QJH+sPK0SEi91py0Xsu50wF01pxkWTzYWOxOaFWk9py0XtNBQEEJkE6WQe6vX4OdwxiNvpYEHFxI5iHYur0m+SD/mC7G/tx+kQLBoneWok0nHB+wIh9mjlIvSbeyxIRy6CIcnuJsVFPLtgnbddacSFlDJuU7KONBIEahLoKnM64ANtgi+sysPtiv2n0hd8Ok3yPS19hKTKlYg1SQaiuEgj7Wh/az/+oHKO5mfF7hBMx3lxqH2AIX+Q2qJsinNj71OdjlzUdw3R5wlQlpdJRX58farTRhDoP2w6JYns0f6XRVXxqXnpuPPbq+2AF8WxA4Y05SI8L+LjYonNRRjRXKRLUEW0ljhR/4GRMFUQCCFOEEJsifrrFUJ8acQ5ZwsheqLO+W4i3zWvPA8h1A4hXaIi9muTfGFlXlyfm1+RR4ZTcKRzkAFvwIyhpRz7WhUXCyri42JOWS5ZGQ4aezx0D6ZH5nmiXNQVZ5Of6aK930drX3oEEujO3vlxrhE9qKLPE6ChOz0yz/e1alzEOS/AZEEgpdwjpVwlpVwFnAwMAo+Mcupr+nlSyh8m8l3Zbid1xdkEQpIjaZJGr/+w8fgHANwuB3PL8pASDrSlR1REZJLHx4XTIcL87W9NEy7CN7/4uBBCsFDbOe9Pk2iZiFCMnws9QXNfusyLBLmA1JqGzgMOSCmPmPUFOgHpEhKWjISfV6Eqc6aNINB+0wVx7vyAcJXSdOFif3iDYHORFBf6GkkTQRDmIoE1kkpBcB1w3xjvnSaE2CqEeFoIsXS0E4QQtwghNgkhNrW1jd6FS58M6SDhewb9tPV5ycpwDGtUHyvmlysuDrRaXzsa8Cr1PcMpmFWSE/fn5+lcpEH8vDcQ5HDHAA6hzF7xIp24CETlRMxLSCimDxehkAwLAn3tx4OUCAIhhBu4DHholLffB2ZJKVcC/w08Oto1pJR3SilXSylXl5eXj3ZKeOecDiaA/W1KzZtfkRdTaYmRmJdGXOiLfW5ZHq4YSkuMRDrNi8Ptg4SkasYeT/SUjnTi4ljXEL5giNqibPJiKC0xEjoX6aARNPV6GPQFKcvLjCt6SkeqNIKLgPellMd1mZdS9kop+7Xjp4AMIUTZyPNiwfw00gjCppAE7H0QvdtJAy5aI0IxEehCMZ24mJfAri/6c2nBhRZMkYg2AOnJxfyK+LVESJ0guJ4xzEJCiCqhxToJIU7RxpRQi635UQve6k0nkvEPAMzVbMGHOwYIWDyKKlkuZpXm4HQIjnUOWr62TDK+EoAZJTm4nQ6aejz0WzyibF8S/gFQfRpy3E46Bnx0WbyXyf4EA0t0mC4IhBC5wPnA36Jeu1UIcav29CpghxBiK/Ar4DqZYGBvflYGlQWZ+AIhGizejOSgtktJdOeX43ZRW5SNPyg5avE6O2EuElzwmS4nM0tyCEklGK2Mg+2aTTzBeeF0iLBv4aDFd8Jh/0CCXAgh0kYrOBDmYopqBFLKASllqZSyJ+q1O6SUd2jH/yOlXCqlXCmlXCulfDOZ75tdGtkJWxmHO9TNOxGHoI6IScTiXLRrXJQmwYUeLWNx5/lhTRDMKYvfaa4jXSLK9DU+Oxku0iSKSp8XsxO8X6RNZrEO/cZp5VyCQDDEMW0XP6t0ek/yUEhypFP9lrOSWvDW3/lJKSM3v6SEYnpElOlrPKnNUppEDiXLRdoJglnaAjnUbl1zSGO3h0BIUl2YlVBkiA79ZnGkw7pctPR58PhDlOa6KYijrs5IzEoDLjoHfPR5AuRnuihJIDJER5gLC5sM+zx+2vt9ZLocVOZnJXydWWmwcfT4gzT2eHA5REKh5pCGgmC2toO28g+rNxhPRhuI/ryVudDNQslykQ7zQjcXzirLibuWTDTSgQtdoM8qzUkovFpHhAvrCkXdB1hXnJ1QeDWkoyAos76PwAiVF9JjF3ykIznbp46Z+oK38C74iAFmIYjiwsLzwggTGcCsEvX5o52Dli0+l6x/ANJQEOg7x2OdQ5YNIY3sgpOb5LVF2TgENPYM4Q1YM2zykEELvrowG7fTQVuf17KF+MILPkkuyvMyyXE76RnyW7YQnxE3P4DCnAyKcjIY9AVps2h3QyOEYtoJghy3i4r8THzBEI0WrSoY+WGTM4e4XQ5qi7ORUtUqtyKOGGQacjoEdSXKfmrVcNrDHcZwIYRgZom1tQKjuADCZUumMxdpJwjA+uahwwaZQyCi+lrVHnzYIDMZRDvPbS5mW9xhHA6jTVI7AuubUG3T0BjQd9KHLfjDBkMyEjpaYsQkt+5uJzpcMlkzGWDpXbCUkkPtxnERnhftVhWKuuPcyDViTS70+WybhkZAl4xWnOSN3UP4g5Kqgiyy3YmHjuqwsiBo7fPi8YcoyXVTmJ146KgOK28Qugf99HkC5GW6KMtLPHRUh5VDSPu9Adr7vbhdDqoLEg8d1WFljUCFjg4p02dxYqGjkK6CwMLZxYcNCh3VMdPCpqHIDtgYLvQFf7TTglxEzYtkQkd16JweteDNTzeFzCpJLnRUxywLR5Qd6xxEShU6mpFg6CikqSDQTQDHOq3nINXHPDOBuvujQU+/t+JuRzeRGcWFvuAPWzDZ0DQuLLhBqO8yhwsrbpaOGcRFWgqCGcWaIOiyXmyw/sPOMGiSh4Vi16DlwmmPaZFO+u+ZLOqKc3AIaLJgOK0e9WXUvKguzCbDKWjt8zLos1Y4rb5ZMooLPZy2e9BPz6DfkGumCjoXdUmukbQUBAXZLvIzXQz6gnRZ7IfVF3wy9r5o5LhdlOdn4g9KmnqspSHpOz+juHC7HFQXZhOSWK46rdFcOB0ismGymOZsNBfR4bRWCy02iou0FARCCGo1YnSirILID2vMbgdgRpgLqy14Y3Y70ZhRYnUujLn5AdRpNz/rrRETuCie3lykpSCA6B/WXvC1GhdW2wU3mMFFkcaFxZINzRCKeoEym4vIHLMqF8maydJWEER2ftaR8B5/kLY+LxlOQaUBYXE66iyoEfiDIZp6hhACqovM4MI68yIUkmGhmGh1ydFgxXkhpTTcNBR9LStxARYyDQkhDgshtgshtgghNo3yvhBC/EoIsV8IsU0IcZIR32tFjUAfa01RNk4DwuJ0RHY71rn5Nfd4CEmoKsgi05V8PoWOMBcWmhdt/V58QVWKOzeBJu1jwYpCsXvQz4AvSH6my5DcEh1W5KLfG6Br0E+my0F5XmZS1zJuVo2Pc6SU7WO8dxGwQPs7Ffi19pgUrCjhzdjpQGQXaSUujpnFhT0vwrCiUNR/t9ribEPyKXToJkMrzYsGA7mYCqahy4E/SoW3gSIhRHWyF7WihA/bPouMs31CRDuykv3TDDswREJRbS6sqjUbH0yhrmdFoWgcF6kQBBJ4TgjxnhDillHerwWORT2v114bBiHELUKITUKITW1tbRN+aV1UaJxVcgnMcBRDRCNo7LZOae76TnN2wVWFWTgENPd68AVChl7bLBwziYvyvEzcTgcdAz6GfNbIqzBLUyzKySDH7aTPG6BnyBoh50bOi1QIgjOllCehTEBfEEKclchFpJR3SilXSylXl5eXT3h+YXYGBVkuhvxBOgesUXM9LOFLjJ3k2W4nZXlu/EFJa5/H0GubBbOEYobTQVVBFlJimbwKs7hwOAQ1miPeKv4js7gQQljOihCOGLKCRiClbNAeW4FHgFNGnNIAzIh6Xqe9ljSspvoeM8kEAFGhghbhwixzCET8BDYXES6O2VxYzpdmpFA0VRAIIXKFEPn6MfBhYMeI0x4HPqlFD60FeqSUTUZ8v9Ucxg0mqb3qmtYSimY5SNU1bS506P4o6whF8+eFZbjoNo4Ls6OGKoFHNI+2C/iLlPIZIcStAFLKO4CngIuB/cAg8CmjvtxK2YJDviDt/T4ynIKKfOPi5nWEd8EWcJL6AiGaez0qh6DQ+AUf3vlZgItQSIZ/s1oTbn5WiqJSOQTG1p+KhpW4AGO1I1MFgZTyILBylNfviDqWwBfM+H4raQS6jbbW4BwCHVayf+o5BDWFWbhdxiutVuKitc+LPygpy3OT4zZ+uVqJi65BP4O+IPlZLgpzjMsh0GElLvo8froH/WRlOAzpTzEVwkdNw4yoyptTHWb6B9R1rSMUzQoR1GElE4DORa3ZXFhAO0rZvLAAF/oY64qN6U+R1oJAj4iwQhN7fYw1BpZTiEathWzBDWZzYSGhGDYL2VyE14hpXFjIWRy5XxhjLkxvQaDZl5u6p37IpD5GM2ziMNxHMNXzKpp6NC4MrKsTDV3ANPd6CASndi5BmAuT5kVlfiYuh6Ctz4vHP7VzCRpNXiNleW4yXQ56hvz0eaZ2LoHORU2hMUIxrQVBUU4GWRkO+ryBKf/DRha8ObudvEwXRTkZeAMh2vq9pnyHUTCbi0yXk4r8TIIhSXPv1N4kNJvMhcvpoKrQGpqz/ltVmcRFdPn6qW4e0ueFUVyktSAQQoRVJ/3mMlXR3KsmnlmTHCIaUuMU15CatUSvKgMrsI5ETZE1uNCT3kydF5bhwlyhCMOz8KcyjOYirQUBRG5+U13C66Yho2x+oyFsEpniGbX6JE8FF1M9u9hs0xBEzAtTngttDZvJRXWYi6kuFI3lIu0FQfiHncK7HSlleOKZufOrtohGkEoupv6CN38XXG0RrTklXFjEr2i0yTD9BUF4kk/d3U7vUIAhf5Bct5N8A+vNj0S1BXbBgz5V9MvtdFCSk3x89FiIbBCmLhe+QIj2fi8OARX5ydWbHw9W0AhCIUmLyT4CiIo0nMJcmLFxTFU/gklDTdgRNoqElxKOvAGNmyG3HBZeANnFKR5hZNJVFxlbY30k9Jtf4xTe+UVPcIcJiXU6wtrRFOaipdeDlFBZkIXLad6ercoCmmJ7v5dASFKS6yYrw7hGRSNRZQGNoGfIz5A/SF6mi/wsYxLr0l4QjKkRDHXBQ5+Cgy9FXssuhot+BiuuSeEIzY8M0RFRe6fubsfoaIixYAXtyOwoGR3VFtAIwhsEEwMIwBrakRkmsrQXBDWjOX/8Q/DHy6FpK2SXwLIroWUnHH0L/vZZGOyAtZ9L2RhTN8nHsAV7euG9u2Hf8zDYCaVzYdUnYOGFYKKGMhpSYQeGcXJMvH3w3h9g77OKi5I5sPI6WHRJ+nJRNAYXvgF4/4+w52kYaIfiWbDiWlhyedpyEe0vkVJGNHTfIGz+M+zZAP2tUDQLVlwNSz4KjtRa2M3YLKW9IKiOCgcL/7DP3q6EQPFsuPFJKJqhzETv/Aae+To880313gkXpWSMzVGmITNRWajszK19XgLBkDI3HH0HHv4U9EZV/m7dCbufgIUXwZV3QlaBqeOKRrPB0RBjoVxLpOoY8OHxB5W5of49eOgm6DkaObF1J3zwJMw/Hz7225SaDlPFRXFOBpmuSL5NflYGNG6Bh26ErsORE1t3wp6nYO7ZcNXdkFNi6riiEVkj5goCZW5x0edR/YBLct3QvAMe/CR0Hoic2LoL9j4Ns+9WXORN3CPFKJghFNPeWZyX6aIgy4U3EFINapq2wqbfgyMDrvmjEgKgdjhrb4VzvwNIePRz0D9xJzQj0Jii3U6my0lZnkqkauv3wqFXlWbU2wA1J8E1f4JbXoHzfwSZhWqi33MJeHpMHVc0UsWF0yGo1DSwll4PHHkL7rlUCYGqFXD1HxQXF/w7ZBXB/ufhD5coLSFFiGTSmstFdL5Nc48H6jep/7XrMFQug6t+r7i48KdKgz74Mtx9EQx0mDquaKQijFZHJN9mSPkP/3CxEgLli+Fjv4N/fBUu/rnyKx5+De6+UGkJKYLRoaMwDQQBMDyp7IXvAxJO/UeoPq4wKqz7Csw9R/kQnvl6SsaXKrs4RKIi2o/thftvgMAQrLoBPv0cLLkMalbBGV+EW1+F4jlKcD58M4RSU34glVzoN9j2hgNw//XgH1Cmj8+8CEs/qrg47Qtw6+tQugBadqhdcjBg+thgkrhoOgx/uRZ8fYqDz7wIyz6muFh7K3zuDXVDbPsAHrgBAqnp/pcq8ylEtI6Olnr4y3VqI7ToErjlJVh+lbpvnPJZuPUNqFwOHfvh/o+DPzUOZlsjSBA6Yb1HtsCBv4M7T93wR4MQcOl/QkYO7PgrHHrN9PHpEr4mBbudqoIs3PiZ8cKt4O2BEy6Gy/4bnCOiD4pnwycfhZxS2P8CvPW/po8NopLJUsFFYRYuAsx56QtK8M8/H674NbhGhK0WzYB/eARyK5QW9cYvTR8bQFOvnlhn/s2vqjALByHmv/JFGGyHOR+CK++CjBHfXVCjuMivgaNvwqv/n+ljg6iAihRwUV2YhSDEwte/BP3NMPN0Zf7JGDEn8yvhH/4GhTOg/l14+d9NHxuYs0EwTRAIIWYIIV4SQuwSQuwUQvzzKOecLYToEUJs0f6+a8ZYdNt72c571AurPj6+fbN4Npz5ZXX84g+U/8AkpCqZTEdNUTafcW6gqHuXcnhd8euxnV3Fs+GKO9Tx3/8N2vaYPr5UlFTQUVOUzU3OZynp2gYFdcof4hgjNLFohvIRALz8U2U3Nhl6dFdViswhNzifp7zrfcivViYQ5xguxIJquOp3gIDXfqHMJyajMUX+Ev07rnW+THXnRmX+uer3x28OdORVKCEhHPDmf8OxjaaPT+fCyMx7MzWCAPAVKeUSYC2qcf2SUc57TUq5Svv7oRkDqSnMIhsPs5ueUi+s+ezEH1r7OTUJ6t9VDjKT0OsJMOgLkuN2UpBlvu9+obuDL7oeUU8u+xVkF03wgQ/DiTdA0AtP/6upQnHIF6R70E+GU1Caa14ymY55mT38i+th9eTS/5zY+Tn3bFj9aQj5TefCH1TFAYXJyWQ65mT381XXg+rJR34xsfNz1ulqjcggbPiqqVwMSyZLgWloVtYg33Ddp55c9DMl+MbDjDVw+hdBhmDDVyBkXkVbKaW1NAIpZZOU8n3tuA/YDdSa9X3jobowm/WO93GHhqB2NZQvnPhDmVHmo9f+w7SJHp1DYGYymY6z6u8gS/h5N+9cdWOLBef/CLIKlZNw/wumjS06bt7MZDIdZxz9DbnCy6acdbDg/Ng+dN53lcP0yBvwwQbTxtba50VKJQQyTEwm07H2yJ0UiCE2Z52qzIWx4JxvKXNZwybY+TfTxtYx4MMflBTnZJDtNi+ZTMeao7+jSAyw1X2S8pPEgg99XZnLmrfB9gdNG5u+cTS6CkFKfARCiNnAicA7o7x9mhBiqxDiaSHE0nGucYsQYpMQYlNbW3zRPNVFWVzmfEs9WX5V7B886ZMqYqRhExwbbejJI5UqL627qa1/Cp90cof7k7F/LqcEzvqaOn7+e6bteMJFxQpSwEXHAWqPPkpAOvg/VxxcZBfB2d9Uxy983zQneirNQnQdoebQwwSl4L8cn4w9RyAzH869XR2/8APTnOgRc2EKuOhtpGr//QD8RzxcuHPUJgHgxR+Z5kRvMqkKgemCQAiRB/wV+JKUsnfE2+8Ds6SUK4H/Bh4d6zpSyjullKullKvLy+OL2a3NkZzl2KaexCrhAdy5sOYz6vjN/47rO2NFKiNDeOWnCCT3B89le19+fJ895Ra142ndCfueNWV4qfSV8MrPEDLEw8GzeL+/KL7Prv4UFM2Ejn0q38IEhCNDUmAK4bWfI0IBHgudwcb+svgaF626AUrnQ/cR07SCVCWTAfDaf+AIenkyeCpv9lUSCsXBxYprVURVbz1se8CU4ZnFhamCQAiRgRIC90opj5slUspeKWW/dvwUkCGEKDN6HNXd75Ep/GwPzSGYWxnfh0+5BZxuZQboPGj00KKiZEye5G17YOcjSKebO4KX0dbvxReIY2fvyoTTb1PHJpnKdNOQ6ZEhHQdg+4NIh4vfyCvpHvQz5ItjZ+/MUDZhgNdN4iJVUTLdR2HLX5DCyW/FVQz6gvQOxbGzd7rgDC0O5PVfmqItpqoEC71N8P49gOBu17X4g5L2gTiaODkccOa/qOM3/tMUbbHZpDBaM6OGBPA7YLeU8j/GOKdKOw8hxCnaeAzPUnEfehGAl0IraeuLsztXfqWKo0aqdHuDkTITwNu/BkCs+gTB/BqkJOyAixkn3agya+s3Khu5wWgMm4ZMXvAb7wQZQqy4jkChSiiMu9rkiTeoYIKmrSok2WBETIZmc/FbCAUQy67EVzhn2HfHjBXXadriLlO0xZRx8e5dEPTB4ksZLFJ+xLiLzy37mKYt7jdFWwybTw2uQmCmRnAG8A/AuVHhoRcLIW4VQtyqnXMVsEMIsRX4FXCdNKOhrubgfDm4KrHysifdqB433wtBY1tehnfBZk7ywU7YquyerP1c4rX4M/PgVO2n0wSLkYiYyUwUip4eVTMGhnMR74LPyIa1n1fHVuXCN6DtgIG1n4tKvIxzjbjcEW3x7f8zcIAKKeHC71H1tgDWfj7x4nNOV0RbNGFeWM40JKV8XUoppJQrosJDn5JS3iGlvEM753+klEullCullGullG8aPpCOA9B5kAFHPlvk/MTKy85cC2UnwEAr7H3G0OE1pcIE8P49KoN43nlQfkJy3blO/hQ4XKoQWU/DxOfHgUhnMhO52Hwv+Pph9jqoWpZctcmTbgRnptpoRNfkMQApMRluvU8JxrpToPbk5LpznXiDSsI89Cq07zN0mCnhYvtDqthk9UqYuTaqOm0CXKy8Htz5cOxtVczSQJhVkTb9M4s1E8aRgpMJ4UhswQsBJ2tawXt/MGxoUkrzI2VCQXj3d+pYq6iaVHeu/EqVbi+DhpvKTE8mkxLe1ZLCNM0mqe5cuaWw9ApAGjov1HhSwMVGjYu1GhfJ1OLPKtRMqMCmu40YYRgpSTLc+Bv1eOrnQIjk1khmHqy8Vh1v+r1BA1QIm09tQRAnjqqwz+6yk4Ekmm+suE45jfe/CN3HDBlanzfAgC9IdoaTgmyTkskOvQI9x1QW8bzzAAO6c635tHp8/x7DQgY9/iBdWjJZWa5JCVRH3lQO//yacGXZpOvPr9a5+JNhIYP+YIjWPpVMVmmWv6ThPVUvKLccFl8GGNCdS58XW+5Vpd4NQCgkaelRfj3TQqybtkLzdhUqrkUVhrlIdI3o82LrA+DtN2CQw6sQGM3FNBAEKn/AX3sqAM29Cf6wuaWw6COAVGqkAYiODDEtmUy3h594Q7iUhG4LTrg71+x1qghbX5OqUGoAdC4qC0xMJtO5WHV9uJRE0n2cZ5yiKnQOtsPux40YJW1aMll5nonJZJv/pB5XXBuuM5V0v96aE1UVW0837HzEgEFC56APXzBEkZnJZPq8WHFNuLZS0j2tK5fAzNNU8T6D7hd9XvOqEKS3IOhvVeVjM3LJmXUikGSD7uVa5zKDfliz1LwwBjth95OAUHZLDVXJ7oKFgNU3q2N9ESUJ0yNDPL2w61F1vOoT4ZeN4eJT6tggLprM5sI3CNv/qo5PvCH8siGdygyeF7pQMq20hN8D27RM4NG4SKabn1lcmFCFIL0FwdG31WPdaqqK8oAke5HOX6/CJ1t3GVJ0LBITbJLKu+OvqkbQ3LMjfReIVPZsTkooXq2cxvueN6Rvg+mRITsfAf8gzDoDSueFX65JxkegY9nHlNnw4MvQ25jkQFOQWLf7cbVTrV0NFYvDL4/szpUQll4Brmzlm+s6kvRQTReKe55SGkzV8mFl6cO9Kvq8BONJKovGokuU07hhkyEOdDOrFKe3INDLQsxcS2VBFkJAa5+HQDDBpBeXG5ZcoY4NqCdiesZktFkoCuX5mTgdgvZ+H95AgkkveeVKMMqgEjhJYrK4CHfn8gTo9ybo78guVm09DTIbNptkBw5jDC7yMl3kZ6omTt2DCYZJZ+bD4kvU8bbk10gkSsZsLv5h2MtZGU5Kc90EQ5L2/jhzj3S4c1RbTzAk09jMKgTpLQj08ri1q3G7HJTlZRKSqqBXwtAb22//a9JZlE1mtt9r2QlNW1Q0x6JLhr3ldAgqtYqWrb3JcKFFRmy9L/FraDB159e+TyXBufMiC1ODECL8nUlpSCuvU49b708609jUzmRdh1VXLVe26tU9AkmFTepYoXNxn2FcmBI62tOgkgGdbqXhjoAhXOjRQ9seSPp+YWb3vvQVBKEQNGn1hWpWASQXJ61jxlrViKK3XjXmSAKm7oK3a+WVl155fHMRIruKhKMiQEXeZBYqgZNkrwJTywjoXCy5XNWPGoGk/QSgmtpkl2hmw+2JX4dIQIMppiFde1v0EbVJGIGqsJM0CS7mnq2qknYeUNFJSaDZzNDRnY8AEhZeMGoJct1km5SfYNaZqtdF91GVV5AEzOxhnb6CoPOAsoPm16jmEWDMzs/hiFQw1W8wCcI0H4GUkQU/RrVVfTI1x1tmIhoZ2bBU22HrmcsJosksH0E0F3qc+wgkHSECymyoXz9JM4Cp/Xl3aCW/xpoXBQZslpyuyA7boHlhDhf6vBhrjRjAhcMBK3QuktOczdw4pq8gaNyiHjVtAKIXfJIxzks1lXr3E0nF0ZuWSdvwnqoGmV+tQthGgSGTHCJmgG0PJqX6mpY92rxNVQnNKVPtF0eBIRsEiJiHtj2YVMGxJrNMQ60fqL7LWYUw79xRT9HNIclzoZlEdjycVFkW0zLvOw5A4/vKXLjwglFPCXORzGYJImtk52MQSNwUa2YQQfoKgqYt6rF6Vfglw25+VcuhZK6KHU+w+Fqfx0+/N0BWhoPC7IyJPxAPos1CY7RerDIiPA6UoCmoU6ay+ncTuoTHH6RzwIfLISjNMziZTN/1Lb1izNaLhoRNAtSeDMVzVCmSBOdFIBiitS+SU2EodC4WX6aqyY4CnYuEk8p0VK1QZVmGuuDgKwldYlg3LqO50EtmL/rI8b2INVQbYT4FqFik7hneHpWQmiCaw5sl2zQUO0bRCAyxBYOKHdejh/TY9DgRHRliaExwKBhJ5hnDFAIGhU2CUn2XXqGOE0wi0qugVhZk4TQymUzKiClkHC4MMQ2Bmhd6v4sEuWjr9xKSUJaXidtl4PKMwUQGUSbDKcBF54BKJivIcpFrYDcuIKZ5oZtsk+YCkuZC3ziaVYUgPQWBlNCiOeyiYoMNW/AQufntfiIhM4BpEQBH3oT+ZlVSovakMU/ThWLSai9ETGW7Hk3IPGRalEz9u6q8RkGtcvKPgSqjTEMQicTZ9XhCZsNwlIzRppCmrcpvlluuMsPHgGFmMojc/D54IqHyGxHTqcE74JZdyqmfVQRzzxnztBojooZ06FzseSqh8hvR/gEzqhCkpyDob1VVFbOKIC/SiCaSLWjAD1u1QjMDtCVkBjAtGmKHZhZa9rFx2+xF1F4DuKg9SdVg72tKKDLCtCiZsInso+HyGqPBMBMAqHITpfOV2fDwa3F/3DRTyI4oLsYwkUFUNFnPUOJJZToqFkHFErUWD74U98dNs4nrmtGSy5WTfwyEk8p6PYknlekomavM1L5+lYQZJ8xOMkxPQdCuhTKWLRx2MzQkqUyHEFEmkUfj/rgpEQBBP+x6TB1P0Ju5Ij9LSyqLs1PZaIg2A+gqdxwwhYsYTWQAJblu3C4HvZ4AA4kmlekQIqIhJdC60ZR8ilAIdsTGRX5WBvmZLjz+ED1DBvTe0LlIYF40m8FFjCYyUEllJbluAiFJR6JJZdHQtcUEzENmho5C2gqCveqxfOGwl6OTytqM+GH1m18C5qFIZIiBP+yBl5RzrlzbiY0Dp0NQoSWVxd2pbDToXOx6bGpwcfh15bQtmauKoY2DYUllRnKx+4m4I2YiUTIGclG/UTnzC2eo3gMToMqooAoYYRKJ73qNZoSONm6GrkPKUjD7zAlPNyzABCJc7H1GNQWKA6YmGZKa5vUXCiH2CCH2CyG+Mcr7mUKIB7T33xFCzE76S9s0QVC28Li3DDWJhM1Drco2HweazOhMtjPKARaDHdHQBV+9KuGIGVM0guhdXyxc6PHzRsyLyiVKGCcQMWNKYl04cmp8E5kOw4IqAMrmaxEzvXAgvogZU0oqDONi4mqmhkWUgTKf1q5WNa/2PRfXR80sLwHmN693Av8LXAQsAa4XQozcqn4a6JJSzgd+Cfw06S9un1gQGOIMizYPxRk9ZLiPwO+BDzaoY10dnwA1RuVVQFJRIob7CIL+SEnoWLlItE3jWEiQi3ATFqN8BKFgxFw4SkmJ0VBjZFAFRJnKEuPCMKEYCkXMuDHOC0M3SxD5DeI0lekbR7O695mtEZwC7JdSHpRS+oD7gctHnHM5oDVO5WHgPJGsW1yv9DeqIDB4wYfDSB+PyyTSZHRM8IEX1a6rarnahcUAQ6NlIOGImWajo0MOvRIxkVWObyLTYTgXCUbMGM7FkTehv0Vpa1E5NePBNC72PB1XxIzhxfcaNikTWUEd1K2J6SOGhdPq0Gtd7XsOvH0xfyy8cTSpUrHZgqAWiG7nVa+9Nuo5UsoA0AOUjryQEOIWIcQmIcSmtrZxyh57+9WP7XSrEMoRMFzCV6+E4tnKJKI1wZkI/d4AfZ4AmS4HRTkGJZPpu60YdzpgsP0TEoqY8QaCtPf7cDoEZUYlk+mOUf0GFAMiiVQGcVF+AlQsjStiJhiStGgFESsKDOJCNxcu/WhMJjIw2HwKUDJH+WniiJiJ7sZlmKao78KXXhGTiQxMmBeFdSqUOeCBvc/G/DHTss01WMZZLKW8U0q5Wkq5ury8fOwTOzRtoHT+qGFyhpqGYHhyWYyqb3Q0hCExwf4htduCOG9+BmtHCUTM6G0IK7XS2Ekj4FO7cEiIi2ajuABYFl8kVZtW+74sz02my4BuXMGA0s4gZrMQRBzVCXfzGw1hU1lsXHQN+vEGQuRnucgzIpksFIqYb+PYLEW0IxO4iHFe9Hn89GlVCAzbOI6A2YKgAZgR9bxOe23Uc4QQLqAQ6Ej4G8OO4gWjvh1uTWjoD3uFeozRPGR4Ia19z6vdVs2JavcVIww3AcDwiJkYTCKRUtwGcXHwJbULr1iqduUxwnDtCCI3nA82xBQx02R0iODh15R2VjpfaWsxwhwu9IiZZ2OKmDG8Ccuxt1WeS9HMcRMtR8Jwfwlo5iEB+59Xc3UCtPRG7hdmtbQ1WxC8CywQQswRQriB64CRjV0fB27Ujq8C/i6TyWQJO4pHvwkYrhFA3BEzhqt50ep/HDBc7QUtYmaxFjHz8oSnm6b+L4uPC8NNhqA6oVWvVFVw909sEjGci/C8uDJms1D09zd1J9GpbCSKZqrQVf9gRHsdB9FtGQ3BjvhNZNHf39LrIZRsUpmOgmoVuhr0RQI8xkGj2e06MVkQaDb/24Bngd3Ag1LKnUKIHwohLtNO+x1QKoTYD3wZOC7ENC5EJ5ONAj2prKXXgKQyHUJEklNi6NZl6IL3DURsjXEKgor8TBwCY5LKopEAF9VGTHK/R8WrQ1zqP0Bprhu300HPkJ9BX5JJZdFIhAsj5kXQr7QyiHteFGRlkJfpYsgfpHfIDC4mNokYGl4dHTkVJxdZGU6KczLwByXtAwbkHukIRw9NPC/CTnOTIoYgBT4CKeVTUsqFUsp5Usofa699V0r5uHbskVJeLaWcL6U8RUp5MKkv1COGykcXBIYnlenQJ/muxyZMItJtr4aYQ/Y+q3ZZdWvUrisOuJwOKvKzkJJwxUtDoE/yD56cMEqk2UjTUDhyasWwvsSxQAhhkqlM42LPMyqQYRwYmj16MP7IqWiEtQJD/QRXgHAo7Wioe9xTDeXiyBtKW48jcioahkcOASy+XPX8PvASDLSPe6rpbVyxkLM4JgQDqs44KLvoGDA8KgJGJBG9PO6p4SxBI3bBCZqFdJhmEglHiYyfOGNo8b2d8UcLRcMULopmaFEiQxOaRKYSF4bW5dKRXxVlEnly3FMNNZ9Gc5GAjd2U+0VuqSp4J6O0lTEQzi0xq28z6SYIug5DyK9S6UdpSahDt7UZKuEhZjOAYVmC3r5IOJ4euRQnDK2wGI1Uc5Fg5FQ0aswQBJB6LhKMnIqGKQ5jiJkLw8ynCUZORcOUyCGI2VRmWtOmKKSXIBgnozgahmeR6ogxSiQcEZGsOWTPMyoeeeZpUDgyPSM2RGqum8TF3mfB0zvmaYYl1iUYORWNKjNCSCHKJPICDHaOeZphjUcSjJyKhmlcLL5MmUQOvgL9Y+cDNRuVSZtg5FQ0wvcLI+pQRWPRR8CZqUxXvY1jnmZ2eQlIO0EwvqNYhykmAFAZvdUrlZ16/wujnjLgDdDrCeB2OShONiY4urRwgjBF7QUlmGaergTVGCYRlUzmxekQlOcnmUC1/SH1GKeTOBqmRFGB6pk95yylrY5hEgmGZPjml3Qymc5FnJFT0TCNi5wSmHeeZhJ5dNRTpJThkuBJm0Oiu/UlGHppaB2qaGQVwMIPA3LcHKRGkyuPQtoJgvEdxTpMCSHVMYHqa1iDif42JWyEM7mbn1E9akfDBJERrb1aFm2yyWRDXaqiI2LC0sLjYTLnRXu/SiYrzXWTlZFEMpm3D3ZrwkZvIJ8AUsPF6CaRbj2ZLDPJZDLfYMT+vuKahC8zmfMiugpBUhvHCcKA00sQtMWmEZiSVKZjglKzhlWX3PFXCAVg/nrIGyfTegKEbcFGq72g/BbCqaJ5RjGJGBYNsfNR5YCc+6GETWRqHCYkD+lYfCk4MuDQq9DXctzbhjVp3/2EckzPPF2VPkkQhmedR2PRxeDKgqNvQk/9cW8bxsWep1QOR+3JYyaYxoLqsGnIBC4WXADuPGh4DzqPD5hsNmrjuO95+PXYZbfTRxBIGVVsbny7qKkSPjpxZvfxZgDD1Lxt96vHldcmdRld9U66if1oyCtXN+dQYNQdj2GZtFs1LlZcl9RlDC2/PBLZxUpoy1DEpBcFnf+ki4ptvU89Jj0vIuZTw5LKdGTmw8IL1PG2B49727AoGaPmRVRwiWFJZTrcOXDCxep4XC6SFIpb/xJp3zsK0kcQ9LeAV2tPmVs27ql6C7rWPq9xSWXRWHW9etzy5+PeMsTx07ZHNdjILIhMogShJ5W19Xvxm8LFJ9TjlnuPe8uQyJDOQ6p8QEaO2nUnAT2prHvQz5Av/j7UE2LVx9Xj5nuPU9UN0Y56GuDQa8oBmWAUmY6CLBe5bieDviC9HgOTynREz4uxuEgmvLq/FQ78XTmmkzAXAmS7nRRpSWUdA/H3Xp4Q+rzYcu9xPb8NKUcz1KVlMI+tUaSPIAh3JTthQqeQnlQWDEljk8p0LPuYUn0PvapCWqNgSCiYvtNZcjlkJLdrynA6KM/P1JLKTOBi0Ucgq1AJruYdw94yxEym76IWXQKZeYlfB3A4BJWFylFrSKeykVh4IeSUQutOxUcU9O9Lyhyy/UFAwgkXQnZR4tfBxAQ7HfPOg7wq6NgPx94Z9pYhmbTbH1YO6fnnq5j9JGFayDnAnA+pkPfuo8dV7TVkjez4W8R0OgbSRxCE/QOx2QJNi58HdePT645v+cuwt5JWe0PByM1vZXIqrw5TzUMZ2RGn5QitQI8MSXi3EwpFmUKM4aK6wEQuXO6ImWLzcG0xwkWCC15K2KJzcX2iIxwGU31pTldEc978p2FvNSbbkEZKZQoBw+aFHkJqChcOR0RDGjEvDGnOo9+DVn587CEkfvUphnGa0YwG00LCdJx4g3rcfO+wiqRJZ0zue171WyierRyCBsC0RCodOhdb7x9WkTRpp+ChV1T/2YJamHt2koNk2FhM52L7w8PKbyRtAjj6lgqfzq1QvggDYKovDWCVxsWOR4aV30i6h3XD+9C8HbJLlBZmAEzVjiBiHtr9+LDyG43JctG0TTXkySyExZeMeVoaCYLxq46OhGlJZTpmnaka4/TWqxuWhqR3O5t+rx5P/lTMzTUmgumTvHqVSm4a6oS9kZyCpHc7m36nHk++Kab+s7EgzIUZpiFQpUhqTlT+rKhggqZkNYJ3NS5O+iQ4jalZb1p2sY6y+ar8hn9gWE6BYfPixE9AhjFJWLq/wjQuimepXJOAZ1hgRdLOYv1+sfK6castpKEgiM00ZPrNL1rde+8PwPCY4JJcd/zX7D6qavc43ZGdpQGIJA+ZJBSFiIxXm5jRnckq8hOY5L1N8MFTKjz1xH8wbKj6gm80wzSkYwQX0Z3JElrw/W1avLyAk2+c8PRYYarJUMcILqI7kyVUiHCoK3IjPflTRoxw2FhM2zhCZB5vujvsQNe1o4SqEHj7IsmFq28e99T0EATePuhtUDfIGGOnTd/tgNqdOVwqtrv7aPKdyd77AyCV/2GCyKh4YEp1xZFYdb2K7Dn4MrTuTr4z2ft/VM7ARR9R9d0NQrg7l5lcLL8G3Pkqjr5pa/Kdybb8WWUtL7wg7gq04yGcbGiWdgQqsCKrSMXRH3s3+c5kW+5Tu+q558RdgXY8pOR+sfgyyClTYZ5H3gh3Jks4mWzbA6rsyqwzoWLRuKemhyDQ/QOl82M2EZiaMKOjoFpl/coQbPxtcvY+v0fd/ABWf9rAQaZokmcXR5yY79wRMZElstMJ+MJa1kQ7nXiREi6yCuAkbff39h3J5ZYEAxH134pcuHOUaQ/gnV+HNbGE6i2FgvDuXerYYC5MtyCAMmOt0db227+O1J4qSqAzWSgEG3UuJtaM0ksQxOgohhRNcoC1t6rH9++hrUN14EzIObrlXhhog6rlMHOtgQM0OZEqGqdqXGx9gI62JiBBO/C2B6CvUZX9njN2SFwiSBkXp9wCCNjxMB3NKrs2IS52/k2ZDEvmGuYk1hEdQWV4Ulk0TvmsMvHteozOpsPquxNZI7ufgM4DUDgTTrjI0CFGO84NTyqLxupPqwz0PU/R2bBv2HfHhX3PQttuyK9RmsYEMEUQCCH+PyHEB0KIbUKIR4QQRWOcd1gIsV0IsUUIsSnhL4yx2Fw0TE8q01F7Msw4FTw9lO1RYVxx73aCAXjjv9TxmV9OuHjWWNC7trX2mZRUpqN8obpZBYao2Hk3kIDtMxSEN/5THZ/5L4Y5zHWU5WaS4RR0Dfrx+E1IKtNRMkclAwZ9VOxUO7f4uQjB679Ux2d8yTCHuY6CbBc5bicDviB9XhOSynQU1sGSyyAUoGzbb4AEtCMp4fX/UMdnfNEwh7mOHLeLwuwMfMEQnYMmJJXpyK9U5jIZomTLr4EEuXhN4+L021TY8gQwSyN4HlgmpVwB7AW+Oc6550gpV0kpVyf8bdHJZDHC9KSyaJz1NQBOPnYPOXji3+3sfAS6j0DJvEh+goHIcDooz1NJZW1mJJVFY91XAVhe/xeK6It/t7P7CZWEVDgz6YzR0eBwiPAmwVQzAMBZXwFg8bH7KaMnfi72PQutuyC/2rB4+WiYnlQWjXWKi4XHHqKSzvgTLg/8HZq2Qm65oYEU0TA9nFbHui8DgrnH/kadaIu/FPeRN6B+ozLHnhRb8IApgkBK+ZzWrxjgbaDOjO8Joy2+iCEdpiaVRWP+eqhbQ16wm086n4tvwQd88PK/q+Mzv2T4rk9HdapMIrNOg3nnkhUa5LOuDfFxEQzASxoXJuz6dJgeRaWj9mRYeBHukId/dD0RX8RQKAh//zd1fNpt4EqydPUYiJQpN5mLquWw5HJc0sfnXY/FyUUowsXazyWdbT8WUsZF+Qmw/GqcMsAXnI/Gx4WU8OIP1fEp/xhztn0qfAQ3A2P16JPAc0KI94QQt4x3ESHELUKITUKITW1tUQ0tgv5I1b5x2lOOBlPTxqMhBJzzLQBudT1BnXsw9s9u+r36/8oWGpYxOhpMrbw5EmcrLj7lfJaZzq7YP7f5j8oMWDxbRWSZhJREUek4+xsA/IPzeWY7x+9dOwxb74eWHao0wRpjgweikVIuPvQNQgiud/6duY7m2D+382/Q+L4qWaH7oUxAuFmPmVFUOj70dUI4uNr5CvM5vkLrmNj9uCrZkVMGp30h5o8lLAiEEC8IIXaM8nd51Dm3AwHg+IpjCmdKKU8CLgK+IIQ4a6zvk1LeKaVcLaVcXV4eVXa564jWnnLmuAkToyFlEh6Qc87mTbmcIjHA7M0/i+1DfS3w8v9Tx+f/0LQdMKQoKkLHjDW8wKnkCC9z3/9xbJ8ZaIe/a+eu/4FpO2BIYSABQM0qnnGsI0v4WfjeDyesGw+okt4v/kAdn/dd03bAkGIuKpfwtPMc3CLI4vd/EBsXnh54/rvq+Nxvx30PiAcp5aJsPk9mfBiXCLF8S4xcePvhuW+r43O+qaLTYkTCgkBKuV5KuWyUv8cAhBA3AZcAn5BjhBxIKRu0x1bgEeCUuAcSdhTHX288JTHjGnq9QW733YRPunBv/wvsf3H8D0gJT/wzeLpVgS6DUuXHgmmdykbBkC/Idzw3MCAzydr3pOonMB6khA1fVi0HZ68zxU8SjZRFDgH+YIjvDF1Pr8wm+/ALkY5a4+Hpr6tquzPWwrKrTB1fKrkIhSQ/9FxLt8wlp/61USvWHodnv6VyiGpPjpRpMAlhQZCKjaOU/NhzNe2ygJymdyIhwuPh+e+qCLKq5XDSTXF9n1lRQxcC/wpcJqUc1Q4ihMgVQuTrx8CHgR2jnTsuEnAU60ilhG/qGeKQrObPmVqd+L99VpUNHgsb71TlGDIL4bL/NjxSaCTCQtGM5hsj0NQzRBOl3OnWzDuP/xN0HBj7A+/drTJn3Xlw+f+az0UKzSEtvR7aZBH/49Kcek/8c6SA4mjYfK+qMurKhiv+z/CoqZGoSaHJsH3AS0swn184tLj3DV89rmLtMGx/WBVpc2bCFb82zX+mI5Xm096hAC3+bH4ib1IvPPMNaNwy9gd2PaZKazgy4Io7VFG/OGDWLPofIB94XgsNvQNACFEjhHhKO6cSeF0IsRXYCGyQUj4T9zcl6CiGFCWVadBTxV+uuEFlPQ52wJ8/NnoD7+0Pqx8e4NJfJtV1K1akViiq73ir9EoV4+zthT9fCd3Hjj9512PwlIq64uKfq5osJmMyuNhYfKna3fsH4M9XHVe+HFAlNZ74Z3V80U8MzZwdC6k0Gepr5L2iC1V5lsAQ3Hv16JuEfc/Do59Xxx/+t4Q2gvHC9DpUUdADFbYUrVelMoI++Ms1kftdNA78Hf72j+p4/fegalnc32dW1NB8KeUMLSx0lZTyVu31RinlxdrxQSnlSu1vqZQyRmPxCMRZbC4aKQsHI/LDVhXlwsd+p5Kh2nbDb85S4aH+IdW27+lvwF8/o7KRz/6WKSGSo8H0aqxRCGePFmWrHX71KnXju/NsVSLA06uEwrO3w4M3qg5n674SKVtsMlIpCMJcFGfDpf8FdWug56ji4v0/KRt4T71S+x/4hPKHnXZbJBvXZKRaawYtmu/in8PM01Ti4G/PUZnkQ93Q2wgv/gjuuw6CXpWYd8pnTR8bDOfC1AQ7RhTeu/AnyiTa3wJ3naeyp4e6VL2tl/4d7r1GCc2TblRzIwEk0Rl6CkDKKEEQezKZDj1evEWr9ZJUA/UJEGkwka0aZdz4BDxwg/LwP3TT8JOFU0n2M/7ZtPGMRCSpzEMgGMLlNM/kEGk8kq0cWp98VHFw8GV4dETUh3DAOd8Ox5mnAmV5mbgcgs4BHx5/MLlm8hNg2LzIzIMb/goPfxr2Pw+P36b+whDwoW+EI41SgcLsDLIznFrBRD/5WeYFLAwrxe3OgU88BH/9rDKRPvHPEW1Ix5lfVs5yk02FOnIzXRRkuej1BOgc8FGaZ17Agu6rqynMVqUnPv4APPKPKo9mw1fUXzRO/ydY/8OEubB2iYneRmVWyC5JqAjbsKQykxOpGkf2IcirgJueUjufymXq5p9ZoEwln30xpUIAIlyEJKYn2DWO7LqUXQw3PKK0g5qTVPHArELVevIzL8BZX03ZYofhSWUtJpsBjmtRmVUIH39Q2XlrVyv7d2ah6sD26edUNEgKuRBCpExzPq51aWY+XH8fXHmX6gPuylJcLLwIPvWM2iylkAtInZ/guPLT7ly45k9w1d0qSMCVpe4XCy6AmzYo81gS/iJrawRtu9VjxeKEJ0R1YRbt/V4ae4aSbxA9DppGK7LmdCm19pTPqqQYkx1/E6G6MIu2Pi+N3Z7kG8qPg1Gb1jscKiP0xBuUppfiBT4S1YVZNHQP0djtYVapeSGJo3ZpcziUGWzV9VOCi6rCLA62D9DY42FBZb5p3xMxGUatQyFgxdXqbwpwUV2UxZ6WPpp6PCyrLTTteyLlp0dwsexK9WcwF9bWCFo/UI8VixO+RKp3O2Omzk+yEIAUcjFRl7ZJXuyQuiiqCbu0TQUuwlFUKeJirE3IlOBCXyPmcjFhRVqDuZj8u08yaNU0gvJFCV8iFUllUsrIzi+RssspQqqiqBp7opzFUxSpcpKGHaQmamDJImVcJFOCOkWoKkiVaWgUjcBEWFsQRJuGEkQqksqSbraRIlSlYMFHd2lLqNlGipCKKCq9S5vLISjPN8/xmCzC88JELqK7tFUWTl0uTO9pzYgubSkSitYVBFJGEm/KkzcNNZnoFLTCrg9SYxpqjtIGEurSliKkoiBhuEtbQZapEWvJIsyFiWsk0qUtM7EubSlCKoozdg748AVCFGS5yE3RxtG6gqDnmGrDlluuwjETRNgcYqJpKGwTT5GalyhSYRo6LnpqiiJSYMxELpJt0p4i6OYQM+3ijT2jOIqnIFKxWYqYhVK3cbSuIGjZpR6T8A9Aan7YpFoRphCpsAWPGiUzBVGTAnOIFfxGEKURpIKLqS4Uo8JHzUoqa5gELqwrCBo3q8eaVUldpqJA2SP1pDIz0NClfti64qm94FPRtU2f5LVTnItSLamsQ0sqMwP6vKid4oKgMDuDrAwHfVpSmRmIcJFjyvWNQl6mi/wsF95AiK5Bk7lI4RqxsCB4Xz3WnJTUZTJdTtOTyuotIgiiE+za+81px2cVLpxRSWWtvdN7XqikMjVGsxLsrMIFmO8niHCROqFoYUGgawQnJn0p839YVYDVCpO8VjMDNHTH0TwnDliJC90kUm8WF90W5KLLXiO67b7BJC4aJmFeWFMQBH0w0KZKSxTPTvpyZtvGw+aQKa72QmQXYtaCD5vJLMSFaQveQrtg/fdqMCmowiomQ4j8XmZxUT8JJkNrCgLfgHqsOdGQDDszk8qGfCpWPMMpqJjCseI69EluhiDwB0M093pwCEwt52EUzOQiFJLhCCprbBDM40JKOSnmkERh+map2zYNxQZvn3qcs86Qy4VVPRMEQUNUyWXHFI4V1xFZ8MabQ5p7PISkckq7XVN/6ulcHDOBi7Z+L75giNJcN9nuqRs3r6OuROOi03guugf9DPqC5Ge6KMyeukmGOsLzwgQu+jx+ugf9ZLoclOW5Db/+WDBtNQohvi+EaNAa02wRQlw8xnkXCiH2CCH2CyFiq6+rC4K55xgy1hklSvIe6zReEFjJ9gnm7naO2VyEYc+LCOonIUomGZjJRbSJLJUJl2anrf1SSvnzsd4UQjiB/wXOB+qBd4UQj0spd4171aAP8mdD1QpDBjkj/MMaL+Enw96XDMw0AViVCzN8BNa7+Zk5L6wmFM3TmicrpHiy9fNTgP1atzIfcD8QW2fyE28wrGJn9CQ3OklkMux9yaA26uYXMjivosFCdmBQSW9CqGgyv8F5FVayiQNU5GeR4RS093sNz6uw2hopzXWTneGk1xOgZ8jYXILJmhdmC4LbhBDbhBC/F0IUj/J+LRDdqLZee+04CCFuEUJsEkJsksJhaHu6opwM8jJd9HsDdBucJGKl+GiAHLeL0lw3vmDI8AY1VuPC7XJQVZBFSBqfeW41LpwOEfalGa0VWI0LIYRp2mJEKFpIIxBCvCCE2DHK3+XAr4F5wCqgCfhFMt8lpbxTSrlaSrlalC9SHb4MQvQPa7RjsEG7nlXMIQB1JeaYyvT4aKuYQyBiNjR8XnRby0wG5plQrWYyBPPMQ5NlJktKEEgp10spl43y95iUskVKGZRShoDfosxAI9EAzIh6Xqe9Nj5cxodhzigxxwEU3u2UWEPtBfPswVYzh4CZXOgL3ubCmlyYc7+YrNwSM6OGqqOefhTYMcpp7wILhBBzhBBu4DrgcbPGNB7MCAnz+IO09nlVuQIL5BDoMGPBB4Kh4/vzWgBmcCGlnJR6MsnCLEFgcxFBRDtKrVA0M2roZ0KIVYAEDgP/CCCEqAHuklJeLKUMCCFuA54FnMDvpZQ7TRzTmDDDBBB943M5J9svHzv03Y6RQlEv6leRn0lWxtSPm9cR3vkZyEV7vw9vIBT2TVkFdSaskZ4hP33eADlu55RuVDQS4ZBzA7kY8gXpGJic5FPTZqGU8h/GeL0RuDjq+VPAU2aNI1aYkUtQb0H/AJiz29FvpFba9YFJXNjzIoxoLqZyo6KRMIML3Yc2Gcmn1tmmmowZJcY7f6wWK65jhgmOMCs6BCHaFmxzEam9ZK8RM+bFsUmcF7Yg0BDt/DEql+BIh5oks0pyDbleqlAbVWDMqFyCI5pGMKvUOg5BUDWRHAKaez34AsbkEhy1KBcV+ZlaLoGPIZ8xuQRHw2vEWlwU52SQ43bSZ2AuQZiLSZgXtiDQkJfpojgnA28gZFhfgqOdqjje7DJrTfJst5OyPDf+oKTVKC46FBezSq0lFM3IJThiUS4cDhHerRpVpvxIpzW5iA45N0orCG8cJ4ELWxBEwWgH0OF2dZ2ZFtvtQIQL/aaVLA5bdOcHUVx0GsyFxTQCiJ4XRt/8rMeFvq6PGsaFJhQnYY3YgiAKMwyMDZZSRpkArLXbAZitjdmoBa9zMbvMulwcNooL7TqzLTwvjOJiMnfByWKW0VxM4v3CFgRR0EvtGiHhOwZ89HsD5Ge5LBUWp0PfoR02QCPo9fjpHPCRleGwRE+GkZilmfaOtCfPhccfpLnXg8shLJVPoUOfF0Zoiv5giIbuIYSIBGtYCbMN5CIUimwcZ9o+gsmFkbudaJXXSmFxOuaU6VwkP8mPRjnNLclFqYFcaIt9RkmOpXJLdOhr5JABQrGha4hgSFJTmE2myzq5JTpmGciFHoxQlpc5Kbkl1puJJiIyyfuTvpZVHYI6wmpve/JCUb+BTsZOxwgYaQI4rN00rOg3gohpzwiTYXheWJSLOSZwMVm+ElsQRCGyCzZQI7DoJJ8dZRpKNpz2SNgmbk0u9MV5tGOQYJLhtGFfiUW5mFGiSnPXdw0mHU4b8RtZk4vqQlWau7nXk3Q47WSGjoItCIahsiCT7AwnnQM+epIsR23VWHEdRTluinIyGPQFky5HrU/ymRbVjnIzXVTkZ+ILhmjqSS6Q4IjFuch0OakpzCYkkw+bDHNhsTwbHS6nIxxgkmxEWdhRPElc2IIgCkKIsOp7KEl78GGLm4YgMvZkVV+dC6vugsG4KKp04MIok8iRNOBCv18ka0INczFJ2pEtCEZgbviHTU4QTLaqZwTmaGNP1hl2dJJ3O0ZAX6CGcWHheTHLoHkR0Y6sz0WygQQR7cgWBFMC+oI/mMQk7/P46RjwkelyUJlvvRBBHRGNIHEuPP4gTT0qXLKmaHpz4Q+GqO9S4ZJWqr0/ErMN4CI6XNLKWrMRXEgpJz2fwhYEIzCnLA9ITiM42DagXSs35VUEjYQuFJNRe/Vd48xSa4ZL6ohElCXOxdFO5WyuLcq2VCnukYiYTxPnoqF7CG8gREX+5IRLGoUwF0ncL1r7vPR7AxTlZExazpF1V6ZJmFOWvKq3v1WFn86ryDNkTJMFI2LGdS7ml1ucCwPnxXzLzwt9g5AEF23pxkXiQvFA1BqZrDwbWxCMQPjm15Z42OQBbZLPs/jNb66mHR1qH0i4CmmYC4sv+IiDdIBAMLGwyXSZFzNLc3BoIaQef2Jhk/rNz+pc1BZl43Y6aO710O8NJHSNqTAvTNHJhBAPACdoT4uAbinlqlHOOwz0AUEgIKVcbcZ44kFJrpuCLBe9ngDt/T7KEyiJEPlhrWv7BCjMyaA8P5O2Pi8N3UPhgmPx4IBmJrP6gs9xu6gtyqahe4gjnYMJ/T8HWtODi0yXk1mluRxqH+BQ+wCLqwvivkZkXsS+Rvx+P/X19Xg8xlSBNQp3XlaFPyg5sHcPblf8e+v5bh+/vayawmzYvXu3IWPKysqirq6OjIzYTE2mCAIp5bX6sRDiF0DPOKefI6VsN2MciUAIwdzyPLYc6+ZAW39CgiBdTAAACyryaOvzsr+1PyFBkFZcVObR0D3Evpb+hG7m6WIOAfU/HGofYF9rf2KCIDwv8mP+TH19Pfn5+cyePXtKlSrJ6RigZ8hPXXEOJbnuuD9/sK2fXG+A2aW5FGQn7yOQUtLR0UF9fT1z5syJ6TOmmoaE+rWuAe4z83uMxsJKtVD3tfTF/Vl/MBSOANBNK1bGAu2mta81fi5CIclB7eY31+LaEUS42J8AF1JKDramh6YIUVwksEYg2mQYOxcej4fS0tIpJQSAsOPfG0jMTObVMrQzM4y5HQshKC0tjUtzMttHsA5okVLuG+N9CTwnhHhPCHHLeBcSQtwihNgkhNjU1tZm+ECjsbBS7VL2JDDJj3YOEtAiQ7Ld1o0M0TE/fPOLv/5SdGRIQZb1KrCORDJctPV56dMiQxLZNU41LNA2S7qWEw+6Bnx0DPjIdTupKogvpHiqCQGATM0c5PXH7zsKhiT+YAghBG4Do+ri5Slh05AQ4gWgapS3bpdSPqYdX8/42sCZUsoGIUQF8LwQ4gMp5aujnSilvBO4E2D16tXG9E8cAws0QbC3Jf5Jnk6mEIio7vsSuPmlkykEkuRiCkSGGIkFOhcJrJHoAIJ04ELXCDwJaAS6FpHpckwqFwmLICnleinlslH+HgMQQriAK4EHxrlGg/bYCjwCnJLoeIzECWFB0Bd35JBuTkqXm19459fSP+25iNYI4i0+tzfNuJhXnocQKqLMH2cUlb7BsmJI8emnnx4+vueee1iwYAHLlyzi8YfuwxcIEQpJbr/9dmbMmEFe3tj/3x/+8AfKy8s5dfXJXHPBOq5Yfwa7du3i8OHDCCH49re/HT63vb2djIwMbrvtNn784x+zatUqVq1ahdPpDB//6le/Sur/MtM0tB74QEpZP9qbQohcIUS+fgx8GNhh4nhiRmVBJvlZLroH/XEXXNvdpBZ8Ig60qYjSXDfFORn0eQO09E5vLgqzM6gsyMQbCNEQZxe7dOMi2+2krjibQEjGnVW7u6kXsCYXb775JgCdnZ384Ac/4J133mHjxo385j9/Rm93N95AkEsvvZSNGzdOeK1rr72WZ199mweffY2X39jIkiVLAJgzZw4bNmwIn/fQQw+xdOlSAG6//Xa2bNnCli1byM7ODh9/8YtfTOr/MjOl7zpGmIWEEDXAXVLKi4FK4BFNHXIBf5FSPmPieGKGEIITKvPZdKSLvc39VMRRJmJXeJLHHg0xlSGEYEFlPhsPdbK7uZeqOLpq7Wq07oIfCwsr82np9bK7uTeuGjm7LHzzGwsLK/I51jnE7qa+uKJ/jOBi9jc2THxSAjj8k4+M+35eXh79/f08++yznH/++ZSUlACw7uxzeOPlF1g655OsXbs25u/T8zCiM81zcnJYvHgxmzZtYvXq1TzwwANcc801NDY2JvAfxQbTNAIp5U1SyjtGvNaoCQGklAellCu1v6VSyh+bNZZEsCABh/GgL8DhjgFcDpE2JgCApTVqweo39ljgDQQ50NaPEBFTWzpgicbFzji4CARD4Xm0KE02CBCZF/FwEQpJPkiDzVJDQwMzZswIP58xYwatzU0MxZFg98ADD3Dx2adxzQXrWLd2DUNDES3zuuuu4/777+fYsWM4nU5qamoMHf9IWLfIh8nQJ2k8N78PmvuQEuZX5lmy9d5YWFpTCMDOxvHSQYZjX0s/gZBkblluWkRP6dC52BUHF4faB/AFQtQWZadF9JSOJQnMi2Ndgwz4gpTnZ1Kal3j/6ol27qlGhkMQCBGXILjq6mv43Ld+jNMhWFJdMMxZfOGFF/Kd73yHyspKrr322nGuYgzsEhNjYFmtmuQ7GmKf5Fa2fY6HRHZ+NhcRpKNZCIZrirEGEqTLvKitreXYsWPh5y3NjVRUVePxB2PmQg84yMpwHhcx5Ha7Ofnkk/nFL37BVVddZdzAx4AtCMbAkuoCnA7BvtY+Bn2x1RDZnQYq72iYX5GH2+XgSMcgvZ7YOrdFnKPpxcWc0lxy3E6aejx0Dvhi+ozOxZI046KuOJvC7Aw6BnwxBxLsSpN5ccEFF/Dcc8/R1dVFV1cXLzz/POvOWU8wJPHFGEUVDKnzsseoRPuVr3yFn/70p2E/hJmwBcEYyMpwsqAij5CM3OAnws40dI4CZDgdYTv/7hh3wrq5IN24cDhE+H+K1SSSrlwIoUwaEDsXuklticW5KCkp4Tvf+Q5r1qxhzZo1fPe736W6shyAf/3av1JXV8fg4CB1dXV8//vfH/Uaj/7tYa65YB0XnLWWVatWhSOSdCxdupQbb7zR7H8FsH0E42JFXSEfNPexrb6Hk2eNL5V9gVBYEKyoK0rB6FKLZbUFbG/oYWdjL6fOLR333GBIsl0zqa2cUZSC0aUWy2oKeO9IFzsbe1m3oHzcc0MhydZj3QCsmllk/uBSjGW1Bbx1sIOdjb2ct7hy3HOllGzRubDovOjvjyTQ3Xzzzdx8883h5809Q/R54Jvf/zH/9ctfjHudm266iVMvuBJ/MMTCyvxhUUM7dhwfRX/TTTdx0003jTmWZGFrBONguXZD314/8W5nd1MvvkCIeeW5FBpQOGqqQfeZbNYW8njY29LHoC/IzJIcypJwCE5VhLk42jXhuQfbB+j1BKgqyKK6MNvsoaUc8XBR3zVEe7+Pklz3pLVkNBO6iScWU7I/EMIfDOEUIlyiYjIx+SOYwliuTfKt9d0TnqsvhBNnFps5pEnDmtlKI3r3UOeEzrDNR7sB6+76JoLOxabDXTFwoeZF2nNxpGvCbOv3o7hIh9ISI5GjdVob9AUJTTAvBv1KWGS7j3cUTwZsQTAOllQXkJXh4EDbAO0TZBhvtrjKOxHml+dRlJNBc6+H+gmyaiNCsSgFI0s9ZpXmUJ6fSceAL1xXfyzo8yJduagpyqa2KJs+T4A9zePn3OgbhBPTdI1kOB1kupyEpJywYc+gT72f454a1nlbEIwDt8vBSdoO/91DnWOeJ6XknYPq/ZNnpadG4HAIVmt+ko3jcAHwzqH05kIIwSm6hnR4fC42pjkXAKfMiY2LdJ8XALlazsyAd3xBoL+fkzk1cmxsQTABTp2jHKPvjHPzO9g+QHOvh5Jcd1pl0Y7EKXPUAt50ZGwujnUOcrRzkIIsVzj5Kh2xZra2QRjn5tfS62F/az85bmdaBhDoWBODUOzo97K7qVdtrtJYEOjmoYFx2lYGQiGGfAEEglxbI7AG9N3OWwc6xjznzf2qwdrp80pxOCbf3mcW9AX/9sGxF/ybBxQXa+eW4kxnLrR58c7BsX0mOhenzClJqIWhVaBvEN4Zx3/01kG1ftbMLh4WIZNuyM2MOIzH4mLAG0QCOW7nlFkj6Ts7DcJJs4rIdTvZ09JHfdfgqOe8rgmCM+aXpXJoKcfy2kIKszM41D4Q7jw2Eq/vVws+3blYVFVAWZ6bhu6hMftWvL5P42JeenMxrzyPqoIs2vq87GgYPc/kjfBmydpcRJehvvDCCykqKuKSSy4Jv+Z2Orj9i7dw8brVLF22nJtvvhm/f3gSZr83wLtvvc6JC2rDZaRXrVrFCy+8ACjT4w033BA+PxAIUF5eziWXXMLdd98dPt/tdrN8+XJWrVrFN77xjaT+L1sQTIBMl5MPnaBixV/c3Xrc+0O+IK/uVZP8rIXjx5RbHS6ng3PG4cLjD/LyB+r1D6U5F06H4NxFFQC8sLvluPf9wRAvfqBe1+dPukIIwfoliovnR+EiGJI8vys95kV00tfXvvY1/vSnPw17XwjBNdddz2Mvb+SFNzYyNDTEXXfdFX5fSknvkBIMZ5xxZriM9JYtW1i/fj0Aubm57NixI1yE7vnnn6e2thaAT33qU+Hza2pqeOmll9iyZQs/+clPkvq/poaBaopj/eJKntrezHO7mrnx9NnD3ntpTytD/iCrZhRRW5R+ceIjsX5JJY9uaeS5Xc189qy5w957bV87fd4AS6oLmF1m/b68E2H94koe3FTPczub+cI584e99+aBDroH/cyvyAu3Pk1nrF9cyZ/fPspzO5v58vkLh7238VAn7f1eZpbkhOsTJY3vm+R/+v74OUN6GWqA8847j5dffvm4cz562SUcbB+gzxNkzZo11NdHWrIM+oL4gyFcDjGuWejiiy9mw4YNXHXVVdx3331cf/31vPbaa4n9TzHA1ghiwLmLKnA7Hbx5oINjncPNQ09uUzXCP7K8ejKGlnJ8aGE5WRkO3j3cxaH24aGTYS5WTA8u1i0oJy/Txdb6nuNCJ5/cqri4eJrMi9PmlVKYncEHzX3HFWqMnhdTIWbebORkunA5HPQPefjjn/7EhRdeGH6vR9MGcjNdvPbaa8NMQwcOHAifp5eh9ng8bNu2jVNPPdXUMdsaQQwoynFz8fIqHt3SyF82HuXrFy4CoLnHw3M7W3A6BJesnB4LPj8rg8tW1vDgpnruffsI375EdVVq6/Py9PZmhIBLV5hbO32qINvt5IoTa/jz20e5950j/PDyZQB0D/p4Qrv5Xb5qenCR6XLysZPq+P0bh/jz20f4ycdWANDr8fPo5gbAYC4m2LlPJhxCUJybwXe++k+cfOrprFu3DlAmsq5BVagwL9PFunXrePLJJ0e9xooVKzh8+DD33XcfF198sfljTubDQoirhRA7hRAhIcTqEe99UwixXwixRwhxwRifnyOEeEc77wEhhDuZ8ZiJG9bOAuDet4/QpVWd/L+X9xMISS5cWpWW5QPGgs7F/e8eCyfa/eaVA/iCIc5bVBlX5y6rQ+fioU31tPR6ALjz1YN4/CHOWljOPAv25U0Un1g7E4BHNjeEAyt+//ohBnxB1s4tYVGVtQvNxYNf/8dP6Opo54u3/1u4QX3HgJdgSJLjdsUUOXXZZZfx1a9+leuvv97s4SZtGtqBalD/avSLQoglqFaVS4ELgf8TQoz2n/8U+KWUcj7QBXw6yfGYhpNnFXPG/FJ6PQG+9vBWHnj3KH9++wgOAV88b8FkDy+lWFFXxDknlNPvDfCVB7fy8Hv1/OHNwwgBX1o/vbhYVFXABUsrGfIH+fKDW3h0cwN3vXYImH5czCvP49KVNXgDIb784FYe39rI/72szB3/sn7hBJ9OH9x111288Pzz/Ob3f0QIwbHOIboHfbRqpborC2Krv3XzzTfzve99j+XLl5s5XCBJQSCl3C2l3DPKW5cD90spvVLKQ8B+4JToE4QyFp4LPKy9dA9wRTLjMRNCCH50+TLys1y8sLuVr/91OyEJt50znxOq0t8ZOBI/uGwZRTkZvLK3ja8+tJVASHLLWXPDRcimE7576VJKc928sb+DLz2wBV8wxKfOmB3OSp9O+PZHFlORn8nGQ5188b7N+AIhPnHqzAkr1loR69at4+qrr+bFF1+krq6OZ599FoBbb72VlpYWrvrIeVxzwVn8x8/+naOdg4SkpDjHTb7WpW6kj+Dhhx8edv26urqkm9LHChFrN51xLyLEy8BXpZSbtOf/A7wtpfyz9vx3wNNSyoejPlOmnTNfez5DO2fZGN9xC3ALwMyZM08+cuRI0uNOBDsaevjxht209nm4evUMblk3N62TyMbDrsZefvzULpp6PFx5Yi2fP3v+tOVib0sfP3pyFw1dQ1y2qoZ/OnfBlEkWSjX2t/bzbxt2caRjkEtWVPPF8xaQ4Uw+LmX37t0sXrzYgBGmDl5/kKYeD95AiIJsF5UFWThS5DAfjS8hxHtSytUjz53QWSyEeAGoGuWt26WUjyU8yjghpbwTuBNg9erVyUuvBLGstpD7blk7WV8/pbCkpoB7P2NzAbCwMp8/fdrcyA6rYH5FHn/41CkTnzgNkJnhtEQo9YSCQEq5PoHrNgAzop7Xaa9FowMoEkK4pJSBMc6xYcOGDRsmw6w8gseB64QQmUKIOcACYGP0CVLZpF4C9M7MNwIp0zBs2LBhPRhhyp4OiJenZMNHPyqEqAdOAzYIIZ7VBrETeBDYBTwDfEFKGdQ+85QQQg8o/jrwZSHEfqAU+F0y47Fhw0b6Iisri46ODlsYTAApJR0dHWRlZcX8GUOcxanG6tWr5aZNmyZ7GDZs2Egh/H4/9fX1eDyeyR7KlEdWVhZ1dXVkZAxvm5uws9iGDRs2pgIyMjKYM2fOZA8jLWHXGrJhw4aNaQ5bENiwYcPGNIctCGzYsGFjmsOSzmIhRB8wWmmL6YgyoH2yBzFFYHMRgc1FBDYXEcySUh7XHciqzuI9o3m+pyOEEJtsLhRsLiKwuYjA5mJi2KYhGzZs2JjmsAWBDRs2bExzWFUQ3DnZA5hCsLmIwOYiApuLCGwuJoAlncU2bNiwYcM4WFUjsGHDhg0bBsEWBDZs2LAxzTGlBIEQ4kKt2f1+IcQ3Rnk/U2tyv19rej876r1vaq/vEUJckNKBm4BEuRBCnC+EeE8IsV17PDflgzcYycwL7f2ZQoh+IcRXUzZok5DkGlkhhHhLCLFTmx+xl6ecgkhijWQIIe7RONgthPhmygc/1SClnBJ/gBM4AMwF3MBWYMmIcz4P3KEdXwc8oB0v0c7PBOZo13FO9v80SVycCNRox8uAhsn+fyaLi6j3HwYeQrVTnfT/aZLmhQvYBqzUnpdO4zXycVRPdYAc4DAwe7L/p8n8m0oawSnAfinlQSmlD7gfuHzEOZejmtyDWtznCSGE9vr9UkqvlPIQsF+7nlWRMBdSys1Sykbt9Z1AthAiMyWjNgfJzAuEEFcAh1BcWB3JcPFhYJuUciuAlLJDaj1CLIpkuJBArhDCBWQDPqA3NcOemphKgqAWOBb1vF57bdRzpGpv2YPa2cTyWSshGS6i8THgfSml16RxpgIJcyGEyEM1P/pBCsaZCiQzLxYCUgjxrBDifSHEv6ZgvGYiGS4eBgaAJuAo8HMpZafZA57KsGqJCRsTQAixFPgpaic4XfF94JdSyn5NQZjOcAFnAmuAQeBFrUnJi5M7rEnBKUAQqAGKgdeEEC9IKQ9O7rAmD1NJI4il4X34HE2tKwQ6YvyslZAMFwgh6oBHgE9KKQ+YPlpzkQwXpwI/E0IcBr4EfEsIcZvJ4zUTyXBRD7wqpWyXUg4CTwEnmT5i85AMFx8HnpFS+qWUrcAbwLSuRTSVBMG7wAIhxBwhhBvl3Hl8xDmPo5rcg2p6/3epPD6PA9dpUQJzgAXAxhSN2wwkzIUQogjYAHxDSvlGqgZsIhLmQkq5Tko5W0o5G/hP4N+llP+TonGbgWTWyLPAciFEjnZT/BCqp7hVkQwXR4FzAYQQucBa4IOUjHqqYrK91dF/wMXAXlQ0wO3aaz8ELtOOs1DRH/tRN/q5UZ+9XfvcHuCiyf5fJosL4Nso++eWqL+Kyf5/JmteRF3j+1g8aihZLoAbUE7zHcDPJvt/mSwugDzt9Z0oYfi1yf5fJvvPLjFhw4YNG9McU8k0ZMOGDRs2JgG2ILBhw4aNaQ5bENiwYcPGNIctCGzYsGFjmsMWBDZs2LAxzWELAhs2bNiY5rAFgQ0bNmxMc/z/vAj/kN7NSlwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "v1_emt = 'n1.v'\n", "v2_emt = 'n2.v'\n", @@ -150,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -193,14 +237,11 @@ "logger.log_attribute('cs.i_intf', 'i_intf', cs)\n", "logger.log_attribute('c_1.i_intf', 'i_intf', c1)\n", "\n", - "# \n", - "mna_parameters = dpsimpy.SolverParametersMNA()\n", - "\n", "#\n", "sim = dpsimpy.Simulation(name)\n", "sim.set_system(system)\n", "sim.set_simulation_parameters(time_step=0.0001, final_time=0.1)\n", - "sim.set_solver_parameters(dpsimpy.Domain.DP, dpsimpy.Solver.MNA, mna_parameters)" + "sim.set_solver_parameters(dpsimpy.Domain.DP, dpsimpy.Solver.MNA)" ] }, {