Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2016-2024 German Aerospace Center (DLR) and others.
4 : // PHEMlight module
5 : // Copyright (C) 2016-2023 Technische Universitaet Graz, https://www.tugraz.at/
6 : // This program and the accompanying materials are made available under the
7 : // terms of the Eclipse Public License 2.0 which is available at
8 : // https://www.eclipse.org/legal/epl-2.0/
9 : // This Source Code may also be made available under the following Secondary
10 : // Licenses when the conditions for such availability set forth in the Eclipse
11 : // Public License 2.0 are satisfied: GNU General Public License, version 2
12 : // or later which is available at
13 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
14 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
15 : /****************************************************************************/
16 : /// @file CEPHandler.cpp
17 : /// @author Martin Dippold
18 : /// @author Michael Behrisch
19 : /// @date July 2016
20 : ///
21 : //
22 : /****************************************************************************/
23 : #include <config.h>
24 :
25 : #include <fstream>
26 : #include <sstream>
27 : #define JSON_USE_IMPLICIT_CONVERSIONS 0
28 : #include <foreign/nlohmann/json.hpp>
29 : #include <utils/common/StringUtils.h>
30 : #include "CEPHandler.h"
31 : #include "CEP.h"
32 : #include "Correction.h"
33 : #include "Helpers.h"
34 :
35 :
36 : namespace PHEMlightdllV5 {
37 :
38 56178 : CEPHandler::CEPHandler() {
39 56178 : }
40 :
41 99 : const std::map<std::string, CEP*>& CEPHandler::getCEPS() const {
42 99 : return _ceps;
43 : }
44 :
45 33 : bool CEPHandler::GetCEP(std::vector<std::string>& DataPath, Helpers* Helper, Correction* DataCor) {
46 33 : if (getCEPS().find(Helper->getgClass()) == getCEPS().end()) {
47 33 : if (!Load(DataPath, Helper, DataCor)) {
48 : return false;
49 : }
50 : }
51 : return true;
52 : }
53 :
54 4 : bool CEPHandler::CalcCorrection(Correction* DataCor, Helpers* Helper, VEHPHEMLightJSON::Vehicle_Data* vehicle_Data) {
55 4 : if (DataCor->getUseDet()) {
56 2 : DataCor->setVehMileage(-1);
57 2 : if (vehicle_Data->getMileage() > 0.) {
58 0 : DataCor->setVehMileage(vehicle_Data->getMileage());
59 : }
60 :
61 2 : if (!DataCor->IniDETfactor(Helper)) {
62 : return false;
63 : }
64 : }
65 4 : if (DataCor->getUseTNOx()) {
66 2 : if (!DataCor->IniTNOxfactor(Helper)) {
67 : return false;
68 : }
69 : }
70 :
71 : //Return value
72 : return true;
73 : }
74 :
75 33 : bool CEPHandler::Load(std::vector<std::string>& DataPath, Helpers* Helper, Correction* DataCor, bool fleetMix) {
76 : //Deklaration
77 : // get string identifier for PHEM emission class
78 33 : std::string emissionRep = Helper->getgClass();
79 :
80 : // to hold everything.
81 : std::vector<std::vector<double> > matrixFCvalues;
82 : std::vector<std::vector<double> > matrixPollutants;
83 : std::vector<double> idlingValuesFCvalues;
84 : std::vector<double> idlingValuesPollutants;
85 : std::vector<std::string> headerFCvalues;
86 : std::vector<std::string> headerPollutants;
87 : VEHPHEMLightJSON::VEH* Vehicle;
88 :
89 33 : if (!ReadVehicleFile(DataPath, emissionRep, Helper, fleetMix, Vehicle)) {
90 0 : delete Vehicle;
91 0 : return false;
92 : }
93 :
94 33 : if (DataCor != nullptr) {
95 4 : if (!CalcCorrection(DataCor, Helper, Vehicle->getVehicleData())) {
96 0 : delete Vehicle;
97 0 : return false;
98 : }
99 : }
100 :
101 33 : if (!ReadEmissionData(true, DataPath, emissionRep, Helper, fleetMix, DataCor, headerFCvalues, matrixFCvalues, idlingValuesFCvalues)) {
102 0 : delete Vehicle;
103 0 : return false;
104 : }
105 33 : if (!ReadEmissionData(false, DataPath, emissionRep, Helper, fleetMix, DataCor, headerPollutants, matrixPollutants, idlingValuesPollutants)) {
106 0 : delete Vehicle;
107 0 : return false;
108 : }
109 :
110 33 : _ceps.insert(std::make_pair(Helper->getgClass(), new CEP(Vehicle, headerFCvalues, matrixFCvalues, headerPollutants, matrixPollutants, idlingValuesFCvalues, idlingValuesPollutants)));
111 33 : delete Vehicle;
112 : return true;
113 33 : }
114 :
115 726 : double json2double(const nlohmann::json& vd, const std::string& key) {
116 : if (vd.contains(key)) {
117 1386 : return vd.at(key).get<double>();
118 : }
119 : return 0.;
120 : }
121 :
122 33 : bool CEPHandler::ReadVehicleFile(const std::vector<std::string>& DataPath, const std::string& emissionClass, Helpers* Helper, bool /* fleetMix */, VEHPHEMLightJSON::VEH*& Vehicle) {
123 33 : std::string path = "";
124 33 : Vehicle = new VEHPHEMLightJSON::VEH();
125 :
126 : //Open file
127 33 : std::ifstream vehicleReader;
128 66 : for (std::vector<std::string>::const_iterator i = DataPath.begin(); i != DataPath.end(); i++) {
129 132 : vehicleReader.open(((*i) + emissionClass + ".PHEMLight.veh").c_str());
130 66 : if (vehicleReader.good()) {
131 : break;
132 : }
133 : }
134 33 : if (!vehicleReader.good()) {
135 0 : Helper->setErrMsg("File does not exist! (" + emissionClass + ".PHEMLight.veh)");
136 0 : return false;
137 : }
138 :
139 : //**** VEH Datei einlesen ****
140 : nlohmann::json json;
141 : try {
142 33 : vehicleReader >> json;
143 0 : } catch (...) {
144 0 : Helper->setErrMsg("Error during file read! (" + emissionClass + ".PHEMLight.veh)");
145 : return false;
146 0 : }
147 :
148 : //*** Get the vehicle data
149 33 : nlohmann::json::iterator vehDataIt = json.find("VehicleData");
150 33 : if (vehDataIt == json.end()) {
151 0 : Helper->setErrMsg("No VehicleData in " + emissionClass + ".PHEMLight.veh!");
152 0 : return false;
153 : }
154 33 : const nlohmann::json& vd = *vehDataIt;
155 99 : Vehicle->getVehicleData()->setMassType(vd.contains("MassType") ? vd.at("MassType").get<std::string>() : "LV");
156 99 : Vehicle->getVehicleData()->setFuelType(vd.contains("FuelType") ? vd.at("FuelType").get<std::string>() : "D");
157 99 : Vehicle->getVehicleData()->setCalcType(vd.contains("CalcType") ? vd.at("CalcType").get<std::string>() : "Conv");
158 33 : Vehicle->getVehicleData()->setMass(json2double(vd, "Mass"));
159 33 : Vehicle->getVehicleData()->setLoading(json2double(vd, "Loading"));
160 33 : Vehicle->getVehicleData()->setRedMassWheel(json2double(vd, "RedMassWheel"));
161 33 : Vehicle->getVehicleData()->setWheelDiameter(json2double(vd, "WheelDiameter"));
162 33 : Vehicle->getVehicleData()->setCw(json2double(vd, "Cw"));
163 33 : Vehicle->getVehicleData()->setA(json2double(vd, "A"));
164 33 : Vehicle->getVehicleData()->setMileage(json2double(vd, "Mileage"));
165 :
166 : // Auxiliaries
167 33 : nlohmann::json::iterator auxDataIt = json.find("AuxiliariesData");
168 33 : if (auxDataIt == json.end() || !auxDataIt->contains("Pauxnorm")) {
169 0 : Vehicle->getAuxiliariesData()->setPauxnorm(0.);
170 : } else {
171 99 : Vehicle->getAuxiliariesData()->setPauxnorm(auxDataIt->at("Pauxnorm").get<double>());
172 : }
173 :
174 : // Engine Data
175 33 : nlohmann::json::iterator engDataIt = json.find("EngineData");
176 66 : if (engDataIt == json.end() || !engDataIt->contains("ICEData") || !engDataIt->contains("EMData")) {
177 0 : Helper->setErrMsg("Incomplete EngineData in " + emissionClass + ".PHEMLight.veh!");
178 0 : return false;
179 : }
180 33 : const nlohmann::json& iced = (*engDataIt)["ICEData"];
181 33 : const nlohmann::json& emd = (*engDataIt)["EMData"];
182 33 : Vehicle->getEngineData()->getICEData()->setPrated(json2double(iced, "Prated"));
183 33 : Vehicle->getEngineData()->getICEData()->setnrated(json2double(iced, "nrated"));
184 33 : Vehicle->getEngineData()->getICEData()->setIdling(json2double(iced, "Idling"));
185 33 : Vehicle->getEngineData()->getEMData()->setPrated(json2double(emd, "Prated"));
186 33 : Vehicle->getEngineData()->getEMData()->setnrated(json2double(emd, "nrated"));
187 :
188 : // Rolling resistance
189 33 : nlohmann::json::iterator rrDataIt = json.find("RollingResData");
190 33 : if (rrDataIt == json.end()) {
191 0 : Helper->setErrMsg("No RollingResData in " + emissionClass + ".PHEMLight.veh!");
192 0 : return false;
193 : }
194 33 : const nlohmann::json& rrd = *rrDataIt;
195 33 : Vehicle->getRollingResData()->setFr0(json2double(rrd, "Fr0"));
196 33 : Vehicle->getRollingResData()->setFr1(json2double(rrd, "Fr1"));
197 33 : Vehicle->getRollingResData()->setFr2(json2double(rrd, "Fr2"));
198 33 : Vehicle->getRollingResData()->setFr3(json2double(rrd, "Fr3"));
199 33 : Vehicle->getRollingResData()->setFr4(json2double(rrd, "Fr4"));
200 :
201 : // Transmission
202 33 : nlohmann::json::iterator trDataIt = json.find("TransmissionData");
203 33 : if (trDataIt == json.end()) {
204 0 : Helper->setErrMsg("No TransmissionData in " + emissionClass + ".PHEMLight.veh!");
205 0 : return false;
206 : }
207 33 : Vehicle->getTransmissionData()->setAxelRatio(json2double(*trDataIt, "AxelRatio"));
208 33 : nlohmann::json::iterator transmIt = trDataIt->find("Transm");
209 33 : if (transmIt == trDataIt->end()) {
210 0 : Helper->setErrMsg(std::string("Transmission ratios missing in vehicle file! Calculation stopped! (") + path + std::string(")"));
211 0 : return false;
212 : } else {
213 33 : if (!transmIt->contains("Speed")) {
214 0 : Helper->setErrMsg(std::string("No Speed signal in transmission data given! Calculation stopped! (") + path + std::string(")"));
215 0 : return false;
216 : }
217 33 : if (!transmIt->contains("GearRatio")) {
218 0 : Helper->setErrMsg(std::string("No GearRatio signal in transmission data given! Calculation stopped! (") + path + std::string(")"));
219 0 : return false;
220 : }
221 33 : if (!transmIt->contains("RotMassF")) {
222 0 : Helper->setErrMsg(std::string("No RotMassF signal in transmission data given! Calculation stopped! (") + path + std::string(")"));
223 0 : return false;
224 : }
225 : }
226 66 : Vehicle->getTransmissionData()->setTransm(transmIt->get<std::map<std::string, std::vector<double> > >());
227 :
228 : // Full load and drag
229 33 : nlohmann::json::iterator fldDataIt = json.find("FLDData");
230 33 : if (fldDataIt == json.end()) {
231 0 : Helper->setErrMsg("No FLDData in " + emissionClass + ".PHEMLight.veh!");
232 0 : return false;
233 : }
234 33 : const nlohmann::json& fld = *fldDataIt;
235 33 : Vehicle->getFLDData()->setP_n_max_v0(json2double(fld, "P_n_max_v0"));
236 33 : Vehicle->getFLDData()->setP_n_max_p0(json2double(fld, "P_n_max_p0"));
237 33 : Vehicle->getFLDData()->setP_n_max_v1(json2double(fld, "P_n_max_v1"));
238 33 : Vehicle->getFLDData()->setP_n_max_p1(json2double(fld, "P_n_max_p1"));
239 33 : nlohmann::json::iterator dragIt = fldDataIt->find("DragCurve");
240 33 : if (dragIt == fldDataIt->end()) {
241 0 : Helper->setErrMsg(std::string("Drag curve missing in vehicle file! Calculation stopped! (") + path + std::string(")"));
242 0 : return false;
243 : } else {
244 33 : if (!dragIt->contains("n_norm")) {
245 0 : Helper->setErrMsg(std::string("No n_norm signal in drag curve data given! Calculation stopped! (") + path + std::string(")"));
246 0 : return false;
247 : }
248 33 : if (!dragIt->contains("pe_drag_norm")) {
249 0 : Helper->setErrMsg(std::string("No pe_drag_norm signal in drag curve data given! Calculation stopped! (") + path + std::string(")"));
250 0 : return false;
251 : }
252 : }
253 66 : Vehicle->getFLDData()->setDragCurve(dragIt->get<std::map<std::string, std::vector<double> > >());
254 :
255 33 : return true;
256 33 : }
257 :
258 66 : bool CEPHandler::ReadEmissionData(bool readFC, const std::vector<std::string>& DataPath, const std::string& emissionClass, Helpers* Helper, bool /* fleetMix */, Correction* DataCor, std::vector<std::string>& header, std::vector<std::vector<double> >& matrix, std::vector<double>& idlingValues) {
259 : // declare file stream
260 : std::string line;
261 66 : std::string path = "";
262 66 : header = std::vector<std::string>();
263 66 : matrix = std::vector<std::vector<double> >();
264 66 : idlingValues = std::vector<double>();
265 :
266 66 : std::string pollutantExtension = "";
267 66 : if (readFC) {
268 66 : pollutantExtension += std::string("_FC");
269 : }
270 :
271 66 : std::ifstream fileReader;
272 132 : for (std::vector<std::string>::const_iterator i = DataPath.begin(); i != DataPath.end(); i++) {
273 264 : fileReader.open(((*i) + emissionClass + pollutantExtension + ".csv").c_str());
274 132 : if (fileReader.good()) {
275 : break;
276 : }
277 : }
278 66 : if (!fileReader.good()) {
279 0 : Helper->setErrMsg("File does not exist! (" + emissionClass + pollutantExtension + ".csv)");
280 0 : return false;
281 : }
282 :
283 : // read header line for pollutant identifiers
284 132 : if ((line = ReadLine(fileReader)) != "") {
285 66 : const std::vector<std::string>& entries = split(line, ',');
286 : // skip first entry "Pe"
287 330 : for (int i = 1; i < (int)entries.size(); i++) {
288 264 : header.push_back(entries[i]);
289 : }
290 66 : }
291 :
292 : // skip units
293 66 : ReadLine(fileReader);
294 :
295 : // skip comment
296 66 : ReadLine(fileReader);
297 :
298 : //readIdlingValues
299 66 : line = ReadLine(fileReader);
300 :
301 66 : std::vector<std::string> stringIdlings = split(line, ',');
302 : stringIdlings.erase(stringIdlings.begin());
303 :
304 66 : idlingValues = todoubleList(stringIdlings);
305 :
306 3036 : while ((line = ReadLine(fileReader)) != "") {
307 2904 : matrix.push_back(todoubleList(split(line, ',')));
308 : }
309 :
310 : //Data correction (Det & TNOx)
311 66 : if (!CorrectEmissionData(DataCor, header, matrix, idlingValues)) {
312 0 : Helper->setErrMsg("Error in correction calculation");
313 0 : return false;
314 : }
315 :
316 : //Return value
317 : return true;
318 66 : }
319 :
320 66 : bool CEPHandler::CorrectEmissionData(Correction* DataCor, std::vector<std::string>& header, std::vector<std::vector<double> >& matrix, std::vector<double>& idlingValues) {
321 330 : for (int i = 0; i < (int)header.size(); i++) {
322 264 : double CorF = GetDetTempCor(DataCor, header[i]);
323 264 : if (CorF != 1) {
324 64 : for (int j = 0; j < (int)matrix.size(); j++) {
325 62 : matrix[j][i + 1] *= CorF;
326 : }
327 2 : idlingValues[i] *= CorF;
328 : }
329 : }
330 :
331 : //Return value
332 66 : return true;
333 : }
334 :
335 264 : double CEPHandler::GetDetTempCor(Correction* DataCor, const std::string& Emi) {
336 : //Initialisation
337 : double CorF = 1;
338 : std::string emi = Emi;
339 693 : std::transform(emi.begin(), emi.end(), emi.begin(), [](char c) { return (char)::toupper(c); });
340 :
341 264 : if (DataCor != 0) {
342 32 : if (DataCor->getUseDet() && DataCor->DETFactors.count(emi) > 0) {
343 6 : CorF += DataCor->DETFactors[emi] - 1;
344 : }
345 32 : if (DataCor->getUseTNOx()) {
346 16 : if (emi.find("NOX") != std::string::npos) {
347 2 : CorF += (DataCor->getTNOxFactor() - 1);
348 : }
349 : }
350 : }
351 :
352 : //Return value
353 264 : return CorF;
354 : }
355 :
356 1584 : const std::vector<std::string> CEPHandler::split(const std::string& s, char delim) {
357 : std::vector<std::string> elems;
358 1584 : std::stringstream ss(s);
359 : std::string item;
360 10098 : while (std::getline(ss, item, delim)) {
361 8514 : elems.push_back(item);
362 : }
363 1584 : return elems;
364 1584 : }
365 :
366 8118 : double CEPHandler::todouble(const std::string& s) {
367 8118 : std::stringstream ss(s);
368 : double item;
369 : ss >> item;
370 8118 : return item;
371 8118 : }
372 :
373 1518 : std::vector<double> CEPHandler::todoubleList(const std::vector<std::string>& s) {
374 : std::vector<double> result;
375 9636 : for (std::vector<std::string>::const_iterator i = s.begin(); i != s.end(); ++i) {
376 8118 : result.push_back(todouble(*i));
377 : }
378 1518 : return result;
379 0 : }
380 :
381 1782 : std::string CEPHandler::ReadLine(std::ifstream& s) {
382 : std::string line;
383 1782 : std::getline(s, line);
384 : size_t lastNWChar = line.find_last_not_of(" \n\r\t");
385 1782 : if (lastNWChar != std::string::npos) {
386 1716 : line.erase(lastNWChar + 1);
387 : }
388 1782 : return line;
389 : }
390 :
391 0 : const std::string& VEHPHEMLightJSON::VEH::getType() const {
392 0 : return privateType;
393 : }
394 :
395 0 : void VEHPHEMLightJSON::VEH::setType(const std::string& value) {
396 0 : privateType = value;
397 0 : }
398 :
399 0 : const std::string& VEHPHEMLightJSON::VEH::getVersion() const {
400 0 : return privateVersion;
401 : }
402 :
403 0 : void VEHPHEMLightJSON::VEH::setVersion(const std::string& value) {
404 0 : privateVersion = value;
405 0 : }
406 :
407 631 : VEHPHEMLightJSON::Vehicle_Data* VEHPHEMLightJSON::VEH::getVehicleData() {
408 631 : return &privateVehicleData;
409 : }
410 :
411 66 : VEHPHEMLightJSON::Aux_Data* VEHPHEMLightJSON::VEH::getAuxiliariesData() {
412 66 : return &privateAuxiliariesData;
413 : }
414 :
415 264 : VEHPHEMLightJSON::Engine_Data* VEHPHEMLightJSON::VEH::getEngineData() {
416 264 : return &privateEngineData;
417 : }
418 :
419 330 : VEHPHEMLightJSON::Rollres_Data* VEHPHEMLightJSON::VEH::getRollingResData() {
420 330 : return &privateRollingResData;
421 : }
422 :
423 363 : VEHPHEMLightJSON::FullLoadDrag_Data* VEHPHEMLightJSON::VEH::getFLDData() {
424 363 : return &privateFLDData;
425 : }
426 :
427 682 : VEHPHEMLightJSON::Transmission_Data* VEHPHEMLightJSON::VEH::getTransmissionData() {
428 682 : return &privateTransmissionData;
429 : }
430 :
431 33 : const std::string& VEHPHEMLightJSON::Vehicle_Data::getMassType() const {
432 33 : return privateMassType;
433 : }
434 :
435 33 : void VEHPHEMLightJSON::Vehicle_Data::setMassType(const std::string& value) {
436 33 : privateMassType = value;
437 33 : }
438 :
439 33 : const std::string& VEHPHEMLightJSON::Vehicle_Data::getFuelType() const {
440 33 : return privateFuelType;
441 : }
442 :
443 33 : void VEHPHEMLightJSON::Vehicle_Data::setFuelType(const std::string& value) {
444 33 : privateFuelType = value;
445 33 : }
446 :
447 33 : const std::string& VEHPHEMLightJSON::Vehicle_Data::getCalcType() const {
448 33 : return privateCalcType;
449 : }
450 :
451 33 : void VEHPHEMLightJSON::Vehicle_Data::setCalcType(const std::string& value) {
452 33 : privateCalcType = value;
453 33 : }
454 :
455 33 : const double& VEHPHEMLightJSON::Vehicle_Data::getMass() const {
456 33 : return privateMass;
457 : }
458 :
459 33 : void VEHPHEMLightJSON::Vehicle_Data::setMass(const double& value) {
460 33 : privateMass = value;
461 33 : }
462 :
463 33 : const double& VEHPHEMLightJSON::Vehicle_Data::getLoading() const {
464 33 : return privateLoading;
465 : }
466 :
467 33 : void VEHPHEMLightJSON::Vehicle_Data::setLoading(const double& value) {
468 33 : privateLoading = value;
469 33 : }
470 :
471 33 : const double& VEHPHEMLightJSON::Vehicle_Data::getRedMassWheel() const {
472 33 : return privateRedMassWheel;
473 : }
474 :
475 33 : void VEHPHEMLightJSON::Vehicle_Data::setRedMassWheel(const double& value) {
476 33 : privateRedMassWheel = value;
477 33 : }
478 :
479 33 : const double& VEHPHEMLightJSON::Vehicle_Data::getWheelDiameter() const {
480 33 : return privateWheelDiameter;
481 : }
482 :
483 33 : void VEHPHEMLightJSON::Vehicle_Data::setWheelDiameter(const double& value) {
484 33 : privateWheelDiameter = value;
485 33 : }
486 :
487 33 : const double& VEHPHEMLightJSON::Vehicle_Data::getCw() const {
488 33 : return privateCw;
489 : }
490 :
491 33 : void VEHPHEMLightJSON::Vehicle_Data::setCw(const double& value) {
492 33 : privateCw = value;
493 33 : }
494 :
495 33 : const double& VEHPHEMLightJSON::Vehicle_Data::getA() const {
496 33 : return privateA;
497 : }
498 :
499 33 : void VEHPHEMLightJSON::Vehicle_Data::setA(const double& value) {
500 33 : privateA = value;
501 33 : }
502 :
503 2 : const double& VEHPHEMLightJSON::Vehicle_Data::getMileage() const {
504 2 : return privateMileage;
505 : }
506 :
507 33 : void VEHPHEMLightJSON::Vehicle_Data::setMileage(const double& value) {
508 33 : privateMileage = value;
509 33 : }
510 :
511 33 : const double& VEHPHEMLightJSON::Rollres_Data::getFr0() const {
512 33 : return privateFr0;
513 : }
514 :
515 33 : void VEHPHEMLightJSON::Rollres_Data::setFr0(const double& value) {
516 33 : privateFr0 = value;
517 33 : }
518 :
519 33 : const double& VEHPHEMLightJSON::Rollres_Data::getFr1() const {
520 33 : return privateFr1;
521 : }
522 :
523 33 : void VEHPHEMLightJSON::Rollres_Data::setFr1(const double& value) {
524 33 : privateFr1 = value;
525 33 : }
526 :
527 33 : const double& VEHPHEMLightJSON::Rollres_Data::getFr2() const {
528 33 : return privateFr2;
529 : }
530 :
531 33 : void VEHPHEMLightJSON::Rollres_Data::setFr2(const double& value) {
532 33 : privateFr2 = value;
533 33 : }
534 :
535 33 : const double& VEHPHEMLightJSON::Rollres_Data::getFr3() const {
536 33 : return privateFr3;
537 : }
538 :
539 33 : void VEHPHEMLightJSON::Rollres_Data::setFr3(const double& value) {
540 33 : privateFr3 = value;
541 33 : }
542 :
543 33 : const double& VEHPHEMLightJSON::Rollres_Data::getFr4() const {
544 33 : return privateFr4;
545 : }
546 :
547 33 : void VEHPHEMLightJSON::Rollres_Data::setFr4(const double& value) {
548 33 : privateFr4 = value;
549 33 : }
550 :
551 198 : VEHPHEMLightJSON::ICE_Data* VEHPHEMLightJSON::Engine_Data::getICEData() {
552 198 : return &privateICEData;
553 : }
554 :
555 66 : VEHPHEMLightJSON::EM_Data* VEHPHEMLightJSON::Engine_Data::getEMData() {
556 66 : return &privateEMData;
557 : }
558 :
559 33 : const double& VEHPHEMLightJSON::ICE_Data::getPrated() const {
560 33 : return privatePrated;
561 : }
562 :
563 33 : void VEHPHEMLightJSON::ICE_Data::setPrated(const double& value) {
564 33 : privatePrated = value;
565 33 : }
566 :
567 33 : const double& VEHPHEMLightJSON::ICE_Data::getnrated() const {
568 33 : return privatenrated;
569 : }
570 :
571 33 : void VEHPHEMLightJSON::ICE_Data::setnrated(const double& value) {
572 33 : privatenrated = value;
573 33 : }
574 :
575 33 : const double& VEHPHEMLightJSON::ICE_Data::getIdling() const {
576 33 : return privateIdling;
577 : }
578 :
579 33 : void VEHPHEMLightJSON::ICE_Data::setIdling(const double& value) {
580 33 : privateIdling = value;
581 33 : }
582 :
583 0 : const double& VEHPHEMLightJSON::EM_Data::getPrated() const {
584 0 : return privatePrated;
585 : }
586 :
587 33 : void VEHPHEMLightJSON::EM_Data::setPrated(const double& value) {
588 33 : privatePrated = value;
589 33 : }
590 :
591 0 : const double& VEHPHEMLightJSON::EM_Data::getnrated() const {
592 0 : return privatenrated;
593 : }
594 :
595 33 : void VEHPHEMLightJSON::EM_Data::setnrated(const double& value) {
596 33 : privatenrated = value;
597 33 : }
598 :
599 33 : const double& VEHPHEMLightJSON::Aux_Data::getPauxnorm() const {
600 33 : return privatePauxnorm;
601 : }
602 :
603 33 : void VEHPHEMLightJSON::Aux_Data::setPauxnorm(const double& value) {
604 33 : privatePauxnorm = value;
605 33 : }
606 :
607 33 : const double& VEHPHEMLightJSON::FullLoadDrag_Data::getP_n_max_v0() const {
608 33 : return privateP_n_max_v0;
609 : }
610 :
611 33 : void VEHPHEMLightJSON::FullLoadDrag_Data::setP_n_max_v0(const double& value) {
612 33 : privateP_n_max_v0 = value;
613 33 : }
614 :
615 33 : const double& VEHPHEMLightJSON::FullLoadDrag_Data::getP_n_max_p0() const {
616 33 : return privateP_n_max_p0;
617 : }
618 :
619 33 : void VEHPHEMLightJSON::FullLoadDrag_Data::setP_n_max_p0(const double& value) {
620 33 : privateP_n_max_p0 = value;
621 33 : }
622 :
623 33 : const double& VEHPHEMLightJSON::FullLoadDrag_Data::getP_n_max_v1() const {
624 33 : return privateP_n_max_v1;
625 : }
626 :
627 33 : void VEHPHEMLightJSON::FullLoadDrag_Data::setP_n_max_v1(const double& value) {
628 33 : privateP_n_max_v1 = value;
629 33 : }
630 :
631 33 : const double& VEHPHEMLightJSON::FullLoadDrag_Data::getP_n_max_p1() const {
632 33 : return privateP_n_max_p1;
633 : }
634 :
635 33 : void VEHPHEMLightJSON::FullLoadDrag_Data::setP_n_max_p1(const double& value) {
636 33 : privateP_n_max_p1 = value;
637 33 : }
638 :
639 66 : std::map<std::string, std::vector<double> >& VEHPHEMLightJSON::FullLoadDrag_Data::getDragCurve() {
640 66 : return privateDragCurve;
641 : }
642 :
643 66 : void VEHPHEMLightJSON::FullLoadDrag_Data::setDragCurve(const std::map<std::string, std::vector<double> >& value) {
644 : privateDragCurve = value;
645 66 : }
646 :
647 33 : VEHPHEMLightJSON::FullLoadDrag_Data::FullLoadDrag_Data() {
648 33 : setDragCurve(std::map<std::string, std::vector<double> >());
649 33 : }
650 :
651 33 : const double& VEHPHEMLightJSON::Transmission_Data::getAxelRatio() const {
652 33 : return privateAxelRatio;
653 : }
654 :
655 33 : void VEHPHEMLightJSON::Transmission_Data::setAxelRatio(const double& value) {
656 33 : privateAxelRatio = value;
657 33 : }
658 :
659 583 : std::map<std::string, std::vector<double> >& VEHPHEMLightJSON::Transmission_Data::getTransm() {
660 583 : return privateTransm;
661 : }
662 :
663 66 : void VEHPHEMLightJSON::Transmission_Data::setTransm(const std::map<std::string, std::vector<double> >& value) {
664 : privateTransm = value;
665 66 : }
666 :
667 33 : VEHPHEMLightJSON::Transmission_Data::Transmission_Data() {
668 33 : setTransm(std::map<std::string, std::vector<double> >());
669 33 : }
670 : }
|
