EMT_Ph3_Resistor.cpp

Go to the documentation of this file.

/* 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_Resistor.h>
 
using namespace CPS;
 
EMT::Ph3::Resistor::Resistor(String uid, String name, Logger::Level logLevel)
    : MNASimPowerComp<Real>(uid, name, false, true, logLevel),
      Base::Ph3::Resistor(mAttributes) {
  mPhaseType = PhaseType::ABC;
  setTerminalNumber(2);
  **mIntfVoltage = Matrix::Zero(3, 1);
  **mIntfCurrent = Matrix::Zero(3, 1);
}
 
SimPowerComp<Real>::Ptr EMT::Ph3::Resistor::clone(String name) {
  auto copy = Resistor::make(name, mLogLevel);
  copy->setParameters(**mResistance);
  return copy;
}
 
void EMT::Ph3::Resistor::initializeFromNodesAndTerminals(Real frequency) {
 
  // IntfVoltage initialization for each phase
  MatrixComp vInitABC = Matrix::Zero(3, 1);
  vInitABC(0, 0) = RMS3PH_TO_PEAK1PH * initialSingleVoltage(1) -
                   RMS3PH_TO_PEAK1PH * initialSingleVoltage(0);
  vInitABC(1, 0) = vInitABC(0, 0) * SHIFT_TO_PHASE_B;
  vInitABC(2, 0) = vInitABC(0, 0) * SHIFT_TO_PHASE_C;
  **mIntfVoltage = vInitABC.real();
 
  // TODO: here, the custom implementation for matrix inversion is still used, because mResistance is still a generic matrix.
  // Change the definition in future, if valid. The author currently doesn't know if this is allowed (mResistance is defined in Base)
  // This is also done in the following
  Matrix mResistanceInv = Matrix::Zero(3, 3);
  Math::invertMatrix(**mResistance, mResistanceInv);
  **mIntfCurrent = (mResistanceInv * vInitABC).real();
 
  SPDLOG_LOGGER_INFO(mSLog,
                     "\nResistance [Ohm]: {:s}"
                     "\nConductance [S]: {:s}",
                     Logger::matrixToString(**mResistance),
                     Logger::matrixToString(mResistanceInv));
  SPDLOG_LOGGER_INFO(
      mSLog,
      "\n--- Initialization from powerflow ---"
      "\nVoltage across: {:s}"
      "\nCurrent: {:s}"
      "\nTerminal 0 voltage: {:s}"
      "\nTerminal 1 voltage: {:s}"
      "\n--- Initialization from powerflow finished ---",
      Logger::matrixToString(**mIntfVoltage),
      Logger::matrixToString(**mIntfCurrent),
      Logger::phasorToString(RMS3PH_TO_PEAK1PH * initialSingleVoltage(0)),
      Logger::phasorToString(RMS3PH_TO_PEAK1PH * initialSingleVoltage(1)));
}
 
void EMT::Ph3::Resistor::mnaCompInitialize(Real omega, Real timeStep,
                                           Attribute<Matrix>::Ptr leftVector) {
  updateMatrixNodeIndices();
  **mRightVector = Matrix::Zero(0, 0);
}
 
void EMT::Ph3::Resistor::mnaCompApplySystemMatrixStamp(
    SparseMatrixRow &systemMatrix) {
  MatrixFixedSize<3, 3> conductance = Matrix::Zero(3, 3);
  conductance = (**mResistance).inverse();
 
  MNAStampUtils::stampConductanceMatrix(
      conductance, systemMatrix, matrixNodeIndex(0), matrixNodeIndex(1),
      terminalNotGrounded(0), terminalNotGrounded(1), mSLog);
 
  SPDLOG_LOGGER_INFO(mSLog, "\nConductance matrix: {:s}",
                     Logger::matrixToString(conductance));
}
 
void EMT::Ph3::Resistor::mnaCompAddPostStepDependencies(
    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::Resistor::mnaCompPostStep(Real time, Int timeStepCount,
                                         Attribute<Matrix>::Ptr &leftVector) {
  mnaCompUpdateVoltage(**leftVector);
  mnaCompUpdateCurrent(**leftVector);
}
 
void EMT::Ph3::Resistor::mnaCompUpdateVoltage(const Matrix &leftVector) {
  // v1 - v0
  **mIntfVoltage = Matrix::Zero(3, 1);
  if (terminalNotGrounded(1)) {
    (**mIntfVoltage)(0, 0) =
        Math::realFromVectorElement(leftVector, matrixNodeIndex(1, 0));
    (**mIntfVoltage)(1, 0) =
        Math::realFromVectorElement(leftVector, matrixNodeIndex(1, 1));
    (**mIntfVoltage)(2, 0) =
        Math::realFromVectorElement(leftVector, matrixNodeIndex(1, 2));
  }
  if (terminalNotGrounded(0)) {
    (**mIntfVoltage)(0, 0) =
        (**mIntfVoltage)(0, 0) -
        Math::realFromVectorElement(leftVector, matrixNodeIndex(0, 0));
    (**mIntfVoltage)(1, 0) =
        (**mIntfVoltage)(1, 0) -
        Math::realFromVectorElement(leftVector, matrixNodeIndex(0, 1));
    (**mIntfVoltage)(2, 0) =
        (**mIntfVoltage)(2, 0) -
        Math::realFromVectorElement(leftVector, matrixNodeIndex(0, 2));
  }
  SPDLOG_LOGGER_DEBUG(mSLog, "\nVoltage: {:s}",
                      Logger::matrixToString(**mIntfVoltage));
  mSLog->flush();
}
 
void EMT::Ph3::Resistor::mnaCompUpdateCurrent(const Matrix &leftVector) {
  Matrix resistanceInv = Matrix::Zero(3, 3);
  Math::invertMatrix(**mResistance, resistanceInv);
  **mIntfCurrent = resistanceInv * **mIntfVoltage;
  SPDLOG_LOGGER_DEBUG(mSLog, "\nCurrent: {:s}",
                      Logger::matrixToString(**mIntfCurrent));
  mSLog->flush();
}
 
// #### Tear Methods ####
void EMT::Ph3::Resistor::mnaTearApplyMatrixStamp(SparseMatrixRow &tearMatrix) {
  MatrixFixedSizeComp<3, 3> conductance = Matrix::Zero(3, 3);
  conductance.real() = (**mResistance).inverse();
  // Set diagonal entries
  Math::addToMatrixElement(tearMatrix, mTearIdx * 3, mTearIdx * 3,
                           1. / conductance(0, 0).real());
  Math::addToMatrixElement(tearMatrix, mTearIdx * 3 + 1, mTearIdx * 3 + 1,
                           1. / conductance(1, 1).real());
  Math::addToMatrixElement(tearMatrix, mTearIdx * 3 + 2, mTearIdx * 3 + 2,
                           1. / conductance(2, 2).real());
}