#include <totalj.h>

Inheritance diagram for TotalForce:

Collaboration diagram for TotalForce:

Public Member Functions
	TotalForce (unsigned int uL, TplDriveCaller< Vec3 > const pDCForce, TplDriveCaller< Vec3 > const pDCCouple, const StructNode pN1, const Vec3 &f1Tmp, const Mat3x3 &R1hTmp, const Mat3x3 &R1hrTmp, const StructNode pN2, const Vec3 &f2Tmp, const Mat3x3 &R2hTmp, const Mat3x3 &R2hrTmp, flag fOut)

	~TotalForce (void)

virtual Force::Type	GetForceType (void) const

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

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 bool	bInverseDynamics (void) const

SubVectorHandler &	AssRes (SubVectorHandler &WorkVec, const VectorHandler &, const VectorHandler &, const VectorHandler &, InverseDynamics::Order iOrder=InverseDynamics::INVERSE_DYNAMICS)

virtual void	Output (OutputHandler &OH) const

virtual void	InitialWorkSpaceDim (integer piNumRows, integer piNumCols) const

virtual VariableSubMatrixHandler &	InitialAssJac (VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)

virtual SubVectorHandler &	InitialAssRes (SubVectorHandler &WorkVec, const VectorHandler &XCurr)

Public Member Functions inherited from Elem
	Elem (unsigned int uL, flag fOut)

virtual	~Elem (void)

virtual unsigned int	iGetNumDof (void) const

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 DofOrder::Order	GetDofType (unsigned int) const

virtual void	AssMats (VariableSubMatrixHandler &WorkMatA, VariableSubMatrixHandler &WorkMatB, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

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 int	GetNumConnectedNodes (void) const

virtual void	GetConnectedNodes (std::vector< const Node * > &connectedNodes) 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 void	SetValue (DataManager pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints h=0)

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 Force
	Force (unsigned int uL, flag fOut)

virtual	~Force (void)

virtual Elem::Type	GetElemType (void) const

virtual unsigned int	iGetInitialNumDof (void) const

Public Member Functions inherited from InitialAssemblyElem
	InitialAssemblyElem (unsigned int uL, flag fOut)

virtual	~InitialAssemblyElem (void)

Public Member Functions inherited from SubjectToInitialAssembly
	SubjectToInitialAssembly (void)

virtual	~SubjectToInitialAssembly (void)

Private Attributes
const StructNode *	pNode1

const StructNode *	pNode2

Vec3	f1

Mat3x3	R1h

Mat3x3	R1hr

Vec3	f2

Mat3x3	R2h

Mat3x3	R2hr

TplDriveOwner< Vec3 >	FDrv

TplDriveOwner< Vec3 >	MDrv

Vec3	M

Vec3	F

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 Force
enum	Type { UNKNOWN = -1, ABSTRACTFORCE = 0, ABSTRACTINTERNALFORCE, ABSOLUTEDISPFORCE, ABSOLUTEINTERNALDISPFORCE, ABSOLUTEFORCE, FOLLOWERFORCE, ABSOLUTECOUPLE, FOLLOWERCOUPLE, ABSOLUTEINTERNALFORCE, FOLLOWERINTERNALFORCE, ABSOLUTEINTERNALCOUPLE, FOLLOWERINTERNALCOUPLE, TOTALFORCE, TOTALINTERNALFORCE, EXTERNALSTRUCTURAL, MODALFORCE, EXTERNALMODAL, LASTFORCETYPE }

Protected Attributes inherited from WithLabel
unsigned int	uLabel

std::string	sName

Protected Attributes inherited from ToBeOutput
flag	fOutput

Detailed Description

Definition at line 482 of file totalj.h.

Constructor & Destructor Documentation

TotalForce::TotalForce	(	unsigned int	uL,
		TplDriveCaller< Vec3 > *const	pDCForce,
		TplDriveCaller< Vec3 > *const	pDCCouple,
		const StructNode *	pN1,
		const Vec3 &	f1Tmp,
		const Mat3x3 &	R1hTmp,
		const Mat3x3 &	R1hrTmp,
		const StructNode *	pN2,
		const Vec3 &	f2Tmp,
		const Mat3x3 &	R2hTmp,
		const Mat3x3 &	R2hrTmp,
		flag	fOut
	)

Definition at line 3746 of file totalj.cc.

References NO_OP.

 : Elem(uL, fOut),
 Force(uL, fOut),
 pNode1(pN1), pNode2(pN2),
 f1(f1Tmp), R1h(R1hTmp), R1hr(R1hrTmp),
 f2(f2Tmp), R2h(R2hTmp), R2hr(R2hrTmp),
 FDrv(pDCForce), MDrv(pDCCouple),
 M(::Zero3), F(::Zero3)
 {
         NO_OP;
 }

TotalForce::~TotalForce ( void )

inline

Definition at line 510 of file totalj.h.

References NO_OP.

                           {
                 NO_OP;
         };

Member Function Documentation

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

virtual

Implements Elem.

Definition at line 3795 of file totalj.cc.

References FullSubMatrixHandler::Add(), DEBUGCOUT, F, f2, StructNode::GetRCurr(), StructNode::GetRRef(), StructDispNode::GetXCurr(), StructDispNode::iGetFirstMomentumIndex(), StructDispNode::iGetFirstPositionIndex(), M, MatCross, MatCrossCross, pNode1, pNode2, FullSubMatrixHandler::PutColIndex(), FullSubMatrixHandler::PutRowIndex(), R1h, R1hr, FullSubMatrixHandler::ResizeReset(), VariableSubMatrixHandler::SetFull(), FullSubMatrixHandler::Sub(), and WorkSpaceDim().

 {
         DEBUGCOUT("Entering TotalForce::AssJac()" << std::endl);
 
         FullSubMatrixHandler& WM = WorkMat.SetFull();
 
         /* Ridimensiona la sottomatrice in base alle esigenze */
         integer iNumRows = 0;
         integer iNumCols = 0;
         WorkSpaceDim(&iNumRows, &iNumCols);
         WM.ResizeReset(iNumRows, iNumCols);
 
         /* Recupera gli indici delle varie incognite */
         integer iNode1FirstPosIndex = pNode1->iGetFirstPositionIndex();
         integer iNode1FirstMomIndex = pNode1->iGetFirstMomentumIndex();
         integer iNode2FirstPosIndex = pNode2->iGetFirstPositionIndex();
         integer iNode2FirstMomIndex = pNode2->iGetFirstMomentumIndex();
 
         /* Setta gli indici delle equazioni */
         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);
         }
 
         /* Recupera i dati che servono */
         Mat3x3 R1(pNode1->GetRRef()*R1h);
         Mat3x3 R1r(pNode1->GetRRef()*R1hr);
         Vec3 b2(pNode2->GetRCurr()*f2);
         Vec3 b1(pNode2->GetXCurr() + b2 - pNode1->GetXCurr());
 
         /* Moltiplica il momento e la forza per il coefficiente del metodo */
         Vec3 FTmp(R1*(F*dCoef));
         Vec3 MTmp(R1r*(M*dCoef));
 
         /* Equilibrium: ((Phi/q)^T*F)/q */
 
         Mat3x3 Tmp;
 
         /* [ F x ] */
         Tmp = Mat3x3(MatCross, FTmp);
 
         /* Lines 1->3: */
         WM.Add(1, 3 + 1, Tmp);
 
         /* Lines 4->6: */
         WM.Sub(3 + 1, 1, Tmp);
 
         WM.Add(3 + 1, 6 + 1, Tmp);
 
         /* Lines 7->9: */
         WM.Sub(6 + 1, 3 + 1, Tmp);
 
         /* [ F x ] [ b2 x ] */
         Tmp = Mat3x3(MatCrossCross, FTmp, b2);
 
         /* Lines 4->6: */
         WM.Sub(3 + 1, 9 + 1, Tmp);
 
         /* Lines 10->12: */
         WM.Add(9 + 1, 9 + 1, Tmp);
 
         /* [ b1 x ] [ F x ] + [ M x ] */
 
         /* Lines 4->6: */
         WM.Add(3 + 1, 3 + 1, Mat3x3(MatCrossCross, b1, FTmp) + Mat3x3(MatCross, MTmp));
 
         /* [ b2 x ] [ F x ] + [ M x ] */
 
         /* Lines 10->12: */
         WM.Sub(9 + 1, 3 + 1, Mat3x3(MatCrossCross, b2, FTmp) + Mat3x3(MatCross, MTmp));
 
         return WorkMat;
 }

