MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
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 SubVectorHandlerAssRes (SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
 
virtual SubVectorHandlerAssRes (SubVectorHandler &WorkVec, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr, const VectorHandler &XPrimePrimeCurr, InverseDynamics::Order iOrder=InverseDynamics::INVERSE_DYNAMICS)
 
virtual bool bInverseDynamics (void) const
 
virtual VariableSubMatrixHandlerAssJac (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 VariableSubMatrixHandlerInitialAssJac (VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
 
virtual SubVectorHandlerInitialAssRes (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 StructNodepGetNode (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 VariableSubMatrixHandlerAssJac (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 HintParseHint (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 StructNodepNode [NUMNODES]
 
const Vec3 f [NUMNODES]
 
Vec3 fRef [NUMNODES]
 
const Mat3x3 RNode [NUMNODES]
 
Mat3x3 R [NUMSEZ]
 
Mat3x3 RRef [NUMSEZ]
 
Mat3x3 RPrev [NUMSEZ]
 
ConstitutiveLaw6DOwnerpD [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
GravitypGravity
 

Static Protected Attributes

static const unsigned int iNumPrivData
 

Friends

class AerodynamicBeam
 
class Beam2
 
ElemReadBeam (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.

75  {
76  OUTPUT_NONE = 0x000U,
77 
80  OUTPUT_EP_CONFIGURATION = (OUTPUT_EP_X | OUTPUT_EP_R),
81 
85 
89 
93 
95 
97  };
Enumerator
STRAIN 
CURVAT 
NUMDEFORM 

Definition at line 138 of file beam.h.

138 { STRAIN = 0, CURVAT = 1, NUMDEFORM = 2 };
Enumerator
NODE1 
NODE2 
NODE3 
NUMNODES 

Definition at line 137 of file beam.h.

137 { NODE1 = 0, NODE2 = 1, NODE3 = 2, NUMNODES = 3 };
Enumerator
S_I 
SII 
NUMSEZ 

Definition at line 136 of file beam.h.

136 { 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.

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.

80 : Elem(uL, fOut),
81 ElemGravityOwner(uL, fOut),
82 InitialAssemblyElem(uL, fOut),
83 od(ood),
84 f(),
85 RNode(),
86 bConsistentInertia(false),
87 dMass_I(0.),
88 S0_I(Zero3),
89 J0_I(Zero3x3),
90 dMassII(0.),
91 S0II(Zero3),
92 J0II(Zero3x3),
93 bFirstRes(false)
94 {
95  ASSERT(pN1 != NULL);
97  ASSERT(pN2 != NULL);
99  ASSERT(pN3 != NULL);
101 
102  pNode[NODE1] = pN1;
103  pNode[NODE2] = pN2;
104  pNode[NODE3] = pN3;
105 
106  const_cast<Vec3&>(f[NODE1]) = F1;
107  const_cast<Vec3&>(f[NODE2]) = F2;
108  const_cast<Vec3&>(f[NODE3]) = F3;
109  const_cast<Mat3x3&>(RNode[NODE1]) = R1;
110  const_cast<Mat3x3&>(RNode[NODE2]) = R2;
111  const_cast<Mat3x3&>(RNode[NODE3]) = R3;
112  RRef[S_I] = R[S_I] = (Mat3x3&)r_I;
113  RRef[SII] = R[SII] = (Mat3x3&)rII;
114 
115  pD[S_I] = 0;
118  ConstitutiveLaw6DOwner(pD_I));
119  pD[SII] = 0;
122  ConstitutiveLaw6DOwner(pDII));
123 
124  Init();
125 }
const Vec3 S0_I
Definition: beam.h:165
const Vec3 Zero3(0., 0., 0.)
const doublereal dMassII
Definition: beam.h:168
Definition: matvec3.h:98
void Init(void)
Definition: beam.cc:191
const Mat3x3 J0_I
Definition: beam.h:166
const Vec3 f[NUMNODES]
Definition: beam.h:145
virtual Node::Type GetNodeType(void) const
Definition: strnode.cc:145
ConstitutiveLawOwner< Vec6, Mat6x6 > ConstitutiveLaw6DOwner
Definition: constltp.h:380
const Vec3 S0II
Definition: beam.h:169
const Mat3x3 RNode[NUMNODES]
Definition: beam.h:147
ConstitutiveLaw6DOwner * pD[NUMSEZ]
Definition: beam.h:156
ElemGravityOwner(unsigned int uL, flag fOut)
Definition: gravity.cc:223
OrientationDescription od
Definition: beam.h:116
const Mat3x3 Zero3x3(0., 0., 0., 0., 0., 0., 0., 0., 0.)
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
#define ASSERT(expression)
Definition: colamd.c:977
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
#define SAFENEWWITHCONSTRUCTOR(pnt, item, constructor)
Definition: mynewmem.h:698
bool bFirstRes
Definition: beam.h:197
Mat3x3 RRef[NUMSEZ]
Definition: beam.h:152
const Mat3x3 J0II
Definition: beam.h:170
InitialAssemblyElem(unsigned int uL, flag fOut)
Definition: elem.cc:233
Elem(unsigned int uL, flag fOut)
Definition: elem.cc:41
const bool bConsistentInertia
Definition: beam.h:162
const doublereal dMass_I
Definition: beam.h:164

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.

151 : Elem(uL, fOut),
152 ElemGravityOwner(uL, fOut),
153 InitialAssemblyElem(uL, fOut),
154 od(ood),
155 f(),
156 RNode(),
157 bConsistentInertia(true),
158 dMass_I(dM_I),
159 S0_I(s0_I),
160 J0_I(j0_I),
161 dMassII(dMII),
162 S0II(s0II),
163 J0II(j0II),
164 bFirstRes(false)
165 {
166  pNode[NODE1] = pN1;
167  pNode[NODE2] = pN2;
168  pNode[NODE3] = pN3;
169  const_cast<Vec3&>(f[NODE1]) = F1;
170  const_cast<Vec3&>(f[NODE2]) = F2;
171  const_cast<Vec3&>(f[NODE3]) = F3;
172  const_cast<Mat3x3&>(RNode[NODE1]) = R1;
173  const_cast<Mat3x3&>(RNode[NODE2]) = R2;
174  const_cast<Mat3x3&>(RNode[NODE3]) = R3;
175  RPrev[S_I] = RRef[S_I] = R[S_I] = const_cast<Mat3x3&>(r_I);
176  RPrev[SII] = RRef[SII] = R[SII] = const_cast<Mat3x3&>(rII);
177 
178  pD[S_I] = 0;
181  ConstitutiveLaw6DOwner(pD_I));
182  pD[SII] = 0;
185  ConstitutiveLaw6DOwner(pDII));
186 
187  Init();
188 }
const Vec3 S0_I
Definition: beam.h:165
const doublereal dMassII
Definition: beam.h:168
Definition: matvec3.h:98
void Init(void)
Definition: beam.cc:191
const Mat3x3 J0_I
Definition: beam.h:166
const Vec3 f[NUMNODES]
Definition: beam.h:145
ConstitutiveLawOwner< Vec6, Mat6x6 > ConstitutiveLaw6DOwner
Definition: constltp.h:380
const Vec3 S0II
Definition: beam.h:169
const Mat3x3 RNode[NUMNODES]
Definition: beam.h:147
ConstitutiveLaw6DOwner * pD[NUMSEZ]
Definition: beam.h:156
ElemGravityOwner(unsigned int uL, flag fOut)
Definition: gravity.cc:223
Mat3x3 RPrev[NUMSEZ]
Definition: beam.h:153
OrientationDescription od
Definition: beam.h:116
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
#define SAFENEWWITHCONSTRUCTOR(pnt, item, constructor)
Definition: mynewmem.h:698
bool bFirstRes
Definition: beam.h:197
Mat3x3 RRef[NUMSEZ]
Definition: beam.h:152
const Mat3x3 J0II
Definition: beam.h:170
InitialAssemblyElem(unsigned int uL, flag fOut)
Definition: elem.cc:233
Elem(unsigned int uL, flag fOut)
Definition: elem.cc:41
const bool bConsistentInertia
Definition: beam.h:162
const doublereal dMass_I
Definition: beam.h:164

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.

237 {
238  ASSERT(pD[S_I] != 0);
239  if (pD[S_I] != 0) {
240  SAFEDELETE(pD[S_I]);
241  }
242 
243  ASSERT(pD[SII] != 0);
244  if (pD[SII] != 0) {
245  SAFEDELETE(pD[SII]);
246  }
247 }
ConstitutiveLaw6DOwner * pD[NUMSEZ]
Definition: beam.h:156
#define ASSERT(expression)
Definition: colamd.c:977
#define SAFEDELETE(pnt)
Definition: mynewmem.h:710

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().

227  {
228  NO_OP;
229  };
#define NO_OP
Definition: myassert.h:74
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().

596 {
597  for (unsigned i = 0; i < NUMSEZ; i++) {
598  RPrev[i] = R[i];
599  DefLocPrev[i] = DefLoc[i];
600  pD[i]->AfterConvergence(DefLoc[i]);
601  }
602 }
Vec6 DefLocPrev[NUMSEZ]
Definition: beam.h:182
ConstitutiveLaw6DOwner * pD[NUMSEZ]
Definition: beam.h:156
Mat3x3 RPrev[NUMSEZ]
Definition: beam.h:153
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
void AfterConvergence(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp.h:288
Vec6 DefLoc[NUMSEZ]
Definition: beam.h:180

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().

607 {
608  AfterConvergence(X, XP);
609 }
virtual void AfterConvergence(const VectorHandler &X, const VectorHandler &XP)
Definition: beam.cc:595

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().

990 {
991  /* Calcola le deformazioni, aggiorna il legame costitutivo e crea la FDE */
992 
993  /* Recupera i dati dei nodi */
994  Vec3 gNod[NUMNODES];
995  Vec3 xTmp[NUMNODES];
996 
997  for (unsigned int i = 0; i < NUMNODES; i++) {
998  gNod[i] = pNode[i]->GetgRef();
999  xTmp[i] = pNode[i]->GetXCurr() + pNode[i]->GetRRef()*f[i];
1000  }
1001 
1002  Mat3x3 RDelta[NUMSEZ];
1003  Vec3 gGrad[NUMSEZ];
1004 
1005  /* Aggiorna le grandezze della trave nei punti di valutazione */
1006  for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
1007 
1008  /* Posizione */
1009  p[iSez] = InterpState(xTmp[NODE1], xTmp[NODE2], xTmp[NODE3], Beam::Section(iSez));
1010 
1011  /* Matrici di rotazione */
1012  g[iSez] = InterpState(gNod[NODE1], gNod[NODE2], gNod[NODE3], Beam::Section(iSez));
1013  RDelta[iSez] = Mat3x3(CGR_Rot::MatR, g[iSez]);
1014  R[iSez] = RRef[iSez] = RDelta[iSez]*RPrev[iSez];
1015 
1016  /* Derivate della posizione */
1017  L[iSez] = LRef[iSez]
1018  = InterpDeriv(xTmp[NODE1], xTmp[NODE2], xTmp[NODE3], Beam::Section(iSez));
1019 
1020  /* Derivate dei parametri di rotazione */
1021  gGrad[iSez]
1022  = InterpDeriv(gNod[NODE1], gNod[NODE2], gNod[NODE3], Beam::Section(iSez));
1023 
1024  /* Calcola le deformazioni nel sistema locale nei punti di valutazione */
1025  DefLoc[iSez] = DefLocRef[iSez]
1026  = Vec6(R[iSez].MulTV(L[iSez]) - L0[iSez],
1027  R[iSez].MulTV(Mat3x3(CGR_Rot::MatG, g[iSez])*gGrad[iSez]) + DefLocPrev[iSez].GetVec2());
1028 
1029  /* Calcola le azioni interne */
1030  pD[iSez]->Update(DefLoc[iSez]);
1031  AzLoc[iSez] = pD[iSez]->GetF();
1032 
1033  /* corregge le azioni interne locali (piezo, ecc) */
1034  AddInternalForces(AzLoc[iSez], iSez);
1035 
1036  /* Porta le azioni interne nel sistema globale */
1037  Az[iSez] = AzRef[iSez] = MultRV(AzLoc[iSez], R[iSez]);
1038 
1039  /* Aggiorna il legame costitutivo di riferimento */
1040  DRef[iSez] = MultRMRt(pD[iSez]->GetFDE(), RRef[iSez]);
1041  }
1042 
1043  bFirstRes = true;
1044 }
Mat3x3 MultRMRt(const Mat3x3 &m, const Mat3x3 &R)
Definition: matvec3.cc:1162
Vec3 MultRV(const Vec3 &v, const Mat3x3 &R)
Definition: matvec3.cc:1144
virtual const Mat3x3 & GetRRef(void) const
Definition: strnode.h:1006
Vec6 DefLocPrev[NUMSEZ]
Definition: beam.h:182
Definition: matvec3.h:98
const Vec3 f[NUMNODES]
Definition: beam.h:145
static Vec3 InterpState(const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, enum Section Sec)
Definition: beam.cc:429
Vec3 L[NUMSEZ]
Definition: beam.h:190
virtual void AddInternalForces(Vec6 &, unsigned int)
Definition: beam.h:227
ConstitutiveLaw6DOwner * pD[NUMSEZ]
Definition: beam.h:156
Mat3x3 RPrev[NUMSEZ]
Definition: beam.h:153
Vec6 DefLocRef[NUMSEZ]
Definition: beam.h:181
Vec6 AzLoc[NUMSEZ]
Definition: beam.h:179
Definition: matvec6.h:37
Vec3 LRef[NUMSEZ]
Definition: beam.h:192
Vec3 L0[NUMSEZ]
Definition: beam.h:189
const MatG_Manip MatG
Definition: matvec3.cc:646
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
Section
Definition: beam.h:136
Vec3 InterpDeriv(const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, enum Section Sec)
Definition: beam.cc:446
const MatR_Manip MatR
Definition: matvec3.cc:645
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
virtual const Vec3 & GetXCurr(void) const
Definition: strnode.h:310
bool bFirstRes
Definition: beam.h:197
Vec6 AzRef[NUMSEZ]
Definition: beam.h:178
Mat3x3 RRef[NUMSEZ]
Definition: beam.h:152
Vec3 g[NUMSEZ]
Definition: beam.h:188
const T & GetF(void) const
Definition: constltp.h:293
virtual const Vec3 & GetgRef(void) const
Definition: strnode.h:976
Vec6 Az[NUMSEZ]
Definition: beam.h:177
void Update(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp.h:283
Mat6x6 DRef[NUMSEZ]
Definition: beam.h:159
Vec3 p[NUMSEZ]
Definition: beam.h:187
Vec6 DefLoc[NUMSEZ]
Definition: beam.h:180

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().

236  {
237  NO_OP;
238  };
#define NO_OP
Definition: myassert.h:74
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().

244  {
245  NO_OP;
246  };
#define NO_OP
Definition: myassert.h:74
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().

776 {
777  DEBUGCOUTFNAME("Beam::AssJac => AssStiffnessMat");
778 
779  integer iNode1FirstMomIndex = pNode[NODE1]->iGetFirstMomentumIndex();
780  integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
781  integer iNode2FirstMomIndex = pNode[NODE2]->iGetFirstMomentumIndex();
782  integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
783  integer iNode3FirstMomIndex = pNode[NODE3]->iGetFirstMomentumIndex();
784  integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();
785 
786  FullSubMatrixHandler& WM = WorkMat.SetFull();
787 
788  /* Dimensiona la matrice, la azzera e pone gli indici corretti */
789  if (bConsistentInertia) {
790  WM.ResizeReset(36, 18);
791  } else {
792  WM.ResizeReset(18, 18);
793  }
794 
795  for (int iCnt = 1; iCnt <= 6; iCnt++) {
796  WM.PutRowIndex(iCnt, iNode1FirstMomIndex + iCnt);
797  WM.PutColIndex(iCnt, iNode1FirstPosIndex + iCnt);
798  WM.PutRowIndex(6 + iCnt, iNode2FirstMomIndex + iCnt);
799  WM.PutColIndex(6 + iCnt, iNode2FirstPosIndex + iCnt);
800  WM.PutRowIndex(12 + iCnt, iNode3FirstMomIndex + iCnt);
801  WM.PutColIndex(12 + iCnt, iNode3FirstPosIndex + iCnt);
802  }
803 
804  AssStiffnessMat(WM, WM, dCoef, XCurr, XPrimeCurr);
805 
806  if (bConsistentInertia) {
807  for (int iCnt = 1; iCnt <= 6; iCnt++) {
808  WM.PutRowIndex(18 + iCnt, iNode1FirstPosIndex + iCnt);
809  WM.PutRowIndex(24 + iCnt, iNode2FirstPosIndex + iCnt);
810  WM.PutRowIndex(30 + iCnt, iNode3FirstPosIndex + iCnt);
811  }
812 
813  AssInertiaMat(WM, WM, dCoef, XCurr, XPrimeCurr);
814  }
815 
816  return WorkMat;
817 }
void PutColIndex(integer iSubCol, integer iCol)
Definition: submat.h:325
virtual void AssInertiaMat(FullSubMatrixHandler &, FullSubMatrixHandler &, doublereal, const VectorHandler &, const VectorHandler &)
Definition: beam.h:232
#define DEBUGCOUTFNAME(fname)
Definition: myassert.h:256
FullSubMatrixHandler & SetFull(void)
Definition: submat.h:1168
virtual integer iGetFirstMomentumIndex(void) const =0
virtual integer iGetFirstPositionIndex(void) const
Definition: strnode.h:452
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
virtual void ResizeReset(integer, integer)
Definition: submat.cc:182
void PutRowIndex(integer iSubRow, integer iRow)
Definition: submat.h:311
const bool bConsistentInertia
Definition: beam.h:162
long int integer
Definition: colamd.c:51
virtual void AssStiffnessMat(FullSubMatrixHandler &WMA, FullSubMatrixHandler &WMB, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: beam.cc:613

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().

826 {
827  DEBUGCOUTFNAME("Beam::AssMats => AssStiffnessMat");
828 
829  integer iNode1FirstMomIndex = pNode[NODE1]->iGetFirstMomentumIndex();
830  integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
831  integer iNode2FirstMomIndex = pNode[NODE2]->iGetFirstMomentumIndex();
832  integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
833  integer iNode3FirstMomIndex = pNode[NODE3]->iGetFirstMomentumIndex();
834  integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();
835 
836  FullSubMatrixHandler& WMA = WorkMatA.SetFull();
837  FullSubMatrixHandler& WMB = WorkMatB.SetFull();
838 
839  /* Dimensiona la matrice, la azzera e pone gli indici corretti */
840  if (bConsistentInertia) {
841  WMA.ResizeReset(36, 18);
842  WMB.ResizeReset(36, 18);
843  } else {
844  WMA.ResizeReset(18, 18);
845  WorkMatB.SetNullMatrix();
846  }
847 
848  for (int iCnt = 1; iCnt <= 6; iCnt++) {
849  WMA.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
850  WMA.PutColIndex(iCnt, iNode1FirstPosIndex+iCnt);
851  WMA.PutRowIndex(6+iCnt, iNode2FirstMomIndex+iCnt);
852  WMA.PutColIndex(6+iCnt, iNode2FirstPosIndex+iCnt);
853  WMA.PutRowIndex(12+iCnt, iNode3FirstMomIndex+iCnt);
854  WMA.PutColIndex(12+iCnt, iNode3FirstPosIndex+iCnt);
855  }
856 
857  AssStiffnessMat(WMA, WMA, 1., XCurr, XPrimeCurr);
858 
859  if (bConsistentInertia) {
860  for (unsigned int iCnt = 1; iCnt <= 6; iCnt++) {
861  WMB.PutRowIndex(iCnt, iNode1FirstMomIndex + iCnt);
862  WMB.PutColIndex(iCnt, iNode1FirstPosIndex + iCnt);
863  WMB.PutRowIndex(6 + iCnt, iNode2FirstMomIndex + iCnt);
864  WMB.PutColIndex(6 + iCnt, iNode2FirstPosIndex + iCnt);
865  WMB.PutRowIndex(12 + iCnt, iNode3FirstMomIndex + iCnt);
866  WMB.PutColIndex(12 + iCnt, iNode3FirstPosIndex + iCnt);
867  }
868 
869  for (unsigned int iCnt = 1; iCnt <= 6; iCnt++) {
870  WMA.PutRowIndex(18 + iCnt, iNode1FirstPosIndex + iCnt);
871  WMA.PutRowIndex(24 + iCnt, iNode2FirstPosIndex + iCnt);
872  WMA.PutRowIndex(30 + iCnt, iNode3FirstPosIndex + iCnt);
873 
874  WMB.PutRowIndex(18 + iCnt, iNode1FirstPosIndex + iCnt);
875  WMB.PutRowIndex(24 + iCnt, iNode2FirstPosIndex + iCnt);
876  WMB.PutRowIndex(30 + iCnt, iNode3FirstPosIndex + iCnt);
877  }
878 
879  AssInertiaMat(WMA, WMB, 1., XCurr, XPrimeCurr);
880  }
881 }
void PutColIndex(integer iSubCol, integer iCol)
Definition: submat.h:325
virtual void AssInertiaMat(FullSubMatrixHandler &, FullSubMatrixHandler &, doublereal, const VectorHandler &, const VectorHandler &)
Definition: beam.h:232
#define DEBUGCOUTFNAME(fname)
Definition: myassert.h:256
FullSubMatrixHandler & SetFull(void)
Definition: submat.h:1168
void SetNullMatrix(void)
Definition: submat.h:1159
virtual integer iGetFirstMomentumIndex(void) const =0
virtual integer iGetFirstPositionIndex(void) const
Definition: strnode.h:452
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
virtual void ResizeReset(integer, integer)
Definition: submat.cc:182
void PutRowIndex(integer iSubRow, integer iRow)
Definition: submat.h:311
const bool bConsistentInertia
Definition: beam.h:162
long int integer
Definition: colamd.c:51
virtual void AssStiffnessMat(FullSubMatrixHandler &WMA, FullSubMatrixHandler &WMB, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: beam.cc:613

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().

890 {
891  DEBUGCOUTFNAME("Beam::AssRes => AssStiffnessVec");
892 
893  integer iNode1FirstMomIndex = pNode[NODE1]->iGetFirstMomentumIndex();
894  integer iNode2FirstMomIndex = pNode[NODE2]->iGetFirstMomentumIndex();
895  integer iNode3FirstMomIndex = pNode[NODE3]->iGetFirstMomentumIndex();
896 
897  /* Dimensiona il vettore, lo azzera e pone gli indici corretti */
898  if (bConsistentInertia) {
899  WorkVec.ResizeReset(36);
900  } else {
901  WorkVec.ResizeReset(18);
902  }
903 
904  for (unsigned int iCnt = 1; iCnt <= 6; iCnt++) {
905  WorkVec.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
906  WorkVec.PutRowIndex(6 + iCnt, iNode2FirstMomIndex + iCnt);
907  WorkVec.PutRowIndex(12 + iCnt, iNode3FirstMomIndex + iCnt);
908  }
909 
910  AssStiffnessVec(WorkVec, dCoef, XCurr, XPrimeCurr);
911 
912  if (bConsistentInertia) {
913  integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
914  integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
915  integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();
916 
917  for (unsigned int iCnt = 1; iCnt <= 6; iCnt++) {
918  WorkVec.PutRowIndex(18 + iCnt, iNode1FirstPosIndex + iCnt);
919  WorkVec.PutRowIndex(24 + iCnt, iNode2FirstPosIndex + iCnt);
920  WorkVec.PutRowIndex(30 + iCnt, iNode3FirstPosIndex + iCnt);
921  }
922 
923  AssInertiaVec(WorkVec, dCoef, XCurr, XPrimeCurr);
924  }
925 
926  return WorkVec;
927 }
#define DEBUGCOUTFNAME(fname)
Definition: myassert.h:256
virtual void ResizeReset(integer)
Definition: vh.cc:55
virtual void AssInertiaVec(SubVectorHandler &, doublereal, const VectorHandler &, const VectorHandler &)
Definition: beam.h:241
virtual void AssStiffnessVec(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: beam.cc:697
virtual void PutRowIndex(integer iSubRow, integer iRow)=0
virtual integer iGetFirstMomentumIndex(void) const =0
virtual integer iGetFirstPositionIndex(void) const
Definition: strnode.h:452
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
const bool bConsistentInertia
Definition: beam.h:162
long int integer
Definition: colamd.c:51

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().

936 {
937  DEBUGCOUTFNAME("Beam::AssRes => AssStiffnessVec");
938 
939  integer iNode1FirstMomIndex = pNode[NODE1]->iGetFirstPositionIndex();
940  integer iNode2FirstMomIndex = pNode[NODE2]->iGetFirstPositionIndex();
941  integer iNode3FirstMomIndex = pNode[NODE3]->iGetFirstPositionIndex();
942 
943  /* Dimensiona il vettore, lo azzera e pone gli indici corretti */
944  WorkVec.ResizeReset(18);
945 
946  for (unsigned int iCnt = 1; iCnt <= 6; iCnt++) {
947  WorkVec.PutRowIndex(iCnt, iNode1FirstMomIndex+iCnt);
948  WorkVec.PutRowIndex(6 + iCnt, iNode2FirstMomIndex + iCnt);
949  WorkVec.PutRowIndex(12 + iCnt, iNode3FirstMomIndex + iCnt);
950  }
951 
952  AssStiffnessVec(WorkVec, 1., XCurr, XPrimeCurr);
953 
954  return WorkVec;
955 }
#define DEBUGCOUTFNAME(fname)
Definition: myassert.h:256
virtual void ResizeReset(integer)
Definition: vh.cc:55
virtual void AssStiffnessVec(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: beam.cc:697
virtual void PutRowIndex(integer iSubRow, integer iRow)=0
virtual integer iGetFirstPositionIndex(void) const
Definition: strnode.h:452
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
long int integer
Definition: colamd.c:51

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().

618 {
619  DEBUGCOUTFNAME("Beam::AssStiffnessMat");
620 
621  /* La matrice arriva gia' dimensionata e con gli indici di righe e colonne
622  * a posto */
623 
624  /* offset nel riferimento globale */
625  Vec3 fTmp[NUMNODES];
626  for (unsigned int i = 0; i < NUMNODES; i++) {
627  fTmp[i] = pNode[i]->GetRCurr()*f[i];
628  }
629 
630  Mat6x6 AzTmp[NUMSEZ][NUMNODES];
631 
632  /* per ogni punto di valutazione: */
633  for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
634  for (unsigned int i = 0; i < NUMNODES; i++) {
635  /* Delta - deformazioni */
636  AzTmp[iSez][i] = Mat6x6(mb_deye<Mat3x3>(dN3P[iSez][i]*dsdxi[iSez]*dCoef),
637  Zero3x3,
638  Mat3x3(MatCross, L[iSez]*(dN3[iSez][i]*dCoef) - fTmp[i]*(dN3P[iSez][i]*dsdxi[iSez]*dCoef)),
639  mb_deye<Mat3x3>(dN3P[iSez][i]*dsdxi[iSez]*dCoef));
640  /* Delta - azioni interne */
641  AzTmp[iSez][i] = DRef[iSez]*AzTmp[iSez][i];
642  /* Correggo per la rotazione da locale a globale */
643  AzTmp[iSez][i].SubMat12(Mat3x3(MatCross, Az[iSez].GetVec1()*(dN3[iSez][i]*dCoef)));
644  AzTmp[iSez][i].SubMat22(Mat3x3(MatCross, Az[iSez].GetVec2()*(dN3[iSez][i]*dCoef)));
645  }
646  } /* end ciclo sui punti di valutazione */
647 
648  Vec3 bTmp[2];
649 
650  /* ciclo sulle equazioni */
651  for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
652  bTmp[0] = p[iSez] - pNode[iSez]->GetXCurr();
653  bTmp[1] = p[iSez] - pNode[iSez + 1]->GetXCurr();
654 
655  unsigned int iRow1 = iSez*6 + 1;
656  unsigned int iRow2 = iRow1 + 6;
657 
658  for (unsigned int i = 0; i < NUMNODES; i++) {
659  /* Equazione all'indietro: */
660  WMA.Sub(iRow1, 6*i + 1, AzTmp[iSez][i].GetMat11());
661  WMA.Sub(iRow1, 6*i + 4, AzTmp[iSez][i].GetMat12());
662 
663  WMA.Sub(iRow1 + 3, 6*i + 1,
664  AzTmp[iSez][i].GetMat21()
665  - Mat3x3(MatCross, Az[iSez].GetVec1()*(dCoef*dN3[iSez][i]))
666  + bTmp[0].Cross(AzTmp[iSez][i].GetMat11()));
667  WMA.Sub(iRow1 + 3, 6*i + 4,
668  AzTmp[iSez][i].GetMat22()
669  - Mat3x3(MatCrossCross, Az[iSez].GetVec1()*(-dCoef*dN3[iSez][i]), fTmp[i])
670  + bTmp[0].Cross(AzTmp[iSez][i].GetMat12()));
671 
672  /* Equazione in avanti: */
673  WMA.Add(iRow2, 6*i+1, AzTmp[iSez][i].GetMat11());
674  WMA.Add(iRow2, 6*i+4, AzTmp[iSez][i].GetMat12());
675 
676  WMA.Add(iRow2 + 3, 6*i + 1,
677  AzTmp[iSez][i].GetMat21()
678  - Mat3x3(MatCross, Az[iSez].GetVec1()*(dCoef*dN3[iSez][i]))
679  + bTmp[1].Cross(AzTmp[iSez][i].GetMat11()));
680  WMA.Add(iRow2 + 3, 6*i + 4,
681  AzTmp[iSez][i].GetMat22()
682  + Mat3x3(MatCrossCross, Az[iSez].GetVec1()*(dCoef*dN3[iSez][i]), fTmp[i])
683  + bTmp[1].Cross(AzTmp[iSez][i].GetMat12()));
684  }
685 
686  /* correzione alle equazioni */
687  Mat3x3 FTmp(MatCross, Az[iSez].GetVec1()*dCoef);
688  WMA.Sub(iRow1 + 3, 6*iSez + 1, FTmp);
689  WMA.Add(iRow2 + 3, 6*iSez + 7, FTmp);
690 
691  } /* end ciclo sui punti di valutazione */
692 }
Definition: matvec3.h:98
#define DEBUGCOUTFNAME(fname)
Definition: myassert.h:256
const Vec3 f[NUMNODES]
Definition: beam.h:145
const MatCross_Manip MatCross
Definition: matvec3.cc:639
virtual const Mat3x3 & GetRCurr(void) const
Definition: strnode.h:1012
Vec3 L[NUMSEZ]
Definition: beam.h:190
void Add(integer iRow, integer iCol, const Vec3 &v)
Definition: submat.cc:209
Mat3x3 mb_deye< Mat3x3 >(const doublereal d)
Definition: matvec3.h:1584
const Mat3x3 Zero3x3(0., 0., 0., 0., 0., 0., 0., 0., 0.)
void SubMat12(const Mat3x3 &x)
Definition: matvec6.h:416
const doublereal dN3[2][3]
Definition: shapefnc.cc:157
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
VectorExpression< VectorCrossExpr< VectorLhsExpr, VectorRhsExpr >, 3 > Cross(const VectorExpression< VectorLhsExpr, 3 > &u, const VectorExpression< VectorRhsExpr, 3 > &v)
Definition: matvec.h:3248
virtual const Vec3 & GetXCurr(void) const
Definition: strnode.h:310
const MatCrossCross_Manip MatCrossCross
Definition: matvec3.cc:640
void Sub(integer iRow, integer iCol, const Vec3 &v)
Definition: submat.cc:215
Vec6 Az[NUMSEZ]
Definition: beam.h:177
Mat6x6 DRef[NUMSEZ]
Definition: beam.h:159
const doublereal dN3P[2][3]
Definition: shapefnc.cc:162
Vec3 p[NUMSEZ]
Definition: beam.h:187
doublereal dsdxi[NUMSEZ]
Definition: beam.h:194

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().

701 {
702  DEBUGCOUTFNAME("Beam::AssStiffnessVec");
703 
704  /* Riceve il vettore gia' dimensionato e con gli indici a posto
705  * per scrivere il residuo delle equazioni di equilibrio dei tre nodi */
706 
707  /* Per la trattazione teorica, il riferimento e' il file ul-travi.tex
708  * (ora e' superato) */
709 
710  if (bFirstRes) {
711  bFirstRes = false; /* AfterPredict ha gia' calcolato tutto */
712  } else {
713  Vec3 gNod[NUMNODES];
714  Vec3 xTmp[NUMNODES];
715 
716  for (unsigned int i = 0; i < NUMNODES; i++) {
717  gNod[i] = pNode[i]->GetgCurr();
718  xTmp[i] = pNode[i]->GetXCurr() + pNode[i]->GetRCurr()*f[i];
719  }
720 
721  Mat3x3 RDelta[NUMSEZ];
722  Vec3 gGrad[NUMSEZ];
723 
724  /* Aggiorna le grandezze della trave nei punti di valutazione */
725  for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
726 
727  /* Posizione */
728  p[iSez] = InterpState(xTmp[NODE1], xTmp[NODE2], xTmp[NODE3], Beam::Section(iSez));
729 
730  /* Matrici di rotazione */
731  g[iSez] = InterpState(gNod[NODE1], gNod[NODE2], gNod[NODE3], Beam::Section(iSez));
732  RDelta[iSez] = Mat3x3(CGR_Rot::MatR, g[iSez]);
733  R[iSez] = RDelta[iSez]*RRef[iSez];
734 
735  /* Derivate della posizione */
736  L[iSez] = InterpDeriv(xTmp[NODE1], xTmp[NODE2], xTmp[NODE3], Beam::Section(iSez));
737 
738  /* Derivate dei parametri di rotazione */
739  gGrad[iSez] = InterpDeriv(gNod[NODE1], gNod[NODE2], gNod[NODE3], Beam::Section(iSez));
740 
741  /* Calcola le deformazioni nel sistema locale nei punti di valutazione */
742  DefLoc[iSez] = Vec6(R[iSez].MulTV(L[iSez]) - L0[iSez],
743  R[iSez].MulTV(Mat3x3(CGR_Rot::MatG, g[iSez])*gGrad[iSez]) + DefLocRef[iSez].GetVec2());
744 
745  /* Calcola le azioni interne */
746  pD[iSez]->Update(DefLoc[iSez]);
747  AzLoc[iSez] = pD[iSez]->GetF();
748 
749  /* corregge le azioni interne locali (piezo, ecc) */
750  AddInternalForces(AzLoc[iSez], iSez);
751 
752  /* Porta le azioni interne nel sistema globale */
753  Az[iSez] = MultRV(AzLoc[iSez], R[iSez]);
754  }
755  }
756 
757  WorkVec.Add(1, Az[S_I].GetVec1());
758  WorkVec.Add(4, (p[S_I] - pNode[NODE1]->GetXCurr()).Cross(Az[S_I].GetVec1())
759  + Az[S_I].GetVec2());
760  WorkVec.Add(7, Az[SII].GetVec1() - Az[S_I].GetVec1());
761  WorkVec.Add(10, Az[SII].GetVec2() - Az[S_I].GetVec2()
762  + (p[SII] - pNode[NODE2]->GetXCurr()).Cross(Az[SII].GetVec1())
763  - (p[S_I] - pNode[NODE2]->GetXCurr()).Cross(Az[S_I].GetVec1()));
764  WorkVec.Sub(13, Az[SII].GetVec1());
765  WorkVec.Add(16, Az[SII].GetVec1().Cross(p[SII] - pNode[NODE3]->GetXCurr())
766  - Az[SII].GetVec2());
767 }
Vec3 MultRV(const Vec3 &v, const Mat3x3 &R)
Definition: matvec3.cc:1144
Definition: matvec3.h:98
#define DEBUGCOUTFNAME(fname)
Definition: myassert.h:256
const Vec3 f[NUMNODES]
Definition: beam.h:145
static Vec3 InterpState(const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, enum Section Sec)
Definition: beam.cc:429
virtual const Vec3 & GetgCurr(void) const
Definition: strnode.h:982
virtual const Mat3x3 & GetRCurr(void) const
Definition: strnode.h:1012
Vec3 L[NUMSEZ]
Definition: beam.h:190
virtual void AddInternalForces(Vec6 &, unsigned int)
Definition: beam.h:227
ConstitutiveLaw6DOwner * pD[NUMSEZ]
Definition: beam.h:156
virtual void Sub(integer iRow, const Vec3 &v)
Definition: vh.cc:78
Vec6 DefLocRef[NUMSEZ]
Definition: beam.h:181
Vec6 AzLoc[NUMSEZ]
Definition: beam.h:179
Definition: matvec6.h:37
Vec3 L0[NUMSEZ]
Definition: beam.h:189
const MatG_Manip MatG
Definition: matvec3.cc:646
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
Section
Definition: beam.h:136
Vec3 InterpDeriv(const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, enum Section Sec)
Definition: beam.cc:446
const MatR_Manip MatR
Definition: matvec3.cc:645
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
VectorExpression< VectorCrossExpr< VectorLhsExpr, VectorRhsExpr >, 3 > Cross(const VectorExpression< VectorLhsExpr, 3 > &u, const VectorExpression< VectorRhsExpr, 3 > &v)
Definition: matvec.h:3248
virtual const Vec3 & GetXCurr(void) const
Definition: strnode.h:310
virtual void Add(integer iRow, const Vec3 &v)
Definition: vh.cc:63
bool bFirstRes
Definition: beam.h:197
Mat3x3 RRef[NUMSEZ]
Definition: beam.h:152
Vec3 g[NUMSEZ]
Definition: beam.h:188
const T & GetF(void) const
Definition: constltp.h:293
Vec6 Az[NUMSEZ]
Definition: beam.h:177
void Update(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp.h:283
Vec3 p[NUMSEZ]
Definition: beam.h:187
Vec6 DefLoc[NUMSEZ]
Definition: beam.h:180

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.

960 {
961  return true;
962 }
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().

382 {
383  ASSERT(i > 0 && i <= iGetNumPrivData());
384 
385  int sez = (i - 1)/iNumPrivData;
386  int idx = (i - 1)%iNumPrivData + 1;
387 
388  switch (idx) {
389  case 1:
390  case 2:
391  case 3:
392  case 4:
393  case 5:
394  case 6:
395 
396  return DefLoc[sez].dGet(idx);
397 
398  case 7:
399  case 8:
400  case 9:
401  case 10:
402  case 11:
403  case 12:
404  return AzLoc[sez].dGet(idx - 6);
405 
406  case 13:
407  case 14:
408  case 15:
409  return p[sez].dGet(idx - 12);
410 
411  case 16:
412  case 17:
413  case 18:
414  return RotManip::VecRot(R[sez]).dGet(idx - 15);
415 
416  case 19:
417  case 20:
418  case 21:
419  return Omega[sez].dGet(idx - 18);
420 
421  default:
422  silent_cerr("Beam(" << GetLabel() << "): "
423  "illegal private data " << i << std::endl);
425  }
426 }
virtual unsigned int iGetNumPrivData(void) const
Definition: beam.cc:263
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
Vec3 Omega[NUMSEZ]
Definition: beam.h:173
static const unsigned int iNumPrivData
Definition: beam.h:100
Vec3 VecRot(const Mat3x3 &Phi)
Definition: Rot.cc:136
Vec6 AzLoc[NUMSEZ]
Definition: beam.h:179
const doublereal & dGet(unsigned short int iRow) const
Definition: matvec3.h:285
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
#define ASSERT(expression)
Definition: colamd.c:977
unsigned int GetLabel(void) const
Definition: withlab.cc:62
const doublereal & dGet(unsigned short int i) const
Definition: matvec6.h:182
Vec3 p[NUMSEZ]
Definition: beam.h:187
Vec6 DefLoc[NUMSEZ]
Definition: beam.h:180

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().

467 {
468  /* Validazione dati */
469  ASSERT(pNode[NODE1] != NULL);
470  ASSERT(pNode[NODE1]->GetNodeType() == Node::STRUCTURAL);
471  ASSERT(pNode[NODE2] != NULL);
472  ASSERT(pNode[NODE2]->GetNodeType() == Node::STRUCTURAL);
473  ASSERT(pNode[NODE3] != NULL);
474  ASSERT(pNode[NODE3]->GetNodeType() == Node::STRUCTURAL);
475 
476  /* Calcola il ds/dxi e le deformazioni iniziali */
477  Mat3x3 RNod[NUMNODES];
478  Vec3 xTmp[NUMNODES];
479  for (unsigned int i = 0; i < NUMNODES; i++) {
480  RNod[i] = pNode[i]->GetRCurr();
481  xTmp[i] = pNode[i]->GetXCurr() + RNod[i]*f[i];
482  }
483 
484  Vec3 xGrad[NUMSEZ];
485  for (unsigned int i = 0; i < NUMSEZ; i++) {
486  /* temporary */
487  dsdxi[i] = 1.;
488  xGrad[i] = InterpDeriv(xTmp[NODE1],
489  xTmp[NODE2],
490  xTmp[NODE3],
491  Beam::Section(i));
492  doublereal d = xGrad[i].Dot();
493  if (d > std::numeric_limits<doublereal>::epsilon()) {
494  /* final */
495  dsdxi[i] = 1./std::sqrt(d);
496 
497  } else {
498  silent_cerr("warning, beam " << GetLabel()
499  << " has singular metric; aborting..." << std::endl);
500 
502  }
503  }
504 
505  /* Calcola le deformazioni iniziali */
506  for (unsigned int i = 0; i < NUMSEZ; i++) {
507  L0[i] = R[i].MulTV(InterpDeriv(xTmp[NODE1],
508  xTmp[NODE2],
509  xTmp[NODE3],
510  Beam::Section(i)));
511  pD[i]->Update(Zero6);
512  DRef[i] = MultRMRt(pD[i]->GetFDE(), R[i]);
513  }
514 }
Mat3x3 MultRMRt(const Mat3x3 &m, const Mat3x3 &R)
Definition: matvec3.cc:1162
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
Definition: matvec3.h:98
const Vec3 f[NUMNODES]
Definition: beam.h:145
virtual const Mat3x3 & GetRCurr(void) const
Definition: strnode.h:1012
doublereal Dot(const Vec3 &v) const
Definition: matvec3.h:243
ConstitutiveLaw6DOwner * pD[NUMSEZ]
Definition: beam.h:156
Vec3 MulTV(const Vec3 &v) const
Definition: matvec3.cc:482
Vec3 L0[NUMSEZ]
Definition: beam.h:189
const Vec6 Zero6(0., 0., 0., 0., 0., 0.)
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
Section
Definition: beam.h:136
Vec3 InterpDeriv(const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, enum Section Sec)
Definition: beam.cc:446
#define ASSERT(expression)
Definition: colamd.c:977
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
GradientExpression< UnaryExpr< FuncSqrt, Expr > > sqrt(const GradientExpression< Expr > &u)
Definition: gradient.h:2974
virtual const Vec3 & GetXCurr(void) const
Definition: strnode.h:310
double doublereal
Definition: colamd.c:52
void Update(const T &Eps, const T &EpsPrime=mb_zero< T >())
Definition: constltp.h:283
unsigned int GetLabel(void) const
Definition: withlab.cc:62
Mat6x6 DRef[NUMSEZ]
Definition: beam.h:159
doublereal dsdxi[NUMSEZ]
Definition: beam.h:194

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().

292  {
293  return Beam::ELASTIC;
294  };
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().

434  {
435  connectedNodes.resize(NUMNODES);
436  for (int i = 0; i < NUMNODES; i++) {
437  connectedNodes[i] = pNode[i];
438  }
439  };
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
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().

297  {
298  return Elem::BEAM;
299  };
virtual unsigned int Beam::iGetInitialNumDof ( void  ) const
inlinevirtual

Implements SubjectToInitialAssembly.

Definition at line 393 of file beam.h.

393  {
394  return 0;
395  };
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().

264 {
265  return 2*iNumPrivData;
266 }
static const unsigned int iNumPrivData
Definition: beam.h:100
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.

347 {
348  ASSERT(s != NULL);
349 
350  unsigned int p_idx = 0;
351 
352  if (strncmp(s, "pI", STRLENOF("pI")) != 0) {
353  return 0;
354  }
355  s += STRLENOF("pI");
356 
357  if (s[0] == 'I') {
358  p_idx += iNumPrivData;
359  s++;
360  }
361 
362  if (s[0] != '.') {
363  return 0;
364  }
365  s++;
366 
368  if (dynamic_cast<const ViscoElasticBeam *>(this)) {
369  type = ConstLawType::VISCOUS;
370  }
371 
372  unsigned int idx = iGetPrivDataIdx_int(s, type);
373  if (idx != 0) {
374  idx += p_idx;
375  }
376 
377  return idx;
378 }
static const unsigned int iNumPrivData
Definition: beam.h:100
#define ASSERT(expression)
Definition: colamd.c:977
static unsigned int iGetPrivDataIdx_int(const char *s, ConstLawType::Type type)
Definition: beam.cc:269
#define STRLENOF(s)
Definition: mbdyn.h:166

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().

270 {
271  ASSERT(s != NULL);
272 
273  unsigned int idx = 0;
274 
275  switch (s[0]) {
276  case 'k':
277  idx += 3;
278  case 'e':
279  if (s[1] == 'P') {
280  if (type != ConstLawType::VISCOUS) {
281  return 0;
282  }
283  s++;
284  idx += 21;
285  break;
286  }
287  break;
288 
289  case 'F':
290  idx += 6;
291  break;
292 
293  case 'M':
294  idx += 9;
295  break;
296 
297  case 'X':
298  idx += 12;
299  break;
300 
301  case 'P':
302  if (strncasecmp(s, "Phi", STRLENOF("Phi")) != 0) {
303  return 0;
304  }
305  s += STRLENOF("Phi") - 1;
306  idx += 15;
307  break;
308 
309  case 'O':
310  if (strncasecmp(s, "Omega", STRLENOF("Omega")) != 0) {
311  return 0;
312  }
313  s += STRLENOF("Omega") - 1;
314  idx += 18;
315  break;
316 
317  default:
318  return 0;
319  }
320 
321  switch (s[1]) {
322  case 'x':
323  idx += 1;
324  break;
325 
326  case 'y':
327  idx += 2;
328  break;
329 
330  case 'z':
331  idx += 3;
332  break;
333 
334  default:
335  return 0;
336  }
337 
338  if (s[2] != '\0') {
339  return 0;
340  }
341 
342  return idx;
343 }
#define ASSERT(expression)
Definition: colamd.c:977
#define STRLENOF(s)
Definition: mbdyn.h:166
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().

192 {
193  for (unsigned i = 0; i < NUMSEZ; i++) {
194 #ifdef USE_NETCDF
195  Var_X[i] = 0;
196  Var_Phi[i] = 0;
197  Var_F[i] = 0;
198  Var_M[i] = 0;
199  Var_Nu[i] = 0;
200  Var_K[i] = 0;
201  Var_NuP[i] = 0;
202  Var_KP[i] = 0;
203 #endif /* USE_NETCDF */
204 
205  Omega[i] = Zero3;
206  Az[i] = Zero6;
207  AzRef[i] = Zero6;
208  AzLoc[i] = Zero6;
209  DefLoc[i] = Zero6;
210  DefLocRef[i] = Zero6;
211  DefLocPrev[i] = Zero6;
212  p[i] = Zero3;
213  g[i] = Zero3;
214  L0[i] = Zero3;
215  L[i] = Zero3;
216  LRef[i] = Zero3;
217  }
218 
219  DsDxi();
220 
221  Vec3 xTmp[NUMNODES];
222 
223  for (unsigned int i = 0; i < NUMNODES; i++) {
224  xTmp[i] = pNode[i]->GetXCurr()+pNode[i]->GetRCurr()*f[i];
225  }
226 
227  /* Aggiorna le grandezze della trave nei punti di valutazione */
228  for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
229  p[iSez] = InterpState(xTmp[NODE1],
230  xTmp[NODE2],
231  xTmp[NODE3],
232  Beam::Section(iSez));
233  }
234 }
const Vec3 Zero3(0., 0., 0.)
Vec6 DefLocPrev[NUMSEZ]
Definition: beam.h:182
Definition: matvec3.h:98
const Vec3 f[NUMNODES]
Definition: beam.h:145
static Vec3 InterpState(const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, enum Section Sec)
Definition: beam.cc:429
virtual const Mat3x3 & GetRCurr(void) const
Definition: strnode.h:1012
Vec3 L[NUMSEZ]
Definition: beam.h:190
Vec3 Omega[NUMSEZ]
Definition: beam.h:173
Vec6 DefLocRef[NUMSEZ]
Definition: beam.h:181
Vec6 AzLoc[NUMSEZ]
Definition: beam.h:179
Vec3 LRef[NUMSEZ]
Definition: beam.h:192
Vec3 L0[NUMSEZ]
Definition: beam.h:189
const Vec6 Zero6(0., 0., 0., 0., 0., 0.)
Section
Definition: beam.h:136
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
virtual void DsDxi(void)
Definition: beam.cc:466
virtual const Vec3 & GetXCurr(void) const
Definition: strnode.h:310
Vec6 AzRef[NUMSEZ]
Definition: beam.h:178
Vec3 g[NUMSEZ]
Definition: beam.h:188
Vec6 Az[NUMSEZ]
Definition: beam.h:177
Vec3 p[NUMSEZ]
Definition: beam.h:187
Vec6 DefLoc[NUMSEZ]
Definition: beam.h:180

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().

1238 {
1239  DEBUGCOUTFNAME("Beam::InitialAssJac => AssStiffnessMat");
1240 
1241  /* Dimensiona la matrice, la azzera e pone gli indici corretti */
1242  FullSubMatrixHandler& WM = WorkMat.SetFull();
1243  WM.ResizeReset(18, 18);
1244 
1245  integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
1246  integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
1247  integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();
1248 
1249  for (int iCnt = 1; iCnt <= 6; iCnt++) {
1250  WM.PutRowIndex(iCnt, iNode1FirstPosIndex + iCnt);
1251  WM.PutColIndex(iCnt, iNode1FirstPosIndex + iCnt);
1252  WM.PutRowIndex(6 + iCnt, iNode2FirstPosIndex + iCnt);
1253  WM.PutColIndex(6 + iCnt, iNode2FirstPosIndex + iCnt);
1254  WM.PutRowIndex(12 + iCnt, iNode3FirstPosIndex + iCnt);
1255  WM.PutColIndex(12 + iCnt, iNode3FirstPosIndex + iCnt);
1256  }
1257 
1258  AssStiffnessMat(WM, WM, 1., XCurr, XCurr);
1259 
1260  return WorkMat;
1261 }
void PutColIndex(integer iSubCol, integer iCol)
Definition: submat.h:325
#define DEBUGCOUTFNAME(fname)
Definition: myassert.h:256
FullSubMatrixHandler & SetFull(void)
Definition: submat.h:1168
virtual integer iGetFirstPositionIndex(void) const
Definition: strnode.h:452
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
virtual void ResizeReset(integer, integer)
Definition: submat.cc:182
void PutRowIndex(integer iSubRow, integer iRow)
Definition: submat.h:311
long int integer
Definition: colamd.c:51
virtual void AssStiffnessMat(FullSubMatrixHandler &WMA, FullSubMatrixHandler &WMB, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: beam.cc:613

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().

1267 {
1268  DEBUGCOUTFNAME("Beam::InitialAssRes => AssStiffnessVec");
1269 
1270  /* Dimensiona il vettore, lo azzera e pone gli indici corretti */
1271  WorkVec.ResizeReset(18);
1272 
1273  integer iNode1FirstPosIndex = pNode[NODE1]->iGetFirstPositionIndex();
1274  integer iNode2FirstPosIndex = pNode[NODE2]->iGetFirstPositionIndex();
1275  integer iNode3FirstPosIndex = pNode[NODE3]->iGetFirstPositionIndex();
1276 
1277  for (int iCnt = 1; iCnt <= 6; iCnt++) {
1278  WorkVec.PutRowIndex(iCnt, iNode1FirstPosIndex + iCnt);
1279  WorkVec.PutRowIndex(6 + iCnt, iNode2FirstPosIndex + iCnt);
1280  WorkVec.PutRowIndex(12 + iCnt, iNode3FirstPosIndex + iCnt);
1281  }
1282 
1283  AssStiffnessVec(WorkVec, 1., XCurr, XCurr);
1284 
1285  return WorkVec;
1286 }
#define DEBUGCOUTFNAME(fname)
Definition: myassert.h:256
virtual void ResizeReset(integer)
Definition: vh.cc:55
virtual void AssStiffnessVec(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: beam.cc:697
virtual void PutRowIndex(integer iSubRow, integer iRow)=0
virtual integer iGetFirstPositionIndex(void) const
Definition: strnode.h:452
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
long int integer
Definition: colamd.c:51

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.

403  {
404  *piNumRows = 18;
405  *piNumCols = 18;
406  };
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().

450 {
451  const doublereal* pv1 = v1.pGetVec();
452  const doublereal* pv2 = v2.pGetVec();
453  const doublereal* pv3 = v3.pGetVec();
454 
455  return Vec3(
456  (pv1[0]*dN3P[Sec][0] + pv2[0]*dN3P[Sec][1]
457  + pv3[0]*dN3P[Sec][2])*dsdxi[Sec],
458  (pv1[1]*dN3P[Sec][0] + pv2[1]*dN3P[Sec][1]
459  + pv3[1]*dN3P[Sec][2])*dsdxi[Sec],
460  (pv1[2]*dN3P[Sec][0] + pv2[2]*dN3P[Sec][1]
461  + pv3[2]*dN3P[Sec][2])*dsdxi[Sec]);
462 }
Definition: matvec3.h:98
const doublereal * pGetVec(void) const
Definition: matvec3.h:192
double doublereal
Definition: colamd.c:52
const doublereal dN3P[2][3]
Definition: shapefnc.cc:162
doublereal dsdxi[NUMSEZ]
Definition: beam.h:194

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().

433 {
434  const doublereal* pv1 = v1.pGetVec();
435  const doublereal* pv2 = v2.pGetVec();
436  const doublereal* pv3 = v3.pGetVec();
437 
438  return Vec3(
439  pv1[0]*dN3[Sec][0] + pv2[0]*dN3[Sec][1] + pv3[0]*dN3[Sec][2],
440  pv1[1]*dN3[Sec][0] + pv2[1]*dN3[Sec][1] + pv3[1]*dN3[Sec][2],
441  pv1[2]*dN3[Sec][0] + pv2[2]*dN3[Sec][1] + pv3[2]*dN3[Sec][2]);
442 }
Definition: matvec3.h:98
const doublereal dN3[2][3]
Definition: shapefnc.cc:157
const doublereal * pGetVec(void) const
Definition: matvec3.h:192
double doublereal
Definition: colamd.c:52

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().

520 {
521  /* Validazione dati */
522  ASSERT(pNode[NODE1] != NULL);
523  ASSERT(pNode[NODE1]->GetNodeType() == Node::STRUCTURAL);
524  ASSERT(pNode[NODE2] != NULL);
525  ASSERT(pNode[NODE2]->GetNodeType() == Node::STRUCTURAL);
526  ASSERT(pNode[NODE3] != NULL);
527  ASSERT(pNode[NODE3]->GetNodeType() == Node::STRUCTURAL);
528 
529  /* Modo consistente: */
530  Mat3x3 RNod[NUMNODES];
531  Vec3 w[NUMNODES];
532  for (unsigned int i = 0; i < NUMNODES; i++) {
533  RNod[i] = pNode[i]->GetRCurr()*RNode[i];
534  w[i] = pNode[i]->GetWCurr();
535  }
536 
537  /* Calcolo i parametri di rotazione dei nodi di estremo rispetto a quello
538  * centrale, nell'ipotesi (realistica) che siano limitati */
539  Vec3 g1(CGR_Rot::Param, RNod[NODE2].MulTM(RNod[NODE1]));
540  Vec3 g3(CGR_Rot::Param, RNod[NODE2].MulTM(RNod[NODE3]));
541 
542  /* Calcolo le derivate dei parametri di rotazione ai nodi di estremo; in
543  * quello centrale si assume che sia uguale alla velocita' di rotazione */
544  Vec3 g1P(Mat3x3(CGR_Rot::MatGm1, g1)*w[NODE1]);
545  Vec3 g3P(Mat3x3(CGR_Rot::MatGm1, g3)*w[NODE3]);
546 
547  for (unsigned int i = 0; i < NUMSEZ; i++) {
548  Vec3 gTmp(g1*dN3[i][NODE1]+g3*dN3[i][NODE3]);
549  Vec3 gPTmp(g1P*dN3[i][NODE1]+w[NODE2]*dN3[i][NODE2]+g3P*dN3[i][NODE3]);
550  Omega[i] = Mat3x3(CGR_Rot::MatG, gTmp)*gPTmp;
551  }
552 
553 #if 0
554  /* Modo brutale: interpolo le velocita' dei nodi */
555  Vec3 w[NUMNODES];
556  for (unsigned int i = 0; i < NUMNODES; i++) {
557  w[i] = pNode[i]->GetWCurr();
558  }
559  for (unsigned int i = 0; i < NUMSEZ; i++) {
560  Omega[i] = (w{NODE1]*dN3[i][NODE1]
561  + w[NODE2]*dN3[i][NODE2]
562  + w[NODE3]*dN3[i][NODE3]);
563  }
564 #endif /* 0 */
565 }
const MatGm1_Manip MatGm1
Definition: matvec3.cc:647
const Param_Manip Param
Definition: matvec3.cc:644
Definition: matvec3.h:98
virtual const Mat3x3 & GetRCurr(void) const
Definition: strnode.h:1012
const Mat3x3 RNode[NUMNODES]
Definition: beam.h:147
Vec3 Omega[NUMSEZ]
Definition: beam.h:173
const doublereal dN3[2][3]
Definition: shapefnc.cc:157
const MatG_Manip MatG
Definition: matvec3.cc:646
virtual const Vec3 & GetWCurr(void) const
Definition: strnode.h:1030
#define ASSERT(expression)
Definition: colamd.c:977
const StructNode * pNode[NUMNODES]
Definition: beam.h:142

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().

1142 {
1143  if (bToBeOutput()) {
1144 #ifdef USE_NETCDF
1145  if (OH.UseNetCDF(OutputHandler::BEAMS)) {
1146  for (unsigned iSez = 0; iSez < NUMSEZ; iSez++) {
1147  if (Var_X[iSez]) {
1148  Var_X[iSez]->put_rec(p[iSez].pGetVec(), OH.GetCurrentStep());
1149  }
1150 
1151  if (Var_Phi[iSez]) {
1152  Vec3 E;
1153  switch (od) {
1154  case EULER_123:
1155  E = MatR2EulerAngles123(R[iSez])*dRaDegr;
1156  break;
1157 
1158  case EULER_313:
1159  E = MatR2EulerAngles313(R[iSez])*dRaDegr;
1160  break;
1161 
1162  case EULER_321:
1163  E = MatR2EulerAngles321(R[iSez])*dRaDegr;
1164  break;
1165 
1166  case ORIENTATION_VECTOR:
1167  E = RotManip::VecRot(R[iSez]);
1168  break;
1169 
1170  case ORIENTATION_MATRIX:
1171  break;
1172 
1173  default:
1174  /* impossible */
1175  break;
1176  }
1177 
1178  switch (od) {
1179  case EULER_123:
1180  case EULER_313:
1181  case EULER_321:
1182  case ORIENTATION_VECTOR:
1183  Var_Phi[iSez]->put_rec(E.pGetVec(), OH.GetCurrentStep());
1184  break;
1185 
1186  case ORIENTATION_MATRIX:
1187  Var_Phi[iSez]->put_rec(R[iSez].pGetMat(), OH.GetCurrentStep());
1188  break;
1189 
1190  default:
1191  /* impossible */
1192  break;
1193  }
1194  }
1195 
1196  if (Var_F[iSez]) {
1197  Var_F[iSez]->put_rec(AzLoc[iSez].GetVec1().pGetVec(), OH.GetCurrentStep());
1198  }
1199 
1200  if (Var_M[iSez]) {
1201  Var_M[iSez]->put_rec(AzLoc[iSez].GetVec2().pGetVec(), OH.GetCurrentStep());
1202  }
1203 
1204  if (Var_Nu[iSez]) {
1205  Var_Nu[iSez]->put_rec(DefLoc[iSez].GetVec1().pGetVec(), OH.GetCurrentStep());
1206  }
1207 
1208  if (Var_K[iSez]) {
1209  Var_K[iSez]->put_rec(DefLoc[iSez].GetVec2().pGetVec(), OH.GetCurrentStep());
1210  }
1211 
1212  if (Var_NuP[iSez]) {
1213  Var_NuP[iSez]->put_rec(DefPrimeLoc[iSez].GetVec1().pGetVec(), OH.GetCurrentStep());
1214  }
1215 
1216  if (Var_KP[iSez]) {
1217  Var_KP[iSez]->put_rec(DefPrimeLoc[iSez].GetVec2().pGetVec(), OH.GetCurrentStep());
1218  }
1219  }
1220  }
1221 #endif /* USE_NETCDF */
1222 
1223  if (OH.UseText(OutputHandler::BEAMS)) {
1224  OH.Beams() << std::setw(8) << GetLabel()
1225  << " " << AzLoc[S_I].GetVec1()
1226  << " " << AzLoc[S_I].GetVec2()
1227  << " " << AzLoc[SII].GetVec1()
1228  << " " << AzLoc[SII].GetVec2()
1229  << std::endl;
1230  }
1231  }
1232 }
virtual bool bToBeOutput(void) const
Definition: output.cc:890
Definition: matvec3.h:98
const Vec3 & GetVec2(void) const
Definition: matvec6.h:76
bool UseNetCDF(int out) const
Definition: output.cc:491
Vec6 DefPrimeLoc[NUMSEZ]
Definition: beam.h:185
Vec3 VecRot(const Mat3x3 &Phi)
Definition: Rot.cc:136
OrientationDescription od
Definition: beam.h:116
Vec6 AzLoc[NUMSEZ]
Definition: beam.h:179
const Vec3 & GetVec1(void) const
Definition: matvec6.h:72
Vec3 MatR2EulerAngles313(const Mat3x3 &R)
Definition: matvec3.cc:927
long GetCurrentStep(void) const
Definition: output.h:116
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
Vec3 MatR2EulerAngles123(const Mat3x3 &R)
Definition: matvec3.cc:893
const doublereal dRaDegr
Definition: matvec3.cc:884
std::ostream & Beams(void) const
Definition: output.h:457
const doublereal * pGetVec(void) const
Definition: matvec3.h:192
Vec3 MatR2EulerAngles321(const Mat3x3 &R)
Definition: matvec3.cc:941
unsigned int GetLabel(void) const
Definition: withlab.cc:62
Vec3 p[NUMSEZ]
Definition: beam.h:187
bool UseText(int out) const
Definition: output.cc:446
Vec6 DefLoc[NUMSEZ]
Definition: beam.h:180

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.

1048 {
1049  if (bToBeOutput()) {
1050 #ifdef USE_NETCDF
1051  if (OH.UseNetCDF(OutputHandler::BEAMS)) {
1053 
1054  const char *type = 0;
1055  switch (GetBeamType()) {
1056  case Beam::ELASTIC:
1057  type = "elastic";
1058  break;
1059 
1060  case Beam::VISCOELASTIC:
1061  type = "viscoelastic";
1062  break;
1063 
1065  type = "piezoelectric elastic";
1066  break;
1067 
1069  type = "piezoelectric viscoelastic";
1070  break;
1071 
1072  default:
1073  type = "unknown";
1074  break;
1075  }
1076 
1077  std::ostringstream os;
1078  os << "elem.beam." << GetLabel();
1079 
1080  (void)OH.CreateVar(os.str(), type);
1081 
1082  os << '.';
1083  std::string name(os.str());
1084 
1085  unsigned uOutputFlags = (fToBeOutput() & ToBeOutput::OUTPUT_PRIVATE_MASK);
1086 
1087  static const char *sez[] = { "I", "II" };
1088  for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
1089  os.str("");
1090  os << "evaluation point " << sez[iSez] << " ";
1091  std::string ep(os.str());
1092 
1093  if (uOutputFlags & Beam::OUTPUT_EP_X) {
1094  Var_X[iSez] = OH.CreateVar<Vec3>(name + "X_" + sez[iSez], "m",
1095  ep + "global position vector (X, Y, Z)");
1096  }
1097 
1098  if (uOutputFlags & Beam::OUTPUT_EP_R) {
1099  Var_Phi[iSez] = OH.CreateRotationVar(name,
1100  std::string("_") + sez[iSez], od, ep + "global");
1101  }
1102 
1103  if (uOutputFlags & Beam::OUTPUT_EP_F) {
1104  Var_F[iSez] = OH.CreateVar<Vec3>(name + "F_" + sez[iSez], "N",
1105  ep + "internal force in local frame (F_X, F_Y, F_Z)");
1106  }
1107 
1108  if (uOutputFlags & Beam::OUTPUT_EP_M) {
1109  Var_M[iSez] = OH.CreateVar<Vec3>(name + "M_" + sez[iSez], "Nm",
1110  ep + "internal moment in local frame (M_X, M_Y, M_Z)");
1111  }
1112 
1113  if (uOutputFlags & Beam::OUTPUT_EP_NU) {
1114  Var_Nu[iSez] = OH.CreateVar<Vec3>(name + "nu_" + sez[iSez], "-",
1115  ep + "linear strain in local frame (nu_X, nu_Y, nu_Z)");
1116  }
1117 
1118  if (uOutputFlags & Beam::OUTPUT_EP_K) {
1119  Var_K[iSez] = OH.CreateVar<Vec3>(name + "k_" + sez[iSez], "1/m",
1120  ep + "angular strain in local frame (K_X, K_Y, K_Z)");
1121  }
1122 
1123  if (uOutputFlags & Beam::OUTPUT_EP_NUP) {
1124  Var_NuP[iSez] = OH.CreateVar<Vec3>(name + "nuP_" + sez[iSez], "1/s",
1125  ep + "linear strain rate in local frame (nuP_X, nuP_Y, nuP_Z)");
1126  }
1127 
1128  if (uOutputFlags & Beam::OUTPUT_EP_KP) {
1129  Var_KP[iSez] = OH.CreateVar<Vec3>(name + "kP_" + sez[iSez], "1/ms",
1130  ep + "angular strain rate in local frame (KP_X, KP_Y, KP_Z)");
1131  }
1132  }
1133  }
1134 #endif // USE_NETCDF
1135  }
1136 }
virtual bool bToBeOutput(void) const
Definition: output.cc:890
Definition: matvec3.h:98
bool UseNetCDF(int out) const
Definition: output.cc:491
OrientationDescription od
Definition: beam.h:116
bool IsOpen(int out) const
Definition: output.cc:395
#define ASSERT(expression)
Definition: colamd.c:977
virtual flag fToBeOutput(void) const
Definition: output.cc:884
unsigned int GetLabel(void) const
Definition: withlab.cc:62
virtual Beam::Type GetBeamType(void) const
Definition: beam.h:292

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().

1291 {
1292  ASSERT(i >= 1 && i <= 3);
1293  switch (i) {
1294  case 1:
1295  case 2:
1296  case 3:
1297  return pNode[i-1];
1298  default:
1300  }
1301 }
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
#define ASSERT(expression)
Definition: colamd.c:977
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
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_().

571 {
572  return Restart_(out)<< ';' << std::endl;
573 }
virtual std::ostream & Restart_(std::ostream &out) const
Definition: beam.cc:576

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().

577 {
578  out << " beam: " << GetLabel();
579  for (unsigned int i = 0; i < NUMNODES; i++) {
580  out << ", " << pNode[i]->GetLabel() << ", reference, node, ",
581  f[i].Write(out, ", ");
582  }
583 
584  for (unsigned int i = 0; i < NUMSEZ; i++) {
585  out << ", reference, global, 1, ",
586  (R[i].GetVec(1)).Write(out, ", ")
587  << ", 2, ", (R[i].GetVec(2)).Write(out, ", ") << ", ",
588  pD[i]->pGetConstLaw()->Restart(out);
589  }
590 
591  return out;
592 }
std::ostream & Write(std::ostream &out, const char *sFill=" ") const
Definition: matvec3.cc:738
ConstitutiveLaw< T, Tder > * pGetConstLaw(void) const
Definition: constltp.h:278
const Vec3 f[NUMNODES]
Definition: beam.h:145
std::ostream & Write(std::ostream &out, const FullMatrixHandler &m, const char *s, const char *s2)
Definition: fullmh.cc:376
ConstitutiveLaw6DOwner * pD[NUMSEZ]
Definition: beam.h:156
Vec3 GetVec(unsigned short int i) const
Definition: matvec3.h:893
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
const StructNode * pNode[NUMNODES]
Definition: beam.h:142
unsigned int GetLabel(void) const
Definition: withlab.cc:62

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.

409  {
410  NO_OP;
411  };
#define NO_OP
Definition: myassert.h:74
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().

969 {
970  /* Aggiorna le grandezze della trave nei punti di valutazione */
971  for (unsigned int iSez = 0; iSez < NUMSEZ; iSez++) {
972  RRef[iSez] = R[iSez];
973  LRef[iSez] = L[iSez];
974  DefLocRef[iSez] = DefLoc[iSez];
975  AzRef[iSez] = Az[iSez];
976 
977  /* Aggiorna il legame costitutivo di riferimento
978  * (la deformazione e' gia' stata aggiornata dall'ultimo residuo) */
979  DRef[iSez] = MultRMRt(pD[iSez]->GetFDE(), RRef[iSez]);
980  }
981 
982  bFirstRes = true;
983 }
Mat3x3 MultRMRt(const Mat3x3 &m, const Mat3x3 &R)
Definition: matvec3.cc:1162
Vec3 L[NUMSEZ]
Definition: beam.h:190
ConstitutiveLaw6DOwner * pD[NUMSEZ]
Definition: beam.h:156
Vec6 DefLocRef[NUMSEZ]
Definition: beam.h:181
Vec3 LRef[NUMSEZ]
Definition: beam.h:192
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
bool bFirstRes
Definition: beam.h:197
Vec6 AzRef[NUMSEZ]
Definition: beam.h:178
Mat3x3 RRef[NUMSEZ]
Definition: beam.h:152
Vec6 Az[NUMSEZ]
Definition: beam.h:177
Mat6x6 DRef[NUMSEZ]
Definition: beam.h:159
Vec6 DefLoc[NUMSEZ]
Definition: beam.h:180

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.

317  {
318  if (bConsistentInertia) {
319  *piNumRows = 36;
320  } else {
321  *piNumRows = 18;
322  }
323 
324  *piNumCols = 18;
325  };
const bool bConsistentInertia
Definition: beam.h:162

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.

1877 {
1878  DEBUGCOUTFNAME("ReadBeam");
1879 
1880  /* Per ogni nodo: */
1881 
1882  /* Nodo 1 */
1883  const StructNode* pNode1 = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);
1884 
1885  const Mat3x3& R1(pNode1->GetRCurr());
1886  if (HP.IsKeyWord("position")) {
1887  /* just eat it! */
1888  NO_OP;
1889  }
1890  Vec3 f1(HP.GetPosRel(ReferenceFrame(pNode1)));
1891  Mat3x3 Rn1(Eye3);
1892  if (HP.IsKeyWord("orientation") || HP.IsKeyWord("rot")) {
1893  Rn1 = HP.GetRotRel(ReferenceFrame(pNode1));
1894  }
1895 
1896  DEBUGLCOUT(MYDEBUG_INPUT, "node 1 offset (node reference frame): "
1897  << f1 << std::endl
1898  << "(global frame): "
1899  << pNode1->GetXCurr()+pNode1->GetRCurr()*f1 << std::endl);
1900 
1901  /* Nodo 2 */
1902  const StructNode* pNode2 = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);
1903 
1904  Mat3x3 R2(pNode2->GetRCurr());
1905  if (HP.IsKeyWord("position")) {
1906  /* just eat it! */
1907  NO_OP;
1908  }
1909  Vec3 f2(HP.GetPosRel(ReferenceFrame(pNode2)));
1910  Mat3x3 Rn2(Eye3);
1911  if (HP.IsKeyWord("orientation") || HP.IsKeyWord("rot")) {
1912  Rn2 = HP.GetRotRel(ReferenceFrame(pNode2));
1913  }
1914 
1915  DEBUGLCOUT(MYDEBUG_INPUT, "node 2 offset (node reference frame): "
1916  << f2 << std::endl
1917  << "(global frame): "
1918  << pNode2->GetXCurr()+pNode2->GetRCurr()*f2 << std::endl);
1919 
1920  /* Nodo 3 */
1921  const StructNode* pNode3 = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);
1922 
1923  Mat3x3 R3(pNode3->GetRCurr());
1924  if (HP.IsKeyWord("position")) {
1925  /* just eat it! */
1926  NO_OP;
1927  }
1928  Vec3 f3(HP.GetPosRel(ReferenceFrame(pNode3)));
1929  Mat3x3 Rn3(Eye3);
1930  if (HP.IsKeyWord("orientation") || HP.IsKeyWord("rot")) {
1931  Rn3 = HP.GetRotRel(ReferenceFrame(pNode3));
1932  }
1933 
1934  DEBUGLCOUT(MYDEBUG_INPUT, "node 3 offset (node reference frame): "
1935  << f3 << std::endl
1936  << "(global frame): "
1937  << pNode3->GetXCurr()+pNode3->GetRCurr()*f3 << std::endl);
1938 
1939  /* Per ogni punto: */
1940 
1941  /* Punto I */
1942 
1943  /* Matrice R */
1944  Mat3x3 R_I;
1945  bool b_I(false);
1946  if (HP.IsKeyWord("from" "nodes") || HP.IsKeyWord("node")) {
1947  b_I = true;
1948  } else {
1949  R_I = HP.GetRotAbs(::AbsRefFrame);
1950  }
1951 
1952  /* Legame costitutivo */
1954  ConstitutiveLaw6D* pD_I = HP.GetConstLaw6D(CLType_I);
1955 
1956  if (pD_I->iGetNumDof() != 0) {
1957  silent_cerr("line " << HP.GetLineData()
1958  << ": Beam(" << uLabel << ") "
1959  "does not support dynamic constitutive laws yet"
1960  << std::endl);
1962  }
1963 
1964 #ifdef DEBUG
1965  Mat6x6 MTmp(pD_I->GetFDE());
1966  Mat3x3 D11(MTmp.GetMat11());
1967  Mat3x3 D12(MTmp.GetMat12());
1968  Mat3x3 D21(MTmp.GetMat21());
1969  Mat3x3 D22(MTmp.GetMat22());
1970 
1972  "First point matrix D11: " << std::endl << D11 << std::endl
1973  << "First point matrix D12: " << std::endl << D12 << std::endl
1974  << "First point matrix D21: " << std::endl << D21 << std::endl
1975  << "First point matrix D22: " << std::endl << D22 << std::endl);
1976 #endif
1977 
1978 
1979  /* Punto II */
1980 
1981  /* Matrice R */
1982  Mat3x3 RII;
1983  bool bII(false);
1984  if (HP.IsKeyWord("same")) {
1985  if (b_I) {
1986  bII = true;
1987  } else {
1988  RII = R_I;
1989  }
1990  } else {
1991  if (HP.IsKeyWord("from" "nodes") || HP.IsKeyWord("node")) {
1992  bII = true;
1993  } else {
1994  RII = HP.GetRotAbs(::AbsRefFrame);
1995  }
1996  }
1997 
1998  /* Legame costitutivo */
2000  ConstitutiveLaw6D* pDII = NULL;
2001 
2002  if (HP.IsKeyWord("same")) {
2003  pDII = pD_I->pCopy();
2004  CLTypeII = CLType_I;
2005 
2006  } else {
2007  pDII = HP.GetConstLaw6D(CLTypeII);
2008 
2009  if (pDII->iGetNumDof() != 0) {
2010  silent_cerr("line " << HP.GetLineData()
2011  << ": Beam(" << uLabel << ") "
2012  "does not support dynamic constitutive laws yet"
2013  << std::endl);
2015  }
2016  }
2017 
2018  Beam::Type Type;
2019  if (CLType_I == ConstLawType::ELASTIC && CLTypeII == ConstLawType::ELASTIC) {
2020  Type = Beam::ELASTIC;
2021  } else {
2022  Type = Beam::VISCOELASTIC;
2023  }
2024 
2025 #ifdef DEBUG
2026  MTmp = pDII->GetFDE();
2027  D11 = MTmp.GetMat11();
2028  D12 = MTmp.GetMat12();
2029  D21 = MTmp.GetMat21();
2030  D22 = MTmp.GetMat22();
2031 
2033  "Second point matrix D11: " << std::endl << D11 << std::endl
2034  << "Second point matrix D12: " << std::endl << D12 << std::endl
2035  << "Second point matrix D21: " << std::endl << D21 << std::endl
2036  << "Second point matrix D22: " << std::endl << D22 << std::endl);
2037 #endif
2038 
2039  flag fPiezo(0);
2040  Mat3xN PiezoMat[2][2];
2041  integer iNumElec = 0;
2042  const ScalarDifferentialNode **pvElecDofs = 0;
2043  if (HP.IsKeyWord("piezoelectric" "actuator")) {
2044  fPiezo = flag(1);
2046  "Piezoelectric actuator beam is expected" << std::endl);
2047 
2048  iNumElec = HP.GetInt();
2050  "piezo actuator " << uLabel << " has " << iNumElec
2051  << " electrodes" << std::endl);
2052  if (iNumElec <= 0) {
2053  silent_cerr("PiezoElectricBeam(" << uLabel << "): "
2054  "illegal number of electric nodes " << iNumElec
2055  << " at line " << HP.GetLineData() << std::endl);
2057  }
2058 
2059  SAFENEWARR(pvElecDofs, const ScalarDifferentialNode *, iNumElec);
2060 
2061  for (integer i = 0; i < iNumElec; i++) {
2062  pvElecDofs[i] = pDM->ReadNode<const ScalarDifferentialNode, Node::ABSTRACT>(HP);
2063  }
2064 
2065  PiezoMat[0][0].Resize(iNumElec);
2066  PiezoMat[1][0].Resize(iNumElec);
2067  PiezoMat[0][1].Resize(iNumElec);
2068  PiezoMat[1][1].Resize(iNumElec);
2069 
2070  /* leggere le matrici (6xN sez. 1, 6xN sez. 2) */
2071  HP.GetMat6xN(PiezoMat[0][0], PiezoMat[1][0], iNumElec);
2072  if (HP.IsKeyWord("same")) {
2073  PiezoMat[0][1].Copy(PiezoMat[0][0]);
2074  PiezoMat[1][1].Copy(PiezoMat[1][0]);
2075  } else {
2076  HP.GetMat6xN(PiezoMat[0][1], PiezoMat[1][1], iNumElec);
2077  }
2078 
2079 #if 0
2080  DEBUGLCOUT(MYDEBUG_INPUT, "Piezo matrix I:" << std::endl << PiezoMat[0][0] << PiezoMat[1][0]);
2081  DEBUGLCOUT(MYDEBUG_INPUT, "Piezo matrix II:" << std::endl << PiezoMat[0][1] << PiezoMat[1][1]);
2082 #endif /* 0 */
2083  }
2084 
2086  unsigned uFlags = Beam::OUTPUT_NONE;
2087  ReadOptionalBeamCustomOutput(pDM, HP, uLabel, Type, uFlags, od);
2088 
2089  flag fOut = pDM->fReadOutput(HP, Elem::BEAM);
2090  if (fOut) {
2091  fOut |= uFlags;
2092  }
2093 
2094  /* Se necessario, interpola i parametri di rotazione delle sezioni */
2095  if (b_I || bII) {
2096  Mat3x3 R(R2*Rn2);
2097  Vec3 g1(CGR_Rot::Param, R.MulTM(R1*Rn1));
2098  Vec3 g3(CGR_Rot::Param, R.MulTM(R3*Rn3));
2099  if (b_I) {
2101  }
2102  if (bII) {
2104  }
2105  }
2106 
2107  std::ostream& out = pDM->GetLogFile();
2108  out << "beam3: " << uLabel
2109  << " " << pNode1->GetLabel()
2110  << " ", f1.Write(out, " ")
2111  << " " << pNode2->GetLabel()
2112  << " ", f2.Write(out, " ")
2113  << " " << pNode3->GetLabel()
2114  << " ", f3.Write(out, " ")
2115  << std::endl;
2116 
2117  Elem* pEl = NULL;
2118 
2119  if ((CLType_I == ConstLawType::ELASTIC)
2120  && (CLTypeII == ConstLawType::ELASTIC))
2121  {
2122  if (fPiezo == 0) {
2124  Beam,
2125  Beam(uLabel,
2126  pNode1, pNode2, pNode3,
2127  f1, f2, f3,
2128  Rn1, Rn2, Rn3,
2129  R_I, RII,
2130  pD_I, pDII,
2131  od, fOut));
2132  } else {
2136  pNode1, pNode2, pNode3,
2137  f1, f2, f3,
2138  Rn1, Rn2, Rn3,
2139  R_I, RII,
2140  pD_I, pDII,
2141  iNumElec,
2142  pvElecDofs,
2143  PiezoMat[0][0], PiezoMat[1][0],
2144  PiezoMat[0][1], PiezoMat[1][1],
2145  od, fOut));
2146  }
2147 
2148  } else /* At least one is VISCOUS or VISCOELASTIC */ {
2149  if (fPiezo == 0) {
2153  pNode1, pNode2, pNode3,
2154  f1, f2, f3,
2155  Rn1, Rn2, Rn3,
2156  R_I, RII,
2157  pD_I, pDII,
2158  od, fOut));
2159  } else {
2163  pNode1, pNode2, pNode3,
2164  f1, f2, f3,
2165  Rn1, Rn2, Rn3,
2166  R_I, RII,
2167  pD_I, pDII,
2168  iNumElec,
2169  pvElecDofs,
2170  PiezoMat[0][0], PiezoMat[1][0],
2171  PiezoMat[0][1], PiezoMat[1][1],
2172  od, fOut));
2173  }
2174  }
2175 
2176  /* Costruttore normale
2177  * Beam(unsigned int uL,
2178  * const StructNode* pN1, const StructNode* pN2, const StructNode* pN3,
2179  * const Vec3& X1, const Vec3& X2, const Vec3& X3,
2180  * const Vec3& F1, const Vec3& F2, const Vec3& F3,
2181  * const Mat3x3& r_I, const Mat3x3& rII,
2182  * const Mat3x3& d11_I, const Mat3x3& d12_I,
2183  * const Mat3x3& d21_I, const Mat3x3& d22_I,
2184  * const Mat3x3& d11II, const Mat3x3& d12II,
2185  * const Mat3x3& d21II, const Mat3x3& d22II,
2186  * const Vec3& eps0_I, const Vec3& k0_I,
2187  * const Vec3& eps0II, const Vec3& k0II);
2188  */
2189 
2190 
2191  /* Se non c'e' il punto e virgola finale */
2192  if (HP.IsArg()) {
2193  silent_cerr("semicolon expected "
2194  "at line " << HP.GetLineData() << std::endl);
2196  }
2197 
2198  return pEl;
2199 } /* End of ReadBeam() */
flag fReadOutput(MBDynParser &HP, const T &t) const
Definition: dataman.h:1064
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: beam.cc:64
Mat3x3 GetRotRel(const ReferenceFrame &rf)
Definition: mbpar.cc:1795
const Vec3 Zero3(0., 0., 0.)
const Param_Manip Param
Definition: matvec3.cc:644
long int flag
Definition: mbdyn.h:43
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
Definition: matvec3.h:98
#define DEBUGCOUTFNAME(fname)
Definition: myassert.h:256
virtual integer GetInt(integer iDefval=0)
Definition: parser.cc:1050
static Vec3 InterpState(const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, enum Section Sec)
Definition: beam.cc:429
virtual const Mat3x3 & GetRCurr(void) const
Definition: strnode.h:1012
Mat3x3 GetRotAbs(const ReferenceFrame &rf)
Definition: mbpar.cc:1857
virtual void GetMat6xN(Mat3xN &m1, Mat3xN &m2, integer iNumCols)
Definition: mbpar.cc:2743
virtual const Tder & GetFDE(void) const
Definition: constltp.h:129
const Mat3x3 Eye3(1., 0., 0., 0., 1., 0., 0., 0., 1.)
OrientationDescription
Definition: matvec3.h:1597
#define NO_OP
Definition: myassert.h:74
Mat3x3 GetMat11(void)
Definition: matvec6.h:320
OrientationDescription od
Definition: beam.h:116
const ReferenceFrame AbsRefFrame(0, Vec3(0., 0., 0), Mat3x3(1., 0., 0., 0., 1., 0., 0., 0., 1.), Vec3(0., 0., 0), Vec3(0., 0., 0), EULER_123)
Vec3 GetPosRel(const ReferenceFrame &rf)
Definition: mbpar.cc:1331
virtual bool IsKeyWord(const char *sKeyWord)
Definition: parser.cc:910
virtual ConstitutiveLaw< T, Tder > * pCopy(void) const =0
Mat3x3 R[NUMSEZ]
Definition: beam.h:151
Definition: beam.h:56
unsigned int uLabel
Definition: withlab.h:44
Type
Definition: beam.h:64
const MatR_Manip MatR
Definition: matvec3.cc:645
ConstitutiveLaw6D * GetConstLaw6D(ConstLawType::Type &clt)
Definition: mbpar.cc:1995
Mat3x3 MulTM(const Mat3x3 &m) const
Definition: matvec3.cc:500
#define SAFENEWWITHCONSTRUCTOR(pnt, item, constructor)
Definition: mynewmem.h:698
virtual const Vec3 & GetXCurr(void) const
Definition: strnode.h:310
void Resize(integer ns)
Definition: matvec3n.cc:318
void ReadOptionalBeamCustomOutput(DataManager *pDM, MBDynParser &HP, unsigned int uLabel, Beam::Type BT, unsigned &uFlags, OrientationDescription &od)
Definition: beam.cc:1863
virtual unsigned int iGetNumDof(void) const
Definition: constltp.h:138
virtual bool IsArg(void)
Definition: parser.cc:807
Definition: elem.h:75
std::ostream & GetLogFile(void) const
Definition: dataman.h:326
#define SAFENEWARR(pnt, item, sz)
Definition: mynewmem.h:701
const Mat3xN & Copy(const Mat3xN &m)
Definition: matvec3n.cc:407
long int integer
Definition: colamd.c:51
virtual HighParser::ErrOut GetLineData(void) const
Definition: parsinc.cc:697
unsigned int GetLabel(void) const
Definition: withlab.cc:62
Node * ReadNode(MBDynParser &HP, Node::Type type) const
Definition: dataman3.cc:2309
#define DEBUGLCOUT(level, msg)
Definition: myassert.h:244

Member Data Documentation

Vec6 Beam::AzRef[NUMSEZ]
protected

Definition at line 178 of file beam.h.

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

Vec6 Beam::DefLocPrev[NUMSEZ]
protected
Vec6 Beam::DefLocRef[NUMSEZ]
protected
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.

doublereal Beam::dsdxi[NUMSEZ]
protected

Definition at line 194 of file beam.h.

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

Vec3 Beam::fRef[NUMNODES]
protected

Definition at line 146 of file beam.h.

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::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().

const Mat3x3 Beam::RNode[NUMNODES]
protected

Definition at line 147 of file beam.h.

Referenced by Beam(), and Omega0().

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: