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