#include <beam2.h>

Inheritance diagram for ViscoElasticBeam2:

Collaboration diagram for ViscoElasticBeam2:

Public Member Functions
	ViscoElasticBeam2 (unsigned int uL, const StructNode pN1, const StructNode pN2, const Vec3 &F1, const Vec3 &F2, const Mat3x3 &R1, const Mat3x3 &R2, const Mat3x3 &r, const ConstitutiveLaw6D *pd, OrientationDescription ood, flag fOut)

virtual	~ViscoElasticBeam2 (void)

virtual Beam::Type	GetBeamType (void) const

void	SetValue (DataManager pDM, VectorHandler &, VectorHandler &, SimulationEntity::Hints ph=0)

virtual void	AfterPredict (VectorHandler &, VectorHandler &)

virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP)

virtual doublereal	dGetPrivData (unsigned int i) const

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 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	Update (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	DerivativesUpdate (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

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	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 Beam2
	Beam2 (unsigned int uL, const StructNode pN1, const StructNode pN2, const Vec3 &F1, const Vec3 &F2, const Mat3x3 &R1, const Mat3x3 &R2, const Mat3x3 &r, const ConstitutiveLaw6D *pd, OrientationDescription ood, flag fOut)

virtual	~Beam2 (void)

virtual Elem::Type	GetElemType (void) const

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

virtual void	WorkSpaceDim (integer piNumRows, integer piNumCols) const

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

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

virtual void	OutputPrepare (OutputHandler &OH)

virtual void	Output (OutputHandler &OH) const

virtual bool	bInverseDynamics (void) const

VariableSubMatrixHandler &	AssJac (VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)

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

void	Update (const VectorHandler &XCurr, InverseDynamics::Order iOrder=InverseDynamics::INVERSE_DYNAMICS)

virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP, const VectorHandler &XPP)

virtual unsigned int	iGetInitialNumDof (void) const

virtual void	InitialWorkSpaceDim (integer piNumRows, integer piNumCols) const

virtual void	SetInitialValue (VectorHandler &)

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

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

virtual unsigned int	iGetNumPrivData (void) const

virtual unsigned int	iGetPrivDataIdx (const char *s) const

virtual const StructNode *	pGetNode (unsigned int i) const

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

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

virtual	~ElemGravityOwner (void)

virtual doublereal	dGetM (void) const

Vec3	GetS (void) const

Mat3x3	GetJ (void) const

Vec3	GetB (void) const

Vec3	GetG (void) const

Public Member Functions inherited from GravityOwner
	GravityOwner (void)

virtual	~GravityOwner (void)

void	PutGravity (const Gravity *pG)

virtual bool	bGetGravity (const Vec3 &X, Vec3 &Acc) 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)

Protected Member Functions
virtual void	AssStiffnessMat (FullSubMatrixHandler &WMA, FullSubMatrixHandler &WMB, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

virtual void	AssStiffnessVec (SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)

Protected Member Functions inherited from Beam2
virtual Vec3	InterpState (const Vec3 &v1, const Vec3 &v2)

virtual Vec3	InterpDeriv (const Vec3 &v1, const Vec3 &v2)

virtual void	AddInternalForces (Vec6 &)

virtual void	AssInertiaMat (FullSubMatrixHandler &, FullSubMatrixHandler &, doublereal, const VectorHandler &, const VectorHandler &)

virtual void	AssInertiaVec (SubVectorHandler &, doublereal, const VectorHandler &, const VectorHandler &)

virtual void	DsDxi (void)

virtual void	Omega0 (void)

void	SetBeamType (Beam::Type T)

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

Protected Member Functions inherited from ElemGravityOwner
virtual Vec3	GetS_int (void) const

virtual Mat3x3	GetJ_int (void) const

virtual Vec3	GetB_int (void) const

virtual Vec3	GetG_int (void) const

Protected Attributes
Vec3	LPrime

Vec3	gPrime

Vec3	LPrimeRef

Vec6	DefPrimeLocRef

Mat6x6	ERef

Protected Attributes inherited from WithLabel
unsigned int	uLabel

std::string	sName

Protected Attributes inherited from ToBeOutput
flag	fOutput

Protected Attributes inherited from Beam2
unsigned	uOutputFlags

OrientationDescription	od

const StructNode *	pNode [NUMNODES]

Vec3	f [NUMNODES]

Vec3	fRef [NUMNODES]

Mat3x3	RNode [NUMNODES]

Mat3x3	R

Mat3x3	RRef

Mat3x3	RPrev

ConstitutiveLaw6DOwner *	pD

Mat6x6	DRef

Vec3	Omega

Vec3	OmegaRef

Vec6	Az

Vec6	AzRef

Vec6	AzLoc

Vec6	DefLoc

Vec6	DefLocRef

Vec6	DefLocPrev

Vec6	DefPrimeLoc

Vec3	p

Vec3	g

Vec3	L0

Vec3	L

Vec3	LRef

doublereal	dsdxi

bool	bFirstRes

bool	bFirstIDRes

Protected Attributes inherited from GravityOwner
Gravity *	pGravity

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 }