Here is the call graph for this function:

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

virtual

Implements Elem.

Definition at line 3877 of file totalj.cc.

References VectorHandler::Add(), Vec3::Cross(), DEBUGCOUT, F, f2, FDrv, TplDriveOwner< T >::Get(), StructNode::GetRCurr(), StructDispNode::GetXCurr(), StructDispNode::iGetFirstMomentumIndex(), M, MDrv, pNode1, pNode2, SubVectorHandler::PutRowIndex(), R1h, R1hr, R2hr, VectorHandler::ResizeReset(), VectorHandler::Sub(), and WorkSpaceDim().

 {
         DEBUGCOUT("Entering TotalForce::AssRes()" << std::endl);
 
         /* Dimensiona e resetta la matrice di lavoro */
         integer iNumRows = 0;
         integer iNumCols = 0;
         WorkSpaceDim(&iNumRows, &iNumCols);
         WorkVec.ResizeReset(iNumRows);
 
         /* Indici */
         integer iNode1FirstMomIndex = pNode1->iGetFirstMomentumIndex();
         integer iNode2FirstMomIndex = pNode2->iGetFirstMomentumIndex();
 
         /* Indici dei nodi */
         for (int iCnt = 1; iCnt <= 6; iCnt++) {
                 WorkVec.PutRowIndex(iCnt, iNode1FirstMomIndex + iCnt);
                 WorkVec.PutRowIndex(6+iCnt, iNode2FirstMomIndex + iCnt);
         }
 
         /* Get Forces */
 
         F = FDrv.Get();
         M = MDrv.Get();
 
         Vec3 b2(pNode2->GetRCurr()*f2);
         Vec3 b1(pNode2->GetXCurr() + b2 - pNode1->GetXCurr());
 
         Mat3x3 R1 = pNode1->GetRCurr()*R1h;
         Mat3x3 R1r = pNode1->GetRCurr()*R1hr;
         Mat3x3 R2r = pNode2->GetRCurr()*R2hr;
 
         Vec3 FTmp(R1*F);
         Vec3 MTmp(R1r*M);
 
         /* Equilibrium, node 1 */
         WorkVec.Add(1, FTmp);
         WorkVec.Add(3 + 1, MTmp + b1.Cross(FTmp));
 
         /* Equilibrium, node 2 */
         WorkVec.Sub(6 + 1, FTmp);
         WorkVec.Sub(9 + 1, MTmp + b2.Cross(FTmp));
 
         return WorkVec;
 }

Here is the call graph for this function:

SubVectorHandler & TotalForce::AssRes	(	SubVectorHandler &	WorkVec,
		const VectorHandler &	,
		const VectorHandler &	,
		const VectorHandler &	,
		InverseDynamics::Order	iOrder = `InverseDynamics::INVERSE_DYNAMICS`
	)

virtual

Reimplemented from Elem.

Definition at line 3935 of file totalj.cc.

References VectorHandler::Add(), ASSERT, Vec3::Cross(), DEBUGCOUT, F, f2, FDrv, TplDriveOwner< T >::Get(), StructNode::GetRCurr(), StructDispNode::GetXCurr(), StructDispNode::iGetFirstPositionIndex(), invdyn2str(), InverseDynamics::INVERSE_DYNAMICS, M, MDrv, pNode1, pNode2, SubVectorHandler::PutRowIndex(), R1h, R1hr, R2hr, VectorHandler::ResizeReset(), VectorHandler::Sub(), and WorkSpaceDim().

 {
         DEBUGCOUT("Entering TotalForce::AssRes(" << invdyn2str(iOrder) << ")" << std::endl);
 
         ASSERT(iOrder == InverseDynamics::INVERSE_DYNAMICS);
 
         /* Dimensiona e resetta la matrice di lavoro */
         integer iNumRows = 0;
         integer iNumCols = 0;
         WorkSpaceDim(&iNumRows, &iNumCols);
         WorkVec.ResizeReset(iNumRows);
 
         /* Indici */
         integer iNode1FirstMomIndex = pNode1->iGetFirstPositionIndex();
         integer iNode2FirstMomIndex = pNode2->iGetFirstPositionIndex();
 
         /* Indici dei nodi */
         for (int iCnt = 1; iCnt <= 6; iCnt++) {
                 WorkVec.PutRowIndex(iCnt, iNode1FirstMomIndex + iCnt);
                 WorkVec.PutRowIndex(6+iCnt, iNode2FirstMomIndex + iCnt);
         }
 
         /* Get Forces */
 
         F = FDrv.Get();
         M = MDrv.Get();
 
         Vec3 b2(pNode2->GetRCurr()*f2);
         Vec3 b1(pNode2->GetXCurr() + b2 - pNode1->GetXCurr());
 
         Mat3x3 R1 = pNode1->GetRCurr()*R1h;
         Mat3x3 R1r = pNode1->GetRCurr()*R1hr;
         Mat3x3 R2r = pNode2->GetRCurr()*R2hr;
 
         Vec3 FTmp(R1*F);
         Vec3 MTmp(R1r*M);
 
         /* Equilibrium, node 1 */
         WorkVec.Add(1, FTmp);
         WorkVec.Add(3 + 1, MTmp + b1.Cross(FTmp));
 
         /* Equilibrium, node 2 */
         WorkVec.Sub(6 + 1, FTmp);
         WorkVec.Sub(9 + 1, MTmp + b2.Cross(FTmp));
 
         return WorkVec;
 }

