36 TOpenWAM::TOpenWAM() {
62 BCButerflyValve = NULL;
68 #ifdef ConcentricElement
73 #ifdef ParticulateFilter
85 BCExhaustValve = NULL;
89 VolumetricCompressor = NULL;
90 MatlabDischarge = NULL;
92 PerdidaPresion = NULL;
107 AtmosphericComposition = NULL;
110 SimulationType = nmEstacionario;
122 SimulationDuration = 0.;
123 CyclesWithoutThemalInertia = 0;
124 AmbientPressure = 0.;
125 AmbientTemperature = 0.;
126 ConvergenceFirstTime =
false;
141 NumberOfConcentrics = 0;
148 NumberOfReedValves = 0;
149 NumberOfWasteGates = 0;
150 NumberOfExternalCalculatedValves = 0;
153 NumberOfConnections = 0;
154 NumberOfVolumetricCompressors = 0;
155 NumberOfExhaustValves = 0;
156 NumberOfIntakeValves = 0;
157 NumberOfCompressorsConnections = 0;
158 NumberOfInjectionEnds = 0;
159 NumberOfConectionsBetweenPlenums = 0;
160 NumberOfButerflyValves = 0;
166 NumberOfVenturis = 0;
169 NumberOfDirectionalJunctions = 0;
176 NumberOfControllers = 0;
186 NumberOfTurbines = 0;
193 NumberOfCompressors = 0;
198 InitFlowIndependentNumThreads();
201 TOpenWAM::~TOpenWAM() {
208 printf(
"INFO: *** CMT : SIMULATION FINISHED CORRECTLY ***\n");
211 if(GestorWAM != NULL)
212 GestorWAM->ProcesoTranscurrido(100);
219 if(NumberOfPlenums > 0 && Plenum != NULL) {
220 for(
int i = 0; i < NumberOfPlenums; i++)
225 if(NumberOfTurbines > 0 && Turbine != NULL)
228 if(NumberOfVenturis > 0 && Venturi != NULL)
232 if(NumberOfCompressors > 0 && Compressor != NULL) {
233 for(
int i = 0; i < NumberOfCompressors; i++)
234 delete Compressor[i];
239 if(NumberOfPipes > 0 && Pipe != NULL) {
240 for(
int i = 0; i < NumberOfPipes; i++)
246 #ifdef ConcentricElement
247 if(NumberOfConcentrics > 0 && Concentric != NULL) {
248 for(
int i = 0; i < NumberOfConcentrics; i++)
249 delete Concentric[i];
255 #ifdef ParticulateFilter
256 if(NumberOfDPF > 0 && DPF != NULL) {
257 for(
int i = 0; i < NumberOfDPF; i++)
264 if(NumberOfConnections > 0 && *BC != NULL) {
265 for(
int i = 0; i < NumberOfConnections; i++)
271 if(NumberOfAxis > 0 && Axis != NULL) {
272 for(
int i = 0; i < NumberOfAxis; i++)
278 if(EngineBlock && Engine != NULL) {
283 if(NumberOfIntakeValves > 0 && BCIntakeValve != NULL)
284 delete[] BCIntakeValve;
286 if(NumberOfExhaustValves > 0 && BCExhaustValve != NULL)
287 delete[] BCExhaustValve;
289 if(NumberOfWasteGates > 0 && BCWasteGate != NULL)
290 delete[] BCWasteGate;
292 if(NumberOfReedValves > 0 && BCReedValve != NULL)
293 delete[] BCReedValve;
295 if(NumberOfVolumetricCompressors > 0 && VolumetricCompressor != NULL)
296 delete[] VolumetricCompressor;
298 if(nematlab > 0 && MatlabDischarge != NULL)
299 delete[] MatlabDischarge;
301 if(NumberOfInjectionEnds > 0 && InjectionEnd != NULL)
302 delete[] InjectionEnd;
304 if(NumTCCPerdidaPresion > 0 && PerdidaPresion != NULL)
305 delete[] PerdidaPresion;
307 if(SpeciesName != NULL)
308 delete[] SpeciesName;
310 if(AtmosphericComposition != NULL)
311 delete[] AtmosphericComposition;
316 if(TypeOfValve != NULL) {
317 for(
int i = 0; i < NumberOfValves; i++) {
318 delete TypeOfValve[i];
320 delete[] TypeOfValve;
323 if(StatorTurbine != NULL) {
324 for(
int i = 0; i < NumberOfTurbines; i++) {
325 delete[] StatorTurbine[i];
327 delete[] StatorTurbine;
330 if(RotorTurbine != NULL)
331 delete[] RotorTurbine;
333 if(CCCalcExtern != NULL)
334 delete[] CCCalcExtern;
336 if(BCButerflyValve != NULL)
337 delete[] BCButerflyValve;
340 if(GestorWAM != NULL) {
341 GestorWAM->NuevoMensaje(
"Simulation finished correctly.");
342 GestorWAM->Terminar();
349 void TOpenWAM::CleanLabelsX() {
355 fileinput =
"tmp.wam";
357 fetmp = fopen(fileinput.c_str(),
"w");
363 while(!feof(FileInput)) {
364 fgets(line, 800, FileInput);
368 while(line[cc] ==
' ' || line[cc] ==
'\t') {
371 while(line[cc] !=
'\n' && cc < 800) {
373 if(line[cc] ==
'>') {
378 if(line[cc] ==
'<') {
381 linenew[cc2] = line[cc];
388 for(
int i = cc2 + 1; i < 800; ++i) {
391 if(linenew[0] !=
'\n') {
392 fputs(linenew, fetmp);
401 void TOpenWAM::CleanLabels() {
403 std::regex labelregex(
"<.*>");
404 std::regex blregex(
"^[:s:]*\\r$");
405 std::regex blregex2(
"^[:s:]*$");
408 ofstream sFileOutput;
409 string strline, strline_out;
411 sFileInput.open(fileinput.c_str());
412 fileinput.append(
".tmp");
413 sFileOutput.open(fileinput.c_str());
415 while(!sFileInput.eof()) {
416 std::getline(sFileInput, strline);
417 strline_out = std::regex_replace(strline, labelregex,
"");
418 if(std::regex_match(strline_out, blregex) ==
false && std::regex_match(strline_out, blregex2) ==
false) {
419 sFileOutput << strline_out << std::endl;
426 void TOpenWAM::ReadInputData(
char* FileName) {
430 FileInput = fopen(FileName,
"r");
431 if(FileInput == NULL) {
432 printf(
"ERROR: The input file do not exist.\n");
434 if(GestorWAM != NULL) {
435 GestorWAM->NuevoMensaje(
"The input file do not exist.");
436 GestorWAM->Terminar();
447 fileinput = FileName;
455 FileInput = fopen(fileinput.c_str(),
"r");
457 std::perror(
"File opening failed: ");
462 if(GestorWAM != NULL)
463 GestorWAM->NuevoMensaje(
"Reading input data.");
468 std::cout <<
"=======================" << std::endl;
469 std::cout <<
" OpenWAM " << VERSION_PRINT << std::endl;
470 std::cout <<
"=======================" << std::endl << std::endl;
472 std::cout <<
"THE MODEL IS READING THE INPUT DATA" << std::endl << std::endl;
477 fscanf(FileInput,
"%d", &OpenWAMVersion);
478 if(OpenWAMVersion != vers) {
479 printf(
"ERROR: THE WAM VERSION IS NOT CORRECT FOR THESE INPUT DATA\n\n");
480 printf(
" OpenWAM version: %d", vers);
481 printf(
" File version: %d", OpenWAMVersion);
485 fscanf(FileInput,
"%d ", &ind);
486 ind == 0 ? Independent = false : Independent =
true;
494 #ifdef ParticulateFilter
498 #ifdef ConcentricElement
510 ReadTurbochargerAxis();
516 ReadOutput(FileName);
518 fgetpos(FileInput, &fileposition);
521 for(
int i = 0; i < NumberOfConnections; i++) {
522 if(BC[i]->getTipoCC() == nmCompresor) {
523 dynamic_cast<TCCCompresor*
>(BC[i])->ReadCompressorData(fileinput.c_str(), fileposition, Compressor);
527 FileInput = fopen(fileinput.c_str(),
"r");
528 fsetpos(FileInput, &fileposition);
531 fscanf(FileInput,
"%d", &dll);
532 dll == 0 ? ThereIsDLL = false : ThereIsDLL =
true;
538 printf(
"INFO: The input file data has been readed correctly\n\n");
540 if(GestorWAM != NULL)
541 GestorWAM->NuevoMensaje(
"Performing preliminar calculations...");
545 if(remove(fileinput.c_str()) != 0)
546 perror(
"WARNING: Error deleting file\n");
548 puts(
"INFO: File successfully deleted\n");
551 void TOpenWAM::ReadDataDLL() {
554 fgetpos(FileInput, &filepos);
558 EXTERN->LeeFicherosDLL(fileinput.c_str(), filepos, controlvalv, nematlab, Engine[0]->getGeometria().NCilin,
559 NumberOfExternalCalculatedValves, CountVGT, SpeciesNumber,
560 NumTCCPerdidaPresion);
562 EXTERN->LeeFicherosDLL(fileinput.c_str(), filepos, controlvalv, nematlab, 0, NumberOfExternalCalculatedValves, CountVGT,
563 SpeciesNumber, NumTCCPerdidaPresion);
566 EXTERN->Lee_Sens_Tubos(fileinput.c_str(), filepos, Pipe, SpeciesModel, ThereIsEGR, ThereIsFuel);
568 EXTERN->Lee_Sens_Dep(fileinput.c_str(), filepos, Plenum, SpeciesModel, ThereIsEGR, ThereIsFuel);
570 EXTERN->Lee_Sens_TG(fileinput.c_str(), filepos, Axis);
572 EXTERN->Lee_Sens_Turbina(fileinput.c_str(), filepos, Turbine);
574 EXTERN->Lee_Sens_Cil(fileinput.c_str(), filepos, Engine);
576 EXTERN->Lee_Sens_Vent(fileinput.c_str(), filepos, Venturi);
578 EXTERN->Lee_Sens_Motor(fileinput.c_str(), filepos, Theta, Engine[0]->getRegimen(), AcumulatedTime);
579 if(NumberOfConectionsBetweenPlenums != 0)
580 EXTERN->Lee_Sens_UED(fileinput.c_str(), filepos, BC);
581 EXTERN->Lectura_Datos_Adicionales(fileinput.c_str(), filepos);
582 EXTERN->IniciaEntradaDLL();
584 FileInput = fopen(fileinput.c_str(),
"r");
585 fsetpos(FileInput, &filepos);
587 }
catch(exception & N) {
589 std::cout <<
"ERROR: ReadDataDLL" << std::endl;
590 std::cout <<
"Tipo de error: " << N.what() << std::endl;
591 err <<
"ERROR: ReadDataDLL" << N.what();
596 void TOpenWAM::ReadGeneralData() {
600 int tipociclo = 0, tipomod = 0, tipocalculoespecies = 0;
601 double fracciontotal = 0.;
602 int haycombustible, tipocombustible, tipogamma, EGR, IntEGR = 1;
604 double *CompAtmosfera;
606 fscanf(FileInput,
"%lf %lf ", &agincr, &SimulationDuration);
607 fscanf(FileInput,
"%lf %lf ", &AmbientPressure, &AmbientTemperature);
608 fscanf(FileInput,
"%d %d ", &tipocalculoespecies, &tipogamma);
612 GammaCalculation = nmGammaConstante;
615 GammaCalculation = nmComposicion;
618 GammaCalculation = nmComposicionTemperatura;
622 fscanf(FileInput,
"%d ", &hayBQ);
624 hayBQ == 0 ? EngineBlock = false : EngineBlock =
true;
627 fscanf(FileInput,
"%d %d %d", &tipociclo, &tipomod, &EGR);
633 EGR == 0 ? ThereIsEGR = false : ThereIsEGR =
true;
634 EGR == 0 ? IntEGR = 1 : IntEGR = 0;
637 SimulationType = nmEstacionario;
640 SimulationType = nmTransitorioCarga;
643 SimulationType = nmTransitorioRegimen;
646 SimulationType = nmTransitorioRegimenExterno;
649 if(SimulationType != nmEstacionario) {
650 fscanf(FileInput,
"%d", &CyclesWithoutThemalInertia);
654 switch(tipocalculoespecies) {
656 SpeciesModel = nmCalculoSimple;
659 SpeciesModel = nmCalculoCompleto;
663 if(SpeciesModel == nmCalculoCompleto) {
664 fscanf(FileInput,
"%d ", &haycombustible);
665 haycombustible == 0 ? ThereIsFuel = false : ThereIsFuel =
true;
666 if(haycombustible == 1) {
667 fscanf(FileInput,
"%d ", &tipocombustible);
668 switch(tipocombustible) {
673 FuelType = nmGasolina;
677 }
else if(haycombustible == 0) {
681 DatEsp =
new stEspecies[SpeciesNumber - IntEGR];
684 DatEsp[0].Nombre =
"O2";
685 DatEsp[0].R = 259.825;
688 DatEsp[1].Nombre =
"CO2";
689 DatEsp[1].R = 188.9207;
692 DatEsp[2].Nombre =
"H2O";
693 DatEsp[2].R = 461.398;
696 DatEsp[3].Nombre =
"HC";
697 DatEsp[3].R = 638.58;
700 DatEsp[4].Nombre =
"Soot";
701 DatEsp[4].R = 692.866;
704 DatEsp[5].Nombre =
"NOx";
705 DatEsp[5].R = 277.1466;
708 DatEsp[6].Nombre =
"CO";
709 DatEsp[6].R = 296.837;
711 if(haycombustible == 1) {
712 if(FuelType == nmDiesel) {
714 DatEsp[7].Nombre =
"Diesel";
716 }
else if(FuelType == nmGasolina) {
718 DatEsp[7].Nombre =
"Gasolina";
719 DatEsp[7].R = 72.425;
722 DatEsp[8].Nombre =
"N2";
723 DatEsp[8].R = 296.837;
727 DatEsp[9].Nombre =
"EGR";
732 DatEsp[7].Nombre =
"N2";
733 DatEsp[7].R = 296.837;
737 DatEsp[8].Nombre =
"EGR";
742 }
else if(SpeciesModel == nmCalculoSimple) {
743 fscanf(FileInput,
"%d ", &haycombustible);
744 if(haycombustible == 1) {
745 fscanf(FileInput,
"%d ", &tipocombustible);
746 switch(tipocombustible) {
751 FuelType = nmGasolina;
755 }
else if(haycombustible == 0) {
759 DatEsp =
new stEspecies[SpeciesNumber - IntEGR];
761 DatEsp[0].Nombre =
new char[15];
762 DatEsp[0].Nombre =
"GasesQuemados";
765 if(haycombustible == 1) {
766 if(FuelType == nmDiesel) {
768 DatEsp[1].Nombre =
"Diesel";
770 }
else if(FuelType == nmGasolina) {
772 DatEsp[1].Nombre =
"Gasolina";
773 DatEsp[1].R = 72.425;
776 DatEsp[2].Nombre =
"Aire";
781 DatEsp[3].Nombre =
"EGR";
786 DatEsp[1].Nombre =
"Aire";
791 DatEsp[2].Nombre =
"EGR";
796 SpeciesName = DatEsp;
800 CompAtmosfera =
new double[SpeciesNumber - IntEGR];
801 for(
int i = 0; i < SpeciesNumber - 1; i++) {
802 fscanf(FileInput,
"%lf ", &CompAtmosfera[i]);
804 fracciontotal += CompAtmosfera[i];
807 CompAtmosfera[SpeciesNumber - 1] = 0.;
808 if(fracciontotal != 1.) {
809 std::cout <<
"ERROR: The total mass fraction must be equal to 1. Check your input data " << std::endl;
813 AtmosphericComposition = CompAtmosfera;
815 }
catch(exception & N) {
816 std::cout <<
"ERROR: ReadGeneralData" << std::endl;
817 std::cout <<
"Tipo de error: " << N.what() << std::endl;
822 void TOpenWAM::ReadEngine()
829 fgetpos(FileInput, &filepos);
832 Engine[0] =
new TBloqueMotor(AmbientPressure, AmbientTemperature, SpeciesModel, SpeciesNumber, GammaCalculation,
834 Engine[0]->LeeMotor(fileinput.c_str(), filepos, SimulationType, CyclesWithoutThemalInertia, EngineType,
835 AtmosphericComposition);
836 FileInput = fopen(fileinput.c_str(),
"r");
837 fsetpos(FileInput, &filepos);
840 }
catch(exception & N) {
841 std::cout <<
"ERROR: ReadEngine " << std::endl;
842 std::cout <<
"Tipo de error: " << N.what() << std::endl;
847 void TOpenWAM::ReadPipes() {
852 fscanf(FileInput,
"%d ", &NumberOfPipes);
853 Pipe =
new TTubo*[NumberOfPipes];
854 printf(
"Number of pipes: %d\n", NumberOfPipes);
857 fgetpos(FileInput, &filepos);
860 for(
int i = 0; i < NumberOfPipes; i++) {
861 Pipe[i] =
new TTubo(SpeciesNumber, i, SimulationDuration, Engine, SpeciesModel, GammaCalculation, ThereIsEGR);
868 cout <<
"INFO: Pipe n. " << i + 1 <<
" - N. of cells " << Pipe[i]->getNin() <<
" - Mesh size = " <<
873 FileInput = fopen(fileinput.c_str(),
"r");
874 fsetpos(FileInput, &filepos);
875 }
catch(exception & N) {
876 std::cout <<
"ERROR: ReadPipes" << std::endl;
877 std::cout <<
"Tipo de error: " << N.what() << std::endl;
882 void TOpenWAM::ReadDPF() {
884 #ifdef ParticulateFilter
887 fscanf(FileInput,
"%d ", &NumberOfDPF);
888 DPF =
new TDPF*[NumberOfDPF];
889 printf(
"Number of DPF: %d\n", NumberOfDPF);
891 fgetpos(FileInput, &filepos);
894 for(
int i = 0; i < NumberOfDPF; i++) {
895 DPF[i] =
new TDPF(i + 1, Engine, SpeciesNumber);
896 DPF[i]->LeeDatosDPF(fileinput.c_str(), filepos, SpeciesModel,
897 GammaCalculation, ThereIsEGR, Engine);
900 FileInput = fopen(fileinput.c_str(),
"r");
901 fsetpos(FileInput, &filepos);
903 }
catch(exception & N) {
904 std::cout <<
"ERROR: ReadDPF" << std::endl;
905 std::cout <<
"Tipo de error: " << N.what() << std::endl;
910 void TOpenWAM::ReadConcentric() {
912 #ifdef ConcentricElement
916 fscanf(FileInput,
"%d ", &NumberOfConcentrics);
918 printf(
"Number of concentrics: %d\n", NumberOfConcentrics);
920 for(
int i = 0; i < NumberOfConcentrics; i++) {
921 fscanf(FileInput,
"%d ", &numducts);
922 fgetpos(FileInput, &filepos);
926 #ifdef ParticulateFilter
927 Concentric[i]->LeeDatosTuboConcentrico(fileinput.c_str(), filepos,
930 Concentric[i]->LeeDatosTuboConcentrico(fileinput.c_str(), filepos,
933 }
else if(numducts == 1) {
935 #ifdef ParticulateFilter
936 Concentric[i]->LeeDatosTuboConcentrico(fileinput.c_str(), filepos,
939 Concentric[i]->LeeDatosTuboConcentrico(fileinput.c_str(), filepos,
943 FileInput = fopen(fileinput.c_str(),
"r");
944 fsetpos(FileInput, &filepos);
947 }
catch(exception & N) {
948 std::cout <<
"ERROR: ReadConcentric" << std::endl;
949 std::cout <<
"Tipo de error: " << N.what() << std::endl;
954 void TOpenWAM::ReadValves() {
956 fscanf(FileInput,
"%d ", &NumberOfValves);
960 int NumTValvula4T = 0;
961 int NumberOfReedValves = 0;
962 int NumTDiscoRotativo = 0;
963 int NumTLumbrera = 0;
964 int NumTValvulaContr = 0;
965 int NumberOfWasteGates = 0;
966 int NumTEstatorTurbina = 0;
967 int NumTRotorTurbina = 0;
968 int NumTCDExterno = 0;
969 int NumberOfButerflyValves = 0;
973 for(
int i = 0; i < NumberOfValves; ++i) {
974 fscanf(FileInput,
"%d ", &tipval);
977 TypeOfValve[i] =
new TCDFijo();
987 TypeOfValve[i] =
new TLamina();
988 val = NumberOfReedValves;
989 NumberOfReedValves++;
993 val = NumTDiscoRotativo;
997 TypeOfValve[i] =
new TLumbrera(Engine[0]->getGeometria().Biela, Engine[0]->getGeometria().Carrera);
1003 val = NumTValvulaContr;
1008 val = NumberOfWasteGates;
1009 NumberOfWasteGates++;
1013 val = NumTEstatorTurbina;
1014 NumTEstatorTurbina++;
1018 val = NumTRotorTurbina;
1024 val = NumTCDExterno;
1029 val = NumberOfButerflyValves;
1030 NumberOfButerflyValves++;
1033 fgetpos(FileInput, &filepos);
1036 TypeOfValve[i]->LeeDatosIniciales(fileinput.c_str(), filepos, val, EngineBlock, NULL);
1038 TypeOfValve[i]->LeeDatosIniciales(fileinput.c_str(), filepos, val, EngineBlock, Engine[0]);
1040 FileInput = fopen(fileinput.c_str(),
"r");
1041 fsetpos(FileInput, &filepos);
1044 }
catch(exception & N) {
1046 std::cout <<
"ERROR: ReadValves" << std::endl;
1047 std::cout <<
"Tipo de error: " << N.what() << std::endl;
1048 err <<
"ERROR: ReadValves" << N.what();
1053 void TOpenWAM::ReadPlenums() {
1057 int tipoDep, ncv = 0;
1058 int numeroturbina = 0, numeroventuri = 0;
1061 int numeroturbinas = 0, numeroventuris = 0, numerounionesdireccionales = 0;
1063 fscanf(FileInput,
"%d ", &NumberOfPlenums);
1065 fscanf(FileInput,
"%d %d %d", &numeroturbinas, &numeroventuris, &numerounionesdireccionales);
1067 fgetpos(FileInput, &filepos);
1070 NumberOfTurbines = 0;
1071 NumberOfVenturis = 0;
1072 NumberOfDirectionalJunctions = 0;
1073 if(NumberOfPlenums != 0) {
1074 Plenum =
new TDeposito*[NumberOfPlenums];
1076 if(NumberOfPlenums != 0) {
1077 for(
int i = 0; i < NumberOfPlenums; ++i) {
1078 FileInput = fopen(fileinput.c_str(),
"r");
1079 fsetpos(FileInput, &filepos);
1080 fscanf(FileInput,
"%d ", &tipoDep);
1081 fgetpos(FileInput, &filepos);
1085 Plenum[i] =
new TDepVolCte(i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1086 Plenum[i]->LeeDatosGeneralesDepositos(fileinput.c_str(), filepos);
1089 Plenum[i] =
new TDepVolVariable(i, ncv, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1090 Plenum[i]->LeeDatosGeneralesDepositos(fileinput.c_str(), filepos);
1091 dynamic_cast<TDepVolVariable*
>(Plenum[i])->LeeDatosDepVolVariable(fileinput.c_str(), filepos, EngineBlock);
1095 FileInput = fopen(fileinput.c_str(),
"r");
1096 fsetpos(FileInput, &filepos);
1097 fscanf(FileInput,
"%d ", &numeroturbina);
1098 Plenum[i] =
new TTurbinaSimple(i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1099 dynamic_cast<TTurbina*
>(Plenum[i])->PutNumeroTurbina(numeroturbina);
1100 fgetpos(FileInput, &filepos);
1102 Plenum[i]->LeeDatosGeneralesDepositos(fileinput.c_str(), filepos);
1103 dynamic_cast<TTurbina*
>(Plenum[i])->LeeTurbina(fileinput.c_str(), filepos);
1104 dynamic_cast<TTurbina*
>(Plenum[i])->IniciaMedias();
1105 NumberOfTurbines = NumberOfTurbines + 1;
1108 FileInput = fopen(fileinput.c_str(),
"r");
1109 fsetpos(FileInput, &filepos);
1110 fscanf(FileInput,
"%d ", &numeroturbina);
1111 Plenum[i] =
new TTurbinaTwin(i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1112 dynamic_cast<TTurbina*
>(Plenum[i])->PutNumeroTurbina(numeroturbina);
1113 fgetpos(FileInput, &filepos);
1115 Plenum[i]->LeeDatosGeneralesDepositos(fileinput.c_str(), filepos);
1116 dynamic_cast<TTurbina*
>(Plenum[i])->LeeTurbina(fileinput.c_str(), filepos);
1117 dynamic_cast<TTurbina*
>(Plenum[i])->IniciaMedias();
1118 NumberOfTurbines = NumberOfTurbines + 1;
1121 FileInput = fopen(fileinput.c_str(),
"r");
1122 fsetpos(FileInput, &filepos);
1123 fscanf(FileInput,
"%d ", &numeroventuri);
1124 Plenum[i] =
new TVenturi(i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1125 dynamic_cast<TVenturi*
>(Plenum[i])->PutNumeroVenturi(numeroventuri);
1126 fgetpos(FileInput, &filepos);
1128 NumberOfVenturis = NumberOfVenturis + 1;
1129 Plenum[i]->LeeDatosGeneralesDepositos(fileinput.c_str(), filepos);
1130 dynamic_cast<TVenturi*
>(Plenum[i])->LeeDatosVenturi(fileinput.c_str(), filepos);
1133 NumberOfDirectionalJunctions = NumberOfDirectionalJunctions + 1;
1134 Plenum[i] =
new TUnionDireccional(i, NumberOfDirectionalJunctions, SpeciesModel, SpeciesNumber, GammaCalculation,
1136 Plenum[i]->LeeDatosGeneralesDepositos(fileinput.c_str(), filepos);
1137 dynamic_cast<TUnionDireccional*
>(Plenum[i])->LeeDatosUnionDireccional(fileinput.c_str(), filepos);
1143 FileInput = fopen(fileinput.c_str(),
"r");
1144 fsetpos(FileInput, &filepos);
1146 if(NumberOfTurbines > 0)
1147 Turbine =
new TTurbina*[NumberOfTurbines];
1148 for(
int i = 0; i < NumberOfTurbines; i++) {
1149 for(
int j = 0; j < NumberOfPlenums; j++) {
1150 if(Plenum[j]->getTipoDeposito() == nmTurbinaSimple || Plenum[j]->getTipoDeposito() == nmTurbinaTwin) {
1151 if(i + 1 ==
dynamic_cast<TTurbina*
>(Plenum[j])->getNumeroTurbina()) {
1152 Turbine[i] =
dynamic_cast<TTurbina*
>(Plenum[j]);
1157 if(NumberOfVenturis > 0)
1158 Venturi =
new TVenturi*[NumberOfVenturis];
1159 for(
int i = 0; i < NumberOfVenturis; i++) {
1160 for(
int j = 0; j < NumberOfPlenums; j++) {
1161 if(Plenum[j]->getTipoDeposito() == nmVenturi) {
1162 if(
dynamic_cast<TVenturi*
>(Plenum[j])->getNumeroVenturi() == i + 1) {
1163 Venturi[i] =
dynamic_cast<TVenturi*
>(Plenum[j]);
1168 }
catch(exception & N) {
1169 std::cout <<
"ERROR: ReadPlenums " << std::endl;
1170 std::cout <<
"Tipo de error: " << N.what() << std::endl;
1175 void TOpenWAM::ReadCompressors() {
1178 int TipoCompresor = 0;
1179 int haydeposito = 0, numid = 0, numid1 = 0, numid2 = 0;
1181 fscanf(FileInput,
"%d ", &NumberOfCompressors);
1182 Compressor =
new TCompresor*[NumberOfCompressors];
1183 fgetpos(FileInput, &filepos);
1186 for(
int j = 0; j < NumberOfCompressors; j++) {
1187 FileInput = fopen(fileinput.c_str(),
"r");
1188 fsetpos(FileInput, &filepos);
1189 fscanf(FileInput,
"%d ", &TipoCompresor);
1190 if(TipoCompresor == 0) {
1192 fscanf(FileInput,
"%d ", &haydeposito);
1193 if(haydeposito == 1)
1194 fscanf(FileInput,
"%d ", &numid);
1196 if(TipoCompresor == 1) {
1198 fscanf(FileInput,
"%d %d", &numid1, &numid2);
1200 fgetpos(FileInput, &filepos);
1202 switch(TipoCompresor) {
1204 Compressor[j] =
new TCompTubDep(j, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1205 (
dynamic_cast<TCompTubDep*
>(Compressor[j]))->LeeCompresor(fileinput.c_str(), filepos);
1208 Compressor[j] =
new TCompresorDep(j, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1209 (
dynamic_cast<TCompresorDep*
>(Compressor[j]))->LeeCompresor(fileinput.c_str(), filepos);
1212 Compressor[j] =
new TCompTubos(j, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1213 (
dynamic_cast<TCompTubos*
>(Compressor[j]))->LeeCompresor(fileinput.c_str(), filepos);
1217 FileInput = fopen(fileinput.c_str(),
"r");
1218 fsetpos(FileInput, &filepos);
1219 }
catch(exception & N) {
1220 std::cout <<
"ERROR: ReadCompressors " << std::endl;
1221 std::cout <<
"Tipo de error: " << N.what() << std::endl;
1226 void TOpenWAM::ReadConnections() {
1229 int numerocv = 0, contador = 0;
1230 int NumTCCDescargaExtremoAbierto = 0, NumTCCExtremoCerrado = 0, NumTCCExtremoAnecoico = 0, NumTCCPulso = 0,
1231 NumTCCUnionEntreTubos = 0, NumTCCCilindro = 0, NumTCCDeposito = 0,
1232 NumTCCRamificacion = 0, NumTCCEntradaCompresor = 0, NumTCCPreVble = 0;
1233 NumTCCPerdidaPresion = 0;
1235 int numerovalvula = 0, quevalv;
1236 int NumTCCExternalConnection = 0;
1239 int numnodosimples, numpulsos, numnododep, numperdpresion, numcomprtornillo, numextremosinyeccion,
1240 numnodoentredepositos, numentradacompresor, numentradapresionestatica;
1242 fscanf(FileInput,
"%d ", &NumberOfConnections);
1244 fscanf(FileInput,
"%d %d %d %d %d %d %d %d %d", &numnodosimples, &numpulsos, &numnododep, &numperdpresion,
1245 &numcomprtornillo, &numextremosinyeccion, &numnodoentredepositos,
1246 &numentradacompresor, &numentradapresionestatica);
1249 printf(
"Number of boundary condition: %d\n", NumberOfConnections);
1250 fgetpos(FileInput, &filepos);
1252 if(NumberOfConnections != 0) {
1253 for(
int i = 0; i <= NumberOfConnections - 1; ++i) {
1254 FileInput = fopen(fileinput.c_str(),
"r");
1255 fsetpos(FileInput, &filepos);
1256 fscanf(FileInput,
"%d ", &TipoCC);
1257 fgetpos(FileInput, &filepos);
1263 NumTCCDescargaExtremoAbierto++;
1264 #ifdef ParticulateFilter
1265 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1266 Pipe, NumberOfDPF, DPF);
1268 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1270 BC[i]->AsignAmbientConditions(AmbientTemperature, AmbientPressure, AtmosphericComposition);
1273 BC[i] =
new TCCDescargaExtremoAbierto(nmOpenEndReservoir, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1274 NumTCCDescargaExtremoAbierto++;
1275 #ifdef ParticulateFilter
1276 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1277 Pipe, NumberOfDPF, DPF);
1279 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1285 NumTCCDescargaExtremoAbierto++;
1287 #ifdef ParticulateFilter
1288 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1289 Pipe, NumberOfDPF, DPF);
1291 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1295 BC[i] =
new TCCExtremoCerrado(nmClosedEnd, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1296 NumTCCExtremoCerrado++;
1297 BC[i]->AsignaTubos(NumberOfPipes, Pipe);
1300 BC[i] =
new TCCExtremoAnecoico(nmAnechoicEnd, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1301 NumTCCExtremoAnecoico++;
1302 BC[i]->AsignaTubos(NumberOfPipes, Pipe);
1305 BC[i] =
new TCCPulso(nmIncidentPressurWave, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1307 #ifdef ParticulateFilter
1308 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1309 Pipe, NumberOfDPF, DPF);
1311 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1315 BC[i] =
new TCCUnionEntreTubos(nmPipesConnection, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1316 NumTCCUnionEntreTubos++;
1317 #ifdef ParticulateFilter
1318 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1319 Pipe, NumberOfDPF, DPF);
1321 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1325 BC[i] =
new TCCCilindro(nmIntakeValve, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1327 NumberOfIntakeValves++;
1328 #ifdef ParticulateFilter
1329 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1330 Pipe, NumberOfDPF, DPF);
1332 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1336 BC[i] =
new TCCCilindro(nmExhaustValve, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1338 NumberOfExhaustValves++;
1339 #ifdef ParticulateFilter
1340 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1341 Pipe, NumberOfDPF, DPF);
1343 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1347 BC[i] =
new TCCPerdidadePresion(nmLinearPressureLoss, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1348 NumTCCPerdidaPresion++;
1349 #ifdef ParticulateFilter
1350 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1351 Pipe, NumberOfDPF, DPF);
1353 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1357 BC[i] =
new TCCPerdidadePresion(nmQuadraticPressureLoss, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1358 NumTCCPerdidaPresion++;
1359 #ifdef ParticulateFilter
1360 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1361 Pipe, NumberOfDPF, DPF);
1363 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1367 BC[i] =
new TCCDeposito(nmPipeToPlenumConnection, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1369 #ifdef ParticulateFilter
1370 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1371 Pipe, NumberOfDPF, DPF);
1373 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1377 BC[i] =
new TCCRamificacion(nmBranch, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1378 NumTCCRamificacion++;
1379 BC[i]->AsignaTubos(NumberOfPipes, Pipe);
1382 FileInput = fopen(fileinput.c_str(),
"r");
1383 fsetpos(FileInput, &filepos);
1384 fscanf(FileInput,
"%d ", &numerocv);
1385 fgetpos(FileInput, &filepos);
1390 NumberOfVolumetricCompressors++;
1391 dynamic_cast<TCCCompresorVolumetrico*
>(BC[i])->LeeCCCompresorVol(fileinput.c_str(), filepos, NumberOfPipes, Pipe,
1396 BC[i] =
new TCCExtremoInyeccion(nmInjectionEnd, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1397 NumberOfInjectionEnds++;
1398 #ifdef ParticulateFilter
1399 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1400 Pipe, NumberOfDPF, DPF);
1402 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1406 BC[i] =
new TCCEntradaCompresor(nmEntradaCompre, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1407 NumTCCEntradaCompresor++;
1408 #ifdef ParticulateFilter
1409 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1410 Pipe, NumberOfDPF, DPF);
1412 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1416 BC[i] =
new TCCUnionEntreDepositos(nmUnionEntreDepositos, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1417 NumberOfConectionsBetweenPlenums++;
1421 BC[i] =
new TCCCompresor(nmCompresor, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1422 NumberOfCompressorsConnections++;
1423 dynamic_cast<TCCCompresor*
>(BC[i])->LeeNumeroCompresor(fileinput.c_str(), filepos);
1426 BC[i] =
new TCCPreVble(nmPresionVble, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1428 #ifdef ParticulateFilter
1429 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1430 Pipe, NumberOfDPF, DPF);
1432 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1436 BC[i] =
new TCFDConnection(nmCFDConnection, i, SpeciesModel, SpeciesNumber, GammaCalculation, ThereIsEGR);
1437 #ifdef ParticulateFilter
1438 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1439 Pipe, NumberOfDPF, DPF);
1441 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1447 NumTCCExternalConnection++;
1448 #ifdef ParticulateFilter
1449 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes,
1450 Pipe, NumberOfDPF, DPF);
1452 BC[i]->ReadBoundaryData(fileinput.c_str(), filepos, NumberOfPipes, Pipe, NumberOfDPF, NULL);
1456 if(BC[i]->getTipoCC() == nmIntakeValve || BC[i]->getTipoCC() == nmExhaustValve
1457 || BC[i]->getTipoCC() == nmPipeToPlenumConnection || BC[i]->getTipoCC() == nmUnionEntreDepositos) {
1458 FileInput = fopen(fileinput.c_str(),
"r");
1459 fsetpos(FileInput, &filepos);
1460 fscanf(FileInput,
"%d ", &quevalv);
1461 fgetpos(FileInput, &filepos);
1463 if(BC[i]->getTipoCC() == nmIntakeValve || BC[i]->getTipoCC() == nmExhaustValve) {
1464 dynamic_cast<TCCCilindro*
>(BC[i])->AsignaTipoValvula(TypeOfValve, quevalv, numerovalvula);
1465 }
else if(BC[i]->getTipoCC() == nmPipeToPlenumConnection) {
1466 dynamic_cast<TCCDeposito*
>(BC[i])->AsignaTipoValvula(TypeOfValve, quevalv, numerovalvula);
1467 if(TypeOfValve[quevalv - 1]->getTypeOfValve() == nmLamina)
1468 NumberOfReedValves++;
1469 if(TypeOfValve[quevalv - 1]->getTypeOfValve() == nmWasteGate)
1470 NumberOfWasteGates++;
1471 if(TypeOfValve[quevalv - 1]->getTypeOfValve() == nmCalcExtern)
1472 NumberOfExternalCalculatedValves++;
1473 if(TypeOfValve[quevalv - 1]->getTypeOfValve() == nmMariposa)
1474 NumberOfButerflyValves++;
1475 }
else if(BC[i]->getTipoCC() == nmUnionEntreDepositos) {
1477 if(TypeOfValve[quevalv - 1]->getTypeOfValve() == nmLamina)
1478 NumberOfReedValves++;
1479 if(TypeOfValve[quevalv - 1]->getTypeOfValve() == nmWasteGate)
1480 NumberOfWasteGates++;
1481 if(TypeOfValve[quevalv - 1]->getTypeOfValve() == nmCalcExtern)
1482 NumberOfExternalCalculatedValves++;
1483 if(TypeOfValve[quevalv - 1]->getTypeOfValve() == nmMariposa)
1484 NumberOfButerflyValves++;
1491 FileInput = fopen(fileinput.c_str(),
"r");
1492 fsetpos(FileInput, &filepos);
1494 if(NumberOfIntakeValves > 0) {
1497 for(
int j = 0; j < NumberOfConnections; j++) {
1498 if(BC[j]->getTipoCC() == nmIntakeValve) {
1499 BCIntakeValve[contador] =
dynamic_cast<TCCCilindro*
>(BC[j]);
1505 if(NumberOfExhaustValves > 0) {
1508 for(
int j = 0; j < NumberOfConnections; j++) {
1509 if(BC[j]->getTipoCC() == nmExhaustValve) {
1510 BCExhaustValve[contador] =
dynamic_cast<TCCCilindro*
>(BC[j]);
1516 if(NumberOfVolumetricCompressors > 0) {
1519 for(
int j = 0; j < NumberOfConnections; j++) {
1520 if(BC[j]->getTipoCC() == nmVolumetricCompressor) {
1529 if(NumTCCPerdidaPresion > 0) {
1532 for(
int j = 0; j < NumberOfConnections; j++) {
1533 if(BC[j]->getTipoCC() == nmLinearPressureLoss || BC[j]->getTipoCC() == nmQuadraticPressureLoss) {
1543 for(
int j = 0; j < NumberOfConnections; j++) {
1544 if(BC[j]->getTipoCC() == nmOpenEndCalcExtern) {
1551 if(NumberOfInjectionEnds > 0) {
1554 for(
int j = 0; j < NumberOfConnections; j++) {
1555 if(BC[j]->getTipoCC() == nmInjectionEnd) {
1562 if(NumberOfReedValves > 0) {
1565 for(
int j = 0; j < NumberOfConnections; j++) {
1566 if(BC[j]->getTipoCC() == nmPipeToPlenumConnection) {
1567 if(
dynamic_cast<TCCDeposito*
>(BC[j])->getValvula()->getTypeOfValve() == nmLamina) {
1568 BCReedValve[contador] =
dynamic_cast<TCCDeposito*
>(BC[j]);
1571 }
else if(BC[j]->getTipoCC() == nmUnionEntreDepositos) {
1580 if(NumberOfWasteGates > 0) {
1583 for(
int j = 0; j < NumberOfConnections; j++) {
1584 if(BC[j]->getTipoCC() == nmPipeToPlenumConnection) {
1585 if(
dynamic_cast<TCCDeposito*
>(BC[j])->getValvula()->getTypeOfValve() == nmWasteGate) {
1586 BCWasteGate[contador] = BC[j];
1589 }
else if(BC[j]->getTipoCC() == nmUnionEntreDepositos) {
1591 BCWasteGate[contador] = BC[j];
1598 if(NumberOfExternalCalculatedValves > 0) {
1599 CCCalcExtern =
new TTipoValvula*[NumberOfExternalCalculatedValves];
1601 for(
int j = 0; j < NumberOfConnections; j++) {
1602 if(BC[j]->getTipoCC() == nmPipeToPlenumConnection) {
1603 if(
dynamic_cast<TCCDeposito*
>(BC[j])->getValvula()->getTypeOfValve() == nmCalcExtern) {
1604 CCCalcExtern[contador] =
dynamic_cast<TCCDeposito*
>(BC[j])->getValvula();
1607 }
else if(BC[j]->getTipoCC() == nmUnionEntreDepositos) {
1609 CCCalcExtern[contador] =
dynamic_cast<TCCDeposito*
>(BC[j])->getValvula();
1616 if(NumberOfButerflyValves > 0) {
1617 BCButerflyValve =
new TTipoValvula*[NumberOfButerflyValves];
1619 for(
int j = 0; j < NumberOfConnections; j++) {
1620 if(BC[j]->getTipoCC() == nmPipeToPlenumConnection) {
1621 if(
dynamic_cast<TCCDeposito*
>(BC[j])->getValvula()->getTypeOfValve() == nmMariposa) {
1622 BCButerflyValve[contador] =
dynamic_cast<TCCDeposito*
>(BC[j])->getValvula();
1625 }
else if(BC[j]->getTipoCC() == nmUnionEntreDepositos) {
1627 BCButerflyValve[contador] =
dynamic_cast<TCCDeposito*
>(BC[j])->getValvula();
1633 if(NumTCCExternalConnection > 0) {
1636 Asigned =
new bool[NumTCCExternalConnection];
1638 for(
int i = 0; i < NumTCCExternalConnection; ++i) {
1642 for(
int i = 0; i < NumberOfConnections; ++i) {
1643 if(BC[i]->getTipoCC() == nmExternalConnection) {
1645 if(Asigned[ID] ==
true) {
1646 std::cout <<
"ERROR: There are two external connection with the same ID" << std::endl;
1650 if(ID >= NumTCCExternalConnection) {
1651 std::cout <<
"ERROR: Wrong ID for the external connection node " << i << std::endl;
1658 }
catch(exception & N) {
1659 std::cout <<
" ERROR : ReadConnections " << std::endl;
1660 std::cout <<
" Tipo de error : " << N.what() << std::endl;
1665 void TOpenWAM::ReadTurbochargerAxis() {
1669 fscanf(FileInput,
" %d ", &NumberOfAxis);
1670 if(NumberOfAxis != 0) {
1673 fgetpos(FileInput, &filepos);
1676 if(NumberOfAxis != 0) {
1677 for(
int i = 0; i < NumberOfAxis; ++i) {
1679 Axis[i] =
new TEjeTurbogrupo(i, Engine[0]->getGeometria().NCilin);
1682 Axis[i]->ReadTurbochargerAxis(fileinput.c_str(), filepos, Compressor, Turbine);
1683 Axis[i]->IniciaMedias();
1687 FileInput = fopen(fileinput.c_str(),
"r");
1688 fsetpos(FileInput, &filepos);
1689 }
catch(exception & N) {
1690 std::cout <<
" ERROR : ReadTurbochargerAxis " << std::endl;
1691 std::cout <<
" Tipo de error : " << N.what() << std::endl;
1696 void TOpenWAM::ReadSensors() {
1699 fscanf(FileInput,
" %d ", &NumberOfSensors);
1701 fgetpos(FileInput, &filepos);
1704 if(NumberOfSensors > 0) {
1705 Sensor =
new TSensor*[NumberOfSensors];
1706 for(
int i = 0; i < NumberOfSensors; i++) {
1708 Sensor[i]->
ReadSensor(fileinput.c_str(), filepos);
1712 FileInput = fopen(fileinput.c_str(),
"r");
1713 fsetpos(FileInput, &filepos);
1716 void TOpenWAM::ReadControllers() {
1720 fscanf(FileInput,
" %d ", &NumberOfControllers);
1721 if(NumberOfControllers > 0) {
1722 Controller =
new TController*[NumberOfControllers];
1723 for(
int i = 0; i < NumberOfControllers; i++) {
1724 fscanf(FileInput,
" %d ", &ctrl);
1736 Controller[i] =
new TGain(i);
1739 fgetpos(FileInput, &filepos);
1743 FileInput = fopen(fileinput.c_str(),
"r");
1744 fsetpos(FileInput, &filepos);
1749 void TOpenWAM::ReadOutput(
char* FileName) {
1752 fgetpos(FileInput, &filepos);
1758 #ifdef ParticulateFilter
1759 Output->ReadAverageResults(fileinput.c_str(), filepos, Pipe, EngineBlock, Engine,
1760 Plenum, Axis, Compressor, Turbine, BC, DPF, VolumetricCompressor,
1761 Venturi, Sensor, Controller, SimulationDuration, FileName);
1763 Output->ReadInstantaneousResults(fileinput.c_str(), filepos, Engine, Plenum, Pipe,
1764 Venturi, BC, DPF, Axis, Compressor, Turbine, VolumetricCompressor,
1765 BCWasteGate, NumberOfWasteGates, BCReedValve, NumberOfReedValves,
1766 Sensor, Controller, FileName);
1768 Output->ReadAverageResults(fileinput.c_str(), filepos, Pipe, EngineBlock, Engine, Plenum, Axis, Compressor, Turbine, BC,
1769 NULL, VolumetricCompressor, Venturi, Sensor, Controller,
1770 SimulationDuration, FileName);
1772 Output->ReadInstantaneousResults(fileinput.c_str(), filepos, Engine, Plenum, Pipe, Venturi, BC, NULL, Axis, Compressor,
1773 Turbine, VolumetricCompressor, BCWasteGate, NumberOfWasteGates, BCReedValve,
1774 NumberOfReedValves, Sensor, Controller, FileName);
1777 Output->ReadSpaceTimeResults(fileinput.c_str(), filepos, Pipe, Engine, Plenum);
1779 FileInput = fopen(FileName,
"r");
1780 fsetpos(FileInput, &filepos);
1783 void TOpenWAM::InitializeParameters() {
1787 InitializeRunningAngles();
1789 CalculateNewHeatPositions();
1791 for(
int j = 0; j < NumberOfPipes; ++j) {
1792 Pipe[j]->IniciaVariablesFundamentalesTubo();
1793 Pipe[j]->InicializaCaracteristicas(BC);
1794 Pipe[j]->IniciaVariablesTransmisionCalor(BC, Engine, AmbientTemperature);
1795 Pipe[j]->CalculaCoeficientePeliculaInterior(BC);
1796 Pipe[j]->EstabilidadMetodoCalculo();
1798 #ifdef ParticulateFilter
1799 for(
int i = 0; i < NumberOfDPF; i++) {
1800 DPF[i]->IniciaVariablesTransmisionCalor(AmbientTemperature);
1801 for(
int j = 0; j < DPF[i]->getNumeroHacesCanales(); j++) {
1802 (DPF[i]->GetCanal(j, 0))->IniciaVariablesFundamentalesCanalDPF();
1803 (DPF[i]->GetCanal(j, 0))->InicializaCaracteristicas(BC);
1804 (DPF[i]->GetCanal(j, 0))->CalculaCoeficientePeliculaInterior();
1805 (DPF[i]->GetCanal(j, 1))->IniciaVariablesFundamentalesCanalDPF();
1806 (DPF[i]->GetCanal(j, 1))->InicializaCaracteristicas(BC);
1807 (DPF[i]->GetCanal(j, 1))->CalculaCoeficientePeliculaInterior();
1808 if(j == DPF[i]->getNumeroHacesCanales() - 1) {
1809 (DPF[i]->GetCanal(j, 0))->CalculaCoeficientePeliculaExterior
1811 (DPF[i]->GetCanal(j, 1))->CalculaCoeficientePeliculaExterior
1814 #ifdef ConcentricElement
1815 DPF[i]->CalculoResistenciaTC_First_Time(j, Pipe, Concentric);
1817 DPF[i]->CalculoResistenciaTC_First_Time(j, Pipe, NULL);
1820 #ifdef ConcentricElement
1821 DPF[i]->InicializaDPF(NumberOfConcentrics, Concentric);
1823 DPF[i]->InicializaDPF(NumberOfConcentrics, NULL);
1825 DPF[i]->CalculoEstabilidadDPF();
1829 FirstIteration =
true;
1831 #ifdef ConcentricElement
1832 for(
int i = 0; i < NumberOfConcentrics; i++) {
1833 Concentric[i]->CalculaResistenciasdePared(BC);
1838 for(
int i = 0; i < NumberOfConnections; i++) {
1839 BC[i]->TuboCalculandose(10000);
1845 for(
int i = 0; i < NumberOfPlenums; i++) {
1846 if(Plenum[i]->getTipoDeposito() == nmDepVolVble) {
1852 for(
int i = 0; i < NumberOfPlenums; i++) {
1853 if(Plenum[i]->getTipoDeposito() == nmDepVolVble) {
1854 dynamic_cast<TDepVolVariable*
>(Plenum[i])->UpdateSpeed(Engine[0]->getRegimen());
1858 Engine[0]->IniciaVarCilindro();
1859 Engine[0]->AsignacionTuboRendVol(Pipe);
1861 if((Engine[0]->getNumTuboRendVol() > NumberOfPipes) || Engine[0]->getNumTuboRendVol() <= 0) {
1862 printf(
" ERROR : The intake pipe selectec for calculating \n ");
1863 printf(
" the volumetric efficieny is not correct(pipe n. %d)\n ", Engine[0]->getTuboRendVol()->getNumeroTubo());
1864 throw Exception(
" ERROR : The pipe selected for calculating the volumetric efficiency is not correct ");
1867 if(EXTERN->getmodcomb()) {
1868 for(
int i = 0; i < Engine[0]->getGeometria().NCilin; i++) {
1869 Engine[0]->GetCilindro(i)->PutHayDLL(
true);
1870 Engine[0]->GetCilindro(i)->PutModComb(
true);
1873 for(
int i = 0; i < Engine[0]->getGeometria().NCilin; i++) {
1874 Engine[0]->GetCilindro(i)->PutHayDLL(
true);
1879 for(
int i = 0; i < Engine[0]->getGeometria().NCilin; i++) {
1880 Engine[0]->GetCilindro(i)->DefineCombustion();
1883 for(
int i = 0; i < NumberOfCompressors; i++) {
1884 Compressor[i]->Initialize();
1887 for(
int i = 0; i < NumberOfAxis; i++) {
1888 Axis[i]->InterpolaValoresMapa();
1889 Axis[i]->InitizlizeHTM(AmbientTemperature);
1892 for(
int i = 0; i < NumberOfConnections; i++) {
1893 if(BC[i]->getTipoCC() == nmPipeToPlenumConnection) {
1896 if(BC[i]->getTipoCC() == nmPipeToPlenumConnection && EngineBlock) {
1898 if(val->getTypeOfValve() == nmDiscoRotativo) {
1899 dynamic_cast<TDiscoRotativo*
>(val)->PutAngle0(Engine[0]->getTheta());
1907 void TOpenWAM::RunningControl() {
1909 double regimenficticio = 0.;
1913 Run.CycleDuration = 720;
1914 regimenficticio = 720. / 6 / SimulationDuration;
1917 agincr *= 6. * regimenficticio;
1920 Run.CycleDuration = Engine[0]->getAngTotalCiclo();
1921 thmax = SimulationDuration * Engine[0]->getAngTotalCiclo();
1922 grmax = thmax - Engine[0]->getAngTotalCiclo();
1925 }
catch(exception & N) {
1926 std::cout <<
" ERROR : RunningControl " << std::endl;
1927 std::cout <<
" Tipo de error : " << N.what() << std::endl;
1932 void TOpenWAM::InitializeRunningAngles() {
1940 Engine[0]->IniciaAnguloCalculo();
1941 Theta = Engine[0]->getTheta();
1947 }
catch(exception & N) {
1948 std::cout <<
" ERROR : InitizalizeRunningAngles " << std::endl;
1949 std::cout <<
" Tipo de error : " << N.what() << std::endl;
1954 void TOpenWAM::AllocateVGTData() {
1963 for(
int i = 0; i < NumberOfTurbines; i++) {
1964 StatorTurbine[i] =
new TEstatorTurbina*[Turbine[i]->getNumeroEntradas()];
1965 for(
int j = 0; j < NumberOfConnections; j++) {
1966 if(BC[j]->getTipoCC() == nmPipeToPlenumConnection) {
1967 if(
dynamic_cast<TCCDeposito*
>(BC[j])->getValvula()->getTypeOfValve() == nmStator) {
1972 }
else if(
dynamic_cast<TCCDeposito*
>(BC[j])->getValvula()->getTypeOfValve() == nmRotor) {
1975 if(RotorTurbine[i]->getTipoRotor() == nmRotVariable) {
1985 for(
int i = 0; i < NumberOfTurbines; i++) {
1986 if(RotorTurbine[i]->getTipoRotor() == nmRotVariable) {
1988 DatosTGV[tgv].Entradas = Turbine[i]->getNumeroEntradas();
1989 DatosTGV[tgv].Turbine = i;
1990 DatosTGV[tgv].Estator =
new TTipoValvula*[Turbine[i]->getNumeroEntradas()];
1991 DatosTGV[tgv].Rendimiento =
new double[Turbine[i]->getNumeroEntradas()];
1992 for(
int j = 0; j < Turbine[i]->getNumeroEntradas(); ++j) {
1993 if(Turbine[i]->GetCCEntrada(j)->getTipoCC() == nmPipeToPlenumConnection) {
1994 DatosTGV[tgv].Estator[j] =
dynamic_cast<TCCDeposito*
>(Turbine[i]->GetCCEntrada(j))->getValvula();
1995 }
else if(Turbine[i]->GetCCEntrada(j)->getTipoCC() == nmUnionEntreDepositos) {
1996 DatosTGV[tgv].Estator[j] =
dynamic_cast<TCCUnionEntreDepositos*
>(Turbine[i]->GetCCEntrada(j))->getValvula();
1998 DatosTGV[tgv].Rendimiento[j] = 0;
1999 if(Turbine[i]->GetCCSalida(0)->getTipoCC() == nmPipeToPlenumConnection) {
2000 DatosTGV[tgv].Rotor =
dynamic_cast<TCCDeposito*
>(Turbine[i]->GetCCSalida(0))->getValvula();
2002 printf(
" ERROR : Tubine output %d is not a connection plenum - pipe.", i + 1);
2005 Turbine[i]->AllocateDatosTGV(DatosTGV);
2009 }
catch(exception & N) {
2011 std::cout <<
" ERROR : AllocateVGTData " << std::endl;
2012 std::cout <<
" Tipo de error : " << N.what() << std::endl;
2013 err <<
" ERROR : dimensionado_tgvwam " << N.what();
2018 void TOpenWAM::ConnectFlowElements() {
2022 for(
int i = 0; i < Engine[0]->getGeometria().NCilin; i++) {
2023 dynamic_cast<TCilindro*
>(Engine[0]->GetCilindro(i))->AsignacionCC(BC, NumberOfConnections);
2025 for(
int i = 0; i < NumberOfConnections; i++) {
2026 if(BC[i]->getTipoCC() == nmIntakeValve || BC[i]->getTipoCC() == nmExhaustValve) {
2027 dynamic_cast<TCCCilindro*
>(BC[i])->AsignaCilindro(Engine[0]);
2032 for(
int i = 0; i < NumberOfConnections; i++) {
2033 if(BC[i]->getTipoCC() == nmCompresor) {
2034 dynamic_cast<TCCCompresor*
>(BC[i])->AsignData(Plenum, NumberOfPipes, Pipe, BC, NumberOfConnections,
2035 AtmosphericComposition, Compressor, AmbientTemperature, AmbientPressure);
2039 for(
int i = 0; i < NumberOfPlenums; i++) {
2040 Plenum[i]->AsignacionCC(BC, NumberOfConnections);
2041 if(Plenum[i]->getTipoDeposito() == nmTurbinaSimple || Plenum[i]->getTipoDeposito() == nmTurbinaTwin) {
2042 dynamic_cast<TTurbina*
>(Plenum[i])->AsignaEntradaSalidaCC();
2043 }
else if(Plenum[i]->getTipoDeposito() == nmVenturi) {
2044 dynamic_cast<TVenturi*
>(Plenum[i])->AsignaEntradaSalidaLateralCC();
2045 }
else if(Plenum[i]->getTipoDeposito() == nmUnionDireccional) {
2050 for(
int i = 0; i < NumberOfConnections; i++) {
2051 if(BC[i]->getTipoCC() == nmPipeToPlenumConnection) {
2052 dynamic_cast<TCCDeposito*
>(BC[i])->AsignaDeposito(Plenum);
2053 }
else if(BC[i]->getTipoCC() == nmUnionEntreDepositos) {
2058 for(
int i = 0; i < NumberOfPipes; i++) {
2059 Pipe[i]->ComunicacionTubo_CC(BC);
2062 for(
int i = 0; i < NumberOfCompressors; i++) {
2063 Compressor[i]->AsignAcousticElements(Pipe, Plenum);
2066 for(
int i = 0; i < NumberOfTurbines; i++) {
2067 Turbine[i]->AsignAcousticElements(Pipe);
2070 #ifdef ParticulateFilter
2071 for(
int i = 0; i < NumberOfDPF; i++) {
2072 for(
int j = 0; j < DPF[i]->getNumeroHacesCanales(); j++) {
2073 DPF[i]->GetCanal(j, 0)->ComunicacionCanal_CC(BC);
2074 DPF[i]->GetCanal(j, 1)->ComunicacionCanal_CC(BC);
2076 DPF[i]->ComunicacionTubos(BC, NumberOfConnections);
2081 void TOpenWAM::ConnectControlElements() {
2085 for(
int i = 0; i < NumberOfSensors; i++) {
2087 switch(Sensor[i]->ObjectSensed()) {
2092 case nmSensDeposito:
2103 for(
int i = 0; i < NumberOfControllers; ++i) {
2108 for(
int i = 0; i < NumberOfTurbines; i++) {
2109 Turbine[i]->AsignaRackController(Controller);
2111 for(
int i = 0; i < NumberOfButerflyValves; i++) {
2112 dynamic_cast<TMariposa*
>(BCButerflyValve[i])->AsignaLevController(Controller);
2114 for(
int i = 0; i < NumberOfIntakeValves; i++) {
2115 if(
dynamic_cast<TCCCilindro*
>(BCIntakeValve[i])->getValvula()->getTypeOfValve() == nmValvula4T) {
2116 dynamic_cast<TValvula4T*
>(
dynamic_cast<TCCCilindro*
>(BCIntakeValve[i])->getValvula())->AsignaLevController(Controller);
2119 for(
int i = 0; i < NumberOfExhaustValves; i++) {
2120 if(
dynamic_cast<TCCCilindro*
>(BCExhaustValve[i])->getValvula()->getTypeOfValve() == nmValvula4T) {
2121 dynamic_cast<TValvula4T*
>(
dynamic_cast<TCCCilindro*
>(BCExhaustValve[i])->getValvula())->AsignaLevController(Controller);
2126 Engine[0]->AsignRPMController(Controller);
2127 Engine[0]->AsignMfController(Controller);
2130 if(NumberOfAxis > 0)
2131 Axis[0]->AsignaRPMController(Controller);
2134 void TOpenWAM::InitialHeatTransferParameters() {
2136 CalculateNewHeatPositions();
2138 for(
int i = 0; i < NumberOfPipes; i++) {
2139 Pipe[i]->IniciaVariablesTransmisionCalor(BC, Engine, AmbientTemperature);
2140 Pipe[i]->CalculaCoeficientePeliculaInterior(BC);
2142 #ifdef ParticulateFilter
2143 for(
int i = 0; i < NumberOfDPF; i++) {
2144 DPF[i]->IniciaVariablesTransmisionCalor(AmbientTemperature);
2145 for(
int j = 0; j < DPF[i]->getNumeroHacesCanales(); j++) {
2146 (DPF[i]->GetCanal(j, 0))->CalculaCoeficientePeliculaInterior();
2147 (DPF[i]->GetCanal(j, 1))->CalculaCoeficientePeliculaInterior();
2148 if(j == DPF[i]->getNumeroHacesCanales() - 1) {
2149 (DPF[i]->GetCanal(j, 0))->CalculaCoeficientePeliculaExterior
2151 (DPF[i]->GetCanal(j, 1))->CalculaCoeficientePeliculaExterior
2154 #ifdef ConcentricElement
2155 DPF[i]->CalculoResistenciaTC_First_Time(j, Pipe, Concentric);
2157 DPF[i]->CalculoResistenciaTC_First_Time(j, Pipe, NULL);
2165 void TOpenWAM::CalculateNewHeatPositions()
2171 bool Encontrado =
false;
2173 for(
int i = 0; i < NumberOfConnections; i++) {
2174 if(BC[i]->getTipoCC() == nmExhaustValve) {
2175 BC[i]->PutPosicionNodo(0.);
2177 BC[i]->PutPosicionNodo(100000.);
2181 for(
int i = 0; i < NumberOfExhaustValves; i++) {
2182 NodoOrigen = BCExhaustValve[i]->getNumeroCC();
2185 for(
int j = 0; j < NumberOfPipes; j++) {
2186 if(Pipe[j]->getNodoDer() == NodoOrigen) {
2187 NodoFin = Pipe[j]->getNodoIzq();
2189 }
else if(Pipe[j]->getNodoIzq() == NodoOrigen) {
2190 NodoFin = Pipe[j]->getNodoDer();
2194 CalculateDistance(NodoOrigen, NodoFin, Pipe[j]->getLongitudTotal(), NumberOfPlenums, NumberOfPipes, NumberOfConnections,
2201 for(
int i = 0; i < NumberOfPlenums; i++) {
2202 if(BC[NodoOrigen - 1]->getTipoCC() == nmPipeToPlenumConnection) {
2203 if(
dynamic_cast<TCCDeposito*
>(BC[NodoOrigen - 1])->getNumeroDeposito() == i + 1) {
2204 for(
int k = 0; k < NumberOfConnections; k++) {
2205 if(BC[k]->getTipoCC() == nmPipeToPlenumConnection) {
2207 (BC[k])->getNumeroDeposito()) {
2209 CalculateDistance(NodoOrigen, NodoFin, 0., NumberOfPlenums, NumberOfPipes, NumberOfConnections, Pipe, BC);
2212 if(BC[k]->getTipoCC() == nmUnionEntreDepositos) {
2214 (BC[k])->getNumeroDeposito1()
2216 (BC[k])->getNumeroDeposito2()) {
2218 CalculateDistance(NodoOrigen, NodoFin, 0., NumberOfPlenums, NumberOfPipes, NumberOfConnections, Pipe, BC);
2224 if(BC[NodoOrigen - 1]->getTipoCC() == nmUnionEntreDepositos) {
2226 for(
int k = 0; k < NumberOfConnections; k++) {
2227 if(BC[k]->getTipoCC() == nmPipeToPlenumConnection) {
2229 (BC[k])->getNumeroDeposito()) {
2231 CalculateDistance(NodoOrigen, NodoFin, 0., NumberOfPlenums, NumberOfPipes, NumberOfConnections, Pipe, BC);
2234 if(BC[k]->getTipoCC() == nmUnionEntreDepositos) {
2240 CalculateDistance(NodoOrigen, NodoFin, 0., NumberOfPlenums, NumberOfPipes, NumberOfConnections, Pipe, BC);
2245 for(
int k = 0; k < NumberOfConnections; k++) {
2246 if(BC[k]->getTipoCC() == nmPipeToPlenumConnection) {
2248 (BC[k])->getNumeroDeposito()) {
2250 CalculateDistance(NodoOrigen, NodoFin, 0., NumberOfPlenums, NumberOfPipes, NumberOfConnections, Pipe, BC);
2253 if(BC[k]->getTipoCC() == nmUnionEntreDepositos) {
2259 CalculateDistance(NodoOrigen, NodoFin, 0., NumberOfPlenums, NumberOfPipes, NumberOfConnections, Pipe, BC);
2268 }
catch(exception & N) {
2269 std::cout <<
" ERROR : CalculateNewHeatPositions " << std::endl;
2270 std::cout <<
" Tipo de error : " << N.what() << std::endl;
2275 void TOpenWAM::CalculateDistance(
int LNodoOrigen,
int LNodoFin,
double LLongitud,
int LNumberOfPlenums,
2279 int NodoOrigen1 = 0, NodoFin1 = 0;
2282 int j = SelectPipe(LPipe, LNumberOfPipes, LNodoOrigen, LNodoFin);
2283 if(LPipe[j]->getTipoTransCal() == 3 || LLongitud == 0.)
2288 if(LBC[LNodoFin - 1]->getPosicionNodo() > LBC[LNodoOrigen - 1]->getPosicionNodo() + Long) {
2289 LBC[LNodoFin - 1]->PutPosicionNodo(LBC[LNodoOrigen - 1]->getPosicionNodo() + Long);
2292 for(
int i = 0; i < LNumberOfPipes; i++) {
2293 if(LPipe[i]->getNodoDer() == LNodoFin && LPipe[i]->getNodoIzq() != LNodoOrigen) {
2294 NodoOrigen1 = LNodoFin;
2296 CalculateDistance(NodoOrigen1, NodoFin1, LPipe[i]->getLongitudTotal(), LNumberOfPlenums, LNumberOfPipes,
2297 LNumberOfConnections, LPipe, LBC);
2298 }
else if(LPipe[i]->getNodoIzq() == LNodoFin && LPipe[i]->getNodoDer() != LNodoOrigen) {
2299 NodoOrigen1 = LNodoFin;
2301 CalculateDistance(NodoOrigen1, NodoFin1, LPipe[i]->getLongitudTotal(), LNumberOfPlenums, LNumberOfPipes,
2302 LNumberOfConnections, LPipe, LBC);
2307 for(
int i = 0; i < LNumberOfPlenums; i++) {
2308 if(LBC[LNodoOrigen - 1]->getTipoCC() == nmPipeToPlenumConnection) {
2309 if(
dynamic_cast<TCCDeposito*
>(LBC[LNodoOrigen - 1])->getNumeroDeposito() == i + 1) {
2310 for(
int k = 0; k < LNumberOfConnections; k++) {
2311 if(LBC[k]->getTipoCC() == nmPipeToPlenumConnection) {
2313 (LBC[k])->getNumeroDeposito()) {
2314 NodoOrigen1 = LNodoFin;
2316 CalculateDistance(NodoOrigen1, NodoFin1, 0, LNumberOfPlenums, LNumberOfPipes, LNumberOfConnections, LPipe, LBC);
2319 if(LBC[k]->getTipoCC() == nmUnionEntreDepositos) {
2321 (LBC[k])->getNumeroDeposito1()
2323 (LBC[k])->getNumeroDeposito2()) {
2324 NodoOrigen1 = LNodoFin;
2326 CalculateDistance(NodoOrigen1, NodoFin1, 0, LNumberOfPlenums, LNumberOfPipes, LNumberOfConnections, LPipe, LBC);
2333 if(LBC[LNodoOrigen - 1]->getTipoCC() == nmUnionEntreDepositos) {
2335 for(
int k = 0; k < LNumberOfConnections; k++) {
2336 if(LBC[k]->getTipoCC() == nmPipeToPlenumConnection) {
2338 (LBC[k])->getNumeroDeposito()) {
2339 NodoOrigen1 = LNodoFin;
2341 CalculateDistance(NodoOrigen1, NodoFin1, 0, LNumberOfPlenums, LNumberOfPipes, LNumberOfConnections, LPipe, LBC);
2344 if(LBC[k]->getTipoCC() == nmUnionEntreDepositos) {
2349 NodoOrigen1 = LNodoFin;
2351 CalculateDistance(NodoOrigen1, NodoFin1, 0, LNumberOfPlenums, LNumberOfPipes, LNumberOfConnections, LPipe, LBC);
2356 for(
int k = 0; k < LNumberOfConnections; k++) {
2357 if(LBC[k]->getTipoCC() == nmPipeToPlenumConnection) {
2359 (LBC[k])->getNumeroDeposito()) {
2360 NodoOrigen1 = LNodoFin;
2362 CalculateDistance(NodoOrigen1, NodoFin1, 0, LNumberOfPlenums, LNumberOfPipes, LNumberOfConnections, LPipe, LBC);
2365 if(LBC[k]->getTipoCC() == nmUnionEntreDepositos) {
2370 NodoOrigen1 = LNodoFin;
2372 CalculateDistance(NodoOrigen1, NodoFin1, 0, LNumberOfPlenums, LNumberOfPipes, LNumberOfConnections, LPipe, LBC);
2381 }
catch(exception & N) {
2382 std::cout <<
" ERROR : CalculateDistance " << std::endl;
2383 std::cout <<
" Tipo de error : " << N.what() << std::endl;
2388 int TOpenWAM::SelectPipe(
TTubo **LPipe,
int LNumberOfPipes,
int Lnodo1,
int Lnodo2) {
2390 for(
int i = 0; i < LNumberOfPipes; i++) {
2391 if((LPipe[i]->getNodoDer() == Lnodo1 && LPipe[i]->getNodoIzq() == Lnodo2) || (LPipe[i]->getNodoDer() == Lnodo2
2392 && LPipe[i]->getNodoIzq() == Lnodo1)) {
2400 void TOpenWAM::Progress() {
2401 Percentage = (float)((Theta - ThetaIni) / (thmax - ThetaIni) * 100.);
2402 Increment = int(Percentage);
2403 if(Increment > Steps) {
2404 std::cout << std::endl;
2405 std::cout <<
"===================================" << std::endl;
2406 std::cout <<
"Progress : " << Percentage <<
"% " << std::endl;
2407 std::cout <<
"-----------------------------------" << std::endl;
2410 if(GestorWAM != NULL)
2411 GestorWAM->ProcesoTranscurrido(Percentage);
2415 float tiempoac = (current.time - begining.time) * 1000 + (current.millitm - begining.millitm);
2416 float tiempoest = tiempoac * 100 / Percentage - tiempoac;
2417 int seg = int(tiempoest / 1000.);
2418 int min = int(seg / 60.);
2419 int hor = int(min / 60.);
2420 int mil = int(tiempoest) - seg * 1000;
2421 seg = seg - min * 60;
2422 min = min - hor * 60;
2423 printf(
"Time left to the end: %d:%02d:%02d,%03d \n", hor, min, seg, mil);
2424 std::cout <<
"===================================" << std::endl;
2425 std::cout << std::endl;
2429 void TOpenWAM::DetermineTimeStepIndependent() {
2433 StudyInflowOutflowMass();
2437 RecalculateStability();
2441 void TOpenWAM::DetermineTimeStepCommon() {
2445 SearchMinimumTimeStep();
2447 if(JCurrent != -2) {
2448 TimeEndStep = Pipe[JCurrent]->getTime1();
2450 Run.TimeStep = Pipe[JCurrent]->getTime1() - Pipe[JCurrent]->getTime0();
2452 #ifdef ParticulateFilter
2453 TimeEndStep = DPF[JCurrentDPF]->getTime1DPF();
2454 Run.TimeStep = DPF[JCurrentDPF]->getTime1DPF() - DPF[JCurrentDPF]
2458 for(
int j = 0; j < NumberOfPipes; j++) {
2459 Pipe[j]->AjustaPaso(TimeEndStep);
2461 #ifdef ParticulateFilter
2462 for(
int j = 0; j < NumberOfDPF; j++) {
2463 DPF[j]->AjustaPaso(TimeEndStep);
2466 StudyInflowOutflowMass();
2472 void TOpenWAM::DetermineTimeStep(
double t) {
2476 SearchMinimumTimeStep();
2478 TimeEndStep = Pipe[JCurrent]->getTime1();
2480 Run.TimeStep = Pipe[JCurrent]->getTime1() - Pipe[JCurrent]->getTime0();
2482 for(
int j = 0; j < NumberOfPipes; j++) {
2483 Pipe[j]->AjustaPaso(TimeEndStep);
2486 StudyInflowOutflowMass();
2488 FixTimeStepExternal(t - Pipe[JCurrent]->getTime0());
2492 void TOpenWAM::MethodStability() {
2493 double TiempoFinPaso0 = 0.;
2495 TiempoFinPaso0 = TimeEndStep;
2497 for(
int j = 0; j < NumberOfPipes; j++) {
2498 if(Pipe[j]->getTime1() >= TimeEndStep) {
2499 TimeEndStep = Pipe[j]->getTime1();
2507 #ifdef ParticulateFilter
2508 for(
int j = 0; j < NumberOfDPF; j++) {
2509 if(DPF[j]->getTime1DPF() >= TimeEndStep) {
2510 TimeEndStep = DPF[j]->getTime1DPF();
2513 PipeStepMax =
false;
2519 #ifdef ConcentricElement
2520 for(
int j = 0; j < NumberOfConcentrics; j++) {
2521 if(Concentric[j]->GetHayDPF()) {
2522 if(Concentric[j]->GetTiempoDPF() > Concentric[j]->GetTiempo(0)) {
2523 Concentric[j]->PutTiempoDPF(Concentric[j]->GetTiempo(0));
2525 Concentric[j]->PutTiempo(0, Concentric[j]->GetTiempoDPF());
2528 if(Concentric[j]->GetTiempo(0) > Concentric[j]->GetTiempo(1)) {
2529 Concentric[j]->PutTiempo(0, Concentric[j]->GetTiempo(1));
2531 Concentric[j]->PutTiempo(1, Concentric[j]->GetTiempo(0));
2537 Run.TimeStep = TimeEndStep - TiempoFinPaso0;
2538 FirstIteration =
false;
2542 void TOpenWAM::SearchMinimumTimeStep() {
2544 double TMinimo = 1e5;
2546 TMinimo = Pipe[JStepMax]->getTime1();
2547 JCurrent = JStepMax;
2552 #ifdef ParticulateFilter
2553 TMinimo = DPF[JStepMaxDPF]->getTime1DPF();
2554 JCurrentDPF = JStepMaxDPF;
2556 TimeMinPipe =
false;
2561 for(
int j = NumberOfPipes - 1; j >= 0; j--) {
2562 if(Pipe[j]->getTime1() <= TMinimo && j != JStepMax) {
2563 TMinimo = Pipe[j]->getTime1();
2570 #ifdef ParticulateFilter
2571 for(
int j = 0; j < NumberOfDPF; j++) {
2572 if(DPF[j]->getTime1DPF() <= TMinimo && j != JStepMaxDPF) {
2573 TMinimo = DPF[j]->getTime1DPF();
2576 TimeMinPipe =
false;
2583 void TOpenWAM::StudyInflowOutflowMass() {
2585 double smadd = 0, cociente, gasta = 0, gaste = 0;
2587 bool masacil, masadep;
2588 double TMinimo = 0.;
2589 DeltaTPlenums = Run.TimeStep;
2600 for(
int j = 0; j < Engine[0]->GetCilindro(i)->getNumeroUnionesAdm(); ++j) {
2601 gasta +=
dynamic_cast<TCCCilindro*
>(Engine[0]->GetCilindro(i)->GetCCValvulaAdm(j))->getMassflow();
2604 for(
int j = 0; j < Engine[0]->GetCilindro(i)->getNumeroUnionesEsc(); ++j) {
2605 gaste +=
dynamic_cast<TCCCilindro*
>(Engine[0]->GetCilindro(i)->GetCCValvulaEsc(j))->getMassflow();
2607 if((Engine[0]->GetCilindro(i)->getMasa() - DeltaTPlenums * (gasta + gaste)) * 1e3 <= 1e-4) {
2611 }
while(masacil && i < Engine[0]->getGeometria().NCilin);
2613 if(masacil && NumberOfPlenums != 0) {
2617 SearchMinimumTime(i + 1, &TMinimo, Plenum);
2618 smadd = Plenum[i]->CriterioEstabilidad(TMinimo);
2619 for(
int j = 0; j < NumberOfPlenums; j++) {
2620 Plenum[j]->PutRealizado(
false);
2622 if(smadd * 1e3 <= 1e-4) {
2624 printf(
" WARNING : Plenum %d with critical conditions \n ", i + 1);
2626 cociente = smadd / Plenum[i]->getMasa();
2628 }
while(masadep && i < NumberOfPlenums && cociente < 2.);
2630 if(!masacil || !masadep || (cociente >= 2.)) {
2632 printf(
" WARNING : there is no mass in the cylinder \n ");
2634 printf(
" WARNING : there is no mass in the plenum \n ");
2636 printf(
" WARNING::Mass increment in a plenum too big \n ");
2637 std::cout <<
" Time step reduction in Theta = " << Theta << std::endl;
2638 std::cout <<
" Original time step : " << DeltaTPlenums << std::endl;
2639 DeltaTPlenums *= .95;
2640 std::cout <<
" New time step : " << DeltaTPlenums << std::endl;
2641 if(DeltaTPlenums <= 2e-7) {
2643 printf(
" ERROR : plenum n. %d too small \n ", i + 1);
2644 printf(
" ERROR : in time step \n ");
2645 throw Exception(
" ERROR : in time step ");
2648 }
while(!masacil || !masadep || (cociente >= 2.));
2649 }
catch(exception & N) {
2650 std::cout <<
" ERROR : StudyInflowOutflowMass " << std::endl;
2651 std::cout <<
" Tipo de error : " << N.what() << std::endl;
2656 void TOpenWAM::SearchMinimumTime(
int LNumDepInicial,
double *LTMinimo,
TDeposito **LPlenum) {
2658 int NumDepSiguiente = 0;
2660 *LTMinimo = 100000.;
2662 if(!LPlenum[LNumDepInicial - 1]->getEstudioEstabilidadRealizado()) {
2663 if(LPlenum[LNumDepInicial - 1]->getNUniones() != 0) {
2664 for(
int i = 0; i < LPlenum[LNumDepInicial - 1]->getNUniones(); i++) {
2665 if(LPlenum[LNumDepInicial - 1]->GetCCDeposito(i)->getUnionDPF()) {
2666 #ifdef ParticulateFilter
2667 if(LPlenum[LNumDepInicial - 1]->GetCCDeposito(i)
2668 ->GetTuboExtremo(0).DPF->getTime1DPF()
2670 *LTMinimo = LPlenum[LNumDepInicial - 1]
2671 ->GetCCDeposito(i)->GetTuboExtremo(0)
2672 .DPF->getTime1DPF();
2676 if(LPlenum[LNumDepInicial - 1]->GetCCDeposito(i)->GetTuboExtremo(0).Pipe->getTime1() < *LTMinimo) {
2677 *LTMinimo = LPlenum[LNumDepInicial - 1]->GetCCDeposito(i)->GetTuboExtremo(0).Pipe->
getTime1();
2683 LPlenum[LNumDepInicial - 1]->PutRealizado(
true);
2685 if(LPlenum[LNumDepInicial - 1]->getNUnionesED() != 0) {
2686 for(
int j = 0; j < LPlenum[LNumDepInicial - 1]->getNUnionesED(); j++) {
2687 if(LPlenum[LNumDepInicial - 1]->GetCCUnionEntreDep(j)->getTipoCC() == nmUnionEntreDepositos) {
2690 j))->getNumeroDeposito1() == LNumDepInicial) {
2692 j))->getNumeroDeposito2();
2695 j))->getNumeroDeposito1();
2698 if(LPlenum[LNumDepInicial - 1]->GetCCUnionEntreDep(j)->getTipoCC() == nmCompresor) {
2699 if(
dynamic_cast<TCCCompresor*
>(LPlenum[LNumDepInicial - 1]->GetCCUnionEntreDep(j))->getNumeroDepositoRot() ==
2701 NumDepSiguiente =
dynamic_cast<TCCCompresor*
>(LPlenum[LNumDepInicial - 1]->GetCCUnionEntreDep(
2702 j))->getNumeroDepositoEst();
2704 NumDepSiguiente =
dynamic_cast<TCCCompresor*
>(LPlenum[LNumDepInicial - 1]->GetCCUnionEntreDep(
2705 j))->getNumeroDepositoRot();
2708 if(!LPlenum[NumDepSiguiente - 1]->getEstudioEstabilidadRealizado()) {
2709 SearchMinimumTimeGroup(LTMinimo, NumDepSiguiente, LPlenum);
2714 }
catch(exception & N) {
2715 std::cout <<
" ERROR : SearchMinimumTime : " << std::endl;
2716 std::cout <<
" Tipo de error : " << N.what() << std::endl;
2721 void TOpenWAM::SearchMinimumTimeGroup(
double *LTMinimo,
int LNumDeposito,
TDeposito **LPlenum) {
2723 int NumDepSiguiente = 0;
2725 if(LPlenum[LNumDeposito - 1]->getNUniones() != 0) {
2726 for(
int i = 0; i < Plenum[LNumDeposito - 1]->getNUniones(); i++) {
2727 if(Plenum[LNumDeposito - 1]->GetCCDeposito(i)->getUnionDPF()) {
2728 #ifdef ParticulateFilter
2729 if(Plenum[LNumDeposito - 1]->GetCCDeposito(i)
2730 ->GetTuboExtremo(0).DPF->getTime1DPF() < *LTMinimo) {
2731 *LTMinimo = Plenum[LNumDeposito - 1]->GetCCDeposito(i)
2732 ->GetTuboExtremo(0).DPF->getTime1DPF();
2736 if(Plenum[LNumDeposito - 1]->GetCCDeposito(i)->GetTuboExtremo(0).Pipe->getTime1() < *LTMinimo) {
2737 *LTMinimo = Plenum[LNumDeposito - 1]->GetCCDeposito(i)->GetTuboExtremo(0).Pipe->
getTime1();
2743 Plenum[LNumDeposito - 1]->PutRealizado(
true);
2745 if(Plenum[LNumDeposito - 1]->getNUnionesED() != 0) {
2746 for(
int j = 0; j < Plenum[LNumDeposito - 1]->getNUnionesED(); j++) {
2747 if(Plenum[LNumDeposito - 1]->GetCCUnionEntreDep(j)->getTipoCC() == nmUnionEntreDepositos) {
2750 j))->getNumeroDeposito1() == LNumDeposito) {
2752 j))->getNumeroDeposito2();
2755 j))->getNumeroDeposito1();
2758 if(Plenum[LNumDeposito - 1]->GetCCUnionEntreDep(j)->getTipoCC() == nmCompresor) {
2759 if(
dynamic_cast<TCCCompresor*
>(Plenum[LNumDeposito - 1]->GetCCUnionEntreDep(j))->getNumeroDepositoRot() ==
2761 NumDepSiguiente =
dynamic_cast<TCCCompresor*
>(Plenum[LNumDeposito - 1]->GetCCUnionEntreDep(j))->getNumeroDepositoEst();
2763 NumDepSiguiente =
dynamic_cast<TCCCompresor*
>(Plenum[LNumDeposito - 1]->GetCCUnionEntreDep(j))->getNumeroDepositoRot();
2766 if(!Plenum[NumDepSiguiente - 1]->getEstudioEstabilidadRealizado()) {
2767 SearchMinimumTimeGroup(LTMinimo, NumDepSiguiente, Plenum);
2772 }
catch(exception & N) {
2773 std::cout <<
" ERROR : SearchMinimumTime en el deposito : " << std::endl;
2774 std::cout <<
" Tipo de error : " << N.what() << std::endl;
2779 void TOpenWAM::FixTimeStep() {
2781 double TInicialPaso = 0., m = 0., RegimenFicticio = 0.;
2782 TInicialPaso = TimeEndStep - Run.TimeStep;
2783 if(DeltaTPlenums < Run.TimeStep) {
2784 TimeEndStep = TInicialPaso + DeltaTPlenums;
2785 for(
int j = 0; j < NumberOfPipes; j++) {
2786 if(Pipe[j]->getTime1() > TimeEndStep) {
2787 Pipe[j]->AjustaPaso(TimeEndStep);
2793 #ifdef ParticulateFilter
2794 for(
int j = 0; j < NumberOfDPF; j++) {
2795 if(DPF[j]->getTime1DPF() > TimeEndStep) {
2796 DPF[j]->AjustaPaso(TimeEndStep);
2803 Run.TimeStep = DeltaTPlenums;
2806 Run.AngleStep = Run.TimeStep * 6. * Engine[0]->getRegimen();
2808 RegimenFicticio = 720. / 6. / SimulationDuration;
2809 Run.AngleStep = Run.TimeStep * 6. * RegimenFicticio;
2812 Theta += Run.AngleStep;
2814 Engine[0]->PutTheta(Theta);
2815 m = floor(Theta / Engine[0]->getAngTotalCiclo());
2816 CrankAngle = Theta - m * Engine[0]->getAngTotalCiclo();
2818 m = floor(Theta / 720.);
2819 CrankAngle = Theta - m * 720.;
2821 AcumulatedTime += Run.TimeStep;
2825 void TOpenWAM::FixTimeStepExternal(
double deltat) {
2827 double TInicialPaso = 0., m = 0., RegimenFicticio = 0.;
2828 TInicialPaso = TimeEndStep - Run.TimeStep;
2830 if(deltat < Min(Run.TimeStep, DeltaTPlenums)) {
2832 Run.TimeStep = deltat;
2833 for(
int j = 0; j < NumberOfPipes; j++) {
2834 Pipe[j]->AjustaPaso(TimeEndStep);
2838 if(DeltaTPlenums < Run.TimeStep) {
2839 Run.TimeStep = DeltaTPlenums;
2840 for(
int j = 0; j < NumberOfPipes; j++) {
2841 Pipe[j]->AjustaPaso(TimeEndStep);
2846 JStepMax = NumberOfPipes - 1;
2849 Run.AngleStep = Run.TimeStep * 6. * Engine[0]->getRegimen();
2851 RegimenFicticio = 720. / 6. / SimulationDuration;
2852 Run.AngleStep = Run.TimeStep * 6. * RegimenFicticio;
2855 Theta += Run.AngleStep;
2857 Engine[0]->PutTheta(Theta);
2858 m = floor(Theta / Engine[0]->getAngTotalCiclo());
2859 CrankAngle = Theta - m * Engine[0]->getAngTotalCiclo();
2861 m = floor(Theta / 720.);
2862 CrankAngle = Theta - m * 720.;
2864 AcumulatedTime += Run.TimeStep;
2868 void TOpenWAM::RecalculateStability() {
2873 for(
int j = 0; j < NumberOfPipes; j++) {
2874 if((Pipe[JStepMax]->getTime1() - Pipe[j]->getTime0()) < (Pipe[j]->getTime1() - Pipe[j]->getTime0())) {
2875 Pipe[j]->PutTime1(Pipe[JStepMax]->getTime1());
2878 while((Pipe[j]->getTime1() - Pipe[j]->getTime0()) < (Pipe[JStepMax]->getTime1() - Pipe[JStepMax]->getTime0()) / pow(2.,
2882 Pipe[j]->PutTime1(Pipe[j]->getTime0() + (Pipe[JStepMax]->getTime1() - Pipe[JStepMax]->getTime0()) / pow(2., i));
2884 Pipe[j]->PutDeltaTime(Pipe[j]->getTime1() - Pipe[j]->getTime0());
2886 #ifdef ParticulateFilter
2887 for(
int j = 0; j < NumberOfDPF; j++) {
2888 if((Pipe[JStepMax]->getTime1() - DPF[j]->getTime0DPF()) <
2889 (DPF[j]->getTime1DPF() - DPF[j]->getTime0DPF())) {
2890 DPF[j]->putTime1DPF(Pipe[JStepMax]->getTime1());
2893 while((DPF[j]->getTime1DPF() - DPF[j]->getTime0DPF()) <
2894 (Pipe[JStepMax]->getTime1() - Pipe[JStepMax]->getTime0())
2899 (DPF[j]->getTime0DPF() + (Pipe[JStepMax]->getTime1()
2900 - Pipe[JStepMax]->getTime0()) / pow(2., i));
2902 DPF[j]->putDeltaTimeDPF(DPF[j]->getTime1DPF() - DPF[j]->getTime0DPF
2904 for(
int k = 0; k < DPF[j]->getNumeroHacesCanales(); k++) {
2905 (DPF[j]->GetCanal(k, 0))->putTime1(DPF[j]->getTime1DPF());
2906 (DPF[j]->GetCanal(k, 0))->putDeltaTime
2907 (DPF[j]->getDeltaTimeDPF());
2908 (DPF[j]->GetCanal(k, 1))->putTime1(DPF[j]->getTime1DPF());
2909 (DPF[j]->GetCanal(k, 1))->putDeltaTime
2910 (DPF[j]->getDeltaTimeDPF());
2914 }
else if(DPFStepMax) {
2915 #ifdef ParticulateFilter
2916 for(
int j = 0; j < NumberOfPipes; j++) {
2917 if((DPF[JStepMaxDPF]->getTime1DPF() - Pipe[j]->getTime0()) <
2918 (Pipe[j]->getTime1() - Pipe[j]->getTime0())) {
2919 Pipe[j]->PutTime1(DPF[JStepMaxDPF]->getTime1DPF());
2922 while((Pipe[j]->getTime1() - Pipe[j]->getTime0()) <
2923 (DPF[JStepMaxDPF]->getTime1DPF() - DPF[JStepMaxDPF]
2924 ->getTime0DPF()) / pow(2., i)) {
2927 Pipe[j]->PutTime1(Pipe[j]->getTime0() +
2928 (DPF[JStepMaxDPF]->getTime1DPF() - DPF[JStepMaxDPF]
2929 ->getTime0DPF()) / pow(2., i));
2931 Pipe[j]->PutDeltaTime(Pipe[j]->getTime1() - Pipe[j]->getTime0());
2934 for(
int j = 0; j < NumberOfDPF; j++) {
2935 if((DPF[JStepMaxDPF]->getTime1DPF() - DPF[j]->getTime0DPF()) <
2936 (DPF[j]->getTime1DPF() - DPF[j]->getTime0DPF())) {
2937 DPF[j]->putTime1DPF(DPF[JStepMaxDPF]->getTime1DPF());
2940 while((DPF[j]->getTime1DPF() - DPF[j]->getTime0DPF()) <
2941 (DPF[JStepMaxDPF]->getTime1DPF() - DPF[JStepMaxDPF]
2942 ->getTime0DPF()) / pow(2., i)) {
2945 DPF[j]->putTime1DPF(DPF[j]->getTime0DPF() +
2946 (DPF[JStepMaxDPF]->getTime1DPF() - DPF[JStepMaxDPF]
2947 ->getTime0DPF()) / pow(2., i));
2949 DPF[j]->putDeltaTimeDPF(DPF[j]->getTime1DPF() - DPF[j]->getTime0DPF
2951 for(
int k = 0; k < DPF[j]->getNumeroHacesCanales(); k++) {
2952 (DPF[j]->GetCanal(k, 0))->putTime1(DPF[j]->getTime1DPF());
2953 (DPF[j]->GetCanal(k, 0))->putDeltaTime
2954 (DPF[j]->getDeltaTimeDPF());
2955 (DPF[j]->GetCanal(k, 1))->putTime1(DPF[j]->getTime1DPF());
2956 (DPF[j]->GetCanal(k, 1))->putDeltaTime
2957 (DPF[j]->getDeltaTimeDPF());
2965 void TOpenWAM::RecalculateStabilitySolver() {
2971 if((Pipe[JStepMax]->getTime1() - Pipe[JCurrent]->getTime0()) < (Pipe[JCurrent]->getTime1() -
2972 Pipe[JCurrent]->getTime0())) {
2973 Pipe[JCurrent]->PutTime1(Pipe[JStepMax]->getTime1());
2976 while((Pipe[JCurrent]->getTime1() - Pipe[JCurrent]->getTime0()) < (Pipe[JStepMax]->getTime1() -
2977 Pipe[JStepMax]->getTime0()) / pow(2., i)) {
2981 Pipe[JCurrent]->PutDeltaTime(Pipe[JCurrent]->getTime1() - Pipe[JCurrent]->getTime0());
2982 }
else if(TimeMinDPF) {
2983 #ifdef ParticulateFilter
2984 if((Pipe[JStepMax]->getTime1() - DPF[JCurrentDPF]->getTime0DPF())
2985 < (DPF[JCurrentDPF]->getTime1DPF() - DPF[JCurrentDPF]
2987 DPF[JCurrentDPF]->putTime1DPF(Pipe[JStepMax]->getTime1());
2990 while((DPF[JCurrentDPF]->getTime1DPF() - DPF[JCurrentDPF]
2991 ->getTime0DPF()) < (Pipe[JStepMax]->getTime1()
2992 - Pipe[JStepMax]->getTime0()) / pow(2., i)) {
2995 DPF[JCurrentDPF]->putTime1DPF
2996 (DPF[JCurrentDPF]->getTime0DPF() +
2997 (Pipe[JStepMax]->getTime1() - Pipe[JStepMax]->getTime0())
3000 DPF[JCurrentDPF]->putDeltaTimeDPF
3001 (DPF[JCurrentDPF]->getTime1DPF() - DPF[JCurrentDPF]
3003 for(
int j = 0; j < DPF[JCurrentDPF]->getNumeroHacesCanales(); j++) {
3004 (DPF[JCurrentDPF]->GetCanal(j, 0))->putTime1
3005 (DPF[JCurrentDPF]->getTime1DPF());
3006 (DPF[JCurrentDPF]->GetCanal(j, 0))->putDeltaTime
3007 (DPF[JCurrentDPF]->getDeltaTimeDPF());
3008 (DPF[JCurrentDPF]->GetCanal(j, 1))->putTime1
3009 (DPF[JCurrentDPF]->getTime1DPF());
3010 (DPF[JCurrentDPF]->GetCanal(j, 1))->putDeltaTime
3011 (DPF[JCurrentDPF]->getDeltaTimeDPF());
3015 }
else if(DPFStepMax) {
3016 #ifdef ParticulateFilter
3018 if((DPF[JStepMaxDPF]->getTime1DPF() - Pipe[JCurrent]->getTime0())
3019 < (Pipe[JCurrent]->getTime1() - Pipe[JCurrent]->getTime0())) {
3020 Pipe[JCurrent]->PutTime1(DPF[JStepMaxDPF]->getTime1DPF());
3023 while((Pipe[JCurrent]->getTime1() - Pipe[JCurrent]->getTime0()
3024 ) < (DPF[JStepMaxDPF]->getTime1DPF() - DPF[JStepMaxDPF]
3025 ->getTime0DPF()) / pow(2., i)) {
3028 Pipe[JCurrent]->PutTime1(Pipe[JCurrent]->getTime0() +
3029 (DPF[JStepMaxDPF]->getTime1DPF() - DPF[JStepMaxDPF]
3030 ->getTime0DPF()) / pow(2., i));
3032 Pipe[JCurrent]->PutDeltaTime
3033 (Pipe[JCurrent]->getTime1() - Pipe[JCurrent]->getTime0());
3034 }
else if(TimeMinDPF) {
3035 if((DPF[JStepMaxDPF]->getTime1DPF() - DPF[JCurrentDPF]->getTime0DPF
3036 ()) < (DPF[JCurrentDPF]->getTime1DPF() - DPF[JCurrentDPF]
3038 DPF[JCurrentDPF]->putTime1DPF(DPF[JStepMaxDPF]->getTime1DPF());
3041 while((DPF[JCurrentDPF]->getTime1DPF() - DPF[JCurrentDPF]
3042 ->getTime0DPF()) < (DPF[JStepMaxDPF]->getTime1DPF()
3043 - DPF[JStepMaxDPF]->getTime0DPF()) / pow(2., i)) {
3046 DPF[JCurrentDPF]->putTime1DPF
3047 (DPF[JCurrentDPF]->getTime0DPF() +
3048 (DPF[JStepMaxDPF]->getTime1DPF() - DPF[JStepMaxDPF]
3049 ->getTime0DPF()) / pow(2., i));
3051 DPF[JCurrentDPF]->putDeltaTimeDPF
3052 (DPF[JCurrentDPF]->getTime1DPF() - DPF[JCurrentDPF]
3054 for(
int j = 0; j < DPF[JCurrentDPF]->getNumeroHacesCanales(); j++) {
3055 (DPF[JCurrentDPF]->GetCanal(j, 0))->putTime1
3056 (DPF[JCurrentDPF]->getTime1DPF());
3057 (DPF[JCurrentDPF]->GetCanal(j, 0))->putDeltaTime
3058 (DPF[JCurrentDPF]->getDeltaTimeDPF());
3059 (DPF[JCurrentDPF]->GetCanal(j, 1))->putTime1
3060 (DPF[JCurrentDPF]->getTime1DPF());
3061 (DPF[JCurrentDPF]->GetCanal(j, 1))->putDeltaTime
3062 (DPF[JCurrentDPF]->getDeltaTimeDPF());
3070 void TOpenWAM::InitializeOutput() {
3071 Output->DoSpaceTimeFiles(SpeciesNumber);
3073 Output->HeaderSpaceTimeResults(thmax, grmax, agincr, SpeciesNumber);
3075 Output->HeaderAverageResults(SpeciesName, EXTERN, ThereIsDLL);
3077 Output->CopyAverageResultsToFile(0);
3079 Output->PutInsPeriod(agincr);
3083 EXTERN->InicializaMedias();
3086 if(GestorWAM != NULL)
3087 GestorWAM->CabeceraResMediosActualizada();
3091 void TOpenWAM::CalculateFlowIndependent() {
3097 SearchMinimumTimeStep();
3099 #pragma omp parallel for private(OneDEnd) num_threads(fi_num_threads)
3100 for(
int i = -1; i < 2; i++) {
3103 Pipe[JCurrent]->CalculaVariablesFundamentales();
3107 OneDEnd = Pipe[JCurrent]->getNodoIzq();
3109 OneDEnd = Pipe[JCurrent]->getNodoDer();
3111 BC[OneDEnd - 1]->CalculaCaracteristicas(Pipe[JCurrent]->getTime1());
3113 BC[OneDEnd - 1]->TuboCalculandose(JCurrent);
3115 if(BC[OneDEnd - 1]->getTipoCC() == nmVolumetricCompressor) {
3118 }
else if(BC[OneDEnd - 1]->getTipoCC() == nmInjectionEnd) {
3121 }
else if(BC[OneDEnd - 1]->getTipoCC() == nmCompresor) {
3123 dynamic_cast<TCCCompresor*
>(BC[OneDEnd - 1])->ObtencionValoresInstantaneos(Theta, Pipe[JCurrent]->getTime1());
3126 BC[OneDEnd - 1]->CalculaCondicionContorno(Pipe[JCurrent]->getTime1());
3128 SolveAdjacentElements(OneDEnd, Pipe[JCurrent]->getTime1());
3131 Pipe[JCurrent]->ActualizaValoresNuevos(BC);
3133 Pipe[JCurrent]->ActualizaPropiedadesGas();
3135 Pipe[JCurrent]->ReduccionFlujoSubsonico();
3137 Pipe[JCurrent]->CalculaCoeficientePeliculaInterior(BC);
3139 Pipe[JCurrent]->CalculaCoeficientePeliculaExterior(Engine, AmbientPressure, AmbientTemperature);
3140 Pipe[JCurrent]->CalculaResistenciasdePared(BC);
3142 if(Engine[0]->getCiclo() < 1) {
3143 Pipe[JCurrent]->CalculaCoeficientePeliculaExterior(Engine, AmbientPressure, AmbientTemperature);
3144 Pipe[JCurrent]->CalculaResistenciasdePared(BC);
3147 if(!Pipe[JCurrent]->getConcentrico()) {
3149 Pipe[JCurrent]->CalculaTemperaturaPared(Engine, Theta, CrankAngle, BC);
3151 Pipe[JCurrent]->CalculaTemperaturaParedSinMotor(BC);
3154 #ifdef ParticulateFilter
3155 for(
int j = 0; j < NumberOfConcentrics; j++) {
3156 if(Pipe[JCurrent]->getNumeroTubo() == Concentric[j]
3157 ->GetNumTuboExterno()) {
3158 Concentric[j]->CalculaTemperaturaPared(Engine, Theta,
3164 Pipe[JCurrent]->CalculaResultadosMedios(Theta);
3165 Pipe[JCurrent]->EstabilidadMetodoCalculo();
3166 if(Pipe[JCurrent]->getTime0() < TimeEndStep) {
3167 RecalculateStabilitySolver();
3169 }
else if(TimeMinDPF) {
3170 #ifdef ParticulateFilter
3171 for(
int j = 0; j < DPF[JCurrentDPF]->getNumeroHacesCanales(); j++) {
3172 for(
int k = 0; k < 2; k++) {
3173 (DPF[JCurrentDPF]->GetCanal(j, k))
3174 ->CalculaVariablesFundamentales();
3176 double IncrementoTiempo = DPF[JCurrentDPF]->getTime1DPF()
3177 - DPF[JCurrentDPF]->getTime0DPF();
3178 (DPF[JCurrentDPF]->GetCanal(j, k))
3179 ->CalculaCaracteristicasExtremos(BC,
3183 for(
int i = 0; i < 2; i++) {
3185 OneDEnd = (DPF[JCurrentDPF]->GetCanal(j, k))
3188 OneDEnd = (DPF[JCurrentDPF]->GetCanal(j, k))
3192 BC[OneDEnd - 1]->CalculaCondicionContorno
3193 (DPF[JCurrentDPF]->getTime1DPF());
3196 (DPF[JCurrentDPF]->GetCanal(j, k))->ActualizaValoresNuevos
3198 (DPF[JCurrentDPF]->GetCanal(j, k))->ActualizaPropiedadesGas
3201 (DPF[JCurrentDPF]->GetCanal(j, k))->ReduccionFlujoSubsonico
3205 SolveAdjacentElements(OneDEnd, DPF[JCurrentDPF]->getTime1DPF());
3208 if(DPF[JCurrentDPF]->getTime1DPF() < DPF[JCurrentDPF]
3209 ->getDuracionCiclo()) {
3210 if(j == DPF[JCurrentDPF]->getNumeroHacesCanales() - 1) {
3211 (DPF[JCurrentDPF]->GetCanal(j, 0))
3212 ->CalculaCoeficientePeliculaExterior
3215 #ifdef ConcentricElement
3216 DPF[JCurrentDPF]->CalculoResistenciaTC(j, Pipe,
3219 DPF[JCurrentDPF]->CalculoResistenciaTC(j, Pipe, NULL);
3222 }
else if(Engine[0]->getCiclo() < 1) {
3223 if(j == DPF[JCurrentDPF]->getNumeroHacesCanales() - 1) {
3224 (DPF[JCurrentDPF]->GetCanal(j, 0))
3225 ->CalculaCoeficientePeliculaExterior
3228 #ifdef ConcentricElement
3229 DPF[JCurrentDPF]->CalculoResistenciaTC(j, Pipe, Concentric);
3231 DPF[JCurrentDPF]->CalculoResistenciaTC(j, Pipe, NULL);
3235 #ifdef ConcentricElement
3236 DPF[JCurrentDPF]->CalculoTransmisionCalor(Engine, Theta, Pipe,
3239 DPF[JCurrentDPF]->CalculoTransmisionCalor(Engine, Theta, Pipe,
3242 DPF[JCurrentDPF]->CalculoSubmodelos();
3243 DPF[JCurrentDPF]->CalculaResultadosMedios(Theta);
3245 DPF[JCurrentDPF]->CalculoEstabilidadDPF();
3246 if(DPF[JCurrentDPF]->getTime0DPF() < TimeEndStep) {
3247 RecalculateStabilitySolver();
3251 for(
int j = 0; j < NumberOfSensors; j++) {
3254 }
while(JCurrent != JStepMax && JCurrentDPF != JStepMaxDPF);
3259 SolveRoadLoadModel();
3262 for(
int i = 0; i < NumberOfPlenums; i++) {
3263 if(SimulationType == nmTransitorioRegimen || SimulationType == nmTransitorioRegimenExterno
3264 || !(Plenum[i]->getCalculadoPaso())) {
3266 if(Plenum[i]->getTipoDeposito() == nmDepVolVble) {
3267 Plenum[i]->UpdateProperties0DModel(Pipe[JStepMax]->getTime0());
3269 Plenum[i]->ActualizaTiempo(Pipe[JStepMax]->getTime0());
3271 }
else if(DPFStepMax) {
3272 #ifdef ParticulateFilter
3273 if(Plenum[i]->getTipoDeposito() == nmDepVolVble) {
3274 Plenum[i]->UpdateProperties0DModel
3275 (DPF[JStepMaxDPF]->getTime0DPF());
3277 Plenum[i]->ActualizaTiempo(DPF[JStepMaxDPF]->getTime0DPF());
3284 UpdateTurbocharger();
3287 void TOpenWAM::SolveAdjacentElements(
int OneDEnd,
double TiempoActual) {
3289 int NumDepInicial = 0, NumeroCilindro = 0;
3290 int NumDepSiguiente = 0;
3291 bool CalculaElementosAdyacentes =
false;
3292 bool CalculoCilindro =
false;
3293 bool CalculoDeposito =
false;
3296 if(BC[OneDEnd - 1]->getTipoCC() == nmPipeToPlenumConnection) {
3297 CalculaElementosAdyacentes =
true;
3298 CalculoDeposito =
true;
3299 }
else if(BC[OneDEnd - 1]->getTipoCC() == nmCompresor) {
3300 if(
dynamic_cast<TCCCompresor*
>(BC[OneDEnd - 1])->getCompressor()->getModeloCompresor() == nmCompOriginal) {
3301 if(
dynamic_cast<TCCCompresor*
>(BC[OneDEnd - 1])->getEntradaCompresor() == nmPlenum) {
3302 CalculaElementosAdyacentes =
true;
3303 CalculoDeposito =
true;
3306 }
else if(BC[OneDEnd - 1]->getTipoCC() == nmIntakeValve || BC[OneDEnd - 1]->getTipoCC() == nmExhaustValve) {
3307 CalculaElementosAdyacentes =
true;
3308 CalculoCilindro =
true;
3311 if(CalculaElementosAdyacentes) {
3314 if(BC[OneDEnd - 1]->getTipoCC() == nmPipeToPlenumConnection) {
3315 NumDepInicial =
dynamic_cast<TCCDeposito*
>(BC[OneDEnd - 1])->getPlenum()->getNumeroDeposito();
3316 if(
dynamic_cast<TCCDeposito*
>(BC[OneDEnd - 1])->getValvula()->getCDTubVol() == 0
3317 &&
dynamic_cast<TCCDeposito*
>(BC[OneDEnd - 1])->getValvula()->getCDVolTub() == 0) {
3318 Plenum[NumDepInicial - 1]->PutCalculadoPaso(
false);
3320 Plenum[NumDepInicial - 1]->PutCalculadoPaso(
true);
3321 }
else if(BC[OneDEnd - 1]->getTipoCC() == nmCompresor) {
3322 if(
dynamic_cast<TCCCompresor*
>(BC[OneDEnd - 1])->getCompressor()->getModeloCompresor() == nmCompOriginal) {
3323 if(
dynamic_cast<TCCCompresor*
>(BC[OneDEnd - 1])->getEntradaCompresor() == nmPlenum) {
3324 NumDepInicial =
dynamic_cast<TCCCompresor*
>(BC[OneDEnd - 1])->getPlenum()->getNumeroDeposito();
3325 Plenum[NumDepInicial - 1]->PutCalculadoPaso(
true);
3328 }
else if(BC[OneDEnd - 1]->getTipoCC() == nmIntakeValve || BC[OneDEnd - 1]->getTipoCC() == nmExhaustValve) {
3329 NumeroCilindro =
dynamic_cast<TCCCilindro*
>(BC[OneDEnd - 1])->getNumeroCilindro();
3330 if(
dynamic_cast<TCCCilindro*
>(BC[OneDEnd - 1])->getValvula()->getCDTubVol() == 0
3331 &&
dynamic_cast<TCCCilindro*
>(BC[OneDEnd - 1])->getValvula()->getCDVolTub() == 0) {
3332 Engine[0]->GetCilindro(NumeroCilindro - 1)->PutCalculadoPaso(
false);
3334 Engine[0]->GetCilindro(NumeroCilindro - 1)->PutCalculadoPaso(
true);
3340 if(CalculoDeposito) {
3341 if(Plenum[NumDepInicial - 1]->getCalculadoPaso()) {
3342 if(Plenum[NumDepInicial - 1]->getTipoDeposito() == nmDepVolCte
3343 || Plenum[NumDepInicial - 1]->getTipoDeposito() == nmDepVolVble) {
3344 for(
int i = 0; i < Plenum[NumDepInicial - 1]->getNUnionesED(); i++) {
3345 if(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i)->getTipoCC() == nmCompresor) {
3346 if(
dynamic_cast<TCCCompresor*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->getCompressor()->getModeloCompresor()
3347 == nmCompPlenums &&
dynamic_cast<TCCCompresor*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(
3348 i))->getInstanteCalculo() != TiempoActual) {
3351 if(
dynamic_cast<TCCCompresor*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->getNumeroDepositoRot() ==
3353 NumDepSiguiente =
dynamic_cast<TCCCompresor*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->getNumeroDepositoEst();
3355 NumDepSiguiente =
dynamic_cast<TCCCompresor*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->getNumeroDepositoRot();
3357 Plenum[NumDepSiguiente - 1]->PutCalculadoPaso(
true);
3360 dynamic_cast<TCCCompresor*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->ObtencionValoresInstantaneos(Theta,
3362 Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i)->CalculaCondicionContorno(TiempoActual);
3363 dynamic_cast<TCCCompresor*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->PutInstanteCalculo(TiempoActual);
3366 if(Plenum[NumDepSiguiente - 1]->getCalculadoPaso()) {
3367 SolveBranch(NumDepSiguiente, TiempoActual);
3370 if(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i)->getTipoCC() == nmUnionEntreDepositos
3372 i))->getInstanteCalculo() != TiempoActual) {
3376 i))->getNumeroDeposito1() == NumDepInicial) {
3378 i))->getNumeroDeposito2();
3381 i))->getNumeroDeposito1();
3383 for(
int j = 0; j < Plenum[NumDepSiguiente - 1]->getNUnionesED(); j++) {
3384 if(Plenum[NumDepSiguiente - 1]->GetCCUnionEntreDep(j)->getTipoCC() == nmCompresor) {
3385 if(
dynamic_cast<TCCCompresor*
>(Plenum[NumDepSiguiente - 1]->GetCCUnionEntreDep(j))->getNumeroCC() ==
3387 i))->getNumeroCC()) {
3390 }
else if(Plenum[NumDepSiguiente - 1]->GetCCUnionEntreDep(j)->getTipoCC() == nmUnionEntreDepositos) {
3392 j))->getNumeroCC() ==
dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(
3393 i))->getNumeroCC()) {
3399 indiceUED))->getValvula()->getCDTubVol() == 0
3401 indiceUED))->getValvula()->getCDVolTub() == 0) {
3402 Plenum[NumDepSiguiente - 1]->PutCalculadoPaso(
false);
3404 Plenum[NumDepSiguiente - 1]->PutCalculadoPaso(
true);
3408 i))->getValvula()->getTypeOfValve() != nmCDFijo) {
3410 dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->CalculaCoeficientesDescarga(
3411 TiempoActual, Engine[0]->getMasaFuel(),
3412 Engine[0]->getRegimen());
3414 dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->CalculaCoeficientesDescarga(
3419 dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->PutInstanteCalculo(
3421 Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i)->CalculaCondicionContorno(TiempoActual);
3422 dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->AcumulaResultadosMediosUED(
3424 dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDepInicial - 1]->GetCCUnionEntreDep(i))->getValvula()->AcumulaCDMedio(
3428 if(Plenum[NumDepSiguiente - 1]->getCalculadoPaso()) {
3429 SolveBranch(NumDepSiguiente, TiempoActual);
3438 if(CalculoCilindro) {
3439 if(Engine[0]->GetCilindro(NumeroCilindro - 1)->getCalculadoPaso()) {
3440 Engine[0]->GetCilindro(NumeroCilindro - 1)->ActualizaPropiedades(TiempoActual);
3441 Engine[0]->GetCilindro(NumeroCilindro - 1)->CalculaVariablesResultados();
3442 Engine[0]->GetCilindro(NumeroCilindro - 1)->AcumulaResultadosMediosCilindro(TiempoActual);
3443 Engine[0]->AcumulaResultadosMediosBloqueMotor(TiempoActual, NumeroCilindro);
3445 }
else if(Plenum[NumDepInicial - 1]->getCalculadoPaso()) {
3447 Plenum[NumDepInicial - 1]->UpdateProperties0DModel(TiempoActual);
3451 }
catch(exception & N) {
3452 std::cout <<
" ERROR : SolveAdjacentElements " << std::endl;
3453 std::cout <<
" Tipo de error : " << N.what() << std::endl;
3458 void TOpenWAM::SolveBranch(
int NumDeposito,
double TiempoActual) {
3462 bool ExisteDepSiguiente =
false;
3463 int NumDepSiguiente = 0;
3466 for(
int i = 0; i < Plenum[NumDeposito - 1]->getNUnionesED(); i++) {
3467 if(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i)->getTipoCC() == nmCompresor) {
3468 if(
dynamic_cast<TCCCompresor*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->getCompressor()->getModeloCompresor() ==
3469 nmCompPlenums &&
dynamic_cast<TCCCompresor*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(
3470 i))->getInstanteCalculo() != TiempoActual) {
3473 if(
dynamic_cast<TCCCompresor*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->getNumeroDepositoRot() == NumDeposito) {
3474 NumDepSiguiente =
dynamic_cast<TCCCompresor*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->getNumeroDepositoEst();
3476 NumDepSiguiente =
dynamic_cast<TCCCompresor*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->getNumeroDepositoRot();
3477 ExisteDepSiguiente =
true;
3479 Plenum[NumDepSiguiente - 1]->PutCalculadoPaso(
true);
3482 dynamic_cast<TCCCompresor*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->ObtencionValoresInstantaneos(Theta,
3484 Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i)->CalculaCondicionContorno(TiempoActual);
3485 dynamic_cast<TCCCompresor*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->PutInstanteCalculo(TiempoActual);
3488 if(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i)->getTipoCC() == nmUnionEntreDepositos
3490 i))->getInstanteCalculo() != TiempoActual) {
3494 i))->getNumeroDeposito1() == NumDeposito) {
3496 i))->getNumeroDeposito2();
3499 i))->getNumeroDeposito1();
3500 ExisteDepSiguiente =
true;
3502 for(
int j = 0; j < Plenum[NumDepSiguiente - 1]->getNUnionesED(); j++) {
3503 if(Plenum[NumDepSiguiente - 1]->GetCCUnionEntreDep(j)->getTipoCC() == nmCompresor) {
3504 if(
dynamic_cast<TCCCompresor*
>(Plenum[NumDepSiguiente - 1]->GetCCUnionEntreDep(j))->getNumeroCC() ==
3506 i))->getNumeroCC()) {
3509 }
else if(Plenum[NumDepSiguiente - 1]->GetCCUnionEntreDep(j)->getTipoCC() == nmUnionEntreDepositos) {
3512 i))->getNumeroCC()) {
3518 indiceUED))->getValvula()->getCDTubVol() == 0
3520 indiceUED))->getValvula()->getCDVolTub() == 0) {
3521 Plenum[NumDepSiguiente - 1]->PutCalculadoPaso(
false);
3523 Plenum[NumDepSiguiente - 1]->PutCalculadoPaso(
true);
3527 i))->getValvula()->getTypeOfValve() != nmCDFijo) {
3529 dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->CalculaCoeficientesDescarga(
3530 TiempoActual, Engine[0]->getMasaFuel(),
3531 Engine[0]->getRegimen());
3533 dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->CalculaCoeficientesDescarga(
3538 dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->PutInstanteCalculo(TiempoActual);
3539 Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i)->CalculaCondicionContorno(TiempoActual);
3540 dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->AcumulaResultadosMediosUED(
3542 dynamic_cast<TCCUnionEntreDepositos*
>(Plenum[NumDeposito - 1]->GetCCUnionEntreDep(i))->getValvula()->AcumulaCDMedio(
3546 if(ExisteDepSiguiente) {
3547 if(Plenum[NumDepSiguiente - 1]->getCalculadoPaso()) {
3548 SolveBranch(NumDepSiguiente, TiempoActual);
3553 Plenum[NumDeposito - 1]->UpdateProperties0DModel(TiempoActual);
3555 }
catch(exception & N) {
3556 std::cout <<
" ERROR : SolveBranch " << std::endl;
3557 std::cout <<
" Tipo de error : " << N.what() << std::endl;
3562 void TOpenWAM::UpdateEngine() {
3563 for(
int i = 0; i < Engine[0]->getGeometria().NCilin; i++) {
3564 if(SimulationType == nmTransitorioRegimen || SimulationType == nmTransitorioRegimenExterno
3565 || !(Engine[0]->GetCilindro(i)->getCalculadoPaso())) {
3567 if(Engine[0]->GetCilindro(i)->getTiempoActual() < Pipe[JStepMax]->getTime0()) {
3568 Engine[0]->GetCilindro(i)->ActualizaPropiedades(Pipe[JStepMax]->getTime0());
3569 Engine[0]->GetCilindro(i)->CalculaVariablesResultados();
3570 Engine[0]->GetCilindro(i)->AcumulaResultadosMediosCilindro(Pipe[JStepMax]->getTime0());
3571 Engine[0]->AcumulaResultadosMediosBloqueMotor(Pipe[JStepMax]->getTime0(), i + 1);
3572 for(
int j = 0; j < Engine[0]->GetCilindro(i)->getNumeroUnionesAdm(); j++) {
3573 dynamic_cast<TCCCilindro*
>(Engine[0]->GetCilindro(i)->GetCCValvulaAdm(j))->ActualizaAnguloValvula(
3574 Pipe[JStepMax]->getTime0(), Engine[0]->getRegimen());
3576 for(
int j = 0; j < Engine[0]->GetCilindro(i)->getNumeroUnionesEsc(); j++) {
3577 dynamic_cast<TCCCilindro*
>(Engine[0]->GetCilindro(i)->GetCCValvulaEsc(j))->ActualizaAnguloValvula(
3578 Pipe[JStepMax]->getTime0(), Engine[0]->getRegimen());
3581 }
else if(DPFStepMax) {
3582 #ifdef ParticulateFilter
3583 if(Engine[0]->GetCilindro(i)->getTiempoActual()
3584 < DPF[JStepMaxDPF]->getTime0DPF()) {
3585 Engine[0]->GetCilindro(i)->ActualizaPropiedades
3586 (DPF[JStepMaxDPF]->getTime0DPF());
3587 Engine[0]->GetCilindro(i)->CalculaVariablesResultados();
3588 Engine[0]->GetCilindro(i)->AcumulaResultadosMediosCilindro
3589 (DPF[JStepMaxDPF]->getTime0DPF());
3590 Engine[0]->AcumulaResultadosMediosBloqueMotor
3591 (DPF[JStepMaxDPF]->getTime0DPF(), i + 1);
3593 j < Engine[0]->GetCilindro(i)->getNumeroUnionesAdm();
3596 (Engine[0]->GetCilindro(i)->GetCCValvulaAdm(j))
3597 ->ActualizaAnguloValvula
3598 (DPF[JStepMaxDPF]->getTime0DPF(),
3599 Engine[0]->getRegimen());
3602 j < Engine[0]->GetCilindro(i)->getNumeroUnionesEsc();
3605 (Engine[0]->GetCilindro(i)->GetCCValvulaEsc(j))
3606 ->ActualizaAnguloValvula
3607 (DPF[JStepMaxDPF]->getTime0DPF(),
3608 Engine[0]->getRegimen());
3613 }
else if(Engine[0]->GetCilindro(i)->getCalculadoPaso()) {
3617 Engine[0]->GetCilindro(i)->PutCalculadoPaso(
false);
3622 void TOpenWAM::SolveRoadLoadModel() {
3623 Engine[0]->ModeloDeVehiculo(AcumulatedTime);
3624 if(SimulationType == nmTransitorioRegimen || SimulationType == nmTransitorioRegimenExterno) {
3626 for(
int i = 0; i < NumberOfPlenums; i++) {
3627 if(Plenum[i]->getTipoDeposito() == nmDepVolVble) {
3628 dynamic_cast<TDepVolVariable*
>(Plenum[i])->UpdateSpeed(Engine[0]->getRegimen());
3635 void TOpenWAM::UpdateTurbocharger() {
3636 for(
int i = 0; i < NumberOfAxis; i++) {
3637 Axis[i]->CalculaEjesTurbogrupo(Theta, SimulationType, AcumulatedTime, CrankAngle);
3638 Axis[i]->AcumulaResultadosMediosEje(AcumulatedTime);
3642 void TOpenWAM::CalculateFlowCommon() {
3644 for(
int j = 0; j < NumberOfPipes; j++) {
3645 Pipe[j]->CalculaVariablesFundamentales();
3646 Pipe[j]->CalculaCaracteristicasExtremos(BC, Run.TimeStep);
3648 #ifdef ParticulateFilter
3649 for(
int i = 0; i < NumberOfDPF; i++) {
3650 for(
int j = 0; j < DPF[i]->getNumeroHacesCanales(); j++) {
3651 for(
int k = 0; k < 2; k++) {
3652 (DPF[i]->GetCanal(j, k))->CalculaVariablesFundamentales();
3653 (DPF[i]->GetCanal(j, k))->CalculaCaracteristicasExtremos(BC,
3660 for(
int i = 0; i < NumberOfConnections; i++) {
3661 if(BC[i]->getTipoCC() == nmVolumetricCompressor) {
3663 }
else if(BC[i]->getTipoCC() == nmInjectionEnd) {
3665 }
else if(BC[i]->getTipoCC() == nmCompresor) {
3666 dynamic_cast<TCCCompresor*
>(BC[i])->ObtencionValoresInstantaneos(Theta, TimeEndStep);
3668 BC[i]->CalculaCondicionContorno(TimeEndStep);
3670 if(BC[i]->getTipoCC() == nmUnionEntreDepositos) {
3676 for(
int j = 0; j < NumberOfPipes; j++) {
3677 Pipe[j]->ActualizaValoresNuevos(BC);
3678 Pipe[j]->ActualizaPropiedadesGas();
3680 Pipe[j]->ReduccionFlujoSubsonico();
3682 Pipe[j]->CalculaCoeficientePeliculaInterior(BC);
3684 Pipe[j]->CalculaCoeficientePeliculaExterior(Engine, AmbientPressure, AmbientTemperature);
3685 Pipe[j]->CalculaResistenciasdePared(BC);
3687 if(Engine[0]->getCiclo() < 1) {
3688 Pipe[j]->CalculaCoeficientePeliculaExterior(Engine, AmbientPressure, AmbientTemperature);
3689 Pipe[j]->CalculaResistenciasdePared(BC);
3692 if(!Pipe[j]->getConcentrico()) {
3693 if(Engine != NULL) {
3694 Pipe[j]->CalculaTemperaturaPared(Engine, Theta, CrankAngle, BC);
3696 Pipe[j]->CalculaTemperaturaParedSinMotor(BC);
3699 #ifdef ConcentricElement
3700 for(
int j = 0; j < NumberOfConcentrics; j++) {
3701 if(Pipe[j]->getNumeroTubo() == Concentric[j]->GetNumTuboExterno
3703 Concentric[j]->CalculaTemperaturaPared(Engine, Theta, BC);
3709 Pipe[j]->CalculaResultadosMedios(Theta);
3711 Pipe[j]->EstabilidadMetodoCalculo();
3713 #ifdef ParticulateFilter
3714 for(
int i = 0; i < NumberOfDPF; i++) {
3715 for(
int j = 0; j < DPF[i]->getNumeroHacesCanales(); j++) {
3716 for(
int k = 0; k < 2; k++) {
3717 (DPF[i]->GetCanal(j, k))->ActualizaValoresNuevos(BC);
3718 (DPF[i]->GetCanal(j, k))->ActualizaPropiedadesGas();
3719 (DPF[i]->GetCanal(j, k))->ReduccionFlujoSubsonico();
3722 if(j == DPF[i]->getNumeroHacesCanales() - 1) {
3723 (DPF[i]->GetCanal(j, 0))->CalculaCoeficientePeliculaExterior
3726 DPF[i]->CalculoResistenciaTC(j, Pipe, Concentric);
3727 }
else if(Engine[0]->getCiclo() < 1) {
3728 if(j == DPF[i]->getNumeroHacesCanales() - 1) {
3729 (DPF[i]->GetCanal(j, 0))->CalculaCoeficientePeliculaExterior
3732 DPF[i]->CalculoResistenciaTC(j, Pipe, Concentric);
3735 DPF[i]->CalculoTransmisionCalor(Engine, Theta, Pipe, Concentric);
3736 DPF[i]->CalculoSubmodelos();
3737 DPF[i]->CalculaResultadosMedios(Theta);
3739 DPF[i]->CalculoEstabilidadDPF();
3742 for(
int j = 0; j < NumberOfSensors; j++) {
3748 SolveRoadLoadModel();
3751 for(
int i = 0; i < NumberOfPlenums; i++) {
3752 Plenum[i]->UpdateProperties0DModel(TimeEndStep);
3755 UpdateTurbocharger();
3766 void TOpenWAM::ManageOutput() {
3767 if(Engine != NULL) {
3768 Output->WriteInstantaneous(EngineBlock, CrankAngle, Run.AngleStep, Engine[0], SimulationDuration);
3770 Output->WriteInstantaneous(EngineBlock, CrankAngle, Run.AngleStep,
3771 NULL, SimulationDuration);
3774 Output->CopyInstananeousResultsToFile(0);
3776 Output->HeaderInstantaneousResults(EXTERN, ThereIsDLL, EngineBlock, SpeciesName);
3779 if(GestorWAM != NULL)
3780 GestorWAM->CabeceraResInstantActualizada();
3781 if(GestorWAM != NULL)
3782 GestorWAM->FichResInstantActualizado();
3785 Output->PlotControl(Theta0, Theta, Run.CycleDuration);
3789 Output->OutputInstantaneousResults(EXTERN, ThereIsDLL, EngineBlock, Theta, Engine[0], AcumulatedTime);
3791 Output->WriteSpaceTime(EngineBlock, Engine[0], Run.CycleDuration);
3793 Output->PrintSpaceTimeResults(EngineBlock, Theta, Run.CycleDuration, Engine, SpeciesNumber);
3795 if(CrankAngle - Run.AngleStep <= 0. && Theta >= 750.) {
3796 Output->OutputAverageResults(AcumulatedTime, EXTERN, ThereIsDLL);
3798 Output->CopyAverageResultsToFile(1);
3801 if(GestorWAM != NULL)
3802 GestorWAM->FichResMediosActualizado();
3805 Engine[0]->PrestacionesMotor();
3807 for(
int i = 0; i < Engine[0]->getGeometria().NCilin; i++) {
3808 Engine[0]->GetCilindro(i)->SalidaGeneralCilindros();
3811 printf(
" \n INFO : == CYCLE N. %d == \n \n ", Engine[0]->getCiclo() + 1);
3815 Output->OutputInstantaneousResults(EXTERN, ThereIsDLL, EngineBlock, Theta, NULL, AcumulatedTime);
3817 Output->WriteSpaceTime(EngineBlock, NULL, Run.CycleDuration);
3819 Output->PrintSpaceTimeResults(EngineBlock, Theta, Run.CycleDuration,
3820 NULL, SpeciesNumber);
3825 void TOpenWAM::GeneralOutput() {
3827 Output->CopyInstananeousResultsToFile(1);
3830 Engine[0]->PrestacionesMotor();
3831 for(
int i = 0; i < Engine[0]->getGeometria().NCilin; i++) {
3832 Engine[0]->GetCilindro(i)->SalidaGeneralCilindros();
3835 for(
int i = 0; i < NumberOfPlenums; i++) {
3836 Plenum[i]->SalidaGeneralDep(SpeciesName);
3838 for(
int i = 0; i < NumberOfPipes; i++) {
3839 Pipe[i]->SalidaGeneralTubos(SpeciesName);
3843 bool TOpenWAM::CalculationEnd() {
3844 return Output->GetFControlAngle1() > thmax;
3847 void TOpenWAM::ProgressBegin() {
3848 char* tzcharstring =
new char[tzstr.length() + 1];
3849 std::strcpy(tzcharstring, tzstr.c_str());
3850 putenv(tzcharstring);
3853 if(GestorWAM != NULL)
3854 GestorWAM->NuevoMensaje(
"Calculating main loop...");
3858 printf(
" Seconds since 1 / 1 / 1970 GMT : % ld \n ", begining.time);
3859 printf(
" Thousandths of a second : %d \n ", begining.millitm);
3862 void TOpenWAM::ProgressEnd() {
3865 float tiempotot = (
final.time - begining.time) * 1000 + (
final.millitm - begining.millitm);
3867 int seg = int(tiempotot / 1000.);
3868 int min = int(seg / 60.);
3869 int hor = int(min / 60.);
3870 int mil = int(tiempotot) - seg * 1000;
3871 seg = seg - min * 60;
3872 min = min - hor * 60;
3873 std::cout << std::endl;
3874 std::cout <<
"===================================" << std::endl;
3875 printf(
"Time consumed: %d:%02d:%02d,%03d \n", hor, min, seg, mil);
3876 std::cout <<
"===================================" << std::endl;
3877 std::cout << std::endl;
3880 void TOpenWAM::NewEngineCycle() {
3883 if(CrankAngle - Run.AngleStep <= 0. && Theta >= Engine[0]->getAngTotalCiclo()) {
3885 Engine[0]->PutCiclo(Engine[0]->getCiclo() + 1);
3886 for(
int i = 0; i < NumberOfPipes; i++) {
3887 Pipe[i]->CalculaCoeficientePeliculaExterior(Engine, AmbientPressure, AmbientTemperature);
3888 Pipe[i]->CalculaResistenciasdePared(BC);
3893 #ifdef ParticulateFilter
3894 for(
int i = 0; i < NumberOfDPF; i++) {
3895 if(DPF[i]->getCicloDPF() > 1) {
3896 for(
int j = 0; j < DPF[i]->getNumeroHacesCanales(); j++) {
3897 (DPF[i]->GetCanal(j, 0))->CalculaCoeficientePeliculaInterior();
3898 (DPF[i]->GetCanal(j, 1))->CalculaCoeficientePeliculaInterior();
3899 if(j == DPF[i]->getNumeroHacesCanales() - 1) {
3900 (DPF[i]->GetCanal(j, 0))->CalculaCoeficientePeliculaExterior
3902 (DPF[i]->GetCanal(j, 1))->CalculaCoeficientePeliculaExterior
3905 DPF[i]->CalculoResistenciaTC(j, Pipe, Concentric);
3912 void TOpenWAM::UpdateExternalBoundary(
int i,
double U0,
double U1,
double T0,
double T1,
double P0,
double P1,
3915 BCExtConnection[i]->UpdateCurrentExternalProperties(U0, U1, T0, T1, P0, P1, t);
3919 void TOpenWAM::UpdateExternalBoundary(
int i,
double U0,
double T0,
double P0,
double t) {
3921 BCExtConnectionVol[i - 1]->UpdateCurrentExternalProperties(U0, T0, P0, t);
3925 void TOpenWAM::InitiateExternalBoundary(
int i,
double D0,
double D1,
double dX) {
3927 BCExtConnection[i]->AsignGeometricalData(D0, D1, dX);
3931 void TOpenWAM::InitiateExternalBoundary(
int i,
double D0,
double dX) {
3933 BCExtConnectionVol[i]->AsignGeometricalData(D0, dX);
3937 void TOpenWAM::LoadNewData(
int i,
double* p,
double* T,
double* u) {
3939 BCExtConnectionVol[i]->LoadNewData(p, T, u);
3942 bool TOpenWAM::GetIs_EndStep() {
3946 void TOpenWAM::comunica_wam_dll() {
3949 EXTERN->Calculo_Sensores_Tubos(Pipe, Run.TimeStep);
3951 EXTERN->Calculo_Sensores_Deposito(Plenum, Run.TimeStep);
3953 EXTERN->Calculo_Sensores_TG(Run.TimeStep, Axis);
3955 EXTERN->Calculo_Sensores_Turbina(Run.TimeStep, Turbine);
3957 EXTERN->Calculo_Sensores_Cilindro(Run.TimeStep, Engine);
3959 EXTERN->Calculo_Sensores_Venturi(Run.TimeStep, Venturi);
3961 EXTERN->Calculo_Sensores_Motor(Run.TimeStep, Engine, AcumulatedTime);
3962 EXTERN->LlamadaECU(Run.TimeStep, Engine);
3964 if(EXTERN->getConvergencia() && ConvergenceFirstTime ==
false) {
3965 ModificacionControlEjecucion();
3966 ConvergenceFirstTime =
true;
3971 void TOpenWAM::ModificacionControlEjecucion() {
3972 int nuevaduracionejecucion = 0;
3976 thmax = Theta + 20.;
3980 nuevaduracionejecucion = (Engine[0]->getCiclo() + 1) + 10;
3981 thmax = nuevaduracionejecucion * Engine[0]->getAngTotalCiclo();
3982 grmax = thmax - Engine[0]->getAngTotalCiclo();
3987 void TOpenWAM::Actuadores()
3990 int compo = 0, contador = 0;
3995 for(
int i = 0; i < nematlab; ++i) {
3996 MatlabDischarge[i]->PutPresion(EXTERN->GetOutput_dll(compo));
3997 MatlabDischarge[i]->PutTemperatura(__units::degCToK(EXTERN->GetOutput_dll(compo + 1)));
4003 if(controlvalv == 1) {
4004 for(
int i = 0; i <= NumberOfExternalCalculatedValves - 1; ++i) {
4005 dynamic_cast<TCDExterno*
>(CCCalcExtern[i])->PutCDEntMatlab(EXTERN->GetOutput_dll(compo));
4006 dynamic_cast<TCDExterno*
>(CCCalcExtern[i])->PutCDSalMatlab(EXTERN->GetOutput_dll(compo + 1));
4007 dynamic_cast<TCDExterno*
>(CCCalcExtern[i])->PutCTorMatlab(EXTERN->GetOutput_dll(compo + 2));
4013 if(EXTERN->getcontrolmfcomb()) {
4014 for(
int i = 0; i < Engine[0]->getGeometria().NCilin; ++i) {
4015 if(Engine[0]->GetCilindro(i)->getAnguloActual() > Engine[0]->GetCilindro(i)->getDistribucion().CA
4016 && Engine[0]->GetCilindro(i)->getAnguloAnterior() <= Engine[0]->GetCilindro(i)->getDistribucion().CA) {
4017 Engine[0]->GetCilindro(i)->PutMasaFuel(EXTERN->GetOutput_dll(compo));
4025 if(EXTERN->getcontroliny()) {
4026 for(
int i = 0; i < Engine[0]->getGeometria().NCilin; ++i) {
4027 if(Engine[0]->GetCilindro(i)->getAnguloActual() > Engine[0]->GetCilindro(i)->getDistribucion().CA
4028 && Engine[0]->GetCilindro(i)->getAnguloAnterior() <= Engine[0]->GetCilindro(i)->getDistribucion().CA) {
4029 Engine[0]->GetCilindro(i)->PutNumeroInyecciones(EXTERN->GetOutput_dll(compo));
4030 Engine[0]->GetCilindro(i)->PutPresionInyeccion(EXTERN->GetOutput_dll(compo + 1));
4032 for(
int j = 0; j < 8; j++) {
4033 if(Engine[0]->getACT()) {
4035 Engine[0]->GetCilindro(i)->PutSOP(j, EXTERN->GetOutput_dll(compo + 2 + j + contador));
4036 Engine[0]->GetCilindro(i)->PutMasaFuelPorInyeccion(j, EXTERN->GetOutput_dll(compo + 3 + j + contador));
4045 for(
int i = 0; i < CountVGT; ++i) {
4046 dynamic_cast<TEstatorTurbina*
>(DatosTGV[i].Estator[0])->PutCDVbl(EXTERN->GetOutput_dll(compo));
4047 dynamic_cast<TRotorTurbina*
>(DatosTGV[i].Rotor)->PutCDVbl(EXTERN->GetOutput_dll(compo + 1));
4048 DatosTGV[i].Rendimiento[0] = EXTERN->GetOutput_dll(compo + 2);
4049 if(DatosTGV[i].Entradas == 2) {
4050 dynamic_cast<TEstatorTurbina*
>(DatosTGV[i].Estator[1])->PutCDVbl(EXTERN->GetOutput_dll(compo + 3));
4051 dynamic_cast<TRotorTurbina*
>(DatosTGV[i].Rotor)->PutCDVbl(EXTERN->GetOutput_dll(compo + 4));
4052 DatosTGV[i].Rendimiento[1] = EXTERN->GetOutput_dll(compo + 5);
4057 if(EXTERN->getajustbaraba()) {
4058 Engine[0]->PutATCAdm(EXTERN->GetOutput_dll(compo));
4059 Engine[0]->PutATCEsc(EXTERN->GetOutput_dll(compo + 1));
4063 if(EXTERN->getmodcomb()) {
4064 for(
int i = 0; i <= Engine[0]->getGeometria().NCilin - 1; ++i) {
4065 Engine[0]->GetCilindro(i)->PutFQL(EXTERN->GetOutput_dll(compo));
4066 Engine[0]->GetCilindro(i)->PutInicioComb(EXTERN->GetOutput_dll(compo + 1));
4067 Engine[0]->GetCilindro(i)->PutFinComb(EXTERN->GetOutput_dll(compo + 2));
4072 if(SimulationType == nmTransitorioRegimenExterno) {
4073 Engine[0]->PutRegimen(EXTERN->GetOutput_dll(compo));
4077 if(EXTERN->getFraccionMasicaEspeciesCil()) {
4078 for(
int i = 0; i < Engine[0]->getGeometria().NCilin; ++i) {
4079 if(Engine[0]->GetCilindro(i)->getAnguloActual() > Engine[0]->GetCilindro(i)->getDistribucion().AE
4080 && Engine[0]->GetCilindro(i)->getAnguloAnterior() <= Engine[0]->GetCilindro(i)->getDistribucion().AE) {
4081 for(
int j = 0; j < Engine[0]->getSpeciesNumber() - 1;
4083 Engine[0]->GetCilindro(i)->PutFraccionMasicaEspecie(j, EXTERN->GetOutput_dll(compo));
4087 compo += Engine[0]->getSpeciesNumber();
4092 if(EXTERN->getControlK()) {
4093 for(
int i = 0; i < NumTCCPerdidaPresion; ++i) {
4094 PerdidaPresion[i]->PutK(EXTERN->GetOutput_dll(compo));
4099 EXTERN->AcumulaMedias(Run.TimeStep);
4103 void TOpenWAM::InitFlowIndependentNumThreads() {
4106 std::stringstream ss;
4108 char const* env_value = getenv(
"OMP_NUM_THREADS");
4109 if(env_value == NULL) {
4110 n_threads = omp_get_num_procs();
4113 if(!(ss >> n_threads)) {
4120 }
else if(n_threads > 1) {
4128 #pragma package(smart_init)kage(smart_init)age(smart_init)