Protected Types inherited from Beam2
enum	NodeName { NODE1 = 0, NODE2 = 1, NUMNODES = 2 }

enum	Deformations { STRAIN = 0, CURVAT = 1, NUMDEFORM = 2 }

Detailed Description

Definition at line 363 of file beam2.h.

Constructor & Destructor Documentation

ViscoElasticBeam2::ViscoElasticBeam2	(	unsigned int	uL,
		const StructNode *	pN1,
		const StructNode *	pN2,
		const Vec3 &	F1,
		const Vec3 &	F2,
		const Mat3x3 &	R1,
		const Mat3x3 &	R2,
		const Mat3x3 &	r,
		const ConstitutiveLaw6D *	pd,
		OrientationDescription	ood,
		flag	fOut
	)

Definition at line 945 of file beam2.cc.

References Beam2::DefPrimeLoc, DefPrimeLocRef, ERef, ConstitutiveLawOwner< T, Tder >::GetFDEPrime(), gPrime, LPrime, LPrimeRef, MultRMRt(), Beam2::Omega, Beam2::Omega0(), Beam2::OmegaRef, Beam2::pD, Beam2::RRef, Zero3, and Zero6.

 : Elem(uL, fOut),
 Beam2(uL, pN1, pN2, F1, F2, R1, R2, r, pd, ood, fOut)
 {
         LPrimeRef = LPrime = Zero3;
         gPrime = Zero3;
 
         DefPrimeLoc = DefPrimeLocRef = Zero6;
 
         /* Nota: DsDxi() viene chiamata dal costruttore di Beam */
         Beam2::Omega0();
 
         OmegaRef = Omega;
         ERef = MultRMRt(pD->GetFDEPrime(), RRef);
 }

Here is the call graph for this function:

virtual ViscoElasticBeam2::~ViscoElasticBeam2 ( void )

inlinevirtual

Definition at line 407 of file beam2.h.

References NO_OP.

                                      {
         NO_OP;
     };

Member Function Documentation

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

virtual

Reimplemented from Beam2.

Definition at line 972 of file beam2.cc.

References ConstitutiveLawOwner< T, Tder >::AfterConvergence(), Beam2::DefLoc, Beam2::DefLocPrev, Beam2::DefPrimeLoc, Beam2::pD, Beam2::R, and Beam2::RPrev.

 {
         RPrev = R;
         DefLocPrev = DefLoc;
         pD->AfterConvergence(DefLoc, DefPrimeLoc);
 }

Here is the call graph for this function:

void ViscoElasticBeam2::AfterPredict	(	VectorHandler &	,
		VectorHandler &
	)

virtual

Reimplemented from Beam2.

Reimplemented in PiezoActuatorVEBeam2.

Definition at line 1221 of file beam2.cc.

