#include <beam.h>

Inheritance diagram for ViscoElasticBeam:

Collaboration diagram for ViscoElasticBeam:

Public Member Functions
	ViscoElasticBeam (unsigned int uL, const StructNode pN1, const StructNode pN2, const StructNode pN3, const Vec3 &F1, const Vec3 &F2, const Vec3 &F3, const Mat3x3 &R1, const Mat3x3 &R2, const Mat3x3 &R3, const Mat3x3 &r_I, const Mat3x3 &rII, const ConstitutiveLaw6D pD_I, const ConstitutiveLaw6D *pDII, OrientationDescription ood, flag fOut)

	ViscoElasticBeam (unsigned int uL, const StructNode pN1, const StructNode pN2, const StructNode pN3, const Vec3 &F1, const Vec3 &F2, const Vec3 &F3, const Mat3x3 &R1, const Mat3x3 &R2, const Mat3x3 &R3, const Mat3x3 &r_I, const Mat3x3 &rII, const ConstitutiveLaw6D pD_I, const ConstitutiveLaw6D *pDII, doublereal dM_I, const Vec3 &s0_I, const Mat3x3 &j0_I, doublereal dMII, const Vec3 &s0II, const Mat3x3 &j0II, OrientationDescription ood, flag fOut)

virtual	~ViscoElasticBeam (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 void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP, const VectorHandler &XPP)

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

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

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 void	Update (const VectorHandler &XCurr, InverseDynamics::Order iOrder)

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 Beam
	Beam (unsigned int uL, const StructNode pN1, const StructNode pN2, const StructNode pN3, const Vec3 &F1, const Vec3 &F2, const Vec3 &F3, const Mat3x3 &R1, const Mat3x3 &R2, const Mat3x3 &R3, const Mat3x3 &r_I, const Mat3x3 &rII, const ConstitutiveLaw6D pD_I, const ConstitutiveLaw6D *pDII, OrientationDescription ood, flag fOut)

	Beam (unsigned int uL, const StructNode pN1, const StructNode pN2, const StructNode pN3, const Vec3 &F1, const Vec3 &F2, const Vec3 &F3, const Mat3x3 &R1, const Mat3x3 &R2, const Mat3x3 &R3, const Mat3x3 &r_I, const Mat3x3 &rII, const ConstitutiveLaw6D pD_I, const ConstitutiveLaw6D *pDII, doublereal dM_I, const Vec3 &s0_I, const Mat3x3 &j0_I, doublereal dMII, const Vec3 &s0II, const Mat3x3 &j0II, OrientationDescription ood, flag fOut)

virtual	~Beam (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 SubVectorHandler &	AssRes (SubVectorHandler &WorkVec, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr, const VectorHandler &XPrimePrimeCurr, InverseDynamics::Order iOrder=InverseDynamics::INVERSE_DYNAMICS)

virtual bool	bInverseDynamics (void) const

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

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

virtual void	OutputPrepare (OutputHandler &OH)

virtual void	Output (OutputHandler &OH) const

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)

void	Init (void)

Protected Member Functions inherited from Beam
Vec3	InterpDeriv (const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, enum Section Sec)

virtual void	AddInternalForces (Vec6 &, unsigned int)

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)

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

void	Init (void)

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 [NUMSEZ]

Vec3	gPrime [NUMSEZ]

Vec3	LPrimeRef [NUMSEZ]

Vec6	DefPrimeLocRef [NUMSEZ]

Mat6x6	ERef [NUMSEZ]

Protected Attributes inherited from WithLabel
unsigned int	uLabel

std::string	sName

Protected Attributes inherited from ToBeOutput
flag	fOutput

Protected Attributes inherited from Beam
OrientationDescription	od

const StructNode *	pNode [NUMNODES]

const Vec3	f [NUMNODES]

Vec3	fRef [NUMNODES]

const Mat3x3	RNode [NUMNODES]

Mat3x3	R [NUMSEZ]

Mat3x3	RRef [NUMSEZ]

Mat3x3	RPrev [NUMSEZ]

ConstitutiveLaw6DOwner *	pD [NUMSEZ]

Mat6x6	DRef [NUMSEZ]

const bool	bConsistentInertia

const doublereal	dMass_I

const Vec3	S0_I

const Mat3x3	J0_I

const doublereal	dMassII

const Vec3	S0II

const Mat3x3	J0II

