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