References Beam2::AddInternalForces(), Beam2::Az, Beam2::AzLoc, Beam2::AzRef, Beam2::bFirstRes, Vec3::Cross(), grad::Cross(), Beam2::DefLoc, Beam2::DefLocPrev, Beam2::DefLocRef, Beam2::DefPrimeLoc, DefPrimeLocRef, Beam2::DRef, ERef, Beam2::f, Beam2::g, ConstitutiveLawOwner< T, Tder >::GetF(), ConstitutiveLawOwner< T, Tder >::GetFDE(), ConstitutiveLawOwner< T, Tder >::GetFDEPrime(), StructNode::GetgPRef(), StructNode::GetgRef(), StructNode::GetRRef(), StructDispNode::GetVCurr(), Vec6::GetVec2(), StructNode::GetWRef(), StructDispNode::GetXCurr(), gPrime, Beam2::InterpDeriv(), Beam2::InterpState(), Beam2::L, Beam2::L0, LPrime, LPrimeRef, Beam2::LRef, CGR_Rot::MatG, CGR_Rot::MatR, MultRMRt(), MultRV(), Mat3x3::MulTV(), Beam2::NODE1, Beam2::NODE2, Beam2::NUMNODES, Beam2::Omega, Beam2::OmegaRef, Beam2::p, Beam2::pD, Beam2::pNode, Beam2::R, Beam2::RPrev, Beam2::RRef, and ConstitutiveLawOwner< T, Tder >::Update().

Referenced by PiezoActuatorVEBeam2::AfterPredict().

 {
         /*
          * Calcola le deformazioni, aggiorna il legame costitutivo
          * e crea la FDE
          */
 
         /* Recupera i dati dei nodi */
         Vec3   gNod[NUMNODES];
         Vec3   xTmp[NUMNODES];
 
         Vec3   gPrimeNod[NUMNODES];
         Vec3   xPrimeTmp[NUMNODES];
 
         for (unsigned int i = 0; i < NUMNODES; i++) {
                 gNod[i] = pNode[i]->GetgRef();
                 Vec3 fTmp = pNode[i]->GetRRef()*f[i];
                 xTmp[i] = pNode[i]->GetXCurr() + fTmp;
                 gPrimeNod[i] = pNode[i]->GetgPRef();
                 xPrimeTmp[i] = pNode[i]->GetVCurr()
                         + pNode[i]->GetWRef().Cross(fTmp);
         }
 
         Mat3x3 RDelta;
         Vec3 gGrad;
         Vec3 gPrimeGrad;
 
         /* Aggiorna le grandezze della trave nel punto di valutazione */
         /* Posizione */
         p = InterpState(xTmp[NODE1], xTmp[NODE2]);
 
         /* Matrici di rotazione */
         g = InterpState(gNod[NODE1], gNod[NODE2]);
         RDelta = Mat3x3(CGR_Rot::MatR, g);
         R = RRef = RDelta*RPrev;
 
         /* Velocita' angolare della sezione */
         gPrime = InterpState(gPrimeNod[NODE1], gPrimeNod[NODE2]);
         Omega = OmegaRef = Mat3x3(CGR_Rot::MatG, g)*gPrime;
 
         /* Derivate della posizione */
         L = LRef = InterpDeriv(xTmp[NODE1], xTmp[NODE2]);
 
         /* Derivate della velocita' */
         LPrime = LPrimeRef = InterpDeriv(xPrimeTmp[NODE1], xPrimeTmp[NODE2]);
 
         /* Derivate dei parametri di rotazione */
         gGrad = InterpDeriv(gNod[NODE1], gNod[NODE2]);
 
         /* Derivate delle derivate spaziali dei parametri di rotazione */
         gPrimeGrad = InterpDeriv(gPrimeNod[NODE1], gPrimeNod[NODE2]);
 
         /*
          * Calcola le deformazioni nel sistema locale nel punto di valutazione
          */
         DefLoc = DefLocRef = Vec6(R.MulTV(L) - L0,
                 R.MulTV(Mat3x3(CGR_Rot::MatG, g)*gGrad) + DefLocPrev.GetVec2());
 
         /*
          * Calcola le velocita' di deformazione nel sistema locale
          * nel punto di valutazione
          */
         DefPrimeLoc = DefPrimeLocRef = Vec6(R.MulTV(LPrime + L.Cross(Omega)),
                 R.MulTV(Mat3x3(CGR_Rot::MatG, g)*gPrimeGrad
                 + (Mat3x3(CGR_Rot::MatG, g)*gGrad).Cross(Omega)));
 
         /* Calcola le azioni interne */
         pD->Update(DefLoc, DefPrimeLoc);
         AzLoc = pD->GetF();
 
         /* corregge le azioni interne locali (piezo, ecc) */
         AddInternalForces(AzLoc);
 
         /* Porta le azioni interne nel sistema globale */
         Az = AzRef = MultRV(AzLoc, R);
 
         /* Aggiorna il legame costitutivo */
         DRef = MultRMRt(pD->GetFDE(), R);
         ERef = MultRMRt(pD->GetFDEPrime(), R);
 
         bFirstRes = true;
 }

