train.h

Go to the documentation of this file.

//
// Created by Ahmed Aredah
// Version 0.1
//
 
#ifndef NeTrainSim_Train_h
#define NeTrainSim_Train_h
 
 
#include <iostream>
#include "../util/vector.h"
#include "car.h"
#include "locomotive.h"
#include "../util/map.h"
#include "qobject.h"
#include <utility>
#include <variant>
 
class NetNode;
 
class NetLink;
using namespace std;
 
class Train : public QObject {
    Q_OBJECT
    /***********************************************
    *              variables declaration           *
    ************************************************/
 
private:
    static unsigned int NumberOfTrainsInSimulator;
    static constexpr double DefaultDesiredDecelerationRate = 0.2;
    static constexpr double DefaultOperatorReactionTime = 1.0;
    static constexpr bool DefaultStopIfNoEnergy = false;
    static constexpr double DefaultMaxAllowedJerk = 2.0;
    static constexpr double DefaultMinFollowingGap = 2.0;
    static constexpr int DefaultLookAheadCounterToUpdate = 1;
    static constexpr int DefaultLookAheadCounter = 1;
 
public:
 
    static constexpr double speedOfSound = 343.0;
    const double g = 9.8066;
    double d_des;
    double operatorReactionTime;
    double totalLength;
    double totalMass;
    double totalEmptyMass = 0;
 
    double coefficientOfFriction = 0.9;
    double maxJerk = 2.0;
    double T_s;
    double trainStartTime;
    double tripTime;
    double trainTotalPathLength;
    double travelledDistance;
    double virtualTravelledDistance;
    double currentSpeed;
    double previousSpeed;
    double averageSpeed;
    double currentAcceleration;
    double previousAcceleration;
    double averageAcceleration;
    double currentTractiveForce;
    double currentResistanceForces;
    double currentUsedTractivePower;
    double cumUsedTractivePower;
    double optimumThrottleLevel;
    double energyStat;
    double cumEnergyStat;
    double totalEConsumed;
    double totalERegenerated;
    double delayTimeStat;
    double cumDelayTimeStat;
    double maxDelayTimeStat;
    double cumMaxDelayTimeStat;
    double stoppedStat;
    double cumStoppedStat;
    double waitedTimeAtNode;
 
    pair<double, double> currentCoordinates;
 
 
    std::shared_ptr<NetLink> currentFirstLink;
    Map<std::shared_ptr<TrainComponent>, double> WeightCentroids;
    Map<int, double> LinkGradeDirection;
    Map<TrainTypes::CarType, Vector<std::shared_ptr<Car>>> carsTypes;
    Map<TrainTypes::CarType, Vector<std::shared_ptr<Car>>> ActiveCarsTypes;
    Map<string, double> cumRegionalConsumedEnergyStat;
 
 
    Vector<std::shared_ptr<Car>> cars;
    Vector<std::shared_ptr<Locomotive>> locomotives;
    Vector<int> trainPath;
    Vector<std::shared_ptr<NetNode>> trainPathNodes;
    Vector<std::shared_ptr<NetLink>> currentLinks;
    Vector<Vector<double>> betweenNodesLengths;
    Vector<double> linksCumLengths;
    Vector<Vector<Map<int, double>>> LowerSpeedNodeIDs;
    Vector<pair<double, double>> startEndPoints;
    Vector<std::shared_ptr<NetLink>> previousLinks;
    Vector < std::shared_ptr<TrainComponent>> trainVehicles;
    Vector<std::shared_ptr<Locomotive>> ActiveLocos;
    Vector<double> currentUsedTractivePowerList;
    Vector<double> throttleLevels;
 
    string trainUserID;
 
    Vector<bool> trainStoppingStations;
 
 
    int nCars = 0;
    int nlocs = 0;
    int id;
    int previousNodeID;
    int LastTrainPointpreviousNodeID;
    int nextNodeID;
    int NoPowerCountStep;
    int lookAheadStepCounter;
    int lookAheadCounterToUpdate;
 
 
    bool stopTrainIfNoEnergy;
    bool isOn;
    bool offloaded = false;
    bool reachedDestination = false;
    bool outOfEnergy = false;
    bool loaded = false;
    bool optimize;
 
 
    Train(int simulatorID, string id, Vector<int> trainPath, double trainStartTime_sec, double frictionCoeff,
          Vector<std::shared_ptr<Locomotive>> locomotives, Vector<std::shared_ptr<Car>> cars, bool optimize,
          double desiredDecelerationRate_mPs = DefaultDesiredDecelerationRate,
          double operatorReactionTime_s = DefaultOperatorReactionTime,
          bool stopIfNoEnergy = DefaultStopIfNoEnergy,
          double maxAllowedJerk_mPcs = DefaultMaxAllowedJerk);
 
