mbsimflexiblebody  4.0.0
MBSim Flexible Body Module
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Pages
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 
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_) {
135  }
140  void setStateDependentTranslation(MBSim::Function<fmatvec::Vec3(fmatvec::VecV)> *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  }
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 
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 
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 
358 
363 
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
MBSim::Function< fmatvec::Vec3(fmatvec::VecV, double)> * getTranslation()
get Kinematic for translational motion
Definition: generic_flexible_ffr_body.h:178
void setStateDependentTranslation(MBSim::Function< fmatvec::Vec3(fmatvec::VecV)> *fPrPK_)
set Kinematic for only state dependent translational motion
Definition: generic_flexible_ffr_body.h:140
void setStateDependentRotation(MBSim::Function< fmatvec::RotMat3(fmatvec::VecV)> *fAPK_)
set Kinematic for only state dependent rotational motion
Definition: generic_flexible_ffr_body.h:166
Definition: generic_flexible_ffr_body.h:36
fmatvec::Mat T
fmatvec::Vec3 PrPK
translation from parent to kinematic Frame in parent and world system
Definition: generic_flexible_ffr_body.h:350
fmatvec::Vec3 WvPKrel
translational and angular velocity from parent to kinematic Frame in world system ...
Definition: generic_flexible_ffr_body.h:355
fmatvec::Vec q
~GenericFlexibleFfrBody() override
destructor
Definition: generic_flexible_ffr_body.cc:86
void setGeneralRotation(MBSim::Function< fmatvec::RotMat3(fmatvec::VecV, double)> *fAPK_)
set Kinematic for general rotational motion
Definition: generic_flexible_ffr_body.h:152
void setGeneralTranslation(MBSim::Function< fmatvec::Vec3(fmatvec::VecV, double)> *fPrPK_)
set Kinematic for genral translational motion
Definition: generic_flexible_ffr_body.h:124
void addFrame(NodeBasedFrame *frame)
Definition: node_based_body.cc:70
fmatvec::SqrMat3 APK
rotation matrix from kinematic Frame to parent Frame
Definition: generic_flexible_ffr_body.h:345
std::vector< Frame * > frame
Generic flexible body using a floating frame of reference formulation.
Definition: generic_flexible_ffr_body.h:62
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
void setTimeDependentTranslation(MBSim::Function< fmatvec::Vec3(double)> *fPrPK_)
set Kinematic for only time dependent translational motion
Definition: generic_flexible_ffr_body.h:133
virtual void addContour(Contour *contour)
MBSim::Function< fmatvec::RotMat3(fmatvec::VecV, double)> * fAPK
rotation from kinematic Frame to parent Frame
Definition: generic_flexible_ffr_body.h:367
Definition: node_based_body.h:30
void setTimeDependentRotation(MBSim::Function< fmatvec::RotMat3(double)> *fAPK_)
set Kinematic for only time dependent rotational motion
Definition: generic_flexible_ffr_body.h:161
MBSim::Function< fmatvec::RotMat3(fmatvec::VecV, double)> * getRotation()
get Kinematic for rotational motion
Definition: generic_flexible_ffr_body.h:183
fmatvec::SymMat M