All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Pages
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/functions/function.h>
25 
26 namespace MBSim {
27  template <class Sig> class TabularFunction;
28 }
29 
30 namespace MBSimHydraulics {
31 
32  class HydlinePressureloss;
33  class HLine;
34 // class RigidLine;
35 // class ClosableRigidLine;
36 // class PlaneLeakage0DOF;
37 
39  class PressureLoss : public MBSim::Function<double(double)> {
40  public:
41  PressureLoss() : line(0), initialized(false) {}
42  virtual void setLine(const HLine *line_) { line = line_; }
43  protected:
44  const HLine *line;
45  bool initialized;
46  };
47 
48 
50  class LinePressureLoss : public PressureLoss {
51  public:
53  };
54 
55 
58  public:
61  void setLine(const HLine *line_) { line = line_; for(unsigned int i=0; i<slp.size(); i++) slp[i]->setLine(line); }
62  void addLinePressureLoss(LinePressureLoss * l) { slp.push_back(l); }
63  double operator()(const double& Q);
64  void initializeUsingXML(xercesc::DOMElement * element);
65  private:
66  std::vector<LinePressureLoss*> slp;
67  };
68 
69 
72  public:
73  ParallelResistanceLinePressureLoss() : LinePressureLoss(), pl(NULL), number(0) {}
74  void setLine(const HLine *line_) { line = line_; pl->setLine(line); }
75  void setLinePressureLoss(LinePressureLoss * pl_, int number_) {pl=pl_; number=double(number_); }
76  double operator()(const double& Q);
77  void initializeUsingXML(xercesc::DOMElement * element);
78  private:
79  LinePressureLoss* pl;
80  double number;
81  };
82 
83 
86  public:
88  void setZeta(double zeta_) {c=zeta_; }
89  double operator()(const double& Q);
90  void initializeUsingXML(xercesc::DOMElement *element);
91  private:
92  double c;
93  };
94 
95 
98  public:
99  ZetaPosNegLinePressureLoss() : LinePressureLoss(), cPos(0), cNeg(0) {};
100  void setZetaPos(double zeta_) {cPos=zeta_; }
101  void setZetaNeg(double zeta_) {cNeg=zeta_; }
102  double operator()(const double& Q);
103  void initializeUsingXML(xercesc::DOMElement *element);
104  private:
105  double cPos, cNeg;
106  };
107 
108 
111  public:
113  double operator()(const double& Q);
114  private:
115  double c;
116  };
117 
118 
121  public:
122  TurbulentTubeFlowLinePressureLoss() : LinePressureLoss(), c(0), dRef(0), dHyd(0), dHydNeg(0), k(0), ReynoldsFactor(0), ReynoldsFactorNeg(0), lambdaTabular(NULL) {}
124  void setReferenceDiameter(double dRef_) {dRef=dRef_; }
125  void setHydraulicDiameter(double dHyd_, double dHydNeg_=0);
126  void setSurfaceRoughness(double k_) {k=k_; }
127  double operator()(const double& Q);
128  void initializeUsingXML(xercesc::DOMElement *element);
129  private:
130  double c, dRef, dHyd, dHydNeg, k, ReynoldsFactor, ReynoldsFactorNeg;
132  };
133 
134 
137  public:
138  CurveFittedLinePressureLoss() : LinePressureLoss(), dRef(0), dHyd(0), aPos(0), bPos(0), aNeg(0), bNeg(0), ReynoldsFactor(0) {}
139  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_; }
140  double operator()(const double& Q);
141  void initializeUsingXML(xercesc::DOMElement *element);
142  private:
143  double dRef, dHyd;
144  double aPos, bPos, aNeg, bNeg;
145  double ReynoldsFactor;
146  };
147 
148 
151  public:
152  TabularLinePressureLoss() : LinePressureLoss(), zetaTabular(NULL) {};
153  ~TabularLinePressureLoss() { delete zetaTabular; }
154  void setZetaTabular(MBSim::Function<double(double)> * zetaTabular_) {
155  zetaTabular=zetaTabular_;
156  zetaTabular->setParent(this);
157  zetaTabular->setName("Zeta");
158  }
159  double operator()(const double& Q);
160  void initializeUsingXML(xercesc::DOMElement *element);
161  void init(MBSim::Element::InitStage stage);
162  private:
163  MBSim::Function<double(double)> * zetaTabular;
164  };
165 
166 
169  public:
171  };
172 
173 
176  public:
178  void setZeta(double zeta_) {c=zeta_; }
179  void setZetaNegative(double zeta_) {cNeg=zeta_; }
180  virtual double operator()(const double& Q);
181  void initializeUsingXML(xercesc::DOMElement *element);
182  private:
183  double c, cNeg;
184  };
185 
186 
189  public:
191  void setLength(double l_) {l=l_; }
192  void setWidth(double b_) {b=b_; }
193  virtual double operator()(const double& Q);
194  void initializeUsingXML(xercesc::DOMElement *element);
195  private:
196  double c, l, b;
197  };
198 
199 
202  public:
203  ReynoldsClosablePressureLoss() : ClosablePressureLoss(), nu(0), lambdaSlope(0), lambdaOffset(0), zetaFactor(0) {}
204  virtual double operator()(const double& Q);
205  private:
206  double nu, lambdaSlope, lambdaOffset, zetaFactor;
207  };
208 
209 
212  public:
213  RelativeAlphaClosablePressureLoss() : ClosablePressureLoss(), alpha(0), alpha2(0), c(0) {}
214  void setAlpha(double alpha_) {alpha=alpha_; assert(alpha>.01); assert(alpha<=1.); }
215  virtual double operator()(const double& Q);
216  void initializeUsingXML(xercesc::DOMElement *element);
217  private:
218  double alpha, alpha2, c;
219  };
220 
221 
224  public:
226  void setBallRadius(double rBall_) {rBall=rBall_; }
227  double getBallRadius() const {return rBall; }
228  virtual double calcBallForceArea() {return -1.; }
229  void initializeUsingXML(xercesc::DOMElement *element);
230  protected:
231  double rBall;
232  };
233 
234 
237  public:
238  GammaCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), alpha(0), gamma(0), c(0), siga(0), coga(0) {}
239  void setAlpha(double alpha_) {alpha=alpha_; }
240  void setGamma(double gamma_) {gamma=gamma_; }
241  virtual double calcBallForceArea() {return M_PI*rBall*rBall*sin(gamma)*sin(gamma); }
242  double operator()(const double& Q);
243  void initializeUsingXML(xercesc::DOMElement *element);
244  private:
245  double alpha, gamma, c, siga, coga;
246  };
247 
248 
251  public:
253  double operator()(const double& Q);
254  private:
255  double d0, c;
256  };
257 
258 
261  public:
263  void setAlpha(double alpha_) {alpha=alpha_; }
264  double operator()(const double& Q);
265  void initializeUsingXML(xercesc::DOMElement *element);
266  private:
267  double alpha;
268  double numer[2], denom[2], c;
269  };
270 
271 
274  public:
275  LeakagePressureLoss() : PressureLoss(), stateless(true) {}
276  protected:
277  bool stateless;
278  };
279 
280 
283  public:
284  PlaneLeakagePressureLoss() : LeakagePressureLoss(), pVfac(0), xdfac(0) {}
285  double operator()(const double& pVorQ);
286  private:
287  double pVfac, xdfac;
288  };
289 
290 
291 
294  public:
296  };
297 
298 
301  public:
302  EccentricCircularLeakagePressureLoss() : CircularLeakagePressureLoss(), ecc(0), pVfac(0), xdfac(0) {}
303  void setEccentricity(double ecc_) {ecc=ecc_; }
304  double operator()(const double& pVorQ);
305  void initializeUsingXML(xercesc::DOMElement *element);
306  private:
307  double ecc, pVfac, xdfac;
308  };
309 
310 
313  public:
314  RealCircularLeakagePressureLoss() : CircularLeakagePressureLoss(), pVfac(0), vIfac(0), vOfac(0) {}
315  double operator()(const double& pVorQ);
316  private:
317  double pVfac, vIfac, vOfac;
318  };
319 
320 
323  public:
325  };
326 
327 
330  public:
332  void setZeta(double zeta_) {c=zeta_; }
333  virtual double operator()(const double& Q);
334  void initializeUsingXML(xercesc::DOMElement *element);
335  private:
336  double c;
337  };
338 
339 
340 // // class PositiveFlowLimittingPressureLoss : public VariablePressureLoss {
341 // // public:
342 // // PositiveFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal) : VariablePressureLoss(name, checkSizeSignal) {}
343 // // bool isUnilateral() {return true; }
344 // // void update(const double& Q);
345 // // double operator()(const double& Q) {pLoss=0; return pLoss; }
346 // // protected:
347 // // double QLimit;
348 // // };
349 // //
350 // // class RegularizedPositiveFlowLimittingPressureLoss : public PositiveFlowLimittingPressureLoss {
351 // // public:
352 // // RegularizedPositiveFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal, double zeta1_,double offset_) : PositiveFlowLimittingPressureLoss(name, checkSizeSignal), zeta1(zeta1_), offset(offset_) {assert(offset>0); }
353 // // bool isUnilateral() {return false; }
354 // // double operator()(const double& Q);
355 // // private:
356 // // double zeta1, offset;
357 // // double zeta;
358 // // };
359 // //
360 // // class NegativeFlowLimittingPressureLoss : public VariablePressureLoss {
361 // // public:
362 // // NegativeFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal) : VariablePressureLoss(name, checkSizeSignal) {}
363 // // bool isUnilateral() {return true; }
364 // // void update(const double& Q);
365 // // double operator()(const double& Q) {pLoss=0; return pLoss; }
366 // // };
367 
368 }
369 
370 #endif /* ----- #ifndef _PRESSURE_LOSS_H_ ----- */
Definition: pressure_loss.h:322
Definition: pressure_loss.h:50
Definition: hline.h:41
Definition: pressure_loss.h:168
Definition: pressure_loss.h:201
Definition: pressure_loss.h:136
Definition: pressure_loss.h:39
Definition: pressure_loss.h:273
Definition: pressure_loss.h:188
Definition: pressure_loss.h:85
Definition: pressure_loss.h:282
Definition: pressure_loss.h:150
Definition: pressure_loss.h:293
Definition: pressure_loss.h:27
Definition: pressure_loss.h:97

Impressum / Disclaimer / Datenschutz Generated by doxygen 1.8.5 Valid HTML