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 <mbsim/functions/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 MBSim::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(MBSim::Function<double(double)> * zetaTabular_) {
00155         zetaTabular=zetaTabular_;
00156         zetaTabular->setParent(this);
00157         zetaTabular->setName("Zeta");
00158       }
00159       double operator()(const double& Q);
00160       void initializeUsingXML(xercesc::DOMElement *element);
00161       void init(MBSim::Element::InitStage stage);
00162     private:
00163       MBSim::Function<double(double)> * zetaTabular;
00164   };
00165 
00166 
00168   class ClosablePressureLoss : public PressureLoss {
00169     public:
00170       ClosablePressureLoss() : PressureLoss() {}
00171   };
00172 
00173 
00175   class RelativeAreaZetaClosablePressureLoss : public ClosablePressureLoss {
00176     public:
00177       RelativeAreaZetaClosablePressureLoss() : ClosablePressureLoss(), c(0), cNeg(-1.) {}
00178       void setZeta(double zeta_) {c=zeta_; }
00179       void setZetaNegative(double zeta_) {cNeg=zeta_; }
00180       virtual double operator()(const double& Q);
00181       void initializeUsingXML(xercesc::DOMElement *element);
00182     private:
00183       double c, cNeg;
00184   };
00185 
00186 
00188   class GapHeightClosablePressureLoss : public ClosablePressureLoss {
00189     public:
00190       GapHeightClosablePressureLoss() : ClosablePressureLoss(), c(0) {}
00191       void setLength(double l_) {l=l_; }
00192       void setWidth(double b_) {b=b_; }
00193       virtual double operator()(const double& Q);
00194       void initializeUsingXML(xercesc::DOMElement *element);
00195     private:
00196       double c, l, b;
00197   };
00198 
00199 
00201   class ReynoldsClosablePressureLoss : public ClosablePressureLoss {
00202     public:
00203       ReynoldsClosablePressureLoss() : ClosablePressureLoss(), nu(0), lambdaSlope(0), lambdaOffset(0), zetaFactor(0) {}
00204       virtual double operator()(const double& Q);
00205     private:
00206       double nu, lambdaSlope, lambdaOffset, zetaFactor;
00207   };
00208 
00209 
00211   class RelativeAlphaClosablePressureLoss : public ClosablePressureLoss {
00212     public:
00213       RelativeAlphaClosablePressureLoss() : ClosablePressureLoss(), alpha(0), alpha2(0), c(0) {}
00214       void setAlpha(double alpha_) {alpha=alpha_; assert(alpha>.01); assert(alpha<=1.); }
00215       virtual double operator()(const double& Q);
00216       void initializeUsingXML(xercesc::DOMElement *element);
00217     private:
00218       double alpha, alpha2, c;
00219   };
00220 
00221 
00223   class CheckvalveClosablePressureLoss : public ClosablePressureLoss {
00224     public:
00225       CheckvalveClosablePressureLoss() : ClosablePressureLoss(), rBall(0) {}
00226       void setBallRadius(double rBall_) {rBall=rBall_; }
00227       double getBallRadius() const {return rBall; }
00228       virtual double calcBallForceArea() {return -1.; }
00229       void initializeUsingXML(xercesc::DOMElement *element);
00230     protected:
00231       double rBall;
00232   };
00233 
00234 
00236   class GammaCheckvalveClosablePressureLoss : public CheckvalveClosablePressureLoss {
00237     public:
00238       GammaCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), alpha(0), gamma(0), c(0), siga(0), coga(0) {}
00239       void setAlpha(double alpha_) {alpha=alpha_; }
00240       void setGamma(double gamma_) {gamma=gamma_; }
00241       virtual double calcBallForceArea() {return M_PI*rBall*rBall*sin(gamma)*sin(gamma); }
00242       double operator()(const double& Q);
00243       void initializeUsingXML(xercesc::DOMElement *element);
00244     private:
00245       double alpha, gamma, c, siga, coga;
00246   };
00247 
00248 
00250   class IdelchickCheckvalveClosablePressureLoss : public CheckvalveClosablePressureLoss {
00251     public:
00252       IdelchickCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), d0(0), c(0) {}
00253       double operator()(const double& Q);
00254     private:
00255       double d0, c;
00256   };
00257 
00258 
00260   class ConeCheckvalveClosablePressureLoss : public CheckvalveClosablePressureLoss {
00261     public:
00262       ConeCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), alpha(0), c(0) {}
00263       void setAlpha(double alpha_) {alpha=alpha_; }
00264       double operator()(const double& Q);
00265       void initializeUsingXML(xercesc::DOMElement *element);
00266     private:
00267       double alpha;
00268       double numer[2], denom[2], c;
00269   };
00270   
00271   
00273   class LeakagePressureLoss : public PressureLoss {
00274     public:
00275       LeakagePressureLoss() : PressureLoss(), stateless(true) {}
00276     protected:
00277       bool stateless;
00278   };
00279 
00280 
00282   class PlaneLeakagePressureLoss : public LeakagePressureLoss {
00283     public:
00284       PlaneLeakagePressureLoss() : LeakagePressureLoss(), pVfac(0), xdfac(0) {}
00285       double operator()(const double& pVorQ);
00286     private:
00287       double pVfac, xdfac;
00288   };
00289 
00290   
00291 
00293   class CircularLeakagePressureLoss : public LeakagePressureLoss {
00294     public:
00295       CircularLeakagePressureLoss() : LeakagePressureLoss() {}
00296   };
00297 
00298 
00300   class EccentricCircularLeakagePressureLoss : public CircularLeakagePressureLoss {
00301     public:
00302       EccentricCircularLeakagePressureLoss() : CircularLeakagePressureLoss(), ecc(0), pVfac(0), xdfac(0) {}
00303       void setEccentricity(double ecc_) {ecc=ecc_; }
00304       double operator()(const double& pVorQ);
00305       void initializeUsingXML(xercesc::DOMElement *element);
00306     private:
00307       double ecc, pVfac, xdfac;
00308   };
00309 
00310 
00312   class RealCircularLeakagePressureLoss : public CircularLeakagePressureLoss {
00313     public:
00314       RealCircularLeakagePressureLoss() : CircularLeakagePressureLoss(), pVfac(0), vIfac(0), vOfac(0) {}
00315       double operator()(const double& pVorQ);
00316     private:
00317       double pVfac, vIfac, vOfac;
00318   };
00319 
00320 
00322   class UnidirectionalPressureLoss : public PressureLoss {
00323     public:
00324       UnidirectionalPressureLoss() : PressureLoss() {}
00325   };
00326 
00327 
00329   class UnidirectionalZetaPressureLoss : public UnidirectionalPressureLoss {
00330     public:
00331       UnidirectionalZetaPressureLoss() : UnidirectionalPressureLoss(), c(0) {}
00332       void setZeta(double zeta_) {c=zeta_; }
00333       virtual double operator()(const double& Q);
00334       void initializeUsingXML(xercesc::DOMElement *element);
00335     private:
00336       double c;
00337   };
00338 
00339 
00340 //  //  class PositiveFlowLimittingPressureLoss : public VariablePressureLoss {
00341 //  //    public:
00342 //  //      PositiveFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal) : VariablePressureLoss(name, checkSizeSignal) {}
00343 //  //      bool isUnilateral() {return true; }
00344 //  //      void update(const double& Q);
00345 //  //      double operator()(const double& Q) {pLoss=0; return pLoss; }
00346 //  //    protected:
00347 //  //      double QLimit;
00348 //  //  };
00349 //  //
00350 //  //  class RegularizedPositiveFlowLimittingPressureLoss : public PositiveFlowLimittingPressureLoss {
00351 //  //    public:
00352 //  //      RegularizedPositiveFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal, double zeta1_,double offset_) : PositiveFlowLimittingPressureLoss(name, checkSizeSignal), zeta1(zeta1_), offset(offset_) {assert(offset>0); }
00353 //  //      bool isUnilateral() {return false; }
00354 //  //      double operator()(const double& Q);
00355 //  //    private:
00356 //  //      double zeta1, offset;
00357 //  //      double zeta;
00358 //  //  };
00359 //  //
00360 //  //  class NegativeFlowLimittingPressureLoss : public VariablePressureLoss {
00361 //  //    public:
00362 //  //      NegativeFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal) : VariablePressureLoss(name, checkSizeSignal) {}
00363 //  //      bool isUnilateral() {return true; }
00364 //  //      void update(const double& Q);
00365 //  //      double operator()(const double& Q) {pLoss=0; return pLoss; }
00366 //  //  };
00367 
00368 }
00369 
00370 #endif   /* ----- #ifndef _PRESSURE_LOSS_H_  ----- */