Vec3	Omega [NUMSEZ]

Vec3	OmegaRef [NUMSEZ]

Vec6	Az [NUMSEZ]

Vec6	AzRef [NUMSEZ]

Vec6	AzLoc [NUMSEZ]

Vec6	DefLoc [NUMSEZ]

Vec6	DefLocRef [NUMSEZ]

Vec6	DefLocPrev [NUMSEZ]

Vec6	DefPrimeLoc [NUMSEZ]

Vec3	p [NUMSEZ]

Vec3	g [NUMSEZ]

Vec3	L0 [NUMSEZ]

Vec3	L [NUMSEZ]

Vec3	LRef [NUMSEZ]

doublereal	dsdxi [NUMSEZ]

bool	bFirstRes

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 }

Public Types inherited from Beam
enum	Type { UNKNOWN = -1, ELASTIC = 0, VISCOELASTIC, PIEZOELECTRICELASTIC, PIEZOELECTRICVISCOELASTIC, LASTBEAMTYPE }

enum	{ OUTPUT_NONE = 0x000U, OUTPUT_EP_X = (ToBeOutput::OUTPUT_PRIVATE << 0), OUTPUT_EP_R = (ToBeOutput::OUTPUT_PRIVATE << 1), OUTPUT_EP_CONFIGURATION = (OUTPUT_EP_X \| OUTPUT_EP_R), OUTPUT_EP_F = (ToBeOutput::OUTPUT_PRIVATE << 2), OUTPUT_EP_M = (ToBeOutput::OUTPUT_PRIVATE << 3), OUTPUT_EP_FORCES = (OUTPUT_EP_F \| OUTPUT_EP_M ), OUTPUT_EP_NU = (ToBeOutput::OUTPUT_PRIVATE << 4), OUTPUT_EP_K = (ToBeOutput::OUTPUT_PRIVATE << 5), OUTPUT_EP_STRAINS = (OUTPUT_EP_NU \| OUTPUT_EP_K), OUTPUT_EP_NUP = (ToBeOutput::OUTPUT_PRIVATE << 6), OUTPUT_EP_KP = (ToBeOutput::OUTPUT_PRIVATE << 7), OUTPUT_EP_STRAIN_RATES = (OUTPUT_EP_NUP \| OUTPUT_EP_KP), OUTPUT_DEFAULT = (OUTPUT_EP_F \| OUTPUT_EP_M), OUTPUT_EP_ALL = (ToBeOutput::OUTPUT_PRIVATE_MASK) }

enum	Section { S_I = 0, SII = 1, NUMSEZ = 2 }

enum	NodeName { NODE1 = 0, NODE2 = 1, NODE3 = 2, NUMNODES = 3 }

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

Static Protected Member Functions inherited from Beam
static unsigned int	iGetPrivDataIdx_int (const char *s, ConstLawType::Type type)

static Vec3	InterpState (const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, enum Section Sec)

Static Protected Attributes inherited from Beam
static const unsigned int	iNumPrivData

Detailed Description

Definition at line 449 of file beam.h.

Constructor & Destructor Documentation

ViscoElasticBeam::ViscoElasticBeam	(	unsigned int	uL,
		const StructNode *	pN1,
		const StructNode *	pN2,
		const StructNode *	pN3,
		const Vec3 &	F1,
		const Vec3 &	F2,
		const Vec3 &	F3,
		const Mat3x3 &	R1,
		const Mat3x3 &	R2,
		const Mat3x3 &	R3,
		const Mat3x3 &	r_I,
		const Mat3x3 &	rII,
		const ConstitutiveLaw6D *	pD_I,
		const ConstitutiveLaw6D *	pDII,
		OrientationDescription	ood,
		flag	fOut
	)

Definition at line 1310 of file beam.cc.

References Init().

 : Elem(uL, fOut),
 Beam(uL, pN1, pN2, pN3, F1, F2, F3, R1, R2, R3, r_I, rII, pD_I, pDII, ood, fOut)
 {
         Init();
 }

Here is the call graph for this function:

