mbsimhydraulics  3.0.0
pressure_loss.h
1 /* Copyright (C) 2004-2009 MBSim Development Team
2  *
3  * This library is free software; you can redistribute it and/or
4  * modify it under the terms of the GNU Lesser General Public
5  * License as published by the Free Software Foundation; either
6  * version 2.1 of the License, or (at your option) any later version.
7  *
8  * This library is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  * Lesser General Public License for more details.
12  *
13  * You should have received a copy of the GNU Lesser General Public
14  * License along with this library; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16  *
17  * Contact: markus.ms.schneider@gmail.com
18  */
19 
20 #ifndef _PRESSURE_LOSS_H_
21 #define _PRESSURE_LOSS_H_
22 
23 #include "mbsim/element.h"
24 #include "mbsim/utils/function.h"
25 
26 namespace MBSim {
27  class TabularFunction1_VS;
28  class Function1_SS;
29 }
30 
31 namespace MBSimHydraulics {
32 
33  class HydlinePressureloss;
34 
36  class PressureLoss : public MBSim::Function1<double,double> {
37  public:
38  PressureLoss() : initialized(false) {}
39  protected:
40  bool initialized;
41  };
42 
43 
45  class LinePressureLoss : public PressureLoss {
46  public:
48  };
49 
50 
53  public:
55  void addLinePressureLoss(LinePressureLoss * l) {slp.push_back(l); }
56  double operator()(const double& Q, const void * line);
57  void initializeUsingXML(TiXmlElement * element);
58  private:
59  std::vector<LinePressureLoss*> slp;
60  };
61 
62 
65  public:
66  ParallelResistanceLinePressureLoss() : LinePressureLoss(), pl(NULL), number(0) {}
67  void setLinePressureLoss(LinePressureLoss * pl_, int number_) {pl=pl_; number=double(number_); }
68  double operator()(const double& Q, const void * line);
69  void initializeUsingXML(TiXmlElement * element);
70  private:
71  LinePressureLoss* pl;
72  double number;
73  };
74 
75 
78  public:
80  void setZeta(double zeta_) {c=zeta_; }
81  double operator()(const double& Q, const void * line);
82  void initializeUsingXML(TiXmlElement *element);
83  private:
84  double c;
85  };
86 
87 
90  public:
91  ZetaPosNegLinePressureLoss() : LinePressureLoss(), cPos(0), cNeg(0) {};
92  void setZetaPos(double zeta_) {cPos=zeta_; }
93  void setZetaNeg(double zeta_) {cNeg=zeta_; }
94  double operator()(const double& Q, const void * line);
95  void initializeUsingXML(TiXmlElement *element);
96  private:
97  double cPos, cNeg;
98  };
99 
100 
103  public:
105  double operator()(const double& Q, const void * line);
106  private:
107  double c;
108  };
109 
110 
113  public:
114  TurbulentTubeFlowLinePressureLoss() : LinePressureLoss(), c(0), dRef(0), dHyd(0), dHydNeg(0), k(0), ReynoldsFactor(0), ReynoldsFactorNeg(0), lambdaTabular(NULL) {}
115  void setReferenceDiameter(double dRef_) {dRef=dRef_; }
116  void setHydraulicDiameter(double dHyd_, double dHydNeg_=0);
117  void setSurfaceRoughness(double k_) {k=k_; }
118  double operator()(const double& Q, const void * line);
119  void initializeUsingXML(TiXmlElement *element);
120  private:
121  double c, dRef, dHyd, dHydNeg, k, ReynoldsFactor, ReynoldsFactorNeg;
122  MBSim::TabularFunction1_VS * lambdaTabular;
123  };
124 
125 
128  public:
129  CurveFittedLinePressureLoss() : LinePressureLoss(), dRef(0), dHyd(0), aPos(0), bPos(0), aNeg(0), bNeg(0), ReynoldsFactor(0) {}
130  void setFactors(double aPos_, double bPos_, double aNeg_, double bNeg_, double dRef_, double dHyd_) { aPos=aPos_; bPos=bPos_; aNeg=aNeg_; bNeg=bNeg_; dRef=dRef_; dHyd=dHyd_; }
131  double operator()(const double& Q, const void * line);
132  void initializeUsingXML(TiXmlElement *element);
133  private:
134  double dRef, dHyd;
135  double aPos, bPos, aNeg, bNeg;
136  double ReynoldsFactor;
137  };
138 
139 
142  public:
143  TabularLinePressureLoss() : LinePressureLoss(), zetaTabular(NULL) {};
144  void setZetaTabular(MBSim::Function1<double, double> * zetaTabular_) {zetaTabular=zetaTabular_; }
145  double operator()(const double& Q, const void * line);
146  void initializeUsingXML(TiXmlElement *element);
147  private:
148  MBSim::Function1<double, double> * zetaTabular;
149  };
150 
151 
154  public:
156  };
157 
158 
161  public:
163  void setZeta(double zeta_) {c=zeta_; }
164  void setZetaNegative(double zeta_) {cNeg=zeta_; }
165  virtual double operator()(const double& Q, const void * line);
166  void initializeUsingXML(TiXmlElement *element);
167  private:
168  double c, cNeg;
169  };
170 
171 
174  public:
176  void setLength(double l_) {l=l_; }
177  void setWidth(double b_) {b=b_; }
178  virtual double operator()(const double& Q, const void * line);
179  void initializeUsingXML(TiXmlElement *element);
180  private:
181  double c, l, b;
182  };
183 
184 
187  public:
188  ReynoldsClosablePressureLoss() : ClosablePressureLoss(), nu(0), lambdaSlope(0), lambdaOffset(0), zetaFactor(0) {}
189  virtual double operator()(const double& Q, const void * line);
190  private:
191  double nu, lambdaSlope, lambdaOffset, zetaFactor;
192  };
193 
194 
197  public:
198  RelativeAlphaClosablePressureLoss() : ClosablePressureLoss(), alpha(0), alpha2(0), c(0) {}
199  void setAlpha(double alpha_) {alpha=alpha_; assert(alpha>.01); assert(alpha<=1.); }
200  virtual double operator()(const double& Q, const void * line);
201  void initializeUsingXML(TiXmlElement *element);
202  private:
203  double alpha, alpha2, c;
204  };
205 
206 
209  public:
211  void setBallRadius(double rBall_) {rBall=rBall_; }
212  double getBallRadius() const {return rBall; }
213  virtual double calcBallForceArea() {return -1.; }
214  void initializeUsingXML(TiXmlElement *element);
215  protected:
216  double rBall;
217  };
218 
219 
222  public:
223  GammaCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), alpha(0), gamma(0), c(0), siga(0), coga(0) {}
224  void setAlpha(double alpha_) {alpha=alpha_; }
225  void setGamma(double gamma_) {gamma=gamma_; }
226  virtual double calcBallForceArea() {return M_PI*rBall*rBall*sin(gamma)*sin(gamma); }
227  double operator()(const double& Q, const void * =NULL);
228  void initializeUsingXML(TiXmlElement *element);
229  private:
230  double alpha, gamma, c, siga, coga;
231  };
232 
233 
236  public:
238  double operator()(const double& Q, const void * line);
239  private:
240  double d0, c;
241  };
242 
243 
246  public:
248  void setAlpha(double alpha_) {alpha=alpha_; }
249  double operator()(const double& Q, const void * line);
250  void initializeUsingXML(TiXmlElement *element);
251  private:
252  double alpha;
253  double numer[2], denom[2], c;
254  };
255 
256 
259  public:
260  LeakagePressureLoss() : PressureLoss(), stateless(true) {}
261  protected:
262  bool stateless;
263  };
264 
265 
268  public:
269  PlaneLeakagePressureLoss() : LeakagePressureLoss(), pVfac(0), xdfac(0) {}
270  double operator()(const double& pVorQ, const void * line);
271  private:
272  double pVfac, xdfac;
273  };
274 
275 
278  public:
280  };
281 
282 
285  public:
286  EccentricCircularLeakagePressureLoss() : CircularLeakagePressureLoss (), ecc(0), pVfac(0), xdfac(0) {}
287  void setEccentricity(double ecc_) {ecc=ecc_; }
288  double operator()(const double& pVorQ, const void * line);
289  void initializeUsingXML(TiXmlElement *element);
290  private:
291  double ecc, pVfac, xdfac;
292  };
293 
294 
297  public:
298  RealCircularLeakagePressureLoss() : CircularLeakagePressureLoss(), pVfac(0), vIfac(0), vOfac(0) {}
299  double operator()(const double& pVorQ, const void * line);
300  private:
301  double pVfac, vIfac, vOfac;
302  };
303 
304 
307  public:
309  };
310 
311 
314  public:
316  void setZeta(double zeta_) {c=zeta_; }
317  virtual double operator()(const double& Q, const void * line);
318  void initializeUsingXML(TiXmlElement *element);
319  private:
320  double c;
321  };
322 
323 
324 // // class PositiveFlowLimittingPressureLoss : public VariablePressureLoss {
325 // // public:
326 // // PositiveFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal) : VariablePressureLoss(name, checkSizeSignal) {}
327 // // bool isUnilateral() {return true; }
328 // // void update(const double& Q);
329 // // double operator()(const double& Q) {pLoss=0; return pLoss; }
330 // // protected:
331 // // double QLimit;
332 // // };
333 // //
334 // // class RegularizedPositiveFlowLimittingPressureLoss : public PositiveFlowLimittingPressureLoss {
335 // // public:
336 // // RegularizedPositiveFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal, double zeta1_,double offset_) : PositiveFlowLimittingPressureLoss(name, checkSizeSignal), zeta1(zeta1_), offset(offset_) {assert(offset>0); }
337 // // bool isUnilateral() {return false; }
338 // // double operator()(const double& Q);
339 // // private:
340 // // double zeta1, offset;
341 // // double zeta;
342 // // };
343 // //
344 // // class NegativeFlowLimittingPressureLoss : public VariablePressureLoss {
345 // // public:
346 // // NegativeFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal) : VariablePressureLoss(name, checkSizeSignal) {}
347 // // bool isUnilateral() {return true; }
348 // // void update(const double& Q);
349 // // double operator()(const double& Q) {pLoss=0; return pLoss; }
350 // // };
351 
352 }
353 
354 #endif /* ----- #ifndef _PRESSURE_LOSS_H_ ----- */