Beam2 Class Reference

#include <beam2.h>

Inheritance diagram for Beam2:

Collaboration diagram for Beam2:

Classes
class	ErrGeneric

Public Member Functions
	Beam2 (unsigned int uL, const StructNode *pN1, const StructNode *pN2, const Vec3 &F1, const Vec3 &F2, const Mat3x3 &R1, const Mat3x3 &R2, const Mat3x3 &r, const ConstitutiveLaw6D *pd, OrientationDescription ood, flag fOut)
virtual	~Beam2 (void)
virtual 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	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 VariableSubMatrixHandler &	AssJac (VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
virtual void	OutputPrepare (OutputHandler &OH)
virtual void	Output (OutputHandler &OH) const
virtual bool	bInverseDynamics (void) const
VariableSubMatrixHandler &	AssJac (VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
SubVectorHandler &	AssRes (SubVectorHandler &WorkVec, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr, const VectorHandler &XPrimePrimeCurr, InverseDynamics::Order iOrder=InverseDynamics::INVERSE_DYNAMICS)
void	Update (const VectorHandler &XCurr, InverseDynamics::Order iOrder=InverseDynamics::INVERSE_DYNAMICS)
virtual void	AfterConvergence (const VectorHandler &X, const VectorHandler &XP, const VectorHandler &XPP)
virtual unsigned int	iGetInitialNumDof (void) const
virtual void	InitialWorkSpaceDim (integer *piNumRows, integer *piNumCols) const
virtual void	SetInitialValue (VectorHandler &)
virtual VariableSubMatrixHandler &	InitialAssJac (VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
virtual SubVectorHandler &	InitialAssRes (SubVectorHandler &WorkVec, const VectorHandler &XCurr)
virtual unsigned int	iGetNumPrivData (void) const
virtual unsigned int	iGetPrivDataIdx (const char *s) const
virtual 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
virtual void	AssMats (VariableSubMatrixHandler &WorkMatA, VariableSubMatrixHandler &WorkMatB, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
void	SetInverseDynamicsFlags (unsigned uIDF)
unsigned	GetInverseDynamicsFlags (void) const
bool	bIsErgonomy (void) const
bool	bIsRightHandSide (void) const
virtual int	GetNumConnectedNodes (void) const
Public Member Functions inherited from WithLabel
	WithLabel (unsigned int uL=0, const std::string &sN="")
virtual	~WithLabel (void)
void	PutLabel (unsigned int uL)
void	PutName (const std::string &sN)
unsigned int	GetLabel (void) const
const std::string &	GetName (void) const
Public Member Functions inherited from SimulationEntity
	SimulationEntity (void)
virtual	~SimulationEntity (void)
virtual bool	bIsValidIndex (unsigned int i) const
virtual DofOrder::Order	GetEqType (unsigned int i) const
virtual Hint *	ParseHint (DataManager *pDM, const char *s) const
virtual void	BeforePredict (VectorHandler &, VectorHandler &, VectorHandler &, VectorHandler &) const
virtual void	Update (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
virtual void	DerivativesUpdate (const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
virtual std::ostream &	OutputAppend (std::ostream &out) const
virtual void	ReadInitialState (MBDynParser &HP)
Public Member Functions inherited from ToBeOutput
	ToBeOutput (flag fOut=fDefaultOut)
virtual	~ToBeOutput (void)
virtual void	Output (OutputHandler &OH, const VectorHandler &X, const VectorHandler &XP) const
virtual flag	fToBeOutput (void) const
virtual bool	bToBeOutput (void) const
virtual void	SetOutputFlag (flag f=flag(1))
Public Member Functions inherited from 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 Types
enum	NodeName { NODE1 = 0, NODE2 = 1, NUMNODES = 2 }
enum	Deformations { STRAIN = 0, CURVAT = 1, NUMDEFORM = 2 }

Protected Member Functions
virtual Vec3	InterpState (const Vec3 &v1, const Vec3 &v2)
virtual Vec3	InterpDeriv (const Vec3 &v1, const Vec3 &v2)
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 &)
virtual void	AssInertiaMat (FullSubMatrixHandler &, FullSubMatrixHandler &, doublereal, const VectorHandler &, const VectorHandler &)
virtual void	AssInertiaVec (SubVectorHandler &, doublereal, const VectorHandler &, const VectorHandler &)
virtual void	DsDxi (void)
virtual void	Omega0 (void)
void	SetBeamType (Beam::Type T)
virtual std::ostream &	Restart_ (std::ostream &out) const
Protected Member Functions inherited from ElemGravityOwner
virtual Vec3	GetS_int (void) const
virtual Mat3x3	GetJ_int (void) const
virtual Vec3	GetB_int (void) const
virtual Vec3	GetG_int (void) const

Protected Attributes
unsigned	uOutputFlags
OrientationDescription	od
const StructNode *	pNode [NUMNODES]
Vec3	f [NUMNODES]
Vec3	fRef [NUMNODES]
Mat3x3	RNode [NUMNODES]
Mat3x3	R
Mat3x3	RRef
Mat3x3	RPrev
ConstitutiveLaw6DOwner *	pD
Mat6x6	DRef
Vec3	Omega
Vec3	OmegaRef
Vec6	Az
Vec6	AzRef
Vec6	AzLoc
Vec6	DefLoc
Vec6	DefLocRef
Vec6	DefLocPrev
Vec6	DefPrimeLoc
Vec3	p
Vec3	g
Vec3	L0
Vec3	L
Vec3	LRef
doublereal	dsdxi
bool	bFirstRes
bool	bFirstIDRes
Protected Attributes inherited from WithLabel
unsigned int	uLabel
std::string	sName
Protected Attributes inherited from ToBeOutput
flag	fOutput
Protected Attributes inherited from GravityOwner
Gravity *	pGravity

Private Attributes
Beam::Type	BeamT

Friends
class	AerodynamicBeam

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 }

Detailed Description

Definition at line 50 of file beam2.h.

Member Enumeration Documentation

enum Beam2::Deformations

protected

Enumerator
STRAIN
CURVAT
NUMDEFORM

Definition at line 65 of file beam2.h.

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

enum Beam2::NodeName

protected

Enumerator
NODE1
NODE2
NUMNODES

Definition at line 64 of file beam2.h.

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

Constructor & Destructor Documentation

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

Definition at line 65 of file beam2.cc.

References ASSERT, Az, AzLoc, AzRef, DefLoc, DefLocPrev, DefLocRef, DsDxi(), f, g, StructDispNode::GetNodeType(), InterpState(), L, L0, NODE1, NODE2, NUMNODES, Omega, p, pD, pNode, R, RNode, RPrev, RRef, SAFENEWWITHCONSTRUCTOR, Node::STRUCTURAL, Zero3, and Zero6.

: Elem(uL, fOut),
ElemGravityOwner(uL, fOut),
InitialAssemblyElem(uL, fOut),
od(ood),
#ifdef USE_NETCDF
Var_X(0),
Var_Phi(0),
Var_F(0),
Var_M(0),
Var_Nu(0),
Var_K(0),
Var_NuP(0),
Var_KP(0),
#endif /* USE_NETCDF */
bFirstRes(false),
bFirstIDRes(true)
{
        /* Validazione dati */
        ASSERT(pN1 != NULL);
        ASSERT(pN1->GetNodeType() == Node::STRUCTURAL);
        ASSERT(pN2 != NULL);
        ASSERT(pN2->GetNodeType() == Node::STRUCTURAL);

        pNode[NODE1] = pN1;
        pNode[NODE2] = pN2;
        const_cast<Vec3&>(f[NODE1]) = F1;
        const_cast<Vec3&>(f[NODE2]) = F2;
        const_cast<Mat3x3&>(RNode[NODE1]) = R1;
        const_cast<Mat3x3&>(RNode[NODE2]) = R2;
        RPrev = RRef = R = (Mat3x3&)r;

        pD = NULL;
        SAFENEWWITHCONSTRUCTOR(pD,
                        ConstitutiveLaw6DOwner,
                        ConstitutiveLaw6DOwner(pd));

        Omega = Zero3;
        Az = Zero6;
        AzRef = Zero6;
        AzLoc = Zero6;
        DefLoc = Zero6;
        DefLocRef = Zero6;
        DefLocPrev = Zero6;
        p = Zero3;
        g = Zero3;
        L0 = Zero3;
        L = 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 nel punto di valutazione */
        p = InterpState(xTmp[NODE1], xTmp[NODE2]);
}

Here is the call graph for this function:

Beam2::~Beam2 ( void  )

virtual

Definition at line 137 of file beam2.cc.

References ASSERT, pD, and SAFEDELETE.

{
        ASSERT(pD != NULL);
        if (pD != NULL) {
                SAFEDELETE(pD);
        }
}

Member Function Documentation

virtual void Beam2::AddInternalForces ( Vec6 &  )

inlineprotectedvirtual

Reimplemented in PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 154 of file beam2.h.

References NO_OP.

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

                               {
        NO_OP;
    };

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

virtual

Reimplemented from SimulationEntity.

Reimplemented in ViscoElasticBeam2.

Definition at line 321 of file beam2.cc.

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

Referenced by AfterConvergence().

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

Here is the call graph for this function:

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

virtual

Reimplemented from SimulationEntity.

Definition at line 931 of file beam2.cc.

References AfterConvergence(), and bFirstIDRes.

{
        AfterConvergence(X, XP);
        bFirstIDRes = true;
}

Here is the call graph for this function:

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

virtual

Reimplemented from SimulationEntity.

Reimplemented in ViscoElasticBeam2, PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 565 of file beam2.cc.

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

Referenced by PiezoActuatorBeam2::AfterPredict(), and AssRes().

{
        /*
         * 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;
        Vec3 gGrad;

        /* Aggiorna le grandezze della trave nel punto di valutazione */

        /* Posizione */
        p = InterpState(xTmp[NODE1], xTmp[NODE2]);

        /* Matrici di rotazione */
        g = InterpState(gNod[NODE1], gNod[NODE2]);
        RDelta = Mat3x3(CGR_Rot::MatR, g);
        R = RRef = RDelta*RPrev;

        /* Derivate della posizione */
        L = LRef = InterpDeriv(xTmp[NODE1], xTmp[NODE2]);

        /* Derivate dei parametri di rotazione */
        gGrad = InterpDeriv(gNod[NODE1], gNod[NODE2]);

        /*
         * Calcola le deformazioni nel sistema locale
         * nei punti di valutazione
         */
        DefLoc = DefLocRef = Vec6(R.MulTV(L) - L0,
                R.MulTV(Mat3x3(CGR_Rot::MatG, g)*gGrad) + DefLocPrev.GetVec2());

        /* Calcola le azioni interne */
        pD->Update(DefLoc);
        AzLoc = pD->GetF();

        /* corregge le azioni interne locali (piezo, ecc) */
        AddInternalForces(AzLoc);

        /* Porta le azioni interne nel sistema globale */
        Az = AzRef = MultRV(AzLoc, R);

        /* Aggiorna il legame costitutivo di riferimento */
        DRef = MultRMRt(pD->GetFDE(), RRef);

        bFirstRes = true;
}

Here is the call graph for this function:

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

inlineprotectedvirtual

Definition at line 159 of file beam2.h.

References NO_OP.

                                           {
        NO_OP;
    };

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

inlineprotectedvirtual

Definition at line 168 of file beam2.h.

References NO_OP.

                                           {
        NO_OP;
    };

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

virtual

Implements Elem.

Reimplemented in PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 485 of file beam2.cc.

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

Referenced by DataManager::AssConstrJac(), and AssJac().

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

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

        FullSubMatrixHandler& WM = WorkMat.SetFull();

        /* Dimensiona la matrice, la azzera e pone gli indici corretti */
        WM.ResizeReset(12, 12);

        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);
        }

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

        return WorkMat;
}

Here is the call graph for this function:

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

virtual

Reimplemented from Elem.

Definition at line 875 of file beam2.cc.

References ASSERT, AssJac(), Elem::bIsErgonomy(), DEBUGCOUT, InverseDynamics::INVERSE_DYNAMICS, and InverseDynamics::POSITION.

{
        // silent_cout("Beam2::IDAssJac()" << std::endl);

        DEBUGCOUT("Entering Beam2::[InverseDynamics]AssJac()" << std::endl);

#if 0
        // iOrder not available
        ASSERT(iOrder == InverseDynamics::INVERSE_DYNAMICS
                || (iOrder == InverseDynamics::POSITION && bIsErgonomy()));
#endif

        return AssJac(WorkMat, 1., XCurr, XCurr);
}

Here is the call graph for this function:

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

virtual

Implements Elem.

Definition at line 517 of file beam2.cc.

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

Referenced by AssRes().

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

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

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

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

        AssStiffnessVec(WorkVec, dCoef, XCurr, XPrimeCurr);

        return WorkVec;
}