Here is the call graph for this function:

void ViscoElasticBeam2::AssStiffnessMat	(	FullSubMatrixHandler &	WMA,
		FullSubMatrixHandler &	WMB,
		doublereal	dCoef,
		const VectorHandler &	XCurr,
		const VectorHandler &	XPrimeCurr
	)

protectedvirtual

Reimplemented from Beam2.

Reimplemented in PiezoActuatorVEBeam2.

Definition at line 983 of file beam2.cc.

References FullSubMatrixHandler::Add(), Beam2::Az, Vec3::Cross(), grad::Cross(), DEBUGCOUTFNAME, dN2, dN2P, Beam2::DRef, Beam2::dsdxi, ERef, Beam2::f, StructNode::GetRCurr(), Vec6::GetVec1(), Vec6::GetVec2(), StructDispNode::GetXCurr(), Beam2::L, LPrime, MatCross, MatCrossCross, mb_deye< Mat3x3 >(), Beam2::NODE1, Beam2::NODE2, Beam2::NUMNODES, Beam2::Omega, Beam2::p, Beam2::pNode, FullSubMatrixHandler::Sub(), Mat6x6::SubMat12(), Mat6x6::SubMat22(), and Zero3x3.

Referenced by PiezoActuatorVEBeam2::AssStiffnessMat().

 {
         DEBUGCOUTFNAME("ViscoElasticBeam2::AssStiffnessMat");
 
         /*
          * La matrice arriva gia' dimensionata
          * e con gli indici di righe e colonne a posto
          */
 
         /* offset nel riferimento globale */
         Vec3 fTmp[NUMNODES];
         for (unsigned int i = 0; i < NUMNODES; i++) {
                 fTmp[i] = pNode[i]->GetRCurr()*f[i];
         }
 
         Mat6x6 AzTmp[NUMNODES];
         Mat6x6 AzPrimeTmp[NUMNODES];
 
         for (unsigned int i = 0; i < NUMNODES; i++) {
                 /* Delta - deformazioni */
                 AzTmp[i] = AzPrimeTmp[i] = Mat6x6(mb_deye<Mat3x3>(dN2P[i]*dsdxi),
                                 Zero3x3,
                                 Mat3x3(MatCross, L*dN2[i] - fTmp[i]*(dN2P[i]*dsdxi)),
                                 mb_deye<Mat3x3>(dN2P[i]*dsdxi));
 
                 AzTmp[i] = DRef*AzTmp[i]*dCoef;
 
                 AzTmp[i] += ERef*Mat6x6(Mat3x3(MatCross, Omega*(-dN2P[i]*dsdxi*dCoef)),
                                 Zero3x3,
                                 (Mat3x3(MatCross, LPrime) - Mat3x3(MatCrossCross, Omega, L))*(dN2[i]*dCoef)
                                         + Mat3x3(MatCrossCross, Omega, fTmp[i]*(dN2P[i]*dsdxi*dCoef))
                                         + Mat3x3(MatCross, fTmp[i].Cross(pNode[i]->GetWCurr()*(dN2P[i]*dsdxi*dCoef))),
                                 Mat3x3(MatCross, Omega*(-dN2P[i]*dsdxi*dCoef)));
 
                 AzPrimeTmp[i] = ERef*AzPrimeTmp[i];
 
                 /* Correggo per la rotazione da locale a globale */
                 AzTmp[i].SubMat12(Mat3x3(MatCross, Az.GetVec1()*(dN2[i]*dCoef)));
                 AzTmp[i].SubMat22(Mat3x3(MatCross, Az.GetVec2()*(dN2[i]*dCoef)));
         }
 
         Vec3 bTmp[NUMNODES];
 
         bTmp[NODE1] = p-pNode[NODE1]->GetXCurr();
         bTmp[NODE2] = p-pNode[NODE2]->GetXCurr();
 
         for (unsigned int i = 0; i < NUMNODES; i++) {
                 /* Equazione all'indietro: */
                 WMA.Sub(1, 6*i + 1, AzTmp[i].GetMat11());
                 WMA.Sub(1, 6*i + 4, AzTmp[i].GetMat12());
 
                 WMA.Sub(4, 6*i + 1,
                                 AzTmp[i].GetMat21()
                                 - Mat3x3(MatCross, Az.GetVec1()*(dCoef*dN2[i]))
                                 + bTmp[NODE1].Cross(AzTmp[i].GetMat11()));
                 WMA.Sub(4, 6*i + 4,
                                 AzTmp[i].GetMat22()
                                 - Mat3x3(MatCrossCross, Az.GetVec1()*(-dCoef*dN2[i]), fTmp[i])
                                 + bTmp[NODE1].Cross(AzTmp[i].GetMat12()));
 
                 /* Equazione in avanti: */
                 WMA.Add(7, 6*i + 1, AzTmp[i].GetMat11());
                 WMA.Add(7, 6*i + 4, AzTmp[i].GetMat12());
 
                 WMA.Add(10, 6*i + 1,
                                 AzTmp[i].GetMat21()
                                 - Mat3x3(MatCross, Az.GetVec1()*(dCoef*dN2[i]))
                                 + bTmp[NODE2].Cross(AzTmp[i].GetMat11()));
                 WMA.Add(10, 6*i + 4,
                                 AzTmp[i].GetMat22()
                                 + Mat3x3(MatCrossCross, Az.GetVec1()*(dCoef*dN2[i]), fTmp[i])
                                 + bTmp[NODE2].Cross(AzTmp[i].GetMat12()));
 
                 /* Equazione viscosa all'indietro: */
                 WMB.Sub(1, 6*i + 1, AzPrimeTmp[i].GetMat11());
                 WMB.Sub(1, 6*i + 4, AzPrimeTmp[i].GetMat12());
 
                 WMB.Sub(4, 6*i + 1,
                                 AzPrimeTmp[i].GetMat21()
                                 + bTmp[NODE1].Cross(AzPrimeTmp[i].GetMat11()));
                 WMB.Sub(4, 6*i + 4,
                                 AzPrimeTmp[i].GetMat22()
                                 + bTmp[NODE1].Cross(AzPrimeTmp[i].GetMat12()));
 
                 /* Equazione viscosa in avanti: */
                 WMB.Add(7, 6*i + 1, AzPrimeTmp[i].GetMat11());
                 WMB.Add(7, 6*i + 4, AzPrimeTmp[i].GetMat12());
 
                 WMB.Add(10, 6*i + 1,
                                 AzPrimeTmp[i].GetMat21()
                                 + bTmp[NODE2].Cross(AzPrimeTmp[i].GetMat11()));
                 WMB.Add(10, 6*i + 4,
                                 AzPrimeTmp[i].GetMat22()
                                 + bTmp[NODE2].Cross(AzPrimeTmp[i].GetMat12()));
         }
 
         /* correzione alle equazioni */
         Mat3x3 FTmp(MatCross, Az.GetVec1()*dCoef);
         WMA.Sub(4, 1, FTmp);
         WMA.Add(10, 7, FTmp);
 };

