Line data    Source code

       1              : /****************************************************************************/
       2              : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3              : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
       4              : // This program and the accompanying materials are made available under the
       5              : // terms of the Eclipse Public License 2.0 which is available at
       6              : // https://www.eclipse.org/legal/epl-2.0/
       7              : // This Source Code may also be made available under the following Secondary
       8              : // Licenses when the conditions for such availability set forth in the Eclipse
       9              : // Public License 2.0 are satisfied: GNU General Public License, version 2
      10              : // or later which is available at
      11              : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
      12              : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
      13              : /****************************************************************************/
      14              : /// @file    Element.cpp
      15              : /// @author  Jakub Sevcik (RICE)
      16              : /// @author  Jan Prikryl (RICE)
      17              : /// @date    2019-12-15
      18              : ///
      19              : /// @note    based on work 2017 Ahmad Khaled, Ahmad Essam, Omnia Zakaria, Mary Nader
      20              : ///
      21              : // Representation of electric circuit elements: resistors, voltage and current sources
      22              : /****************************************************************************/
      23              : #include <cfloat>
      24              : #include <cmath>
      25              : #include <utils/common/MsgHandler.h>
      26              : #include "Element.h"
      27              : #include "Node.h"
      28              : 
      29              : 
      30              : // ===========================================================================
      31              : // method definitions
      32              : // ===========================================================================
      33          424 : Element::Element(std::string name, ElementType type, double value) {
      34          424 :     this->id = -2;
      35          424 :     this->name = name;
      36          424 :     this->type = type;
      37          424 :     this->isenabled = true;
      38          424 :     this->resistance = 0;
      39          424 :     this->current = 0;
      40          424 :     this->voltage = 0;
      41          424 :     this->powerWanted = NAN;
      42          424 :     switch (type) {
      43          180 :         case CURRENT_SOURCE_traction_wire:
      44          180 :             this->current = value;
      45          180 :             break;
      46           11 :         case VOLTAGE_SOURCE_traction_wire:
      47           11 :             this->voltage = value;
      48           11 :             break;
      49          233 :         case RESISTOR_traction_wire:
      50          233 :             this->resistance = value;
      51          233 :             break;
      52            0 :         default:
      53            0 :             WRITE_ERRORF(TL("Undefined element type for '%'."), name);
      54            0 :             break;
      55              :     }
      56          424 :     this->pNode = nullptr;
      57          424 :     this->nNode = nullptr;
      58          424 : }
      59              : 
      60            0 : void Element::setVoltage(double voltageIn) {
      61            0 :     this->voltage = voltageIn;
      62            0 : }
      63          993 : void Element::setCurrent(double currentIn) {
      64          993 :     this->current = currentIn;
      65          993 : }
      66          360 : void Element::setResistance(double resistanceIn) {
      67          360 :     if (resistanceIn <= 1e-6) {
      68            0 :         this->resistance = 1e-6;
      69              :     } else {
      70          360 :         this->resistance = resistanceIn;
      71              :     }
      72          360 : }
      73          180 : void Element::setPowerWanted(double powerWantedIn) {
      74          180 :     this->powerWanted = powerWantedIn;
      75          180 : }
      76         1102 : double Element::getVoltage() {
      77         1102 :     if (!this->isenabled) {
      78              :         return DBL_MAX;
      79              :     }
      80         1102 :     if (getType() == Element::ElementType::VOLTAGE_SOURCE_traction_wire) {
      81          922 :         return voltage;
      82              :     }
      83          180 :     return this->pNode->getVoltage() - this->nNode->getVoltage();
      84              : }
      85          753 : double Element::getCurrent() {
      86          753 :     if (!this->isenabled) {
      87              :         return DBL_MAX;
      88              :     }
      89          753 :     switch (this->type) {
      90            0 :         case Element::ElementType::RESISTOR_traction_wire:
      91            0 :             return -1 * getVoltage() / resistance;
      92          753 :         case Element::ElementType::CURRENT_SOURCE_traction_wire:
      93              :         case Element::ElementType::VOLTAGE_SOURCE_traction_wire:
      94          753 :             return current;
      95              :         default:
      96              :             return 0;
      97              :     }
      98              : }
      99        11213 : double Element::getResistance() {
     100        11213 :     return this->resistance;
     101              : }
     102         2046 : double Element::getPowerWanted() {
     103         2046 :     return      this->powerWanted;
     104              : }
     105          191 : double Element::getPower() {
     106          191 :     return      -1 * getCurrent() * getVoltage();
     107              : }
     108         5803 : int Element::getId() {
     109              : 
     110         5803 :     return this->id;
     111              : }
     112         4405 : Node* Element::getPosNode() {
     113         4405 :     return this->pNode;
     114              : }
     115         1558 : Node* Element::getNegNode() {
     116         1558 :     return this->nNode;
     117              : }
     118              : 
     119         9926 : Element::ElementType Element::getType() {
     120         9926 :     return this->type;
     121              : }
     122         5754 : std::string Element::getName() {
     123         5754 :     return this->name;
     124              : }
     125              : 
     126          799 : void Element::setPosNode(Node* node) {
     127          799 :     this->pNode = node;
     128              : 
     129          799 : }
     130          424 : void Element::setNegNode(Node* node) {
     131          424 :     this->nNode = node;
     132          424 : }
     133           11 : void Element::setId(int newId) {
     134           11 :     this->id = newId;
     135           11 : }
     136              : 
     137              : // if node == pNode, return nNode, else if node == nNode return pNode, else return nullptr
     138        10430 : Node* Element::getTheOtherNode(Node* node) {
     139        10430 :     if (node == pNode) {
     140         6347 :         return nNode;
     141         4083 :     } else if (node == nNode) {
     142              :         return pNode;
     143              :     } else {
     144            0 :         return nullptr;
     145              :     }
     146              : }
     147              : 
     148         1946 : bool Element::isEnabled() {
     149         1946 :     return isenabled;
     150              : }
     151              : 
     152            0 : void Element::setEnabled(bool newIsEnabled) {
     153            0 :     this->isenabled = newIsEnabled;
     154            0 : }
     155              : 
     156            0 : void Element::setType(ElementType ET) {
     157            0 :     this->type = ET;
     158            0 : }