Here is the call graph for this function:

SubVectorHandler & Beam2::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 893 of file beam2.cc.

References AfterPredict(), ASSERT, AssRes(), bFirstIDRes, bFirstRes, Elem::bIsErgonomy(), DEBUGCOUT, InverseDynamics::INVERSE_DYNAMICS, and InverseDynamics::POSITION.

{
        // silent_cout("Beam2::IDAssRes(" << iOrder << ")" << std::endl);

        DEBUGCOUT("Entering Beam2::[InverseDynamics]AssRes()" << std::endl);

        ASSERT(iOrder == InverseDynamics::INVERSE_DYNAMICS
                || (iOrder == InverseDynamics::POSITION && bIsErgonomy()));

        // if (iOrder == InverseDynamics::POSITION) {
                // ASSERT(bIsErgonomy());

                if (bFirstIDRes) {
                        // prepare for new step
                        AfterPredict(const_cast<VectorHandler&>(XCurr),
                                const_cast<VectorHandler&>(XPrimeCurr));

                        bFirstIDRes = false;
                        bFirstRes = true;
                }
        // }

        return AssRes(WorkVec, 1., XCurr, XPrimeCurr);
}

Here is the call graph for this function:

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

protectedvirtual

Reimplemented in ViscoElasticBeam2, PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 330 of file beam2.cc.

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

Referenced by AssJac(), PiezoActuatorBeam2::AssStiffnessMat(), and InitialAssJac().

{
        DEBUGCOUTFNAME("Beam2::AssStiffnessMat");

        /*
         * La matrice arriva gia' dimensionata
         * e con gli indici di righe e colonne a posto
         */

        /* offset nel riferimento globale */
        Vec3 fTmp[NUMNODES];
        for (unsigned int i = 0; i < NUMNODES; i++) {
                fTmp[i] = pNode[i]->GetRCurr()*f[i];
        }

        Mat6x6 AzTmp[NUMNODES];

        for (unsigned int i = 0; i < NUMNODES; i++) {
                /* Delta - deformazioni */
                AzTmp[i] = Mat6x6(mb_deye<Mat3x3>(dN2P[i]*dsdxi*dCoef),
                                Zero3x3,
                                Mat3x3(MatCross, L*(dN2[i]*dCoef) -fTmp[i]*(dN2P[i]*dsdxi*dCoef)),
                                mb_deye<Mat3x3>(dN2P[i]*dsdxi*dCoef));

                /* Delta - azioni interne */
                AzTmp[i] = DRef*AzTmp[i];

                /* Correggo per la rotazione da locale a globale */
                AzTmp[i].SubMat12(Mat3x3(MatCross, Az.GetVec1()*(dN2[i]*dCoef)));
                AzTmp[i].SubMat22(Mat3x3(MatCross, Az.GetVec2()*(dN2[i]*dCoef)));
        }

        Vec3 bTmp[NUMNODES];

        bTmp[NODE1] = p - pNode[NODE1]->GetXCurr();
        bTmp[NODE2] = p - pNode[NODE2]->GetXCurr();

        for (unsigned int i = 0; i < NUMNODES; i++) {
                /* Equazione all'indietro: */
                WMA.Sub(1, 6*i + 1, AzTmp[i].GetMat11());
                WMA.Sub(1, 6*i + 4, AzTmp[i].GetMat12());

                WMA.Sub(3 + 1, 6*i + 1,
                                AzTmp[i].GetMat21()
                                - Mat3x3(MatCross, Az.GetVec1()*(dCoef*dN2[i]))
                                + bTmp[NODE1].Cross(AzTmp[i].GetMat11()));
                WMA.Sub(3 + 1, 6*i + 4,
                                AzTmp[i].GetMat22()
                                - Mat3x3(MatCrossCross, Az.GetVec1()*(-dCoef*dN2[i]), fTmp[i])
                                + bTmp[NODE1].Cross(AzTmp[i].GetMat12()));

                /* Equazione in avanti: */
                WMA.Add(6 + 1, 6*i + 1, AzTmp[i].GetMat11());
                WMA.Add(6 + 1, 6*i + 4, AzTmp[i].GetMat12());

                WMA.Add(9 + 1, 6*i + 1,
                                AzTmp[i].GetMat21()
                                - Mat3x3(MatCross, Az.GetVec1()*(dCoef*dN2[i]))
                                + bTmp[NODE2].Cross(AzTmp[i].GetMat11()));
                WMA.Add(9 + 1, 6*i + 4,
                                AzTmp[i].GetMat22()
                                + Mat3x3(MatCrossCross, Az.GetVec1()*(dCoef*dN2[i]), fTmp[i])
                                + bTmp[NODE2].Cross(AzTmp[i].GetMat12()));
        }

        /* correzione alle equazioni */
        Mat3x3 FTmp(MatCross, Az.GetVec1()*dCoef);
        WMA.Sub(3 + 1, 1, FTmp);
        WMA.Add(9 + 1, 6 + 1, FTmp);
};

Here is the call graph for this function:

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

protectedvirtual

Reimplemented in ViscoElasticBeam2, PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 408 of file beam2.cc.

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

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

{
        DEBUGCOUTFNAME("Beam2::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;
                Vec3 gGrad;

                /*
                 * Aggiorna le grandezze della trave nel punto di valutazione
                 */

                /* Posizione */
                p = InterpState(xTmp[NODE1], xTmp[NODE2]);

                /* Matrici di rotazione */
                g = InterpState(gNod[NODE1], gNod[NODE2]);
                RDelta = Mat3x3(CGR_Rot::MatR, g);
                R = RDelta*RRef;

                /* Derivate della posizione */
                L = InterpDeriv(xTmp[NODE1], xTmp[NODE2]);

                /* Derivate dei parametri di rotazione */
                gGrad = InterpDeriv(gNod[NODE1], gNod[NODE2]);

                /*
                 * Calcola le deformazioni nel sistema locale
                 * nei punti di valutazione
                 */
                DefLoc = Vec6(R.MulTV(L) - L0,
                        R.MulTV(Mat3x3(CGR_Rot::MatG, g)*gGrad) + DefLocRef.GetVec2());

                /* Calcola le azioni interne */
                pD->Update(DefLoc);
                AzLoc = pD->GetF();

                /* corregge le azioni interne locali (piezo, ecc) */
                AddInternalForces(AzLoc);

                /* Porta le azioni interne nel sistema globale */
                Az = MultRV(AzLoc, R);
        }

        WorkVec.Add(1, Az.GetVec1());
        WorkVec.Add(4, (p - pNode[NODE1]->GetXCurr()).Cross(Az.GetVec1()) + Az.GetVec2());
        WorkVec.Sub(7, Az.GetVec1());
        WorkVec.Sub(10, Az.GetVec2() + (p - pNode[NODE2]->GetXCurr()).Cross(Az.GetVec1()));
}

