MSChargingStation.h

Go to the documentation of this file.

/****************************************************************************/
// Chargin Station for Electric vehicles
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef MSChargingStation_h
#define MSChargingStation_h

// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#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 definitions
// ===========================================================================
class MSChargingStation : public MSStoppingPlace {
public:

    MSChargingStation(const std::string& chargingStationID, MSLane& lane, double startPos, double endPos,
                      double chargingPower, double efficency, bool chargeInTransit, int chargeDelay);

    ~MSChargingStation();

    double getChargingPower() const;

    double getEfficency() const;

    bool getChargeInTransit() const;

    double getChargeDelay() const;

    void setChargingPower(double chargingPower);

    void setEfficency(double efficency);

    void setChargeInTransit(bool chargeInTransit);

    void setChargeDelay(int chargeDelay);

    void setChargingVehicle(bool value);

    bool vehicleIsInside(const double position) const;

    bool isCharging() const;

    void addChargeValueForOutput(double WCharged, MSDevice_Battery* battery);

    void writeChargingStationOutput(OutputDevice& output);

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;
    };

    double myChargingPower;

    double myEfficiency;

    bool myChargeInTransit;

    int myChargeDelay;

    bool myChargingVehicle;

    double myTotalCharge;

    std::vector<charge> myChargeValues;

private:
    MSChargingStation(const MSChargingStation&);

    MSChargingStation& operator=(const MSChargingStation&);
};

#endif