OpenWAM
TLamina.cpp
1 /*--------------------------------------------------------------------------------*\
2 ==========================|
3  \\ /\ /\ // O pen | OpenWAM: The Open Source 1D Gas-Dynamic Code
4  \\ | X | // W ave |
5  \\ \/_\/ // A ction | CMT-Motores Termicos / Universidad Politecnica Valencia
6  \\/ \// M odel |
7  ----------------------------------------------------------------------------------
8  License
9 
10  This file is part of OpenWAM.
11 
12  OpenWAM is free software: you can redistribute it and/or modify
13  it under the terms of the GNU General Public License as published by
14  the Free Software Foundation, either version 3 of the License, or
15  (at your option) any later version.
16 
17  OpenWAM is distributed in the hope that it will be useful,
18  but WITHOUT ANY WARRANTY; without even the implied warranty of
19  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  GNU General Public License for more details.
21 
22  You should have received a copy of the GNU General Public License
23  along with OpenWAM. If not, see <http://www.gnu.org/licenses/>.
24 
25 
26  \*--------------------------------------------------------------------------------*/
27 
28 //---------------------------------------------------------------------------
29 #pragma hdrstop
30 
31 #include "TLamina.h"
32 #include "TTubo.h"
33 #include "TCilindro.h"
34 #include "TDeposito.h"
35 
36 //---------------------------------------------------------------------------
37 //---------------------------------------------------------------------------
38 
39 TLamina::TLamina() :
40  TTipoValvula(nmLamina) {
41 
42 //FDatosCDEntrada=NULL;
43 //FDatosCDSalida=NULL;
44  FFuerza = NULL;
45  FLev1 = NULL;
46  FLev2 = NULL;
47  FLev3 = NULL;
48  FTime0 = 0;
49  fun_CDin = NULL;
50  fun_CDout = NULL;
51 }
52 
53 //---------------------------------------------------------------------------
54 //---------------------------------------------------------------------------
55 
56 TLamina::~TLamina() {
57 
58 //if(FDatosCDEntrada!=NULL)delete[] FDatosCDEntrada;
59 //if(FDatosCDSalida!=NULL) delete[] FDatosCDSalida;
60  if(FFuerza != NULL)
61  delete[] FFuerza;
62  if(FLev1 != NULL)
63  delete[] FLev1;
64  if(FLev2 != NULL)
65  delete[] FLev2;
66  if(FLev3 != NULL)
67  delete[] FLev3;
68 }
69 
70 //---------------------------------------------------------------------------
71 //---------------------------------------------------------------------------
72 
73 TLamina::TLamina(TLamina *Origen, int Valvula) :
74  TTipoValvula(nmLamina) {
75 
76  FValvula = Valvula;
77 
78  FFuerza = NULL;
79  FLev1 = NULL;
80  FLev2 = NULL;
81  FLev3 = NULL;
82 
83  FTipoLamina = Origen->FTipoLamina;
84  FSentidoLamina = Origen->FSentidoLamina;
85  FDiametroRef = Origen->FDiametroRef;
86  FNumeroOrden = Origen->FNumeroOrden;
87 
88  FDiamRef = FDiametroRef;
89 
90  FMasa = Origen->FMasa;
91  FDensidad = Origen->FDensidad;
92  FAmortiguamiento = Origen->FAmortiguamiento;
93  FArea = Origen->FArea;
94  FAnchoPetalo = Origen->FAnchoPetalo;
95  FRigidez = Origen->FRigidez;
96  FModuloYoung = Origen->FModuloYoung;
97  FEspesor = Origen->FEspesor;
98  FNumPestanyas = Origen->FNumPestanyas;
99  FLongitud = Origen->FLongitud;
100  FLongReal = Origen->FLongReal;
101 
102  FKCDE = Origen->FKCDE;
103  FKCDS = Origen->FKCDS;
104 
105  FNumLevCDE = Origen->FNumLevCDE;
106  FNumLevCDS = Origen->FNumLevCDS;
107  FIncrLev = Origen->FIncrLev;
108 
109  FLiftCDin.resize(Origen->FLiftCDin.size());
110  FDatosCDEntrada.resize(Origen->FDatosCDEntrada.size());
111  FLiftCDout.resize(Origen->FLiftCDout.size());
112  FDatosCDSalida.resize(Origen->FDatosCDSalida.size());
113  for(dVector::size_type i = 0; i < FDatosCDEntrada.size(); i++) {
114  FLiftCDin[i] = Origen->FLiftCDin[i];
115  FDatosCDEntrada[i] = Origen->FDatosCDEntrada[i];
116  }
117  fun_CDin = new Hermite_interp(FLiftCDin, FDatosCDEntrada);
118 
119  for(dVector::size_type i = 0; i < FDatosCDSalida.size(); i++) {
120  FLiftCDout[i] = Origen->FLiftCDout[i];
121  FDatosCDSalida[i] = Origen->FDatosCDSalida[i];
122  }
123  fun_CDout = new Hermite_interp(FLiftCDout, FDatosCDSalida);
124 
125  if(FTipoLamina == nmLamina2D) {
126  FNodosLamina = 15;
127  FDeltaX = FLongitud / double(FNodosLamina - 1);
128  FNodosFijos = floor((FLongReal - FLongitud) / FDeltaX);
129  FCoefC = FModuloYoung * FEspesor * FEspesor / 12. / FDensidad;
130  FAreaTrans = FEspesor * FAnchoPetalo * FNumPestanyas;
131  FFuerza = new double[FNodosLamina + FNodosFijos + 2];
132  FLev1 = new double[FNodosLamina + FNodosFijos + 3];
133  FLev2 = new double[FNodosLamina + FNodosFijos + 3];
134  FLev3 = new double[FNodosLamina + FNodosFijos + 3];
135  for(int i = 0; i < FNodosLamina + FNodosFijos + 3; i++) {
136  FLev1[i] = 0.;
137  FLev2[i] = 0.;
138  FLev3[i] = 0.;
139  }
140  FBucle = 10;
141  }
142  FGraficasLam = false;
143 
144 }
145 
146 //---------------------------------------------------------------------------
147 //---------------------------------------------------------------------------
148 
149 void TLamina::LeeDatosIniciales(const char *FileWAM, fpos_t &filepos, int norden, bool HayMotor, TBloqueMotor *Engine) {
150  try {
151  int tipo = 0, sentido = 0;
152 
153  FILE *fich = fopen(FileWAM, "r");
154  fsetpos(fich, &filepos);
155 
156  FNumeroOrden = norden;
157 
158  fscanf(fich, "%d %lf %d ", &tipo, &FDiametroRef, &sentido);
159  switch(tipo) {
160  case 0:
161  FTipoLamina = nmLamina0D;
162  break;
163  case 1:
164  FTipoLamina = nmLamina1D;
165  break;
166  case 3:
167  FTipoLamina = nmLamina2D;
168  break;
169  default:
170  std::cout << "ERROR: Seleccion Tipo de Lamina" << std::endl;
171  break;
172  }
173  switch(sentido) {
174  case 0:
175  FSentidoLamina = 1;
176  break;
177  case 1:
178  FSentidoLamina = -1;
179  break;
180  default:
181  std::cout << "ERROR: Seleccion Sentido de Lamina" << std::endl;
182  break;
183  }
184 
185  if(FTipoLamina == nmLamina1D) {
186  fscanf(fich, "%lf %lf %lf %lf ", &FMasa, &FAmortiguamiento, &FRigidez, &FArea);
187  } else if(FTipoLamina == nmLamina2D) {
188  fscanf(fich, "%lf %lf %lf %lf %lf %d %lf %lf ", &FDensidad, &FAmortiguamiento, &FModuloYoung, &FAnchoPetalo, &FEspesor,
189  &FNumPestanyas, &FLongitud, &FLongReal);
190  }
191  fscanf(fich, "%d %d ", &FNumLevCDE, &FNumLevCDS);
192 
193  FLiftCDin.resize(FNumLevCDE);
194  FDatosCDEntrada.resize(FNumLevCDE);
195  FLiftCDout.resize(FNumLevCDS);
196  FDatosCDSalida.resize(FNumLevCDS);
197 
198  fscanf(fich, "%lf ", &FIncrLev);
199  fscanf(fich, "%lf %lf ", &FKCDE, &FKCDS);
200  for(int j = 0; j < FNumLevCDE; ++j) {
201  FLiftCDin[j] = (double) j * FIncrLev;
202  fscanf(fich, "%lf ", &FDatosCDEntrada[j]);
203  }
204  for(int j = 0; j < FNumLevCDS; ++j) {
205  FLiftCDout[j] = (double) j * FIncrLev;
206  fscanf(fich, "%lf ", &FDatosCDSalida[j]);
207  }
208 
209  fgetpos(fich, &filepos);
210  fclose(fich);
211  } catch(exception &N) {
212  std::cout << "ERROR: LeeDatosIniciales Lamina" << std::endl;
213  //std::cout << "Tipo de error: " << N.what().scr() << std::endl;
214  throw Exception(N.what());
215 
216  }
217 }
218 
219 //---------------------------------------------------------------------------
220 //---------------------------------------------------------------------------
221 
222 void TLamina::CalculaCD(double deltaP, double ttotal) {
223  try {
224  double X = 0.;
225  int Indice = 0;
226  double deltaT = ttotal - FTime0;
227  FTime0 = ttotal;
228 
229 //deltaP=FPipe->GetPresion(FPipeNode)-FCylinder->getPressure();
230 
231  double deltaP2 = deltaP * (double) FSentidoLamina;
232 
233  switch(FTipoLamina) {
234  case nmLamina0D:
235  if(deltaP2 >= 0.) {
236  FCDTubVol = fun_CDin->interp(deltaP2) * FKCDE;
237  FCDVolTub = fun_CDout->interp(deltaP2) * FKCDS;
238  } else {
239  FCDTubVol = 0.;
240  FCDVolTub = 0.;
241  }
242  break;
243  case nmLamina1D:
244  FddLev = (__units::BarToPa(deltaP2) * FArea - FRigidez * FLev - FAmortiguamiento * FdLev) / FMasa;
245  FLev = FLev + FdLev * deltaT + FddLev / 2 * pow2(deltaT);
246  FdLev = FdLev + FddLev * deltaT;
247 
248  if(FLev > 99999911.0e-3) {
249  FLev = 99999911.0e-3;
250  FdLev = 0.;
251  }
252  if(FLev > 0) {
253  FCDTubVol = fun_CDin->interp(FLev) * FKCDE;
254  FCDVolTub = fun_CDout->interp(FLev) * FKCDS;
255  } else {
256  FLev = 0.;
257  FdLev = 0.;
258  FCDTubVol = 0.;
259  FCDVolTub = 0.;
260  }
261  break;
262  case nmLamina2D:
263  for(int i = 0; i < (FNodosLamina + FNodosFijos + 2); ++i) {
264  FFuerza[i] = __units::BarToPa(deltaP2) * FAnchoPetalo * FNumPestanyas / FDensidad / FAreaTrans;
265  if(i < FNodosFijos + 1) {
266  FFuerza[i] = 0.;
267  }
268  if(i == FNodosFijos + 1 || i == FNodosFijos + FNodosLamina + 1) {
269  FFuerza[i] *= 0.5;
270  }
271  }
272  double deltaT2 = deltaT / (double) FBucle;
273  for(int veces = 0; veces <= FBucle; ++veces) {
274  FLev2[0] = FLev2[2];
275  FLev2[FNodosLamina + FNodosFijos + 2] = 2 * FLev2[FNodosLamina + FNodosFijos + 1] - FLev2[FNodosLamina + FNodosFijos];
276  for(int i = 2; i <= FNodosLamina + FNodosFijos; ++i) {
277  FDerivada4 = FLev2[i - 2] - 4 * FLev2[i - 1] + 6 * FLev2[i] - 4 * FLev2[i + 1] + FLev2[i + 2];
278  FDerivada4 = FDerivada4 / pow4(FDeltaX);
279  FLev3[i] = pow2(deltaT2) * (FFuerza[i] - FCoefC * FDerivada4) + (2 * FAmortiguamiento * deltaT2) * FLev2[i] - FLev1[i];
280  FLev3[i] = FLev3[i] / (1 + FAmortiguamiento * deltaT2);
281  if(FLev3[i] < 0)
282  FLev3[i] = 0.;
283  }
284  FLev3[1] = 0.;
285  FLev3[FNodosLamina + FNodosFijos + 1] = 2 * FLev3[FNodosLamina + FNodosFijos] - FLev3[FNodosLamina + FNodosFijos - 1];
286  if(FLev3[FNodosLamina + FNodosFijos + 1] < 0.)
287  FLev3[FNodosLamina + FNodosFijos + 1] = 0;
288  for(int i = 1; i <= FNodosLamina + FNodosFijos + 1; ++i) {
289  FLev1[i] = FLev2[i];
290  FLev2[i] = FLev3[i];
291  }
292  }
293  FLev = FLev3[FNodosLamina + FNodosFijos + 1];
294 
295  if(FLev > 99999911.0e-3) {
296  FLev = 99999911.0e-3;
297  FdLev = 0.;
298  }
299  if(FLev > 0) {
300  FCDTubVol = fun_CDin->interp(FLev) * FKCDE;
301  FCDVolTub = fun_CDout->interp(FLev) * FKCDS;
302  } else {
303  FLev = 0.;
304  FCDTubVol = 0.;
305  FCDVolTub = 0.;
306  }
307 
308  break;
309  }
310  FCDTubVol *= FSectionRatio;
311  FCDVolTub *= FSectionRatio;
312  } catch(exception &N) {
313  std::cout << "ERROR: CalculaCD Lamina" << std::endl;
314  //std::cout << "Tipo de error: " << N.what().scr() << std::endl;
315  throw Exception(N.what());
316 
317  }
318 }
319 
320 void TLamina::GetCDin(double Time) {
321 
322  double deltaT = Time - FTime0;
323  FTime0 = Time;
324  double deltaP = 0.;
325 
326  if(FToCylinder) {
327  deltaP = (FPipe->GetPresion(FPipeNode) - FCylinder->getPressure()) * (double) FSentidoLamina;
328  } else {
329  deltaP = (FPipe->GetPresion(FPipeNode) - FPlenum->getPressure()) * (double) FSentidoLamina;
330  }
331 
332  switch(FTipoLamina) {
333  case nmLamina0D:
334  if(deltaP >= 0.) {
335  FCDTubVol = fun_CDin->interp(deltaP) * FKCDE;
336  } else {
337  FCDTubVol = 0.;
338  }
339  break;
340  case nmLamina1D:
341  FddLev = (__units::BarToPa(deltaP) * FArea - FRigidez * FLev - FAmortiguamiento * FdLev) / FMasa;
342  FLev = FLev + FdLev * deltaT + FddLev / 2 * pow2(deltaT);
343  FdLev = FdLev + FddLev * deltaT;
344 
345  if(FLev > 99999911.0e-3) {
346  FLev = 99999911.0e-3;
347  FdLev = 0.;
348  }
349  if(FLev > 0) {
350  FCDTubVol = fun_CDin->interp(FLev) * FKCDE;
351  } else {
352  FLev = 0.;
353  FdLev = 0.;
354  FCDTubVol = 0.;
355  ;
356  }
357  break;
358  case nmLamina2D:
359  for(int i = 0; i < (FNodosLamina + FNodosFijos + 2); ++i) {
360  FFuerza[i] = __units::BarToPa(deltaP) * FAnchoPetalo * FNumPestanyas / FDensidad / FAreaTrans;
361  if(i < FNodosFijos + 1) {
362  FFuerza[i] = 0.;
363  }
364  if(i == FNodosFijos + 1 || i == FNodosFijos + FNodosLamina + 1) {
365  FFuerza[i] *= 0.5;
366  }
367  }
368  double deltaT2 = deltaT / (double) FBucle;
369  for(int veces = 0; veces <= FBucle; ++veces) {
370  FLev2[0] = FLev2[2];
371  FLev2[FNodosLamina + FNodosFijos + 2] = 2 * FLev2[FNodosLamina + FNodosFijos + 1] - FLev2[FNodosLamina + FNodosFijos];
372  for(int i = 2; i <= FNodosLamina + FNodosFijos; ++i) {
373  FDerivada4 = FLev2[i - 2] - 4 * FLev2[i - 1] + 6 * FLev2[i] - 4 * FLev2[i + 1] + FLev2[i + 2];
374  FDerivada4 = FDerivada4 / pow4(FDeltaX);
375  FLev3[i] = pow2(deltaT2) * (FFuerza[i] - FCoefC * FDerivada4) + (2 * FAmortiguamiento * deltaT2) * FLev2[i] - FLev1[i];
376  FLev3[i] = FLev3[i] / (1 + FAmortiguamiento * deltaT2);
377  if(FLev3[i] < 0)
378  FLev3[i] = 0.;
379  }
380  FLev3[1] = 0.;
381  FLev3[FNodosLamina + FNodosFijos + 1] = 2 * FLev3[FNodosLamina + FNodosFijos] - FLev3[FNodosLamina + FNodosFijos - 1];
382  if(FLev3[FNodosLamina + FNodosFijos + 1] < 0.)
383  FLev3[FNodosLamina + FNodosFijos + 1] = 0;
384  for(int i = 1; i <= FNodosLamina + FNodosFijos + 1; ++i) {
385  FLev1[i] = FLev2[i];
386  FLev2[i] = FLev3[i];
387  }
388  }
389  FLev = FLev3[FNodosLamina + FNodosFijos + 1];
390 
391  if(FLev > 99999911.0e-3) {
392  FLev = 99999911.0e-3;
393  FdLev = 0.;
394  }
395  if(FLev > 0) {
396  FCDTubVol = fun_CDin->interp(FLev) * FKCDE;
397  } else {
398  FLev = 0.;
399  FCDTubVol = 0.;
400  }
401 
402  break;
403  }
404  FCDTubVol *= FSectionRatio;
405 }
406 
407 void TLamina::GetCDout(double Time) {
408 
409  double deltaT = Time - FTime0;
410  FTime0 = Time;
411  double deltaP = 0.;
412 
413  if(FToCylinder) {
414  deltaP = (FPipe->GetPresion(FPipeNode) - FCylinder->getPressure()) * (double) FSentidoLamina;
415  } else {
416  deltaP = (FPipe->GetPresion(FPipeNode) - FPlenum->getPressure()) * (double) FSentidoLamina;
417  }
418 
419  switch(FTipoLamina) {
420  case nmLamina0D:
421  if(deltaP >= 0.) {
422  FCDVolTub = fun_CDout->interp(deltaP) * FKCDS;
423  } else {
424  FCDVolTub = 0.;
425  }
426  break;
427  case nmLamina1D:
428  FddLev = (__units::BarToPa(deltaP) * FArea - FRigidez * FLev - FAmortiguamiento * FdLev) / FMasa;
429  FLev = FLev + FdLev * deltaT + FddLev / 2 * pow2(deltaT);
430  FdLev = FdLev + FddLev * deltaT;
431 
432  if(FLev > 99999911.0e-3) {
433  FLev = 99999911.0e-3;
434  FdLev = 0.;
435  }
436  if(FLev > 0) {
437  FCDVolTub = fun_CDout->interp(FLev) * FKCDS;
438  } else {
439  FLev = 0.;
440  FdLev = 0.;
441  FCDVolTub = 0.;
442  }
443  break;
444  case nmLamina2D:
445  for(int i = 0; i < (FNodosLamina + FNodosFijos + 2); ++i) {
446  FFuerza[i] = __units::BarToPa(deltaP) * FAnchoPetalo * FNumPestanyas / FDensidad / FAreaTrans;
447  if(i < FNodosFijos + 1) {
448  FFuerza[i] = 0.;
449  }
450  if(i == FNodosFijos + 1 || i == FNodosFijos + FNodosLamina + 1) {
451  FFuerza[i] *= 0.5;
452  }
453  }
454  double deltaT2 = deltaT / (double) FBucle;
455  for(int veces = 0; veces <= FBucle; ++veces) {
456  FLev2[0] = FLev2[2];
457  FLev2[FNodosLamina + FNodosFijos + 2] = 2 * FLev2[FNodosLamina + FNodosFijos + 1] - FLev2[FNodosLamina + FNodosFijos];
458  for(int i = 2; i <= FNodosLamina + FNodosFijos; ++i) {
459  FDerivada4 = FLev2[i - 2] - 4 * FLev2[i - 1] + 6 * FLev2[i] - 4 * FLev2[i + 1] + FLev2[i + 2];
460  FDerivada4 = FDerivada4 / pow4(FDeltaX);
461  FLev3[i] = pow2(deltaT2) * (FFuerza[i] - FCoefC * FDerivada4) + (2 * FAmortiguamiento * deltaT2) * FLev2[i] - FLev1[i];
462  FLev3[i] = FLev3[i] / (1 + FAmortiguamiento * deltaT2);
463  if(FLev3[i] < 0)
464  FLev3[i] = 0.;
465  }
466  FLev3[1] = 0.;
467  FLev3[FNodosLamina + FNodosFijos + 1] = 2 * FLev3[FNodosLamina + FNodosFijos] - FLev3[FNodosLamina + FNodosFijos - 1];
468  if(FLev3[FNodosLamina + FNodosFijos + 1] < 0.)
469  FLev3[FNodosLamina + FNodosFijos + 1] = 0;
470  for(int i = 1; i <= FNodosLamina + FNodosFijos + 1; ++i) {
471  FLev1[i] = FLev2[i];
472  FLev2[i] = FLev3[i];
473  }
474  }
475  FLev = FLev3[FNodosLamina + FNodosFijos + 1];
476 
477  if(FLev > 99999911.0e-3) {
478  FLev = 99999911.0e-3;
479  FdLev = 0.;
480  }
481  if(FLev > 0) {
482  FCDVolTub = fun_CDout->interp(FLev) * FKCDS;
483  } else {
484  FLev = 0.;
485  FCDVolTub = 0.;
486  }
487 
488  break;
489  }
490  FCDVolTub *= FSectionRatio;
491 }
492 
493 //---------------------------------------------------------------------------
494 //---------------------------------------------------------------------------
495 
496 void TLamina::LeeDatosGraficas(const char *FileWAM, fpos_t &filepos) {
497  try {
498  int ndv = 0, var = 0;
499  FILE *fich = fopen(FileWAM, "r");
500  fsetpos(fich, &filepos);
501  FGraficasLam = true;
502  FGrafLev = false;
503  fscanf(fich, " %d", &ndv);
504  for(int i = 0; i < ndv; i++) {
505  fscanf(fich, " %d", &var);
506  switch(var) {
507  case 0:
508  FGrafLev = true;
509  break;
510  }
511  }
512  fgetpos(fich, &filepos);
513  fclose(fich);
514  } catch(exception &N) {
515  std::cout << "ERROR: LeeDatosGraficas Lamina" << std::endl;
516  //std::cout << "Tipo de error: " << N.what().scr() << std::endl;
517  throw Exception(N.what());
518 
519  }
520 }
521 
522 //---------------------------------------------------------------------------
523 //---------------------------------------------------------------------------
524 
525 void TLamina::CabeceraGraficaINS(stringstream& insoutput, int lam) {
526  try {
527 //FILE *fich=fopen(FileSALIDA,"a");
528  std::string Label;
529 
530  if(FGraficasLam) {
531  if(FGrafLev) {
532  Label = "\t" + PutLabel(14) + std::to_string(lam) + PutLabel(902);
533  insoutput << Label.c_str();
534  }
535  }
536 //fclose(fich);
537  } catch(exception &N) {
538  std::cout << "ERROR: CabeceraGrafica Lamina" << std::endl;
539  //std::cout << "Tipo de error: " << N.what().scr() << std::endl;
540  throw Exception(N.what());
541 
542  }
543 }
544 
545 //---------------------------------------------------------------------------
546 //---------------------------------------------------------------------------
547 
548 void TLamina::ImprimeGraficaINS(stringstream& insoutput) {
549  try {
550 //FILE *fich=fopen(FileSALIDA,"a");
551  if(FGraficasLam) {
552  if(FGrafLev)
553  insoutput << "\t" << FLev;
554  }
555 //fclose(fich);
556  } catch(exception &N) {
557  std::cout << "ERROR: ImprimeGrafica Lamina" << std::endl;
558  //std::cout << "Tipo de error: " << N.what().scr() << std::endl;
559  throw Exception(N.what());
560 
561  }
562 }
563 
564 //---------------------------------------------------------------------------
565 //---------------------------------------------------------------------------
566 
567 #pragma package(smart_init)
TTipoValvula
Definition: TTipoValvula.h:53
Hermite_interp
Definition: Math_wam.h:311
TLamina
Definition: TLamina.h:50
TTubo::GetPresion
double GetPresion(int i) const
Gets the fluid pressure.
Definition: TTubo.cpp:5468
PutLabel
std::string PutLabel(int idx)
Returns an integer.
Definition: labels.cpp:475
Exception
Custom exception class.
Definition: Exception.hpp:39
pow4
T pow4(T x)
Returns x to the power of 4.
Definition: Math_wam.h:114
TTubo.h
TBloqueMotor
Definition: TBloqueMotor.h:43
pow2
T pow2(T x)
Returns x to the power of 2.
Definition: Math_wam.h:88