    ~Train();
 
    void setTrainSimulatorID(int newID);
 
    bool rechargeCarsBatteries(double timeStep, double EC_kwh, std::shared_ptr<Locomotive> &loco);
 
    Map<string, double> getTrainConsumedTank();
 
    void setTrainPath(Vector<int> path);
    static unsigned int getNumberOfTrainsInSimulator();
 
 
    double getMinFollowingTrainGap();
 
    void setTrainsCurrentLinks(Vector<std::shared_ptr<NetLink> > newLinks);
    double getCargoNetWeight();
 
    Map<TrainTypes::PowerType, int> LocTypeCount();
 
    Map<TrainTypes::CarType, int> carTypeCount();
    Map < std::shared_ptr<TrainComponent>, double> getTrainCentroids();
 
    int getActiveLocomotivesNumber();
 
    double getBatteryEnergyConsumed();
    double getBatteryEnergyRegenerated();
 
    double getBatteryNetEnergyConsumed();
 
    double getAverageLocomotivesBatteryStatus();
 
    double getAverageLocomotiveTankStatus();
 
    double getAverageTendersTankStatus();
 
    double getAverageTendersBatteryStatus();
 
 
    double getTrainTotalTorque();
 
    double getAverageTendersStatus();
    //void setCars(Vector<Car> cars);
    //void setLocomotives(Vector<Locomotive> locomotives);
 
    void setTrainLength();
 
    void setTrainWeight();
 
    void resetTrain();
 
    void rearrangeTrain();
 
    void updateGradesCurvatures(Vector<double> &LocsCurvature, Vector<double> &LocsGrade, 
        Vector<double> &CarsCurvature, Vector<double> &CarsGrade);
 
    void updateGradesCurvatures(const Vector<double> &trainGrade, const Vector<double> &trainCurvature);
 
    double getTotalTractiveForce(double speed, double acceleration, bool optimize, double optimumThrottleLevel);
 
    double getTotalResistance(double speed);
 
    double getAccelerationUpperBound(double speed, double acceleration, double freeFlowSpeed, 
        bool optimize, double optimumThrottleLevel);
 
    double getSafeGap(double initialGap, double speed, double freeFlowSpeed, double T_s, bool estimate);
 
    double getNextTimeStepSpeed(double gap, double minGap, double speed, double freeFlowSpeed, 
        double aMax, double T_s, double deltaT);
 
    double getTimeToCollision(double gap, double minGap, double speed, double leaderSpeed);
 
    double accelerate(double gap, double mingap, double speed, double acceleration, double leaderSpeed,
        double freeFlowSpeed, double deltaT, bool optimize, double throttleLevel = -1);
 
    double accelerateConsideringJerk(double acceleration, double previousAcceleration, double jerk, double deltaT);
 
    double smoothAccelerate(double acceleration, double previousAccelerationValue, double alpha = 0.2);
 
    double speedUpDown(double previousSpeed, double acceleration, double deltaT, double freeFlowSpeed);
 
    double adjustAcceleration(double speed, double previousSpeed, double deltaT);
 
    void checkSuddenAccChange(double previousAcceleration, double currentAcceleration, double deltaT);
 
    double getStepAcceleration(double timeStep, double freeFlowSpeed, Vector<double>& gapToNextCriticalPoint,
                                         Vector<bool> &gapToNextCriticalPointType, Vector<double>& leaderSpeed);
 
    void moveTrain(double timeStep, double freeFlowSpeed, Vector<double>& gapToNextCriticalPoint,
        Vector<bool>& gapToNextCriticalPointType, Vector<double>& leaderSpeed);
 
    pair<Vector<double>, double> getTractivePower(double speed, double acceleration, double resistanceForces);
 
    void updateLocNotch();
 