ViscoElasticBeam::ViscoElasticBeam	(	unsigned int	uL,
		const StructNode *	pN1,
		const StructNode *	pN2,
		const StructNode *	pN3,
		const Vec3 &	F1,
		const Vec3 &	F2,
		const Vec3 &	F3,
		const Mat3x3 &	R1,
		const Mat3x3 &	R2,
		const Mat3x3 &	R3,
		const Mat3x3 &	r_I,
		const Mat3x3 &	rII,
		const ConstitutiveLaw6D *	pD_I,
		const ConstitutiveLaw6D *	pDII,
		doublereal	dM_I,
		const Vec3 &	s0_I,
		const Mat3x3 &	j0_I,
		doublereal	dMII,
		const Vec3 &	s0II,
		const Mat3x3 &	j0II,
		OrientationDescription	ood,
		flag	fOut
	)

Definition at line 1335 of file beam.cc.

References Init().

 : Elem(uL, fOut),
 Beam(uL, pN1, pN2, pN3, F1, F2, F3, R1, R2, R3, r_I, rII, pD_I, pDII,
           dM_I, s0_I, j0_I, dMII, s0II, j0II, ood, fOut)
 {
         Init();
 }

Here is the call graph for this function:

virtual ViscoElasticBeam::~ViscoElasticBeam ( void )

inlinevirtual

Definition at line 526 of file beam.h.

References NO_OP.

                                     {
         NO_OP;
     };

Member Function Documentation

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

virtual

Reimplemented from Beam.

Definition at line 1384 of file beam.cc.

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

Referenced by AfterConvergence().

 {
         for (unsigned i = 0; i < NUMSEZ; i++) {
                 RPrev[i] = R[i];
                 DefLocPrev[i] = DefLoc[i];
                 pD[i]->AfterConvergence(DefLoc[i], DefPrimeLoc[i]);
         }
 }

Here is the call graph for this function:

void ViscoElasticBeam::AfterConvergence	(	const VectorHandler &	X,
		const VectorHandler &	XP,
		const VectorHandler &	XPP
	)

virtual

Reimplemented from Beam.

Definition at line 1396 of file beam.cc.

References AfterConvergence().

 {
         AfterConvergence(X, XP);
 }

Here is the call graph for this function:

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

virtual

Reimplemented from Beam.

Reimplemented in PiezoActuatorVEBeam.

Definition at line 1657 of file beam.cc.

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

Referenced by PiezoActuatorVEBeam::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[NUMSEZ];
         Vec3 gGrad[NUMSEZ];
         Vec3 gPrimeGrad[NUMSEZ];
 
         /* Aggiorna le grandezze della trave nei punti di valutazione */
         for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
                 /* Posizione */
                 p[iSez] = InterpState(xTmp[NODE1],
                 xTmp[NODE2],
                 xTmp[NODE3], Beam::Section(iSez));
 
                 /* Matrici di rotazione */
                 g[iSez] = InterpState(gNod[NODE1],
                         gNod[NODE2],
                         gNod[NODE3], Beam::Section(iSez));
                 RDelta[iSez] = Mat3x3(CGR_Rot::MatR, g[iSez]);
                 R[iSez] = RRef[iSez] = RDelta[iSez]*RPrev[iSez];
 
                 /* Velocita' angolare della sezione */
                 gPrime[iSez] = InterpState(gPrimeNod[NODE1],
                         gPrimeNod[NODE2],
                         gPrimeNod[NODE3], Beam::Section(iSez));
                 Omega[iSez] = OmegaRef[iSez] = Mat3x3(CGR_Rot::MatG, g[iSez])*gPrime[iSez];
 
                 /* Derivate della posizione */
                 L[iSez] = LRef[iSez] = InterpDeriv(xTmp[NODE1],
                         xTmp[NODE2],
                         xTmp[NODE3], Beam::Section(iSez));
 
                 /* Derivate della velocita' */
                 LPrime[iSez] = LPrimeRef[iSez]
                         = InterpDeriv(xPrimeTmp[NODE1],
                                 xPrimeTmp[NODE2],
                                 xPrimeTmp[NODE3], Beam::Section(iSez));
 
                 /* Derivate dei parametri di rotazione */
                 gGrad[iSez] = InterpDeriv(gNod[NODE1],
                         gNod[NODE2],
                         gNod[NODE3], Beam::Section(iSez));
 
                 /* Derivate delle derivate spaziali dei parametri di rotazione */
                 gPrimeGrad[iSez] = InterpDeriv(gPrimeNod[NODE1],
                         gPrimeNod[NODE2],
                         gPrimeNod[NODE3], Beam::Section(iSez));
 
                 /* Calcola le deformazioni nel sistema locale nei punti di valutazione */
                 DefLoc[iSez] = DefLocRef[iSez]
                         = Vec6(R[iSez].MulTV(L[iSez]) - L0[iSez],
                                 R[iSez].MulTV(Mat3x3(CGR_Rot::MatG, g[iSez])*gGrad[iSez]) + DefLocPrev[iSez].GetVec2());
 
                 /* Calcola le velocita' di deformazione nel sistema locale nei punti di valutazione */
                 DefPrimeLoc[iSez] = DefPrimeLocRef[iSez]
                         = Vec6(R[iSez].MulTV(LPrime[iSez] + L[iSez].Cross(Omega[iSez])),
                                 R[iSez].MulTV(Mat3x3(CGR_Rot::MatG, g[iSez])*gPrimeGrad[iSez]
                                         + (Mat3x3(CGR_Rot::MatG, g[iSez])*gGrad[iSez]).Cross(Omega[iSez])));
 
                 /* Calcola le azioni interne */
                 pD[iSez]->Update(DefLoc[iSez], DefPrimeLoc[iSez]);
                 AzLoc[iSez] = pD[iSez]->GetF();
 
                 /* corregge le azioni interne locali (piezo, ecc) */
                 AddInternalForces(AzLoc[iSez], iSez);
 
                 /* Porta le azioni interne nel sistema globale */
                 Az[iSez] = AzRef[iSez] = MultRV(AzLoc[iSez], R[iSez]);
 
                 /* Aggiorna il legame costitutivo */
                 DRef[iSez] = MultRMRt(pD[iSez]->GetFDE(), R[iSez]);
                 ERef[iSez] = MultRMRt(pD[iSez]->GetFDEPrime(), R[iSez]);
         }
 
         bFirstRes = true;
 }

