|
mbsimhydraulics
3.2.0
|
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_ ----- */
1.8.0