    void immediateStop(double timeStep);
 
    void kickForwardADistance(double& distance);
 
    double getEnergyConsumption(double timeStep);
 
    void calculateEnergyConsumption(double timeStep, std::string currentRegion);
 
    double getTotalEnergyConsumption(double& timeStep, Vector<double>& usedTractivePower);
 
    bool consumeEnergy(double& timeStep, double trainSpeed, Vector<double>& usedTractivePower);
 
    void resetTrainEnergyConsumption();
 
    std::pair<bool, double> consumeTendersEnergy(double timeStep, double trainSpeed, double EC_kwh, TrainTypes::PowerType powerType,
                              double dieselConversionFactor = EC::DefaultDieselConversionFactor,
                              double hydrogenConversionFactor = EC::DefaultHydrogenConversionFactor,
                              double dieselDensity = EC::DefaultDieselDensity);
 
    Vector<std::shared_ptr<Car>>  getActiveTanksOfType(TrainTypes::CarType cartype);
 
    int getRechargableCarsNumber();
 
    int getRechargableLocsNumber();
 
    tuple<double, double, double> AStarOptimization(double prevSpeed, double currentSpeed, double currentAcceleration,
                                                         double prevThrottle, Vector<double> vector_grade,
                                                         Vector<double> vector_curvature, double freeSpeed_ms,
                                                         double timeStep, Vector<double> u_leader,
                                                         Vector<double> gapToNextCriticalPoint);
 
    double heuristicFunction(double distanceToEnd, double stepAcceleration, double stepSpeed,
                                    double timeStep, double resistance, double currentSpeed);
 
    double pickOptimalThrottleLevelAStar(Vector<double> throttleLevels, int lookAheadCounterToUpdate);
 
// ##################################################################
// #                  start: statistics calculations                #
// ##################################################################
 
    void calcTrainStats(Vector<double> listOfLinksFreeFlowSpeeds, double MinFreeFlow, double timeStep, std::string currentRegion);
 
    double calculateAverage(double previousAverage, double currentTimeStepData, double timeStep);
 
    double getDelayTimeStat(double freeflowSpeed, double timeStep);
 
    double getMaxDelayTimeStat(Vector<double> listOfLinksFreeFlowSpeeds, double timeStep);
 
    double getStoppingTimeStat(Vector<double> listOfLinksFreeFlowSpeeds);
 
    void resetTrainLookAhead();
 
    std::pair<double, Map<TrainTypes::PowerType, double>> getMaxProvidedEnergy(double &timeStep);
 
    bool canProvideEnergy(double &EC, double &timeStep);
 
    void reducePower(double &reductionFactor);
 
    void resetPowerRestriction();
 
// ##################################################################
// #                    end: statistics calculations                #
// ##################################################################
 
    friend ostream& operator<<(ostream& ostr, Train& train);
 
    private:
 
        double get_acceleration_an11(double u_hat, double speed, double TTC_s, double frictionCoef);
 
        double get_acceleration_an12(double u_hat, double speed, double T_s, double amax);
 
        double get_beta1(double an11);
 
        double get_acceleration_an13(double beta1, double an11, double an12);
 
        double get_acceleration_an14(double speed, double leaderSpeed, double T_s, double amax, double frictionCoef);
 
        double get_beta2();
 
        double get_acceleration_an1(double beta2, double an13, double an14);
 
        double get_gamma(double speedDiff);
 
        Map<TrainTypes::PowerType, double> getMaxProvidedEnergyFromLocomotivesOnly(double &timeStep);
 
        Map<TrainTypes::PowerType, double> getMaxProvidedEnergyFromTendersOnly(Map<TrainTypes::PowerType, double> EC,
                                                                               double &timeStep);
        Map<TrainTypes::CarType, double> canProvideEnergyFromLocomotivesOnly(double &EC, double &timeStep);
 
        bool canProvideEnergyFromTendersOnly(Map<TrainTypes::CarType, double> &EC, double &timeStep);
 
        double get_acceleration_an2(double gap, double minGap, double speed, double leaderSpeed, double T_s, double frictionCoef);
 
    public:
    signals:
 
        void suddenAccelerationOccurred(std::string msg);
 
        void slowSpeedOrStopped(std::string msg);
 
};
 
#endif // !NeTrainSim_Train_h