Here is the call graph for this function:

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

protectedvirtual

Reimplemented from Beam.

Reimplemented in PiezoActuatorVEBeam.

Definition at line 1404 of file beam.cc.

References FullSubMatrixHandler::Add(), Beam::Az, grad::Cross(), DEBUGCOUTFNAME, dN3, dN3P, Beam::DRef, Beam::dsdxi, ERef, Beam::f, StructNode::GetRCurr(), StructNode::GetWCurr(), StructDispNode::GetXCurr(), Beam::L, LPrime, MatCross, MatCrossCross, mb_deye< Mat3x3 >(), Beam::NUMNODES, Beam::NUMSEZ, Beam::Omega, Beam::p, Beam::pNode, FullSubMatrixHandler::Sub(), Mat6x6::SubMat12(), Mat6x6::SubMat22(), and Zero3x3.

Referenced by PiezoActuatorVEBeam::AssStiffnessMat().

 {
         DEBUGCOUTFNAME("ViscoElasticBeam::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[NUMSEZ][NUMNODES];
         Mat6x6 AzPrimeTmp[NUMSEZ][NUMNODES];
 
         /* per ogni punto di valutazione: */
         for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
                 for (unsigned int i = 0; i < NUMNODES; i++) {
                         /* Delta - deformazioni */
                         AzTmp[iSez][i] = AzPrimeTmp[iSez][i]
                                 = Mat6x6(mb_deye<Mat3x3>(dN3P[iSez][i]*dsdxi[iSez]),
                                         Zero3x3,
                                         Mat3x3(MatCross, L[iSez]*dN3[iSez][i] - fTmp[i]*(dN3P[iSez][i]*dsdxi[iSez])),
                                         mb_deye<Mat3x3>(dN3P[iSez][i]*dsdxi[iSez]));
                         AzTmp[iSez][i] = DRef[iSez]*AzTmp[iSez][i]*dCoef;
                         AzTmp[iSez][i] +=
                                 ERef[iSez]*Mat6x6(Mat3x3(MatCross, Omega[iSez]*(-dN3P[iSez][i]*dsdxi[iSez]*dCoef)),
                                         Zero3x3,
                                         (Mat3x3(MatCross, LPrime[iSez]) - Mat3x3(MatCrossCross, Omega[iSez], L[iSez]))*(dN3[iSez][i]*dCoef)
                                                 + Mat3x3(MatCrossCross, Omega[iSez], fTmp[i]*(dN3P[iSez][i]*dsdxi[iSez]*dCoef))
                                                 + Mat3x3(MatCross, fTmp[i].Cross(pNode[i]->GetWCurr()*(dN3P[iSez][i]*dsdxi[iSez]*dCoef))),
                                         Mat3x3(MatCross, Omega[iSez]*(-dN3P[iSez][i]*dsdxi[iSez]*dCoef)));
                         AzPrimeTmp[iSez][i] = ERef[iSez]*AzPrimeTmp[iSez][i];
 
                         /* Correggo per la rotazione da locale a globale */
                         AzTmp[iSez][i].SubMat12(Mat3x3(MatCross, Az[iSez].GetVec1()*(dN3[iSez][i]*dCoef)));
                         AzTmp[iSez][i].SubMat22(Mat3x3(MatCross, Az[iSez].GetVec2()*(dN3[iSez][i]*dCoef)));
                 }
         } /* end ciclo sui punti di valutazione */
 
 
         Vec3 bTmp[2];
 
         /* ciclo sulle equazioni */
         for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
                 bTmp[0] = p[iSez] - pNode[iSez]->GetXCurr();
                 bTmp[1] = p[iSez] - pNode[iSez + 1]->GetXCurr();
 
                 unsigned int iRow1 = iSez*6 + 1;
                 unsigned int iRow2 = iRow1 + 6;
 
                 for (unsigned int i = 0; i < NUMNODES; i++) {
                         /* Equazione all'indietro: */
                         WMA.Sub(iRow1, 6*i + 1, AzTmp[iSez][i].GetMat11());
                         WMA.Sub(iRow1, 6*i + 4, AzTmp[iSez][i].GetMat12());
 
                         WMA.Sub(iRow1 + 3, 6*i + 1,
                                 AzTmp[iSez][i].GetMat21()
                                 - Mat3x3(MatCross, Az[iSez].GetVec1()*(dCoef*dN3[iSez][i]))
                                 + bTmp[0].Cross(AzTmp[iSez][i].GetMat11()));
                         WMA.Sub(iRow1 + 3, 6*i + 4,
                                  AzTmp[iSez][i].GetMat22()
                                 - Mat3x3(MatCrossCross, Az[iSez].GetVec1()*(-dCoef*dN3[iSez][i]), fTmp[i])
                                 + bTmp[0].Cross(AzTmp[iSez][i].GetMat12()));
 
                         /* Equazione in avanti: */
                         WMA.Add(iRow2, 6*i + 1, AzTmp[iSez][i].GetMat11());
                         WMA.Add(iRow2, 6*i + 4, AzTmp[iSez][i].GetMat12());
 
                         WMA.Add(iRow2 + 3, 6*i + 1,
                                 AzTmp[iSez][i].GetMat21()
                                 - Mat3x3(MatCross, Az[iSez].GetVec1()*(dCoef*dN3[iSez][i]))
                                 + bTmp[1].Cross(AzTmp[iSez][i].GetMat11()));
                         WMA.Add(iRow2 + 3, 6*i + 4,
                                 AzTmp[iSez][i].GetMat22()
                                 + Mat3x3(MatCrossCross, Az[iSez].GetVec1()*(dCoef*dN3[iSez][i]), fTmp[i])
                                 + bTmp[1].Cross(AzTmp[iSez][i].GetMat12()));
 
 
                         /* Equazione viscosa all'indietro: */
                         WMB.Sub(iRow1, 6*i + 1, AzPrimeTmp[iSez][i].GetMat11());
                         WMB.Sub(iRow1, 6*i + 4, AzPrimeTmp[iSez][i].GetMat12());
 
                         WMB.Sub(iRow1 + 3, 6*i + 1,
                                 AzPrimeTmp[iSez][i].GetMat21()
                                 + bTmp[0].Cross(AzPrimeTmp[iSez][i].GetMat11()));
                         WMB.Sub(iRow1 + 3, 6*i + 4,
                                 AzPrimeTmp[iSez][i].GetMat22()
                                 + bTmp[0].Cross(AzPrimeTmp[iSez][i].GetMat12()));
 
                         /* Equazione viscosa in avanti: */
                         WMB.Add(iRow2, 6*i + 1, AzPrimeTmp[iSez][i].GetMat11());
                         WMB.Add(iRow2, 6*i + 4, AzPrimeTmp[iSez][i].GetMat12());
 
                         WMB.Add(iRow2 + 3, 6*i + 1,
                                 AzPrimeTmp[iSez][i].GetMat21()
                                 + bTmp[1].Cross(AzPrimeTmp[iSez][i].GetMat11()));
                         WMB.Add(iRow2 + 3, 6*i + 4,
                                 AzPrimeTmp[iSez][i].GetMat22()
                                 + bTmp[1].Cross(AzPrimeTmp[iSez][i].GetMat12()));
                 }
 
                 /* correzione alle equazioni */
                 Mat3x3 FTmp(MatCross, Az[iSez].GetVec1()*dCoef);
                 WMA.Sub(iRow1 + 3, 6*iSez + 1, FTmp);
                 WMA.Add(iRow2 + 3, 6*iSez + 7, FTmp);
 
         } /* end ciclo sui punti di valutazione */
 };

