Beam Class Reference

#include <beam.h>

Inheritance diagram for Beam:

Collaboration diagram for Beam:

Classes
class	ErrGeneric

Public Types
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 }
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 Member Functions
	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 Beam::Type	GetBeamType (void) const
virtual Elem::Type	GetElemType (void) const
virtual std::ostream &	Restart (std::ostream &out) const
virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP)
virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP, const VectorHandler &XPP)
virtual void	WorkSpaceDim (integer *piNumRows, integer *piNumCols) const
void	SetValue (DataManager *pDM, VectorHandler &, VectorHandler &, SimulationEntity::Hints *ph=0)
virtual void	AfterPredict (VectorHandler &, VectorHandler &)
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 doublereal	dGetPrivData (unsigned int i) const
virtual const StructNode *	pGetNode (unsigned int i) const
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 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 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
Vec3	InterpDeriv (const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, enum Section Sec)
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)
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

Static Protected Member Functions
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)

Protected Attributes
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 WithLabel
unsigned int	uLabel
std::string	sName
Protected Attributes inherited from ToBeOutput
flag	fOutput
Protected Attributes inherited from GravityOwner
Gravity *	pGravity

Static Protected Attributes
static const unsigned int	iNumPrivData

Friends
class	AerodynamicBeam
class	Beam2
Elem *	ReadBeam (DataManager *pDM, MBDynParser &HP, unsigned int uLabel)

Detailed Description

Definition at line 56 of file beam.h.

Member Enumeration Documentation

anonymous enum

Enumerator
OUTPUT_NONE
OUTPUT_EP_X
OUTPUT_EP_R
OUTPUT_EP_CONFIGURATION
OUTPUT_EP_F
OUTPUT_EP_M
OUTPUT_EP_FORCES
OUTPUT_EP_NU
OUTPUT_EP_K
OUTPUT_EP_STRAINS
OUTPUT_EP_NUP
OUTPUT_EP_KP
OUTPUT_EP_STRAIN_RATES
OUTPUT_DEFAULT
OUTPUT_EP_ALL

Definition at line 75 of file beam.h.

             {
                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 Beam::Deformations

Enumerator
STRAIN
CURVAT
NUMDEFORM

Definition at line 138 of file beam.h.

{ STRAIN = 0, CURVAT = 1, NUMDEFORM = 2 };

enum Beam::NodeName

Enumerator
NODE1
NODE2
NODE3
NUMNODES

Definition at line 137 of file beam.h.

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

enum Beam::Section

Enumerator
S_I
SII
NUMSEZ

Definition at line 136 of file beam.h.

{ S_I = 0, SII = 1, NUMSEZ = 2 };

enum Beam::Type

Enumerator
UNKNOWN
ELASTIC
VISCOELASTIC
PIEZOELECTRICELASTIC
PIEZOELECTRICVISCOELASTIC
LASTBEAMTYPE

Definition at line 64 of file beam.h.

              {
        UNKNOWN = -1,
        ELASTIC = 0,
        VISCOELASTIC,
        PIEZOELECTRICELASTIC,
        PIEZOELECTRICVISCOELASTIC,

        LASTBEAMTYPE
    };

Constructor & Destructor Documentation

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
	)

Definition at line 64 of file beam.cc.

References ASSERT, f, StructDispNode::GetNodeType(), Init(), NODE1, NODE2, NODE3, pD, pNode, R, RNode, RRef, S_I, SAFENEWWITHCONSTRUCTOR, SII, and Node::STRUCTURAL.

: Elem(uL, fOut),
ElemGravityOwner(uL, fOut),
InitialAssemblyElem(uL, fOut),
od(ood),
f(),
RNode(),
bConsistentInertia(false),
dMass_I(0.),
S0_I(Zero3),
J0_I(Zero3x3),
dMassII(0.),
S0II(Zero3),
J0II(Zero3x3),
bFirstRes(false)
{
        ASSERT(pN1 != NULL);
        ASSERT(pN1->GetNodeType() == Node::STRUCTURAL);
        ASSERT(pN2 != NULL);
        ASSERT(pN2->GetNodeType() == Node::STRUCTURAL);
        ASSERT(pN3 != NULL);
        ASSERT(pN3->GetNodeType() == Node::STRUCTURAL);

        pNode[NODE1] = pN1;
        pNode[NODE2] = pN2;
        pNode[NODE3] = pN3;

        const_cast<Vec3&>(f[NODE1]) = F1;
        const_cast<Vec3&>(f[NODE2]) = F2;
        const_cast<Vec3&>(f[NODE3]) = F3;
        const_cast<Mat3x3&>(RNode[NODE1]) = R1;
        const_cast<Mat3x3&>(RNode[NODE2]) = R2;
        const_cast<Mat3x3&>(RNode[NODE3]) = R3;
        RRef[S_I] = R[S_I] = (Mat3x3&)r_I;
        RRef[SII] = R[SII] = (Mat3x3&)rII;

        pD[S_I] = 0;
        SAFENEWWITHCONSTRUCTOR(pD[S_I],
                ConstitutiveLaw6DOwner,
                ConstitutiveLaw6DOwner(pD_I));
        pD[SII] = 0;
        SAFENEWWITHCONSTRUCTOR(pD[SII],
                ConstitutiveLaw6DOwner,
                ConstitutiveLaw6DOwner(pDII));

        Init();
}

Here is the call graph for this function:

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,
		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 129 of file beam.cc.

References f, Init(), NODE1, NODE2, NODE3, pD, pNode, R, RNode, RPrev, RRef, S_I, SAFENEWWITHCONSTRUCTOR, and SII.

: Elem(uL, fOut),
ElemGravityOwner(uL, fOut),
InitialAssemblyElem(uL, fOut),
od(ood),
f(),
RNode(),
bConsistentInertia(true),
dMass_I(dM_I),
S0_I(s0_I),
J0_I(j0_I),
dMassII(dMII),
S0II(s0II),
J0II(j0II),
bFirstRes(false)
{
        pNode[NODE1] = pN1;
        pNode[NODE2] = pN2;
        pNode[NODE3] = pN3;
        const_cast<Vec3&>(f[NODE1]) = F1;
        const_cast<Vec3&>(f[NODE2]) = F2;
        const_cast<Vec3&>(f[NODE3]) = F3;
        const_cast<Mat3x3&>(RNode[NODE1]) = R1;
        const_cast<Mat3x3&>(RNode[NODE2]) = R2;
        const_cast<Mat3x3&>(RNode[NODE3]) = R3;
        RPrev[S_I] = RRef[S_I] = R[S_I] = const_cast<Mat3x3&>(r_I);
        RPrev[SII] = RRef[SII] = R[SII] = const_cast<Mat3x3&>(rII);

        pD[S_I] = 0;
        SAFENEWWITHCONSTRUCTOR(pD[S_I],
                ConstitutiveLaw6DOwner,
                ConstitutiveLaw6DOwner(pD_I));
        pD[SII] = 0;
        SAFENEWWITHCONSTRUCTOR(pD[SII],
                ConstitutiveLaw6DOwner,
                ConstitutiveLaw6DOwner(pDII));

        Init();
}

Here is the call graph for this function:

Beam::~Beam ( void  )

virtual

Definition at line 236 of file beam.cc.

References ASSERT, pD, S_I, SAFEDELETE, and SII.

{
        ASSERT(pD[S_I] != 0);
        if (pD[S_I] != 0) {
                SAFEDELETE(pD[S_I]);
        }

        ASSERT(pD[SII] != 0);
        if (pD[SII] != 0) {
                SAFEDELETE(pD[SII]);
        }
}

Member Function Documentation

virtual void Beam::AddInternalForces ( Vec6 &  , unsigned int    )

inlineprotectedvirtual

Reimplemented in PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 227 of file beam.h.

References NO_OP.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessVec(), and ViscoElasticBeam::AssStiffnessVec().

                                                 {
        NO_OP;
    };

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

virtual

Reimplemented from SimulationEntity.

Reimplemented in ViscoElasticBeam.

Definition at line 595 of file beam.cc.

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

Referenced by AfterConvergence().

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

Here is the call graph for this function:

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

virtual

Reimplemented from SimulationEntity.

Reimplemented in ViscoElasticBeam.

Definition at line 606 of file beam.cc.

References AfterConvergence().

{
        AfterConvergence(X, XP);
}

Here is the call graph for this function:

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

virtual

Reimplemented from SimulationEntity.

Reimplemented in ViscoElasticBeam, PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 988 of file beam.cc.

References AddInternalForces(), Az, AzLoc, AzRef, bFirstRes, DefLoc, DefLocPrev, DefLocRef, DRef, f, g, ConstitutiveLawOwner< T, Tder >::GetF(), StructNode::GetgRef(), StructNode::GetRRef(), StructDispNode::GetXCurr(), InterpDeriv(), InterpState(), L, L0, LRef, CGR_Rot::MatG, CGR_Rot::MatR, MultRMRt(), MultRV(), NODE2, NUMNODES, NUMSEZ, p, pD, pNode, R, RPrev, RRef, and ConstitutiveLawOwner< T, Tder >::Update().

