Path: blob/main/src/foreign/PHEMlight/dll_code/CEPHandler.cs
169684 views
#define FLEET
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Globalization;
namespace PHEMlightdll
{
public class CEPHandler
{
//--------------------------------------------------------------------------------------------------
// Constructors
//--------------------------------------------------------------------------------------------------
#region Constructor
public CEPHandler()
{
_ceps = new Dictionary<string, CEP>();
}
#endregion
//--------------------------------------------------------------------------------------------------
// Members
//--------------------------------------------------------------------------------------------------
#region CEPS
private Dictionary<string, CEP> _ceps;
public Dictionary<string, CEP> CEPS
{
get
{
return _ceps;
}
}
#endregion
#if FLEET
#region FleetShares
private Dictionary<string, Dictionary<string, double>> _fleetShares;
public Dictionary<string, Dictionary<string, double>> FleetShares
{
get
{
return _fleetShares;
}
}
#endregion
#endif
//--------------------------------------------------------------------------------------------------
// Methods
//--------------------------------------------------------------------------------------------------
#region GetCEP
public bool GetCEP(string DataPath, Helpers Helper)
{
if (!CEPS.ContainsKey(Helper.gClass))
{
if (!Load(DataPath, Helper))
{
return false;
}
}
return true;
}
#endregion
#if FLEET
#region GetFleetCEP
public bool GetFleetCEP(string DataPath, string AggClass, Helpers Helper)
{
if (!CEPS.ContainsKey(Helper.gClass))
{
if (Constants.AGGREGATED_VEHICLECLASSES.Contains(AggClass))
{
List<CEP> weightedCEPS = new List<CEP>();
if (FleetShares.ContainsKey(AggClass))
{
foreach (string aggVehClass in FleetShares[AggClass].Keys)
{
if (!Helper.setclass(aggVehClass))
{
return false;
}
if (!CEPS.ContainsKey(aggVehClass) && !Load(DataPath, Helper))
{
return false;
}
weightedCEPS.Add(CEPS[aggVehClass] * FleetShares[AggClass][aggVehClass]);
}
_ceps.Add(AggClass, CEP.AddRangeCeps(weightedCEPS.ToArray(), Helper));
//Set the vehicle class back
Helper.gClass = AggClass;
}
else
{
Helper.ErrMsg = "The aggregated vehicle class (" + AggClass + ") is not available in the FleetShare file!";
return false;
}
}
else
{
Helper.ErrMsg = "The aggregated vehicle class (" + AggClass + ") is a unknown class!";
return false;
}
}
return true;
}
#endregion
#endif
//--------------------------------------------------------------------------------------------------
// Methods
//--------------------------------------------------------------------------------------------------
#region Load
private bool Load(string DataPath, Helpers Helper)
{
//Deklaration
// get string identifier for PHEM emission class
string emissionRep = Helper.gClass.ToString();
// to hold everything.
List<List<double>> matrixSpeedInertiaTable;
List<List<double>> normedTragTableSpeedInertiaTable;
List<List<double>> matrixFC;
List<List<double>> matrixPollutants;
List<double> idlingValuesFC;
List<double> idlingValuesPollutants;
List<string> headerFC;
List<string> headerPollutants;
double vehicleMass;
double vehicleLoading;
double vehicleMassRot;
double crosssectionalArea;
double cwValue;
double f0;
double f1;
double f2;
double f3;
double f4;
double axleRatio;
List<double> transmissionGearRatios;
double auxPower;
double ratedPower;
double engineIdlingSpeed;
double engineRatedSpeed;
double effectiveWhellDiameter;
string vehicleMassType;
string vehicleFuelType;
double pNormV0;
double pNormP0;
double pNormV1;
double pNormP1;
if (!ReadVehicleFile(DataPath,
emissionRep,
Helper,
out vehicleMass,
out vehicleLoading,
out vehicleMassRot,
out crosssectionalArea,
out cwValue,
out f0,
out f1,
out f2,
out f3,
out f4,
out axleRatio,
out auxPower,
out ratedPower,
out engineIdlingSpeed,
out engineRatedSpeed,
out effectiveWhellDiameter,
out transmissionGearRatios,
out vehicleMassType,
out vehicleFuelType,
out pNormV0,
out pNormP0,
out pNormV1,
out pNormP1,
out matrixSpeedInertiaTable,
out normedTragTableSpeedInertiaTable))
return false;
if (!ReadEmissionData(true, DataPath, emissionRep, Helper, out headerFC, out matrixFC, out idlingValuesFC))
return false;
if (!ReadEmissionData(false, DataPath, emissionRep, Helper, out headerPollutants, out matrixPollutants, out idlingValuesPollutants))
return false;
_ceps.Add(Helper.gClass, new CEP(vehicleMassType == Constants.HeavyVehicle,
vehicleMass,
vehicleLoading,
vehicleMassRot,
crosssectionalArea,
cwValue,
f0,
f1,
f2,
f3,
f4,
axleRatio,
transmissionGearRatios,
auxPower,
ratedPower,
engineIdlingSpeed,
engineRatedSpeed,
effectiveWhellDiameter,
pNormV0,
pNormP0,
pNormV1,
pNormP1,
vehicleFuelType,
matrixFC,
headerPollutants,
matrixPollutants,
matrixSpeedInertiaTable,
normedTragTableSpeedInertiaTable,
idlingValuesFC.First(),
idlingValuesPollutants));
return true;
}
#endregion
#region ReadVehicleFile
private bool ReadVehicleFile(string DataPath,
string emissionClass,
Helpers Helper,
out double vehicleMass,
out double vehicleLoading,
out double vehicleMassRot,
out double crossArea,
out double cWValue,
out double f0,
out double f1,
out double f2,
out double f3,
out double f4,
out double axleRatio,
out double auxPower,
out double ratedPower,
out double engineIdlingSpeed,
out double engineRatedSpeed,
out double effectiveWheelDiameter,
out List<double> transmissionGearRatios,
out string vehicleMassType,
out string vehicleFuelType,
out double pNormV0,
out double pNormP0,
out double pNormV1,
out double pNormP1,
out List<List<double>> matrixSpeedInertiaTable,
out List<List<double>> normedDragTable)
{
vehicleMass = 0;
vehicleLoading = 0;
vehicleMassRot = 0;
crossArea = 0;
cWValue = 0;
f0 = 0;
f1 = 0;
f2 = 0;
f3 = 0;
f4 = 0;
axleRatio = 0;
ratedPower = 0;
auxPower = 0;
engineIdlingSpeed = 0;
engineRatedSpeed = 0;
effectiveWheelDiameter = 0;
vehicleMassType = "";
vehicleFuelType = "";
pNormV0 = 0;
pNormP0 = 0;
pNormV1 = 0;
pNormP1 = 0;
transmissionGearRatios = new List<double>();
matrixSpeedInertiaTable = new List<List<double>>();
normedDragTable = new List<List<double>>();
string line;
string cell;
int dataCount = 0;
//Open file
string path = DataPath + @"\" + emissionClass + ".PHEMLight.veh";
if (!File.Exists(@path))
{
Helper.ErrMsg = "File do not exist! (" + path + ")";
return false;
}
StreamReader vehicleReader = File.OpenText(@path);
// skip header
ReadLine(vehicleReader);
while ((line = ReadLine(vehicleReader)) != null && dataCount <= 49)
{
if (line.Substring(0, 1) == Helper.CommentPrefix)
{
continue;
}
else
{
dataCount++;
}
cell = split(line, ',')[0];
// reading Mass
if (dataCount == 1)
vehicleMass = todouble(cell);
// reading vehicle loading
if (dataCount == 2)
vehicleLoading = todouble(cell);
// reading cWValue
if (dataCount == 3)
cWValue = todouble(cell);
// reading crossectional area
if (dataCount == 4)
crossArea = todouble(cell);
// reading vehicle mass rotational
if (dataCount == 7)
vehicleMassRot = todouble(cell);
// reading rated power
if (dataCount == 9)
auxPower = todouble(cell);
// reading rated power
if (dataCount == 10)
ratedPower = todouble(cell);
// reading engine rated speed
if (dataCount == 11)
engineRatedSpeed = todouble(cell);
// reading engine idling speed
if (dataCount == 12)
engineIdlingSpeed = todouble(cell);
// reading f0
if (dataCount == 14)
f0 = todouble(cell);
// reading f1
if (dataCount == 15)
f1 = todouble(cell);
// reading f2
if (dataCount == 16)
f2 = todouble(cell);
// reading f3
if (dataCount == 17)
f3 = todouble(cell);
// reading f4
if (dataCount == 18)
f4 = todouble(cell);
// reading axleRatio
if (dataCount == 21)
axleRatio = todouble(cell);
// reading effective wheel diameter
if (dataCount == 22)
effectiveWheelDiameter = todouble(cell);
if (dataCount >= 23 && dataCount <= 40)
transmissionGearRatios.Add(todouble(cell));
// reading vehicleMassType
if (dataCount == 45)
vehicleMassType = cell;
// reading vehicleFuelType
if (dataCount == 46)
vehicleFuelType = cell;
// reading pNormV0
if (dataCount == 47)
pNormV0 = todouble(cell);
// reading pNormP0
if (dataCount == 48)
pNormP0 = todouble(cell);
// reading pNormV1
if (dataCount == 49)
pNormV1 = todouble(cell);
// reading pNormP1
if (dataCount == 50)
pNormP1 = todouble(cell);
}
while ((line = ReadLine(vehicleReader)) != null && line.Substring(0, 1) != Helper.CommentPrefix)
{
if (line.Substring(0, 1) == Helper.CommentPrefix)
continue;
matrixSpeedInertiaTable.Add(todoubleList(split(line, ',')));
}
while ((line = ReadLine(vehicleReader)) != null)
{
if (line.Substring(0, 1) == Helper.CommentPrefix)
continue;
normedDragTable.Add(todoubleList(split(line, ',')));
}
vehicleReader.Close();
return true;
}
#endregion
#region ReadEmissionData
private bool ReadEmissionData(bool readFC,
string DataPath,
string emissionClass,
Helpers Helper,
out List<string> header,
out List<List<double>> matrix,
out List<double> idlingValues)
{
// declare file stream
string line;
header = new List<string>();
matrix = new List<List<double>>();
idlingValues = new List<double>();
string pollutantExtension = "";
if (readFC)
pollutantExtension += "_FC";
string path = DataPath + @"\" + emissionClass + pollutantExtension + ".csv";
if (!File.Exists(path))
{
Helper.ErrMsg = "File do not exist! (" + path + ")";
return false;
}
StreamReader fileReader = File.OpenText(@path);
// read header line for pollutant identifiers
if ((line = ReadLine(fileReader)) != null)
{
List<string> entries = split(line, ',');
// skip first entry "Pe"
for (int i = 1; i < entries.Count; i++)
{
header.Add(entries[i]);
}
}
// skip units
ReadLine(fileReader);
// skip comment
ReadLine(fileReader);
//readIdlingValues
line = ReadLine(fileReader);
List<string> stringIdlings = split(line, ',').ToList();
stringIdlings.RemoveAt(0);
idlingValues = todoubleList(stringIdlings);
while ((line = ReadLine(fileReader)) != null)
{
matrix.Add(todoubleList(split(line, ',')));
}
fileReader.Close();
return true;
}
#endregion
#if FLEET
#region ReadFleetShares
public bool ReadFleetShares(string DataPath, Helpers Helper)
{
//Declaration
string line;
string path = DataPath + @"\FleetShares.csv";
if (!File.Exists(@path))
{
Helper.ErrMsg = "FleetShares file does not exist! (" + path + ")";
return false;
}
StreamReader shareReader = File.OpenText(@path);
_fleetShares = new Dictionary<string, Dictionary<string, double>>();
while ((line = ReadLine(shareReader)) != null)
{
if (line.Substring(0, 1) == Helper.CommentPrefix)
continue;
List<string> splitLine = split(line, ',');
string aggregateClass = splitLine[0];
if (!FleetShares.ContainsKey(aggregateClass))
FleetShares.Add(aggregateClass, new Dictionary<string, double>());
string subClass = splitLine[1];
if (!FleetShares[aggregateClass].ContainsKey(subClass))
FleetShares[aggregateClass].Add(subClass, todouble(splitLine[2]));
}
return true;
}
#endregion
#endif
//--------------------------------------------------------------------------------------------------
// Functions
//--------------------------------------------------------------------------------------------------
#region Functions
//Split the string
private List<string> split(string s, char delim)
{
return s.Split(delim).ToList();
}
//Convert string to double
private double todouble(string s)
{
return double.Parse(s, CultureInfo.InvariantCulture);
}
//Convert string to double list
private List<double> todoubleList(List<string> s)
{
return s.Select(p => todouble(p)).Cast<double>().ToList();
}
//Read a line from file
private string ReadLine(StreamReader s)
{
return s.ReadLine();
}
#endregion
}
}