Here is the call graph for this function:

void ViscoElasticBeam2::AssStiffnessVec	(	SubVectorHandler &	WorkVec,
		doublereal	dCoef,
		const VectorHandler &	XCurr,
		const VectorHandler &	XPrimeCurr
	)

protectedvirtual

Reimplemented from Beam2.

Reimplemented in PiezoActuatorVEBeam2.

Definition at line 1092 of file beam2.cc.

References VectorHandler::Add(), Beam2::AddInternalForces(), Beam2::Az, Beam2::AzLoc, Beam2::bFirstRes, Vec3::Cross(), grad::Cross(), DEBUGCOUTFNAME, Beam2::DefLoc, Beam2::DefLocRef, Beam2::DefPrimeLoc, DefPrimeLocRef, Beam2::f, Beam2::g, ConstitutiveLawOwner< T, Tder >::GetF(), StructNode::GetgCurr(), StructNode::GetgPCurr(), StructNode::GetRCurr(), StructDispNode::GetVCurr(), Vec6::GetVec1(), Vec6::GetVec2(), StructNode::GetWCurr(), StructDispNode::GetXCurr(), gPrime, Beam2::InterpDeriv(), Beam2::InterpState(), Beam2::L, Beam2::L0, LPrime, CGR_Rot::MatG, CGR_Rot::MatR, MultRV(), Mat3x3::MulTV(), Beam2::NODE1, Beam2::NODE2, Beam2::NUMNODES, Beam2::Omega, Beam2::OmegaRef, Beam2::p, Beam2::pD, Beam2::pNode, Beam2::R, Beam2::RRef, VectorHandler::Sub(), and ConstitutiveLawOwner< T, Tder >::Update().