Here is the call graph for this function:

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

protectedvirtual

Reimplemented from Beam.

Reimplemented in PiezoActuatorVEBeam.

Definition at line 1522 of file beam.cc.

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

Referenced by PiezoActuatorVEBeam::AssStiffnessVec().

 {
         DEBUGCOUTFNAME("ViscoElasticBeam::AssStiffnessVec");
 
         /* Riceve il vettore gia' dimensionato e con gli indici a posto
          * per scrivere il residuo delle equazioni di equilibrio dei tre 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[NUMSEZ];
                 Vec3 gGrad[NUMSEZ];
                 Vec3 gPrimeGrad[NUMSEZ];
 
                 /* Aggiorna le grandezze della trave nei punti di valutazione */
                 for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
 
                         /* Posizione */
                         p[iSez] = InterpState(xTmp[NODE1],
                                 xTmp[NODE2],
                                 xTmp[NODE3], Beam::Section(iSez));
 
                         /* Matrici di rotazione */
                         g[iSez] = InterpState(gNod[NODE1],
                                 gNod[NODE2],
                                 gNod[NODE3], Beam::Section(iSez));
                         RDelta[iSez] = Mat3x3(CGR_Rot::MatR, g[iSez]);
                         R[iSez] = RDelta[iSez]*RRef[iSez];
 
                         /* Velocita' angolare della sezione */
                         gPrime[iSez] = InterpState(gPrimeNod[NODE1],
                                 gPrimeNod[NODE2],
                                 gPrimeNod[NODE3], Beam::Section(iSez));
                         Omega[iSez] = Mat3x3(CGR_Rot::MatG, g[iSez])*gPrime[iSez]
                                 + RDelta[iSez]*OmegaRef[iSez];
 
                         /* Derivate della posizione */
                         L[iSez] = InterpDeriv(xTmp[NODE1],
                                 xTmp[NODE2],
                                 xTmp[NODE3], Beam::Section(iSez));
 
                         /* Derivate della velocita' */
                         LPrime[iSez] = InterpDeriv(xPrimeTmp[NODE1],
                                 xPrimeTmp[NODE2],
                                 xPrimeTmp[NODE3], Beam::Section(iSez));
 
                         /* Derivate dei parametri di rotazione */
                         gGrad[iSez] = InterpDeriv(gNod[NODE1],
                                 gNod[NODE2],
                                 gNod[NODE3], Beam::Section(iSez));
 
                         /* Derivate delle derivate spaziali dei parametri di rotazione */
                         gPrimeGrad[iSez] = InterpDeriv(gPrimeNod[NODE1],
                                 gPrimeNod[NODE2],
                                 gPrimeNod[NODE3], Beam::Section(iSez));
 
                         /* Calcola le deformazioni nel sistema locale nei punti di valutazione */
                         DefLoc[iSez] = Vec6(R[iSez].MulTV(L[iSez]) - L0[iSez],
                                 R[iSez].MulTV(Mat3x3(CGR_Rot::MatG, g[iSez])*gGrad[iSez]) + DefLocRef[iSez].GetVec2());
 
                         /* Calcola le velocita' di deformazione nel sistema locale nei punti di valutazione */
                         DefPrimeLoc[iSez] = Vec6(R[iSez].MulTV(LPrime[iSez] + L[iSez].Cross(Omega[iSez])),
                                 R[iSez].MulTV(Mat3x3(CGR_Rot::MatG, g[iSez])*gPrimeGrad[iSez]
                                 + (Mat3x3(CGR_Rot::MatG, g[iSez])*gGrad[iSez]).Cross(Omega[iSez]))
                                 + DefPrimeLocRef[iSez].GetVec2());
 
                         /* Calcola le azioni interne */
                         pD[iSez]->Update(DefLoc[iSez], DefPrimeLoc[iSez]);
                         AzLoc[iSez] = pD[iSez]->GetF();
 
                         /* corregge le azioni interne locali (piezo, ecc) */
                         AddInternalForces(AzLoc[iSez], iSez);
 
                         /* Porta le azioni interne nel sistema globale */
                         Az[iSez] = MultRV(AzLoc[iSez], R[iSez]);
                 }
         }
 
         WorkVec.Add(1, Az[S_I].GetVec1());
         WorkVec.Add(4, (p[S_I] - pNode[NODE1]->GetXCurr()).Cross(Az[S_I].GetVec1())
                 + Az[S_I].GetVec2());
         WorkVec.Add(7, Az[SII].GetVec1() - Az[S_I].GetVec1());
         WorkVec.Add(10, Az[SII].GetVec2() - Az[S_I].GetVec2()
                 + (p[SII] - pNode[NODE2]->GetXCurr()).Cross(Az[SII].GetVec1())
                 - (p[S_I] - pNode[NODE2]->GetXCurr()).Cross(Az[S_I].GetVec1()));
         WorkVec.Sub(13, Az[SII].GetVec1());
         WorkVec.Add(16, Az[SII].GetVec1().Cross(p[SII] - pNode[NODE3]->GetXCurr())
                 - Az[SII].GetVec2());
 }