Referenced by PiezoActuatorBeam::AfterPredict().

{
        /* Calcola le deformazioni, aggiorna il legame costitutivo e crea la FDE */

        /* Recupera i dati dei nodi */
        Vec3   gNod[NUMNODES];
        Vec3   xTmp[NUMNODES];

        for (unsigned int i = 0; i < NUMNODES; i++) {
                gNod[i] = pNode[i]->GetgRef();
                xTmp[i] = pNode[i]->GetXCurr() + pNode[i]->GetRRef()*f[i];
        }

        Mat3x3 RDelta[NUMSEZ];
        Vec3 gGrad[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];

                /* Derivate della posizione */
                L[iSez] = LRef[iSez]
                        = InterpDeriv(xTmp[NODE1], xTmp[NODE2], xTmp[NODE3], Beam::Section(iSez));

                /* Derivate dei parametri di rotazione */
                gGrad[iSez]
                        = InterpDeriv(gNod[NODE1], gNod[NODE2], gNod[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 azioni interne */
                pD[iSez]->Update(DefLoc[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 di riferimento */
                DRef[iSez] = MultRMRt(pD[iSez]->GetFDE(), RRef[iSez]);
        }

        bFirstRes = true;
}

Here is the call graph for this function:

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

inlineprotectedvirtual

Definition at line 232 of file beam.h.

References NO_OP.

Referenced by PiezoActuatorBeam::AssJac(), PiezoActuatorVEBeam::AssJac(), AssJac(), and AssMats().

                                           {
        NO_OP;
    };

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

inlineprotectedvirtual

Definition at line 241 of file beam.h.

References NO_OP.

Referenced by AssRes().

                                           {
        NO_OP;
    };

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

virtual

Implements Elem.

Reimplemented in PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 772 of file beam.cc.

References AssInertiaMat(), AssStiffnessMat(), bConsistentInertia, DEBUGCOUTFNAME, StructDispNode::iGetFirstMomentumIndex(), StructDispNode::iGetFirstPositionIndex(), NODE1, NODE2, NODE3, pNode, FullSubMatrixHandler::PutColIndex(), FullSubMatrixHandler::PutRowIndex(), FullSubMatrixHandler::ResizeReset(), and VariableSubMatrixHandler::SetFull().

{
        DEBUGCOUTFNAME("Beam::AssJac => AssStiffnessMat");

        integer iNode1FirstMomIndex = pNode[NODE1]->iGetFirstMomentumIndex();
        integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
        integer iNode2FirstMomIndex = pNode[NODE2]->iGetFirstMomentumIndex();
        integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
        integer iNode3FirstMomIndex = pNode[NODE3]->iGetFirstMomentumIndex();
        integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();

        FullSubMatrixHandler& WM = WorkMat.SetFull();

        /* Dimensiona la matrice, la azzera e pone gli indici corretti */
        if (bConsistentInertia) {
                WM.ResizeReset(36, 18);
        } else {
                WM.ResizeReset(18, 18);
        }

        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);
                WM.PutRowIndex(12 + iCnt, iNode3FirstMomIndex + iCnt);
                WM.PutColIndex(12 + iCnt, iNode3FirstPosIndex + iCnt);
        }

        AssStiffnessMat(WM, WM, dCoef, XCurr, XPrimeCurr);

        if (bConsistentInertia) {
                for (int iCnt = 1; iCnt <= 6; iCnt++) {
                        WM.PutRowIndex(18 + iCnt, iNode1FirstPosIndex + iCnt);
                        WM.PutRowIndex(24 + iCnt, iNode2FirstPosIndex + iCnt);
                        WM.PutRowIndex(30 + iCnt, iNode3FirstPosIndex + iCnt);
                }

                AssInertiaMat(WM, WM, dCoef, XCurr, XPrimeCurr);
        }

        return WorkMat;
}

Here is the call graph for this function:

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

virtual

Reimplemented from Elem.

Definition at line 822 of file beam.cc.

References AssInertiaMat(), AssStiffnessMat(), bConsistentInertia, DEBUGCOUTFNAME, StructDispNode::iGetFirstMomentumIndex(), StructDispNode::iGetFirstPositionIndex(), NODE1, NODE2, NODE3, pNode, FullSubMatrixHandler::PutColIndex(), FullSubMatrixHandler::PutRowIndex(), FullSubMatrixHandler::ResizeReset(), VariableSubMatrixHandler::SetFull(), and VariableSubMatrixHandler::SetNullMatrix().

{
        DEBUGCOUTFNAME("Beam::AssMats => AssStiffnessMat");

        integer iNode1FirstMomIndex = pNode[NODE1]->iGetFirstMomentumIndex();
        integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
        integer iNode2FirstMomIndex = pNode[NODE2]->iGetFirstMomentumIndex();
        integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
        integer iNode3FirstMomIndex = pNode[NODE3]->iGetFirstMomentumIndex();
        integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();

        FullSubMatrixHandler& WMA = WorkMatA.SetFull();
        FullSubMatrixHandler& WMB = WorkMatB.SetFull();

        /* Dimensiona la matrice, la azzera e pone gli indici corretti */
        if (bConsistentInertia) {
                WMA.ResizeReset(36, 18);
                WMB.ResizeReset(36, 18);
        } else  {
                WMA.ResizeReset(18, 18);
                WorkMatB.SetNullMatrix();
        }

        for (int iCnt = 1; iCnt <= 6; iCnt++) {
                WMA.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
                WMA.PutColIndex(iCnt, iNode1FirstPosIndex+iCnt);
                WMA.PutRowIndex(6+iCnt, iNode2FirstMomIndex+iCnt);
                WMA.PutColIndex(6+iCnt, iNode2FirstPosIndex+iCnt);
                WMA.PutRowIndex(12+iCnt, iNode3FirstMomIndex+iCnt);
                WMA.PutColIndex(12+iCnt, iNode3FirstPosIndex+iCnt);
        }

        AssStiffnessMat(WMA, WMA, 1., XCurr, XPrimeCurr);

        if (bConsistentInertia) {
                for (unsigned int iCnt = 1; iCnt <= 6; iCnt++) {
                        WMB.PutRowIndex(iCnt, iNode1FirstMomIndex + iCnt);
                        WMB.PutColIndex(iCnt, iNode1FirstPosIndex + iCnt);
                        WMB.PutRowIndex(6 + iCnt, iNode2FirstMomIndex + iCnt);
                        WMB.PutColIndex(6 + iCnt, iNode2FirstPosIndex + iCnt);
                        WMB.PutRowIndex(12 + iCnt, iNode3FirstMomIndex + iCnt);
                        WMB.PutColIndex(12 + iCnt, iNode3FirstPosIndex + iCnt);
                }

                for (unsigned int iCnt = 1; iCnt <= 6; iCnt++) {
                        WMA.PutRowIndex(18 + iCnt, iNode1FirstPosIndex + iCnt);
                        WMA.PutRowIndex(24 + iCnt, iNode2FirstPosIndex + iCnt);
                        WMA.PutRowIndex(30 + iCnt, iNode3FirstPosIndex + iCnt);

                        WMB.PutRowIndex(18 + iCnt, iNode1FirstPosIndex + iCnt);
                        WMB.PutRowIndex(24 + iCnt, iNode2FirstPosIndex + iCnt);
                        WMB.PutRowIndex(30 + iCnt, iNode3FirstPosIndex + iCnt);
                }

                AssInertiaMat(WMA, WMB, 1., XCurr, XPrimeCurr);
        }
}

Here is the call graph for this function:

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

virtual

Implements Elem.

Definition at line 886 of file beam.cc.

References AssInertiaVec(), AssStiffnessVec(), bConsistentInertia, DEBUGCOUTFNAME, StructDispNode::iGetFirstMomentumIndex(), StructDispNode::iGetFirstPositionIndex(), NODE1, NODE2, NODE3, pNode, SubVectorHandler::PutRowIndex(), and VectorHandler::ResizeReset().

{
        DEBUGCOUTFNAME("Beam::AssRes => AssStiffnessVec");

        integer iNode1FirstMomIndex = pNode[NODE1]->iGetFirstMomentumIndex();
        integer iNode2FirstMomIndex = pNode[NODE2]->iGetFirstMomentumIndex();
        integer iNode3FirstMomIndex = pNode[NODE3]->iGetFirstMomentumIndex();

        /* Dimensiona il vettore, lo azzera e pone gli indici corretti */
        if (bConsistentInertia) {
                WorkVec.ResizeReset(36);
        } else {
                WorkVec.ResizeReset(18);
        }

        for (unsigned int iCnt = 1; iCnt <= 6; iCnt++) {
                WorkVec.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
                WorkVec.PutRowIndex(6 + iCnt, iNode2FirstMomIndex + iCnt);
                WorkVec.PutRowIndex(12 + iCnt, iNode3FirstMomIndex + iCnt);
        }

        AssStiffnessVec(WorkVec, dCoef, XCurr, XPrimeCurr);

        if (bConsistentInertia) {
                integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
                integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
                integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();

                for (unsigned int iCnt = 1; iCnt <= 6; iCnt++) {
                        WorkVec.PutRowIndex(18 + iCnt, iNode1FirstPosIndex + iCnt);
                        WorkVec.PutRowIndex(24 + iCnt, iNode2FirstPosIndex + iCnt);
                        WorkVec.PutRowIndex(30 + iCnt, iNode3FirstPosIndex + iCnt);
                }

                AssInertiaVec(WorkVec, dCoef, XCurr, XPrimeCurr);
        }

        return WorkVec;
}

Here is the call graph for this function:

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

virtual

Reimplemented from Elem.

Definition at line 931 of file beam.cc.

References AssStiffnessVec(), DEBUGCOUTFNAME, StructDispNode::iGetFirstPositionIndex(), NODE1, NODE2, NODE3, pNode, SubVectorHandler::PutRowIndex(), and VectorHandler::ResizeReset().

{
        DEBUGCOUTFNAME("Beam::AssRes => AssStiffnessVec");

        integer iNode1FirstMomIndex = pNode[NODE1]->iGetFirstPositionIndex();
        integer iNode2FirstMomIndex = pNode[NODE2]->iGetFirstPositionIndex();
        integer iNode3FirstMomIndex = pNode[NODE3]->iGetFirstPositionIndex();

        /* Dimensiona il vettore, lo azzera e pone gli indici corretti */
        WorkVec.ResizeReset(18);

        for (unsigned int iCnt = 1; iCnt <= 6; iCnt++) {
                WorkVec.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
                WorkVec.PutRowIndex(6 + iCnt, iNode2FirstMomIndex + iCnt);
                WorkVec.PutRowIndex(12 + iCnt, iNode3FirstMomIndex + iCnt);
        }

        AssStiffnessVec(WorkVec, 1., XCurr, XPrimeCurr);

        return WorkVec;
}

Here is the call graph for this function:

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

protectedvirtual

Reimplemented in ViscoElasticBeam, PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 613 of file beam.cc.

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

Referenced by AssJac(), AssMats(), PiezoActuatorBeam::AssStiffnessMat(), and InitialAssJac().

{
        DEBUGCOUTFNAME("Beam::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];

        /* 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] = Mat6x6(mb_deye<Mat3x3>(dN3P[iSez][i]*dsdxi[iSez]*dCoef),
                                Zero3x3,
                                Mat3x3(MatCross, L[iSez]*(dN3[iSez][i]*dCoef) - fTmp[i]*(dN3P[iSez][i]*dsdxi[iSez]*dCoef)),
                                mb_deye<Mat3x3>(dN3P[iSez][i]*dsdxi[iSez]*dCoef));
                        /* Delta - azioni interne */
                        AzTmp[iSez][i] = DRef[iSez]*AzTmp[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()));
                }

                /* 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 Beam::AssStiffnessVec ( SubVectorHandler &  WorkVec, doublereal  dCoef, const VectorHandler &  XCurr, const VectorHandler &  XPrimeCurr  )

protectedvirtual

Reimplemented in ViscoElasticBeam, PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 697 of file beam.cc.

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

Referenced by AssRes(), PiezoActuatorBeam::AssStiffnessVec(), and InitialAssRes().

{
        DEBUGCOUTFNAME("Beam::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];

                for (unsigned int i = 0; i < NUMNODES; i++) {
                        gNod[i] = pNode[i]->GetgCurr();
                        xTmp[i] = pNode[i]->GetXCurr() + pNode[i]->GetRCurr()*f[i];
                }

                Mat3x3 RDelta[NUMSEZ];
                Vec3 gGrad[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];

                        /* Derivate della posizione */
                        L[iSez] = InterpDeriv(xTmp[NODE1], xTmp[NODE2], xTmp[NODE3], Beam::Section(iSez));

                        /* Derivate dei parametri di rotazione */
                        gGrad[iSez] = InterpDeriv(gNod[NODE1], gNod[NODE2], gNod[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 azioni interne */
                        pD[iSez]->Update(DefLoc[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:

bool Beam::bInverseDynamics ( void  ) const

virtual

Reimplemented from Elem.

Definition at line 959 of file beam.cc.

{
        return true;
}

doublereal Beam::dGetPrivData ( unsigned int  i ) const

virtual

Reimplemented from SimulationEntity.

Reimplemented in ViscoElasticBeam.

Definition at line 381 of file beam.cc.

References ASSERT, AzLoc, DefLoc, Vec6::dGet(), Vec3::dGet(), WithLabel::GetLabel(), iGetNumPrivData(), iNumPrivData, MBDYN_EXCEPT_ARGS, Omega, p, R, and RotManip::VecRot().

Referenced by ViscoElasticBeam::dGetPrivData().

{
        ASSERT(i > 0 && i <= iGetNumPrivData());

        int sez = (i - 1)/iNumPrivData;
        int idx = (i - 1)%iNumPrivData + 1;

        switch (idx) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
        case 6:

                return DefLoc[sez].dGet(idx);

        case 7:
        case 8:
        case 9:
        case 10:
        case 11:
        case 12:
                return AzLoc[sez].dGet(idx - 6);

        case 13:
        case 14:
        case 15:
                return p[sez].dGet(idx - 12);

        case 16:
        case 17:
        case 18:
                return RotManip::VecRot(R[sez]).dGet(idx - 15);

        case 19:
        case 20:
        case 21:
                return Omega[sez].dGet(idx - 18);

        default:
                silent_cerr("Beam(" << GetLabel() << "): "
                        "illegal private data " << i << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }
}

Here is the call graph for this function:

void Beam::DsDxi ( void  )

protectedvirtual

Definition at line 466 of file beam.cc.

References ASSERT, Vec3::Dot(), DRef, dsdxi, f, WithLabel::GetLabel(), StructDispNode::GetNodeType(), StructNode::GetRCurr(), StructDispNode::GetXCurr(), InterpDeriv(), L0, MBDYN_EXCEPT_ARGS, MultRMRt(), Mat3x3::MulTV(), NODE1, NODE2, NODE3, NUMNODES, NUMSEZ, pD, pNode, R, grad::sqrt(), Node::STRUCTURAL, ConstitutiveLawOwner< T, Tder >::Update(), and Zero6.

Referenced by Init().

{
        /* Validazione dati */
        ASSERT(pNode[NODE1] != NULL);
        ASSERT(pNode[NODE1]->GetNodeType() == Node::STRUCTURAL);
        ASSERT(pNode[NODE2] != NULL);
        ASSERT(pNode[NODE2]->GetNodeType() == Node::STRUCTURAL);
        ASSERT(pNode[NODE3] != NULL);
        ASSERT(pNode[NODE3]->GetNodeType() == Node::STRUCTURAL);

        /* Calcola il ds/dxi e le deformazioni iniziali */
        Mat3x3 RNod[NUMNODES];
        Vec3 xTmp[NUMNODES];
        for (unsigned int i = 0; i < NUMNODES; i++) {
                RNod[i] = pNode[i]->GetRCurr();
                xTmp[i] = pNode[i]->GetXCurr() + RNod[i]*f[i];
        }

        Vec3 xGrad[NUMSEZ];
        for (unsigned int i = 0; i < NUMSEZ; i++) {
                /* temporary */
                dsdxi[i] = 1.;
                xGrad[i] = InterpDeriv(xTmp[NODE1],
                        xTmp[NODE2],
                        xTmp[NODE3],
                        Beam::Section(i));
                doublereal d = xGrad[i].Dot();
                if (d > std::numeric_limits<doublereal>::epsilon()) {
                        /* final */
                        dsdxi[i] = 1./std::sqrt(d);

                } else {
                        silent_cerr("warning, beam " << GetLabel()
                                << " has singular metric; aborting..." << std::endl);

                        throw ErrNullNorm(MBDYN_EXCEPT_ARGS);
                }
        }

        /* Calcola le deformazioni iniziali */
        for (unsigned int i = 0; i < NUMSEZ; i++) {
                L0[i] = R[i].MulTV(InterpDeriv(xTmp[NODE1],
                        xTmp[NODE2],
                        xTmp[NODE3],
                        Beam::Section(i)));
                pD[i]->Update(Zero6);
                DRef[i] = MultRMRt(pD[i]->GetFDE(), R[i]);
        }
}

Here is the call graph for this function:

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

inlinevirtual

Reimplemented in ViscoElasticBeam, PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 292 of file beam.h.

References ELASTIC.

Referenced by OutputPrepare().

                                             {
        return Beam::ELASTIC;
    };

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

inlinevirtual

Reimplemented from Elem.

Reimplemented in PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 434 of file beam.h.

References NUMNODES, and pNode.

Referenced by PiezoActuatorBeam::GetConnectedNodes().

                                                                     {
        connectedNodes.resize(NUMNODES);
        for (int i = 0; i < NUMNODES; i++) {
            connectedNodes[i] = pNode[i];
        }
    };

virtual Elem::Type Beam::GetElemType ( void  ) const

inlinevirtual

Implements Elem.

Definition at line 297 of file beam.h.

References Elem::BEAM.

Referenced by AerodynamicBeam::AerodynamicBeam().

                                             {
        return Elem::BEAM;
    };

virtual unsigned int Beam::iGetInitialNumDof ( void  ) const

inlinevirtual

Implements SubjectToInitialAssembly.

Definition at line 393 of file beam.h.

                                                       {
        return 0;
    };

unsigned int Beam::iGetNumPrivData ( void  ) const

virtual

Reimplemented from SimulationEntity.

Definition at line 263 of file beam.cc.

References iNumPrivData.

Referenced by dGetPrivData(), and ViscoElasticBeam::dGetPrivData().

{
        return 2*iNumPrivData;
}

unsigned int Beam::iGetPrivDataIdx ( const char *  s ) const

virtual

Reimplemented from SimulationEntity.

Definition at line 346 of file beam.cc.

References ASSERT, ConstLawType::ELASTIC, iGetPrivDataIdx_int(), iNumPrivData, STRLENOF, and ConstLawType::VISCOUS.

{
        ASSERT(s != NULL);

        unsigned int p_idx = 0;

        if (strncmp(s, "pI", STRLENOF("pI")) != 0) {
                return 0;
        }
        s += STRLENOF("pI");

        if (s[0] == 'I') {
                p_idx += iNumPrivData;
                s++;
        }

        if (s[0] != '.') {
                return 0;
        }
        s++;

        ConstLawType::Type type = ConstLawType::ELASTIC;
        if (dynamic_cast<const ViscoElasticBeam *>(this)) {
                type = ConstLawType::VISCOUS;
        }

        unsigned int idx = iGetPrivDataIdx_int(s, type);
        if (idx != 0) {
                idx += p_idx;
        }

        return idx;
}

Here is the call graph for this function:

unsigned int Beam::iGetPrivDataIdx_int ( const char *  s, ConstLawType::Type  type  )

staticprotected

Definition at line 269 of file beam.cc.

References ASSERT, STRLENOF, and ConstLawType::VISCOUS.

Referenced by Beam2::iGetPrivDataIdx(), and iGetPrivDataIdx().

{
        ASSERT(s != NULL);

        unsigned int idx = 0;

        switch (s[0]) {
        case 'k':
                idx += 3;
        case 'e':
                if (s[1] == 'P') {
                        if (type != ConstLawType::VISCOUS) {
                                return 0;
                        }
                        s++;
                        idx += 21;
                        break;
                }
                break;

        case 'F':
                idx += 6;
                break;

        case 'M':
                idx += 9;
                break;

        case 'X':
                idx += 12;
                break;

        case 'P':
                if (strncasecmp(s, "Phi", STRLENOF("Phi")) != 0) {
                        return 0;
                }
                s += STRLENOF("Phi") - 1;
                idx += 15;
                break;

        case 'O':
                if (strncasecmp(s, "Omega", STRLENOF("Omega")) != 0) {
                        return 0;
                }
                s += STRLENOF("Omega") - 1;
                idx += 18;
                break;

        default:
                return 0;
        }

        switch (s[1]) {
        case 'x':
                idx += 1;
                break;

        case 'y':
                idx += 2;
                break;

        case 'z':
                idx += 3;
                break;

        default:
                return 0;
        }

        if (s[2] != '\0') {
                return 0;
        }

        return idx;
}

void Beam::Init ( void  )

protected

Definition at line 191 of file beam.cc.

References Az, AzLoc, AzRef, DefLoc, DefLocPrev, DefLocRef, DsDxi(), f, g, StructNode::GetRCurr(), StructDispNode::GetXCurr(), InterpState(), L, L0, LRef, NODE1, NODE2, NODE3, NUMNODES, NUMSEZ, Omega, p, pNode, Zero3, and Zero6.

Referenced by Beam().

{
        for (unsigned i = 0; i < NUMSEZ; i++) {
#ifdef USE_NETCDF
                Var_X[i] = 0;
                Var_Phi[i] = 0;
                Var_F[i] = 0;
                Var_M[i] = 0;
                Var_Nu[i] = 0;
                Var_K[i] = 0;
                Var_NuP[i] = 0;
                Var_KP[i] = 0;
#endif /* USE_NETCDF */

                Omega[i] = Zero3;
                Az[i] = Zero6;
                AzRef[i] = Zero6;
                AzLoc[i] = Zero6;
                DefLoc[i] = Zero6;
                DefLocRef[i] = Zero6;
                DefLocPrev[i] = Zero6;
                p[i] = Zero3;
                g[i] = Zero3;
                L0[i] = Zero3;
                L[i] = Zero3;
                LRef[i] = Zero3;
        }

        DsDxi();

        Vec3 xTmp[NUMNODES];

        for (unsigned int i = 0; i < NUMNODES; i++) {
                xTmp[i] = pNode[i]->GetXCurr()+pNode[i]->GetRCurr()*f[i];
        }

        /* Aggiorna le grandezze della trave nei punti di valutazione */
        for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
                p[iSez] = InterpState(xTmp[NODE1],
                        xTmp[NODE2],
                        xTmp[NODE3],
                        Beam::Section(iSez));
        }
}

Here is the call graph for this function:

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

virtual

Implements SubjectToInitialAssembly.

Reimplemented in PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 1236 of file beam.cc.

References AssStiffnessMat(), DEBUGCOUTFNAME, StructDispNode::iGetFirstPositionIndex(), NODE1, NODE2, NODE3, pNode, FullSubMatrixHandler::PutColIndex(), FullSubMatrixHandler::PutRowIndex(), FullSubMatrixHandler::ResizeReset(), and VariableSubMatrixHandler::SetFull().

Referenced by PiezoActuatorBeam::InitialAssJac(), and PiezoActuatorVEBeam::InitialAssJac().

{
        DEBUGCOUTFNAME("Beam::InitialAssJac => AssStiffnessMat");

        /* Dimensiona la matrice, la azzera e pone gli indici corretti */
        FullSubMatrixHandler& WM = WorkMat.SetFull();
        WM.ResizeReset(18, 18);

        integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
        integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
        integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();

        for (int iCnt = 1; iCnt <= 6; iCnt++) {
                WM.PutRowIndex(iCnt, iNode1FirstPosIndex + iCnt);
                WM.PutColIndex(iCnt, iNode1FirstPosIndex + iCnt);
                WM.PutRowIndex(6 + iCnt, iNode2FirstPosIndex + iCnt);
                WM.PutColIndex(6 + iCnt, iNode2FirstPosIndex + iCnt);
                WM.PutRowIndex(12 + iCnt, iNode3FirstPosIndex + iCnt);
                WM.PutColIndex(12 + iCnt, iNode3FirstPosIndex + iCnt);
        }

        AssStiffnessMat(WM, WM, 1., XCurr, XCurr);

        return WorkMat;
}

Here is the call graph for this function:

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

virtual

Implements SubjectToInitialAssembly.

Reimplemented in PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 1265 of file beam.cc.

References AssStiffnessVec(), DEBUGCOUTFNAME, StructDispNode::iGetFirstPositionIndex(), NODE1, NODE2, NODE3, pNode, SubVectorHandler::PutRowIndex(), and VectorHandler::ResizeReset().

Referenced by PiezoActuatorBeam::InitialAssRes(), and PiezoActuatorVEBeam::InitialAssRes().

{
        DEBUGCOUTFNAME("Beam::InitialAssRes => AssStiffnessVec");

        /* Dimensiona il vettore, lo azzera e pone gli indici corretti */
        WorkVec.ResizeReset(18);

        integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
        integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
        integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();

        for (int iCnt = 1; iCnt <= 6; iCnt++) {
                WorkVec.PutRowIndex(iCnt, iNode1FirstPosIndex + iCnt);
                WorkVec.PutRowIndex(6 + iCnt, iNode2FirstPosIndex + iCnt);
                WorkVec.PutRowIndex(12 + iCnt, iNode3FirstPosIndex + iCnt);
        }

        AssStiffnessVec(WorkVec, 1., XCurr, XCurr);

        return WorkVec;
}

Here is the call graph for this function:

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

inlinevirtual

Implements SubjectToInitialAssembly.

Definition at line 402 of file beam.h.

                                                  {
        *piNumRows = 18;
        *piNumCols = 18;
    };

Vec3 Beam::InterpDeriv ( const Vec3 &  v1, const Vec3 &  v2, const Vec3 &  v3, enum Section  Sec  )

protected

Definition at line 446 of file beam.cc.

References dN3P, dsdxi, and Vec3::pGetVec().

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), and DsDxi().

{
        const doublereal* pv1 = v1.pGetVec();
        const doublereal* pv2 = v2.pGetVec();
        const doublereal* pv3 = v3.pGetVec();

        return Vec3(
                (pv1[0]*dN3P[Sec][0] + pv2[0]*dN3P[Sec][1]
                        + pv3[0]*dN3P[Sec][2])*dsdxi[Sec],
                (pv1[1]*dN3P[Sec][0] + pv2[1]*dN3P[Sec][1]
                        + pv3[1]*dN3P[Sec][2])*dsdxi[Sec],
                (pv1[2]*dN3P[Sec][0] + pv2[2]*dN3P[Sec][1]
                        + pv3[2]*dN3P[Sec][2])*dsdxi[Sec]);
}

Here is the call graph for this function:

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

staticprotected

Definition at line 429 of file beam.cc.

References dN3, and Vec3::pGetVec().

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), Init(), and ReadBeam().

{
        const doublereal* pv1 = v1.pGetVec();
        const doublereal* pv2 = v2.pGetVec();
        const doublereal* pv3 = v3.pGetVec();

        return Vec3(
                pv1[0]*dN3[Sec][0] + pv2[0]*dN3[Sec][1] + pv3[0]*dN3[Sec][2],
                pv1[1]*dN3[Sec][0] + pv2[1]*dN3[Sec][1] + pv3[1]*dN3[Sec][2],
                pv1[2]*dN3[Sec][0] + pv2[2]*dN3[Sec][1] + pv3[2]*dN3[Sec][2]);
}

Here is the call graph for this function:

void Beam::Omega0 ( void  )

protectedvirtual

Definition at line 519 of file beam.cc.

References ASSERT, dN3, StructDispNode::GetNodeType(), StructNode::GetRCurr(), StructNode::GetWCurr(), CGR_Rot::MatG, CGR_Rot::MatGm1, NODE1, NODE2, NODE3, NUMNODES, NUMSEZ, Omega, CGR_Rot::Param, pNode, RNode, and Node::STRUCTURAL.

Referenced by ViscoElasticBeam::Init().

{
        /* Validazione dati */
        ASSERT(pNode[NODE1] != NULL);
        ASSERT(pNode[NODE1]->GetNodeType() == Node::STRUCTURAL);
        ASSERT(pNode[NODE2] != NULL);
        ASSERT(pNode[NODE2]->GetNodeType() == Node::STRUCTURAL);
        ASSERT(pNode[NODE3] != NULL);
        ASSERT(pNode[NODE3]->GetNodeType() == Node::STRUCTURAL);

        /* Modo consistente: */
        Mat3x3 RNod[NUMNODES];
        Vec3 w[NUMNODES];
        for (unsigned int i = 0; i < NUMNODES; i++) {
                RNod[i] = pNode[i]->GetRCurr()*RNode[i];
                w[i] = pNode[i]->GetWCurr();
        }

        /* Calcolo i parametri di rotazione dei nodi di estremo rispetto a quello
         * centrale, nell'ipotesi (realistica) che siano limitati */
        Vec3 g1(CGR_Rot::Param, RNod[NODE2].MulTM(RNod[NODE1]));
        Vec3 g3(CGR_Rot::Param, RNod[NODE2].MulTM(RNod[NODE3]));

        /* Calcolo le derivate dei parametri di rotazione ai nodi di estremo; in
         * quello centrale si assume che sia uguale alla velocita' di rotazione */
        Vec3 g1P(Mat3x3(CGR_Rot::MatGm1, g1)*w[NODE1]);
        Vec3 g3P(Mat3x3(CGR_Rot::MatGm1, g3)*w[NODE3]);

        for (unsigned int i = 0; i < NUMSEZ; i++) {
                Vec3 gTmp(g1*dN3[i][NODE1]+g3*dN3[i][NODE3]);
                Vec3 gPTmp(g1P*dN3[i][NODE1]+w[NODE2]*dN3[i][NODE2]+g3P*dN3[i][NODE3]);
                Omega[i] = Mat3x3(CGR_Rot::MatG, gTmp)*gPTmp;
        }

#if 0
        /* Modo brutale: interpolo le velocita' dei nodi */
        Vec3 w[NUMNODES];
        for (unsigned int i = 0; i < NUMNODES; i++) {
                w[i] = pNode[i]->GetWCurr();
        }
        for (unsigned int i = 0; i < NUMSEZ; i++) {
        Omega[i] = (w{NODE1]*dN3[i][NODE1]
                + w[NODE2]*dN3[i][NODE2]
                + w[NODE3]*dN3[i][NODE3]);
        }
#endif /* 0 */
}

Here is the call graph for this function:

void Beam::Output ( OutputHandler &  OH ) const

virtual

Reimplemented from ToBeOutput.

Definition at line 1141 of file beam.cc.

References AzLoc, OutputHandler::BEAMS, OutputHandler::Beams(), ToBeOutput::bToBeOutput(), DefLoc, DefPrimeLoc, dRaDegr, EULER_123, EULER_313, EULER_321, OutputHandler::GetCurrentStep(), WithLabel::GetLabel(), Vec6::GetVec1(), Vec6::GetVec2(), MatR2EulerAngles123(), MatR2EulerAngles313(), MatR2EulerAngles321(), NUMSEZ, od, ORIENTATION_MATRIX, ORIENTATION_VECTOR, p, Vec3::pGetVec(), R, S_I, SII, OutputHandler::UseNetCDF(), OutputHandler::UseText(), and RotManip::VecRot().

{
        if (bToBeOutput()) {
#ifdef USE_NETCDF
                if (OH.UseNetCDF(OutputHandler::BEAMS)) {
                        for (unsigned iSez = 0; iSez < NUMSEZ; iSez++) {
                                if (Var_X[iSez]) {
                                        Var_X[iSez]->put_rec(p[iSez].pGetVec(), OH.GetCurrentStep());
                                }

                                if (Var_Phi[iSez]) {
                                        Vec3 E;
                                        switch (od) {
                                        case EULER_123:
                                                E = MatR2EulerAngles123(R[iSez])*dRaDegr;
                                                break;

                                        case EULER_313:
                                                E = MatR2EulerAngles313(R[iSez])*dRaDegr;
                                                break;

                                        case EULER_321:
                                                E = MatR2EulerAngles321(R[iSez])*dRaDegr;
                                                break;

                                        case ORIENTATION_VECTOR:
                                                E = RotManip::VecRot(R[iSez]);
                                                break;

                                        case ORIENTATION_MATRIX:
                                                break;

                                        default:
                                                /* impossible */
                                                break;
                                        }

                                        switch (od) {
                                        case EULER_123:
                                        case EULER_313:
                                        case EULER_321:
                                        case ORIENTATION_VECTOR:
                                                Var_Phi[iSez]->put_rec(E.pGetVec(), OH.GetCurrentStep());
                                                break;

                                        case ORIENTATION_MATRIX:
                                                Var_Phi[iSez]->put_rec(R[iSez].pGetMat(), OH.GetCurrentStep());
                                                break;

                                        default:
                                                /* impossible */
                                                break;
                                        }
                                }

                                if (Var_F[iSez]) {
                                        Var_F[iSez]->put_rec(AzLoc[iSez].GetVec1().pGetVec(), OH.GetCurrentStep());
                                }

                                if (Var_M[iSez]) {
                                        Var_M[iSez]->put_rec(AzLoc[iSez].GetVec2().pGetVec(), OH.GetCurrentStep());
                                }

                                if (Var_Nu[iSez]) {
                                        Var_Nu[iSez]->put_rec(DefLoc[iSez].GetVec1().pGetVec(), OH.GetCurrentStep());
                                }

                                if (Var_K[iSez]) {
                                        Var_K[iSez]->put_rec(DefLoc[iSez].GetVec2().pGetVec(), OH.GetCurrentStep());
                                }

                                if (Var_NuP[iSez]) {
                                        Var_NuP[iSez]->put_rec(DefPrimeLoc[iSez].GetVec1().pGetVec(), OH.GetCurrentStep());
                                }

                                if (Var_KP[iSez]) {
                                        Var_KP[iSez]->put_rec(DefPrimeLoc[iSez].GetVec2().pGetVec(), OH.GetCurrentStep());
                                }
                        }
                }
#endif /* USE_NETCDF */

                if (OH.UseText(OutputHandler::BEAMS)) {
                        OH.Beams() << std::setw(8) << GetLabel()
                                << " " << AzLoc[S_I].GetVec1()
                                << " " << AzLoc[S_I].GetVec2()
                                << " " << AzLoc[SII].GetVec1()
                                << " " << AzLoc[SII].GetVec2()
                                << std::endl;
                }
        }
}

Here is the call graph for this function:

void Beam::OutputPrepare ( OutputHandler &  OH )

virtual

Reimplemented from ToBeOutput.

Definition at line 1047 of file beam.cc.

References ASSERT, OutputHandler::BEAMS, ToBeOutput::bToBeOutput(), ELASTIC, ToBeOutput::fToBeOutput(), GetBeamType(), WithLabel::GetLabel(), OutputHandler::IsOpen(), OutputHandler::NETCDF, NUMSEZ, od, OUTPUT_EP_F, OUTPUT_EP_K, OUTPUT_EP_KP, OUTPUT_EP_M, OUTPUT_EP_NU, OUTPUT_EP_NUP, OUTPUT_EP_R, OUTPUT_EP_X, ToBeOutput::OUTPUT_PRIVATE_MASK, PIEZOELECTRICELASTIC, PIEZOELECTRICVISCOELASTIC, OutputHandler::UseNetCDF(), and VISCOELASTIC.

{
        if (bToBeOutput()) {
#ifdef USE_NETCDF
                if (OH.UseNetCDF(OutputHandler::BEAMS)) {
                        ASSERT(OH.IsOpen(OutputHandler::NETCDF));

                        const char *type = 0;
                        switch (GetBeamType()) {
                        case Beam::ELASTIC:
                                type = "elastic";
                                break;

                        case Beam::VISCOELASTIC:
                                type = "viscoelastic";
                                break;

                        case Beam::PIEZOELECTRICELASTIC:
                                type = "piezoelectric elastic";
                                break;

                        case Beam::PIEZOELECTRICVISCOELASTIC:
                                type = "piezoelectric viscoelastic";
                                break;

                        default:
                                type = "unknown";
                                break;
                        }

                        std::ostringstream os;
                        os << "elem.beam." << GetLabel();

                        (void)OH.CreateVar(os.str(), type);

                        os << '.';
                        std::string name(os.str());

                        unsigned uOutputFlags = (fToBeOutput() & ToBeOutput::OUTPUT_PRIVATE_MASK);

                        static const char *sez[] = { "I", "II" };
                        for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
                                os.str("");
                                os << "evaluation point " << sez[iSez] << " ";
                                std::string ep(os.str());

                                if (uOutputFlags & Beam::OUTPUT_EP_X) {
                                        Var_X[iSez] = OH.CreateVar<Vec3>(name + "X_" + sez[iSez], "m",
                                                ep + "global position vector (X, Y, Z)");
                                }

                                if (uOutputFlags & Beam::OUTPUT_EP_R) {
                                        Var_Phi[iSez] = OH.CreateRotationVar(name,
                                                std::string("_") + sez[iSez], od, ep + "global");
                                }

                                if (uOutputFlags & Beam::OUTPUT_EP_F) {
                                        Var_F[iSez] = OH.CreateVar<Vec3>(name + "F_" + sez[iSez], "N",
                                                ep + "internal force in local frame (F_X, F_Y, F_Z)");
                                }

                                if (uOutputFlags & Beam::OUTPUT_EP_M) {
                                        Var_M[iSez] = OH.CreateVar<Vec3>(name + "M_" + sez[iSez], "Nm",
                                                ep + "internal moment in local frame (M_X, M_Y, M_Z)");
                                }

                                if (uOutputFlags & Beam::OUTPUT_EP_NU) {
                                        Var_Nu[iSez] = OH.CreateVar<Vec3>(name + "nu_" + sez[iSez], "-",
                                                ep + "linear strain in local frame (nu_X, nu_Y, nu_Z)");
                                }

                                if (uOutputFlags & Beam::OUTPUT_EP_K) {
                                        Var_K[iSez] = OH.CreateVar<Vec3>(name + "k_" + sez[iSez], "1/m",
                                                ep + "angular strain in local frame (K_X, K_Y, K_Z)");
                                }

                                if (uOutputFlags & Beam::OUTPUT_EP_NUP) {
                                        Var_NuP[iSez] = OH.CreateVar<Vec3>(name + "nuP_" + sez[iSez], "1/s",
                                                ep + "linear strain rate in local frame (nuP_X, nuP_Y, nuP_Z)");
                                }

                                if (uOutputFlags & Beam::OUTPUT_EP_KP) {
                                        Var_KP[iSez] = OH.CreateVar<Vec3>(name + "kP_" + sez[iSez], "1/ms",
                                                ep + "angular strain rate in local frame (KP_X, KP_Y, KP_Z)");
                                }
                        }
                }
#endif // USE_NETCDF
        }
}

Here is the call graph for this function:

const StructNode * Beam::pGetNode ( unsigned int  i ) const

virtual

Definition at line 1290 of file beam.cc.

References ASSERT, MBDYN_EXCEPT_ARGS, and pNode.

Referenced by AerodynamicBeam::AerodynamicBeam(), BeamConn::pGetNode(), and ReadAerodynamicBeam().

{
        ASSERT(i >= 1 && i <= 3);
        switch (i) {
        case 1:
        case 2:
        case 3:
                return pNode[i-1];
        default:
                throw Beam::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }
}

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

virtual

Implements Elem.

Reimplemented in PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 570 of file beam.cc.

References Restart_().

{
        return Restart_(out)<< ';' << std::endl;
}

Here is the call graph for this function:

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

protectedvirtual

Definition at line 576 of file beam.cc.

References f, WithLabel::GetLabel(), Mat3x3::GetVec(), NUMNODES, NUMSEZ, pD, ConstitutiveLawOwner< T, Tder >::pGetConstLaw(), pNode, R, Write(), and Vec3::Write().

Referenced by PiezoActuatorBeam::Restart(), PiezoActuatorVEBeam::Restart(), and Restart().

{
        out << "  beam: " << GetLabel();
        for (unsigned int i = 0; i < NUMNODES; i++) {
                out << ", " << pNode[i]->GetLabel() << ", reference, node, ",
                        f[i].Write(out, ", ");
        }

        for (unsigned int i = 0; i < NUMSEZ; i++) {
                out << ", reference, global, 1, ",
                        (R[i].GetVec(1)).Write(out, ", ")
                        << ", 2, ", (R[i].GetVec(2)).Write(out, ", ") << ", ",
                        pD[i]->pGetConstLaw()->Restart(out);
        }

        return out;
}

Here is the call graph for this function:

virtual void Beam::SetInitialValue ( VectorHandler &  )

inlinevirtual

Definition at line 409 of file beam.h.

References NO_OP.

                                                    {
        NO_OP;
    };

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

virtual

Implements ElemGravityOwner.

Reimplemented in ViscoElasticBeam, PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 966 of file beam.cc.

References Az, AzRef, bFirstRes, DefLoc, DefLocRef, DRef, L, LRef, MultRMRt(), NUMSEZ, pD, R, and RRef.

Referenced by PiezoActuatorBeam::SetValue(), and ViscoElasticBeam::SetValue().

{
        /* Aggiorna le grandezze della trave nei punti di valutazione */
        for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
                RRef[iSez] = R[iSez];
                LRef[iSez] = L[iSez];
                DefLocRef[iSez] = DefLoc[iSez];
                AzRef[iSez] = Az[iSez];

                /* Aggiorna il legame costitutivo di riferimento
                 * (la deformazione e' gia' stata aggiornata dall'ultimo residuo) */
                DRef[iSez] = MultRMRt(pD[iSez]->GetFDE(), RRef[iSez]);
        }

        bFirstRes = true;
}

