MSOverheadWire.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2002-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Overhead wires for Electric (equipped with elecHybrid device) vehicles (Overhead wire segments, overhead wire sections, traction substations)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <list>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <microsim/MSStoppingPlace.h>
#include <utils/common/Named.h>
#include <utils/vehicle/SUMOVehicle.h>
#include <utils/common/WrappingCommand.h>
#include <utils/traction_wire/Circuit.h>
 
// Resistivity of Cu is 1.69*10^-8 Ohm*m. A cross-section S of the overhead wire used in Pilsen is 150 mm^2. So the "resistivity/S" is 0.000113 Ohm/m.
const double WIRE_RESISTIVITY = (double)2 * 0.000113;
 
// Conversion macros
#define WATTHR2JOULE(_x) ((_x)*3600.0)
#define JOULE2WATTHR(_x) ((_x)/3600.0)
#define WATTHR2WATT(_x) ((_x)*3600.0/TS)
#define WATT2WATTHR(_x) ((_x)*TS/3600.0)
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSLane;
class MSBusStop;
class OptionsCont;
class MSDevice_ElecHybrid;
class MSTractionSubstation;
class Named;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSOverheadWire : public MSStoppingPlace {
public:
 
    MSOverheadWire(const std::string& overheadWireSegmentID, MSLane& lane, double startPos, double endPos,
                   bool voltageSource);
 
    ~MSOverheadWire();
 
    double getVoltage() const;
 
    void setVoltage(double voltage);
 
    void setChargingVehicle(bool value);
 
    bool vehicleIsInside(const double position) const;
 
    bool isCharging() const;
 
    void addVehicle(SUMOVehicle& veh);
 
    void eraseVehicle(SUMOVehicle& veh);
 
    int getElecHybridCount() const {
        return (int)myChargingVehicles.size();
    }
 
    const std::vector<SUMOVehicle*>& getChargingVehicles() const {
        return myChargingVehicles;
    }
 
    double getTotalCharged() const {
        return myTotalCharge;
    }
 
    void addChargeValueForOutput(double WCharged, MSDevice_ElecHybrid* elecHybrid, bool ischarging = 1);
 
    void writeOverheadWireSegmentOutput(OutputDevice& output);
 
    std::string getOverheadWireSegmentName();
 
    MSTractionSubstation* getTractionSubstation() const {
        return myTractionSubstation;
    }
 
    void setTractionSubstation(MSTractionSubstation* substation) {
        myTractionSubstation = substation;
    }
 
    Circuit* getCircuit() const;
 
    void setCircuitStartNodePos(Node* node) {
        myCircuitStartNodePos = node;
    }
 
    void setCircuitEndNodePos(Node* node) {
        myCircuitEndNodePos = node;
    }
 
    void setCircuitElementPos(Element* element) {
        myCircuitElementPos = element;
    }
 
    Node* getCircuitStartNodePos() const {
        return myCircuitStartNodePos;
    }
 
    Node* getCircuitEndNodePos() const {
        return myCircuitEndNodePos;
    }
 
    Element* getCircuitElementPos() const {
        return myCircuitElementPos;
    }
 
    bool isThereVoltageSource() const {
        return myVoltageSource;
    }
 
    void lock() const;
    void unlock() const;
 
protected:
 
    struct Charge {
        Charge(SUMOTime _timeStep, std::string _vehicleID, std::string _vehicleType, std::string _status,
               double _WCharged, double _actualBatteryCapacity, double _maxBatteryCapacity, double _voltage,
               double _totalEnergyCharged) :
            timeStep(_timeStep),
            vehicleID(_vehicleID),
            vehicleType(_vehicleType),
            status(_status),
            WCharged(_WCharged),
            actualBatteryCapacity(_actualBatteryCapacity),
            maxBatteryCapacity(_maxBatteryCapacity),
            voltage(_voltage),
            totalEnergyCharged(_totalEnergyCharged) {}
 
        // @brief vehicle TimeStep
        SUMOTime timeStep;
        // @brief vehicle ID
        std::string vehicleID;
        // @brief vehicle Type
        std::string vehicleType;
        std::string status;
        // @brief W charged
        double WCharged;
        // @brief actual battery capacity AFTER charging
        double actualBatteryCapacity;
        // @brief battery max capacity
        double maxBatteryCapacity;
        // @brief current charging power of charging station
        double voltage;
        // @brief current efficiency of charging station
        double chargingEfficiency;
        // @brief current energy charged by charging stations AFTER charging
        double totalEnergyCharged;
    };
 
    class vehicle_position_sorter {
    public:
        explicit vehicle_position_sorter() { }
 
        int operator()(SUMOVehicle* v1, SUMOVehicle* v2) {
            return v1->getPositionOnLane() > v2->getPositionOnLane();
        }
    };
 
    void static writeVehicle(OutputDevice& out, const std::vector<Charge>& chargeSteps, int iStart, int iEnd, double charged);
 
    double myVoltage;
 
    bool myChargingVehicle;
 
    double myTotalCharge;
 
    std::map<std::string, std::vector<Charge> > myChargeValues;
    std::vector<std::string> myChargedVehicles;
 
    std::vector<SUMOVehicle*> myChargingVehicles;
 
    MSTractionSubstation* myTractionSubstation;
 
