mbsimhydraulics  4.0.0
pressure_loss.h
00001 /* Copyright (C) 2004-2009 MBSim Development Team
00002  *
00003  * This library is free software; you can redistribute it and/or 
00004  * modify it under the terms of the GNU Lesser General Public 
00005  * License as published by the Free Software Foundation; either 
00006  * version 2.1 of the License, or (at your option) any later version. 
00007  *  
00008  * This library is distributed in the hope that it will be useful, 
00009  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
00010  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
00011  * Lesser General Public License for more details. 
00012  *  
00013  * You should have received a copy of the GNU Lesser General Public 
00014  * License along with this library; if not, write to the Free Software 
00015  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
00016  *
00017  * Contact: markus.ms.schneider@gmail.com
00018  */
00019 
00020 #ifndef  _PRESSURE_LOSS_H_
00021 #define  _PRESSURE_LOSS_H_
00022 
00023 #include "mbsim/element.h"
00024 #include <fmatvec/function.h>
00025 
00026 namespace MBSim {
00027   template <class Sig> class TabularFunction;
00028 }
00029 
00030 namespace MBSimHydraulics {
00031 
00032   class HydlinePressureloss;
00033   class HLine;
00034 //  class RigidLine;
00035 //  class ClosableRigidLine;
00036 //  class PlaneLeakage0DOF;
00037 
00039   class PressureLoss : public fmatvec::Function<double(double)> {
00040     public:
00041       PressureLoss() : line(0), initialized(false) {}
00042       virtual void setLine(const HLine *line_) { line = line_; }
00043     protected:
00044       const HLine *line;
00045       bool initialized;
00046   };
00047 
00048 
00050   class LinePressureLoss : public PressureLoss {
00051     public:
00052       LinePressureLoss() : PressureLoss() {}
00053   };
00054 
00055 
00057   class SerialResistanceLinePressureLoss : public LinePressureLoss {
00058     public:
00059       SerialResistanceLinePressureLoss() : LinePressureLoss() {}
00060       ~SerialResistanceLinePressureLoss();
00061       void setLine(const HLine *line_) { line = line_; for(unsigned int i=0; i<slp.size(); i++) slp[i]->setLine(line); }
00062       void addLinePressureLoss(LinePressureLoss * l) { slp.push_back(l); }
00063       double operator()(const double& Q);
00064       void initializeUsingXML(xercesc::DOMElement * element);
00065     private:
00066       std::vector<LinePressureLoss*> slp;
00067   };
00068 
00069 
00071   class ParallelResistanceLinePressureLoss : public LinePressureLoss {
00072     public:
00073       ParallelResistanceLinePressureLoss() : LinePressureLoss(), pl(NULL), number(0) {}
00074       void setLine(const HLine *line_) { line = line_; pl->setLine(line); }
00075       void setLinePressureLoss(LinePressureLoss * pl_, int number_) {pl=pl_; number=double(number_); }
00076       double operator()(const double& Q);
00077       void initializeUsingXML(xercesc::DOMElement * element);
00078     private:
00079       LinePressureLoss* pl;
00080       double number;
00081   };
00082 
00083 
00085   class ZetaLinePressureLoss : public LinePressureLoss {
00086     public:
00087       ZetaLinePressureLoss() : LinePressureLoss(), c(0) {};
00088       void setZeta(double zeta_) {c=zeta_; }
00089       double operator()(const double& Q);
00090       void initializeUsingXML(xercesc::DOMElement *element);
00091     private:
00092       double c;
00093   };
00094 
00095 
00097   class ZetaPosNegLinePressureLoss : public LinePressureLoss {
00098     public:
00099       ZetaPosNegLinePressureLoss() : LinePressureLoss(), cPos(0), cNeg(0) {};
00100       void setZetaPos(double zeta_) {cPos=zeta_; }
00101       void setZetaNeg(double zeta_) {cNeg=zeta_; }
00102       double operator()(const double& Q);
00103       void initializeUsingXML(xercesc::DOMElement *element);
00104     private:
00105       double cPos, cNeg;
00106   };
00107 
00108 
00110   class LaminarTubeFlowLinePressureLoss : public LinePressureLoss {
00111     public:
00112       LaminarTubeFlowLinePressureLoss() : LinePressureLoss(), c(0) {}
00113       double operator()(const double& Q);
00114     private:
00115       double c;
00116   };
00117 
00118 
00120   class TurbulentTubeFlowLinePressureLoss : public LinePressureLoss {
00121     public:
00122       TurbulentTubeFlowLinePressureLoss() : LinePressureLoss(), c(0), dRef(0), dHyd(0), dHydNeg(0), k(0), ReynoldsFactor(0), ReynoldsFactorNeg(0), lambdaTabular(NULL) {}
00123       ~TurbulentTubeFlowLinePressureLoss();
00124       void setReferenceDiameter(double dRef_) {dRef=dRef_; }
00125       void setHydraulicDiameter(double dHyd_, double dHydNeg_=0);
00126       void setSurfaceRoughness(double k_) {k=k_; }
00127       double operator()(const double& Q);
00128       void initializeUsingXML(xercesc::DOMElement *element);
00129     private:
00130       double c, dRef, dHyd, dHydNeg, k, ReynoldsFactor, ReynoldsFactorNeg;
00131       MBSim::TabularFunction<double(double)> * lambdaTabular;
00132   };
00133 
00134 
00136   class CurveFittedLinePressureLoss : public LinePressureLoss {
00137     public:
00138       CurveFittedLinePressureLoss() : LinePressureLoss(), dRef(0), dHyd(0), aPos(0), bPos(0), aNeg(0), bNeg(0), ReynoldsFactor(0) {}
00139       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_; }
00140       double operator()(const double& Q);
00141       void initializeUsingXML(xercesc::DOMElement *element);
00142     private:
00143       double dRef, dHyd;
00144       double aPos, bPos, aNeg, bNeg;
00145       double ReynoldsFactor;
00146   };
00147 
00148 
00150   class TabularLinePressureLoss : public LinePressureLoss {
00151     public:
00152       TabularLinePressureLoss() : LinePressureLoss(), zetaTabular(NULL) {};
00153       ~TabularLinePressureLoss() { delete zetaTabular; }
00154       void setZetaTabular(fmatvec::Function<double(double)> * zetaTabular_) {zetaTabular=zetaTabular_; }
00155       double operator()(const double& Q);
00156       void initializeUsingXML(xercesc::DOMElement *element);
00157     private:
00158       fmatvec::Function<double(double)> * zetaTabular;
00159   };
00160 
00161 
00163   class ClosablePressureLoss : public PressureLoss {
00164     public:
00165       ClosablePressureLoss() : PressureLoss() {}
00166   };
00167 
00168 
00170   class RelativeAreaZetaClosablePressureLoss : public ClosablePressureLoss {
00171     public:
00172       RelativeAreaZetaClosablePressureLoss() : ClosablePressureLoss(), c(0), cNeg(-1.) {}
00173       void setZeta(double zeta_) {c=zeta_; }
00174       void setZetaNegative(double zeta_) {cNeg=zeta_; }
00175       virtual double operator()(const double& Q);
00176       void initializeUsingXML(xercesc::DOMElement *element);
00177     private:
00178       double c, cNeg;
00179   };
00180 
00181 
00183   class GapHeightClosablePressureLoss : public ClosablePressureLoss {
00184     public:
00185       GapHeightClosablePressureLoss() : ClosablePressureLoss(), c(0) {}
00186       void setLength(double l_) {l=l_; }
00187       void setWidth(double b_) {b=b_; }
00188       virtual double operator()(const double& Q);
00189       void initializeUsingXML(xercesc::DOMElement *element);
00190     private:
00191       double c, l, b;
00192   };
00193 
00194 
00196   class ReynoldsClosablePressureLoss : public ClosablePressureLoss {
00197     public:
00198       ReynoldsClosablePressureLoss() : ClosablePressureLoss(), nu(0), lambdaSlope(0), lambdaOffset(0), zetaFactor(0) {}
00199       virtual double operator()(const double& Q);
00200     private:
00201       double nu, lambdaSlope, lambdaOffset, zetaFactor;
00202   };
00203 
00204 
00206   class RelativeAlphaClosablePressureLoss : public ClosablePressureLoss {
00207     public:
00208       RelativeAlphaClosablePressureLoss() : ClosablePressureLoss(), alpha(0), alpha2(0), c(0) {}
00209       void setAlpha(double alpha_) {alpha=alpha_; assert(alpha>.01); assert(alpha<=1.); }
00210       virtual double operator()(const double& Q);
00211       void initializeUsingXML(xercesc::DOMElement *element);
00212     private:
00213       double alpha, alpha2, c;
00214   };
00215 
00216 
00218   class CheckvalveClosablePressureLoss : public ClosablePressureLoss {
00219     public:
00220       CheckvalveClosablePressureLoss() : ClosablePressureLoss(), rBall(0) {}
00221       void setBallRadius(double rBall_) {rBall=rBall_; }
00222       double getBallRadius() const {return rBall; }
00223       virtual double calcBallForceArea() {return -1.; }
00224       void initializeUsingXML(xercesc::DOMElement *element);
00225     protected:
00226       double rBall;
00227   };
00228 
00229 
00231   class GammaCheckvalveClosablePressureLoss : public CheckvalveClosablePressureLoss {
00232     public:
00233       GammaCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), alpha(0), gamma(0), c(0), siga(0), coga(0) {}
00234       void setAlpha(double alpha_) {alpha=alpha_; }
00235       void setGamma(double gamma_) {gamma=gamma_; }
00236       virtual double calcBallForceArea() {return M_PI*rBall*rBall*sin(gamma)*sin(gamma); }
00237       double operator()(const double& Q);
00238       void initializeUsingXML(xercesc::DOMElement *element);
00239     private:
00240       double alpha, gamma, c, siga, coga;
00241   };
00242 
00243 
00245   class IdelchickCheckvalveClosablePressureLoss : public CheckvalveClosablePressureLoss {
00246     public:
00247       IdelchickCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), d0(0), c(0) {}
00248       double operator()(const double& Q);
00249     private:
00250       double d0, c;
00251   };
00252 
00253 
00255   class ConeCheckvalveClosablePressureLoss : public CheckvalveClosablePressureLoss {
00256     public:
00257       ConeCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), alpha(0), c(0) {}
00258       void setAlpha(double alpha_) {alpha=alpha_; }
00259       double operator()(const double& Q);
00260       void initializeUsingXML(xercesc::DOMElement *element);
00261     private:
00262       double alpha;
00263       double numer[2], denom[2], c;
00264   };
00265   
00266   
00268   class LeakagePressureLoss : public PressureLoss {
00269     public:
00270       LeakagePressureLoss() : PressureLoss(), stateless(true) {}
00271     protected:
00272       bool stateless;
00273   };
00274 
00275 
00277   class PlaneLeakagePressureLoss : public LeakagePressureLoss {
00278     public:
00279       PlaneLeakagePressureLoss() : LeakagePressureLoss(), pVfac(0), xdfac(0) {}
00280       double operator()(const double& pVorQ);
00281     private:
00282       double pVfac, xdfac;
00283   };
00284 
00285   
00286 
00288   class CircularLeakagePressureLoss : public LeakagePressureLoss {
00289     public:
00290       CircularLeakagePressureLoss() : LeakagePressureLoss() {}
00291   };
00292 
00293 
00295   class EccentricCircularLeakagePressureLoss : public CircularLeakagePressureLoss {
00296     public:
00297       EccentricCircularLeakagePressureLoss() : CircularLeakagePressureLoss(), ecc(0), pVfac(0), xdfac(0) {}
00298       void setEccentricity(double ecc_) {ecc=ecc_; }
00299       double operator()(const double& pVorQ);
00300       void initializeUsingXML(xercesc::DOMElement *element);
00301     private:
00302       double ecc, pVfac, xdfac;
00303   };
00304 
00305 
00307   class RealCircularLeakagePressureLoss : public CircularLeakagePressureLoss {
00308     public:
00309       RealCircularLeakagePressureLoss() : CircularLeakagePressureLoss(), pVfac(0), vIfac(0), vOfac(0) {}
00310       double operator()(const double& pVorQ);
00311     private:
00312       double pVfac, vIfac, vOfac;
00313   };
00314 
00315 
00317   class UnidirectionalPressureLoss : public PressureLoss {
00318     public:
00319       UnidirectionalPressureLoss() : PressureLoss() {}
00320   };
00321 
00322 
00324   class UnidirectionalZetaPressureLoss : public UnidirectionalPressureLoss {
00325     public:
00326       UnidirectionalZetaPressureLoss() : UnidirectionalPressureLoss(), c(0) {}
00327       void setZeta(double zeta_) {c=zeta_; }
00328       virtual double operator()(const double& Q);
00329       void initializeUsingXML(xercesc::DOMElement *element);
00330     private:
00331       double c;
00332   };
00333 
00334 
00335 //  //  class PositiveFlowLimittingPressureLoss : public VariablePressureLoss {
00336 //  //    public:
00337 //  //      PositiveFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal) : VariablePressureLoss(name, checkSizeSignal) {}
00338 //  //      bool isUnilateral() {return true; }
00339 //  //      void update(const double& Q);
00340 //  //      double operator()(const double& Q) {pLoss=0; return pLoss; }
00341 //  //    protected:
00342 //  //      double QLimit;
00343 //  //  };
00344 //  //
00345 //  //  class RegularizedPositiveFlowLimittingPressureLoss : public PositiveFlowLimittingPressureLoss {
00346 //  //    public:
00347 //  //      RegularizedPositiveFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal, double zeta1_,double offset_) : PositiveFlowLimittingPressureLoss(name, checkSizeSignal), zeta1(zeta1_), offset(offset_) {assert(offset>0); }
00348 //  //      bool isUnilateral() {return false; }
00349 //  //      double operator()(const double& Q);
00350 //  //    private:
00351 //  //      double zeta1, offset;
00352 //  //      double zeta;
00353 //  //  };
00354 //  //
00355 //  //  class NegativeFlowLimittingPressureLoss : public VariablePressureLoss {
00356 //  //    public:
00357 //  //      NegativeFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal) : VariablePressureLoss(name, checkSizeSignal) {}
00358 //  //      bool isUnilateral() {return true; }
00359 //  //      void update(const double& Q);
00360 //  //      double operator()(const double& Q) {pLoss=0; return pLoss; }
00361 //  //  };
00362 
00363 }
00364 
00365 #endif   /* ----- #ifndef _PRESSURE_LOSS_H_  ----- */