Referenced by PiezoActuatorVEBeam2::AssStiffnessVec().

 {
         DEBUGCOUTFNAME("ViscoElasticBeam2::AssStiffnessVec");
 
         /*
          * Riceve il vettore gia' dimensionato e con gli indici a posto
          * per scrivere il residuo delle equazioni di equilibrio dei due nodi
          */
 
         /*
          * Per la trattazione teorica, il riferimento e' il file ul-travi.tex
          * (ora e' superato)
          */
 
         if (bFirstRes) {
                 bFirstRes = false; /* AfterPredict ha gia' calcolato tutto */
 
         } else {
                 Vec3 gNod[NUMNODES];
                 Vec3 xTmp[NUMNODES];
 
                 Vec3 gPrimeNod[NUMNODES];
                 Vec3 xPrimeTmp[NUMNODES];
 
                 for (unsigned int i = 0; i < NUMNODES; i++) {
                         gNod[i] = pNode[i]->GetgCurr();
                         Vec3 fTmp = pNode[i]->GetRCurr()*f[i];
                         xTmp[i] = pNode[i]->GetXCurr() + fTmp;
                         gPrimeNod[i] = pNode[i]->GetgPCurr();
                         xPrimeTmp[i] = pNode[i]->GetVCurr()
                                 + pNode[i]->GetWCurr().Cross(fTmp);
                 }
 
                 Mat3x3 RDelta;
                 Vec3 gGrad;
                 Vec3 gPrimeGrad;
 
                 /*
                  * Aggiorna le grandezze della trave nel punto di valutazione
                  */
 
                 /* Posizione */
                 p = InterpState(xTmp[NODE1], xTmp[NODE2]);
 
                 /* Matrici di rotazione */
                 g = InterpState(gNod[NODE1], gNod[NODE2]);
                 RDelta = Mat3x3(CGR_Rot::MatR, g);
                 R = RDelta*RRef;
 
                 /* Velocita' angolare della sezione */
                 gPrime = InterpState(gPrimeNod[NODE1], gPrimeNod[NODE2]);
                 Omega = Mat3x3(CGR_Rot::MatG, g)*gPrime + RDelta*OmegaRef;
 
                 /* Derivate della posizione */
                 L = InterpDeriv(xTmp[NODE1], xTmp[NODE2]);
 
                 /* Derivate della velocita' */
                 LPrime = InterpDeriv(xPrimeTmp[NODE1], xPrimeTmp[NODE2]);
 
                 /* Derivate dei parametri di rotazione */
                 gGrad = InterpDeriv(gNod[NODE1], gNod[NODE2]);
 
                 /*
                  * Derivate delle derivate spaziali dei parametri di rotazione
                  */
                 gPrimeGrad = InterpDeriv(gPrimeNod[NODE1], gPrimeNod[NODE2]);
 
                 /*
                  * Calcola le deformazioni nel sistema locale nel punto
                  * di valutazione
                  */
                 DefLoc = Vec6(R.MulTV(L) - L0,
                         R.MulTV(Mat3x3(CGR_Rot::MatG, g)*gGrad) + DefLocRef.GetVec2());
 
                 /*
                  * Calcola le velocita' di deformazione nel sistema locale
                  * nel punto di valutazione
                  */
                 DefPrimeLoc = Vec6(R.MulTV(LPrime + L.Cross(Omega)),
                         R.MulTV(Mat3x3(CGR_Rot::MatG, g)*gPrimeGrad
                         + (Mat3x3(CGR_Rot::MatG, g)*gGrad).Cross(Omega))
                         + DefPrimeLocRef.GetVec2());
 
                 /* Calcola le azioni interne */
                 pD->Update(DefLoc, DefPrimeLoc);
                 AzLoc = pD->GetF();
 
                 /* corregge le azioni interne locali (piezo, ecc) */
                 AddInternalForces(AzLoc);
 
                 /* Porta le azioni interne nel sistema globale */
                 Az = MultRV(AzLoc, R);
         }
 
         WorkVec.Add(1, Az.GetVec1());
         WorkVec.Add(4, (p - pNode[NODE1]->GetXCurr()).Cross(Az.GetVec1()) + Az.GetVec2());
         WorkVec.Sub(7, Az.GetVec1());
         WorkVec.Sub(10, Az.GetVec2() + (p - pNode[NODE2]->GetXCurr()).Cross(Az.GetVec1()));
 }

