locomotive.h

Go to the documentation of this file.

//
// Created by Ahmed Aredah
// Version 0.0.1
//
 
#ifndef NeTrainSim_Locomotive_h
#define NeTrainSim_Locomotive_h
 
#include <functional>
#include <string>
#include <iostream>
#include "../util/vector.h"
#include "traintypes.h"
#include "energyconsumption.h"
#include "traincomponent.h"
 
using namespace std;
 
class Locomotive : public TrainComponent{
    /***********************************************
    *              variables declaration           *
    ************************************************/
private:
    inline static const  string DefaultLocomotiveName = "locomotive";
    static constexpr double DefaultLocomotiveMaxSpeed = 100.0 / 3.0;
    static constexpr double DefaultLocomotiveMaxAcheivableNotch = 0;
    static const int DefaultLocomotiveNoOfNotches = 8;
    static const int DefaultLocomotiveNoOfAxiles = 6;
    static const int DefaultLocomotiveType = 0;
    static constexpr double DefaultLocomotiveEmptyWeight = 180;
 
private:
    double maxTractiveForce = 0.0;
public:
    double maxPower;
    double currentTractiveForce = 0.0;
    double transmissionEfficiency;
    TrainTypes::PowerType powerType;
    TrainTypes::LocomotivePowerMethod hybridMethod;
    double maxSpeed;
 
    bool isLocOn = true;
    int Nmax = 8;
    int maxLocNotch = 0;
    int currentLocNotch = 0;
    double locPowerReductionFactor = 1.0;
    Vector<double> discritizedLamda;
    double throttleLevel;
    Vector<double> throttleLevels;
    const double g = 9.8067;
 
    double usedPowerPortion = 0.0;
 
 
    Locomotive(double locomotiveMaxPower_kw,
               double locomotiveTransmissionEfficiency,
               double locomotiveLength_m,
               double locomotiveDragCoef,
               double locomotiveFrontalArea_sqm,
               double locomotiveWeight_t,
               int locomotiveNoOfAxiles = DefaultLocomotiveNoOfAxiles,
               int locomotivePowerType = DefaultLocomotiveType,
               double locomotiveMaxSpeed_mps = DefaultLocomotiveMaxSpeed,
               int totalNotches = DefaultLocomotiveNoOfNotches,
               int locomotiveMaxAchievableNotch =
                                DefaultLocomotiveMaxAcheivableNotch,
               double locomotiveAuxiliaryPower_kw =
                                EC::DefaultLocomotiveAuxiliaryPower,
               string locomotiveName = DefaultLocomotiveName,
               double batteryMaxCharge_kwh =
                                std::numeric_limits<double>::quiet_NaN(), // NAN value should be resolved latter
               double batteryInitialCharge_perc =
                                std::numeric_limits<double>::quiet_NaN(), // NAN value should be resolved latter
               double tankMaxCapacity_kg =
                                EC::DefaultLocomotiveTankMaxCapacityDiesel,
               double tankInitialCapacity_perc =
                                EC::DefaultLocomotiveTankInitialCapacity,
               double batteryCRate =
                                EC::DefaultLocomotiveBatteryCRate,
               TrainTypes::LocomotivePowerMethod theHybridMethod =
                                TrainTypes::LocomotivePowerMethod::notApplicable);
 
 
    string getPowerTypeString();
 
    TrainTypes::PowerType getPowerTypeEnum(string powertype);
 
    double getHyperbolicThrottleCoef(double &trainSpeed);
 
    double getlamdaDiscretized(double &lamda);
 
    double getDiscretizedThrottleCoef(double& trainSpeed);
 
    double getThrottleLevel(double &trainSpeed, bool &optimize,
                            double &optimumThrottleLevel);
 
    double getResistance(double trainSpeed) override;
 
    double getTractiveForce(double &frictionCoef, double &trainSpeed,
        bool &optimize, double &optimumThrottleLevel);
 
    double getNetForce(double &frictionCoef, double &trainAcceleration,
        bool &optimize, double &optimumThrottleLevel);
 
    double getSharedVirtualTractivePower(double& trainSpeed,
                                         double& trainAcceleration,
                                         double& sharedWeight,
                                         double& sharedResistance);
 
    double getRegenerativeEffeciency(double &LocomotiveVirtualTractivePower,
                                     double &trainAcceleration,
                                     double &trainSpeed);
 
    double getEnergyConsumptionAtDCBus(double &LocomotiveVirtualTractivePower,
                                       double &trainAcceleration,
                                       double &trainSpeed, double &timeStep);
 
    double getEnergyConsumptionAtTank(double &LocomotiveVirtualTractivePower,
                                      double &trainSpeed,
                                      double EnergyConsumptionAtDCBus);
    double getEnergyConsumption(double& LocomotiveVirtualTractivePower,
                                double& acceleration, double& speed,
        double& timeStep);
 
 
 
    std::pair<bool,double> consumeFuel(double timeStep, double trainSpeed,
                                       double EC_kwh,
                                       double LocomotiveVirtualTractivePower =
                                        std::numeric_limits<double>::quiet_NaN(),
                                       double dieselConversionFactor =
                                        EC::DefaultDieselConversionFactor,
                                       double bioDieselConversionFactor =
                                        EC::DefaultBiodieselConversionFactor,
                                       double hydrogenConversionFactor =
                                        EC::DefaultHydrogenConversionFactor,
                                       double dieselDensity =
                                        EC::DefaultDieselDensity,
                                       double bioDieselDensity =
                                        EC::DefaultBioDieselDensity,
                                       double hydrogenDensity =
                                        EC::DefaultHydrogenDensity) override;
 
    double getMaxRechargeEnergy(double timeStep, double trainSpeed,
                                double LocomotiveVirtualTractivePower);
 
    double getUsedPowerPortion(double trainSpeed,
                               double LocomotiveVirtualTractivePower);
 
    void rechargeBatteryByMaxFlow(double timeStep, double trainSpeed,
                                  double powerPortion,
                                  double fuelConversionFactor,
                                  double fuelDensity,
                                  double LocomotiveVirtualTractivePower,
                                  std::function<std::pair<bool, double>(
                                           double, double, double)>
                                                    ConsumeFuelFunc);
 
    std::pair<bool, double> consumeEnergyFromHybridTechnology(
                                double timeStep,
                                double trainSpeed,
                                double powerPortion,
                                double EC_kwh,
                                double fuelConversionFactor,
                                double fuelDensity,
                                double LocomotiveVirtualTractivePower,
                                std::function<std::pair<bool, double>(
                                        double, double, double)>
                                                    ConsumeFuelFunc);
 
    Vector<double> defineThrottleLevels();
 
    void updateLocNotch(double &trainSpeed);
 
    void reducePower(double &reductionFactor);
 
    void resetPowerRestriction();
 
    double getMaxProvidedEnergy(double &timeStep);
 
    double canProvideEnergy(double &EC, double &timeStep);
 
    friend ostream& operator<<(ostream& ostr, Locomotive& stud);
};
 
 
 
#endif // !NeTrainSim_Locomotive_h