    bool myVoltageSource;
 
    Element* myCircuitElementPos;
    Node* myCircuitStartNodePos;
    Node* myCircuitEndNodePos;
 
private:
    MSOverheadWire(const MSOverheadWire&);
 
    MSOverheadWire& operator=(const MSOverheadWire&);
};
 
 
class MSTractionSubstation : public Named {
public:
 
    MSTractionSubstation(const std::string& substationId, double voltage, double currentLimit);
 
    ~MSTractionSubstation();
 
    Circuit* getCircuit() const {
        return myCircuit;
    }
    void addOverheadWireSegmentToCircuit(MSOverheadWire* newOverheadWireSegment);
 
    void addOverheadWireClampToCircuit(const std::string id, MSOverheadWire* startSegment, MSOverheadWire* endSegment);
 
    void eraseOverheadWireSegmentFromCircuit(MSOverheadWire* oldWireSegment);
 
    void writeOut();
    std::size_t numberOfOverheadSegments() const {
        return myOverheadWireSegments.size();
    }
 
    void setChargingVehicle(bool value);
 
    bool isCharging() const;
 
    void increaseElecHybridCount();
 
    void decreaseElecHybridCount();
 
    void addForbiddenLane(MSLane* lane);
 
    bool isForbidden(const MSLane* lane);
 
    void addClamp(const std::string& id, MSOverheadWire* startPos, MSOverheadWire* endPos);
 
    int getElecHybridCount() const {
        return myElecHybridCount;
    }
 
    void addVehicle(MSDevice_ElecHybrid* elecHybrid);
 
    void eraseVehicle(MSDevice_ElecHybrid* elecHybrid);
 
    double getSubstationVoltage() const {
        return mySubstationVoltage;
    }
 
    bool isAnySectionPreviouslyDefined();
 
    void addSolvingCircuitToEndOfTimestepEvents();
    SUMOTime solveCircuit(SUMOTime currentTime);
 
    void addChargeValueForOutput(double energy, double current, double alpha, Circuit::alphaFlag alphaReason);
 
    void writeTractionSubstationOutput(OutputDevice& output);
 
protected:
    struct chargeTS {
        chargeTS(SUMOTime _timeStep, std::string _substationID, std::string _vehicleIDs, double _energy,
                 double _current, std::string _currentsString, double _voltage, std::string _status,
                 int _numVehicle, int _numVoltageSources, double _alpha, Circuit::alphaFlag _alphaReason) :
            timeStep(_timeStep),
            substationID(_substationID),
            vehicleIDs(_vehicleIDs),
            energy(_energy),
            current(_current),
            currentsString(_currentsString),
            voltage(_voltage),
            status(_status),
            numVehicles(_numVehicle),
            numVoltageSources(_numVoltageSources),
            alpha(_alpha),
            alphaReason(_alphaReason) {}
 
        // @brief vehicle TimeStep
        SUMOTime timeStep;
        // @brief substation ID
        std::string substationID;
        // @brief vehicle IDs
        std::string vehicleIDs;
        // @brief total power from voltage sources
        double energy;
        //@brief total current through voltage sources
        double current;
        // @brief list of all voltage currents
        std::string currentsString;
        //@brief voltage of voltage sources
        double voltage;
        std::string status;
        //@brief number of vehicles connected to the circuit
        int numVehicles;
        //@brief number of votlage sources connected to the section
        int numVoltageSources;
        //@brief best alpha scaling value
        double alpha;
        Circuit::alphaFlag alphaReason;
    };
    std::vector<chargeTS> myChargeValues;
 
public:
    //preparation of overhead wire clamp
    struct OverheadWireClamp {
        // @todo: 'MSTractionSubstation::overheadWireClamp' : no appropriate default constructor available
        // provide default constructor for vector construction below
        OverheadWireClamp() :
            id("undefined"),
            start(nullptr),
            end(nullptr),
            usage(false) {}
 
        OverheadWireClamp(const std::string _id, MSOverheadWire* _start, MSOverheadWire* _end, bool _usage):
            id(_id),
            start(_start),
            end(_end),
            usage(_usage) {}
 
        const std::string id;
        MSOverheadWire* start;
        MSOverheadWire* end;
        bool usage;
    };
 
    OverheadWireClamp* findClamp(std::string id);
 
private:
    void addOverheadWireInnerSegmentToCircuit(MSOverheadWire* incomingSegment, MSOverheadWire* outgoingSegment,
            const MSLane* connection, const MSLane* frontConnection, const MSLane* behindConnection);
 
protected:
    bool myChargingVehicle;
    int myElecHybridCount;
 
private:
    double mySubstationVoltage;
    Circuit* myCircuit;
    std::vector<MSOverheadWire*> myOverheadWireSegments;
    std::vector<MSDevice_ElecHybrid*> myElecHybrid;
    std::vector<MSLane*> myForbiddenLanes;
    static Command* myCommandForSolvingCircuit;
    double myTotalEnergy;
 
    // RICE_TODO: Does this cause the "'MSTractionSubstation::overheadWireClamp' : no appropriate default
    // constructor available" error in MSVC2013?
    // This is probably an issue with gitHub build chain
    std::vector<OverheadWireClamp> myOverheadWireClamps;
 
};