Here is the call graph for this function:

virtual void Beam::WorkSpaceDim ( integer *  piNumRows, integer *  piNumCols  ) const

inlinevirtual

Implements Elem.

Reimplemented in PiezoActuatorVEBeam, and PiezoActuatorBeam.

Definition at line 317 of file beam.h.

References bConsistentInertia.

                                                                            {
        if (bConsistentInertia) {
            *piNumRows = 36;
        } else {
            *piNumRows = 18;
        }

        *piNumCols = 18;
    };

Friends And Related Function Documentation

friend class AerodynamicBeam

friend

Definition at line 58 of file beam.h.

friend class Beam2

friend

Definition at line 60 of file beam.h.

Elem* ReadBeam ( DataManager *  pDM, MBDynParser &  HP, unsigned int  uLabel  )

friend

Definition at line 1876 of file beam.cc.

{
        DEBUGCOUTFNAME("ReadBeam");

        /* Per ogni nodo: */

        /* Nodo 1 */
        const StructNode* pNode1 = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);

        const Mat3x3& R1(pNode1->GetRCurr());
        if (HP.IsKeyWord("position")) {
                /* just eat it! */
                NO_OP;
        }
        Vec3 f1(HP.GetPosRel(ReferenceFrame(pNode1)));
        Mat3x3 Rn1(Eye3);
        if (HP.IsKeyWord("orientation") || HP.IsKeyWord("rot")) {
                Rn1 = HP.GetRotRel(ReferenceFrame(pNode1));
        }

        DEBUGLCOUT(MYDEBUG_INPUT, "node 1 offset (node reference frame): "
                << f1 << std::endl
                << "(global frame): "
                << pNode1->GetXCurr()+pNode1->GetRCurr()*f1 << std::endl);

        /* Nodo 2 */
        const StructNode* pNode2 = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);

        Mat3x3 R2(pNode2->GetRCurr());
        if (HP.IsKeyWord("position")) {
                /* just eat it! */
                NO_OP;
        }
        Vec3 f2(HP.GetPosRel(ReferenceFrame(pNode2)));
        Mat3x3 Rn2(Eye3);
        if (HP.IsKeyWord("orientation") || HP.IsKeyWord("rot")) {
                Rn2 = HP.GetRotRel(ReferenceFrame(pNode2));
        }

        DEBUGLCOUT(MYDEBUG_INPUT, "node 2 offset (node reference frame): "
                << f2 << std::endl
                << "(global frame): "
                << pNode2->GetXCurr()+pNode2->GetRCurr()*f2 << std::endl);

        /* Nodo 3 */
        const StructNode* pNode3 = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);

        Mat3x3 R3(pNode3->GetRCurr());
        if (HP.IsKeyWord("position")) {
                /* just eat it! */
                NO_OP;
        }
        Vec3 f3(HP.GetPosRel(ReferenceFrame(pNode3)));
        Mat3x3 Rn3(Eye3);
        if (HP.IsKeyWord("orientation") || HP.IsKeyWord("rot")) {
                Rn3 = HP.GetRotRel(ReferenceFrame(pNode3));
        }

        DEBUGLCOUT(MYDEBUG_INPUT, "node 3 offset (node reference frame): "
                << f3 << std::endl
                << "(global frame): "
                << pNode3->GetXCurr()+pNode3->GetRCurr()*f3 << std::endl);

        /*   Per ogni punto: */

        /* Punto I */

        /*     Matrice R */
        Mat3x3 R_I;
        bool b_I(false);
        if (HP.IsKeyWord("from" "nodes") || HP.IsKeyWord("node")) {
                b_I = true;
        } else {
                R_I = HP.GetRotAbs(::AbsRefFrame);
        }

        /*     Legame costitutivo */
        ConstLawType::Type CLType_I = ConstLawType::UNKNOWN;
        ConstitutiveLaw6D* pD_I = HP.GetConstLaw6D(CLType_I);

        if (pD_I->iGetNumDof() != 0) {
                silent_cerr("line " << HP.GetLineData()
                        << ": Beam(" << uLabel << ") "
                        "does not support dynamic constitutive laws yet"
                        << std::endl);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

#ifdef DEBUG
        Mat6x6 MTmp(pD_I->GetFDE());
        Mat3x3 D11(MTmp.GetMat11());
        Mat3x3 D12(MTmp.GetMat12());
        Mat3x3 D21(MTmp.GetMat21());
        Mat3x3 D22(MTmp.GetMat22());

        DEBUGLCOUT(MYDEBUG_INPUT,
                "First point matrix D11: " << std::endl << D11 << std::endl
                << "First point matrix D12: " << std::endl << D12 << std::endl
                << "First point matrix D21: " << std::endl << D21 << std::endl
                << "First point matrix D22: " << std::endl << D22 << std::endl);
#endif


        /* Punto II */

        /* Matrice R */
        Mat3x3 RII;
        bool bII(false);
        if (HP.IsKeyWord("same")) {
                if (b_I) {
                        bII = true;
                } else {
                        RII = R_I;
                }
        } else {
                if (HP.IsKeyWord("from" "nodes") || HP.IsKeyWord("node")) {
                        bII = true;
                } else {
                        RII = HP.GetRotAbs(::AbsRefFrame);
                }
        }

        /* Legame costitutivo */
        ConstLawType::Type CLTypeII = ConstLawType::UNKNOWN;
        ConstitutiveLaw6D* pDII = NULL;

        if (HP.IsKeyWord("same")) {
                pDII = pD_I->pCopy();
                CLTypeII = CLType_I;

        } else {
                pDII = HP.GetConstLaw6D(CLTypeII);

                if (pDII->iGetNumDof() != 0) {
                        silent_cerr("line " << HP.GetLineData()
                                << ": Beam(" << uLabel << ") "
                                "does not support dynamic constitutive laws yet"
                                << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
        }

        Beam::Type Type;
        if (CLType_I == ConstLawType::ELASTIC && CLTypeII == ConstLawType::ELASTIC) {
                Type = Beam::ELASTIC;
        } else {
                Type = Beam::VISCOELASTIC;
        }

#ifdef DEBUG
        MTmp = pDII->GetFDE();
        D11 = MTmp.GetMat11();
        D12 = MTmp.GetMat12();
        D21 = MTmp.GetMat21();
        D22 = MTmp.GetMat22();

        DEBUGLCOUT(MYDEBUG_INPUT,
                "Second point matrix D11: " << std::endl << D11 << std::endl
                << "Second point matrix D12: " << std::endl << D12 << std::endl
                << "Second point matrix D21: " << std::endl << D21 << std::endl
                << "Second point matrix D22: " << std::endl << D22 << std::endl);
#endif

        flag fPiezo(0);
        Mat3xN PiezoMat[2][2];
        integer iNumElec = 0;
        const ScalarDifferentialNode **pvElecDofs = 0;
        if (HP.IsKeyWord("piezoelectric" "actuator")) {
                fPiezo = flag(1);
                DEBUGLCOUT(MYDEBUG_INPUT,
                        "Piezoelectric actuator beam is expected" << std::endl);

                iNumElec = HP.GetInt();
                DEBUGLCOUT(MYDEBUG_INPUT,
                        "piezo actuator " << uLabel << " has " << iNumElec
                        << " electrodes" << std::endl);
                if (iNumElec <= 0) {
                        silent_cerr("PiezoElectricBeam(" << uLabel << "): "
                                "illegal number of electric nodes " << iNumElec
                                << " at line " << HP.GetLineData() << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }

                SAFENEWARR(pvElecDofs, const ScalarDifferentialNode *, iNumElec);

                for (integer i = 0; i < iNumElec; i++) {
                        pvElecDofs[i] = pDM->ReadNode<const ScalarDifferentialNode, Node::ABSTRACT>(HP);
                }

                PiezoMat[0][0].Resize(iNumElec);
                PiezoMat[1][0].Resize(iNumElec);
                PiezoMat[0][1].Resize(iNumElec);
                PiezoMat[1][1].Resize(iNumElec);

                /* leggere le matrici (6xN sez. 1, 6xN sez. 2) */
                HP.GetMat6xN(PiezoMat[0][0], PiezoMat[1][0], iNumElec);
                if (HP.IsKeyWord("same")) {
                        PiezoMat[0][1].Copy(PiezoMat[0][0]);
                        PiezoMat[1][1].Copy(PiezoMat[1][0]);
                } else {
                        HP.GetMat6xN(PiezoMat[0][1], PiezoMat[1][1], iNumElec);
                }

#if 0
                DEBUGLCOUT(MYDEBUG_INPUT, "Piezo matrix I:" << std::endl << PiezoMat[0][0] << PiezoMat[1][0]);
                DEBUGLCOUT(MYDEBUG_INPUT, "Piezo matrix II:" << std::endl << PiezoMat[0][1] << PiezoMat[1][1]);
#endif /* 0 */
        }

        OrientationDescription od = UNKNOWN_ORIENTATION_DESCRIPTION;
        unsigned uFlags = Beam::OUTPUT_NONE;
        ReadOptionalBeamCustomOutput(pDM, HP, uLabel, Type, uFlags, od);

        flag fOut = pDM->fReadOutput(HP, Elem::BEAM);
        if (fOut) {
                fOut |= uFlags;
        }

        /* Se necessario, interpola i parametri di rotazione delle sezioni */
        if (b_I || bII) {
                Mat3x3 R(R2*Rn2);
                Vec3 g1(CGR_Rot::Param, R.MulTM(R1*Rn1));
                Vec3 g3(CGR_Rot::Param, R.MulTM(R3*Rn3));
                if (b_I) {
                        R_I = R*Mat3x3(CGR_Rot::MatR, Beam::InterpState(g1, Zero3, g3, Beam::S_I));
                }
                if (bII) {
                        RII = R*Mat3x3(CGR_Rot::MatR, Beam::InterpState(g1, Zero3, g3, Beam::SII));
                }
        }

        std::ostream& out = pDM->GetLogFile();
        out << "beam3: " << uLabel
                << " " << pNode1->GetLabel()
                << " ", f1.Write(out, " ")
                << " " << pNode2->GetLabel()
                << " ", f2.Write(out, " ")
                << " " << pNode3->GetLabel()
                << " ", f3.Write(out, " ")
                << std::endl;

        Elem* pEl = NULL;

        if ((CLType_I == ConstLawType::ELASTIC)
                && (CLTypeII == ConstLawType::ELASTIC))
        {
                if (fPiezo == 0) {
                        SAFENEWWITHCONSTRUCTOR(pEl,
                                Beam,
                                Beam(uLabel,
                                        pNode1, pNode2, pNode3,
                                        f1, f2, f3,
                                        Rn1, Rn2, Rn3,
                                        R_I, RII,
                                        pD_I, pDII,
                                        od, fOut));
                } else {
                        SAFENEWWITHCONSTRUCTOR(pEl,
                                PiezoActuatorBeam,
                                PiezoActuatorBeam(uLabel,
                                        pNode1, pNode2, pNode3,
                                        f1, f2, f3,
                                        Rn1, Rn2, Rn3,
                                        R_I, RII,
                                        pD_I, pDII,
                                        iNumElec,
                                        pvElecDofs,
                                        PiezoMat[0][0], PiezoMat[1][0],
                                        PiezoMat[0][1], PiezoMat[1][1],
                                        od, fOut));
                }

        } else /* At least one is VISCOUS or VISCOELASTIC */ {
                if (fPiezo == 0) {
                        SAFENEWWITHCONSTRUCTOR(pEl,
                                ViscoElasticBeam,
                                ViscoElasticBeam(uLabel,
                                        pNode1, pNode2, pNode3,
                                        f1, f2, f3,
                                        Rn1, Rn2, Rn3,
                                        R_I, RII,
                                        pD_I, pDII,
                                        od, fOut));
                } else {
                        SAFENEWWITHCONSTRUCTOR(pEl,
                                PiezoActuatorVEBeam,
                                PiezoActuatorVEBeam(uLabel,
                                        pNode1, pNode2, pNode3,
                                        f1, f2, f3,
                                        Rn1, Rn2, Rn3,
                                        R_I, RII,
                                        pD_I, pDII,
                                        iNumElec,
                                        pvElecDofs,
                                        PiezoMat[0][0], PiezoMat[1][0],
                                        PiezoMat[0][1], PiezoMat[1][1],
                                        od, fOut));
                }
        }

        /* Costruttore normale
         * Beam(unsigned int uL,
         *      const StructNode* pN1, const StructNode* pN2, const StructNode* pN3,
         *         const Vec3& X1, const Vec3& X2, const Vec3& X3,
         *         const Vec3& F1, const Vec3& F2, const Vec3& F3,
         *         const Mat3x3& r_I, const Mat3x3& rII,
         *         const Mat3x3& d11_I, const Mat3x3& d12_I,
         *         const Mat3x3& d21_I, const Mat3x3& d22_I,
         *         const Mat3x3& d11II, const Mat3x3& d12II,
         *         const Mat3x3& d21II, const Mat3x3& d22II,
         *         const Vec3& eps0_I, const Vec3& k0_I,
         *         const Vec3& eps0II, const Vec3& k0II);
         */


        /* Se non c'e' il punto e virgola finale */
        if (HP.IsArg()) {
                silent_cerr("semicolon expected "
                        "at line " << HP.GetLineData() << std::endl);
                throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        return pEl;
} /* End of ReadBeam() */

Member Data Documentation

Vec6 Beam::Az[NUMSEZ]

protected

Definition at line 177 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessMat(), ViscoElasticBeam::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), Init(), and SetValue().

Vec6 Beam::AzLoc[NUMSEZ]

protected

Definition at line 179 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), dGetPrivData(), Init(), and Output().

Vec6 Beam::AzRef[NUMSEZ]

protected

Definition at line 178 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), Init(), and SetValue().

const bool Beam::bConsistentInertia

protected

Definition at line 162 of file beam.h.

Referenced by PiezoActuatorBeam::AssJac(), PiezoActuatorVEBeam::AssJac(), AssJac(), AssMats(), AssRes(), PiezoActuatorBeam::WorkSpaceDim(), PiezoActuatorVEBeam::WorkSpaceDim(), and WorkSpaceDim().

bool Beam::bFirstRes

protected

Definition at line 197 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), PiezoActuatorBeam::AssStiffnessVec(), PiezoActuatorVEBeam::AssStiffnessVec(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), SetValue(), and ViscoElasticBeam::SetValue().

