#define FLEET
using System;
using System.IO;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
namespace PHEMlightdll
{
public class Start
{
private List<string> _DataPath;
private CEPHandler DataInput;
public Helpers Helper = new Helpers();
//******************* Parameters of Array or Single calculation *******************
//********************************* INPUT ******************************************
//*** DATATYP | UNIT | VARIBLE | Description ***
//List<string> | [-] | DataFiles (VEH, FC, EMI)| Name of file (e.g. "PC_D_EU4" path neede if not in "Default Vehicles") or aggregated name (PC, HDV, BUS, TW) by FleetMix calculation
//List<double> / double | [s] | Time | Time signal
//List<double> / double | [m/s] | Velocity | Velocity signal
//double | [m/s^2]| acc | Acceleration (ONLY NEDDED BY SINGLE CALCULATION)
//List<double> / double | [%] | Gradient | Gradient of the route
//out List<VehicleResult> | [-] | VehicleResultsOrg | Returned result list
//bool | [-] | fleetMix = false | Optional parameter if fleetMix should be calculate
//string | [-] | CommentPref = "c" | Optional parameter for comment prefix
//********************************* OUPUT: VehicleResultsOrg **********************
//*** DATATYP | UNIT | VARIBLE | Description ***
//string | [-] | vehicle | Name of the vehicle
//string | [-] | cycle | Name of the cycle
//double | [s] | time | Time
//double | [m/s] | speed | Velocity
//double | [kW] | power | Calculated power at the engine (ICE for conventional and HEV vehicles, electric engine for BEVs) including engine inertia and auxiliaries; not limited for engine fullload and braking limitations
//double | [kW] | P_pos | Positive engine power limited with engine rated power
//double | [-] | pNormRated | Engine power normalised with rated engine power and limited with the power range (fullload and drag) as specified in the characteristic curve for fuel consumption
//double | [-] | pNormDrive | Engine power normalised with "P_drive" and limited with the power range (fullload and drag) as specified in the characteristic curve for emissions
//double | [m/s^2]| acc | Caclulated/given acceleration
//Dictionary<string, double>| [*] | Emissiondata | Calculated emissions for all components which are defined in the emission curves. Unit dependent of emission component
#region calculate
//Calculate data from array
public bool CALC_Array(List<string> DataFiles,
List<double> Time,
List<double> Velocity,
List<double> Gradient,
out List<VehicleResult> VehicleResultsOrg,
bool fleetMix = false,
Correction DataCor = null,
string CommentPref = "c")
{
//Declaration
int i;
double acc;
List<VehicleResult> _VehicleResult = new List<VehicleResult>();
//Initialisation
Helper.ErrMsg = null;
//Borrow
Helper.CommentPrefix = CommentPref;
_DataPath = new List<string>();
//Set path by normal calculation (on given) and set path by fleetmix (on Default Vehicles) calculation
for (i = 0; i < DataFiles.Count; i++)
{
if ((DataFiles[i].LastIndexOf(@"\")) >= 0)
{
_DataPath.Add(DataFiles[i]);
}
else
{
//_DataPath.Add(Assembly.GetExecutingAssembly().Location.Substring(0, Assembly.GetExecutingAssembly().Location.LastIndexOf(@"\")) + @"\Default Vehicles\" + Helper.PHEMDataV);
_DataPath.Add(DataFiles[i + 1].Substring(0, DataFiles[i + 1].LastIndexOf(@"\")));
_DataPath.Add(DataFiles[i + 1].Substring(0, DataFiles[i + 1].LastIndexOf(@"\")));
_DataPath.Add(DataFiles[i + 1].Substring(0, DataFiles[i + 1].LastIndexOf(@"\")));
i += 1;
}
}
//Read the vehicle and emission data
#if FLEET
if (fleetMix)
{
//Set the vehicle class
Helper.gClass = _DataPath[0];
//Generate the class
DataInput = new CEPHandler();
//Read the FleetShares
if (!DataInput.ReadFleetShares(DataFiles[1], Helper))
{
VehicleResultsOrg = null;
return false;
}
//Read the vehicle and emission data
if (!DataInput.GetFleetCEP(_DataPath, DataFiles[0], Helper, DataCor))
{
VehicleResultsOrg = null;
return false;
}
}
else
#endif
{
//Get vehicle string
if (!Helper.setclass(DataFiles[0]))
{
VehicleResultsOrg = null;
return false;
}
//Generate the class
DataInput = new CEPHandler();
//Read the vehicle and emission data
if (!DataInput.GetCEP(_DataPath, Helper, DataCor))
{
VehicleResultsOrg = null;
return false;
}
}
//Calculate emissions per second
for (i = 1; i <= Time.Count - 1; i++)
{
//Calculate the acceleration
acc = (Velocity[i] - Velocity[i - 1]) / (Time[i] - Time[i - 1]);
//Calculate and save the data in the List
_VehicleResult.Add(PHEMLight.CreateVehicleStateData(Helper,
DataInput.CEPS[Helper.gClass],
Time[i - 1],
Velocity[i - 1],
acc,
Gradient[i - 1]));
if (Helper.ErrMsg != null)
{
VehicleResultsOrg = null;
return false;
}
}
VehicleResultsOrg = _VehicleResult;
return true;
}
//Calculate single data
public bool CALC_Single(List<string> DataFiles,
double Time,
double Velocity,
double acc,
double Gradient,
out List<VehicleResult> VehicleResultsOrg,
bool fleetMix = false,
Correction DataCor = null,
string CommentPref = "c")
{
//Declaration
List<VehicleResult> _VehicleResult = new List<VehicleResult>();
VehicleResultsOrg = _VehicleResult;
//Borrow
Helper.CommentPrefix = CommentPref;
_DataPath = new List<string>();
//Set path by normal calculation (on given) and set path by fleetmix (on Fleetshare file) calculation
for (int i = 0; i < DataFiles.Count; i++)
{
if ((DataFiles[i].LastIndexOf(@"\")) >= 0)
{
_DataPath.Add(DataFiles[i]);
}
else
{
//_DataPath.Add(Assembly.GetExecutingAssembly().Location.Substring(0, Assembly.GetExecutingAssembly().Location.LastIndexOf(@"\")) + @"\Default Vehicles\" + Helper.PHEMDataV);
_DataPath.Add(DataFiles[i + 1].Substring(0, DataFiles[i + 1].LastIndexOf(@"\")));
_DataPath.Add(DataFiles[i + 1].Substring(0, DataFiles[i + 1].LastIndexOf(@"\")));
_DataPath.Add(DataFiles[i + 1].Substring(0, DataFiles[i + 1].LastIndexOf(@"\")));
i += 1;
}
}
//Read the vehicle and emission data
#if FLEET
if (fleetMix)
{
//Set the vehicle class
Helper.gClass = "AggClass_" + DataFiles[0];
//Generate the class
DataInput = new CEPHandler();
//Read the FleetShares
if (!DataInput.ReadFleetShares(DataFiles[1], Helper))
{
VehicleResultsOrg = null;
return false;
}
//Read the vehicle and emission data
if (!DataInput.GetFleetCEP(_DataPath, DataFiles[0], Helper, DataCor))
{
VehicleResultsOrg = null;
return false;
}
}
else
#endif
{
//Get vehicle string
if (!Helper.setclass(DataFiles[0]))
{
VehicleResultsOrg = null;
return false;
}
//Generate the class
DataInput = new CEPHandler();
//Read the vehicle and emission data
if (!DataInput.GetCEP(_DataPath, Helper, DataCor))
{
VehicleResultsOrg = null;
return false;
}
}
//Calculate and save the data in the List
_VehicleResult.Add(PHEMLight.CreateVehicleStateData(Helper,
DataInput.CEPS[Helper.gClass],
Time,
Velocity,
acc,
Gradient));
VehicleResultsOrg = _VehicleResult;
return true;
}
#endregion
#region ExportData
private Dictionary<string, cErgEntry> ErgEntries = new Dictionary<string, cErgEntry>();
private List<string> ErgEntryList = new List<string>(); //Needed because Dictionary is not sorted
//Add to ERG file
private void AddToErg(string IDstring, string Head, string Unit)
{
if (!ErgEntries.ContainsKey(IDstring))
{
ErgEntries.Add(IDstring, new cErgEntry(Head, Unit));
ErgEntryList.Add(IDstring);
}
}
//Create result head
private string ErgHead()
{
//Declaration
StringBuilder s = new StringBuilder();
string key = null;
bool First = true;
foreach (string key_loopVariable in ErgEntryList)
{
key = key_loopVariable;
if (!First)
s.Append(",");
s.Append(ErgEntries[key].Head);
First = false;
}
//Return value
return s.ToString();
}
//Create result units
private string ErgUnits()
{
//Declaration
StringBuilder s = new StringBuilder();
bool First = true;
string key = null;
foreach (string key_loopVariable in ErgEntryList)
{
key = key_loopVariable;
if (!First)
s.Append(",");
s.Append(ErgEntries[key].Unit);
First = false;
}
//Return value
return s.ToString();
}
//Output sequence for the emissions
private void OutSeq(VehicleResult _VehicleResult, bool STA = false, bool add = false)
{
string Unit = "/km";
List<string> OutSeqStr = new List<string> { "FC", "FC_EL", "CO2", "NOX", "CO", "HC", "PM", "PN" };
if (STA) Unit = "/h";
if (!add)
{
//Clear the result arrays
ErgEntries.Clear();
ErgEntryList.Clear();
AddToErg("FC", "FC", "[g" + Unit + "]");
AddToErg("FC_EL", "Engine Power", "[kWh" + Unit + "]");
AddToErg("CO2", "CO2", "[g" + Unit + "]");
AddToErg("NOX", "NOx", "[g" + Unit + "]");
AddToErg("CO", "CO", "[g" + Unit + "]");
AddToErg("HC", "HC", "[g" + Unit + "]");
AddToErg("PM", "PM", "[g" + Unit + "]");
AddToErg("PN", "PN", "[#" + Unit + "]");
foreach (string id in _VehicleResult.EmissionData.Emi.Keys)
{
if (!OutSeqStr.Contains(id)) AddToErg(id.ToUpper(), id, "[g" + Unit + "]");
}
}
else
{
foreach (string id in _VehicleResult.EmissionData.Emi.Keys)
{
if (!ErgEntries.ContainsKey(id.ToUpper())) AddToErg(id.ToUpper(), id, "[g" + Unit + "]");
}
}
}
//Export the data
public bool ExportData(string path, List<VehicleResult> _VehicleResult)
{
if (path == null || _VehicleResult == null || _VehicleResult.Count == 0) return false;
//Write head
StringBuilder allLines = new StringBuilder();
string lineEnding = "\r\n";
//Produce emission output sequence. Only first one needed because should be always the same for a single vehicle
OutSeq(_VehicleResult[0], true);
//Vehicle type
allLines.AppendLine("Vehicletype: ," + _VehicleResult[0].Vehicle);
//Header and unit
allLines.AppendLine("Time, Speed, Gradient, Accelaration, Engine power raw, P_pos, P_norm_rated, P_norm_drive," + ErgHead());
allLines.AppendLine("[s], [m/s], [%], [m/s^2], [kW], [kW], [-], [-]," + ErgUnits());
//Write data
foreach (VehicleResult Result in _VehicleResult)
{
allLines.Append(Result.Time.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.Speed.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.Grad.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.Accelaration.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.Power.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.PPos.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.PNormRated.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.PNormDrive.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
foreach (string id in ErgEntryList)
{
if (Result.EmissionData.Emi.ContainsKey(id))
allLines.Append(Result.EmissionData.Emi[id].ToString("0.0000", CultureInfo.InvariantCulture) + ",");
else
allLines.Append("-,");
}
allLines.Append(lineEnding);
}
// Write the string to a file.
if (path.IndexOf(".", 0) < 0)
{
path = path + ".sta";
}
try
{
StreamWriter file = new StreamWriter(path);
file.WriteLine(allLines);
file.Close();
return true;
}
catch (Exception ex)
{
return false;
}
}
//Export summerized data
public bool ExportSumData(string path, List<VehicleResult> _VehicleResult)
{
if (path == null || _VehicleResult == null) return false;
StringBuilder allLines = new StringBuilder();
if (path.IndexOf(".", 0) < 0)
{
path = path + ".erg";
}
//Produce emission output sequence for all calculated vehicles
OutSeq(_VehicleResult[0], false);
foreach (VehicleResult Result in _VehicleResult)
{
OutSeq(Result, false, true);
}
if (!File.Exists(path))
{
//Write head
allLines.AppendLine("PHEMLight Results");
allLines.AppendLine("");
allLines.AppendLine("Vehicle, Cycle, Time, Speed, Gradient, Accelaration, Engine power raw, P_pos, P_norm_rated, P_norm_drive," + ErgHead());
allLines.AppendLine("[-], [-], [s], [km/h], [%], [m/s^2], [kW], [kW], [-], [-]," + ErgUnits());
}
//Write data
foreach (VehicleResult Result in _VehicleResult)
{
allLines.Append(Result.Vehicle + ",");
allLines.Append(Result.Cycle + ",");
allLines.Append(Result.Time.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.Speed.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.Grad.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.Accelaration.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.Power.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.PPos.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.PNormRated.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
allLines.Append(Result.PNormDrive.ToString("0.0000", CultureInfo.InvariantCulture) + ",");
foreach (string id in ErgEntryList)
{
if (Result.EmissionData.Emi.ContainsKey(id))
allLines.Append(Result.EmissionData.Emi[id].ToString("0.0000", CultureInfo.InvariantCulture) + ",");
else
allLines.Append("-,");
}
allLines.Append("\r\n");
}
// Write the string to a file.
try
{
StreamWriter file = new StreamWriter(path, true);
file.WriteLine(allLines);
file.Close();
return true;
}
catch (Exception ex)
{
return false;
}
}
public VehicleResult GenerateSumData(List<VehicleResult> _VehicleResult)
{
//Declaration
string vehicle = "";
string cycle = "";
double sum_time = 0;
double sum_speed = 0;
double sum_grad = 0;
double sum_power = 0;
double sum_pPos = 0;
double sum_pNormRated = 0;
double sum_pNormDrive = 0;
double sum_acc = 0;
Dictionary<string, double> sum_Emi = new Dictionary<string, double>();
if (_VehicleResult == null || _VehicleResult.Count == 0) return new VehicleResult("", "", 0, 0, 0, 0, 0, 0, 0, 0, sum_Emi);
//Vehicle and cycle are always the same here
vehicle = _VehicleResult[0].Vehicle;
cycle = _VehicleResult[0].Cycle;
//Write data
foreach (VehicleResult Result in _VehicleResult)
{
sum_speed += Result.Speed * 3.6;
sum_power += Result.Power;
if (Result.PPos > 0) { sum_pPos += Result.PPos; }
sum_grad += Result.Grad;
sum_pNormRated += Result.PNormRated;
sum_pNormDrive += Result.PNormDrive;
sum_acc += Result.Accelaration;
foreach(string id in Result.EmissionData.Emi.Keys)
{
if (sum_Emi.ContainsKey(id))
sum_Emi[id] += Result.EmissionData.Emi[id];
else
sum_Emi.Add(id, Result.EmissionData.Emi[id]);
}
}
//Build average
sum_time = _VehicleResult[_VehicleResult.Count - 1].Time - _VehicleResult[0].Time;
sum_power /= _VehicleResult.Count;
sum_pPos /= _VehicleResult.Count;
sum_grad /= _VehicleResult.Count;
sum_pNormRated /= _VehicleResult.Count;
sum_pNormDrive /= _VehicleResult.Count;
sum_acc /= _VehicleResult.Count;
if (sum_speed > 0)
{
foreach (string id in sum_Emi.Keys.ToList())
{
sum_Emi[id] /= sum_speed;
}
}
else
{
foreach (string id in sum_Emi.Keys)
{
sum_Emi[id] = 0;
}
}
sum_speed /= _VehicleResult.Count;
return new VehicleResult(vehicle,
cycle,
sum_time,
sum_speed,
sum_grad,
sum_power,
sum_pPos,
sum_pNormRated,
sum_pNormDrive,
sum_acc,
sum_Emi);
}
#endregion
}
//Calculation
class PHEMLight
{
#region CreateVehicleStateData
static public VehicleResult CreateVehicleStateData(Helpers Helper,
CEP currCep,
double time,
double inputSpeed,
double inputAcc,
double Gradient = 0,
Correction DataCor = null)
{
//Declaration
double speed = Math.Max(inputSpeed, 0);
double acc;
double P_pos;
//Speed/Acceleration limitation
if (speed == 0)
acc = 0;
else
acc = Math.Min(inputAcc, currCep.GetMaxAccel(speed, Gradient, (Helper.pClass == Constants.strBEV | Helper.uClass == Constants.strHybrid)));
//Calculate the power
double power = currCep.CalcPower(speed, acc, Gradient, (Helper.pClass == Constants.strBEV | Helper.uClass == Constants.strHybrid));
double P_eng = currCep.CalcEngPower(power);
double Pwheel = 0;
if (Helper.uClass == Constants.strHybrid) Pwheel = currCep.CalcWheelPower(speed, acc, Gradient);
//Power limitation
if (P_eng >= 0)
P_pos = power;
else
P_pos = 0;
//Calculate the result values (BEV)
if (Helper.pClass == Constants.strBEV)
{
return new VehicleResult(Helper.gClass,
"",
time,
speed,
Gradient,
P_eng,
P_pos,
P_eng / currCep.RatedPower,
P_eng / currCep.DrivingPower,
acc,
currCep.GetAllEmission(P_eng, speed, Helper));
}
//Calculate the decel costing
double decelCoast = currCep.GetDecelCoast(speed, acc, Gradient);
//Calculate the result values (Zero emissions by costing, Idling emissions by v <= 0.5m / s²)
if (acc >= decelCoast || speed <= Constants.ZERO_SPEED_ACCURACY)
{
if (Helper.uClass == Constants.strHybrid)
return new VehicleResult(Helper.gClass,
"",
time,
speed,
Gradient,
P_eng,
P_pos,
P_eng / currCep.RatedPower,
P_eng / currCep.DrivingPower,
acc,
currCep.GetAllEmission(Pwheel, speed, Helper));
else
return new VehicleResult(Helper.gClass,
"",
time,
speed,
Gradient,
P_eng,
P_pos,
P_eng / currCep.RatedPower,
P_eng / currCep.DrivingPower,
acc,
currCep.GetAllEmission(P_eng, speed, Helper));
}
else
{
if (Helper.uClass == Constants.strHybrid)
return new VehicleResult(Helper.gClass,
"",
time,
speed,
Gradient,
P_eng,
P_pos,
P_eng / currCep.RatedPower,
P_eng / currCep.DrivingPower,
acc,
currCep.GetAllEmission(Pwheel, speed, Helper, true));
else
return new VehicleResult(Helper.gClass,
"",
time,
speed,
Gradient,
P_eng,
P_pos,
P_eng / currCep.RatedPower,
P_eng / currCep.DrivingPower,
acc,
currCep.GetAllEmission(P_eng, speed, Helper, true));
}
}
#endregion
}
}