Here is the call graph for this function:

doublereal ViscoElasticBeam::dGetPrivData ( unsigned int i ) const

virtual

Reimplemented from Beam.

Definition at line 1752 of file beam.cc.

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

 {
         ASSERT(i > 0 && i <= iGetNumPrivData());
 
         int sez = (i - 1)/iNumPrivData;
         int idx = (i - 1)%iNumPrivData + 1;
 
         switch (idx) {
         case 22:
         case 23:
         case 24:
         case 25:
         case 26:
         case 27:
                 return DefPrimeLoc[sez].dGet(idx - 21);
 
         default:
                 return Beam::dGetPrivData(i);
         }
 }

Here is the call graph for this function:

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

inlinevirtual

Reimplemented from Beam.

Reimplemented in PiezoActuatorVEBeam.

Definition at line 531 of file beam.h.

References Beam::VISCOELASTIC.

                                              {
         return Beam::VISCOELASTIC;
     };

void ViscoElasticBeam::Init ( void )

protected

Definition at line 1363 of file beam.cc.

References Beam::DefPrimeLoc, DefPrimeLocRef, ERef, gPrime, LPrime, LPrimeRef, MultRMRt(), Beam::Omega, Beam::Omega0(), Beam::OmegaRef, Beam::pD, Beam::RRef, Beam::S_I, Beam::SII, Zero3, and Zero6.