Here is the call graph for this function:

bool TotalForce::bInverseDynamics ( void ) const

virtual

Reimplemented from Elem.

Definition at line 3928 of file totalj.cc.

 {
         return true;
 }

virtual Force::Type TotalForce::GetForceType ( void ) const

inlinevirtual

Implements Force.

Definition at line 515 of file totalj.h.

References Force::TOTALINTERNALFORCE.

                                                    {
                 return Force::TOTALINTERNALFORCE;
         };

VariableSubMatrixHandler & TotalForce::InitialAssJac	(	VariableSubMatrixHandler &	WorkMat,
		const VectorHandler &	XCurr
	)

virtual

Reimplemented from Force.

Definition at line 3989 of file totalj.cc.

References FullSubMatrixHandler::Add(), Vec3::Cross(), F, f2, StructNode::GetRCurr(), StructNode::GetRRef(), StructDispNode::GetVCurr(), StructNode::GetWCurr(), StructDispNode::GetXCurr(), StructDispNode::iGetFirstPositionIndex(), InitialWorkSpaceDim(), M, MatCross, MatCrossCross, pNode1, pNode2, FullSubMatrixHandler::PutColIndex(), FullSubMatrixHandler::PutRowIndex(), R1h, R1hr, FullSubMatrixHandler::ResizeReset(), VariableSubMatrixHandler::SetFull(), and FullSubMatrixHandler::Sub().

 {
 
         /* Per ora usa la matrice piena; eventualmente si puo'
          * passare a quella sparsa quando si ottimizza */
         FullSubMatrixHandler& WM = WorkMat.SetFull();
 
         /* Dimensiona e resetta la matrice di lavoro */
         integer iNumRows = 0;
         integer iNumCols = 0;
         InitialWorkSpaceDim(&iNumRows, &iNumCols);
         WM.ResizeReset(iNumRows, iNumCols);
 
         /* Indici */
         integer iNode1FirstPosIndex = pNode1->iGetFirstPositionIndex();
         integer iNode1FirstVelIndex = iNode1FirstPosIndex + 6;
         integer iNode2FirstPosIndex = pNode2->iGetFirstPositionIndex();
         integer iNode2FirstVelIndex = iNode2FirstPosIndex + 6;
 
 
         /* Setta gli indici dei nodi */
         for (int iCnt = 1; iCnt <= 6; iCnt++) {
                 WM.PutRowIndex(iCnt, iNode1FirstPosIndex + iCnt);
                 WM.PutColIndex(iCnt, iNode1FirstPosIndex + iCnt);
                 WM.PutRowIndex(6 + iCnt, iNode1FirstVelIndex + iCnt);
                 WM.PutColIndex(6 + iCnt, iNode1FirstVelIndex + iCnt);
                 WM.PutRowIndex(12 + iCnt, iNode2FirstPosIndex + iCnt);
                 WM.PutColIndex(12 + iCnt, iNode2FirstPosIndex + iCnt);
                 WM.PutRowIndex(18 + iCnt, iNode2FirstVelIndex + iCnt);
                 WM.PutColIndex(18 + iCnt, iNode2FirstVelIndex + iCnt);
         }
 
         /* Recupera i dati che servono */
         Mat3x3 R1(pNode1->GetRRef()*R1h);
         Mat3x3 R1r(pNode1->GetRRef()*R1hr);
 
         Vec3 b2(pNode2->GetRCurr()*f2);
         Vec3 b1(pNode2->GetXCurr() + b2 - pNode1->GetXCurr());
 
         Vec3 Omega1(pNode1->GetWCurr());
         Vec3 Omega2(pNode2->GetWCurr());
 
         Vec3 b1Prime(pNode2->GetVCurr() + Omega2.Cross(b2) - pNode1->GetVCurr());
 
         Vec3 FTmp(R1*F);
         Vec3 MTmp(R1r*M);
 
         Mat3x3 Tmp;
 
         /* [ F x ] */
         Tmp = Mat3x3(MatCross, FTmp);
 
         /* Force, Node 1, Lines 1->3: */
         WM.Add(1, 3 + 1, Tmp);  // * Delta_g1
 
         /* Moment, Node 1, Lines 4->6: */
         WM.Sub(3 + 1, 1, Tmp);  // * Delta_x1
 
         WM.Add(3 + 1, 12 + 1, Tmp);     // * Delta_x2
 
         /* Force, Node 2, Lines 13->15: */
         WM.Sub(12 + 1, 3 + 1, Tmp);     // * Delta_g1
 
         /* [ F x ] [ b2 x ] */
         Tmp = Mat3x3(MatCrossCross, FTmp, b2);
 
         /* Moment, Node1, Lines 4->6: */
         WM.Sub(3 + 1, 15 + 1, Tmp);     // * Delta_g2
 
         /* Moment, Node2, Lines 16->18: */
         WM.Add(15 + 1, 15 + 1, Tmp);    // * Delta_g2
 
         /* [ b1 x ] [ F x ] + [ M x ] */
 
         /* Moment, Node1, Lines 4->6: */
         WM.Add(3 + 1, 3 + 1, Mat3x3(MatCrossCross, b1, FTmp) + Mat3x3(MatCross, MTmp)); // *Delta_g1
 
         /* [ b2 x ] [ F x ] + [ M x ] */
 
         /* Moment, Node2, Lines 16->18: */
         WM.Sub(15 + 1, 3 + 1, Mat3x3(MatCrossCross, b2, FTmp) + Mat3x3(MatCross, MTmp));        // * Delta_g1
 
         /* d/dt(Moment), Node2, Lines 22->24: */
         WM.Sub(21 + 1, 9 + 1, Mat3x3(MatCrossCross, b2, FTmp) + Mat3x3(MatCross, MTmp));        // * Delta_W1
 
         return WorkMat;
 }