Vec6 Beam::DefLoc[NUMSEZ]

protected

Definition at line 180 of file beam.h.

Referenced by AfterConvergence(), ViscoElasticBeam::AfterConvergence(), AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), dGetPrivData(), Init(), Output(), and SetValue().

Vec6 Beam::DefLocPrev[NUMSEZ]

protected

Definition at line 182 of file beam.h.

Referenced by AfterConvergence(), ViscoElasticBeam::AfterConvergence(), AfterPredict(), ViscoElasticBeam::AfterPredict(), and Init().

Vec6 Beam::DefLocRef[NUMSEZ]

protected

Definition at line 181 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), Init(), and SetValue().

Vec6 Beam::DefPrimeLoc[NUMSEZ]

protected

Definition at line 185 of file beam.h.

Referenced by ViscoElasticBeam::AfterConvergence(), ViscoElasticBeam::AfterPredict(), ViscoElasticBeam::AssStiffnessVec(), ViscoElasticBeam::dGetPrivData(), ViscoElasticBeam::Init(), Output(), and ViscoElasticBeam::SetValue().

const doublereal Beam::dMass_I

protected

Definition at line 164 of file beam.h.

const doublereal Beam::dMassII

protected

Definition at line 168 of file beam.h.

Mat6x6 Beam::DRef[NUMSEZ]