Here is the call graph for this function:

bool Beam2::bInverseDynamics ( void  ) const

virtual

Reimplemented from Elem.

Definition at line 867 of file beam2.cc.

{
        return true;
}

doublereal Beam2::dGetPrivData ( unsigned int  i ) const

virtual

Reimplemented from SimulationEntity.

Reimplemented in ViscoElasticBeam2.

Definition at line 164 of file beam2.cc.

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

Referenced by ViscoElasticBeam2::dGetPrivData().

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

        switch (i) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
        case 6:
                return DefLoc.dGet(i);

        case 7:
        case 8:
        case 9:
        case 10:
        case 11:
        case 12:
                return AzLoc.dGet(i - 7);

        case 13:
        case 14:
        case 15:
                return p.dGet(i - 12);

        case 16:
        case 17:
        case 18:
                return RotManip::VecRot(R).dGet(i - 15);

        case 19:
        case 20:
        case 21:
                return Omega.dGet(i - 18);

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

Here is the call graph for this function:

void Beam2::DsDxi ( void  )

protectedvirtual

Definition at line 230 of file beam2.cc.

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

Referenced by Beam2().

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

        dsdxi = 1.;

        Vec3 xGrad = InterpDeriv(xTmp[NODE1], xTmp[NODE2]);
        doublereal d = xGrad.Dot();
        if (d > std::numeric_limits<doublereal>::epsilon()) {
                dsdxi = 1./std::sqrt(d);
        } else {
                silent_cerr("warning, Beam2(" << GetLabel() << ") "
                        "has singular metric; aborting..." << std::endl);

                throw ErrNullNorm(MBDYN_EXCEPT_ARGS);
        }

        /* Calcola le deformazioni iniziali */
        L0 = R.MulTV(InterpDeriv(xTmp[NODE1], xTmp[NODE2]));
        pD->Update(Zero6);
        DRef = MultRMRt(pD->GetFDE(), R);
}

Here is the call graph for this function:

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

inlinevirtual

Reimplemented in ViscoElasticBeam2, PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 207 of file beam2.h.

References Beam::ELASTIC.

Referenced by OutputPrepare().

                                             {
        return Beam::ELASTIC;
    };

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

inlinevirtual

Reimplemented from Elem.

Reimplemented in PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 348 of file beam2.h.

References NUMNODES, and pNode.

Referenced by PiezoActuatorBeam2::GetConnectedNodes().

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

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

inlinevirtual

Implements Elem.

Definition at line 212 of file beam2.h.

References Elem::BEAM.

Referenced by AerodynamicBeam2::AerodynamicBeam2().

                                             {
        return Elem::BEAM;
    };

virtual unsigned int Beam2::iGetInitialNumDof ( void  ) const

inlinevirtual

Implements SubjectToInitialAssembly.

Definition at line 307 of file beam2.h.

                                                       {
        return 0;
    };

unsigned int Beam2::iGetNumPrivData ( void  ) const

virtual

Reimplemented from SimulationEntity.

Definition at line 147 of file beam2.cc.

References Beam::iNumPrivData.

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

{
        return Beam::iNumPrivData;
}

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

virtual

Reimplemented from SimulationEntity.

Definition at line 153 of file beam2.cc.

References ConstLawType::ELASTIC, Beam::iGetPrivDataIdx_int(), and ConstLawType::VISCOUS.

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

        return Beam::iGetPrivDataIdx_int(s, type);
}

Here is the call graph for this function:

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

virtual

Implements SubjectToInitialAssembly.

Reimplemented in PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 804 of file beam2.cc.

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

Referenced by PiezoActuatorBeam2::InitialAssJac(), and PiezoActuatorVEBeam2::InitialAssJac().

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

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

        integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
        integer iNode2FirstPosIndex = pNode[NODE2]->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);
        }

        AssStiffnessMat(WM, WM, 1., XCurr, XCurr);
        return WorkMat;
}

Here is the call graph for this function:

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

virtual

Implements SubjectToInitialAssembly.

Reimplemented in PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 830 of file beam2.cc.

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

Referenced by PiezoActuatorBeam2::InitialAssRes(), and PiezoActuatorVEBeam2::InitialAssRes().

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

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

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

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

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

Here is the call graph for this function:

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

inlinevirtual

Implements SubjectToInitialAssembly.

Definition at line 316 of file beam2.h.

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

Vec3 Beam2::InterpDeriv ( const Vec3 &  v1, const Vec3 &  v2  )

protectedvirtual

Definition at line 219 of file beam2.cc.

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

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

{
        doublereal* pv1 = (doublereal*)v1.pGetVec();
        doublereal* pv2 = (doublereal*)v2.pGetVec();
        return Vec3((pv1[0]*dN2P[0] + pv2[0]*dN2P[1])*dsdxi,
                        (pv1[1]*dN2P[0] + pv2[1]*dN2P[1])*dsdxi,
                        (pv1[2]*dN2P[0] + pv2[2]*dN2P[1])*dsdxi);
}