Here is the call graph for this function:

SubVectorHandler & TotalForce::InitialAssRes	(	SubVectorHandler &	WorkVec,
		const VectorHandler &	XCurr
	)

virtual

Implements SubjectToInitialAssembly.

Definition at line 4081 of file totalj.cc.

References VectorHandler::Add(), Vec3::Cross(), DEBUGCOUT, F, f2, FDrv, TplDriveOwner< T >::Get(), StructNode::GetRCurr(), StructNode::GetRRef(), StructDispNode::GetVCurr(), StructNode::GetWCurr(), StructDispNode::GetXCurr(), StructDispNode::iGetFirstPositionIndex(), InitialWorkSpaceDim(), M, MDrv, pNode1, pNode2, SubVectorHandler::PutRowIndex(), R1h, R1hr, R2hr, VectorHandler::ResizeReset(), and VectorHandler::Sub().

 {
 
         DEBUGCOUT("Entering TotalForce::InitialAssRes()" << std::endl);
 
         /* Dimensiona e resetta la matrice di lavoro */
         integer iNumRows = 0;
         integer iNumCols = 0;
         InitialWorkSpaceDim(&iNumRows, &iNumCols);
         WorkVec.ResizeReset(iNumRows);
 
         /* Indici */
         integer iNode1FirstPosIndex = pNode1->iGetFirstPositionIndex();
         integer iNode1FirstVelIndex = iNode1FirstPosIndex + 6;
         integer iNode2FirstPosIndex = pNode2->iGetFirstPositionIndex();
         integer iNode2FirstVelIndex = iNode2FirstPosIndex + 6;
 
         /* Setta gli indici */
         for (int iCnt = 1; iCnt <= 6; iCnt++) {
                 WorkVec.PutRowIndex(iCnt, iNode1FirstPosIndex+iCnt);
                 WorkVec.PutRowIndex(6 + iCnt, iNode1FirstVelIndex + iCnt);
                 WorkVec.PutRowIndex(12 + iCnt, iNode2FirstPosIndex + iCnt);
                 WorkVec.PutRowIndex(18 + iCnt, iNode2FirstVelIndex + iCnt);
         }
 
         /* Recupera i dati */
         /* Recupera i dati che servono */
         Mat3x3 R1(pNode1->GetRRef()*R1h);
         Mat3x3 R1r(pNode1->GetRRef()*R1hr);
         Mat3x3 R2r(pNode2->GetRCurr()*R2hr);
 
         Vec3 b2(pNode2->GetRCurr()*f2);
         Vec3 b1(pNode2->GetXCurr() + b2 - pNode1->GetXCurr());
 
         Vec3 Omega1(pNode1->GetWCurr());
         Vec3 Omega2(pNode2->GetWCurr());
 
         Vec3 b1Prime(pNode2->GetVCurr() + Omega2.Cross(b2) - pNode1->GetVCurr());
 
         /* Aggiorna F ed M, che restano anche per InitialAssJac */
 
         F = FDrv.Get();
         M = MDrv.Get();
 
         Vec3 FTmp(R1*F);
         Vec3 MTmp(R1r*M);
 
         /* Equilibrium, node 1 */
         WorkVec.Add(1, FTmp);
         WorkVec.Add(3 + 1, b1.Cross(FTmp) + MTmp);
 
         /* Equilibrium, node 2 */
         WorkVec.Sub(12 + 1, FTmp);
         WorkVec.Sub(15 + 1, b2.Cross(FTmp) + MTmp);
 
         return WorkVec;
 }