protected

Definition at line 159 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessMat(), ViscoElasticBeam::AssStiffnessMat(), DsDxi(), and SetValue().

doublereal Beam::dsdxi[NUMSEZ]

protected

Definition at line 194 of file beam.h.

Referenced by AssStiffnessMat(), ViscoElasticBeam::AssStiffnessMat(), DsDxi(), and InterpDeriv().

const Vec3 Beam::f[NUMNODES]

protected

Definition at line 145 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessMat(), ViscoElasticBeam::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), Beam(), DsDxi(), Init(), and Restart_().

Vec3 Beam::fRef[NUMNODES]

protected

Definition at line 146 of file beam.h.

Vec3 Beam::g[NUMSEZ]

protected

Definition at line 188 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), and Init().

const unsigned int Beam::iNumPrivData

staticprotected

Initial value:

=
                +3              
                +3              
                +3              
                +3              
                +3              
                +3              
                +3              
                +3              
                +3

Definition at line 100 of file beam.h.

Referenced by dGetPrivData(), ViscoElasticBeam::dGetPrivData(), Beam2::iGetNumPrivData(), iGetNumPrivData(), and iGetPrivDataIdx().

const Mat3x3 Beam::J0_I

protected

Definition at line 166 of file beam.h.

const Mat3x3 Beam::J0II

