EMT_Ph3_NetworkInjection.cpp

/* 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/.
 *********************************************************************************/
 
#include <dpsim-models/EMT/EMT_Ph3_NetworkInjection.h>
 
using namespace CPS;
 
EMT::Ph3::NetworkInjection::NetworkInjection(String uid, String name,
                                             Logger::Level logLevel)
    : CompositePowerComp<Real>(uid, name, true, true, logLevel),
      mVoltageRef(mAttributes->createDynamic<MatrixComp>("V_ref")),
      mSrcFreq(mAttributes->createDynamic<Real>("f_src")) {
  mPhaseType = PhaseType::ABC;
  setVirtualNodeNumber(0);
  setTerminalNumber(1);
  **mIntfVoltage = Matrix::Zero(3, 1);
  **mIntfCurrent = Matrix::Zero(3, 1);
 
  SPDLOG_LOGGER_INFO(mSLog, "Create {} {}", this->type(), name);
 
  // Create electrical sub components
  mSubVoltageSource =
      std::make_shared<EMT::Ph3::VoltageSource>(**mName + "_vs", mLogLevel);
  addMNASubComponent(mSubVoltageSource,
                     MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT,
                     MNA_SUBCOMP_TASK_ORDER::TASK_BEFORE_PARENT, true);
  SPDLOG_LOGGER_INFO(mSLog, "Electrical subcomponents: ");
  for (auto subcomp : mSubComponents)
    SPDLOG_LOGGER_INFO(mSLog, "- {}", subcomp->name());
 
  mSubVoltageSource->mVoltageRef->setReference(mVoltageRef);
  mSubVoltageSource->mSrcFreq->setReference(mSrcFreq);
}
 
SimPowerComp<Real>::Ptr EMT::Ph3::NetworkInjection::clone(String name) {
  auto copy = NetworkInjection::make(name, mLogLevel);
  copy->setParameters(**mVoltageRef);
  return copy;
}
 
void EMT::Ph3::NetworkInjection::setParameters(MatrixComp voltageRef,
                                               Real srcFreq) {
  mParametersSet = true;
 
  mSubVoltageSource->setParameters(voltageRef, srcFreq);
 
  SPDLOG_LOGGER_INFO(mSLog,
                     "\nVoltage Ref={:s} [V]"
                     "\nFrequency={:s} [Hz]",
                     Logger::matrixCompToString(voltageRef),
                     Logger::realToString(srcFreq));
}
 
void EMT::Ph3::NetworkInjection::setParameters(MatrixComp voltageRef,
                                               Real freqStart, Real rocof,
                                               Real timeStart, Real duration,
                                               bool smoothRamp) {
  mParametersSet = true;
 
  mSubVoltageSource->setParameters(voltageRef, freqStart, rocof, timeStart,
                                   duration, smoothRamp);
 
  SPDLOG_LOGGER_INFO(
      mSLog,
      "\nVoltage Ref={:s} [V]"
      "\nInitial frequency={:s} [Hz]"
      "\nRamp ROCOF={:s} [Hz/s]"
      "\nRamp duration={:s} [s]"
      "\nRamp nadir={:s} [Hz]",
      Logger::matrixCompToString(voltageRef), Logger::realToString(freqStart),
      Logger::realToString(rocof), Logger::realToString(duration),
      Logger::realToString(freqStart + rocof * duration));
}
 
void EMT::Ph3::NetworkInjection::setParameters(MatrixComp voltageRef,
                                               Real modulationFrequency,
                                               Real modulationAmplitude,
                                               Real baseFrequency /*= 0.0*/,
                                               bool zigzag /*= false*/) {
  mParametersSet = true;
 
  mSubVoltageSource->setParameters(voltageRef, modulationFrequency,
                                   modulationAmplitude, baseFrequency, zigzag);
 
  SPDLOG_LOGGER_INFO(mSLog,
                     "\nVoltage Ref={:s} [V]"
                     "\nFrequency={:s} [Hz]",
                     Logger::matrixCompToString(voltageRef),
                     Logger::realToString(baseFrequency));
}
 
void EMT::Ph3::NetworkInjection::initializeFromNodesAndTerminals(
    Real frequency) {
  // Connect electrical subcomponents
  mSubVoltageSource->connect({SimNode::GND, node(0)});
 
  // Initialize electrical subcomponents
  for (auto subcomp : mSubComponents) {
    subcomp->initialize(mFrequencies);
    subcomp->initializeFromNodesAndTerminals(frequency);
  }
}
 
// #### MNA functions ####
void EMT::Ph3::NetworkInjection::mnaParentApplyRightSideVectorStamp(
    Matrix &rightVector) {
  SPDLOG_LOGGER_DEBUG(mSLog, "Right Side Vector: {:s}",
                      Logger::matrixToString(rightVector));
}
 
void EMT::Ph3::NetworkInjection::mnaParentAddPreStepDependencies(
    AttributeBase::List &prevStepDependencies,
    AttributeBase::List &attributeDependencies,
    AttributeBase::List &modifiedAttributes) {
  prevStepDependencies.push_back(mIntfCurrent);
  prevStepDependencies.push_back(mIntfVoltage);
  modifiedAttributes.push_back(mRightVector);
}
 
void EMT::Ph3::NetworkInjection::mnaParentPreStep(Real time,
                                                  Int timeStepCount) {
  mnaCompApplyRightSideVectorStamp(**mRightVector);
}
 
void EMT::Ph3::NetworkInjection::mnaParentAddPostStepDependencies(
    AttributeBase::List &prevStepDependencies,
    AttributeBase::List &attributeDependencies,
    AttributeBase::List &modifiedAttributes,
    Attribute<Matrix>::Ptr &leftVector) {
  attributeDependencies.push_back(leftVector);
  modifiedAttributes.push_back(mIntfVoltage);
  modifiedAttributes.push_back(mIntfCurrent);
}
 
void EMT::Ph3::NetworkInjection::mnaParentPostStep(
    Real time, Int timeStepCount, Attribute<Matrix>::Ptr &leftVector) {
  mnaCompUpdateCurrent(**leftVector);
  mnaCompUpdateVoltage(**leftVector);
}
 
void EMT::Ph3::NetworkInjection::mnaCompUpdateVoltage(
    const Matrix &leftVector) {
  **mIntfVoltage = **mSubVoltageSource->mIntfVoltage;
}
 
void EMT::Ph3::NetworkInjection::mnaCompUpdateCurrent(
    const Matrix &leftVector) {
  **mIntfCurrent = **mSubVoltageSource->mIntfCurrent;
}