OpenWAM
BoundaryFunctions.h
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 #ifndef BoundaryFunctionsH
30 #define BoundaryFunctionsH
31 
32 //#include "roots.h"
33 // #include "Math_wam.h"
34 #include "Globales.h"
35 // ---------------------------------------------------------------------------
36 
37 struct stFESub {
38  double AA;
39  double Ad;
40  double Gam;
41  double K;
42  double BC;
43  double Ga3;
44 
45  double U2;
46  double U2_2;
47  double AdAA;
48  double invAdAA;
49 
50  stFESub(const double iAA, const double iAd, const double ig, const double iK, const double iCC) :
51  AA(iAA), Ad(iAd), Gam(ig), K(iK), BC(iCC) {
52  Ga3 = (Gam - 1) / 2;
53  AdAA = Ad * AA;
54  invAdAA = 1 / AdAA;
55  }
56  ;
57 
58  double operator()(const double A2) {
59  double xx = A2 * invAdAA;
60  double yy = pow(xx, 2 / Ga3);
61  yy = pow2(K) * yy - 1.;
62  U2_2 = 0;
63  if(xx > 1)
64  U2_2 = AdAA * sqrt((pow2(xx) - 1.) / (yy * Ga3)); // Valor absoluto
65  U2 = (BC - A2) / Ga3;
66  return U2_2 - U2;
67  }
68 };
69 
70 struct stFESup {
71  double Gam;
72  double K;
73  double Ga3;
74  double Ga8;
75  double Ga9;
76 
77  stFESup(const double ig, const double iK) :
78  Gam(ig), K(iK) {
79  Ga3 = (Gam - 1) / 2;
80  Ga8 = (Gam + 1) / 2;
81  Ga9 = (Gam - 1) / Ga8;
82  }
83  ;
84 
85  double operator()(const double M) {
86 
87  double yy = Ga8 * pow(K * M, Ga9);
88  double xx = Ga3 * pow2(M);
89  return xx - yy + 1.;
90  }
91 };
92 
93 struct stFSSub {
94  double AA;
95  double Ad;
96  double Gam;
97  double K;
98  double BC;
99  double Ga3;
100  double Ac;
101 
102  double U2;
103  double invAdAA;
104  double pow2Ac;
105 
106  stFSSub(const double iAA, const double iAd, const double ig, const double iK, const double iCC, const double iAc) :
107  AA(iAA), Ad(iAd), Ac(iAc), Gam(ig), K(iK), BC(iCC) {
108  Ga3 = (Gam - 1) / 2;
109  invAdAA = 1 / (AA * Ad);
110  pow2Ac = pow2(Ac);
111  }
112  ;
113 
114  double operator()(const double A2) {
115  U2 = 0;
116  if(pow2Ac > pow2(A2)) {
117  U2 = sqrt((pow2Ac - pow2(A2)) / Ga3);
118  }
119  double A1 = Ac * (BC + Ga3 * U2) * invAdAA;
120  double U1 = K * U2 * pow2(A1 / A2);
121  return pow2(A1) + Ga3 * pow2(U1) - pow2Ac;
122  }
123 };
124 
125 struct stFSSup {
126  double AA;
127  double Fcc;
128  double Gam;
129  double K;
130  double BC;
131  double Ga3;
132  double Ac;
133 
134  double A2;
135  double invAA;
136  double invFcc;
137 
138  stFSSup(const double iAA, const double iFcc, const double ig, const double iK, const double iCC, const double iAc) :
139  AA(iAA), Ac(iAc), Gam(ig), K(iK), BC(iCC), Fcc(iFcc) {
140  Ga3 = (Gam - 1) / 2;
141  invAA = 1 / AA;
142  invFcc = 1 / Fcc;
143 
144  }
145  ;
146 
147  double operator()(const double U2) {
148 
149  double dif = pow2(Ac) - Ga3 * pow2(U2);
150  if(dif > 0) {
151  A2 = sqrt(dif);
152  } else {
153  A2 = 0;
154  }
155  //A2 = sqrt(pow2(Ac) - Ga3 * pow2(U2));
156  double A2_2 = sqrt(U2 * pow((BC + Ga3 * U2) * invAA, Gam / Ga3) * invFcc);
157 
158  return A2 - A2_2;
159  }
160 };
161 
162 struct stRecover {
163 
164  double AA;
165  double Ad;
166  double Gam;
167  double CR;
168  double BC;
169  double Ga3;
170 
171  double A2_2;
172  double U2;
173  double UThroat;
174  double A1;
175  double invAdAA;
176 
177  stRecover(const double iAA, const double iAd, const double ig, const double iCR, const double iCC) :
178  AA(iAA), Ad(iAd), Gam(ig), CR(iCR), BC(iCC) {
179  Ga3 = (Gam - 1) / 2;
180  invAdAA = 1 / (Ad * AA);
181  }
182  ;
183 
184  double operator()(double A2) {
185  U2 = (BC - A2) / Ga3;
186  double Ga3U22 = Ga3 * pow2(U2);
187  double Adep1 = sqrt(pow2(A2) + Ga3U22);
188  A1 = A2 * Adep1 * invAdAA;
189  UThroat = U2 * CR * pow2(A1 / A2);
190  double Adep2 = sqrt(pow2(A1) + Ga3 * pow2(UThroat));
191  A2_2 = sqrt(pow2(Adep2) - Ga3U22);
192  return A2 - A2_2;
193  }
194 };
195 /* NUEVO- PROGRAMACION DE LAS EXPRESIONES NECESARIAS PARA
196  EL METODO DE BRENT:
197  - Union Tubos: Ensanchamiento - Estrechamiento
198  - Compressor Volumetrico
199  - Perdida de presion adiabatica
200  */
201 
202 /* Wider in cross section */
203 struct stExpansion {
204 
205  /* !Definicion de las VARIABLES LOCALES */
206  /*Variables locales que almacenaran la inforamcion pasada por funcion */
207 
208  double CCS; // Variable local asociada a la caracteristica conocida en 1 (salida del tubo) y que se pasa por funcion//
209  double CCE; // Variable l.a. a la caracteristica conocida en 2, entrada al tubo//
210  double Gam; // Variable l.a. al Gamma pasado por funcion//
211  double rel_area; // Variable l.a. a la relacion de area pasada por funcion//
212  double rel_entropia; // Variable l.a. a la relacion de entropia pasada por funcion//
213 
214  /* Variables locales internas, si no se quiere acceder despues a la
215  informacion que contienen, es preferible definirlas directamente dentro del
216  operador */
217 
218  double U1; // V.L para la velocidad del fluido en 1 (SALIENTE del tubo//
219  double U2; // V.L para la velocidad del fluido en 2 (ENTRANTE al deposito//
220  double A2; // V.L para la velocidad del sonido en 2//
221  double xx3; // V.L para la velocidad del sonido, hara falta en el calculo de las caracteristicas//
222  double Ga2; // Es necesario definirlo aqui, ya que se utiliza en el operador//
223  double Ga3; // idem que Ga2//
224 
225  /* CONSTRUCTOR de la funcion, aqui se recibe por orden la informacion pasada por
226  funcion y se almacena en las variables locales */
227 
228  stExpansion(const double iCCS, const double iCCE, const double R_E, const double R_A, const double iGam) :
229  CCS(iCCS), CCE(iCCE), rel_entropia(R_E), rel_area(R_A), Gam(iGam) {
230  Ga3 = (Gam - 1) / 2;
231  /* Definicion de aquellas variables internas que se usaran en el operador, pero que no se requiere su acceso, aqui o dentro del operador */
232  Ga2 = Gam + 1;
233  }
234 
235  double operator()(const double A1) { // A1 es la velocidad del sonido en 1 es LA VARIABLE DE LA FUNCION//
236 
237  U1 = (CCS - A1) / Ga3; // Calculo de la velocidad del fluido en 1 mediante la ecuacion 4.291//
238  double xx1 = pow2(A1) + Ga3 * pow2(U1);
239  double xx2 = rel_area * pow2(A1) + Gam * pow2(U1);
240  if(fabs(U1 - A1) < 1e-15) {
241  if(Ga2 / (Gam + rel_area) >= 1) {
242  U2 = (xx2 / (Ga2 * U1));
243  } else {
244  U2 = (xx2 / (Ga2 * U1)) * (1 - sqrt(1 - pow2(Ga2 / (Gam + rel_area))));
245  }
246  } else {
247  if((xx1 * 2. * Ga2 * (pow2(U1) / pow2(xx2))) >= 1) {
248  U2 = xx2 / Ga2;
249  } else {
250  U2 = xx2 * (1 - sqrt(1. - (xx1 * 2. * Ga2 * (pow2(U1) / pow2(xx2))))) / Ga2;
251  }
252 
253  if(U1 == 0) {
254  U2 = 0;
255  } else {
256  U2 = U2 / U1;
257  }
258  }
259  A2 = sqrt(xx1 - Ga3 * pow2(U2));
260  xx3 = CCE + Ga3 * U2; // Velocity del sonido corregida, hara falta en el calculo de las caracteristicas//
261  double xx = pow(rel_entropia * xx3, Gam);
262  double xtx = (pow2(A2) + Gam * pow2(U2)) / (((Gam * pow2(U1)) / rel_area + pow2(A1)) * pow2(A2));
263  xtx = pow(xtx, Ga3);
264  double A1p = xx * xtx;
265 
266  return A1 - A1p;
267  }
268 };
269 /* ! Reduction in cross section */
270 
272 
273  /* Definicion de variables locales */
274  /* Variables locales para almacenar la informacion pasada por funcion */
275 
276  double CCS; // Variable local asociada a la caracteristica incidente conocida en 1, pasada por funcion//
277  double CCE; // Variable l.a a la caracteristica conocida en 2 inicial, pasada por funcion//
278  double rel_entropia; // Variable l.a a la relacion de entropia pasada por funcion//
279  double rel_area; // Variable l.a a la relacion de area, pasada por funcion//
280  double Gam; // Variable l.a a gamma, pasado por funcion//
281 
282  /* Variables locales internas, que permitiran el acceso. Si no se requiere acceso
283  es mejor definirlas directamente dentro del operador */
284 
285  double A1; // Variable local para la velocidad del sonido en 1//
286  double A2; // Variable local para la velocidad del sonido en 2//
287  double U2; // Variable local para la velocidad del flujo en 2//
288  double Ga1;
289  double Ga3;
290 
291  /* CONSTRUCTOR: Se recibe la informacion por funcion en variables ficticias y se
292  almacena en las variables locales */
293 
294  stContraction(const double iCCS, const double iCCE, const double R_E, const double R_A, const double iGam) :
295  CCS(iCCS), CCE(iCCE), rel_entropia(R_E), rel_area(R_A), Gam(iGam) {
296  Ga3 = (Gam - 1) / 2;
297  Ga1 = (Gam - 1);
298  }
299 
300  double operator()(const double U1) { // U1 es la velocidad del fluido en 1, es la variable a iterar de la funcion//
301 
302  A1 = CCS - Ga3 * U1; // Calculo de A1 por la ecuacion 4.315//
303  double xx1 = rel_entropia * 4. * CCE / Ga1; // Variable auxiliar para el calculo de A2//
304  double xx2 = pow2(rel_entropia) / Ga3 + 1.; // Variable auxiliar para el calculo de A2//
305  double xx3 = pow2(CCE) / Ga3 - Ga3 * pow2(U1) - pow2(A1);
306  // Variable auxiliar para el calculo de A2//
307  double b = pow2(xx1) - xx2 * 4. * xx3;
308  if(b < 0) { /* Adaptacion del metodo para este caso problematico */
309  A2 = xx1 / (2 * xx2);
310  } else {
311  A2 = (xx1 + sqrt(b)) / (2. * xx2); // Calculo de A2 segun la ec. 4.316, si el //
312  }
313  /* Si el flujo es supersonico en la seccion 1 (diametro mayor) peta el metodo de Brent peta al calcular el valor en el extremo
314  derecho, debido a que sale una raiz negativa. Probar entonces una condicion que bloquee en este caso el calculo de la raiz
315  (pero solo para el calculo de la funcion en el extremo). Por ejemplo A2=xx1/2*xx2. YA VEREMOS QUE PASA, SI CONVERGE O SIGUE PETANDO
316  ENTONCES SERIA FLUJO SUPERSONICO */
317 
318  U2 = (A2 * rel_entropia - CCE) / Ga3; // Calculo de U2 segun ec.4.317//
319  double U1p = A1 / A2; // Variable auxiliar para el calculo de U1p//
320  double xx = 1. / Ga3; // Variable auxiliar para el calculo de U1p//
321  U1p = rel_area * U2 / pow(U1p, xx); // Nuevo valor de la velocidad del flujo U1, segun la ec.4.318//
322 
323  return U1 - U1p;
324  }
325 };
326 
327 /* Adiabatic loss pressure */
328 
329 struct stPerdPresAd {
330 
331  /* Definir las variables locales donde se almacenara la informacion que se pase
332  desde el programa y que son necesarias para el calculo de la condicion de contorno.
333  Son variables de tipo double */
334 
335  // VARIABLES ALMACENAMIENTO DE VARIABLES QUE SE PASARAN//
336  double CC1; // Variable local asociada a la caracteristica incidente del extremo 1 pasada por funcion//
337  double CC2; // Variable l.a. a la caracteristica incidente del extremo 2 pasada por funcion//
338  double FK; // Variable l.a. al parametro K pasado por funcion//
339  double Gam; // Variable l.a. a Gamma pasado por funcion//
340  double FRE; // Variable l.a. a la relacion de entropia que se pasa por funcion//
341 
342  // VARIABLES INTERNAS//
343  double U1; // Variable local para almacenar la velocidad del fluido en 1//
344  double U2; // Variable local para almacenar la velocidad del fluido en 2//
345  double A2; // Variable local para almacenar la velocidad del sonido en 2//
346  double A1p; // Variable local para almacenar el valor calculado de A1 segun 4.256//
347  double xx3;
348  double Ga3;
349  double Ga5;
350 
351  /* Constructor de la funcion. Aqui se RECIBEN las variables necesarias para el calculo
352  y que han sido enviadas desde el programa, el nombre de cabecera es ficticio, la
353  informacion se almacena por posicion. En el lado derecho se asocia a cada variable
354  local el valor de la variable pasada por funcion */
355 
356  stPerdPresAd(const double iCC1, const double iCC2, const double iFK, const double iGam, const double iFRE) :
357  CC1(iCC1), CC2(iCC2), FK(iFK), Gam(iGam), FRE(iFRE) {
358  Ga3 = (Gam - 1) / 2;
359  Ga5 = (Gam - 1) / 2 / Gam;
360  }
361 
362  double operator()(const double A1) { // A1 es la variable incognita de la funcion, es decir sobre la que se itera//
363 
364  U1 = (CC1 - A1) / Ga3; // ecuacion 4.246//
365  double a = Ga3;
366  double b1 = -FK * pow2(U1) / pow2(A1) + 1.;
367  double b = pow2(A1) * b1;
368  double c = -(pow2(A1) + Ga3 * pow2(U1)) * pow2(U1);
369  double u2u1 = (sqrt(pow2(b) - 4. * a * c) - b) / (2. * a); // ec. 252//
370  if(U1 == 0.) {
371  U2 = 0.; // ec.253//
372  } else { // ec.254//
373  U2 = u2u1 / U1;
374  }
375 
376  A2 = sqrt(pow2(A1) + Ga3 * (pow2(U1) - pow2(U2))); // ec.255//
377 
378  xx3 = CC2 + Ga3 * U2;
379  A1p = xx3 * FRE * pow(b1, -Ga5); // ec.4.256, CUIDADO QUE HAY UN SIGNO MENOS EN EL EXPONENTE//
380 
381  return A1p - A1;
382  }
383 };
384 
386 
387  double CC1; // Variable local asociada a la caracteristica incidente del extremo 1 pasada por funcion//
388  double CC2; // Variable l.a. a la caracteristica incidente del extremo 2 pasada por funcion//
389  double FK; // Variable l.a. al parametro K pasado por funcion//
390  double Gam; // Variable l.a. a Gamma pasado por funcion//
391  double FRE; // Variable l.a. a la relacion de entropia que se pasa por funcion//
392  double ARef; // Variable l.a. a la velocidad del sonido de referencia //
393  double ei;
394  double ed;
395 
396  double U1; // Variable local para almacenar la velocidad del fluido en 1//
397  double U2; // Variable local para almacenar la velocidad del fluido en 2//
398  double A2; // Variable local para almacenar la velocidad del sonido en 2//
399  double A1p; // Variable local para almacenar el valor calculado de A1 segun 4.256//
400  double xx3;
401  double Ga3;
402  double Ga5;
403 
404  stPerdPresAdL(const double iCC1, const double iCC2, const double iFK, const double iGam, const double iFRE,
405  const double iARef) :
406  CC1(iCC1), CC2(iCC2), FK(iFK), Gam(iGam), FRE(iFRE), ARef(iARef) {
407  Ga3 = (Gam - 1) / 2;
408  Ga5 = (Gam - 1) / 2 / Gam;
409  }
410 
411  double operator()(const double A1) {
412 
413  U1 = (CC1 - A1) / Ga3; // Calculo de la velocidad saliente.//
414  double b1 = -FK * fabs(U1) / pow2(A1) + 1.;
415  b1 += 1e-14; // Resolucion ecuacion de 2 grado y calculo de la velocidad entrante.OJO que he cambiado la formula.Pedro.//
416  // Resolucion ecuacion de 2 grado y calculo de la velocidad entrante.//
417  double a = Ga3;
418  double b = b1 * pow2(A1);
419  double c = -(pow2(A1) + Ga3 * pow2(U1)) * pow2(U1);
420  double u2u1 = QuadraticEqP(a, b, c);
421  if(U1 == 0.) {
422  U2 = 0.;
423  } else {
424  U2 = u2u1 / U1;
425  }
426  A2 = sqrt(pow2(A1) + Ga3 * (pow2(U1) - pow2(U2)));
427  // Calculo de la velocidad del sonido entrante.
428 
429  xx3 = CC2 + U2 * Ga3;
430 
431  A1p = xx3 * FRE / pow(b1, Ga5);
432 
433  return A1p - A1;
434  }
435 };
436 
437 /* ! Volumetric Compressor */
438 
439 struct stComprVol {
440 
441  /* Definicion de las variables locales (pueden tomar cualquier nombre)
442  y que almacenaran la informacion de las variables pasadas a la funcion
443  desde el programa, LA INFORMACION SE ASOCIARA EN EL CONSTRUCTOR. AQUI
444  SOLO SE ESTAN DEFINIENDO */
445 
446  /* PASO POR EL CONSTRUCTOR __cons::ARef y PRef para evitar incluir la libreria globales */
447 
448  double AA; // Variable local asociada al nivel de entropia inicial pasado por la funcion//
449  double BC; // Variable l.a a la caracteristica incidente inicial pasada por la funcion //
450  double Gam; // Variable l.a al gamma pasado por la funcion//
451  double A; // Variable l.a a la velocidad del sonido pasada por la funcion//
452  double Gasto_calculado; // Variable l.a al massflow calculado por (4.113) y pasado por la funcion//
453  double F; // Variable l.a a la seccion del tubo y pasado por funcion//
454  double PRef; // Variable l.a a la presion de referencia y que se ha pasado por funcion y asi evitar incluir la libreria globales//
455  double ARef; // Variable l.a a la velocidad del sonido de referencia con idem justificacion que PRef//
456 
457  double Ga3; // Variable local//
458  double Ga4; // Variable local//
459  double entropia; // Variable local para la entropia//
460  // double Gasto_supuesto; //Variable local para el massflow supueso//
461  double CD; // Variable local//
462  double U;
463 
464  /* CONSTRUCTOR: Aqui se RECIBEN las VARIABLES PASADAS con un nombre ficticio
465  parecido al de la definicio de las variables locales (por ejemplo precedido de i)
466  EN EL LADO IZQUIERDO (variables recibidas) : EN EL LADO DERECHO (informacion almacenada)
467  y que son necesarias para el calculo del operador (tipo de variable y nombre ficticio) y a continuacion
468  SE ASOCIAN a las variables locales que almacenaran la informacion pasada */
469 
470  stComprVol(const double iAA, const double iCC, const double iGam, const double iA, const double iGS, const double iF,
471  const double iPRef, const double iARef) :
472  AA(iAA), BC(iCC), Gam(iGam), A(iA), Gasto_calculado(iGS), F(iF), PRef(iPRef), ARef(iARef) {
473  Ga3 = (Gam - 1) / 2;
474  Ga4 = 2 * Gam / (Gam - 1);
475  CD = 1;
476  }
477  ;
478 
479  double operator()(const double Vel) {
480  double entropia = A * AA / (BC + Ga3 * Vel);
481  U = Gasto_calculado * pow(entropia, Ga4) / (CD * Gam * F * __units::BarToPa(PRef) / ARef * pow(A, 1 / Ga3));
482 
483  return U - Vel;
484  }
485 
486 };
487 
489  double Mass;
490  double A01;
491  double AA1;
492  double Section;
493  double Lambda;
494  double Gam;
495  double Ga3;
496  double Eff;
497 
498  stNewCompressorConditions(const double iMass, const double iCC, const double T01, const double P01, const double iEff,
499  const double iGam, const double R, const double Sec) :
500  Mass(iMass), Lambda(iCC), Gam(iGam), Section(Sec), Eff(iEff) {
501  A01 = sqrt(Gam * R * T01);
502  AA1 = A01 * pow(P01, (1 - Gam) / 2 / Gam);
503  Ga3 = (Gam - 1) / 2;
504  }
505 
506  double operator()(const double Match) {
507 
508  double A2 = Lambda / (1 - Ga3 * Match);
509  double k = pow2(A2) * (1 + Ga3 * Match * Match) / (A01 * A01) - 1;
510  double AA2 = AA1 * sqrt(1 + k) / (k * Eff + 1);
511  double Match2 = Mass / (Gam * pow(A2 / pow(AA2, Gam), 1 / Ga3) * A2 * Section);
512  return Match - Match2;
513 
514  }
515 };
516 
517 struct stCharOrigin {
518  double W00;
519  double W10;
520  double W20;
521  double W01;
522  double W11;
523  double W21;
524  double G0;
525  double G1;
526  double dtdx;
527  int signo;
528 
529  stCharOrigin(const double iW00, const double iW10, const double iW20, const double iW01, const double iW11,
530  const double iW21, const double iG0, const double iG1, const double idtdx, int isigno) :
531  W00(iW00), W10(iW10), W20(iW20), W01(iW01), W11(iW11), W21(iW21), G0(iG0), G1(iG1), dtdx(idtdx), signo(isigno) {
532  }
533 
534  double operator()(const double x) {
535  double W0p = Interpola(W00, W01, 1., x);
536  double W1p = Interpola(W10, W11, 1., x);
537  double W2p = Interpola(W20, W21, 1., x);
538  double Gp = Interpola(G0, G1, 1., x);
539  double Up = W1p / W0p;
540  double Ap = sqrt(Gp * (Gp - 1) * (W2p / W0p - pow2(Up) / 2.));
541  return x + signo * (Up - signo * Ap) * dtdx;
542  }
543 };
544 
545 struct stPathOrigin {
546  double W00;
547  double W10;
548  double W01;
549  double W11;
550  double dtdx;
551  int signo;
552 
553  stPathOrigin(const double iW00, const double iW10, const double iW01, const double iW11, const double idtdx,
554  int isigno) :
555  W00(iW00), W10(iW10), W01(iW01), W11(iW11), dtdx(idtdx), signo(isigno) {
556  }
557 
558  double operator()(const double x) {
559  double W0p = Interpola(W00, W01, 1., x);
560  double W1p = Interpola(W10, W11, 1., x);
561  double Up = W1p / W0p;
562  return x + signo * Up * dtdx;
563  }
564 };
565 
566 #endif
567 
stRecover
Definition: BoundaryFunctions.h:162
stPathOrigin
Definition: BoundaryFunctions.h:545
stExpansion
Definition: BoundaryFunctions.h:203
stFESub
Definition: BoundaryFunctions.h:37
stPerdPresAd
Definition: BoundaryFunctions.h:329
stComprVol
Definition: BoundaryFunctions.h:439
stNewCompressorConditions
Definition: BoundaryFunctions.h:488
stFESup
Definition: BoundaryFunctions.h:70
stFSSub
Definition: BoundaryFunctions.h:93
stPerdPresAdL
Definition: BoundaryFunctions.h:385
stContraction
Definition: BoundaryFunctions.h:271
stCharOrigin
Definition: BoundaryFunctions.h:517
pow2
T pow2(T x)
Returns x to the power of 2.
Definition: Math_wam.h:88
stFSSup
Definition: BoundaryFunctions.h:125