protected

Definition at line 170 of file beam.h.

Vec3 Beam::L[NUMSEZ]

protected

Definition at line 190 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessMat(), ViscoElasticBeam::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), Init(), and SetValue().

Vec3 Beam::L0[NUMSEZ]

protected

Definition at line 189 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), DsDxi(), and Init().

Vec3 Beam::LRef[NUMSEZ]

protected

Definition at line 192 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), Init(), and SetValue().

OrientationDescription Beam::od

protected

Definition at line 116 of file beam.h.

Referenced by Output(), and OutputPrepare().

Vec3 Beam::Omega[NUMSEZ]

protected

Definition at line 173 of file beam.h.

Referenced by ViscoElasticBeam::AfterPredict(), ViscoElasticBeam::AssStiffnessMat(), ViscoElasticBeam::AssStiffnessVec(), dGetPrivData(), Init(), ViscoElasticBeam::Init(), Omega0(), and ViscoElasticBeam::SetValue().

Vec3 Beam::OmegaRef[NUMSEZ]

protected

Definition at line 174 of file beam.h.

Referenced by ViscoElasticBeam::AfterPredict(), ViscoElasticBeam::AssStiffnessVec(), ViscoElasticBeam::Init(), and ViscoElasticBeam::SetValue().

Vec3 Beam::p[NUMSEZ]

protected

Definition at line 187 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), PiezoActuatorBeam::AssStiffnessMat(), PiezoActuatorVEBeam::AssStiffnessMat(), AssStiffnessMat(), ViscoElasticBeam::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), dGetPrivData(), Init(), and Output().

ConstitutiveLaw6DOwner* Beam::pD[NUMSEZ]

protected

Definition at line 156 of file beam.h.

Referenced by AfterConvergence(), ViscoElasticBeam::AfterConvergence(), AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), Beam(), DsDxi(), ViscoElasticBeam::Init(), Restart_(), SetValue(), ViscoElasticBeam::SetValue(), and ~Beam().

const StructNode* Beam::pNode[NUMNODES]

protected

Definition at line 142 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), PiezoActuatorBeam::AssJac(), PiezoActuatorVEBeam::AssJac(), AssJac(), AssMats(), AssRes(), PiezoActuatorBeam::AssStiffnessMat(), PiezoActuatorVEBeam::AssStiffnessMat(), AssStiffnessMat(), ViscoElasticBeam::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), Beam(), DsDxi(), GetConnectedNodes(), Init(), InitialAssJac(), InitialAssRes(), Omega0(), pGetNode(), and Restart_().

Mat3x3 Beam::R[NUMSEZ]

protected

Definition at line 151 of file beam.h.

Referenced by AfterConvergence(), ViscoElasticBeam::AfterConvergence(), AfterPredict(), ViscoElasticBeam::AfterPredict(), PiezoActuatorBeam::AssStiffnessMat(), PiezoActuatorVEBeam::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), Beam(), dGetPrivData(), DsDxi(), Output(), Restart_(), and SetValue().

const Mat3x3 Beam::RNode[NUMNODES]

protected

Definition at line 147 of file beam.h.

Referenced by Beam(), and Omega0().

Mat3x3 Beam::RPrev[NUMSEZ]

protected

Definition at line 153 of file beam.h.

Referenced by AfterConvergence(), ViscoElasticBeam::AfterConvergence(), AfterPredict(), ViscoElasticBeam::AfterPredict(), and Beam().

Mat3x3 Beam::RRef[NUMSEZ]

protected

Definition at line 152 of file beam.h.

Referenced by AfterPredict(), ViscoElasticBeam::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam::AssStiffnessVec(), Beam(), ViscoElasticBeam::Init(), SetValue(), and ViscoElasticBeam::SetValue().

const Vec3 Beam::S0_I

protected

Definition at line 165 of file beam.h.

const Vec3 Beam::S0II

protected

Definition at line 169 of file beam.h.

---

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

• beam.h
• beam.cc