Referenced by ViscoElasticBeam().

 {
         gPrime[S_I] = gPrime[SII] = Zero3;
 
         LPrime[S_I] = LPrime[SII] = Zero3;
         LPrimeRef[S_I] = LPrimeRef[SII] = Zero3;
 
         DefPrimeLoc[S_I] = DefPrimeLoc[SII] = Zero6;
         DefPrimeLocRef[S_I] = DefPrimeLocRef[SII] = Zero6;
 
         /* Nota: DsDxi() viene chiamata dal costruttore di Beam */
         Beam::Omega0();
 
         OmegaRef[S_I] = Omega[S_I];
         OmegaRef[SII] = Omega[SII];
 
         const_cast<Mat6x6&>(ERef[S_I]) = MultRMRt(pD[S_I]->GetFDEPrime(), RRef[S_I]);
         const_cast<Mat6x6&>(ERef[SII]) = MultRMRt(pD[SII]->GetFDEPrime(), RRef[SII]);
 }

Here is the call graph for this function:

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

virtual

Reimplemented from Beam.

Reimplemented in PiezoActuatorVEBeam.

Definition at line 1635 of file beam.cc.

References ASSERT, Beam::bFirstRes, Beam::DefPrimeLoc, DefPrimeLocRef, ERef, LPrime, LPrimeRef, MultRMRt(), Beam::NUMSEZ, Beam::Omega, Beam::OmegaRef, Beam::pD, Beam::RRef, and Beam::SetValue().

Referenced by PiezoActuatorVEBeam::SetValue().

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