Dynamic_pipe Class Reference

#include <pipe.h>

Inheritance diagram for Dynamic_pipe:

Collaboration diagram for Dynamic_pipe:

Public Member Functions
	Dynamic_pipe (unsigned int uL, const DofOwner *pD, HydraulicFluid *hf, const PressureNode *p1, const PressureNode *p2, doublereal Dh, doublereal A, doublereal L, flag transition, doublereal q0, flag fOut)
	~Dynamic_pipe (void)
virtual HydraulicElem::Type	GetHydraulicType (void) const
virtual std::ostream &	Restart (std::ostream &out) const
virtual unsigned int	iGetNumDof (void) const
virtual DofOrder::Order	GetDofType (unsigned int i) const
virtual void	WorkSpaceDim (integer *piNumRows, integer *piNumCols) const
VariableSubMatrixHandler &	AssJac (VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
SubVectorHandler &	AssRes (SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP)
virtual void	Output (OutputHandler &OH) const
virtual void	SetValue (DataManager *pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints *ph=0)
virtual void	GetConnectedNodes (std::vector< const Node * > &connectedNodes) const
Public Member Functions inherited from Elem
	Elem (unsigned int uL, flag fOut)
virtual	~Elem (void)
virtual std::ostream &	DescribeDof (std::ostream &out, const char *prefix="", bool bInitial=false) const
virtual void	DescribeDof (std::vector< std::string > &desc, bool bInitial=false, int i=-1) const
virtual std::ostream &	DescribeEq (std::ostream &out, const char *prefix="", bool bInitial=false) const
virtual void	DescribeEq (std::vector< std::string > &desc, bool bInitial=false, int i=-1) const
virtual void	AssMats (VariableSubMatrixHandler &WorkMatA, VariableSubMatrixHandler &WorkMatB, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
virtual bool	bInverseDynamics (void) const
void	SetInverseDynamicsFlags (unsigned uIDF)
unsigned	GetInverseDynamicsFlags (void) const
bool	bIsErgonomy (void) const
bool	bIsRightHandSide (void) const
virtual VariableSubMatrixHandler &	AssJac (VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
virtual SubVectorHandler &	AssRes (SubVectorHandler &WorkVec, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr, const VectorHandler &XPrimePrimeCurr, InverseDynamics::Order iOrder=InverseDynamics::INVERSE_DYNAMICS)
virtual int	GetNumConnectedNodes (void) const
Public Member Functions inherited from WithLabel
	WithLabel (unsigned int uL=0, const std::string &sN="")
virtual	~WithLabel (void)
void	PutLabel (unsigned int uL)
void	PutName (const std::string &sN)
unsigned int	GetLabel (void) const
const std::string &	GetName (void) const
Public Member Functions inherited from SimulationEntity
	SimulationEntity (void)
virtual	~SimulationEntity (void)
virtual bool	bIsValidIndex (unsigned int i) const
virtual DofOrder::Order	GetEqType (unsigned int i) const
virtual Hint *	ParseHint (DataManager *pDM, const char *s) const
virtual void	BeforePredict (VectorHandler &, VectorHandler &, VectorHandler &, VectorHandler &) const
virtual void	AfterPredict (VectorHandler &X, VectorHandler &XP)
virtual void	Update (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
virtual void	DerivativesUpdate (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
virtual void	Update (const VectorHandler &XCurr, InverseDynamics::Order iOrder)
virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP, const VectorHandler &XPP)
virtual unsigned int	iGetNumPrivData (void) const
virtual unsigned int	iGetPrivDataIdx (const char *s) const
virtual doublereal	dGetPrivData (unsigned int i) const
virtual std::ostream &	OutputAppend (std::ostream &out) const
virtual void	ReadInitialState (MBDynParser &HP)
Public Member Functions inherited from ToBeOutput
	ToBeOutput (flag fOut=fDefaultOut)
virtual	~ToBeOutput (void)
virtual void	OutputPrepare (OutputHandler &OH)
virtual void	Output (OutputHandler &OH, const VectorHandler &X, const VectorHandler &XP) const
virtual flag	fToBeOutput (void) const
virtual bool	bToBeOutput (void) const
virtual void	SetOutputFlag (flag f=flag(1))
Public Member Functions inherited from HydraulicElem
	HydraulicElem (unsigned int uL, const DofOwner *pDO, HydraulicFluid *hf, flag fOut)
virtual	~HydraulicElem (void)
virtual Elem::Type	GetElemType (void) const
Public Member Functions inherited from ElemWithDofs
	ElemWithDofs (unsigned int uL, const DofOwner *pDO, flag fOut)
virtual	~ElemWithDofs (void)
Public Member Functions inherited from DofOwnerOwner
	DofOwnerOwner (const DofOwner *pDO)
virtual	~DofOwnerOwner ()
virtual const DofOwner *	pGetDofOwner (void) const
virtual integer	iGetFirstIndex (void) const
virtual void	SetInitialValue (VectorHandler &X)

Private Attributes
const PressureNode *	pNode1
const PressureNode *	pNode2
doublereal	diameter
doublereal	area
doublereal	length
flag	turbulent
doublereal	q0
doublereal	flow1
doublereal	flow2
doublereal	Re
doublereal	ktrb
doublereal	klam
doublereal	ktra
doublereal	densitySt
doublereal	densityMe
doublereal	densityEn
doublereal	densityDPres
doublereal	viscosity
doublereal	VelS
doublereal	VelM
doublereal	VelE
doublereal	fa
doublereal	pp

Additional Inherited Members
Public Types inherited from Elem
enum	Type {   UNKNOWN = -1, AIRPROPERTIES = 0, INDUCEDVELOCITY, AUTOMATICSTRUCTURAL,   GRAVITY, BODY, JOINT, JOINT_REGULARIZATION,   BEAM, PLATE, FORCE, INERTIA,   ELECTRICBULK, ELECTRIC, THERMAL, HYDRAULIC,   BULK, LOADABLE, DRIVEN, EXTERNAL,   AEROMODAL, AERODYNAMIC, GENEL, SOCKETSTREAM_OUTPUT,   RTAI_OUTPUT = SOCKETSTREAM_OUTPUT, LASTELEMTYPE }
Public Types inherited from SimulationEntity
typedef std::vector< Hint * >	Hints
Public Types inherited from ToBeOutput
enum	{ OUTPUT = 0x1U, OUTPUT_MASK = 0xFU, OUTPUT_PRIVATE = 0x10U, OUTPUT_PRIVATE_MASK = ~OUTPUT_MASK }
Public Types inherited from HydraulicElem
enum	Type {   UNKNOWN = -1, MINOR_LOSS = 0, THREEWAYMINORLOSS, CONTROL_VALVE,   DYNAMIC_CONTROL_VALVE, PRESSURE_FLOW_CONTROL_VALVE, PRESSURE_VALVE, FLOW_VALVE,   ORIFICE, ACCUMULATOR, TANK, PIPE,   DYNAMIC_PIPE, HYDRAULIC_ACTUATOR, ACTUATOR, LASTHYDRAULICTYPE }
Protected Attributes inherited from WithLabel
unsigned int	uLabel
std::string	sName
Protected Attributes inherited from ToBeOutput
flag	fOutput
Protected Attributes inherited from HydraulicElem
HydraulicFluid *	HF

Detailed Description

Definition at line 117 of file pipe.h.

Constructor & Destructor Documentation

Dynamic_pipe::Dynamic_pipe	(	unsigned int	uL,
		const DofOwner *	pD,
		HydraulicFluid *	hf,
		const PressureNode *	p1,
		const PressureNode *	p2,
		doublereal	Dh,
		doublereal	A,
		doublereal	L,
		flag	transition,
		doublereal	q0,
		flag	fOut
	)

Definition at line 469 of file pipe.cc.

References area, ASSERT, HydraulicFluid::dGetDensity(), HydraulicFluid::dGetViscosity(), ScalarAlgebraicNode::dGetX(), diameter, PressureNode::GetNodeType(), HydraulicElem::HF, Node::HYDRAULIC, klam, ktra, ktrb, length, pNode1, pNode2, grad::pow(), and viscosity.

: Elem(uL, fOut), 
HydraulicElem(uL, pDO, hf, fOut),
pNode1(p1), pNode2(p2),
diameter(Dh), area(A),
length(L), turbulent(transition), q0(q0)
{
   ASSERT(pNode1 != NULL);
   ASSERT(pNode1->GetNodeType() == Node::HYDRAULIC);
   ASSERT(pNode2 != NULL);
   ASSERT(pNode2->GetNodeType() == Node::HYDRAULIC);
   ASSERT(Dh > std::numeric_limits<doublereal>::epsilon());
   ASSERT(A > std::numeric_limits<doublereal>::epsilon());
   ASSERT(L > std::numeric_limits<doublereal>::epsilon());
   
   doublereal viscosity = HF->dGetViscosity();
   doublereal density = HF->dGetDensity((pNode1->dGetX()+pNode2->dGetX())/2.);
   
   klam = 8.*length*viscosity/(diameter*diameter);
   ktra = .5/(density*area*diameter);
   ktrb = .5*length*.1582*pow(viscosity, .25)/(pow(diameter, 1.25)*pow(area, .75));
}

Here is the call graph for this function:

Dynamic_pipe::~Dynamic_pipe

(

void

)

Definition at line 496 of file pipe.cc.

References NO_OP.

{
   NO_OP;
}

Member Function Documentation

void Dynamic_pipe::AfterConvergence ( const VectorHandler &  X, const VectorHandler &  XP  )

virtual

Reimplemented from SimulationEntity.

Definition at line 954 of file pipe.cc.

References DEBUGCOUT, HydraulicFluid::dGetRe(), WithLabel::GetLabel(), HydraulicElem::HF, HydraulicFluid::LOWER, Re, turbulent, and HydraulicFluid::UPPER.

{
   if (Re < HF->dGetRe(HydraulicFluid::LOWER)) {
      turbulent = 0;
   } else if (Re > HF->dGetRe(HydraulicFluid::UPPER)) {
      turbulent = 1;
   }
   
#ifdef HYDR_DEVEL
   DEBUGCOUT("Dynamic_Pipe(" << GetLabel() << "): turbulent mode =  " 
                   << turbulent << std::endl);
#endif /* HYDR_DEVEL */
}

Here is the call graph for this function:

VariableSubMatrixHandler & Dynamic_pipe::AssJac ( VariableSubMatrixHandler &  WorkMat, doublereal  dCoef, const VectorHandler &  XCurr, const VectorHandler &  XPrimeCurr  )

virtual

Implements Elem.

Definition at line 532 of file pipe.cc.

References a, area, c, DEBUGCOUT, densityDPres, HydraulicFluid::dGetDensity(), HydraulicFluid::dGetDensityDPres(), HydraulicFluid::dGetRe(), ScalarAlgebraicNode::dGetX(), diameter, fa, grad::fabs(), HydraulicElem::HF, Node::iGetFirstColIndex(), DofOwnerOwner::iGetFirstIndex(), Node::iGetFirstRowIndex(), klam, length, HydraulicFluid::LOWER, pNode1, pNode2, grad::pow(), FullSubMatrixHandler::PutCoef(), FullSubMatrixHandler::PutColIndex(), FullSubMatrixHandler::PutRowIndex(), Re, FullSubMatrixHandler::ResizeReset(), VariableSubMatrixHandler::SetFull(), turbulent, HydraulicFluid::UPPER, and viscosity.

{
   DEBUGCOUT("Entering Pipe::AssJac()" << std::endl);
   DEBUGCOUT("Valore di dblepsilon INIZIO:"  << std::numeric_limits<doublereal>::epsilon() << std::endl); 
   FullSubMatrixHandler& WM = WorkMat.SetFull();
   WM.ResizeReset(5, 5);
  
   integer iNode1RowIndex = pNode1->iGetFirstRowIndex()+1;
   integer iNode2RowIndex = pNode2->iGetFirstRowIndex()+1;
   integer iNode1ColIndex = pNode1->iGetFirstColIndex()+1;
   integer iNode2ColIndex = pNode2->iGetFirstColIndex()+1;
   integer iFirstIndex = iGetFirstIndex();
  
   WM.PutRowIndex(1, iNode1RowIndex);
   WM.PutRowIndex(2, iNode2RowIndex);
   WM.PutColIndex(1, iNode1ColIndex);
   WM.PutColIndex(2, iNode2ColIndex);
   WM.PutRowIndex(3, iFirstIndex+1);
   WM.PutColIndex(3, iFirstIndex+1);
   WM.PutRowIndex(4, iFirstIndex+2);
   WM.PutColIndex(4, iFirstIndex+2);
   WM.PutRowIndex(5, iFirstIndex+3);
   WM.PutColIndex(5, iFirstIndex+3);
   
   doublereal p1 = pNode1->dGetX();
   doublereal p2 = pNode2->dGetX();
   
   doublereal q1 = XCurr(iFirstIndex+2);        /* portata nodo 1 */
   doublereal q2 = XCurr(iFirstIndex+3);        /* portata nodo 2 */
   
   doublereal densityDPres = HF->dGetDensityDPres();
   doublereal densityS = HF->dGetDensity(p1);            /* densita' all'inizio del tubo */
   doublereal densityE = HF->dGetDensity(p2);            /* densita' alla fine del nodo */
   doublereal kappa1 = length*area*densityDPres;

   doublereal Jac14 = dCoef;
   doublereal Jac25 = dCoef;
   doublereal Jac31 = -.5;
   doublereal Jac32 = -.5;
   doublereal Jac33 = dCoef;
   doublereal Jac43 = kappa1;
   doublereal Jac44 = dCoef;
   doublereal Jac45 = dCoef;
   doublereal Jac51 = -area+q1*q1/(densityS*densityS*area)*densityDPres;
   doublereal Jac52 = area-q2*q2/(densityE*densityE*area)*densityDPres;
   doublereal Jac54 = -length/2.-2.*dCoef*(q1/(area*densityS));
   doublereal Jac55 = length/2.+2.*dCoef*(q2/(area*densityE));
  
   doublereal lack54;
   doublereal lack55;

   /* usata nel caso turbolento & transizione */
   doublereal kappa2 = length/(6.*diameter*area);
  
   if (Re < HF->dGetRe(HydraulicFluid::LOWER)) {
       /*******************************************
       * moto sicuramente laminare  (jacobiano)
       ******************************************/
      lack54 = dCoef*(-2.*klam/densityS);
      lack55 = dCoef*(2.*klam/densityE);
   } else if (Re > HF->dGetRe(HydraulicFluid::UPPER)) {
      /*******************************************
       * moto sicuramente turbolento  (jacobiano)
       ******************************************/
#ifdef HYDR_DEVEL
      DEBUGCOUT("AssJac() sono turbolento" << std::endl);   
#endif /* HYDR_DEVEL */
      fa = .3164/pow(Re, .25);
       
      lack54 = -dCoef*(fa*kappa2/densityS)*fabs(-q2+2.*q1);
      lack55 = dCoef*(fa*kappa2/densityE)*fabs(2.*q2-q1);    
#ifdef HYDR_DEVEL 
      DEBUGCOUT("fa " << fa << std::endl);
#endif /* HYDR_DEVEL */
   } else {
      /***********************************
       * moto di transizione  (jacobiano)
       **********************************/
#ifdef HYDR_DEVEL
      DEBUGCOUT("AssJac() sono in transizione" << std::endl);
#endif /* HYDR_DEVEL */
      
      if (turbulent == 0) {
         /*******************************************************
          * moto di transizione laminare-turbolento  (jacobiano)
          ******************************************************/
#ifdef HYDR_DEVEL
         DEBUGCOUT("Sono in transizione lam->turb" << std::endl);
#endif /* HYDR_DEVEL */
         if (Re < HF->dGetRe(HydraulicFluid::LOWER)*1.25) {
            /* uso lo jacobiano laminare */     
            lack54 = dCoef*(-2.*klam/densityS);
            lack55 = dCoef*(+2.*klam/densityE);
         } else {
            doublereal dva = diameter/(viscosity*area);
            doublereal c = -1.8e-5*dva;
            doublereal dva2 = dva*dva;
            doublereal b = 8.e-10*dva2;
            doublereal dva3 = dva2*dva;
            doublereal a = 7.e-13*dva3;
            doublereal d = .0542;
            
            doublereal qm1 = fabs(q1);
            doublereal qm2 = fabs(q2);
            
            doublereal fa1 = ((a*qm1+b)*qm1+c)*qm1+d;
            doublereal fa2 = ((a*qm2+b)*qm2+c)*qm2+d;
#ifdef HYDR_DEVEL           
            DEBUGCOUT("JAC fa1: " << fa1 << std::endl);
            DEBUGCOUT("JAC fa2: " << fa2 << std::endl);
#endif /* HYDR_DEVEL */
            lack54 = -dCoef*(fa1*length/(6.*diameter*area*densityS))*fabs(-q2+2.*q1);
            lack55 = dCoef*(fa2*length/(6.*diameter*area*densityE))*fabs(2.*q2-q1);
         } 
      } else {
         /*******************************************************
          * moto di transizione turbolento-laminare  (jacobiano)
          ******************************************************/
#ifdef HYDR_DEVEL
         DEBUGCOUT("Sono in transizione turb->lam" << std::endl);
#endif /* HYDR_DEVEL */
         
         if (Re > HF->dGetRe(HydraulicFluid::UPPER)*.775) {
            /* uso lo jacobiano turbolento per la parte finale */
            fa = .3164/pow(Re, .25);
            
            lack54 = -dCoef*(fa*kappa2/densityS)*fabs(-q2+2.*q1);
            lack55 = dCoef*(fa*kappa2/densityE)*fabs(2.*q2-q1);    
#ifdef HYDR_DEVEL
            DEBUGCOUT("fa " << fa << std::endl);   
#endif /* HYDR_DEVEL */
         } else {
#ifdef HYDR_DEVEL
            DEBUGCOUT("Jac turb->lam: TRATTO DI INTERPOLAZIONE"<< std::endl);
#endif /* HYDR_DEVEL */
            doublereal dva = diameter/(viscosity*area);
            doublereal c = -1.8e-5*dva;
            doublereal dva2 = dva*dva;
            doublereal b = 2.e-9*dva2;
            doublereal dva3 = dva2*dva;
            doublereal a = 9.e-13*dva3;
            doublereal d = .0528;
            
            doublereal qm1 = fabs(q1);
            doublereal qm2 = fabs(q2);
            
            doublereal fa1 = ((a*qm1+b)*qm1+c)*qm1+d;
            doublereal fa2 = ((a*qm2+b)*qm2+c)*qm2+d;
#ifdef HYDR_DEVEL        
            DEBUGCOUT("JAC fa1: " << fa1 << std::endl);
            DEBUGCOUT("JAC fa2: " << fa2 << std::endl);
#endif /* HYDR_DEVEL */
            lack54 = -dCoef*(fa1*length/(6.*diameter*area*densityS))*fabs(-q2+2.*q1);
            lack55 = dCoef*(fa2*length/(6.*diameter*area*densityE))*fabs(2.*q2-q1);
         }
      }
   } 
   
   Jac54 += lack54;
   Jac55 += lack55;
   
#ifdef HYDR_DEVEL
   DEBUGCOUT("JAC Re:        " << Re << std::endl);
   DEBUGCOUT("JAC density:   " << HF->dGetDensity() << std::endl);
   DEBUGCOUT("JAC p1:        " << p1 << std::endl);
   DEBUGCOUT("JAC p2:        " << p2 << std::endl);
   DEBUGCOUT("JAC q1:        " << q1 << std::endl);
   DEBUGCOUT("JAC q2:        " << q2 << std::endl);
   doublereal q1p = XPrimeCurr(iFirstIndex+2); /* derivata q nodo 1 */
   doublereal q2p = XPrimeCurr(iFirstIndex+3); /* derivata q nodo 2 */
   DEBUGCOUT("JAC q1p:       " << q1p << std::endl);
   DEBUGCOUT("JAC q2p:       " << q2p << std::endl);
   DEBUGCOUT("JAC length:    " << length << std::endl);
   DEBUGCOUT("JAC diameter:  " << diameter << std::endl);
   DEBUGCOUT("JAC viscosity: " << viscosity << std::endl);
   DEBUGCOUT("JAC turbulent: " << turbulent << std::endl);
   DEBUGCOUT("JAC Jac14:     " << Jac14 << std::endl);
   DEBUGCOUT("JAC Jac25:     " << Jac25 << std::endl);
   DEBUGCOUT("JAC Jac31:     " << Jac31 << std::endl);
   DEBUGCOUT("JAC Jac32:     " << Jac32 << std::endl);
   DEBUGCOUT("JAC Jac33:     " << Jac33 << std::endl);
   DEBUGCOUT("JAC Jac43:     " << Jac43 << std::endl);
   DEBUGCOUT("JAC Jac44:     " << Jac44 << std::endl);
   DEBUGCOUT("JAC Jac45:     " << Jac45 << std::endl);
   DEBUGCOUT("JAC Jac51:     " << Jac51 << std::endl);
   DEBUGCOUT("JAC Jac52:     " << Jac52 << std::endl);
   DEBUGCOUT("JAC Jac54:     " << Jac54 << std::endl);
   DEBUGCOUT("JAC Jac55:     " << Jac55 << std::endl);
#endif /* HYDR_DEVEL */
   
   WM.PutCoef(1, 4, Jac14);
   WM.PutCoef(2, 5, Jac25);
   WM.PutCoef(3, 1, Jac31);
   WM.PutCoef(3, 2, Jac32);
   WM.PutCoef(3, 3, Jac33);
   WM.PutCoef(4, 3, Jac43);
   WM.PutCoef(4, 4, Jac44);
   WM.PutCoef(4, 5, Jac45);
   WM.PutCoef(5, 1, Jac51);   
   WM.PutCoef(5, 2, Jac52);
   WM.PutCoef(5, 4, Jac54);
   WM.PutCoef(5, 5, Jac55);
 
   return WorkMat;
}

Here is the call graph for this function:

SubVectorHandler & Dynamic_pipe::AssRes ( SubVectorHandler &  WorkVec, doublereal  dCoef, const VectorHandler &  XCurr, const VectorHandler &  XPrimeCurr  )

virtual

Implements Elem.

Definition at line 743 of file pipe.cc.

References a, area, c, copysign(), DEBUGCOUT, densityDPres, densityEn, densityMe, densitySt, HydraulicFluid::dGetDensity(), HydraulicFluid::dGetDensityDPres(), HydraulicFluid::dGetRe(), HydraulicFluid::dGetViscosity(), ScalarAlgebraicNode::dGetX(), diameter, grad::fabs(), flow1, flow2, HydraulicElem::HF, DofOwnerOwner::iGetFirstIndex(), Node::iGetFirstRowIndex(), klam, ktrb, length, HydraulicFluid::LOWER, pNode1, pNode2, grad::pow(), pp, SubVectorHandler::PutItem(), Re, VectorHandler::Resize(), grad::sqrt(), turbulent, HydraulicFluid::UPPER, VelE, VelM, VelS, and viscosity.

{
   DEBUGCOUT("Entering Dynamic_pipe::AssRes()" << std::endl);
   WorkVec.Resize(5);
   
   integer iNode1RowIndex = pNode1->iGetFirstRowIndex()+1;
   integer iNode2RowIndex = pNode2->iGetFirstRowIndex()+1;
   
   doublereal p1 = pNode1->dGetX();
   doublereal p2 = pNode2->dGetX();
   integer iFirstIndex = iGetFirstIndex();
   
   doublereal pr = XCurr(iFirstIndex+1);        /* pressione */
   doublereal prp = XPrimeCurr(iFirstIndex+1);  /* derivata pressione */
   
   doublereal q1 = XCurr(iFirstIndex+2);        /* portata nodo 1 */
   doublereal q2 = XCurr(iFirstIndex+3);        /* portata nodo 2 */
   doublereal q1p = XPrimeCurr(iFirstIndex+2);  /* derivata portata nodo 1 */
   doublereal q2p = XPrimeCurr(iFirstIndex+3);  /* derivata portata nodo 2 */
   
   flow1 = q1;  /* per l'output */
   flow2 = q2;  /* per l'output */
   pp = prp;    /* per l'output */
  
   doublereal densityS = HF->dGetDensity(p1);           /* densita' all'inizio del tubo */
   doublereal densityE = HF->dGetDensity(p2);           /* densita' alla fine del nodo */
   doublereal densityM = HF->dGetDensity(pr);           /* densita' a meta' tubo */
   
   
   densitySt = densityS;  /* per l'output */
   densityEn = densityE;  /* per l'output */
   densityMe = densityM;  /* per l'output */
   
   viscosity = HF->dGetViscosity();
   densityDPres = HF->dGetDensityDPres(); 
   
   doublereal kappa1 = area*length*densityDPres;
   
   const doublereal x1 = -1./(sqrt(3.));
   const doublereal x2 = -x1;
   doublereal Qx1 = (q1+q2)*x1-q1+q2;
   doublereal Qx2 = (q1+q2)*x2-q1+q2;
   
   doublereal densityx1 = HF->dGetDensity(.5*(p2-p1)*x1+pr);
   doublereal densityx2 = HF->dGetDensity(.5*(p2-p1)*x2+pr);
                                 
   doublereal Res_1 = -q1;
   doublereal Res_2 = -q2;
   doublereal Res_3 = .5*(p1+p2)-pr;
   doublereal Res_4 = -q2-q1-kappa1*prp;
   doublereal Res_5 = (length/2.)*(q1p-q2p)+q1*q1/(area*densityS)-q2*q2/(area*densityE)+area*(p1-p2);
   doublereal lack;
   
   if (Re < HF->dGetRe(HydraulicFluid::LOWER)) {
#ifdef HYDR_DEVEL
     DEBUGCOUT("SONO IN LAMINARE" << std::endl);
#endif /* HYDR_DEVEL */
     lack = -klam*(Qx1/densityx1+Qx2/densityx2);
   
   } else if (Re > HF->dGetRe(HydraulicFluid::UPPER)) {
#ifdef HYDR_DEVEL
      DEBUGCOUT("SONO IN TURBOLENTO" << std::endl);
#endif /* HYDR_DEVEL */
      const doublereal espo = 7./4.;

      lack = -ktrb*(copysign(pow(.5*fabs(Qx1), espo)/densityx1, Qx1)
                    +copysign(pow(.5*fabs(Qx2), espo)/densityx2, Qx2));
#ifdef HYDR_DEVEL
      DEBUGCOUT("SONO IN TURBOLENTO lack: " << lack << std::endl);
      DEBUGCOUT("SONO IN TURBOLENTO Qx1:  " << Qx1 << std::endl);
      DEBUGCOUT("SONO IN TURBOLENTO Qx2:  " << Qx2 << std::endl);
#endif /* HYDR_DEVEL */
   } else { 
      /*********************************
       * moto di transizione  (residuo)
       ********************************/
#ifdef HYDR_DEVEL
      DEBUGCOUT("SONO IN TRANSIZIONE" << std::endl);
      DEBUGCOUT("Re: " << Re << std::endl);
#endif /* HYDR_DEVEL */
      if (turbulent == 0) {  
         /****************************************************
          * moto di transizione laminare-turbolento (residuo)
          ***************************************************/
#ifdef HYDR_DEVEL
         DEBUGCOUT("SONO IN TRANSIZIONE lam->turb" << std::endl);
#endif /* HYDR_DEVEL */
         if (Re < HF->dGetRe(HydraulicFluid::LOWER)*1.25) {
            /* uso il residuo laminare */
            lack = -klam*(Qx1/densityx1+Qx2/densityx2);
#ifdef HYDR_DEVEL
            DEBUGCOUT("RES lam->turb: TRATTO 64/RE" << std::endl);
#endif /* HYDR_DEVEL */
         } else {
#ifdef HYDR_DEVEL
            DEBUGCOUT("RES lam->turb: TRATTO DI INTERPOLAZIONE"<< std::endl);
#endif /* HYDR_DEVEL */
            doublereal dva = diameter/(viscosity*area);
            doublereal c = -1.8e-5*dva;
            doublereal dva2 = dva*dva;
            doublereal b = 8.e-10*dva2;
            doublereal dva3 = dva2*dva;
            doublereal a = 7.e-13*dva3;
            doublereal d = .0542;
             
            doublereal qx1 = fabs(-q1+((q2+q1)/length)*x1); /* usata solo per calcolare il giusto fa in x1 */
            doublereal qx2 = fabs(-q1+((q2+q1)/length)*x2); /* usata solo per calcolare il giusto fa in x2 */
            doublereal fax1 = ((a*qx1+b)*qx1+c)*qx1+d;
            doublereal fax2 = ((a*qx2+b)*qx2+c)*qx2+d;

            doublereal kappa3 = length/(16.*diameter*area);
#ifdef HYDR_DEVEL
            DEBUGCOUT("RES lam->turb fax1: " << fax1 << std::endl);
            DEBUGCOUT("RES lam->turb fax2: " << fax2 << std::endl);
#endif /* HYDR_DEVEL */
            lack = -kappa3*(fax1*copysign(Qx1*Qx1, Qx1)/densityx1
                            +fax2*copysign(Qx2*Qx2, Qx2)/densityx2);
         } 
      } else {
         /****************************************************
          * moto di transizione turbolento-laminare (residuo)
          ***************************************************/
#ifdef HYDR_DEVEL
         DEBUGCOUT("SONO IN TRANSIZIONE turb->lam" << std::endl);
#endif /* HYDR_DEVEL */
         if (Re > HF->dGetRe(HydraulicFluid::UPPER)*.775) {
            /* utilizzo il residuo turbolento */
            const doublereal espo = 7./4.;

            lack = -ktrb*(copysign(pow(.5*fabs(Qx1), espo)/densityx1, Qx1)
                          +copysign(pow(.5*fabs(Qx2), espo)/densityx2, Qx2));
  
            /* DEBUGCOUT("RES turb->lam: TRATTO 0.3164/Re^0.25" << std::endl); */
         } else {
#ifdef HYDR_DEVEL
            DEBUGCOUT("RES turb->lam:TRATTO DI INTERPOLAZIONE" << std::endl);
#endif /* HYDR_DEVEL */
            doublereal dva = diameter/(viscosity*area);
            doublereal c = -1.8e-5*dva;
            doublereal dva2 = dva*dva;
            doublereal b = 2.e-9*dva2;
            doublereal dva3 = dva2*dva;
            doublereal a = 9.e-13*dva3;
            doublereal d = .0528;

            doublereal qx1 = fabs(-q1+((q2+q1)/length)*x1); /* usata solo per calcolare il giusto fa in x1 */
            doublereal qx2 = fabs(-q1+((q2+q1)/length)*x2); /* usata solo per calcolare il giusto fa in x2 */
            doublereal fax1 = ((a*qx1+b)*qx1+c)*qx1+d;
            doublereal fax2 = ((a*qx2+b)*qx2+c)*qx2+d;
#ifdef HYDR_DEVEL
            DEBUGCOUT("RES turb->lam fax1: " << fax1 << std::endl);
            DEBUGCOUT("RES turb->lam fax2: " << fax2 << std::endl);
#endif /* HYDR_DEVEL */
            doublereal kappa3 = length/(16.*diameter*area);

            lack = -kappa3*(fax1*copysign(Qx1*Qx1, Qx1)/densityx1
                            +fax2*copysign(Qx2*Qx2, Qx2)/densityx2);
         }
      }
   }
   
   Res_5 += lack;                                 /* aggiungo la parte dovuta all'attrito */
   VelS = -q1/(area*densityS);                    /* velocita' inizio */
   VelM = ((-q1+q2)/2.)/(area*densityM);          /* velocita' media */
   VelE = q2/(area*densityE);                     /* velocita' fine */
   Re = densityM*fabs(VelM)*diameter/viscosity;   /* numero di Reynolds medio */
   
#ifdef HYDR_DEVEL   
   DEBUGCOUT("RES density:          " << HF->dGetDensity() << std::endl);
   DEBUGCOUT("RES densityS:         " << densityS << std::endl);
   DEBUGCOUT("RES densityM:         " << densityM << std::endl);
   DEBUGCOUT("RES densityE:         " << densityE << std::endl);
   DEBUGCOUT("RES p1 :              " << p1 << std::endl);
   DEBUGCOUT("RES p2 :              " << p2 << std::endl);
   DEBUGCOUT("RES pr :              " << pr << std::endl);
   DEBUGCOUT("RES prp:              " << prp << std::endl);
   DEBUGCOUT("RES q1:               " << q1 << std::endl);
   DEBUGCOUT("RES q2:               " << q2 << std::endl);
   DEBUGCOUT("RES q1p:              " << q1p << std::endl);
   DEBUGCOUT("RES q2p:              " << q2p << std::endl);
   DEBUGCOUT("RES length:           " << length << std::endl);
   DEBUGCOUT("RES diameter:         " << diameter << std::endl);
   DEBUGCOUT("RES viscosity:        " << viscosity << std::endl);
   DEBUGCOUT("RES area:             " << area << std::endl);
   DEBUGCOUT("RES Re:               " << Re << std::endl);
   DEBUGCOUT("***********************************************"<< std::endl);
   DEBUGCOUT("RES velocita' Start:  " << VelS << std::endl);
   DEBUGCOUT("RES velocita' Middle: " << VelM << std::endl);
   DEBUGCOUT("RES velocita' End:    " << VelE << std::endl);
   DEBUGCOUT("    se positiva il fluido va dal nodo 1 al nodo 2 " << std::endl);
   DEBUGCOUT("***********************************************"<< std::endl);
   DEBUGCOUT("RES Res_1:            " << Res_1 << std::endl);
   DEBUGCOUT("RES Res_2:            " << Res_2 << std::endl);
   DEBUGCOUT("RES Res_3:            " << Res_3 << std::endl);
   DEBUGCOUT("RES Res_4:            " << Res_4 << std::endl);
   DEBUGCOUT("RES Res_5:            " << Res_5 << std::endl);
#endif   /* HYDR_DEVEL */ 
   
   WorkVec.PutItem(1, iNode1RowIndex, Res_1);   
   WorkVec.PutItem(2, iNode2RowIndex, Res_2);
   WorkVec.PutItem(3, iFirstIndex+1, Res_3);
   WorkVec.PutItem(4, iFirstIndex+2, Res_4);    
   WorkVec.PutItem(5, iFirstIndex+3, Res_5);
   
   return WorkVec;
}

Here is the call graph for this function:

virtual void Dynamic_pipe::GetConnectedNodes ( std::vector< const Node * > &  connectedNodes ) const

inlinevirtual

Reimplemented from Elem.

Definition at line 188 of file pipe.h.

References pNode1, and pNode2.

                                                                                 {
     connectedNodes.resize(2);
     connectedNodes[0] = pNode1;
     connectedNodes[1] = pNode2;
   };

DofOrder::Order Dynamic_pipe::GetDofType ( unsigned int  i ) const

virtual

Reimplemented from Elem.

Definition at line 518 of file pipe.cc.

References ASSERT, and DofOrder::DIFFERENTIAL.

{
   ASSERT(i >= 0 && i <= 2);
   return DofOrder::DIFFERENTIAL;
}

HydraulicElem::Type Dynamic_pipe::GetHydraulicType ( void  ) const

virtual

Implements HydraulicElem.

Definition at line 502 of file pipe.cc.

References HydraulicElem::DYNAMIC_PIPE.

                                                           {
   return HydraulicElem::DYNAMIC_PIPE;
}

unsigned int Dynamic_pipe::iGetNumDof ( void  ) const

virtual

Reimplemented from Elem.

Definition at line 512 of file pipe.cc.

{
   return 3;
}

void Dynamic_pipe::Output ( OutputHandler &  OH ) const

virtual

Reimplemented from ToBeOutput.

Definition at line 968 of file pipe.cc.

References ToBeOutput::bToBeOutput(), densityEn, densityMe, densitySt, flow1, flow2, WithLabel::GetLabel(), OutputHandler::Hydraulic(), pp, Re, VelE, VelM, and VelS.

{
   if (bToBeOutput()) { 
      std::ostream& out = OH.Hydraulic();
      out 
        << std::setw(8) << GetLabel()
        << " " << Re << " " << -flow1 << " " << flow2
        << " " << densitySt << " " << densityMe << " " << densityEn
        << " " << VelS << " " << VelM << " " << VelE
        << " " << pp
        << std::endl;
   }
}

Here is the call graph for this function:

std::ostream & Dynamic_pipe::Restart ( std::ostream &  out ) const

virtual

Implements Elem.

Definition at line 507 of file pipe.cc.

{
   return out << "Pipe not implemented yet!" << std::endl;
}

void Dynamic_pipe::SetValue ( DataManager *  pDM, VectorHandler &  X, VectorHandler &  XP, SimulationEntity::Hints *  ph = 0  )

virtual

Reimplemented from SimulationEntity.

Definition at line 983 of file pipe.cc.

References ScalarAlgebraicNode::dGetX(), DofOwnerOwner::iGetFirstIndex(), pNode1, pNode2, VectorHandler::PutCoef(), and q0.

{
   integer i = iGetFirstIndex();
   
   doublereal p1 = pNode1->dGetX();
   doublereal p2 = pNode2->dGetX();
   
   X.PutCoef(i+1, .5*(p1+p2));
   X.PutCoef(i+2, q0);
   X.PutCoef(i+3, -q0);
   
   XP.PutCoef(i+1, 0.);
   XP.PutCoef(i+2, 0.);
   XP.PutCoef(i+3, 0.);
}

Here is the call graph for this function:

void Dynamic_pipe::WorkSpaceDim ( integer *  piNumRows, integer *  piNumCols  ) const

virtual

Implements Elem.

Definition at line 525 of file pipe.cc.

{
   *piNumRows = 5; 
   *piNumCols = 5; 
}

Member Data Documentation

doublereal Dynamic_pipe::area

private

Definition at line 122 of file pipe.h.

Referenced by AssJac(), AssRes(), and Dynamic_pipe().

doublereal Dynamic_pipe::densityDPres

private

Definition at line 136 of file pipe.h.

Referenced by AssJac(), and AssRes().

doublereal Dynamic_pipe::densityEn

private

Definition at line 135 of file pipe.h.

Referenced by AssRes(), and Output().

doublereal Dynamic_pipe::densityMe

private

Definition at line 134 of file pipe.h.

Referenced by AssRes(), and Output().

doublereal Dynamic_pipe::densitySt

private

Definition at line 133 of file pipe.h.

Referenced by AssRes(), and Output().

doublereal Dynamic_pipe::diameter

private

Definition at line 121 of file pipe.h.

Referenced by AssJac(), AssRes(), and Dynamic_pipe().

doublereal Dynamic_pipe::fa

private

Definition at line 143 of file pipe.h.

Referenced by AssJac().

doublereal Dynamic_pipe::flow1

private

Definition at line 127 of file pipe.h.

Referenced by AssRes(), and Output().

doublereal Dynamic_pipe::flow2

private

Definition at line 128 of file pipe.h.

Referenced by AssRes(), and Output().

doublereal Dynamic_pipe::klam

private

Definition at line 131 of file pipe.h.

Referenced by AssJac(), AssRes(), and Dynamic_pipe().

doublereal Dynamic_pipe::ktra

private

Definition at line 132 of file pipe.h.

Referenced by Dynamic_pipe().

doublereal Dynamic_pipe::ktrb

private

Definition at line 130 of file pipe.h.

Referenced by AssRes(), and Dynamic_pipe().

doublereal Dynamic_pipe::length

private

Definition at line 123 of file pipe.h.

Referenced by AssJac(), AssRes(), and Dynamic_pipe().

const PressureNode* Dynamic_pipe::pNode1

private

Definition at line 119 of file pipe.h.

Referenced by AssJac(), AssRes(), Dynamic_pipe(), GetConnectedNodes(), and SetValue().

const PressureNode* Dynamic_pipe::pNode2

private

Definition at line 120 of file pipe.h.

Referenced by AssJac(), AssRes(), Dynamic_pipe(), GetConnectedNodes(), and SetValue().

doublereal Dynamic_pipe::pp

private

Definition at line 145 of file pipe.h.

Referenced by AssRes(), and Output().

doublereal Dynamic_pipe::q0

private

Definition at line 125 of file pipe.h.

Referenced by SetValue().

doublereal Dynamic_pipe::Re

private

Definition at line 129 of file pipe.h.

Referenced by AfterConvergence(), AssJac(), AssRes(), and Output().

flag Dynamic_pipe::turbulent

private

Definition at line 124 of file pipe.h.

Referenced by AfterConvergence(), AssJac(), and AssRes().

doublereal Dynamic_pipe::VelE

private

Definition at line 142 of file pipe.h.

Referenced by AssRes(), and Output().

doublereal Dynamic_pipe::VelM

private

Definition at line 141 of file pipe.h.

Referenced by AssRes(), and Output().

doublereal Dynamic_pipe::VelS

private

Definition at line 140 of file pipe.h.

Referenced by AssRes(), and Output().

doublereal Dynamic_pipe::viscosity

private

Definition at line 138 of file pipe.h.

Referenced by AssJac(), AssRes(), and Dynamic_pipe().

---

The documentation for this class was generated from the following files:

• pipe.h
• pipe.cc