Here is the call graph for this function:

Vec3 Beam2::InterpState ( const Vec3 &  v1, const Vec3 &  v2  )

protectedvirtual

Definition at line 208 of file beam2.cc.

References dN2, and Vec3::pGetVec().

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), and Beam2().

{
        doublereal* pv1 = (doublereal*)v1.pGetVec();
        doublereal* pv2 = (doublereal*)v2.pGetVec();
        return Vec3(pv1[0]*dN2[0] + pv2[0]*dN2[1],
                        pv1[1]*dN2[0] + pv2[1]*dN2[1],
                        pv1[2]*dN2[0] + pv2[2]*dN2[1]);
}

Here is the call graph for this function:

void Beam2::Omega0 ( void  )

protectedvirtual

Definition at line 264 of file beam2.cc.

References dN2, StructNode::GetRCurr(), StructNode::GetWCurr(), CGR_Rot::MatG, CGR_Rot::MatGm1, NODE1, NODE2, NUMNODES, Omega, CGR_Rot::Param, pNode, and RNode.

Referenced by ViscoElasticBeam2::ViscoElasticBeam2().

{
        /* 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 della rotazione relativa
         * tra inizio e fine e li dimezzo nell'ipotesi che siano limitati
         */
        Vec3 gTmp(CGR_Rot::Param, RNod[NODE2].MulTM(RNod[NODE1]));

        /*
         * Le derivate dei parametri di rotazione si ricavano da omega
         */
        Vec3 g1P(Mat3x3(CGR_Rot::MatGm1, gTmp*(-.5))*w[NODE1]);
        Vec3 g2P(Mat3x3(CGR_Rot::MatGm1, gTmp*.5)*w[NODE2]);

        Vec3 gPTmp(g1P*dN2[NODE1] + g2P*dN2[NODE2]);
        Omega = Mat3x3(CGR_Rot::MatG, gTmp)*gPTmp;

#if 0
        /* Modo brutale: interpolo le velocita' dei nodi */
        Omega = pNode[NODE1]->GetWCurr()*dN2[NODE1]
                + pNode[NODE2]->GetWCurr()*dN2[NODE2];
#endif /* 0 */
}

Here is the call graph for this function:

void Beam2::Output ( OutputHandler &  OH ) const

virtual

Reimplemented from ToBeOutput.

Definition at line 712 of file beam2.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(), MBDYN_EXCEPT_ARGS, od, ORIENTATION_MATRIX, ORIENTATION_VECTOR, p, Mat3x3::pGetMat(), Vec3::pGetVec(), R, OutputHandler::UseNetCDF(), OutputHandler::UseText(), and RotManip::VecRot().

{
        if (bToBeOutput()) {
#ifdef USE_NETCDF
                if (OH.UseNetCDF(OutputHandler::BEAMS)) {
                        if (Var_X) {
                                Var_X->put_rec(p.pGetVec(), OH.GetCurrentStep());
                        }

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

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

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

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

                                case ORIENTATION_MATRIX:
                                        break;

                                default:
                                        /* impossible */
                                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                                        break;
                                }

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

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

                                default:
                                        /* impossible */
                                        break;
                                }
                        }

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

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

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

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

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

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

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

Here is the call graph for this function:

void Beam2::OutputPrepare ( OutputHandler &  OH )

virtual

Reimplemented from ToBeOutput.

Definition at line 625 of file beam2.cc.

References ASSERT, OutputHandler::BEAMS, ToBeOutput::bToBeOutput(), Beam::ELASTIC, ToBeOutput::fToBeOutput(), GetBeamType(), WithLabel::GetLabel(), OutputHandler::IsOpen(), OutputHandler::NETCDF, od, Beam::OUTPUT_EP_F, Beam::OUTPUT_EP_K, Beam::OUTPUT_EP_KP, Beam::OUTPUT_EP_M, Beam::OUTPUT_EP_NU, Beam::OUTPUT_EP_NUP, Beam::OUTPUT_EP_R, Beam::OUTPUT_EP_X, ToBeOutput::OUTPUT_PRIVATE_MASK, Beam::PIEZOELECTRICELASTIC, Beam::PIEZOELECTRICVISCOELASTIC, uOutputFlags, OutputHandler::UseNetCDF(), and Beam::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);

                        if (uOutputFlags & Beam::OUTPUT_EP_X) {
                                Var_X = OH.CreateVar<Vec3>(name + "X", "m",
                                        "evaluation point global position vector (X, Y, Z)");
                        }

                        if (uOutputFlags & Beam::OUTPUT_EP_R) {
                                Var_Phi = OH.CreateRotationVar(name, "", od,
                                        " evaluation point global orientation matrix");
                        }

                        if (uOutputFlags & Beam::OUTPUT_EP_F) {
                                Var_F = OH.CreateVar<Vec3>(name + "F", "N",
                                        "evaluation point internal force in local frame (F_X, F_Y, F_Z)");
                        }

                        if (uOutputFlags & Beam::OUTPUT_EP_M) {
                                Var_M = OH.CreateVar<Vec3>(name + "M", "Nm",
                                        "evaluation point internal force in local frame (M_X, M_Y, M_Z)");
                        }

                        if (uOutputFlags & Beam::OUTPUT_EP_NU) {
                                Var_Nu = OH.CreateVar<Vec3>(name + "nu", "-",
                                        "evaluation point linear strain in local frame (nu_X, nu_Y, nu_Z)");
                        }

                        if (uOutputFlags & Beam::OUTPUT_EP_K) {
                                Var_K = OH.CreateVar<Vec3>(name + "k", "1/m",
                                        "evaluation point angular strain in local frame (K_X, K_Y, K_Z)");
                        }

                        if (uOutputFlags & Beam::OUTPUT_EP_NUP) {
                                Var_NuP = OH.CreateVar<Vec3>(name + "nuP", "1/s",
                                        "evaluation point linear strain rate in local frame (nuP_X, nuP_Y, nuP_Z)");
                        }

                        if (uOutputFlags & Beam::OUTPUT_EP_KP) {
                                Var_KP = OH.CreateVar<Vec3>(name + "kP", "1/ms",
                                        "evaluation point 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 * Beam2::pGetNode ( unsigned int  i ) const

virtual

Definition at line 852 of file beam2.cc.

References ASSERT, MBDYN_EXCEPT_ARGS, and pNode.

Referenced by AerodynamicBeam2::AerodynamicBeam2(), and ReadAerodynamicBeam2().

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

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

virtual

Implements Elem.

Reimplemented in PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 299 of file beam2.cc.

References Restart_().

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

Here is the call graph for this function:

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

protectedvirtual

Definition at line 305 of file beam2.cc.

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

Referenced by PiezoActuatorBeam2::Restart(), PiezoActuatorVEBeam2::Restart(), and Restart().

{
        out << "  beam2: " << GetLabel();
        for (unsigned int i = 0; i < NUMNODES; i++) {
                out << ", " << pNode[i]->GetLabel() << ", reference, node, ",
                f[i].Write(out, ", ");
        }
        out << ", reference, global,"
                << "1, ", (R.GetVec(1)).Write(out, ", ") << ", "
                << "2, ", (R.GetVec(2)).Write(out, ", ") << ", ",
        pD->pGetConstLaw()->Restart(out);

        return out;
}

Here is the call graph for this function:

void Beam2::SetBeamType ( Beam::Type  T )

inlineprotected

Definition at line 185 of file beam2.h.

References BeamT.

                                 {
        BeamT = T;
    };

virtual void Beam2::SetInitialValue ( VectorHandler &  )

inlinevirtual

Definition at line 323 of file beam2.h.

References NO_OP.

                                                    {
        NO_OP;
    };

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

virtual

Implements ElemGravityOwner.

Reimplemented in ViscoElasticBeam2, PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 543 of file beam2.cc.

References Az, AzRef, bFirstRes, DefLoc, DefLocRef, DRef, ConstitutiveLawOwner< T, Tder >::GetFDE(), L, LRef, MultRMRt(), pD, R, and RRef.

Referenced by PiezoActuatorBeam2::SetValue(), and ViscoElasticBeam2::SetValue().

{
        /* Aggiorna le grandezze della trave nei punti di valutazione */
        RRef = R;
        LRef = L;
        DefLocRef = DefLoc;
        AzRef = Az;

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

        bFirstRes = true;
}

Here is the call graph for this function:

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

virtual

Reimplemented from SimulationEntity.

Definition at line 924 of file beam2.cc.

References NO_OP.

{
        NO_OP;
}

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

inlinevirtual

Implements Elem.

Reimplemented in PiezoActuatorVEBeam2, and PiezoActuatorBeam2.

Definition at line 227 of file beam2.h.

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

Friends And Related Function Documentation

friend class AerodynamicBeam

friend

Definition at line 52 of file beam2.h.

Member Data Documentation

Vec6 Beam2::Az

protected

Definition at line 107 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessMat(), ViscoElasticBeam2::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), and SetValue().

Vec6 Beam2::AzLoc

protected

Definition at line 109 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), dGetPrivData(), and Output().

Vec6 Beam2::AzRef

protected

Definition at line 108 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), Beam2(), and SetValue().

Beam::Type Beam2::BeamT

private

Definition at line 61 of file beam2.h.

Referenced by SetBeamType().

bool Beam2::bFirstIDRes

protected

Definition at line 128 of file beam2.h.

Referenced by AfterConvergence(), and AssRes().

bool Beam2::bFirstRes

protected

Definition at line 127 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssRes(), PiezoActuatorBeam2::AssStiffnessVec(), AssStiffnessVec(), PiezoActuatorVEBeam2::AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), SetValue(), and ViscoElasticBeam2::SetValue().

Vec6 Beam2::DefLoc

protected

Definition at line 110 of file beam2.h.

Referenced by AfterConvergence(), ViscoElasticBeam2::AfterConvergence(), AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), dGetPrivData(), Output(), and SetValue().

Vec6 Beam2::DefLocPrev

protected

Definition at line 112 of file beam2.h.

Referenced by AfterConvergence(), ViscoElasticBeam2::AfterConvergence(), AfterPredict(), ViscoElasticBeam2::AfterPredict(), and Beam2().

Vec6 Beam2::DefLocRef

protected

Definition at line 111 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), and SetValue().

Vec6 Beam2::DefPrimeLoc

protected

Definition at line 115 of file beam2.h.

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

Mat6x6 Beam2::DRef

protected

Definition at line 100 of file beam2.h.

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

doublereal Beam2::dsdxi

protected

Definition at line 124 of file beam2.h.

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

Vec3 Beam2::f[NUMNODES]

protected

Definition at line 86 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessMat(), ViscoElasticBeam2::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), DsDxi(), and Restart_().

Vec3 Beam2::fRef[NUMNODES]

protected

Definition at line 87 of file beam2.h.

Vec3 Beam2::g

protected

Definition at line 118 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), and Beam2().

Vec3 Beam2::L

protected

Definition at line 120 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessMat(), ViscoElasticBeam2::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), and SetValue().

Vec3 Beam2::L0

protected

Definition at line 119 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), and DsDxi().

Vec3 Beam2::LRef

protected

Definition at line 122 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), and SetValue().

OrientationDescription Beam2::od

protected

Definition at line 69 of file beam2.h.

Referenced by Output(), and OutputPrepare().

Vec3 Beam2::Omega

protected

Definition at line 103 of file beam2.h.

Referenced by ViscoElasticBeam2::AfterPredict(), ViscoElasticBeam2::AssStiffnessMat(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), dGetPrivData(), Omega0(), ViscoElasticBeam2::SetValue(), and ViscoElasticBeam2::ViscoElasticBeam2().

Vec3 Beam2::OmegaRef

protected

Definition at line 104 of file beam2.h.

Referenced by ViscoElasticBeam2::AfterPredict(), ViscoElasticBeam2::AssStiffnessVec(), ViscoElasticBeam2::SetValue(), and ViscoElasticBeam2::ViscoElasticBeam2().

Vec3 Beam2::p

protected

Definition at line 117 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), PiezoActuatorBeam2::AssStiffnessMat(), AssStiffnessMat(), PiezoActuatorVEBeam2::AssStiffnessMat(), ViscoElasticBeam2::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), dGetPrivData(), and Output().

ConstitutiveLaw6DOwner* Beam2::pD

protected

Definition at line 97 of file beam2.h.

Referenced by AfterConvergence(), ViscoElasticBeam2::AfterConvergence(), AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), DsDxi(), Restart_(), SetValue(), ViscoElasticBeam2::SetValue(), ViscoElasticBeam2::ViscoElasticBeam2(), and ~Beam2().

const StructNode* Beam2::pNode[NUMNODES]

protected

Definition at line 83 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), PiezoActuatorBeam2::AssJac(), PiezoActuatorVEBeam2::AssJac(), AssJac(), AssRes(), PiezoActuatorBeam2::AssStiffnessMat(), AssStiffnessMat(), PiezoActuatorVEBeam2::AssStiffnessMat(), ViscoElasticBeam2::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), DsDxi(), GetConnectedNodes(), InitialAssJac(), InitialAssRes(), Omega0(), pGetNode(), and Restart_().

Mat3x3 Beam2::R

protected

Definition at line 92 of file beam2.h.

Referenced by AfterConvergence(), ViscoElasticBeam2::AfterConvergence(), AfterPredict(), ViscoElasticBeam2::AfterPredict(), PiezoActuatorBeam2::AssStiffnessMat(), PiezoActuatorVEBeam2::AssStiffnessMat(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), dGetPrivData(), DsDxi(), Output(), Restart_(), and SetValue().

Mat3x3 Beam2::RNode[NUMNODES]

protected

Definition at line 88 of file beam2.h.

Referenced by Beam2(), and Omega0().

Mat3x3 Beam2::RPrev

protected

Definition at line 94 of file beam2.h.

Referenced by AfterConvergence(), ViscoElasticBeam2::AfterConvergence(), AfterPredict(), ViscoElasticBeam2::AfterPredict(), and Beam2().

Mat3x3 Beam2::RRef

protected

Definition at line 93 of file beam2.h.

Referenced by AfterPredict(), ViscoElasticBeam2::AfterPredict(), AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), Beam2(), SetValue(), ViscoElasticBeam2::SetValue(), and ViscoElasticBeam2::ViscoElasticBeam2().

unsigned Beam2::uOutputFlags

protected

Definition at line 68 of file beam2.h.

Referenced by OutputPrepare().

---

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

• beam2.h
• beam2.cc