mbsimflexiblebody 4.0.0 MBSim Flexible Body Module

generic_flexible_ffr_body.h
1 /* Copyright (C) 2004-2015 MBSim Development Team
2 *
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public
5 * License as published by the Free Software Foundation; either
6 * version 2.1 of the License, or (at your option) any later version.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
12 *
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16 *
17 * Contact: martin.o.foerg@googlemail.com
18 */
19
20 #ifndef _GENERIC_FLEXIBLE_FFR_BODY_H_
21 #define _GENERIC_FLEXIBLE_FFR_BODY_H_
22
23 #include "mbsimFlexibleBody/node_based_body.h"
24 #include "mbsimFlexibleBody/utils/openmbv_utils.h"
25 #include "mbsim/functions/time_dependent_function.h"
26 #include "mbsim/functions/state_dependent_function.h"
27 #include "mbsim/utils/index.h"
28
29 namespace MBSim {
30 class Frame;
31 }
32
33 namespace MBSimFlexibleBody {
34
35 template<typename Dep>
36 struct BaseType;
37
38 template<int N>
39 struct BaseType<fmatvec::Vector<fmatvec::Fixed<N>, double>> {
40 using type = fmatvec::VecV;
41 };
42
43 template<>
44 struct BaseType<fmatvec::SqrMat3> {
45 using type = fmatvec::MatVx3;
46 };
47
48 template<>
49 struct BaseType<fmatvec::SqrMatV> {
50 using type = fmatvec::MatV;
51 };
52
53 template<int N>
54 struct BaseType<fmatvec::Matrix<fmatvec::General, fmatvec::Fixed<N>, fmatvec::Var, double>> {
55 using type = fmatvec::MatV;
56 };
57
62 class GenericFlexibleFfrBody : public NodeBasedBody {
63
64 public:
65 enum GeneralizedVelocityOfRotation {
66 derivativeOfGeneralizedPositionOfRotation=0,
67 coordinatesOfAngularVelocityWrtFrameOfReference,
68 coordinatesOfAngularVelocityWrtFrameForKinematics,
69 unknown
70 };
71
72 GenericFlexibleFfrBody(const std::string &name="");
76 ~GenericFlexibleFfrBody() override;
77
78 void updateqd() override;
79 void updateT() override;
80 void updateh(int j=0) override;
81 void updateM() override;
82 void updateGeneralizedPositions() override;
83 void updateGeneralizedVelocities() override;
84 void updateDerivativeOfGeneralizedPositions() override;
85 void updateGeneralizedAccelerations() override;
86 void updatePositions();
87 void updateVelocities();
88 void updateAccelerations();
89 void updateJacobians() override;
90 void updateGyroscopicAccelerations();
91 void updatePositions(MBSim::Frame *frame) override;
92 void updateVelocities(MBSim::Frame *frame) override;
93 void updateAccelerations(MBSim::Frame *frame) override;
94 void updateJacobians(MBSim::Frame *frame, int j=0) override { (this->*updateJacobians_[j])(frame); }
95 void updateGyroscopicAccelerations(MBSim::Frame *frame) override;
96 void updateJacobians0(MBSim::Frame *frame);
97 void updateJacobians1(MBSim::Frame *frame) { }
98 void updateMb();
99 void updateKJ(int j=0) { (this->*updateKJ_[j])(); }
100 void updateKJ0();
101 void updateKJ1();
102 void (GenericFlexibleFfrBody::*updateKJ_[2])();
103 void calcSize() override;
104 void calcqSize() override;
105 void calcuSize(int j=0) override;
106
107 /* INHERITED INTERFACE OF OBJECT */
108 void init(InitStage stage, const MBSim::InitConfigSet &config) override;
109 void setUpInverseKinetics() override;
110 /*****************************************************/
111
112 /* INHERITED INTERFACE OF ELEMENT */
113 void plot() override;
114 /*****************************************************/
115
116 /* GETTER / SETTER */
117 int getNumberOfModeShapes() { if(updSize) calcSize(); return ne; }
118
119 // NOTE: we can not use a overloaded setTranslation here due to restrictions in XML but define them for convinience in c++
124 void setGeneralTranslation(MBSim::Function<fmatvec::Vec3(fmatvec::VecV, double)> *fPrPK_) {
125 fPrPK = fPrPK_;
126 fPrPK->setParent(this);
127 fPrPK->setName("GeneralTranslation");
128 }
133 void setTimeDependentTranslation(MBSim::Function<fmatvec::Vec3(double)> *fPrPK_) {
134 setGeneralTranslation(new MBSim::TimeDependentFunction<fmatvec::Vec3>(fPrPK_));
135 }
140 void setStateDependentTranslation(MBSim::Function<fmatvec::Vec3(fmatvec::VecV)> *fPrPK_) {
141 setGeneralTranslation(new MBSim::StateDependentFunction<fmatvec::Vec3>(fPrPK_));
142 }
143 void setTranslation(MBSim::Function<fmatvec::Vec3(fmatvec::VecV, double)> *fPrPK_) { setGeneralTranslation(fPrPK_); }
144 void setTranslation(MBSim::Function<fmatvec::Vec3(double)> *fPrPK_) { setTimeDependentTranslation(fPrPK_); }
145 void setTranslation(MBSim::Function<fmatvec::Vec3(fmatvec::VecV)> *fPrPK_) { setStateDependentTranslation(fPrPK_); }
146
147 // NOTE: we can not use a overloaded setRotation here due to restrictions in XML but define them for convinience in c++
152 void setGeneralRotation(MBSim::Function<fmatvec::RotMat3(fmatvec::VecV, double)>* fAPK_) {
153 fAPK = fAPK_;
154 fAPK->setParent(this);
155 fAPK->setName("GeneralRotation");
156 }
161 void setTimeDependentRotation(MBSim::Function<fmatvec::RotMat3(double)>* fAPK_) { setGeneralRotation(new MBSim::TimeDependentFunction<fmatvec::RotMat3>(fAPK_)); }
166 void setStateDependentRotation(MBSim::Function<fmatvec::RotMat3(fmatvec::VecV)>* fAPK_) { setGeneralRotation(new MBSim::StateDependentFunction<fmatvec::RotMat3>(fAPK_)); }
167 void setRotation(MBSim::Function<fmatvec::RotMat3(fmatvec::VecV, double)>* fAPK_) { setGeneralRotation(fAPK_); }
168 void setRotation(MBSim::Function<fmatvec::RotMat3(double)>* fAPK_) { setTimeDependentRotation(fAPK_); }
169 void setRotation(MBSim::Function<fmatvec::RotMat3(fmatvec::VecV)>* fAPK_) { setStateDependentRotation(fAPK_); }
170
171 void setTranslationDependentRotation(bool dep) { translationDependentRotation = dep; }
172 void setGeneralizedVelocityOfRotation(GeneralizedVelocityOfRotation generalizedVelocityOfRotation_) { generalizedVelocityOfRotation = generalizedVelocityOfRotation_; }
173
178 MBSim::Function<fmatvec::Vec3(fmatvec::VecV, double)>* getTranslation() { return fPrPK; }
183 MBSim::Function<fmatvec::RotMat3(fmatvec::VecV, double)>* getRotation() { return fAPK; }
184
185 MBSim::Frame* getFrameK() { return K; };
186
187 const fmatvec::Vec3& getNodalRelativePosition(int i) const { return KrKP[i]; }
188 const fmatvec::SqrMat3& getNodalRelativeOrientation(int i) const { return ARP[i]; }
189 const fmatvec::Mat3xV& getNodalShapeMatrixOfTranslation(int i) const { return Phi[i]; }
190 const fmatvec::Mat3xV& getNodalShapeMatrixOfRotation(int i) const { return Psi[i]; }
191
192 using NodeBasedBody::addFrame;
193 using NodeBasedBody::addContour;
194
195 void initializeUsingXML(xercesc::DOMElement *element) override;
196
197 void setqRel(const fmatvec::VecV &q);
198 void setuRel(const fmatvec::VecV &u);
199
200 bool transformCoordinates() const {return fTR!=nullptr;}
201
202 void resetUpToDate() override;
203 const fmatvec::VecV& evalqTRel() { if(updq) updateGeneralizedPositions(); return qTRel; }
204 const fmatvec::VecV& evalqRRel() { if(updq) updateGeneralizedPositions(); return qRRel; }
205 const fmatvec::VecV& evalqERel() { if(updq) updateGeneralizedPositions(); return qERel; }
206 const fmatvec::VecV& evaluTRel() { if(updu) updateGeneralizedVelocities(); return uTRel; }
207 const fmatvec::VecV& evaluRRel() { if(updu) updateGeneralizedVelocities(); return uRRel; }
208 const fmatvec::VecV& evaluERel() { if(updu) updateGeneralizedVelocities(); return uERel; }
209 const fmatvec::VecV& evalqdTRel() { if(updqd) updateDerivativeOfGeneralizedPositions(); return qdTRel; }
210 const fmatvec::VecV& evalqdRRel() { if(updqd) updateDerivativeOfGeneralizedPositions(); return qdRRel; }
211 const fmatvec::VecV& evalqdERel() { if(updqd) updateDerivativeOfGeneralizedPositions(); return qdERel; }
212 const fmatvec::VecV& evaludERel() { if(updud) updateGeneralizedAccelerations(); return udERel; }
213 const fmatvec::Vec3& evalGlobalRelativePosition() { if(updPos) updatePositions(); return WrPK; }
214 const fmatvec::Vec3& evalGlobalRelativeVelocity() { if(updVel) updateVelocities(); return WvPKrel; }
215 const fmatvec::Vec3& evalGlobalRelativeAngularVelocity() { if(updVel) updateVelocities(); return WomPK; }
216 const fmatvec::Mat3xV& evalPJTT() { if(updPJ) updateJacobians(); return PJTT; }
217 const fmatvec::Mat3xV& evalPJRR() { if(updPJ) updateJacobians(); return PJRR; }
218 const fmatvec::Vec3& evalPjhT() { if(updPJ) updateJacobians(); return PjhT; }
219 const fmatvec::Vec3& evalPjhR() { if(updPJ) updateJacobians(); return PjhR; }
220 const fmatvec::Vec3& evalPjbT() { if(updPjb) updateGyroscopicAccelerations(); return PjbT; }
221 const fmatvec::Vec3& evalPjbR() { if(updPjb) updateGyroscopicAccelerations(); return PjbR; }
222 const fmatvec::SymMatV& evalMb() { if(updMb) updateMb(); return M_; }
223 const fmatvec::VecV& evalhb() { if(updMb) updateMb(); return h_; }
224 const fmatvec::MatV& evalKJ(int j=0) { if(updKJ[j]) updateKJ(j); return KJ[j]; }
225 const fmatvec::VecV& evalKi() { if(updKJ[0]) updateKJ(0); return Ki; }
226 const fmatvec::Vec3& evalGlobalRelativePosition(int i) { if(updNodalPos[i]) updatePositions(i); return WrRP[i]; }
227 const fmatvec::Vec3& evalGlobalRelativeAngularVelocity(int i) { if(updNodalVel[i]) updateVelocities(i); return Womrel[i]; }
228
229 fmatvec::Vec3& getGlobalRelativeVelocity(bool check=true) { assert((not check) or (not updVel)); return WvPKrel; }
230 fmatvec::SqrMat3& getRelativeOrientation(bool check=true) { assert((not check) or (not updPos)); return APK; }
231 fmatvec::Vec3& getPjbT(bool check=true) { assert((not check) or (not updPjb)); return PjbT; }
232 fmatvec::Vec3& getPjbR(bool check=true) { assert((not check) or (not updPjb)); return PjbR; }
233
234 fmatvec::VecV& getqTRel(bool check=true) { assert((not check) or (not updq)); return qTRel; }
235 fmatvec::VecV& getqRRel(bool check=true) { assert((not check) or (not updq)); return qRRel; }
236 fmatvec::VecV& getqERel(bool check=true) { assert((not check) or (not updq)); return qERel; }
237 fmatvec::VecV& getuTRel(bool check=true) { assert((not check) or (not updu)); return uTRel; }
238 fmatvec::VecV& getuRRel(bool check=true) { assert((not check) or (not updu)); return uRRel; }
239 fmatvec::VecV& getuERel(bool check=true) { assert((not check) or (not updu)); return uERel; }
240 fmatvec::VecV& getqdTRel(bool check=true) { assert((not check) or (not updqd)); return qdTRel; }
241 fmatvec::VecV& getqdRRel(bool check=true) { assert((not check) or (not updqd)); return qdRRel; }
242 fmatvec::VecV& getqdERel(bool check=true) { assert((not check) or (not updqd)); return qdERel; }
243 fmatvec::VecV& getudERel(bool check=true) { assert((not check) or (not updud)); return udERel; }
244
245 fmatvec::Vec3& getNodalRelativeVelocity(int i, bool check=true) { assert((not check) or (not updNodalVel[i])); return Wvrel[i]; }
246
247 void updateStresses(int i) override;
248 void updatePositions(int i) override;
249 void updateVelocities(int i) override;
250 void updateAccelerations(int i) override;
251 void updateJacobians(int i, int j=0) override;
252 void updateGyroscopicAccelerations(int i) override;
253
254 template <class T>
255 static std::vector<T> getCellArray1D(xercesc::DOMElement *element) {
256 std::vector<T> array;
257 xercesc::DOMElement* e=element->getFirstElementChild();
258 if(MBXMLUtils::E(e)->getTagName()==MBSIMFLEX%"ele") {
259 while(e) {
260 array.push_back(MBXMLUtils::E(e)->getText<T>());
261 e=e->getNextElementSibling();
262 }
263 }
264 return array;
265 }
266
267 template <class T>
268 static std::vector<T> getCellArray1D(int m, const typename BaseType<T>::type &A) {
269 std::vector<T> array;
270 int M = A.rows()/m;
271 int n = A.cols();
272 for(int i=0; i<M; i++)
273 array.push_back(T(A(fmatvec::RangeV(i*m,i*m+m-1),fmatvec::RangeV(0,n-1))));
274 return array;
275 }
276
277 template <class T>
278 static std::vector<std::vector<T>> getCellArray2D(xercesc::DOMElement *element) {
279 std::vector<std::vector<T>> array;
280 xercesc::DOMElement *e=element->getFirstElementChild();
281 if(MBXMLUtils::E(e)->getTagName()==MBSIMFLEX%"row") {
282 while(e) {
283 array.push_back(std::vector<T>());
284 xercesc::DOMElement *ee=e->getFirstElementChild();
285 while(ee) {
286 array[array.size()-1].push_back(MBXMLUtils::E(ee)->getText<T>());
287 ee=ee->getNextElementSibling();
288 }
289 e=e->getNextElementSibling();
290 }
291 }
292 return array;
293 }
294
295 template <class T>
296 static std::vector<std::vector<T>> getCellArray2D(int m, int N, const typename BaseType<T>::type &A) {
297 int M = A.rows()/(m*N);
298 int n = A.cols();
299 std::vector<std::vector<T>> array(M);
300 for(int i=0, k=0; i<M; i++) {
301 for(int j=0; j<N; j++) {
302 array[i].push_back(T(A(fmatvec::RangeV(k*m,k*m+m-1),fmatvec::RangeV(0,n-1))));
303 k++;
304 }
305 }
306 return array;
307 }
308
309 protected:
310 double m{0};
311 fmatvec::Vec3 rdm;
312 fmatvec::SymMat3 rrdm, mmi0;
313 fmatvec::Mat3xV Pdm;
314 std::vector<std::vector<fmatvec::SqrMatV>> PPdm, Knl2;
315 std::vector<std::vector<fmatvec::SqrMatV>> Ke2;
316 std::vector<fmatvec::Mat3xV> rPdm;
317 std::vector<std::vector<fmatvec::SqrMat3>> mmi2, Gr1;
318 std::vector<fmatvec::SqrMatV> Knl1, K0t, K0r, K0om, Ct1, Cr1, Ge, Oe1, Ke1, De1;
319 fmatvec::VecV ksigma0;
320 fmatvec::SqrMatV ksigma1;
321 std::vector<fmatvec::SymMat3> mmi1;
322 fmatvec::MatVx3 Ct0, Cr0;
323 fmatvec::SymMatV Me, Ke0, De0;
324 std::vector<fmatvec::SqrMat3> Gr0;
325 fmatvec::Matrix<fmatvec::General,fmatvec::Var,fmatvec::Fixed<6>,double> Oe0;
326
327 std::vector<fmatvec::Vec3> KrKP, WrRP, Wvrel, Womrel;
328 std::vector<fmatvec::SqrMat3> ARP;
329 std::vector<fmatvec::Mat3xV> Phi, Psi;
330 std::vector<std::vector<fmatvec::SqrMatV>> K0F, K0M;
331 std::vector<fmatvec::Vector<fmatvec::Fixed<6>, double>> sigma0;
332 std::vector<fmatvec::Matrix<fmatvec::General, fmatvec::Fixed<6>, fmatvec::Var, double>> sigmahel;
333 std::vector<std::vector<fmatvec::Matrix<fmatvec::General, fmatvec::Fixed<6>, fmatvec::Var, double>> > sigmahen;
334
335 // Number of mode shapes
336 int ne{0};
337
338 MBSim::Frame *K;
339
340 fmatvec::Vec3 PjhT, PjhR, PjbT, PjbR;
341
345 fmatvec::SqrMat3 APK;
346
350 fmatvec::Vec3 PrPK, WrPK;
351
355 fmatvec::Vec3 WvPKrel, WomPK;
356
357 MBSim::Function<fmatvec::MatV(fmatvec::VecV)> *fTR{nullptr};
358
362 MBSim::Function<fmatvec::Vec3(fmatvec::VecV, double)> *fPrPK{nullptr};
363
367 MBSim::Function<fmatvec::RotMat3(fmatvec::VecV, double)> *fAPK{nullptr};
368
369 void (GenericFlexibleFfrBody::*updateJacobians_[2])(MBSim::Frame *frame);
370
371 fmatvec::Vec aT, aR;
372
373 fmatvec::VecV qTRel, qRRel, qERel, uTRel, uRRel, uERel, qdTRel, qdRRel, qdERel, udERel;
374 fmatvec::Mat3xV WJTrel, WJRrel, PJTT, PJRR;
375
376 MBSim::Frame *frameForJacobianOfRotation{nullptr};
377
378 fmatvec::Range<fmatvec::Var,fmatvec::Var> i02, iqT, iqR, iqE, iuT, iuR, iuE;
379
380 bool translationDependentRotation{false}, constJT{false}, constJR{false}, constjT{false}, constjR{false};
381
382 bool updPjb{true}, updGC{true}, updMb{true}, updKJ[2];
383
384 fmatvec::SymMatV M_;
385 fmatvec::VecV h_;
386 fmatvec::MatV KJ[2];
387 fmatvec::VecV Ki;
388
389 void assemble();
390 void prefillMassMatrix();
391
392 GeneralizedVelocityOfRotation generalizedVelocityOfRotation{derivativeOfGeneralizedPositionOfRotation};
393
394 OpenMBVFlexibleBody::ColorRepresentation ombvColorRepresentation{OpenMBVFlexibleBody::none};
395
396 std::vector<int> plotNodes, visuNodes;
397
398 private:
399 double (GenericFlexibleFfrBody::*evalOMBVColorRepresentation[12])(int i);
400 double evalNone(int i) { return 0; }
401 double evalXDisplacement(int i) { return evalNodalDisplacement(i)(0); }
402 double evalYDisplacement(int i) { return evalNodalDisplacement(i)(1); }
403 double evalZDisplacement(int i) { return evalNodalDisplacement(i)(2); }
404 double evalTotalDisplacement(int i) { return fmatvec::nrm2(evalNodalDisplacement(i)); }
405 double evalXXStress(int i) { return evalNodalStress(i)(0); }
406 double evalYYStress(int i) { return evalNodalStress(i)(1); }
407 double evalZZStress(int i) { return evalNodalStress(i)(2); }
408 double evalXYStress(int i) { return evalNodalStress(i)(3); }
409 double evalYZStress(int i) { return evalNodalStress(i)(4); }
410 double evalZXStress(int i) { return evalNodalStress(i)(5); }
411 double evalEquivalentStress(int i);
412 };
413
414 }
415
416 #endif
MBSimFlexibleBody::GenericFlexibleFfrBody::getTranslation
MBSim::Function< fmatvec::Vec3(fmatvec::VecV, double)> * getTranslation()
get Kinematic for translational motion
Definition: generic_flexible_ffr_body.h:178
MBSimFlexibleBody::GenericFlexibleFfrBody::setStateDependentTranslation
void setStateDependentTranslation(MBSim::Function< fmatvec::Vec3(fmatvec::VecV)> *fPrPK_)
set Kinematic for only state dependent translational motion
Definition: generic_flexible_ffr_body.h:140
MBSimFlexibleBody::GenericFlexibleFfrBody::setStateDependentRotation
void setStateDependentRotation(MBSim::Function< fmatvec::RotMat3(fmatvec::VecV)> *fAPK_)
set Kinematic for only state dependent rotational motion
Definition: generic_flexible_ffr_body.h:166
MBSimFlexibleBody::BaseType
Definition: generic_flexible_ffr_body.h:36
MBSim::Object::T
fmatvec::Mat T
MBSimFlexibleBody::GenericFlexibleFfrBody::PrPK
fmatvec::Vec3 PrPK
translation from parent to kinematic Frame in parent and world system
Definition: generic_flexible_ffr_body.h:350
MBSimFlexibleBody::GenericFlexibleFfrBody::WvPKrel
fmatvec::Vec3 WvPKrel
translational and angular velocity from parent to kinematic Frame in world system
Definition: generic_flexible_ffr_body.h:355
MBSim::Object::q
fmatvec::Vec q
MBSimFlexibleBody::GenericFlexibleFfrBody::~GenericFlexibleFfrBody
~GenericFlexibleFfrBody() override
destructor
Definition: generic_flexible_ffr_body.cc:86
MBSim::TimeDependentFunction
MBSimFlexibleBody::GenericFlexibleFfrBody::setGeneralRotation
void setGeneralRotation(MBSim::Function< fmatvec::RotMat3(fmatvec::VecV, double)> *fAPK_)
set Kinematic for general rotational motion
Definition: generic_flexible_ffr_body.h:152
MBSimFlexibleBody::GenericFlexibleFfrBody::setGeneralTranslation
void setGeneralTranslation(MBSim::Function< fmatvec::Vec3(fmatvec::VecV, double)> *fPrPK_)
set Kinematic for genral translational motion
Definition: generic_flexible_ffr_body.h:124
MBSim::Element::InitStage
InitStage
MBSimFlexibleBody::NodeBasedBody::addFrame
void addFrame(NodeBasedFrame *frame)
Definition: node_based_body.cc:70
MBSimFlexibleBody::GenericFlexibleFfrBody::APK
fmatvec::SqrMat3 APK
rotation matrix from kinematic Frame to parent Frame
Definition: generic_flexible_ffr_body.h:345
MBSim::Function
MBSim::Element::name
std::string name
MBSim::Body::frame
std::vector< Frame * > frame
MBSimFlexibleBody::GenericFlexibleFfrBody
Generic flexible body using a floating frame of reference formulation.
Definition: generic_flexible_ffr_body.h:62
MBSim::Frame
MBSimFlexibleBody::GenericFlexibleFfrBody::fPrPK
MBSim::Function< fmatvec::Vec3(fmatvec::VecV, double)> * fPrPK
translation from parent Frame to kinematic Frame in parent system
Definition: generic_flexible_ffr_body.h:362
MBSimFlexibleBody::GenericFlexibleFfrBody::setTimeDependentTranslation
void setTimeDependentTranslation(MBSim::Function< fmatvec::Vec3(double)> *fPrPK_)
set Kinematic for only time dependent translational motion
Definition: generic_flexible_ffr_body.h:133
MBSim::StateDependentFunction
MBSim::Body::addContour
virtual void addContour(Contour *contour)
MBSimFlexibleBody::GenericFlexibleFfrBody::fAPK
MBSim::Function< fmatvec::RotMat3(fmatvec::VecV, double)> * fAPK
rotation from kinematic Frame to parent Frame
Definition: generic_flexible_ffr_body.h:367
MBSim::Element::setName
void setName(const std::string &str)
MBSimFlexibleBody::NodeBasedBody
Definition: node_based_body.h:30
MBSimFlexibleBody::GenericFlexibleFfrBody::setTimeDependentRotation
void setTimeDependentRotation(MBSim::Function< fmatvec::RotMat3(double)> *fAPK_)
set Kinematic for only time dependent rotational motion
Definition: generic_flexible_ffr_body.h:161
MBSimFlexibleBody::GenericFlexibleFfrBody::getRotation
MBSim::Function< fmatvec::RotMat3(fmatvec::VecV, double)> * getRotation()
get Kinematic for rotational motion
Definition: generic_flexible_ffr_body.h:183
MBSim::Object::M
fmatvec::SymMat M