Actuator Class Reference

#include <actuator.h>

Inheritance diagram for Actuator:

Collaboration diagram for Actuator:

Public Member Functions
	Actuator (unsigned int uL, const DofOwner *pD, const PressureNode *p1, const PressureNode *p2, const StructNode *pN1, const StructNode *pN2, const Vec3 &f1Tmp, const Vec3 &f2Tmp, const Vec3 &axisTmp, HydraulicFluid *hf1, HydraulicFluid *hf2, doublereal A_1, doublereal A_2, doublereal l, flag fOut)
	~Actuator (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 DofOrder::Order	GetEqType (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	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 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)
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 *	pNodeHyd1
const PressureNode *	pNodeHyd2
HydraulicFluid *	HF2
doublereal	area1
doublereal	area2
doublereal	dl
const Vec3	axis
doublereal	dp1
doublereal	dp2
doublereal	dpP1
doublereal	dpP2
doublereal	flow1
doublereal	flow2
doublereal	Vol1
doublereal	Vol2
doublereal	density1
doublereal	density2
const StructNode *	pNodeStr1
const StructNode *	pNodeStr2
const Vec3	f1
const Vec3	f2

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 44 of file actuator.h.

Constructor & Destructor Documentation

Actuator::Actuator	(	unsigned int	uL,
		const DofOwner *	pD,
		const PressureNode *	p1,
		const PressureNode *	p2,
		const StructNode *	pN1,
		const StructNode *	pN2,
		const Vec3 &	f1Tmp,
		const Vec3 &	f2Tmp,
		const Vec3 &	axisTmp,
		HydraulicFluid *	hf1,
		HydraulicFluid *	hf2,
		doublereal	A_1,
		doublereal	A_2,
		doublereal	l,
		flag	fOut
	)

Definition at line 100 of file actuator.cc.

References area1, area2, ASSERT, dl, PressureNode::GetNodeType(), StructDispNode::GetNodeType(), HF2, Node::HYDRAULIC, pNodeHyd1, pNodeHyd2, pNodeStr1, pNodeStr2, and Node::STRUCTURAL.

: Elem(uL, fOut),
HydraulicElem(uL, pDO, hf1, fOut),
pNodeHyd1(p1), pNodeHyd2(p2),
HF2(hf2),
area1(A_1), area2(A_2),
dl(l), axis(axisTmp),
dp1(0.),
dp2(0.),
dpP1(0.),
dpP2(0.),
flow1(0.),
flow2(0.),
Vol1(0.),
Vol2(0.),
density1(0.),
density2(0.),
pNodeStr1(pN1), pNodeStr2(pN2), f1(f1Tmp), f2(f2Tmp)
{
   ASSERT(pNodeHyd1 != NULL);
   ASSERT(pNodeHyd1->GetNodeType() == Node::HYDRAULIC);
   ASSERT(pNodeHyd2 != NULL);
   ASSERT(pNodeHyd2->GetNodeType() == Node::HYDRAULIC);
   ASSERT(area1 > std::numeric_limits<doublereal>::epsilon()); 
   ASSERT(area2 > std::numeric_limits<doublereal>::epsilon());
   ASSERT(dl > std::numeric_limits<doublereal>::epsilon());
   ASSERT(pNodeStr1 != NULL);
   ASSERT(pNodeStr1->GetNodeType() == Node::STRUCTURAL);
   ASSERT(pNodeStr2 != NULL);
   ASSERT(pNodeStr2->GetNodeType() == Node::STRUCTURAL);
   ASSERT(HF2 != NULL);
}

Here is the call graph for this function:

Actuator::~Actuator

(

void

)

Definition at line 144 of file actuator.cc.

References HF2, and SAFEDELETE.

{
   if (HF2 != NULL) {
      SAFEDELETE(HF2);
   }
}

Member Function Documentation

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

virtual

Implements Elem.

Definition at line 193 of file actuator.cc.

References FullSubMatrixHandler::Add(), area1, area2, axis, Vec3::Cross(), DEBUGCOUT, density1, density2, Vec3::dGet(), HydraulicFluid::dGetDensity(), HydraulicFluid::dGetDensityDPres(), ScalarAlgebraicNode::dGetX(), dl, Vec3::Dot(), dpP1, dpP2, f1, f2, StructNode::GetRRef(), StructDispNode::GetVCurr(), StructNode::GetWRef(), StructDispNode::GetXCurr(), HF1, HF2, Node::iGetFirstColIndex(), DofOwnerOwner::iGetFirstIndex(), StructDispNode::iGetFirstMomentumIndex(), StructDispNode::iGetFirstPositionIndex(), Node::iGetFirstRowIndex(), MatCross, pNodeHyd1, pNodeHyd2, pNodeStr1, pNodeStr2, FullSubMatrixHandler::PutCoef(), FullSubMatrixHandler::PutColIndex(), FullSubMatrixHandler::PutRowIndex(), FullSubMatrixHandler::ResizeReset(), VariableSubMatrixHandler::SetFull(), and FullSubMatrixHandler::Sub().

{
   DEBUGCOUT("Entering Actuator::AssJac()" << std::endl);
      
   FullSubMatrixHandler& WM = WorkMat.SetFull();
   WM.ResizeReset(16, 16);   
   
   /* Recupera gli indici */
   integer iNode1FirstPosIndex = pNodeStr1->iGetFirstPositionIndex();
   integer iNode1FirstMomIndex = pNodeStr1->iGetFirstMomentumIndex();
   integer iNode2FirstPosIndex = pNodeStr2->iGetFirstPositionIndex();
   integer iNode2FirstMomIndex = pNodeStr2->iGetFirstMomentumIndex();
   integer iIndex = iGetFirstIndex();
   
   /* Setta gli indici della matrice */
   for (int iCnt = 1; iCnt <= 6; iCnt++) {
      WM.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
      WM.PutColIndex(iCnt, iNode1FirstPosIndex+iCnt);   
      WM.PutRowIndex(6+iCnt, iNode2FirstMomIndex+iCnt);
      WM.PutColIndex(6+iCnt, iNode2FirstPosIndex+iCnt);
   }           
    
   integer iNode1RowIndex = pNodeHyd1->iGetFirstRowIndex()+1;
   integer iNode1ColIndex = pNodeHyd1->iGetFirstColIndex()+1;
   integer iNode2RowIndex = pNodeHyd2->iGetFirstRowIndex()+1;
   integer iNode2ColIndex = pNodeHyd2->iGetFirstColIndex()+1;
 
   WM.PutRowIndex(13, iNode1RowIndex);
   WM.PutColIndex(13, iNode1ColIndex);
   WM.PutRowIndex(14, iNode2RowIndex);
   WM.PutColIndex(14, iNode2ColIndex);
   
   WM.PutRowIndex(15, iIndex+1);
   WM.PutColIndex(15, iIndex+1);
   WM.PutRowIndex(16, iIndex+2);
   WM.PutColIndex(16, iIndex+2);

   doublereal p1 = pNodeHyd1->dGetX();
   doublereal p2 = pNodeHyd2->dGetX();
   
   doublereal density1 = HF1->dGetDensity(p1);
   doublereal density2 = HF2->dGetDensity(p2);
   doublereal densityDP1 = HF1->dGetDensityDPres(p1);
   doublereal densityDP2 = HF2->dGetDensityDPres(p2);
   
   Vec3 x1(pNodeStr1->GetXCurr());
   Vec3 x2(pNodeStr2->GetXCurr());
   Mat3x3 R1(pNodeStr1->GetRRef());
   Mat3x3 R2(pNodeStr2->GetRRef());
   
   Vec3 f1Tmp(R1*f1);
   Vec3 f2Tmp(R2*f2);
     
   Vec3 v1(pNodeStr1->GetVCurr());
   Vec3 v2(pNodeStr2->GetVCurr());
   Vec3 Omega1(pNodeStr1->GetWRef());
   Vec3 Omega2(pNodeStr2->GetWRef());
   
   Vec3 TmpAxis(R1*axis);
   
   Vec3 FHyd = TmpAxis*(area1*p1-area2*p2); /* forza idraulica (scalare) */
   
   doublereal dDist = TmpAxis.Dot(x2+f2Tmp-x1-f1Tmp);
   doublereal dVel = TmpAxis.Dot(v2+Omega2.Cross(f2Tmp)-v1-Omega1.Cross(f1Tmp));
   
   /* prima equazione & terza equazione
    * moltiplica deltagpuntonodo1 */
   Mat3x3 JacMatWedge1(MatCross, FHyd*dCoef);
   WM.Sub(1, 4, JacMatWedge1);
   WM.Add(7, 4, JacMatWedge1);
   
   /* moltiplica deltaP1 e deltaP2 */
   for (int iCnt = 1; iCnt <= 3; iCnt++) {
      doublereal d = TmpAxis.dGet(iCnt);
      doublereal d1 = d*area1;
      doublereal d2 = d*area2;
      
      WM.PutCoef(iCnt, 13, d1);
      WM.PutCoef(6+iCnt, 13, -d1);
      

      WM.PutCoef(iCnt, 14, -d2);
      WM.PutCoef(6+iCnt, 14, d2);
   }

   /* seconda equazione moltiplica deltagpuntonodo1 */
   WM.Sub(4, 4, Mat3x3(MatCross, f1Tmp.Cross(FHyd*dCoef)));
   
   /* moltiplica deltaP1 e deltaP2 */
   Vec3 JacVec = f1Tmp.Cross(TmpAxis);
   for (int iCnt = 1; iCnt <= 3; iCnt++) {
      doublereal d = JacVec.dGet(iCnt);
      
      WM.PutCoef(3+iCnt, 13, d*area1);
      WM.PutCoef(3+iCnt, 14, -d*area2);
   }
 
   /* quarta equazione moltiplica deltagpuntonodo1 */
   Mat3x3 TmpMat(MatCross, f2Tmp.Cross(FHyd*dCoef));
   WM.Add(4, 4, TmpMat);
   WM.Sub(4, 10, TmpMat);

   /* moltiplica deltaP1 e deltaP2 */
   JacVec = f2Tmp.Cross(TmpAxis);
   for (int iCnt = 1; iCnt <=3; iCnt++) {
      doublereal d = JacVec.dGet(iCnt);
      
      WM.PutCoef(9+iCnt, 13, -d*area1);
      WM.PutCoef(9+iCnt, 14, d*area2);
   }

   /* inerzia del fluido */
   WM.PutCoef(13, 15, -densityDP1*dDist*area1);
   WM.PutCoef(13, 13, -densityDP1*dVel*area1);
   WM.PutCoef(14, 16, -densityDP2*(dl-dDist)*area2);
   WM.PutCoef(14, 14, densityDP2*dVel*area2);
   
   /* termini in spostamento e velocita' */
   doublereal rho1A1 = (density1+dCoef*densityDP1*dpP1)*area1;
   doublereal rho2A2 = (density2+dCoef*densityDP2*dpP2)*area2;

   for (int iCnt = 1; iCnt <= 3; iCnt++) {
      doublereal d = TmpAxis.dGet(iCnt);
      WM.PutCoef(13, iCnt, d*rho1A1);
      WM.PutCoef(13, 6+iCnt, -d*rho1A1);
      
      WM.PutCoef(14, iCnt, -d*rho2A2);
      WM.PutCoef(14, 6+iCnt, d*rho2A2);
   }

   /* prima eq., nodo 1 */
   JacVec = (TmpAxis.Cross(x2+f2Tmp-x1))*(densityDP1*dpP1*dCoef)
     +(TmpAxis.Cross(f1Tmp+(x2+Omega2.Cross(f2Tmp)-x1)*dCoef))*density1;
   for (int iCnt = 1; iCnt <= 3; iCnt++) {
      WM.PutCoef(13, 3+iCnt, -JacVec.dGet(iCnt)*area1);
   }
   
   /* prima eq., nodo 2 */
   JacVec = (TmpAxis.Cross(f2Tmp))*(densityDP1*dpP1*dCoef)
     +(TmpAxis.Cross(f2Tmp+(Omega2.Cross(f2Tmp))*dCoef))*density1;
   for (int iCnt = 1; iCnt <= 3; iCnt++) {
      WM.PutCoef(13, 9+iCnt, JacVec.dGet(iCnt)*area1);
   }
   
   /* seconda eq., nodo 1 */
   JacVec = (TmpAxis.Cross(x2+f2Tmp-x1))*(densityDP2*dpP2*dCoef)
     +(TmpAxis.Cross(f1Tmp+(x2+Omega2.Cross(f2Tmp)-x1)*dCoef))*density2;
   for (int iCnt = 1; iCnt <= 3; iCnt++) {
      WM.PutCoef(14, 3+iCnt, JacVec.dGet(iCnt)*area2);
   }
   
   /* seconda eq., nodo 2 */
   JacVec = (TmpAxis.Cross(f2Tmp))*(densityDP2*dpP2*dCoef)
     +(TmpAxis.Cross(f2Tmp+(Omega2.Cross(f2Tmp))*dCoef))*density2;
   for (int iCnt = 1; iCnt <= 3; iCnt++) {
      WM.PutCoef(14, 9+iCnt, JacVec.dGet(iCnt)*area2);
   }
   
   /* definizione della pressione interna */
   
   WM.PutCoef(15, 15, dCoef);
   WM.PutCoef(15, 13, -1.);
    
   WM.PutCoef(16, 16, dCoef);
   WM.PutCoef(16, 14, -1.);

   return WorkMat;
}

Here is the call graph for this function:

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

virtual

Implements Elem.

Definition at line 367 of file actuator.cc.

References VectorHandler::Add(), area1, area2, axis, Vec3::Cross(), density1, density2, HydraulicFluid::dGetDensity(), HydraulicFluid::dGetDensityDPres(), ScalarAlgebraicNode::dGetX(), dl, Vec3::Dot(), dp1, dp2, dpP1, dpP2, f1, f2, flow1, flow2, StructNode::GetRCurr(), StructDispNode::GetVCurr(), StructNode::GetWCurr(), StructDispNode::GetXCurr(), HF1, HF2, DofOwnerOwner::iGetFirstIndex(), StructDispNode::iGetFirstMomentumIndex(), Node::iGetFirstRowIndex(), pNodeHyd1, pNodeHyd2, pNodeStr1, pNodeStr2, VectorHandler::PutCoef(), SubVectorHandler::PutRowIndex(), VectorHandler::ResizeReset(), VectorHandler::Sub(), Vol1, and Vol2.

{      
   WorkVec.ResizeReset(16);
   
   integer iNode1RowIndex = pNodeHyd1->iGetFirstRowIndex()+1;
   integer iNode2RowIndex = pNodeHyd2->iGetFirstRowIndex()+1;
   integer iNode1FirstMomIndex = pNodeStr1->iGetFirstMomentumIndex();
   integer iNode2FirstMomIndex = pNodeStr2->iGetFirstMomentumIndex();
   integer iIndex = iGetFirstIndex();
     
   /* Setta gli indici */
   for (int iCnt = 1; iCnt <= 6; iCnt++) {
      WorkVec.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
      WorkVec.PutRowIndex(6+iCnt, iNode2FirstMomIndex+iCnt);
   }
   
   WorkVec.PutRowIndex(13, iNode1RowIndex);
   WorkVec.PutRowIndex(14, iNode2RowIndex);
   
   WorkVec.PutRowIndex(15, iIndex+1);
   WorkVec.PutRowIndex(16, iIndex+2);
   
   /* Dati */
   doublereal p1 = pNodeHyd1->dGetX();
   doublereal p2 = pNodeHyd2->dGetX();
   
   dp1 = XCurr(iIndex+1);
   dp2 = XCurr(iIndex+2);
   
   dpP1 = XPrimeCurr(iIndex+1);
   dpP2 = XPrimeCurr(iIndex+2);
   
   Vec3 x1(pNodeStr1->GetXCurr());
   Vec3 x2(pNodeStr2->GetXCurr());
   Mat3x3 R1(pNodeStr1->GetRCurr());
   Mat3x3 R2(pNodeStr2->GetRCurr());
     
   Vec3 v1(pNodeStr1->GetVCurr());
   Vec3 v2(pNodeStr2->GetVCurr());
   Vec3 Omega1(pNodeStr1->GetWCurr());
   Vec3 Omega2(pNodeStr2->GetWCurr());
   
   Vec3 f1Tmp(R1*f1);
   Vec3 f2Tmp(R2*f2);
  
   density1 = HF1->dGetDensity(p1);
   density2 = HF2->dGetDensity(p2);
 
   doublereal densityDP1 = HF1->dGetDensityDPres(p1);
   doublereal densityDP2 = HF2->dGetDensityDPres(p2);
   
   /* asse nel sistema globale */
   Vec3 TmpAxis(R1*axis);
   
   /* Calcolo della forza */
   Vec3 FHyd = TmpAxis*(area1*p1-area2*p2);
   
   /* Calcolo delle portate */
   /*
    * FIXME: manca nello Jacobiano un pezzo della velocita' 
    * dell'attuatore dipendente dalla velocita' angolare dell'asse
    */
   Vec3 Dist = x2+f2Tmp-x1-f1Tmp;
   doublereal dDist = TmpAxis*Dist;
   doublereal dVel = TmpAxis.Dot(v2+Omega2.Cross(f2Tmp)-v1-Omega1.Cross(f1Tmp))
           +Dist*(Omega1.Cross(TmpAxis));
   flow1 = area1*(densityDP1*dpP1*dDist+density1*dVel);
   flow2 = area2*(densityDP2*dpP2*(dl-dDist)-density2*dVel);
   Vol1 = area1*dDist;
   Vol2 = area2*(dl-dDist);

   /* Forze e coppia sul nodo strutturale 1 */
   WorkVec.Sub(1, FHyd);
   WorkVec.Sub(4, f1Tmp.Cross(FHyd));
   
   /* Forze e coppia sul nodo strutturale 2 */
   WorkVec.Add(7, FHyd);
   WorkVec.Add(10, f2Tmp.Cross(FHyd));

   /* Portata sul nodo idraulico 1 */
   WorkVec.PutCoef(13, flow1);
   
   /* Portata sul nodo idraulico 2 */
   WorkVec.PutCoef(14, flow2);
   
   /* pressioni */
   WorkVec.PutCoef(15, p1-dp1);
   WorkVec.PutCoef(16, p2-dp2);
   
   return WorkVec;
}

Here is the call graph for this function:

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

inlinevirtual

Reimplemented from Elem.

Definition at line 119 of file actuator.h.

References pNodeHyd1, pNodeHyd2, pNodeStr1, and pNodeStr2.

                                                                                 {
     connectedNodes.resize(4);
     connectedNodes[0] = pNodeHyd1;
     connectedNodes[1] = pNodeHyd2;
     connectedNodes[2] = pNodeStr1;
     connectedNodes[3] = pNodeStr2;
   };

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

virtual

Reimplemented from Elem.

Definition at line 171 of file actuator.cc.

References DofOrder::DIFFERENTIAL.

{   
   return DofOrder::DIFFERENTIAL;
}  

DofOrder::Order Actuator::GetEqType ( unsigned int  i ) const

virtual

Reimplemented from SimulationEntity.

Definition at line 177 of file actuator.cc.

References DofOrder::DIFFERENTIAL.

{   
   return DofOrder::DIFFERENTIAL;
}  

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

virtual

Implements HydraulicElem.

Definition at line 152 of file actuator.cc.

References HydraulicElem::ACTUATOR.

{
   return HydraulicElem::ACTUATOR;
}

unsigned int Actuator::iGetNumDof ( void  ) const

virtual

Reimplemented from Elem.

Definition at line 165 of file actuator.cc.

{
  return 2;
}

void Actuator::Output ( OutputHandler &  OH ) const

virtual

Reimplemented from ToBeOutput.

Definition at line 464 of file actuator.cc.

References ToBeOutput::bToBeOutput(), density1, density2, dp1, dp2, dpP1, dpP2, flow1, flow2, WithLabel::GetLabel(), OutputHandler::Hydraulic(), Vol1, and Vol2.

{
   if (bToBeOutput()) { 
      std::ostream& out = OH.Hydraulic();
      out << std::setw(8) << GetLabel()
        << " " << flow1  << " " << flow2 
        << " " << dp1 << " " << dp2
        << " " << dpP1 << " " << dpP2
        << " " << Vol1 << " " << Vol2
        << " " << density1 << " " << density2
        << std::endl;
   }  
}

Here is the call graph for this function:

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

virtual

Implements Elem.

Definition at line 159 of file actuator.cc.

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

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

virtual

Reimplemented from SimulationEntity.

Definition at line 479 of file actuator.cc.

References ScalarAlgebraicNode::dGetX(), dp1, dp2, dpP1, dpP2, DofOwnerOwner::iGetFirstIndex(), pNodeHyd1, pNodeHyd2, and VectorHandler::PutCoef().

{
   integer iIndex = iGetFirstIndex();
   (doublereal&)dp1 = pNodeHyd1->dGetX();
   (doublereal&)dp2 = pNodeHyd2->dGetX();
   (doublereal&)dpP1 = 0.;
   (doublereal&)dpP2 = 0.;
   
   X.PutCoef(iIndex+1, dp1);
   X.PutCoef(iIndex+2, dp2);
   XP.PutCoef(iIndex+1, dpP1);
   XP.PutCoef(iIndex+2, dpP2);
}

Here is the call graph for this function:

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

virtual

Implements Elem.

Definition at line 184 of file actuator.cc.

{   
   *piNumRows = 16;
   *piNumCols = 16;   
    
}

Member Data Documentation

doublereal Actuator::area1

private

Definition at line 49 of file actuator.h.

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

doublereal Actuator::area2

private

Definition at line 50 of file actuator.h.

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

const Vec3 Actuator::axis

private

Definition at line 55 of file actuator.h.

Referenced by AssJac(), and AssRes().

doublereal Actuator::density1

private

Definition at line 66 of file actuator.h.

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

doublereal Actuator::density2

private

Definition at line 67 of file actuator.h.

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

doublereal Actuator::dl

private

Definition at line 52 of file actuator.h.

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

doublereal Actuator::dp1

private

Definition at line 57 of file actuator.h.

Referenced by AssRes(), Output(), and SetValue().

doublereal Actuator::dp2

private

Definition at line 58 of file actuator.h.

Referenced by AssRes(), Output(), and SetValue().

doublereal Actuator::dpP1

private

Definition at line 59 of file actuator.h.

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

doublereal Actuator::dpP2

private

Definition at line 60 of file actuator.h.

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

const Vec3 Actuator::f1

private

Definition at line 71 of file actuator.h.

Referenced by AssJac(), and AssRes().

const Vec3 Actuator::f2

private

Definition at line 72 of file actuator.h.

Referenced by AssJac(), and AssRes().

doublereal Actuator::flow1

private

Definition at line 62 of file actuator.h.

Referenced by AssRes(), and Output().

doublereal Actuator::flow2

private

Definition at line 63 of file actuator.h.

Referenced by AssRes(), and Output().

HydraulicFluid* Actuator::HF2

private

Definition at line 48 of file actuator.h.

Referenced by Actuator(), AssJac(), AssRes(), and ~Actuator().

const PressureNode* Actuator::pNodeHyd1

private

Definition at line 46 of file actuator.h.

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

const PressureNode* Actuator::pNodeHyd2

private

Definition at line 47 of file actuator.h.

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

const StructNode* Actuator::pNodeStr1

private

Definition at line 69 of file actuator.h.

Referenced by Actuator(), AssJac(), AssRes(), and GetConnectedNodes().

const StructNode* Actuator::pNodeStr2

private

Definition at line 70 of file actuator.h.

Referenced by Actuator(), AssJac(), AssRes(), and GetConnectedNodes().

doublereal Actuator::Vol1

private

Definition at line 64 of file actuator.h.

Referenced by AssRes(), and Output().

doublereal Actuator::Vol2

private

Definition at line 65 of file actuator.h.

Referenced by AssRes(), and Output().

---

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

• actuator.h
• actuator.cc