PHEMCEP.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2013-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
/****************************************************************************/
// Helper class for PHEM Light, holds a specific CEP for a PHEM emission class
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/StringBijection.h>
#include "PHEMConstants.h"
 
 
 
// ===========================================================================
// enumerations
// ===========================================================================
enum NormalizingType {
    RatedPower,
    DrivingPower
};
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class PHEMCEP {
public:
    /*** @brief Constructor
     * @param[in] emissionClass PHEM emission class of vehicle
     * @param[in] vehicleMass vehicle mass
     * @param[in] vehicleLoading vehicle loading
     * @param[in] vehicleMassRot rotational mass of vehicle
     * @param[in] crossArea crosssectional area of vehicle
     * @param[in] cWValue cw-value
     * @param[in] f0 Rolling resistance f0
     * @param[in] f1 Rolling resistance f1
     * @param[in] f2 Rolling resistance f2
     * @param[in] f3 Rolling resistance f3
     * @param[in] f4 Rolling resistance f4
     * @param[in] ratedPower rated power of vehicle
     * @param[in] pNormV0 out variable for step function to get maximum normalized rated power over speed
     * @param[in] pNormP0 out variable for step function to get maximum normalized rated power over speed
     * @param[in] pNormV1 out variable for step function to get maximum normalized rated power over speed
     * @param[in] pNormP1 out variable for step function to get maximum normalized rated power over speed
     * @param[in] vehicleFuelType out variable for fuel type (D, G) of vehicle, needed for density of fuel
     * @param[in] matrixFC Coefficients of the fuel consumption
     * @param[in] headerLine Definition of covered pollutants
     * @param[in] headerLinePollutants Coefficients of the pollutants
     * @param[in] matrixPollutants Coefficients of the pollutants
     * @param[in] matrixSpeedRotational Table for rotational coefficients over speed
     */
    PHEMCEP(bool heavyVehicel, SUMOEmissionClass emissionClass, const std::string& emissionClassIdentifier,
            double vehicleMass, double vehicleLoading, double vehicleMassRot,
            double crossArea, double cdValue,
            double f0, double f1, double f2, double f3, double f4,
            double ratedPower, double pNormV0, double pNormP0, double pNormV1, double pNormP1,
            double axleRatio, double engineIdlingSpeed, double engineRatedSpeed, double effectiveWheelDiameter,
            double idlingFC,
            const std::string& vehicleFuelType,
            const std::vector< std::vector<double> >& matrixFC,
            const std::vector<std::string>& headerLinePollutants,
            const std::vector< std::vector<double> >& matrixPollutants,
            const std::vector< std::vector<double> >& matrixSpeedRotational,
            const std::vector< std::vector<double> >& normedDragTable,
            const std::vector<double>& idlingValuesPollutants);
 
    ~PHEMCEP();
 
    double CalcPower(double v, double a, double slope, double vehicleLoading = 0) const;
 
 
    double GetMaxAccel(double v, double a, double gradient, double vehicleLoading = 0) const;
 
    double GetEmission(const std::string& pollutantIdentifier, double power, double speed, bool normalized = false) const;
    double GetDecelCoast(double speed, double acc, double gradient, double vehicleLoading) const;
 
 
    SUMOEmissionClass GetEmissionClass() const {
        return _emissionClass;
    }
 
 
    double GetResistanceF0() const {
        return _resistanceF0;
    }
 
 
    double GetResistanceF1() const {
        return _resistanceF1;
    }
 
 
    double GetResistanceF2() const {
        return _resistanceF2;
    }
 
 
    double GetResistanceF3() const {
        return _resistanceF3;
    }
 
 
    double GetResistanceF4() const {
        return _resistanceF4;
    }
 
 
    double GetCdValue() const {
        return _cdValue;
    }
 
    double GetCrossSectionalArea() const {
        return _crossSectionalArea;
    }
 
 
    double GetMassVehicle() const {
        return _massVehicle;
    }
 
    double GetVehicleLoading() const {
        return _vehicleLoading;
    }
 
 
    double GetMassRot() const {
        return _massRot;
    }
 
 
    double GetRatedPower() const {
        return _ratedPower;
    }
 
    const std::string& GetVehicleFuelType() const {
        return _vehicleFuelType;
    }
 
private:
    double Interpolate(double px, double p1, double p2, double e1, double e2) const;
 
    void FindLowerUpperInPattern(int& lowerIndex, int& upperIndex, const std::vector<double>& pattern, double value) const;
 
    double GetRotationalCoeffecient(double speed) const;
    double GetGearCoeffecient(double speed) const;
    double GetDragCoeffecient(double nNorm) const;
 
    double GetPMaxNorm(double speed) const;
 
private:
    SUMOEmissionClass _emissionClass;
    NormalizingType _normalizingType;
    double _resistanceF0;
    double _resistanceF1;
    double _resistanceF2;
    double _resistanceF3;
    double _resistanceF4;
    double _cdValue;
    double _crossSectionalArea;
    double _massVehicle;
    double _vehicleLoading;
    double _massRot;
    double _ratedPower;
    double _pNormV0;
    double _pNormP0;
    double _pNormV1;
    double _pNormP1;
    double _axleRatio;
    double _engineIdlingSpeed;
    double _engineRatedSpeed;
    double _effictiveWheelDiameter;
    double _idlingFC;
    std::string _vehicleFuelType;
    int _sizeOfPatternFC;
    int _sizeOfPatternPollutants;
    double _normalizingPower;
    double _drivingPower;
    bool _heavyVehicle;
    std::vector<double> _speedPatternRotational;
    std::vector<double> _powerPatternFC;
    std::vector<double> _powerPatternPollutants;
    std::vector<double> _normalizedPowerPatternFC;
    std::vector<double> _normailzedPowerPatternPollutants;
    std::vector<double> _cepCurveFC;
    std::vector<double> _normedCepCurveFC;
    std::vector<double> _speedCurveRotational;
    std::vector<double> _gearTransmissionCurve;
    std::vector<double> _nNormTable;
    std::vector<double> _dragNormTable;
    StringBijection< std::vector<double> > _cepCurvePollutants;
    StringBijection<std::vector<double> > _normalizedCepCurvePollutants;
    StringBijection<double> _idlingValuesPollutants;
 
};