Here is the call graph for this function:

doublereal ViscoElasticBeam2::dGetPrivData ( unsigned int i ) const

virtual

Reimplemented from Beam2.

Definition at line 1306 of file beam2.cc.

References ASSERT, Beam2::DefPrimeLoc, Vec6::dGet(), Beam2::dGetPrivData(), and Beam2::iGetNumPrivData().

 {
         ASSERT(i > 0 && i <= iGetNumPrivData());
 
         switch (i) {
         case 22:
         case 23:
         case 24:
         case 25:
         case 26:
         case 27:
                 return DefPrimeLoc.dGet(i - 21);
 
         default:
                 return Beam2::dGetPrivData(i);
         }
 }

Here is the call graph for this function:

virtual Beam::Type ViscoElasticBeam2::GetBeamType ( void ) const

inlinevirtual

Reimplemented from Beam2.

Reimplemented in PiezoActuatorVEBeam2.

Definition at line 412 of file beam2.h.

References Beam::VISCOELASTIC.

                                              {
         return Beam::VISCOELASTIC;
     };

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

virtual

Reimplemented from Beam2.

Reimplemented in PiezoActuatorVEBeam2.

Definition at line 1198 of file beam2.cc.

References ASSERT, Beam2::bFirstRes, Beam2::DefPrimeLoc, DefPrimeLocRef, ERef, ConstitutiveLawOwner< T, Tder >::GetFDEPrime(), LPrime, LPrimeRef, MultRMRt(), Beam2::Omega, Beam2::OmegaRef, Beam2::pD, Beam2::RRef, and Beam2::SetValue().

Referenced by PiezoActuatorVEBeam2::SetValue().

 {
         Beam2::SetValue(pDM, X, XP, ph);
 
         /* Aggiorna le grandezze della trave nei punti di valutazione */
         OmegaRef = Omega;
         LPrimeRef = LPrime;
         DefPrimeLocRef = DefPrimeLoc;
 
         /*
          * Aggiorna il legame costitutivo di riferimento
          * (la deformazione e' gia' stata aggiornata dall'ultimo residuo)
          */
         ERef = MultRMRt(pD->GetFDEPrime(), RRef);
 
         ASSERT(bFirstRes == true);
 }