MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
body.h
Go to the documentation of this file.
1 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/struct/body.h,v 1.48 2017/01/12 14:46:43 masarati Exp $ */
2 /*
3  * MBDyn (C) is a multibody analysis code.
4  * http://www.mbdyn.org
5  *
6  * Copyright (C) 1996-2017
7  *
8  * Pierangelo Masarati <masarati@aero.polimi.it>
9  * Paolo Mantegazza <mantegazza@aero.polimi.it>
10  *
11  * Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano
12  * via La Masa, 34 - 20156 Milano, Italy
13  * http://www.aero.polimi.it
14  *
15  * Changing this copyright notice is forbidden.
16  *
17  * This program is free software; you can redistribute it and/or modify
18  * it under the terms of the GNU General Public License as published by
19  * the Free Software Foundation (version 2 of the License).
20  *
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software
29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30  */
31 
32 /* elementi di massa, tipo: Elem::Type BODY */
33 
34 #ifndef BODY_H
35 #define BODY_H
36 
37 /* include per derivazione della classe */
38 
39 #include "elem.h"
40 #include "strnode.h"
41 #include "gravity.h"
42 
43 /* Mass - begin */
44 
45 class Mass :
46 virtual public Elem, public ElemGravityOwner, public InitialAssemblyElem {
47 protected:
50 
51  /* momento statico */
52  Vec3 GetS_int(void) const;
53 
54  /* momento d'inerzia */
55  Mat3x3 GetJ_int(void) const;
56 
57  /* Scrive il contributo dell'elemento al file di restart */
58  virtual std::ostream& Restart(std::ostream& out) const;
59 
60  void
62 
63  void
67  const doublereal& dCoef);
68 
69 public:
70  /* Costruttore definitivo (da mettere a punto) */
71  Mass(unsigned int uL, const StructDispNode *pNode,
72  doublereal dMassTmp, flag fOut);
73 
74  virtual ~Mass(void);
75 
76  /* massa totale */
77  doublereal dGetM(void) const;
78 
79  /* momento statico */
80  Vec3 GetS(void) const;
81 
82  /* momento d'inerzia */
83  Mat3x3 GetJ(void) const;
84 
85  /* nodo */
86  const StructDispNode *pGetNode(void) const;
87 
88  /* Tipo dell'elemento (usato solo per debug ecc.) */
89  virtual Elem::Type GetElemType(void) const {
90  return Elem::BODY;
91  };
92 
93  /* Numero gdl durante l'assemblaggio iniziale */
94  virtual unsigned int iGetInitialNumDof(void) const {
95  return 0;
96  };
97 
98  /* Accesso ai dati privati */
99  virtual unsigned int iGetNumPrivData(void) const;
100  virtual unsigned int iGetPrivDataIdx(const char *s) const;
101  virtual doublereal dGetPrivData(unsigned int i) const;
102 
103  /******** PER IL SOLUTORE PARALLELO *********/
104  /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
105  * utile per l'assemblaggio della matrice di connessione fra i dofs */
106  virtual void
107  GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
108  connectedNodes.resize(1);
109  connectedNodes[0] = pNode;
110  };
111  /**************************************************/
112 };
113 
114 /* Mass - end */
115 
116 /* DynamicMass - begin */
117 
118 class DynamicMass :
119 virtual public Elem, public Mass {
120 private:
121 
122  Vec3 GetB_int(void) const;
123 
124  /* Assembla le due matrici necessarie per il calcolo degli
125  * autovalori e per lo jacobiano */
126  void AssMats(FullSubMatrixHandler& WorkMatA,
127  FullSubMatrixHandler& WorkMatB,
128  doublereal dCoef,
129  bool bGravity,
130  const Vec3& GravityAcceleration);
131 
132 public:
133  /* Costruttore definitivo (da mettere a punto) */
134  DynamicMass(unsigned int uL, const DynamicStructDispNode* pNode,
135  doublereal dMassTmp, flag fOut);
136 
137  virtual ~DynamicMass(void);
138 
139  void WorkSpaceDim(integer* piNumRows, integer* piNumCols) const {
140  *piNumRows = 3;
141  *piNumCols = 3;
142  };
143 
144  virtual VariableSubMatrixHandler&
146  doublereal dCoef,
147  const VectorHandler& XCurr,
148  const VectorHandler& XPrimeCurr);
149 
150  void AssMats(VariableSubMatrixHandler& WorkMatA,
151  VariableSubMatrixHandler& WorkMatB,
152  const VectorHandler& XCurr,
153  const VectorHandler& XPrimeCurr);
154 
155  virtual SubVectorHandler&
156  AssRes(SubVectorHandler& WorkVec,
157  doublereal dCoef,
158  const VectorHandler& XCurr,
159  const VectorHandler& XPrimeCurr);
160 
161  /* Dimensione del workspace durante l'assemblaggio iniziale.
162  * Occorre tener conto del numero di dof che l'elemento definisce
163  * in questa fase e dei dof dei nodi che vengono utilizzati.
164  * Sono considerati dof indipendenti la posizione e la velocita'
165  * dei nodi */
166  virtual void
167  InitialWorkSpaceDim(integer* piNumRows, integer* piNumCols) const {
168  *piNumRows = 3;
169  *piNumCols = 3;
170  };
171 
172  /* Contributo allo jacobiano durante l'assemblaggio iniziale */
173  virtual VariableSubMatrixHandler&
175  const VectorHandler& XCurr);
176 
177  /* Contributo al residuo durante l'assemblaggio iniziale */
178  virtual SubVectorHandler&
179  InitialAssRes(SubVectorHandler& WorkVec, const VectorHandler& XCurr);
180 
181  /* Usata per inizializzare la quantita' di moto */
182  virtual void SetValue(DataManager *pDM,
184  SimulationEntity::Hints *ph = 0);
185 };
186 
187 /* DynamicMass - end */
188 
189 /* StaticMass - begin */
190 
191 class StaticMass :
192 virtual public Elem, public Mass {
193 private:
194  /* Assembla le due matrici necessarie per il calcolo degli
195  * autovalori e per lo jacobiano */
196  bool AssMats(FullSubMatrixHandler& WorkMatA,
197  FullSubMatrixHandler& WorkMatB,
198  doublereal dCoef);
199 
200 public:
201  /* Costruttore definitivo (da mettere a punto) */
202  StaticMass(unsigned int uL, const StaticStructDispNode* pNode,
203  doublereal dMass, flag fOut);
204 
205  virtual ~StaticMass(void);
206 
207  void WorkSpaceDim(integer* piNumRows, integer* piNumCols) const {
208  *piNumRows = 3;
209  *piNumCols = 3;
210  };
211 
212  virtual VariableSubMatrixHandler&
214  doublereal dCoef,
215  const VectorHandler& XCurr,
216  const VectorHandler& XPrimeCurr);
217 
218  void AssMats(VariableSubMatrixHandler& WorkMatA,
219  VariableSubMatrixHandler& WorkMatB,
220  const VectorHandler& XCurr,
221  const VectorHandler& XPrimeCurr);
222 
223  virtual SubVectorHandler&
224  AssRes(SubVectorHandler& WorkVec,
225  doublereal dCoef,
226  const VectorHandler& XCurr,
227  const VectorHandler& XPrimeCurr);
228 
229  /* inverse dynamics capable element */
230  virtual bool bInverseDynamics(void) const;
231 
232  /* Inverse Dynamics: */
233  virtual SubVectorHandler&
234  AssRes(SubVectorHandler& WorkVec,
235  const VectorHandler& /* XCurr */ ,
236  const VectorHandler& /* XPrimeCurr */ ,
237  const VectorHandler& /* XPrimePrimeCurr */ ,
239 
240  /* Dimensione del workspace durante l'assemblaggio iniziale.
241  * Occorre tener conto del numero di dof che l'elemento definisce
242  * in questa fase e dei dof dei nodi che vengono utilizzati.
243  * Sono considerati dof indipendenti la posizione e la velocita'
244  * dei nodi */
245  virtual void
246  InitialWorkSpaceDim(integer* piNumRows, integer* piNumCols) const {
247  *piNumRows = 3;
248  *piNumCols = 3;
249  };
250 
251  /* Contributo allo jacobiano durante l'assemblaggio iniziale */
252  virtual VariableSubMatrixHandler&
254  const VectorHandler& XCurr);
255 
256  /* Contributo al residuo durante l'assemblaggio iniziale */
257  virtual SubVectorHandler&
258  InitialAssRes(SubVectorHandler& WorkVec, const VectorHandler& XCurr);
259 
260  /* Usata per inizializzare la quantita' di moto */
261  virtual void SetValue(DataManager *pDM,
263  SimulationEntity::Hints *ph = 0);
264 };
265 
266 /* StaticMass - end */
267 
268 /* Body - begin */
269 
270 class Body :
271 virtual public Elem, public ElemGravityOwner, public InitialAssemblyElem {
272 protected:
278 
279  mutable Vec3 STmp;
280  mutable Mat3x3 JTmp;
281 
282  /* momento statico */
283  Vec3 GetS_int(void) const;
284 
285  /* momento d'inerzia */
286  Mat3x3 GetJ_int(void) const;
287 
288  void
290 
291  void
295  const doublereal& dCoef,
296  const Vec3& Sc);
297 
298 public:
299  /* Costruttore definitivo (da mettere a punto) */
300  Body(unsigned int uL, const StructNode *pNode,
301  doublereal dMassTmp, const Vec3& XgcTmp, const Mat3x3& JTmp,
302  flag fOut);
303 
304  virtual ~Body(void);
305 
306  /* Scrive il contributo dell'elemento al file di restart */
307  virtual std::ostream& Restart(std::ostream& out) const;
308 
309  /* massa totale */
310  doublereal dGetM(void) const;
311 
312  /* momento statico */
313  Vec3 GetS(void) const;
314 
315  /* momento d'inerzia */
316  Mat3x3 GetJ(void) const;
317 
318  /* nodo */
319  const StructNode *pGetNode(void) const;
320 
321  /* Tipo dell'elemento (usato solo per debug ecc.) */
322  virtual Elem::Type GetElemType(void) const {
323  return Elem::BODY;
324  };
325 
326  /* Numero gdl durante l'assemblaggio iniziale */
327  virtual unsigned int iGetInitialNumDof(void) const {
328  return 0;
329  };
330 
331  virtual void AfterPredict(VectorHandler& X, VectorHandler& XP);
332 
333  /* Accesso ai dati privati */
334  virtual unsigned int iGetNumPrivData(void) const;
335  virtual unsigned int iGetPrivDataIdx(const char *s) const;
336  virtual doublereal dGetPrivData(unsigned int i) const;
337 
338  /******** PER IL SOLUTORE PARALLELO *********/
339  /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento
340  * utile per l'assemblaggio della matrice di connessione fra i dofs */
341  virtual void
342  GetConnectedNodes(std::vector<const Node *>& connectedNodes) const {
343  connectedNodes.resize(1);
344  connectedNodes[0] = pNode;
345  };
346  /**************************************************/
347 };
348 
349 /* Body - end */
350 
351 
352 /* DynamicBody - begin */
353 
354 class DynamicBody :
355 virtual public Elem, public Body {
356 private:
357 
358  Vec3 GetB_int(void) const;
359  Vec3 GetG_int(void) const;
360 
361  /* Assembla le due matrici necessarie per il calcolo degli
362  * autovalori e per lo jacobiano */
363  void AssMats(FullSubMatrixHandler& WorkMatA,
364  FullSubMatrixHandler& WorkMatB,
365  doublereal dCoef,
366  bool bGravity,
367  const Vec3& GravityAcceleration);
368 
369 public:
370  /* Costruttore definitivo (da mettere a punto) */
371  DynamicBody(unsigned int uL, const DynamicStructNode* pNodeTmp,
372  doublereal dMassTmp, const Vec3& XgcTmp, const Mat3x3& JTmp,
373  flag fOut);
374 
375  virtual ~DynamicBody(void);
376 
377  virtual void WorkSpaceDim(integer* piNumRows, integer* piNumCols) const;
378 
379  virtual VariableSubMatrixHandler&
381  doublereal dCoef,
382  const VectorHandler& XCurr,
383  const VectorHandler& XPrimeCurr);
384 
385  virtual void
387  VariableSubMatrixHandler& WorkMatB,
388  const VectorHandler& XCurr,
389  const VectorHandler& XPrimeCurr);
390 
391  virtual SubVectorHandler&
392  AssRes(SubVectorHandler& WorkVec,
393  doublereal dCoef,
394  const VectorHandler& XCurr,
395  const VectorHandler& XPrimeCurr);
396 
397  /* Dimensione del workspace durante l'assemblaggio iniziale.
398  * Occorre tener conto del numero di dof che l'elemento definisce
399  * in questa fase e dei dof dei nodi che vengono utilizzati.
400  * Sono considerati dof indipendenti la posizione e la velocita'
401  * dei nodi */
402  virtual void
403  InitialWorkSpaceDim(integer* piNumRows, integer* piNumCols) const;
404 
405  /* Contributo allo jacobiano durante l'assemblaggio iniziale */
406  virtual VariableSubMatrixHandler&
408  const VectorHandler& XCurr);
409 
410  /* Contributo al residuo durante l'assemblaggio iniziale */
411  virtual SubVectorHandler&
412  InitialAssRes(SubVectorHandler& WorkVec, const VectorHandler& XCurr);
413 
414  /* Usata per inizializzare la quantita' di moto */
415  virtual void SetValue(DataManager *pDM,
417  SimulationEntity::Hints *ph = 0);
418 };
419 
420 /* DynamicBody - end */
421 
422 
423 /* ModalBody - begin */
424 
425 class ModalBody :
426 virtual public Elem, public DynamicBody {
427 private:
429 
430  /* Assembla le due matrici necessarie per il calcolo degli
431  * autovalori e per lo jacobiano */
432  void AssMats(FullSubMatrixHandler& WorkMatA,
433  FullSubMatrixHandler& WorkMatB,
434  doublereal dCoef,
435  const VectorHandler& XCurr,
436  const VectorHandler& XPrimeCurr,
437  bool bGravity,
438  const Vec3& GravityAcceleration);
439 
440 public:
441  /* Costruttore definitivo (da mettere a punto) */
442  ModalBody(unsigned int uL, const ModalNode* pNodeTmp,
443  doublereal dMassTmp, const Vec3& XgcTmp, const Mat3x3& JTmp,
444  flag fOut);
445 
446  virtual ~ModalBody(void);
447 
448  void WorkSpaceDim(integer* piNumRows, integer* piNumCols) const;
449 
450  virtual VariableSubMatrixHandler&
452  doublereal dCoef,
453  const VectorHandler& XCurr,
454  const VectorHandler& XPrimeCurr);
455 
456  void AssMats(VariableSubMatrixHandler& WorkMatA,
457  VariableSubMatrixHandler& WorkMatB,
458  const VectorHandler& XCurr,
459  const VectorHandler& XPrimeCurr);
460 
461  virtual SubVectorHandler&
462  AssRes(SubVectorHandler& WorkVec,
463  doublereal dCoef,
464  const VectorHandler& XCurr,
465  const VectorHandler& XPrimeCurr);
466 };
467 
468 /* ModalBody - end */
469 
470 
471 /* StaticBody - begin */
472 
473 class StaticBody :
474 virtual public Elem, public Body {
475 private:
476  /* Assembla le due matrici necessarie per il calcolo degli
477  * autovalori e per lo jacobiano */
478  bool AssMats(FullSubMatrixHandler& WorkMatA,
479  FullSubMatrixHandler& WorkMatB,
480  doublereal dCoef);
481 
482 public:
483  /* Costruttore definitivo (da mettere a punto) */
484  StaticBody(unsigned int uL, const StaticStructNode* pNode,
485  doublereal dMass, const Vec3& Xgc, const Mat3x3& J,
486  flag fOut);
487 
488  virtual ~StaticBody(void);
489 
490  void WorkSpaceDim(integer* piNumRows, integer* piNumCols) const {
491  *piNumRows = 6;
492  *piNumCols = 6;
493  };
494 
495  virtual VariableSubMatrixHandler&
497  doublereal dCoef,
498  const VectorHandler& XCurr,
499  const VectorHandler& XPrimeCurr);
500 
501  void AssMats(VariableSubMatrixHandler& WorkMatA,
502  VariableSubMatrixHandler& WorkMatB,
503  const VectorHandler& XCurr,
504  const VectorHandler& XPrimeCurr);
505 
506  virtual SubVectorHandler&
507  AssRes(SubVectorHandler& WorkVec,
508  doublereal dCoef,
509  const VectorHandler& XCurr,
510  const VectorHandler& XPrimeCurr);
511 
512  /* inverse dynamics capable element */
513  virtual bool bInverseDynamics(void) const;
514 
515  /* Inverse Dynamics: */
516  virtual SubVectorHandler&
517  AssRes(SubVectorHandler& WorkVec,
518  const VectorHandler& /* XCurr */ ,
519  const VectorHandler& /* XPrimeCurr */ ,
520  const VectorHandler& /* XPrimePrimeCurr */ ,
522 
523  /* Dimensione del workspace durante l'assemblaggio iniziale.
524  * Occorre tener conto del numero di dof che l'elemento definisce
525  * in questa fase e dei dof dei nodi che vengono utilizzati.
526  * Sono considerati dof indipendenti la posizione e la velocita'
527  * dei nodi */
528  virtual void
529  InitialWorkSpaceDim(integer* piNumRows, integer* piNumCols) const {
530  *piNumRows = 6;
531  *piNumCols = 6;
532  };
533 
534  /* Contributo allo jacobiano durante l'assemblaggio iniziale */
535  virtual VariableSubMatrixHandler&
537  const VectorHandler& XCurr);
538 
539  /* Contributo al residuo durante l'assemblaggio iniziale */
540  virtual SubVectorHandler&
541  InitialAssRes(SubVectorHandler& WorkVec, const VectorHandler& XCurr);
542 
543  /* Usata per inizializzare la quantita' di moto */
544  virtual void SetValue(DataManager *pDM,
546  SimulationEntity::Hints *ph = 0);
547 };
548 
549 /* StaticBody - end */
550 
551 class DataManager;
552 class MBDynParser;
553 
554 extern Elem* ReadBody(DataManager* pDM, MBDynParser& HP, unsigned int uLabel);
555 
556 #endif /* BODY_H */
557 
virtual std::ostream & Restart(std::ostream &out) const
Definition: body.cc:774
virtual Elem::Type GetElemType(void) const
Definition: body.h:89
virtual void SetValue(DataManager *pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints *ph=0)
Definition: body.cc:1377
virtual VariableSubMatrixHandler & InitialAssJac(VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
Definition: body.cc:684
void AssVecRBK_int(SubVectorHandler &WorkVec)
Definition: body.cc:183
virtual void SetValue(DataManager *pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints *ph=0)
Definition: body.cc:1925
long int flag
Definition: mbdyn.h:43
Definition: body.h:270
Definition: matvec3.h:98
virtual void SetValue(DataManager *pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints *ph=0)
Definition: body.cc:710
virtual void InitialWorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: body.h:246
virtual SubVectorHandler & AssRes(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: body.cc:1192
void AssMats(FullSubMatrixHandler &WorkMatA, FullSubMatrixHandler &WorkMatB, doublereal dCoef, bool bGravity, const Vec3 &GravityAcceleration)
Definition: body.cc:1139
virtual VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: body.cc:496
Vec3 STmp
Definition: body.h:279
virtual ~StaticMass(void)
Definition: body.cc:489
virtual ~Body(void)
Definition: body.cc:744
Vec3 GetG_int(void) const
Definition: body.cc:1407
virtual unsigned int iGetPrivDataIdx(const char *s) const
Definition: body.cc:831
const StructNode * pGetNode(void) const
Definition: body.cc:818
virtual SubVectorHandler & AssRes(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: body.cc:375
DynamicBody(unsigned int uL, const DynamicStructNode *pNodeTmp, doublereal dMassTmp, const Vec3 &XgcTmp, const Mat3x3 &JTmp, flag fOut)
Definition: body.cc:1002
virtual SubVectorHandler & AssRes(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: body.cc:1591
virtual void InitialWorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: body.h:529
doublereal dGetM(void) const
Definition: body.cc:98
Vec3 GetS(void) const
Definition: body.cc:804
virtual ~DynamicMass(void)
Definition: body.cc:240
StaticMass(unsigned int uL, const StaticStructDispNode *pNode, doublereal dMass, flag fOut)
Definition: body.cc:477
void AssVecRBK_int(SubVectorHandler &WorkVec)
Definition: body.cc:888
virtual VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: body.cc:247
bool AssMats(FullSubMatrixHandler &WorkMatA, FullSubMatrixHandler &WorkMatB, doublereal dCoef)
Definition: body.cc:1758
Mat3x3 GetJ_int(void) const
Definition: body.cc:77
virtual void WorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: body.cc:1022
std::vector< Hint * > Hints
Definition: simentity.h:89
virtual SubVectorHandler & InitialAssRes(SubVectorHandler &WorkVec, const VectorHandler &XCurr)
Definition: body.cc:1324
Mat3x3 J0
Definition: body.h:277
void WorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: body.h:139
virtual SubVectorHandler & InitialAssRes(SubVectorHandler &WorkVec, const VectorHandler &XCurr)
Definition: body.cc:440
virtual void AfterPredict(VectorHandler &X, VectorHandler &XP)
Definition: body.cc:787
virtual void InitialWorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: body.cc:1029
virtual unsigned int iGetInitialNumDof(void) const
Definition: body.h:327
Vec3 GetB_int(void) const
Definition: body.cc:1395
virtual void SetValue(DataManager *pDM, VectorHandler &X, VectorHandler &XP, SimulationEntity::Hints *ph=0)
Definition: body.cc:453
StaticBody(unsigned int uL, const StaticStructNode *pNode, doublereal dMass, const Vec3 &Xgc, const Mat3x3 &J, flag fOut)
Definition: body.cc:1659
virtual unsigned int iGetInitialNumDof(void) const
Definition: body.h:94
virtual VariableSubMatrixHandler & InitialAssJac(VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
Definition: body.cc:1899
virtual ~ModalBody(void)
Definition: body.cc:1441
bool AssMats(FullSubMatrixHandler &WorkMatA, FullSubMatrixHandler &WorkMatB, doublereal dCoef)
Definition: body.cc:574
virtual std::ostream & Restart(std::ostream &out) const
Definition: body.cc:87
DataManager * pDM
Definition: mbpar.h:252
virtual unsigned int iGetNumPrivData(void) const
Definition: body.cc:126
ModalBody(unsigned int uL, const ModalNode *pNodeTmp, doublereal dMassTmp, const Vec3 &XgcTmp, const Mat3x3 &JTmp, flag fOut)
Definition: body.cc:1427
const StructDispNode * pNode
Definition: body.h:48
Vec3 GetS(void) const
Definition: body.cc:105
virtual ~DynamicBody(void)
Definition: body.cc:1016
virtual void GetConnectedNodes(std::vector< const Node * > &connectedNodes) const
Definition: body.h:107
virtual Elem::Type GetElemType(void) const
Definition: body.h:322
doublereal dMass
Definition: body.h:49
void WorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: body.h:490
doublereal dMass
Definition: body.h:274
virtual ~Mass(void)
Definition: body.cc:61
doublereal dGetM(void) const
Definition: body.cc:797
void AssMatsRBK_int(FullSubMatrixHandler &WMA, FullSubMatrixHandler &WMB, const doublereal &dCoef, const Vec3 &Sc)
Definition: body.cc:928
virtual VariableSubMatrixHandler & InitialAssJac(VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
Definition: body.cc:426
virtual SubVectorHandler & AssRes(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: body.cc:601
virtual VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: body.cc:1454
DynamicMass(unsigned int uL, const DynamicStructDispNode *pNode, doublereal dMassTmp, flag fOut)
Definition: body.cc:228
Vec3 WP
Definition: body.h:428
Definition: body.h:45
virtual VariableSubMatrixHandler & InitialAssJac(VariableSubMatrixHandler &WorkMat, const VectorHandler &XCurr)
Definition: body.cc:1255
Mat3x3 JTmp
Definition: body.h:280
virtual SubVectorHandler & InitialAssRes(SubVectorHandler &WorkVec, const VectorHandler &XCurr)
Definition: body.cc:697
Vec3 GetB_int(void) const
Definition: body.cc:465
virtual doublereal dGetPrivData(unsigned int i) const
Definition: body.cc:153
const StructDispNode * pGetNode(void) const
Definition: body.cc:119
virtual bool bInverseDynamics(void) const
Definition: body.cc:1841
void AssMats(FullSubMatrixHandler &WorkMatA, FullSubMatrixHandler &WorkMatB, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr, bool bGravity, const Vec3 &GravityAcceleration)
Definition: body.cc:1540
virtual ~StaticBody(void)
Definition: body.cc:1673
Definition: elem.h:75
Type
Definition: elem.h:91
virtual unsigned int iGetPrivDataIdx(const char *s) const
Definition: body.cc:132
virtual void GetConnectedNodes(std::vector< const Node * > &connectedNodes) const
Definition: body.h:342
Elem * ReadBody(DataManager *pDM, MBDynParser &HP, unsigned int uLabel)
Definition: body.cc:1937
virtual VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: body.cc:1036
Mat3x3 GetJ_int(void) const
Definition: body.cc:760
void AssMats(FullSubMatrixHandler &WorkMatA, FullSubMatrixHandler &WorkMatB, doublereal dCoef, bool bGravity, const Vec3 &GravityAcceleration)
Definition: body.cc:350
virtual unsigned int iGetNumPrivData(void) const
Definition: body.cc:825
Vec3 GetS_int(void) const
Definition: body.cc:752
Vec3 S0
Definition: body.h:276
virtual bool bInverseDynamics(void) const
Definition: body.cc:642
Mass(unsigned int uL, const StructDispNode *pNode, doublereal dMassTmp, flag fOut)
Definition: body.cc:44
void AssMatsRBK_int(FullSubMatrixHandler &WMA, FullSubMatrixHandler &WMB, const doublereal &dCoef)
Definition: body.cc:204
virtual SubVectorHandler & InitialAssRes(SubVectorHandler &WorkVec, const VectorHandler &XCurr)
Definition: body.cc:1912
void WorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: body.h:207
virtual VariableSubMatrixHandler & AssJac(VariableSubMatrixHandler &WorkMat, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: body.cc:1680
double doublereal
Definition: colamd.c:52
long int integer
Definition: colamd.c:51
virtual doublereal dGetPrivData(unsigned int i) const
Definition: body.cc:852
const StructNode * pNode
Definition: body.h:273
virtual SubVectorHandler & AssRes(SubVectorHandler &WorkVec, doublereal dCoef, const VectorHandler &XCurr, const VectorHandler &XPrimeCurr)
Definition: body.cc:1794
Mat3x3 GetJ(void) const
Definition: body.cc:112
Mat3x3 GetJ(void) const
Definition: body.cc:811
virtual void InitialWorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: body.h:167
Vec3 XPP
Definition: body.h:428
Vec3 Xgc
Definition: body.h:275
Vec3 GetS_int(void) const
Definition: body.cc:69
void WorkSpaceDim(integer *piNumRows, integer *piNumCols) const
Definition: body.cc:1447
Body(unsigned int uL, const StructNode *pNode, doublereal dMassTmp, const Vec3 &XgcTmp, const Mat3x3 &JTmp, flag fOut)
Definition: body.cc:722