From a2e685950eaa214380143dc9d4715f809802461c Mon Sep 17 00:00:00 2001 From: Martin Moraga Date: Thu, 25 May 2023 15:07:42 +0200 Subject: [PATCH] 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": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAD4CAYAAADrRI2NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA5h0lEQVR4nO3deXxU1d348c+ZJXsIYQmQhQQIIHsUFBBQAUEWi2Ddl6JdsFaf/urTRcU+1adVa6u2dW3lUQtuLKKIIqiIqCgiBA1L2BK2sAWykYSsM5nz+2MyQ6ABksydeyfk+3698iKZ3HvOyWHyzblnVVprhBBCtB02qwsghBDCXBL4hRCijZHAL4QQbYwEfiGEaGMk8AshRBvjsCLTTp066bS0NCuyFkKIVmvjxo2FWuvOgaZjSeBPS0sjMzPTiqyFEKLVUkrtNyId6eoRQog2RgK/EEK0MRL4hRCijZHAL4QQbYwEfiGEaGMMmdWjlNoHlAN1gFtrPcyIdIUQQhjPyOmcY7XWhQamJ4QQIggs6erZX2bIVFQhhBAtYFTg18AnSqmNSqlZjV2glJqllMpUSmVWuCoMylYIIURzKSMOYlFKJWmtDymlEoCVwH9prb880/VRPaJ05d7KgPMVQoi2RCm10YgxVENa/FrrQ/X/HgOWAJec9Xo0Hu0xImshhBDNFHDgV0pFK6VifZ8DE4Gt57rP5XEFmrUQQogWMGJWTxdgiVLKl95bWuuPznWTq85FuD3cgOyFEEI0R8CBX2u9BxjS3PtqPbWBZi2EEKIFLFu566qTrh4hhLCCdYFf+viFEMISlgV+6eoRQghrSFePEEK0MZYFfrfHbVXWQgjRpklXjxBCtDHS1SOEEG2MzOoRQog2xrqunjrp6hFCCCtIi18IIdoYGdwVQog2RgZ3hRCijZGuHiGEaGMk8AshRBsjXT1CCNHGSItfCCHaGJnVI4QQbYx09QghRBsjXT1CCNHGyJYNQgjRxhgW+JVSdqXU90qpZU25Xlr8QghhDSNb/P8P2N7UiyXwCyGENQwJ/EqpZGAq8HJT75HBXSGEsIZRLf5/AL8DPE29QVr8QghhjYADv1LqauCY1nrjOa6bpZTKVEplggR+IYSwihEt/lHANKXUPmABME4p9cbpF2mt52ith2mth4HM6hFCCKsEHPi11g9qrZO11mnATcBnWuvbznWftPiFEMIasmWDEEK0MQ4jE9Nafw583pRrZVaPEEJYQ7ZsEEKINkYCvxBCtDGyO6cQQrQx0uIXQog2Rmb1CCFEGyNdPUII0cZIV48QQrQxlgZ+rbVV2QshRJtlSeBXKADcHrcV2QshRJtmTeBX3sAv3T1CCGE+S1v8skOnEEKYT1r8QgjRxljb4pe5/EIIYTprW/wyl18IIUxnSeC31WcrXT1CCGE+S1v80tUjhBDms7SPX7p6hBDCfDKrRwgh2hhp8QshRBsjffxCCNHGyMpdIYRoYwIO/EqpCKXUeqXUJqVUtlLqf5twDwA1dTWBZi+EEKKZHAakUQOM01qfUEo5ga+UUiu01uvOdINvHr+0+IUQwnwBB37t3VT/RP2XzvqPs260Ly1+IYSwjiF9/Eopu1IqCzgGrNRaf9vINbOUUplKqczqqmpApnMKIYQVDAn8Wus6rXUGkAxcopQa2Mg1c7TWw7TWw6KjogFp8QshhBUMndWjtT4OrAYmne066eoRQgjrGDGrp7NSqn3955HABGDHWe+R6ZxCCGEZI2b1dAPmKaXseP+QLNJaLzvbDTYls3qEEMIqRszq2Qxc2Jx7fC1+6eoRQgjzWbtlg7T4hRDCdJYexCItfiGEMJ+0+IUQoo2R3TmFEKKNsXR3TunqEUII81nTxy/TOYUQwjLS4hdCiDZGBneFEKKNka4eIYRoY6SrRwgh2hjp6hFCiDZGVu4KIUQbY/kCLu/JjUIIIcxiSeAHcNi8G4PK8YtCCGEuywJ/uD0ckO4eIYQwmwR+IYRoYywL/GH2MABcddLVI4QQZpIWvxBCtDGWBX6nzQlI4BdCCLNZ3uKXRVxCCGGugAO/UipFKbVaKbVNKZWtlPp/TblPunqEEMIaDgPScAO/1lp/p5SKBTYqpVZqrbed7Sbf4K6cwiWEEOYKuMWvtT6itf6u/vNyYDuQdK77/IFfunqEEMJUhvbxK6XSgAuBbxv53iylVKZSKrOgoEC6eoQQwiKGBX6lVAzwDvArrXXZ6d/XWs/RWg/TWg/r3LmztPiFEMIihgR+pZQTb9B/U2v9blPukVk9QghhDSNm9SjgFWC71vpvTb1P5vELIYQ1jGjxjwJuB8YppbLqP6ac6yZp8QshhDUCns6ptf4K6s9SbAYZ3BVCCGtYvkmbBH4hhDCX5Vs2yEEsQghhLmnxCyFEG2N54JfBXSGEMJflXT3VddVWFUEIIdokywJ/hD0CgBq3dPUIIYSZrAv8Dm/glxa/EEKYy/IWf7VbAr8QQpjJuj5+R30fvwR+IYQwlfUtfunqEUIIU1kW+CMdkYC0+IUQwmyWT+eUBVxCCGEu62f1SItfCCFMZXngr6qrsqoIQgjRJlm3ZYMtDIXC7XHj9ritKoYQQrQ5lgV+pZS/1S/9/EIIYR7LAj/IIi4hhLCCtYFftm0QQgjTWRr4/VM6ZaM2IYQwjaWB37eIS2b2CCGEeUKixS99/EIIYR5DAr9S6lWl1DGl1Nbm3Oef1SNdPUIIYRqjWvxzgUnNvUkWcQkhhPkcRiSitf5SKZXW3PtC6RSuQycO8fbOt9lUsAmXx0Xv+N5M6zWNCxMutLpolnB5XGQXZlNQVUCXqC4M6DgAu81udbEsUVtXy9bCrRRVF9Etuhv9O/bHpiztJbVMTV0NWwu3UlJdQreYbvTr0K/N1kWVu4qthVsprSklKSaJCzpcgFLK6mI1iSGBvymUUrOAWQDdu3cHQmM6p9aaV7e+yvNZz5+ygnhTwSYW71rMxNSJPHLpI8SGxVpWRjPVeepYsHMBczbPobi62P96QmQC91x4D9PTp7eZX3S3x80b297g1a2vUlJT4n+9a3RXfnnhL7m659Wt5hc9UK46F3Oz5zI3ey5ltWX+15NikvjV0F9xVepVbaYuautqeXnLy7y+7XVOuE74X09tl8p9Q+9jfPfxFpauaZTW2piEvC3+ZVrrgee6dtiwYTozM5NH1z3Kwp0LeeCSB7i1362GlKM5PNrDY+seY9GuRQBM6TGFqT2nEumIZO3htby1/S0q3ZWkt0/n5Ykv0zGyo+llNFO1u5rffvlbPj/wOQBp7dJIi0sjtySXgycOAjApbRKPjn7UPzB/vqp0VXLf5/ex9vBaAHrF9SKlXQq7indxuOIwANN6TeORkY/gtDutLGrQldeW88vPfknm0UwA0tunkxybzI7iHeRX5ANwfZ/rmT18Ng6baW1JSxyvPs49n93D5oLNAPSN70u36G5sK9rGsapjANzW7zZ+M+w3QXlCVkpt1FoPCzQdS/+XfNM5rdqy4R8b/8GiXYsIs4Xx1OVPMbb7WP/3Lu56MdemX8u9n91L7vFcfv7pz3lt8mv+Mp9vXHUu7ll1D+vz19MurB1/HPVHxqWMQymF1prle5fzp3V/4qN9H+HyuHj68qfP266fanc1s1bOYlPBJjpEdOBPo/7EmKQxKKXwaA9Lc5fy5/V/5v3d71On63h89OPn7VNQpauSn3z8E7YXbychMoFHRz/KyMSRgLfhtHjXYv6y/i+8vettPNrDwyMfPm9b/uW15dz58Z3kHs+lW3Q3Hhv9GBd3vRg4+aT8VOZTvLH9DTSa+y++P2TrIjRW7lownXPV/lX8O/vf2JWd58Y/d0rQ90lpl8KrV71K99ju7CjewcNrH8aoJ6RQorXmsW8fY33+ejpHdua1ya8xvvt4/5tWKcXUnlOZN2kesc5YVuWt4u8b/25xqYNDa80j3zzCpoJNdI3uymuTX+Oy5Mv8dWFTNmb0nsErE18hyhHFh3s+5MWsFy0udXB4tIfZX81me/F2UmJTeG3Ka/6gD966uKHvDcyZOIdwezjv5LzDK1tfsbDEwVPnqeN3X/6O3OO59IjrweuTX/cHfQC7zc6t/W7lxfEv4rQ5eXP7m7y14y0LS3x2Rk3nnA98A/RVSh1USv2kKff55/Gb3MdfXF3Mw988DMB9Q+/j0sRLz3htx8iOPDP2GaIcUazYu4Jle5aZVUzTLN+7nHdy3iHcHs6z456lV/tejV7Xt0Nfnhn3DA6bg3nb5vHVoa9MLmnwvZvzLh/u+ZBIRyTPj3ue1HapjV43qPMg/nbF37ApG3M2z2FD/gaTSxp8b21/i1V5q4h1xvLC+BdIiklq9LqhXYby18v+CsDz3z/v7wY5n/w7+998degr2oe358XxL9Ilukuj141MHMmjox4F4OnMp9lZvNPMYjaZIYFfa32z1rqb1tqptU7WWjfpz75Vxy8+nfk0pTWljOw2kh/1/9E5r0+PT+fB4Q8C8MT6JyisKgx2EU1TWFXIn9f/GYAHL3mQgZ3OPkRzcdeLuSfjHgD+5+v/obSmNOhlNMuRE0d4MvNJAB4e+TB9O/Q96/Wjkkbxs0E/Q6OZ/dVsKl2VZhTTFHlleTzz3TMAPDr6UXrE9Tjr9eO6j2Nm/5nU6ToeXPPgebUoM7ck1/9U95cxfyE5Nvms10/pOYUb+tyAy+PigTUP4PK4zChms7S5lbtZx7J4f/f7hNnC+P2I3ze5D+6aXtcwKmkUZbVl51U3x5MbnqS0ppRRiaO4tve1TbrnzgF3cmHChRRWFfLPTf8McgnN88T6J6hwVTAuZRxTekxp0j13DbmL/h37k1+Rz5zNc4JcQnNorXl03aNU11UztedUxnUf16T7fnnRL0lvn05eeR5zs+cGt5Am0Vrzp3V/wuVx8cPeP+TSpDP3DjT062G/pntsd3KP5/LW9tDr8gmNvXrc5i3geu775wCYOWAm3dt1b/J9SikeGv4QDpuDD3Z/wI7iHcEqomm2Fm5l+d7lhNnC+J+R/9PkP4J2m52Hhj+ETdlYsGMBu0p2BbmkwZeZn8lnBz4j0hHJQyMeanJdOG1OHhr+EADzts1jf9n+YBbTFF8f/ppvjnxDrDOW+y++v8n3hdnDmD18NgAvb3mZwycOB6uIplmVt4rvjn1Hh4gO/HrYr5t8X5QzigcueQCAf276Z8j1Elga+KMcUYB5gf/bI9+yPn89sWGx3DHwjmbfnxKbws0X3IxG83Tm0616oFdrzVOZTwFwa/9bz9h/eyZ9O/Tlhj43UKfr/H9MWyuP9vB05tOA92kmISqhWfcP7jyY6enTcXvcvPD9C8EoomnqPHX+upg1eBbxEfHNuv/irhczKW0SNXU1/GvTv4JRRNO46lz+p/u7h9zd7LU8Y5LHcEXyFVS4Kvi/zf8XjCK2mLUtfqe3xV/pNqdv9OUtLwNwx4A7aBfWrkVp3DX4LmLDYll3ZF2rHtBbc2gNG49upH14e3466KctSuOuIXcR6Yjk8wOfk12YbWwBTfTp/k/ZWrSVzpGdmTlgZovSuCfjHpw2Jx/t+4ickhyDS2ieD/d+SO7xXJJikri5380tSuO/Lvwv7MrO+7vfJ68sz+ASmmdJ7hLyyvNIa5fGD/v8sEVp/PKiX6JQvL3rbf+ah1AQGi1+V/Bb/DklOaw7so5IRyQ39r2xxenEhcf5B4T/b0to/RVvDt8fwZ8M/EmL/wh2iuzETRfcBMALWa2zpau19tfFrMGziHJGtSidrtFdua7PdWh0qx338GgPr2zxzsv4+ZCft3iRXvd23ZnWaxp1uo6XNr9kZBFN4/a4eXXrqwDce+G9OG0tW6TXO743V6VdhcvjCqlWf0gEfjNa/G9ufxPwDtLGhccFlNbNF9xMtDOadUfWsaVgixHFM9XGoxv5/tj3tAtrx/V9rw8orTsH3EmUI4o1h9awrWibQSU0z9rDa9levJ2OER2Znj49oLR+OuinhNvDWbl/JXuO7zGmgCZanbeaPaV76Bbdjak9pwaU1qzBs3AoB8v2LONg+UGDSmiej/Z9xKETh0hrl8aV3a8MKK27h9yNTdl4N/ddjlUeM6iEgbE28DvNCfwl1SX++fdGbA0RFx7HTX29Ld3W2Or3tXBv6XcL0c7ogNKKj4jnuj7XAfDattcCLpvZfHVxe//b/QsKWyohKoFrel0DtL660Fr738szB8xscQvXJzk2mSk9p+DRHn+jq7Vo+ORz58A7A16h3rN9T8Z3H4/b42b+jvlGFDFgodHiD/L852V7llFTV8PopNGkxaUZkuZt/W8jzBbG5wc+50D5AUPSNMPO4p18degrIh2R3HqBMfsj3drvVuzKzsd7Pw6pfsxz2VywmcyjmcQ6YwPq/mvo9v63A/DB7g9O2eQu1K3PX092UTYdIjo0eVrvufjq4t2cd0/Z2C3UrTm4htzjuSREJfCDnj8wJE1f9/CinYtCYr1HmxjcXZq7FMCwNzR4+7cn9ZiERrNgxwLD0g22xbsWA94ur/YR7Q1JMzEmkQmpE3Dr0GnRNMXbu94G4Lo+1xETFmNImmlxaVyRfAW1nloW7lxoSJpm8NXFjX1vNGw/qgs6XMDwrsOpdFfy7q53DUnTDL66uLXfrYZtwJeRkMHgzoMpqy3j/d3vG5JmICwN/GG2MOzKjtvjxlUXnNVtO4p3sLNkJ3HhcVyefLmhad/S7xYAluQsCYm/4udS7a7mwz0fAvi7Z4zia9G8vevtVlEXJ2pP8PG+jwFaPGPjTH40wFsXC3YsoLau1tC0g6GkuoRVeatQKEMbR3CyLt7c8eYp256HqqMVR1lzaA0O5fB32xnF9zvy+rbX8WiPoWk3l6WBXykV9AFeX2t/ctpkwuxhhqY9oOMAMjpnUO4q54PdHxiadjB8mvcp5a5yBnYceM7tCJprUOdBDOk8hPLaclbsXWFo2sHw0b6PqHJXMazLsDPux9NSw7oMo298X4qri/l0/6eGph0My/Ysw+1xMyppFF2juxqa9uik0aS1SyO/Ip8vD35paNrB8P7u9/FoD2O7jzV8G/bx3cfTLbobeeV5rDuyztC0m8vyvWR93T3BWMRV56lj+d7lAAHP2DgT32Dx/B3zQ35B17s53sfta/sY26rzuaHvDcDJR+VQ5q8Lg1u44G3QtJa60Fr76+KHvY198gHvDp6+p8tQrwuP9gT1feGwOfzp+rpcrWJ54A/mAO93x76juLqY7rHd6d+xv+HpA4xPHU+HiA7sLt3NpoJNQcnDCPvL9rMhfwORjkgmp00OSh4TUyfSLqwd2UXZIT21c2fxTrYUbiHWGcuE1AlByWNKjylEOiLJPJrJntLQndq5uXAzucdz6RDRwfCuUJ9pvabhtDn5+tDXHDpxKCh5GGFD/gYOnjhI1+iujOw28tw3tMC1va/Fruyszltt6TYOlgd+30BSMLp6Ptn3CQATUicE7UAEp83JNenevsB3ct4JSh5GWJKzBPAGZ6MGMk8X4YhgWq9pQGi37pbkeutiSs8pAU/hPJOYsBj/Rm9Wt+7OxtfCndZrWtBOEouPiGdC6gQ0mnd2he7viO/3d3r69KAdMpQQlcDlyZfj1m7/76QVLA/8/rn8Brf4PdrDqrxVAEFr1fn4HpE/3vcxJ2pPnONq87k9bpbu9o51GD2QeTrfY/3yPcupcFUENa+WqKmr8Y/HBKNro6Hr+3gXx72/+33LTpk7mwpXhX88ZkbvGUHNy1cXS3KXhOQ2xaU1paza7x3gDla3sI9v0eQ7Oe9YNshrfeAP0kZtmwo2UVBVQGJ0YtC6eXxS26UyrMswqtxVrNgXegObaw6uobCqkB5xPcjonBHUvHq178VFCRdR6a70zyAKJav2r6Kstox+HfrRr2O/oOY1oNMA+nXoR2lNqf/pM5R8vO9jqtxVXJRwET3jegY1r6FdhtIzrieFVYV8ceCLoObVEsv2LKPWU8vIxJHN3rCwuS5NvJSkmCQOnTjkP9PZbNYH/iCt3vXNprgy9UpTzr30DdqE4qOsf8Aq/VpT6sLX6rfyUfZM3s0N3kBmY3ytO1/3UijxdW0EYyDzdEop//vC934MFVprU+vCpmz+959VdWF94A/S4K5v6tjYlP88SzcYJqROIDYsluyi7JDaq/9oxVG+PPQlDuXgB72MWYV4LhNSJxDrjGVr0daQOnruQPkBvj3yLRH2CCb3DM4A9+kmp00m0hHJhvwNIbVXf05JDpsLNhPjjAl6V6jP1T2v9g7yHv46pFZ4Zxdlk1OSQ3x4vGnx4pr0a7ApG6sPrKaoqsiUPBuyPPAHY3D3YPlB9pXtI8YZw5CEIYalezYRjgiu7nk1EFotmmDOSz6TCEcEU3p6BzZDqS58TyATUie0eEfS5ooJi2Fi6sRT8g8Fvv+XyT0mt3hH0uaKj4hnXPdxeLSH93LfMyXPpvC19q/udbXha33OJCEqgTFJY3B73Jac42154A/G4K7vEPCRiSMD3myqOXyPiR/u+TAkBvM82uPvYjDjEbYh36Osb58kq7k97qBs3dEUvgH1pbuXhsTAZm1drT/YmNXl5eOr+yU5SyxfvQreuOMb4L423dz3hb97OOcd09cAGRL4lVKTlFI7lVK5SqkHmnNvMAZ3fYF/TNIYw9Jsigs6XEC/Dv0oqy3js7zPTM27MZn5mRwoPxDUecln0q9jP39drNq/ytS8G/P1oa85VnWM1HapDO0y1NS8Mzpn0COuB4VVhaw5uMbUvBvz2YHPOF5znL7xfYM+8eF0I7qNIDE6kcMVhy1fvQrwyf5PqHBVMKTzENLj003Ne0zyGDpFdmJv6V7T1wAFHPiVUnbgBWAy0B+4WSnV5HeT0YO7NXU1rM9fD8CopFGGpNkcvmlxofBYb8a85LOxegCroYYrMs0Y4G5IKeWvi1B4X/g2TLOiLmzKFlK/I8FctXwuTpvTvx+Q2WuAVKCPGEqpkcAjWuur6r9+EEBr/ecz3TMs0a4zZ3kXES2JieYPnTsyrfwEjxUGvo3t2ogI7uqWQN+aWhYfNn8AqdRmY1xKEi4FHx08TKK7zvQyeMuhGJeSjEvBioOHSbKgHGU2xfiUJKptNpYfOEyK25pNugrtNq5MSUIBKw8colOd+V0MRTYbV3ZPwgN8cuAwXeqseV8cctiZlJJEmEfz2YGDxHnM32Yk325nYkoiDmBV3iHiPdZ0+exxOrgmOZEoj4fVeYeIsmDLlf0OB1enJBLp8fBZ3iFizlEG9b9lG7XWwwLN14iuniSg4Yb0B+tfO4VSapZSKlMpldnw9aj6//RKmzHDDV9HeVdijq4y5wD308V5PIyvrEQrxdKYwA45CcSH0dHU2hQjq6otCfoA7TyaiRXeJ7klsdbVxdKYaOqU4rLKKkuCPkBHj4exlVV4lOJ9C98X78V4G1xXVlZaEvQButbVMaqqGpdSLLOwLpbU18XkikpLgj5AqtvNsKpqqmw2VsSYM8gOeOewBvIBXAe83ODr24Hnz3bP0KFDtc/XB7/WA+cO1D/5+CfaCNe9f50eOHeg/vbwt4ak1xJrD63VA+cO1BPfnqjrPHWm5+/xePS1S6/VA+cO1Cv2rjA9/4Y2HNmgB84dqMctHKdddS7T8/d4PHrKO1P0wLkD9RcHvjA9/4bWHFyjB84dqCctnmTJ+8Jd59bjF423/PdDa61X7lupB84dqKe/N117PB7T86911+rLFlymB84dqDcd22R6/g29n/u+Hjh3oL552c3nvBbI1AHGbK21IS3+Q0BKg6+T619rEt++MUZsdVBaU8rO4p2E2cJMm8bZmOHdhvsHsL498q3p+W8r2saukl20D2/PuJRxpuff0NAuQ0ltl8qxqmN8fehr0/PPPJpJXnkeCVEJXJp4qen5NzSy20i6Rnfl4ImDbMjfYHr+aw+v5WjlUVJiUxjWNeDegoBcnnw5HSI6kHs8l82Fm03P//ODn1NcXUx6+3QGdRpkev4N+da9bCncYtq6FyMC/wagt1Kqh1IqDLgJaPIRM/7A7wo88GfmZ6LRDO48mHB7eMDptZRN2fz7fVixYtM3UPSDXj8wbV7ymSilTpm2Zjbf4N309Ok4bA7T82/IbrMzI907sGnFgHfDAW6bsnYmt9N+cmDTikFe33vxh71/aPoA9+kiHBH+w+3NihcB/+9rrd3AvcDHwHZgkdY6u6n3xzpjASivLQ+0KP7ZPJd0vSTgtAJ1Tfo1KBSr9q+itKbUtHwrXZX+MwjMnpd8JtN6TcOhHHx58EsKKgtMy7estoyV+1cC+AOu1aanT0eh+HT/p6a+LwqrCvn8wOfYld2/g6rVpveeDsDyveZu6HfkxBHWHlqL0+b0L7q0mq9x9MHuD0xZ92LIn32t9XKtdR+tdS+t9WPNudfIrh5f4L+468UBpxWoxJhERnQbQa2n1h+IzbBy/0rL5iWfSafITlyecjl1us6/S6gZlu9ZTk1dDcO7DSc5Ntm0fM8mMSaRkYkjqfXUmrpic9nuZbi1mzFJY0iISjAt37PpGdeTixIuospd5T8G0wzv7X4PjWZ89/GGnTsdKLPXvVi+cjfCHoFDOaj11AZ0PmlxdTG5x3MJt4czuPNgA0vYclbMVw7mCUKBaLhiU5s0g8LKOdpnY/aKTW3yJmTNYXY3oEd7eC/nvVPyDhX+dS+5we8GtDzwK6X8rf5Aunsy872zRDM6Z1jer+0zrvs42oW1Y3vxdlM2btt9fDffHfuOKEcUV6VdFfT8mmNU4igSohLIK88j82jmuW8IUHZhNtuLtxMXHse47tYOcJ9ubMpY4sPjySnJIbuoyb2iLbbx6Eb2le2jU2QnxiSbu5r9XCakTiDGGcPmgs3klOQEPb+1h9dyuOIwSTFJDO82POj5NcfknpOJsEfw7ZFvOVB+4Nw3BMDa0a56Mc4Yjtcc54TrRIs3EvPNkgiFbh6fcHs4U3tOZf6O+SzJWcKDwx8Man6+k56m9JxCtNO6+dGNsdvsTE+fzpzNc3g3592g/z/5TgCb1muapQP9jQmzh3F1r6t5fdvrvJPzDgM7DQxqfr66mJE+w/IB7oZcLhdHDx7lb/3/RqWrkqL9Rbjzg7vIT1Ur/tH/H8SGxbJzR+jsHOvzzIBnqHRXkrM7h64DuuJ0BmevsZB4F8SGeQd4A+nnzyrIAuCiLhcZUSTDzEifwfwd81m2Zxn/Pey/gxaEqt3V/v5z32lHoWZG+gzmbJ7Dyv0reXD4g0HbIfNE7Qn/uIpvD/hQc236tby+7XVW7F3Bb4f9Nmg7ZJZUl7By/0oUKuTq4uDBg8TGxtIlqQt7y/Zit9npE98naDOOXHUudpXsQqHo3aG3qRs4NlWFq4K9x/dSV1HHgQMH6NkzOAfkWN7VAycHeMtdLevqqXRVsqtkF3ZlZ0DHAUYWLWANB21W560OWj6f7P+E8tpyBnQcYPrGW02VHJvMiG4jqKmrYfme4A14L9+7nCp3FcO6DAv6yVItlR6fzpDOQ6hwVfDJ/uCdzvX+7vdxeVyMShpFYkxi0PJpierqajp27EikM5IIRwR1njpDZvedSUlNCQCx4bEhGfTBu2lluCMce7Sd0orgzfoKjcDvDGxmz9bCrXi0hz7xfUzbW7w5fHP6gzl3++2d3sf5G/reELQ8jBDsjdu01v6ujVB98vExoy583X+hWhdKKZRStA9vD3ifUIJBa83x6uMAxIfHByUPIyiliI+IRyll+KmEDYVE4Pd19bT0r71vS9Mhna1brXs2U3tOJcIewTdHvmFP6R7D088pySGrIIsYZwyT0iYZnr6RxnUfR1x4HNuLt7OtaJvh6W8t3MqO4h20D2/PlalXGp6+ka5Ku4ooRxTfH/uePceNf19syN/AvrJ9JEQmcFnyZYanb6S48DiUUlS4KgKa3XcmJ1wncHlcOO3OkBv/Ol1ceBwKRY27hsKqwqDkERKB39/ib+HqXX/gt3CbhrOJC4/zr8x7a/tbhqf/5vY3Ae/RdqH4xNNQmD2MH/T0HgEZjJbuG9vfALxPWaEyu+tMopxRTO7hPQIymHVxbZ9rQ2pQtzEOm8M/5nO85rjh6fuON4wPjz/rSt2srCxGjhzJgAEDGDx4MAsXLmz0ujvuuIMePXqQkZFBRkYGl17q3Q5k7ty5KKX49NNP/de+9957KKVYvHgxM2bMICMjg/T0dOLi4vz3r1178tB1p81JTFgMGu0/PMhooRH4A1jEpbVmc4F3r49QbfED3NbvNsDb52rkis2iqiI+2P0BCsWt/W41LN1g8q1vWL5nuaEH8ORX5PPJvk+wKzu3XHCLYekGk3/F5p4PcNUZdzrX/rL9fH7gc5w2Jzf2vdGwdIPJ1wVTUl1i6PqGanc1Fa4KbMpGfMTZu3mioqJ47bXXyM7O5qOPPuJXv/oVx48fb/TaJ598kqysLLKysk4J3IMGDWLBggX+r+fPn8+QId7YtGTJErKysnj55ZcZM2aM/37fHw4fXzmX5AbnpLKQaAb4t21oweBuXnkeJTUldIjoQHJMaKzObEx6fDojuo1g3ZF1LMlZwh0D7zAk3YU7F1LrqeWKlCtIi0szJM1g6xPfh8GdB7O5YDNLcpZwSz9jgvRb29/Crd1MTptMt5huhqQZbIM6DaJ3fG9ySnJYtmeZ/49ioN7Y9gYazdU9r6ZTZCdD0gymtAc+PO2VXEPS3ffEVIqqva399uHt/U8+DzzwACkpKdxzzz0APPLII8TExPCb3/zGf29iYiIJCQkUFBTQvn37Juc5ZswY1qxZg8vloqamhtzcXDIyMppV7hhnDHZlZ3/Zfr48+CVXpFzRrPvPpdW3+Bv271u92dK53N7/dgDe3PGmIa27anc1C3d6H0V/1P9HAadnpjsH3AnA3Oy5hpxDW+Gq8A9k+uq5NVBK+evi1a2vUucJ/OyE0ppS/9Te1lQXweDyuPxP2B0iO/hfv/HGG1m0aJH/60WLFnHjjac+Ga1fv57a2lp69erVaNq//e1v/V01t9568mlbKcWVV17Jxx9/zNKlS5k2rfl7IymliA7zjkW8vOVlw1d4h0SLPy48DqBFXSCbjoX2wG5Do5NG0yuuF7tLd7N099KA51UvzV1KcXUx/Tr0Y1gXa7fZba5x3cfRI64He0v3smLvioA3Dlu8azHlrnIuSriIQZ2t3Wa3uSb1mMQLWS+wr2wfq/JWMTFtYkDpzd8xnyp3FZcmXkrv+N4GlTK49j3hHQPzaA85JTm4PW66t+vun/jRUkcrjqK1JjYs9pQ1NBdeeCHHjh3j8OHDFBQUEB8fT0rKyd3ljxw5wu233868efOwneGQqCeffJLrrmv8d/imm27i2WefpbS0lKeffprHH3+82WWPckTRPrw9mwo2kXk009BFjyHR4vdN5WrJoE6oz+hpyKZs3DXkLsD7VzyQlm5NXQ1ztswB4CeDfhLyTzunsykbPx74YwBe2fJKQP2Yla5KXt36KuCti9bGaXNyx4A7gMBbd2W1ZbyW/RoAPx30UyOKZyqbsvlX7wc6o8XtcVNc7T3OtbHuruuvv57FixezcOHCU1r7ZWVlTJ06lccee4wRI0a0KO9LLrmELVu2UFhYSJ8+fVqUhk3Z/N2gr2x5pUVpnDFtQ1NroZYG/gpXBTnHc3AoBwM6hdbCrTOZmDqRtHZpHDpxiGW7W7474+JdizlWeYw+8X2YkDrBwBKaZ2rPqXSN7sqe0j0B7WA6f8d8iquLGdx5MGOSQmsvmqaanj6djhEd2V68nc/yPmtxOq9ve51yVznDuw4Pqe1LmiM+PB67slPpqgxoNX9hVSEe7SE2LLbR2W433ngjCxYsYPHixVx/vXedQ21tLTNmzOBHP/rRGVvzTfXEE0+0qKXf0C0X3EKUI4qvD3/NxqMbA0qroZAI/L4R7OYGfv/CrQ59iHREBqFkxrPb7P5W/3PfP0elq/mLNCpcFby85WUA7sm4x/JDNVrKaXPyiyG/AODZ755t0T7kpTWl/Dv734C3Llrbk49PhCOCWYNnAfD37/7eoqfBoqoiXt/2OgD3XHiPoeUzk91mp1OUt4WeX5nfoicgV53L39rvHNW50WsGDBhAeXk5SUlJdOvmnQywaNEivvzyS+bOnevvv8/Kymr0/oZ9/BkZGdTWnrr+YPLkyYwdO7bZZW8oLjyOmQNmAvDUhqcCSquhkIgYcWEn+/ib88jfmrp5GprSYwoDOw6koKrAH8Cb46XNL1FYVcigToMYmxLYG8tq03pNo098H45UHOGNbW80+/4Xsl6gtKaUi7tezMhuI4NQQvNc3/d6Utulsr9sv38ldnM8890zVLgqGJM0hgsTLgxCCc3TIaIDTpuTGndNi7qAj1Z6+/bbhbc7a6Nwy5YtrF59ciuV2267DZfL5Z9mmZWV1eiMnLlz57J3795TrgsLC+OOO+7g+eefb/T6hk8QV1xxBcuWNe2J/44Bd9ApshNbi7Y26fqmCInA77Q7iXHGUKebt1eHL/BndM4IUsmCw6Zs3H/J/QDMy55HXllek+/dU7qH17e9jkIxe/jsVtvC9bHb7Px62K8B7x+0QyeafFwzO4t3snDnQuzKzv0X39/q68Jpc3Lf0PsAeD7reY5VHmvyvZsKNrEkdwkOm4PfXfy7YBXRNDZlIyHae2DM0cqjuD1N37WzoraC0ppSlFJ0ieoSrCKaJsoZxb0Z9xqaZkgEfmh+P/8pC7dCdMXu2WQkZPCDnj+g1lPL7K9mN+mN7fK4eHDNg7g9bq7tfW3Qt/M1y6WJlzIxdSJV7ioe/vrhJj311dTV8MCaB/BoDzddcBN9O/Q1oaTBNy5lHGOSxlBeW84fv/ljk7o5Kl2VPPTVQwDM7D+z1aznOJe4sDiindHUeeo4UnGkSffUeer8jYdOkZ1CfvV2U01Pn27okZkhE/h9/fxN3aRpf9l+jtccp1NkJxKjQ2vXwaa6/5L7SYhKYFPBJl7IeuGc1z+z8Rm2FW0jMTrR30o+X8wePpv48Hi+zf+Wlza/dNZrtdY8ueFJco/nktoulV9e+EuTShl8SikeHvkwsc5Yvjj4BfOy5531eq01j3/7OPvL9pPePp27M+42qaTBp5QiMSYRm7JRVlNGcVXxWa/XWnO44jAuj4sIR0SrWLjWVHabncdGN+tU27MKmcDf3Ln8rWnh1pnEhcfx2OjHsCs7L2952b8AqTHzd8xn3rZ52JWdP4/5c8Dzm0NNx8iOPDr6URSKF7NePOt5tPOy57Fw50KcNidPjHki5Pcnaq4u0V3446g/At6BXt+B8Y3516Z/sXT3UsLt4Twx5omQO3QmUGH2MP8q7PyK/DN2BWutOVp5lLKaMmzKRnJMcqud9GCGgGpGKXW9UipbKeVRSgW0gsi/T0dN01r8rXVg93Qjuo1g9vDZAPzvN//LS5teOqXbx+Vx8WLWizz+rXda2COXPhJyh80Y5bLky/jvof8NwOw1s/n31n+fspK1tq6Wv2/8O09vfBqAx0c/ft50d53uytQr+cWQX+DRHn7zxW94c/ubp3SBVbur+cv6v/DiphexKRt/veyv50131+nah7enY2RHNJoDZQcori4+pQvM1xVUVFWEQpESm0K44/z6A2i0QFfubgWuBc7+bN4EvtPufXtmn8v5EvjBu4d+lbuKpzKf4vms51m2ZxljU8bi0R4+O/AZB8oPoFDcf8n9/r39z1d3DLwDDx7+vvHv/G3j33gv9z2uSLkCt8fNqrxVHDpxCLuy8/sRv2dSj9DegjpQPx/yczSaf276J0+sf4J3ct7hsqTLqKmr4dO8T8mvyMdhc/DHS/8YcucKG803SFtUVcSRE0coqS4hxhmDBw9lNWW4PW6UUiTFJPm3gBFnFlDg11pvBwzpamnO4O6J2hPklHgXboXqaVPNNXPATHq178Wj6x5lX9k+/9x0gJTYFH4/4vdcmnjpWVI4f/x44I9Ja5fGY98+xp7SPaecYZDWLo0/jPxDq12c1BxKKX6R8Qt6te/FE+ufIKck55QDydPbp/PwyIfJSMiwrpAmUUrRNborEY4I8ivyqXZXU+2u9n8/whFBYnQikc7A1vNkZWVx9913U1ZWht1u56GHHvqPPXzAuy3zF198Qbt27aiqqmLEiBE8/vjjJCd7N4pMS0sjNjbWW+6uXXnttdfo2rVrQGUzkml79SilZgGzALp37/4f3/efwNOErp4thVvQaC7ocAERjghDy2ml0UmjWTZjGWsPr2V70XaUUvTv2J8R3UaE/H7qRhvX3Tu75atDX7GjZId/dfbwrsOx2+xWF89UV6VdxdiUsaw5uIZdJbtw2p0M7jSYoV2Gtrm6aB/ennZh7SivLaemrgaFIsoZRZQjypAGqG9b5t69e3P48GGGDh3KVVdd1ejunL69erTW/OMf/2DcuHFs3bqVsDDvTKLVq1fTqVMnZs+ezeOPP86zzz4bcPmMcs5oopT6FGjsT9VDWusmnxKgtZ4DzAEYNmzYf8xR8+3P4Tsw4WxC/eCVQDhsDi5LvizkT0wyg9PuZGz3sYzt3roXqRkhzB7G+NTxjE8db3VRguORuCZfagOafPUjjU8WMXJbZqUU9913H0uWLGHFihVcc801p3z/sssuC6mgD00Y3NVaX6m1HtjIh6FHw/j68I5WHj3ntedT/74QwnxGbMt8uosuuogdO3b8x+vLli1j0KDQ2jE2ZPoPfIH/XKsVPdrTalfsCiHO4Awt82AxYlvm052+2G7s2LHY7XYGDx7Mo48+amj5AxVQ4FdKzQCeAzoDHyqlsrTWV7UkrQ4RHbArO8XVxdTW1Z5xxd2e43sory2nS1SXVnPKkhAi9Pi2Zc7PzzdkW+bvv/+e8eNPdsX5+vhDUaCzepYAS4woiN1mp3NUZ/Ir8jlWeYzk2MaPUfy+4HuAVr8JlRDCWjfeeCM/+9nPKCws5IsvvgBati2z1prnnnuOI0eOMGlS65hiHFJL2xKivJsyna27J+tYFkCbmMImhAgeI7ZlHjJkCH369GHDhg2sXr3aP6Mn1IVMHz80rZ9fAr8Qwihbtmw55evbbruN22677Zz3zZ0796zf37dvXwClCr6QavGfa2ZPUVUReeV5RDoi6RPfsuPMhBCirQupwO/r6jlT4M8qyAJgUKdBOG1Os4olhBDnlZAK/F2jvevE8ivyG/3+pmMyf18IIQIVUoG/ezvvVg77yvY1+v0N+RsAGNplqFlFEkKI805IBf7U2FQA8sry/uMUptKaUrKLsnHanDKVUwghAhBSgT8mLIZOkZ2oqavhaMWp/fzr89ej0WQkZJx3B28IIYSZQirwA6S287b695btPeX1dYfXAd6DS4QQIhiysrIYOXIkAwYMYPDgwSxcuLDR69atW8fw4cPJyMigX79+PPLII4B3mue99xp7MHowhNQ8fvDuMb7x6EZ2FO84Zf/5b458A0jgF0IET1O3ZZ45cyaLFi1iyJAh1NXVsXPnTmsK3EIhF/gHdBwAQHZhtv+13JJcDpQfIC487rw5eEUIcdKgecHZvXLLzC2Nvh7otszHjh3zr/a12+3079+64lLIdfX4zlDNLjoZ+D/e/zEAV3a/ss0dSCKEMF6g2zLfd9999O3blxkzZvDSSy9RXV39H9eEspCLoj3jehLrjOXQiUMcKDtAcmwyH+39CPCeRCSEOP+cqWUeLIFuy/yHP/yBW2+9lU8++YS33nqL+fPn8/nnn5v4EwQm5AK/3WZndNJoVuxbweoDq+kd35t9ZfvoFNmpTZyzKoQwR6DbMvfq1Yu7776bn/3sZ3Tu3JmionOfHhgqQi7wA4xLHceKfSuYt20esc5YAG6+4Gbp5hFCGCaQbZk//PBDpkyZglKKnJwc7Hb7WY9nDDUh18cP3r78XnG9OFZ5jN2lu0mMTuSWC26xulhCiPNIINsyv/766/Tt25eMjAxuv/123nzzTex278H3c+fOJTk52f9x8OBBM3+sJlGnHxdmhmHDhunMzMyzXrOzeCcPr30YheLhSx/mgg4XmFQ6IYQZtm/fTr9+/awuRshqrH6UUhu11sMCTTtk+076dujLgqsXWF0MIYQ474RkV48QQojgkcAvhLCMFV3NrUGw60UCvxDCEhERERQVFUnwP43WmqKiIiIiIoKWR0B9/EqpJ4EfALXAbuBOrfVxA8olhDjP+Wa8FBQUWF2UkBMREUFycnLQ0g90cHcl8KDW2q2U+gvwIHB/4MUSQpzvnE4nPXr0sLoYbVJAXT1a60+01u76L9cBwfsTJYQQwhBG9vH/GFhxpm8qpWYppTKVUpnyaCeEENY5Z1ePUupToGsj33pIa720/pqHADfw5pnS0VrPAeaAdwFXi0orhBAiYAGv3FVK3QHcBYzXWlc28Z5yoHWdXBA8nYBCqwsRIqQuTpK6OEnq4qS+WuvYQBMJdFbPJOB3wOVNDfr1dhqx7Ph8oJTKlLrwkro4SeriJKmLk5RSZ9/rpokC7eN/HogFViqlspRS/zKgTEIIIYIooBa/1jrdqIIIIYQwh1Urd+dYlG8okro4SeriJKmLk6QuTjKkLizZllkIIYR1ZK8eIYRoYyTwCyFEG2N44FdKTVJK7VRK5SqlHmjk++FKqYX13/9WKZXW4HsP1r++Uyl1ldFlM1NL60EpNUEptVEptaX+33GmF95ggbwn6r/fXSl1Qin1G9MKHSQB/n4MVkp9o5TKrn9/BG/7RhME8DviVErNq6+D7UqpB00vvMGaUBeXKaW+U0q5lVLXnfa9mUqpnPqPmU3KUGtt2Adgx7tLZ08gDNgE9D/tml8A/6r//CZgYf3n/euvDwd61KdjN7J8Zn0EWA8XAon1nw8EDln981hVFw2+vxh4G/iN1T+Phe8LB7AZGFL/dcfW+vthQF3cAiyo/zwK2AekWf0zBbku0oDBwGvAdQ1e7wDsqf83vv7z+HPlaXSL/xIgV2u9R2tdCywArjntmmuAefWfLwbGK6VU/esLtNY1Wuu9QG59eq1Ri+tBa/291vpw/evZQKRSKtyUUgdHIO8JlFLTgb1466K1C6QuJgKbtdabALTWRVrrOpPKHQyB1IUGopVSDiAS77bwZeYUOyjOWRda631a682A57R7rwJWaq2LtdYleHdMnnSuDI0O/EnAgQZfH6x/rdFrtHdnz1K8rZem3NtaBFIPDf0Q+E5rXROkcpqhxXWhlIrBu833/5pQTjME8r7oA2il1Mf1j/y/M6G8wRRIXSwGKoAjQB7wlNa6ONgFDqJAYl+L7g3Zw9bbOqXUAOAveFt6bdUjwN+11ifqHwDaMgcwGrgYqARWKaU2aq1XWVssS1wC1AGJeLs31iilPtVa77G2WK2H0S3+Q0BKg6+T619r9Jr6R7U4oKiJ97YWgdQDSqlkYAnwI6317qCXNrgCqYvhwF+VUvuAXwGzlVL3Brm8wRRIXRwEvtRaF2rvvljLgYuCXuLgCaQubgE+0lq7tNbHgK+B1ryXTyCxr2X3GjxI4cA7uNCDk4MUA0675h5OHbBZVP/5AE4d3N1DKx28CrAe2tdff63VP4fVdXHaNY/Q+gd3A3lfxAPf4R3MdACfAlOt/pksqov7gX/Xfx4NbAMGW/0zBbMuGlw7l/8c3N1b//6Ir/+8wznzDMIPMQXYhXeU+qH61/4ITKv/PALvDI1cYD3Qs8G9D9XftxOYbPV/iBX1APweb/9lVoOPBKt/HqveEw3SaPWBP9C6AG7DO8i9Ffir1T+LVXUBxNS/nl0f9H9r9c9iQl1cjPeprwLvU092g3t/XF9HuXjPPT9nfrJlgxBCtDGyclcIIdoYCfxCCNHGSOAXQog2RgK/EEK0MRL4hRCijZHAL4QQbYwEfiGEaGP+P5MWlBjSPUyzAAAAAElFTkSuQmCC", - "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": [