Here is the call graph for this function:

virtual void TotalForce::InitialWorkSpaceDim	(	integer *	piNumRows,
		integer *	piNumCols
	)		const

inlinevirtual

Implements SubjectToInitialAssembly.

Definition at line 548 of file totalj.h.

Referenced by InitialAssJac(), and InitialAssRes().

                                                                                        {
                 *piNumRows = 24;
                 *piNumCols = 12;
         };

void TotalForce::Output ( OutputHandler & OH ) const

virtual

Reimplemented from ToBeOutput.

Definition at line 3767 of file totalj.cc.

References ToBeOutput::bToBeOutput(), F, OutputHandler::Forces(), WithLabel::GetLabel(), and M.

 {
         if (bToBeOutput()) {
                 OH.Forces() << std::setw(8) << GetLabel()
                         << " " << F << " " << M << std::endl;
         }
 }

Here is the call graph for this function:

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

virtual

Implements Elem.

Definition at line 3776 of file totalj.cc.

References f1, f2, FDrv, WithLabel::GetLabel(), MDrv, TplDriveOwner< T >::pGetDriveCaller(), pNode1, pNode2, R1h, R1hr, R2h, R2hr, TplDriveCaller< T >::Restart(), Force::Restart(), Vec3::Write(), and Mat3x3::Write().

 {
         Force::Restart(out) << ", total internal, "
                 << pNode1->GetLabel() << ", "
                 "position, ", f1.Write(out, ", ") << ", "
                 "force orientation, ", R1h.Write(out, ", ") << ", "
                 "moment orientation, ", R1hr.Write(out, ", ") << ", "
                 << pNode2->GetLabel() << ", "
                 "position, ", f2.Write(out, ", ") << ", "
                 "force orientation, ", R2h.Write(out, ", ") << ", "
                 "moment orientation, ", R2hr.Write(out, ", ") << ", "
                 "force, ", FDrv.pGetDriveCaller()->Restart(out) << ", "
                 "moment , ", MDrv.pGetDriveCaller()->Restart(out) << ";"
                 << std::endl;
         return out;
 }

Here is the call graph for this function:

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

inlinevirtual

Implements Elem.

Definition at line 521 of file totalj.h.

Referenced by AssJac(), and AssRes().

                                                                         {
                 *piNumRows = 12;
                 *piNumCols = 6;
         };