mbsimhydraulics  3.2.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/utils/function.h"
00025 
00026 namespace MBSim {
00027   template <class Row, class Col> class TabularFunction1_VS;
00028   class Function1_SS;
00029 }
00030 
00031 namespace MBSimHydraulics {
00032 
00033   class HydlinePressureloss;
00034 
00036   class PressureLoss : public MBSim::Function1<double,double> {
00037     public:
00038       PressureLoss() : initialized(false) {}
00039     protected:
00040       bool initialized;
00041   };
00042 
00043 
00045   class LinePressureLoss : public PressureLoss {
00046     public:
00047       LinePressureLoss() : PressureLoss() {}
00048   };
00049 
00050 
00052   class SerialResistanceLinePressureLoss : public LinePressureLoss {
00053     public:
00054       SerialResistanceLinePressureLoss() : LinePressureLoss() {}
00055       void addLinePressureLoss(LinePressureLoss * l) {slp.push_back(l); }
00056       double operator()(const double& Q, const void * line);
00057       void initializeUsingXML(MBXMLUtils::TiXmlElement * element);
00058     private:
00059       std::vector<LinePressureLoss*> slp;
00060   };
00061 
00062 
00064   class ParallelResistanceLinePressureLoss : public LinePressureLoss {
00065     public:
00066       ParallelResistanceLinePressureLoss() : LinePressureLoss(), pl(NULL), number(0) {}
00067       void setLinePressureLoss(LinePressureLoss * pl_, int number_) {pl=pl_; number=double(number_); }
00068       double operator()(const double& Q, const void * line);
00069       void initializeUsingXML(MBXMLUtils::TiXmlElement * element);
00070     private:
00071       LinePressureLoss* pl;
00072       double number;
00073   };
00074 
00075 
00077   class ZetaLinePressureLoss : public LinePressureLoss {
00078     public:
00079       ZetaLinePressureLoss() : LinePressureLoss(), c(0) {};
00080       void setZeta(double zeta_) {c=zeta_; }
00081       double operator()(const double& Q, const void * line);
00082       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00083     private:
00084       double c;
00085   };
00086 
00087 
00089   class ZetaPosNegLinePressureLoss : public LinePressureLoss {
00090     public:
00091       ZetaPosNegLinePressureLoss() : LinePressureLoss(), cPos(0), cNeg(0) {};
00092       void setZetaPos(double zeta_) {cPos=zeta_; }
00093       void setZetaNeg(double zeta_) {cNeg=zeta_; }
00094       double operator()(const double& Q, const void * line);
00095       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00096     private:
00097       double cPos, cNeg;
00098   };
00099 
00100 
00102   class LaminarTubeFlowLinePressureLoss : public LinePressureLoss {
00103     public:
00104       LaminarTubeFlowLinePressureLoss() : LinePressureLoss(), c(0) {}
00105       double operator()(const double& Q, const void * line);
00106     private:
00107       double c;
00108   };
00109 
00110 
00112   class TurbulentTubeFlowLinePressureLoss : public LinePressureLoss {
00113     public:
00114       TurbulentTubeFlowLinePressureLoss() : LinePressureLoss(), c(0), dRef(0), dHyd(0), dHydNeg(0), k(0), ReynoldsFactor(0), ReynoldsFactorNeg(0), lambdaTabular(NULL) {}
00115       void setReferenceDiameter(double dRef_) {dRef=dRef_; }
00116       void setHydraulicDiameter(double dHyd_, double dHydNeg_=0);
00117       void setSurfaceRoughness(double k_) {k=k_; }
00118       double operator()(const double& Q, const void * line);
00119       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00120     private:
00121       double c, dRef, dHyd, dHydNeg, k, ReynoldsFactor, ReynoldsFactorNeg;
00122       MBSim::TabularFunction1_VS<fmatvec::Ref,fmatvec::Ref> * lambdaTabular;
00123   };
00124 
00125 
00127   class CurveFittedLinePressureLoss : public LinePressureLoss {
00128     public:
00129       CurveFittedLinePressureLoss() : LinePressureLoss(), dRef(0), dHyd(0), aPos(0), bPos(0), aNeg(0), bNeg(0), ReynoldsFactor(0) {}
00130       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_; }
00131       double operator()(const double& Q, const void * line);
00132       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00133     private:
00134       double dRef, dHyd;
00135       double aPos, bPos, aNeg, bNeg;
00136       double ReynoldsFactor;
00137   };
00138 
00139 
00141   class TabularLinePressureLoss : public LinePressureLoss {
00142     public:
00143       TabularLinePressureLoss() : LinePressureLoss(), zetaTabular(NULL) {};
00144       void setZetaTabular(MBSim::Function1<double, double> * zetaTabular_) {zetaTabular=zetaTabular_; }
00145       double operator()(const double& Q, const void * line);
00146       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00147     private:
00148       MBSim::Function1<double, double> * zetaTabular;
00149   };
00150 
00151 
00153   class ClosablePressureLoss : public PressureLoss {
00154     public:
00155       ClosablePressureLoss() : PressureLoss() {}
00156   };
00157 
00158 
00160   class RelativeAreaZetaClosablePressureLoss : public ClosablePressureLoss {
00161     public:
00162       RelativeAreaZetaClosablePressureLoss() : ClosablePressureLoss(), c(0), cNeg(-1.) {}
00163       void setZeta(double zeta_) {c=zeta_; }
00164       void setZetaNegative(double zeta_) {cNeg=zeta_; }
00165       virtual double operator()(const double& Q, const void * line);
00166       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00167     private:
00168       double c, cNeg;
00169   };
00170 
00171 
00173   class GapHeightClosablePressureLoss : public ClosablePressureLoss {
00174     public:
00175       GapHeightClosablePressureLoss() : ClosablePressureLoss(), c(0) {}
00176       void setLength(double l_) {l=l_; }
00177       void setWidth(double b_) {b=b_; }
00178       virtual double operator()(const double& Q, const void * line);
00179       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00180     private:
00181       double c, l, b;
00182   };
00183 
00184 
00186   class ReynoldsClosablePressureLoss : public ClosablePressureLoss {
00187     public:
00188       ReynoldsClosablePressureLoss() : ClosablePressureLoss(), nu(0), lambdaSlope(0), lambdaOffset(0), zetaFactor(0) {}
00189       virtual double operator()(const double& Q, const void * line);
00190     private:
00191       double nu, lambdaSlope, lambdaOffset, zetaFactor;
00192   };
00193 
00194 
00196   class RelativeAlphaClosablePressureLoss : public ClosablePressureLoss {
00197     public:
00198       RelativeAlphaClosablePressureLoss() : ClosablePressureLoss(), alpha(0), alpha2(0), c(0) {}
00199       void setAlpha(double alpha_) {alpha=alpha_; assert(alpha>.01); assert(alpha<=1.); }
00200       virtual double operator()(const double& Q, const void * line);
00201       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00202     private:
00203       double alpha, alpha2, c;
00204   };
00205 
00206 
00208   class CheckvalveClosablePressureLoss : public ClosablePressureLoss {
00209     public:
00210       CheckvalveClosablePressureLoss() : ClosablePressureLoss(), rBall(0) {}
00211       void setBallRadius(double rBall_) {rBall=rBall_; }
00212       double getBallRadius() const {return rBall; }
00213       virtual double calcBallForceArea() {return -1.; }
00214       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00215     protected:
00216       double rBall;
00217   };
00218 
00219 
00221   class GammaCheckvalveClosablePressureLoss : public CheckvalveClosablePressureLoss {
00222     public:
00223       GammaCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), alpha(0), gamma(0), c(0), siga(0), coga(0) {}
00224       void setAlpha(double alpha_) {alpha=alpha_; }
00225       void setGamma(double gamma_) {gamma=gamma_; }
00226       virtual double calcBallForceArea() {return M_PI*rBall*rBall*sin(gamma)*sin(gamma); }
00227       double operator()(const double& Q, const void * =NULL);
00228       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00229     private:
00230       double alpha, gamma, c, siga, coga;
00231   };
00232 
00233 
00235   class IdelchickCheckvalveClosablePressureLoss : public CheckvalveClosablePressureLoss {
00236     public:
00237       IdelchickCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), d0(0), c(0) {}
00238       double operator()(const double& Q, const void * line);
00239     private:
00240       double d0, c;
00241   };
00242 
00243 
00245   class ConeCheckvalveClosablePressureLoss : public CheckvalveClosablePressureLoss {
00246     public:
00247       ConeCheckvalveClosablePressureLoss() : CheckvalveClosablePressureLoss(), alpha(0), c(0) {}
00248       void setAlpha(double alpha_) {alpha=alpha_; }
00249       double operator()(const double& Q, const void * line);
00250       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00251     private:
00252       double alpha;
00253       double numer[2], denom[2], c;
00254   };
00255   
00256   
00258   class LeakagePressureLoss : public PressureLoss {
00259     public:
00260       LeakagePressureLoss() : PressureLoss(), stateless(true) {}
00261     protected:
00262       bool stateless;
00263   };
00264 
00265 
00267   class PlaneLeakagePressureLoss : public LeakagePressureLoss {
00268     public:
00269       PlaneLeakagePressureLoss() : LeakagePressureLoss(), pVfac(0), xdfac(0) {}
00270       double operator()(const double& pVorQ, const void * line);
00271     private:
00272       double pVfac, xdfac;
00273   };
00274   
00275 
00277   class CircularLeakagePressureLoss : public LeakagePressureLoss {
00278     public:
00279       CircularLeakagePressureLoss() : LeakagePressureLoss() {}
00280   };
00281 
00282 
00284   class EccentricCircularLeakagePressureLoss : public CircularLeakagePressureLoss {
00285     public:
00286       EccentricCircularLeakagePressureLoss() : CircularLeakagePressureLoss (), ecc(0), pVfac(0), xdfac(0) {}
00287       void setEccentricity(double ecc_) {ecc=ecc_; }
00288       double operator()(const double& pVorQ, const void * line);
00289       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00290     private:
00291       double ecc, pVfac, xdfac;
00292   };
00293 
00294 
00296   class RealCircularLeakagePressureLoss : public CircularLeakagePressureLoss {
00297     public:
00298       RealCircularLeakagePressureLoss() : CircularLeakagePressureLoss(), pVfac(0), vIfac(0), vOfac(0) {}
00299       double operator()(const double& pVorQ, const void * line);
00300     private:
00301       double pVfac, vIfac, vOfac;
00302   };
00303 
00304 
00306   class UnidirectionalPressureLoss : public PressureLoss {
00307     public:
00308       UnidirectionalPressureLoss() : PressureLoss() {}
00309   };
00310 
00311 
00313   class UnidirectionalZetaPressureLoss : public UnidirectionalPressureLoss {
00314     public:
00315       UnidirectionalZetaPressureLoss() : UnidirectionalPressureLoss(), c(0) {}
00316       void setZeta(double zeta_) {c=zeta_; }
00317       virtual double operator()(const double& Q, const void * line);
00318       void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00319     private:
00320       double c;
00321   };
00322 
00323 
00324 //  //  class PositiveFlowLimittingPressureLoss : public VariablePressureLoss {
00325 //  //    public:
00326 //  //      PositiveFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal) : VariablePressureLoss(name, checkSizeSignal) {}
00327 //  //      bool isUnilateral() {return true; }
00328 //  //      void update(const double& Q);
00329 //  //      double operator()(const double& Q) {pLoss=0; return pLoss; }
00330 //  //    protected:
00331 //  //      double QLimit;
00332 //  //  };
00333 //  //
00334 //  //  class RegularizedPositiveFlowLimittingPressureLoss : public PositiveFlowLimittingPressureLoss {
00335 //  //    public:
00336 //  //      RegularizedPositiveFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal, double zeta1_,double offset_) : PositiveFlowLimittingPressureLoss(name, checkSizeSignal), zeta1(zeta1_), offset(offset_) {assert(offset>0); }
00337 //  //      bool isUnilateral() {return false; }
00338 //  //      double operator()(const double& Q);
00339 //  //    private:
00340 //  //      double zeta1, offset;
00341 //  //      double zeta;
00342 //  //  };
00343 //  //
00344 //  //  class NegativeFlowLimittingPressureLoss : public VariablePressureLoss {
00345 //  //    public:
00346 //  //      NegativeFlowLimittingPressureLoss(const std::string &name, Signal * checkSizeSignal) : VariablePressureLoss(name, checkSizeSignal) {}
00347 //  //      bool isUnilateral() {return true; }
00348 //  //      void update(const double& Q);
00349 //  //      double operator()(const double& Q) {pLoss=0; return pLoss; }
00350 //  //  };
00351 
00352 }
00353 
00354 #endif   /* ----- #ifndef _PRESSURE_LOSS_H_  ----- */