MSChargingStation.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 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
/****************************************************************************/
// Charging Station for Electric vehicles
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <list>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <microsim/MSStoppingPlace.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSLane;
class MSBusStop;
class OptionsCont;
class MSDevice_Battery;
class Command;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSChargingStation : public MSStoppingPlace {
 
public:
    enum ChargeType {
        CHARGETYPE_NORMAL = 0,
        CHARGETYPE_BATTERYEXCHANGE,
        CHARGETYPE_FUEL
    };
 
    static inline std::string chargeTypeToString(ChargeType type) {
        if (type == CHARGETYPE_NORMAL) {
            return "normal";
        } else if (type == CHARGETYPE_BATTERYEXCHANGE) {
            return "battery-exchange";
        } else if (type == CHARGETYPE_FUEL) {
            return "fuel";
        } else {
            WRITE_WARNING(TL("Encountered an unknown charge type. Assuming charge type 'normal'."));
            return "normal";
        }
    }
 
    static inline ChargeType stringToChargeType(const std::string& repr) {
        if (repr == "normal") {
            return ChargeType::CHARGETYPE_NORMAL;
        } else if (repr == "battery-exchange") {
            return ChargeType::CHARGETYPE_BATTERYEXCHANGE;
        } else if (repr == "fuel") {
            return ChargeType::CHARGETYPE_FUEL;
        } else {
            WRITE_WARNINGF("Encountered an unknown charge type string '%'. Assuming charge type 'normal'.", repr);
            return ChargeType::CHARGETYPE_NORMAL;
        }
    }
 
public:
 
    MSChargingStation(const std::string& chargingStationID, MSLane& lane, double startPos, double endPos,
                      const std::string& name, double chargingPower, double totalPower, double efficency, bool chargeInTransit,
                      SUMOTime chargeDelay, const std::string& chargeType, SUMOTime waitingTime);
 
    MSChargingStation(const std::string& chargingStationID, const MSParkingArea* parkingArea, const std::string& name, double chargingPower,
                      double totalPower, double efficency, bool chargeInTransit, SUMOTime chargeDelay, const std::string& chargeType,
                      SUMOTime waitingTime);
 
    ~MSChargingStation();
 
    double getChargingPower(bool usingFuel) const;
 
    double getEfficency() const;
 
    bool getChargeInTransit() const;
 
    SUMOTime getChargeDelay() const;
 
    ChargeType getChargeType() const;
 
    SUMOTime getWaitingTime() const;
 
    const MSParkingArea* getParkingArea() const;
 
    void setChargingPower(double chargingPower);
 
    void setEfficiency(double efficiency);
 
    void setChargeDelay(SUMOTime delay);
 
    void setChargeInTransit(bool value);
 
    void setChargingVehicle(bool value);
 
    SUMOTime checkTotalPower(SUMOTime currentTime);
 
    bool vehicleIsInside(const double position) const;
 
    bool isCharging() const;
 
    double getTotalCharged() const {
        return myTotalCharge;
    }
 
    void addChargeValueForOutput(double WCharged, MSDevice_Battery* battery);
 
    void writeChargingStationOutput(OutputDevice& output);
 
    void writeAggregatedChargingStationOutput(OutputDevice& output, bool includeUnfinished = false);
 
protected:
 
    struct Charge {
        Charge(SUMOTime _timeStep, std::string _vehicleID, std::string _vehicleType, std::string _status,
               double _WCharged, double _actualBatteryCapacity, double _maxBatteryCapacity, double _chargingPower,
               double _chargingEfficiency, double _totalEnergyCharged) :
            timeStep(_timeStep),
            vehicleID(_vehicleID),
            vehicleType(_vehicleType),
            status(_status),
            WCharged(_WCharged),
            actualBatteryCapacity(_actualBatteryCapacity),
            maxBatteryCapacity(_maxBatteryCapacity),
            chargingPower(_chargingPower),
            chargingEfficiency(_chargingEfficiency),
            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 chargingPower;
        // @brief current efficiency of charging station
        double chargingEfficiency;
        // @brief current energy charged by charging stations AFTER charging
        double totalEnergyCharged;
    };
 
    static void writeVehicle(OutputDevice& out, const std::vector<Charge>& chargeSteps, int iStart, int iEnd, double charged);
 
    double myNominalChargingPower = 0;
 
    double myTotalChargingPower = 0;
 
    double myEfficiency = 0;
 
    bool myChargeInTransit;
 
    SUMOTime myChargeDelay = 0;
 
    const ChargeType myChargeType;
 
    SUMOTime myWaitingTime = 0;
 
    bool myChargingVehicle = false;
 
    double myTotalCharge = 0;
 
    const MSParkingArea* myParkingArea = nullptr;
 
    std::map<std::string, std::vector<Charge> > myChargeValues;
    std::vector<std::string> myChargedVehicles;
 
    std::map<std::string, MSDevice_Battery*> myChargedBatteries;
 
    Command* myTotalPowerCheckEvent;
 
 
private:
    MSChargingStation(const MSChargingStation&) = delete;
 
    MSChargingStation& operator=(const MSChargingStation&) = delete;
};