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 55645 : CEPHandler::CEPHandler() {
39 55645 : }
40 :
41 84 : const std::map<std::string, CEP*>& CEPHandler::getCEPS() const {
42 84 : return _ceps;
43 : }
44 :
45 28 : bool CEPHandler::GetCEP(std::vector<std::string>& DataPath, Helpers* Helper, Correction* DataCor) {
46 28 : if (getCEPS().find(Helper->getgClass()) == getCEPS().end()) {
47 28 : 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 28 : 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 28 : 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 28 : if (!ReadVehicleFile(DataPath, emissionRep, Helper, fleetMix, Vehicle)) {
90 0 : delete Vehicle;
91 0 : return false;
92 : }
93 :
94 28 : if (DataCor != nullptr) {
95 4 : if (!CalcCorrection(DataCor, Helper, Vehicle->getVehicleData())) {
96 0 : delete Vehicle;
97 0 : return false;
98 : }
99 : }
100 :
101 28 : if (!ReadEmissionData(true, DataPath, emissionRep, Helper, fleetMix, DataCor, headerFCvalues, matrixFCvalues, idlingValuesFCvalues)) {
102 0 : delete Vehicle;
103 0 : return false;
104 : }
105 28 : if (!ReadEmissionData(false, DataPath, emissionRep, Helper, fleetMix, DataCor, headerPollutants, matrixPollutants, idlingValuesPollutants)) {
106 0 : delete Vehicle;
107 0 : return false;
108 : }
109 :
110 28 : _ceps.insert(std::make_pair(Helper->getgClass(), new CEP(Vehicle, headerFCvalues, matrixFCvalues, headerPollutants, matrixPollutants, idlingValuesFCvalues, idlingValuesPollutants)));
111 28 : delete Vehicle;
112 : return true;
113 28 : }
114 :
115 616 : double json2double(const nlohmann::json& vd, const std::string& key) {
116 : if (vd.contains(key)) {
117 1176 : return vd.at(key).get<double>();
118 : }
119 : return 0.;
120 : }
121 :
122 28 : bool CEPHandler::ReadVehicleFile(const std::vector<std::string>& DataPath, const std::string& emissionClass, Helpers* Helper, bool /* fleetMix */, VEHPHEMLightJSON::VEH*& Vehicle) {
123 28 : std::string path = "";
124 28 : Vehicle = new VEHPHEMLightJSON::VEH();
125 :
126 : //Open file
127 28 : std::ifstream vehicleReader;
128 56 : for (std::vector<std::string>::const_iterator i = DataPath.begin(); i != DataPath.end(); i++) {
129 112 : vehicleReader.open(((*i) + emissionClass + ".PHEMLight.veh").c_str());
130 56 : if (vehicleReader.good()) {
131 : break;
132 : }
133 : }
134 28 : 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 28 : 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 28 : nlohmann::json::iterator vehDataIt = json.find("VehicleData");
150 28 : if (vehDataIt == json.end()) {
151 0 : Helper->setErrMsg("No VehicleData in " + emissionClass + ".PHEMLight.veh!");
152 0 : return false;
153 : }
154 28 : const nlohmann::json& vd = *vehDataIt;
155 84 : Vehicle->getVehicleData()->setMassType(vd.contains("MassType") ? vd.at("MassType").get<std::string>() : "LV");
156 84 : Vehicle->getVehicleData()->setFuelType(vd.contains("FuelType") ? vd.at("FuelType").get<std::string>() : "D");
157 84 : Vehicle->getVehicleData()->setCalcType(vd.contains("CalcType") ? vd.at("CalcType").get<std::string>() : "Conv");
158 28 : Vehicle->getVehicleData()->setMass(json2double(vd, "Mass"));
159 28 : Vehicle->getVehicleData()->setLoading(json2double(vd, "Loading"));
160 28 : Vehicle->getVehicleData()->setRedMassWheel(json2double(vd, "RedMassWheel"));
161 28 : Vehicle->getVehicleData()->setWheelDiameter(json2double(vd, "WheelDiameter"));
162 28 : Vehicle->getVehicleData()->setCw(json2double(vd, "Cw"));
163 28 : Vehicle->getVehicleData()->setA(json2double(vd, "A"));
164 28 : Vehicle->getVehicleData()->setMileage(json2double(vd, "Mileage"));
165 :
166 : // Auxiliaries
167 28 : nlohmann::json::iterator auxDataIt = json.find("AuxiliariesData");
168 28 : if (auxDataIt == json.end() || !auxDataIt->contains("Pauxnorm")) {
169 0 : Vehicle->getAuxiliariesData()->setPauxnorm(0.);
170 : } else {
171 84 : Vehicle->getAuxiliariesData()->setPauxnorm(auxDataIt->at("Pauxnorm").get<double>());
172 : }
173 :
174 : // Engine Data
175 28 : nlohmann::json::iterator engDataIt = json.find("EngineData");
176 56 : 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 28 : const nlohmann::json& iced = (*engDataIt)["ICEData"];
181 28 : const nlohmann::json& emd = (*engDataIt)["EMData"];
182 28 : Vehicle->getEngineData()->getICEData()->setPrated(json2double(iced, "Prated"));
183 28 : Vehicle->getEngineData()->getICEData()->setnrated(json2double(iced, "nrated"));
184 28 : Vehicle->getEngineData()->getICEData()->setIdling(json2double(iced, "Idling"));
185 28 : Vehicle->getEngineData()->getEMData()->setPrated(json2double(emd, "Prated"));
186 28 : Vehicle->getEngineData()->getEMData()->setnrated(json2double(emd, "nrated"));
187 :
188 : // Rolling resistance
189 28 : nlohmann::json::iterator rrDataIt = json.find("RollingResData");
190 28 : if (rrDataIt == json.end()) {
191 0 : Helper->setErrMsg("No RollingResData in " + emissionClass + ".PHEMLight.veh!");
192 0 : return false;
193 : }
194 28 : const nlohmann::json& rrd = *rrDataIt;
195 28 : Vehicle->getRollingResData()->setFr0(json2double(rrd, "Fr0"));
196 28 : Vehicle->getRollingResData()->setFr1(json2double(rrd, "Fr1"));
197 28 : Vehicle->getRollingResData()->setFr2(json2double(rrd, "Fr2"));
198 28 : Vehicle->getRollingResData()->setFr3(json2double(rrd, "Fr3"));
199 28 : Vehicle->getRollingResData()->setFr4(json2double(rrd, "Fr4"));
200 :
201 : // Transmission
202 28 : nlohmann::json::iterator trDataIt = json.find("TransmissionData");
203 28 : if (trDataIt == json.end()) {
204 0 : Helper->setErrMsg("No TransmissionData in " + emissionClass + ".PHEMLight.veh!");
205 0 : return false;
206 : }
207 28 : Vehicle->getTransmissionData()->setAxelRatio(json2double(*trDataIt, "AxelRatio"));
208 28 : nlohmann::json::iterator transmIt = trDataIt->find("Transm");
209 28 : 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 28 : 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 28 : 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 28 : 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 56 : Vehicle->getTransmissionData()->setTransm(transmIt->get<std::map<std::string, std::vector<double> > >());
227 :
228 : // Full load and drag
229 28 : nlohmann::json::iterator fldDataIt = json.find("FLDData");
230 28 : if (fldDataIt == json.end()) {
231 0 : Helper->setErrMsg("No FLDData in " + emissionClass + ".PHEMLight.veh!");
232 0 : return false;
233 : }
234 28 : const nlohmann::json& fld = *fldDataIt;
235 28 : Vehicle->getFLDData()->setP_n_max_v0(json2double(fld, "P_n_max_v0"));
236 28 : Vehicle->getFLDData()->setP_n_max_p0(json2double(fld, "P_n_max_p0"));
237 28 : Vehicle->getFLDData()->setP_n_max_v1(json2double(fld, "P_n_max_v1"));
238 28 : Vehicle->getFLDData()->setP_n_max_p1(json2double(fld, "P_n_max_p1"));
239 28 : nlohmann::json::iterator dragIt = fldDataIt->find("DragCurve");
240 28 : 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 28 : 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 28 : 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 56 : Vehicle->getFLDData()->setDragCurve(dragIt->get<std::map<std::string, std::vector<double> > >());
254 :
255 28 : return true;
256 28 : }
257 :
258 56 : 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 56 : std::string path = "";
262 56 : header = std::vector<std::string>();
263 56 : matrix = std::vector<std::vector<double> >();
264 56 : idlingValues = std::vector<double>();
265 :
266 56 : std::string pollutantExtension = "";
267 56 : if (readFC) {
268 56 : pollutantExtension += std::string("_FC");
269 : }
270 :
271 56 : std::ifstream fileReader;
272 112 : for (std::vector<std::string>::const_iterator i = DataPath.begin(); i != DataPath.end(); i++) {
273 224 : fileReader.open(((*i) + emissionClass + pollutantExtension + ".csv").c_str());
274 112 : if (fileReader.good()) {
275 : break;
276 : }
277 : }
278 56 : 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 112 : if ((line = ReadLine(fileReader)) != "") {
285 56 : const std::vector<std::string>& entries = split(line, ',');
286 : // skip first entry "Pe"
287 280 : for (int i = 1; i < (int)entries.size(); i++) {
288 224 : header.push_back(entries[i]);
289 : }
290 56 : }
291 :
292 : // skip units
293 56 : ReadLine(fileReader);
294 :
295 : // skip comment
296 56 : ReadLine(fileReader);
297 :
298 : //readIdlingValues
299 56 : line = ReadLine(fileReader);
300 :
301 56 : std::vector<std::string> stringIdlings = split(line, ',');
302 : stringIdlings.erase(stringIdlings.begin());
303 :
304 56 : idlingValues = todoubleList(stringIdlings);
305 :
306 2576 : while ((line = ReadLine(fileReader)) != "") {
307 2464 : matrix.push_back(todoubleList(split(line, ',')));
308 : }
309 :
310 : //Data correction (Det & TNOx)
311 56 : 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 56 : }
319 :
320 56 : bool CEPHandler::CorrectEmissionData(Correction* DataCor, std::vector<std::string>& header, std::vector<std::vector<double> >& matrix, std::vector<double>& idlingValues) {
321 280 : for (int i = 0; i < (int)header.size(); i++) {
322 224 : double CorF = GetDetTempCor(DataCor, header[i]);
323 224 : 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 56 : return true;
333 : }
334 :
335 224 : double CEPHandler::GetDetTempCor(Correction* DataCor, const std::string& Emi) {
336 : //Initialisation
337 : double CorF = 1;
338 : std::string emi = Emi;
339 588 : std::transform(emi.begin(), emi.end(), emi.begin(), [](char c) { return (char)::toupper(c); });
340 :
341 224 : 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 224 : return CorF;
354 : }
355 :
356 1344 : const std::vector<std::string> CEPHandler::split(const std::string& s, char delim) {
357 : std::vector<std::string> elems;
358 1344 : std::stringstream ss(s);
359 : std::string item;
360 8568 : while (std::getline(ss, item, delim)) {
361 7224 : elems.push_back(item);
362 : }
363 1344 : return elems;
364 1344 : }
365 :
366 6888 : double CEPHandler::todouble(const std::string& s) {
367 6888 : std::stringstream ss(s);
368 : double item;
369 : ss >> item;
370 6888 : return item;
371 6888 : }
372 :
373 1288 : std::vector<double> CEPHandler::todoubleList(const std::vector<std::string>& s) {
374 : std::vector<double> result;
375 8176 : for (std::vector<std::string>::const_iterator i = s.begin(); i != s.end(); ++i) {
376 6888 : result.push_back(todouble(*i));
377 : }
378 1288 : return result;
379 0 : }
380 :
381 1512 : std::string CEPHandler::ReadLine(std::ifstream& s) {
382 : std::string line;
383 1512 : std::getline(s, line);
384 : size_t lastNWChar = line.find_last_not_of(" \n\r\t");
385 1512 : if (lastNWChar != std::string::npos) {
386 1456 : line.erase(lastNWChar + 1);
387 : }
388 1512 : 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 536 : VEHPHEMLightJSON::Vehicle_Data* VEHPHEMLightJSON::VEH::getVehicleData() {
408 536 : return &privateVehicleData;
409 : }
410 :
411 56 : VEHPHEMLightJSON::Aux_Data* VEHPHEMLightJSON::VEH::getAuxiliariesData() {
412 56 : return &privateAuxiliariesData;
413 : }
414 :
415 224 : VEHPHEMLightJSON::Engine_Data* VEHPHEMLightJSON::VEH::getEngineData() {
416 224 : return &privateEngineData;
417 : }
418 :
419 280 : VEHPHEMLightJSON::Rollres_Data* VEHPHEMLightJSON::VEH::getRollingResData() {
420 280 : return &privateRollingResData;
421 : }
422 :
423 308 : VEHPHEMLightJSON::FullLoadDrag_Data* VEHPHEMLightJSON::VEH::getFLDData() {
424 308 : return &privateFLDData;
425 : }
426 :
427 582 : VEHPHEMLightJSON::Transmission_Data* VEHPHEMLightJSON::VEH::getTransmissionData() {
428 582 : return &privateTransmissionData;
429 : }
430 :
431 28 : const std::string& VEHPHEMLightJSON::Vehicle_Data::getMassType() const {
432 28 : return privateMassType;
433 : }
434 :
435 28 : void VEHPHEMLightJSON::Vehicle_Data::setMassType(const std::string& value) {
436 28 : privateMassType = value;
437 28 : }
438 :
439 28 : const std::string& VEHPHEMLightJSON::Vehicle_Data::getFuelType() const {
440 28 : return privateFuelType;
441 : }
442 :
443 28 : void VEHPHEMLightJSON::Vehicle_Data::setFuelType(const std::string& value) {
444 28 : privateFuelType = value;
445 28 : }
446 :
447 28 : const std::string& VEHPHEMLightJSON::Vehicle_Data::getCalcType() const {
448 28 : return privateCalcType;
449 : }
450 :
451 28 : void VEHPHEMLightJSON::Vehicle_Data::setCalcType(const std::string& value) {
452 28 : privateCalcType = value;
453 28 : }
454 :
455 28 : const double& VEHPHEMLightJSON::Vehicle_Data::getMass() const {
456 28 : return privateMass;
457 : }
458 :
459 28 : void VEHPHEMLightJSON::Vehicle_Data::setMass(const double& value) {
460 28 : privateMass = value;
461 28 : }
462 :
463 28 : const double& VEHPHEMLightJSON::Vehicle_Data::getLoading() const {
464 28 : return privateLoading;
465 : }
466 :
467 28 : void VEHPHEMLightJSON::Vehicle_Data::setLoading(const double& value) {
468 28 : privateLoading = value;
469 28 : }
470 :
471 28 : const double& VEHPHEMLightJSON::Vehicle_Data::getRedMassWheel() const {
472 28 : return privateRedMassWheel;
473 : }
474 :
475 28 : void VEHPHEMLightJSON::Vehicle_Data::setRedMassWheel(const double& value) {
476 28 : privateRedMassWheel = value;
477 28 : }
478 :
479 28 : const double& VEHPHEMLightJSON::Vehicle_Data::getWheelDiameter() const {
480 28 : return privateWheelDiameter;
481 : }
482 :
483 28 : void VEHPHEMLightJSON::Vehicle_Data::setWheelDiameter(const double& value) {
484 28 : privateWheelDiameter = value;
485 28 : }
486 :
487 28 : const double& VEHPHEMLightJSON::Vehicle_Data::getCw() const {
488 28 : return privateCw;
489 : }
490 :
491 28 : void VEHPHEMLightJSON::Vehicle_Data::setCw(const double& value) {
492 28 : privateCw = value;
493 28 : }
494 :
495 28 : const double& VEHPHEMLightJSON::Vehicle_Data::getA() const {
496 28 : return privateA;
497 : }
498 :
499 28 : void VEHPHEMLightJSON::Vehicle_Data::setA(const double& value) {
500 28 : privateA = value;
501 28 : }
502 :
503 2 : const double& VEHPHEMLightJSON::Vehicle_Data::getMileage() const {
504 2 : return privateMileage;
505 : }
506 :
507 28 : void VEHPHEMLightJSON::Vehicle_Data::setMileage(const double& value) {
508 28 : privateMileage = value;
509 28 : }
510 :
511 28 : const double& VEHPHEMLightJSON::Rollres_Data::getFr0() const {
512 28 : return privateFr0;
513 : }
514 :
515 28 : void VEHPHEMLightJSON::Rollres_Data::setFr0(const double& value) {
516 28 : privateFr0 = value;
517 28 : }
518 :
519 28 : const double& VEHPHEMLightJSON::Rollres_Data::getFr1() const {
520 28 : return privateFr1;
521 : }
522 :
523 28 : void VEHPHEMLightJSON::Rollres_Data::setFr1(const double& value) {
524 28 : privateFr1 = value;
525 28 : }
526 :
527 28 : const double& VEHPHEMLightJSON::Rollres_Data::getFr2() const {
528 28 : return privateFr2;
529 : }
530 :
531 28 : void VEHPHEMLightJSON::Rollres_Data::setFr2(const double& value) {
532 28 : privateFr2 = value;
533 28 : }
534 :
535 28 : const double& VEHPHEMLightJSON::Rollres_Data::getFr3() const {
536 28 : return privateFr3;
537 : }
538 :
539 28 : void VEHPHEMLightJSON::Rollres_Data::setFr3(const double& value) {
540 28 : privateFr3 = value;
541 28 : }
542 :
543 28 : const double& VEHPHEMLightJSON::Rollres_Data::getFr4() const {
544 28 : return privateFr4;
545 : }
546 :
547 28 : void VEHPHEMLightJSON::Rollres_Data::setFr4(const double& value) {
548 28 : privateFr4 = value;
549 28 : }
550 :
551 168 : VEHPHEMLightJSON::ICE_Data* VEHPHEMLightJSON::Engine_Data::getICEData() {
552 168 : return &privateICEData;
553 : }
554 :
555 56 : VEHPHEMLightJSON::EM_Data* VEHPHEMLightJSON::Engine_Data::getEMData() {
556 56 : return &privateEMData;
557 : }
558 :
559 28 : const double& VEHPHEMLightJSON::ICE_Data::getPrated() const {
560 28 : return privatePrated;
561 : }
562 :
563 28 : void VEHPHEMLightJSON::ICE_Data::setPrated(const double& value) {
564 28 : privatePrated = value;
565 28 : }
566 :
567 28 : const double& VEHPHEMLightJSON::ICE_Data::getnrated() const {
568 28 : return privatenrated;
569 : }
570 :
571 28 : void VEHPHEMLightJSON::ICE_Data::setnrated(const double& value) {
572 28 : privatenrated = value;
573 28 : }
574 :
575 28 : const double& VEHPHEMLightJSON::ICE_Data::getIdling() const {
576 28 : return privateIdling;
577 : }
578 :
579 28 : void VEHPHEMLightJSON::ICE_Data::setIdling(const double& value) {
580 28 : privateIdling = value;
581 28 : }
582 :
583 0 : const double& VEHPHEMLightJSON::EM_Data::getPrated() const {
584 0 : return privatePrated;
585 : }
586 :
587 28 : void VEHPHEMLightJSON::EM_Data::setPrated(const double& value) {
588 28 : privatePrated = value;
589 28 : }
590 :
591 0 : const double& VEHPHEMLightJSON::EM_Data::getnrated() const {
592 0 : return privatenrated;
593 : }
594 :
595 28 : void VEHPHEMLightJSON::EM_Data::setnrated(const double& value) {
596 28 : privatenrated = value;
597 28 : }
598 :
599 28 : const double& VEHPHEMLightJSON::Aux_Data::getPauxnorm() const {
600 28 : return privatePauxnorm;
601 : }
602 :
603 28 : void VEHPHEMLightJSON::Aux_Data::setPauxnorm(const double& value) {
604 28 : privatePauxnorm = value;
605 28 : }
606 :
607 28 : const double& VEHPHEMLightJSON::FullLoadDrag_Data::getP_n_max_v0() const {
608 28 : return privateP_n_max_v0;
609 : }
610 :
611 28 : void VEHPHEMLightJSON::FullLoadDrag_Data::setP_n_max_v0(const double& value) {
612 28 : privateP_n_max_v0 = value;
613 28 : }
614 :
615 28 : const double& VEHPHEMLightJSON::FullLoadDrag_Data::getP_n_max_p0() const {
616 28 : return privateP_n_max_p0;
617 : }
618 :
619 28 : void VEHPHEMLightJSON::FullLoadDrag_Data::setP_n_max_p0(const double& value) {
620 28 : privateP_n_max_p0 = value;
621 28 : }
622 :
623 28 : const double& VEHPHEMLightJSON::FullLoadDrag_Data::getP_n_max_v1() const {
624 28 : return privateP_n_max_v1;
625 : }
626 :
627 28 : void VEHPHEMLightJSON::FullLoadDrag_Data::setP_n_max_v1(const double& value) {
628 28 : privateP_n_max_v1 = value;
629 28 : }
630 :
631 28 : const double& VEHPHEMLightJSON::FullLoadDrag_Data::getP_n_max_p1() const {
632 28 : return privateP_n_max_p1;
633 : }
634 :
635 28 : void VEHPHEMLightJSON::FullLoadDrag_Data::setP_n_max_p1(const double& value) {
636 28 : privateP_n_max_p1 = value;
637 28 : }
638 :
639 56 : std::map<std::string, std::vector<double> >& VEHPHEMLightJSON::FullLoadDrag_Data::getDragCurve() {
640 56 : return privateDragCurve;
641 : }
642 :
643 56 : void VEHPHEMLightJSON::FullLoadDrag_Data::setDragCurve(const std::map<std::string, std::vector<double> >& value) {
644 : privateDragCurve = value;
645 56 : }
646 :
647 28 : VEHPHEMLightJSON::FullLoadDrag_Data::FullLoadDrag_Data() {
648 28 : setDragCurve(std::map<std::string, std::vector<double> >());
649 28 : }
650 :
651 28 : const double& VEHPHEMLightJSON::Transmission_Data::getAxelRatio() const {
652 28 : return privateAxelRatio;
653 : }
654 :
655 28 : void VEHPHEMLightJSON::Transmission_Data::setAxelRatio(const double& value) {
656 28 : privateAxelRatio = value;
657 28 : }
658 :
659 498 : std::map<std::string, std::vector<double> >& VEHPHEMLightJSON::Transmission_Data::getTransm() {
660 498 : return privateTransm;
661 : }
662 :
663 56 : void VEHPHEMLightJSON::Transmission_Data::setTransm(const std::map<std::string, std::vector<double> >& value) {
664 : privateTransm = value;
665 56 : }
666 :
667 28 : VEHPHEMLightJSON::Transmission_Data::Transmission_Data() {
668 28 : setTransm(std::map<std::string, std::vector<double> >());
669 28 : }
670 : }
|
