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  typedef fmatvec::VecV type;
41  };
42 
43  template<>
44  struct BaseType<fmatvec::SqrMat3> {
45  typedef fmatvec::MatVx3 type;
46  };
47 
48  template<>
49  struct BaseType<fmatvec::SqrMatV> {
50  typedef fmatvec::MatV type;
51  };
52 
53  template<int N>
54  struct BaseType<fmatvec::Matrix<fmatvec::General, fmatvec::Fixed<N>, fmatvec::Var, double>> {
55  typedef fmatvec::MatV type;
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 updatehb();
100  void updateKJ(int j=0) { (this->*updateKJ_[j])(); }
101  void updateKJ0();
102  void updateKJ1();
103  void (GenericFlexibleFfrBody::*updateKJ_[2])();
104  void calcSize() override;
105  void calcqSize() override;
106  void calcuSize(int j=0) override;
107 
108  /* INHERITED INTERFACE OF OBJECT */
109  void init(InitStage stage, const MBSim::InitConfigSet &config) override;
110  void setUpInverseKinetics() override;
111  /*****************************************************/
112 
113  /* INHERITED INTERFACE OF ELEMENT */
114  void plot() override;
115  /*****************************************************/
116 
117  /* GETTER / SETTER */
118  int getNumberOfModeShapes() { if(updSize) calcSize(); return ne; }
119 
120  void setProportionalDamping(const fmatvec::Vec2 &beta_) { beta = beta_; }
121 
122  void setModalReduction(bool modalReduction_) { modalReduction = modalReduction_; }
123  void setModeRange(const fmatvec::Vec2 &mRange_) { mRange = mRange_; }
124  void setModalDamping(const fmatvec::VecV &mDamping_) { mDamping <<= mDamping_; }
125 
126  // NOTE: we can not use a overloaded setTranslation here due to restrictions in XML but define them for convinience in c++
131  void setGeneralTranslation(MBSim::Function<fmatvec::Vec3(fmatvec::VecV, double)> *fPrPK_) {
132  fPrPK = fPrPK_;
133  fPrPK->setParent(this);
134  fPrPK->setName("GeneralTranslation");
135  }
140  void setTimeDependentTranslation(MBSim::Function<fmatvec::Vec3(double)> *fPrPK_) {
142  }
147  void setStateDependentTranslation(MBSim::Function<fmatvec::Vec3(fmatvec::VecV)> *fPrPK_) {
149  }
150  void setTranslation(MBSim::Function<fmatvec::Vec3(fmatvec::VecV, double)> *fPrPK_) { setGeneralTranslation(fPrPK_); }
151  void setTranslation(MBSim::Function<fmatvec::Vec3(double)> *fPrPK_) { setTimeDependentTranslation(fPrPK_); }
152  void setTranslation(MBSim::Function<fmatvec::Vec3(fmatvec::VecV)> *fPrPK_) { setStateDependentTranslation(fPrPK_); }
153 
154  // NOTE: we can not use a overloaded setRotation here due to restrictions in XML but define them for convinience in c++
159  void setGeneralRotation(MBSim::Function<fmatvec::RotMat3(fmatvec::VecV, double)>* fAPK_) {
160  fAPK = fAPK_;
161  fAPK->setParent(this);
162  fAPK->setName("GeneralRotation");
163  }
174  void setRotation(MBSim::Function<fmatvec::RotMat3(fmatvec::VecV, double)>* fAPK_) { setGeneralRotation(fAPK_); }
175  void setRotation(MBSim::Function<fmatvec::RotMat3(double)>* fAPK_) { setTimeDependentRotation(fAPK_); }
176  void setRotation(MBSim::Function<fmatvec::RotMat3(fmatvec::VecV)>* fAPK_) { setStateDependentRotation(fAPK_); }
177 
178  void setTranslationDependentRotation(bool dep) { translationDependentRotation = dep; }
179  void setGeneralizedVelocityOfRotation(GeneralizedVelocityOfRotation generalizedVelocityOfRotation_) { generalizedVelocityOfRotation = generalizedVelocityOfRotation_; }
180 
185  MBSim::Function<fmatvec::Vec3(fmatvec::VecV, double)>* getTranslation() { return fPrPK; }
190  MBSim::Function<fmatvec::RotMat3(fmatvec::VecV, double)>* getRotation() { return fAPK; }
191 
192  MBSim::Frame* getFrameK() { return K; };
193 
194  const fmatvec::Vec3& getNodalRelativePosition(int i) const { return KrKP[i]; }
195  const fmatvec::SqrMat3& getNodalRelativeOrientation(int i) const { return ARP[i]; }
196  const fmatvec::Mat3xV& getNodalShapeMatrixOfTranslation(int i) const { return Phi[i]; }
197  const fmatvec::Mat3xV& getNodalShapeMatrixOfRotation(int i) const { return Psi[i]; }
198 
201 
202  void initializeUsingXML(xercesc::DOMElement *element) override;
203 
204  void setqRel(const fmatvec::VecV &q);
205  void setuRel(const fmatvec::VecV &u);
206 
207  bool transformCoordinates() const {return fTR!=nullptr;}
208 
209  void resetUpToDate() override;
210  const fmatvec::VecV& evalqTRel() { if(updq) updateGeneralizedPositions(); return qTRel; }
211  const fmatvec::VecV& evalqRRel() { if(updq) updateGeneralizedPositions(); return qRRel; }
212  const fmatvec::VecV& evalqERel() { if(updq) updateGeneralizedPositions(); return qERel; }
213  const fmatvec::VecV& evaluTRel() { if(updu) updateGeneralizedVelocities(); return uTRel; }
214  const fmatvec::VecV& evaluRRel() { if(updu) updateGeneralizedVelocities(); return uRRel; }
215  const fmatvec::VecV& evaluERel() { if(updu) updateGeneralizedVelocities(); return uERel; }
216  const fmatvec::VecV& evalqdTRel() { if(updqd) updateDerivativeOfGeneralizedPositions(); return qdTRel; }
217  const fmatvec::VecV& evalqdRRel() { if(updqd) updateDerivativeOfGeneralizedPositions(); return qdRRel; }
218  const fmatvec::VecV& evalqdERel() { if(updqd) updateDerivativeOfGeneralizedPositions(); return qdERel; }
219  const fmatvec::VecV& evaludERel() { if(updud) updateGeneralizedAccelerations(); return udERel; }
220  const fmatvec::Vec3& evalGlobalRelativePosition() { if(updPos) updatePositions(); return WrPK; }
221  const fmatvec::Vec3& evalGlobalRelativeVelocity() { if(updVel) updateVelocities(); return WvPKrel; }
222  const fmatvec::Vec3& evalGlobalRelativeAngularVelocity() { if(updVel) updateVelocities(); return WomPK; }
223  const fmatvec::Mat3xV& evalPJTT() { if(updPJ) updateJacobians(); return PJTT; }
224  const fmatvec::Mat3xV& evalPJRR() { if(updPJ) updateJacobians(); return PJRR; }
225  const fmatvec::Vec3& evalPjhT() { if(updPJ) updateJacobians(); return PjhT; }
226  const fmatvec::Vec3& evalPjhR() { if(updPJ) updateJacobians(); return PjhR; }
227  const fmatvec::Vec3& evalPjbT() { if(updPjb) updateGyroscopicAccelerations(); return PjbT; }
228  const fmatvec::Vec3& evalPjbR() { if(updPjb) updateGyroscopicAccelerations(); return PjbR; }
229  const fmatvec::SymMatV& evalMb() { if(updMb) updateMb(); return M_; }
230  const fmatvec::VecV& evalhb() { if(updMb) updateMb(); return h_; }
231  const fmatvec::MatV& evalKJ(int j=0) { if(updKJ[j]) updateKJ(j); return KJ[j]; }
232  const fmatvec::VecV& evalKi() { if(updKJ[0]) updateKJ(0); return Ki; }
233  const fmatvec::Vec3& evalGlobalRelativePosition(int i) { if(updNodalPos[i]) updatePositions(i); return WrRP[i]; }
234  const fmatvec::Vec3& evalGlobalRelativeAngularVelocity(int i) { if(updNodalVel[i]) updateVelocities(i); return Womrel[i]; }
235 
236  fmatvec::Vec3& getGlobalRelativeVelocity(bool check=true) { assert((not check) or (not updVel)); return WvPKrel; }
237  fmatvec::SqrMat3& getRelativeOrientation(bool check=true) { assert((not check) or (not updPos)); return APK; }
238  fmatvec::Vec3& getPjbT(bool check=true) { assert((not check) or (not updPjb)); return PjbT; }
239  fmatvec::Vec3& getPjbR(bool check=true) { assert((not check) or (not updPjb)); return PjbR; }
240 
241  fmatvec::VecV& getqTRel(bool check=true) { assert((not check) or (not updq)); return qTRel; }
242  fmatvec::VecV& getqRRel(bool check=true) { assert((not check) or (not updq)); return qRRel; }
243  fmatvec::VecV& getqERel(bool check=true) { assert((not check) or (not updq)); return qERel; }
244  fmatvec::VecV& getuTRel(bool check=true) { assert((not check) or (not updu)); return uTRel; }
245  fmatvec::VecV& getuRRel(bool check=true) { assert((not check) or (not updu)); return uRRel; }
246  fmatvec::VecV& getuERel(bool check=true) { assert((not check) or (not updu)); return uERel; }
247  fmatvec::VecV& getqdTRel(bool check=true) { assert((not check) or (not updqd)); return qdTRel; }
248  fmatvec::VecV& getqdRRel(bool check=true) { assert((not check) or (not updqd)); return qdRRel; }
249  fmatvec::VecV& getqdERel(bool check=true) { assert((not check) or (not updqd)); return qdERel; }
250  fmatvec::VecV& getudERel(bool check=true) { assert((not check) or (not updud)); return udERel; }
251 
252  fmatvec::Vec3& getNodalRelativeVelocity(int i, bool check=true) { assert((not check) or (not updNodalVel[i])); return Wvrel[i]; }
253 
254  void updateStresses(int i) override;
255  void updatePositions(int i) override;
256  void updateVelocities(int i) override;
257  void updateAccelerations(int i) override;
258  void updateJacobians(int i, int j=0) override;
259  void updateGyroscopicAccelerations(int i) override;
260 
261  template <class T>
262  static std::vector<T> getCellArray1D(xercesc::DOMElement *element) {
263  std::vector<T> array;
264  xercesc::DOMElement* e=element->getFirstElementChild();
265  if(MBXMLUtils::E(e)->getTagName()==MBSIMFLEX%"ele") {
266  while(e) {
267  array.push_back(MBXMLUtils::E(e)->getText<T>());
268  e=e->getNextElementSibling();
269  }
270  }
271  return array;
272  }
273 
274  template <class T>
275  static std::vector<T> getCellArray1D(int m, const typename BaseType<T>::type &A) {
276  std::vector<T> array;
277  int M = A.rows()/m;
278  int n = A.cols();
279  for(int i=0; i<M; i++)
280  array.push_back(T(A(fmatvec::RangeV(i*m,i*m+m-1),fmatvec::RangeV(0,n-1))));
281  return array;
282  }
283 
284  template <class T>
285  static std::vector<std::vector<T>> getCellArray2D(xercesc::DOMElement *element) {
286  std::vector<std::vector<T>> array;
287  xercesc::DOMElement *e=element->getFirstElementChild();
288  if(MBXMLUtils::E(e)->getTagName()==MBSIMFLEX%"row") {
289  while(e) {
290  array.push_back(std::vector<T>());
291  xercesc::DOMElement *ee=e->getFirstElementChild();
292  while(ee) {
293  array[array.size()-1].push_back(MBXMLUtils::E(ee)->getText<T>());
294  ee=ee->getNextElementSibling();
295  }
296  e=e->getNextElementSibling();
297  }
298  }
299  return array;
300  }
301 
302  template <class T>
303  static std::vector<std::vector<T>> getCellArray2D(int m, int N, const typename BaseType<T>::type &A) {
304  int M = A.rows()/(m*N);
305  int n = A.cols();
306  std::vector<std::vector<T>> array(M);
307  for(int i=0, k=0; i<M; i++) {
308  for(int j=0; j<N; j++) {
309  array[i].push_back(T(A(fmatvec::RangeV(k*m,k*m+m-1),fmatvec::RangeV(0,n-1))));
310  k++;
311  }
312  }
313  return array;
314  }
315 
316  protected:
317  double m{0};
318  fmatvec::Vec3 rdm;
319  fmatvec::SymMat3 rrdm, mmi0;
320  fmatvec::Mat3xV Pdm;
321  std::vector<std::vector<fmatvec::SqrMatV>> PPdm, Knl2;
322  std::vector<std::vector<fmatvec::SqrMatV>> Ke2;
323  std::vector<fmatvec::Mat3xV> rPdm;
324  std::vector<std::vector<fmatvec::SqrMat3>> mmi2, Gr1;
325  std::vector<fmatvec::SqrMatV> Knl1, K0t, K0r, K0om, Ct1, Cr1, Ge, Oe1, Ke1, De1;
326  fmatvec::Vec2 beta;
327  fmatvec::VecV ksigma0;
328  fmatvec::SqrMatV ksigma1;
329  std::vector<fmatvec::SymMat3> mmi1;
330  fmatvec::MatVx3 Ct0, Cr0;
331  fmatvec::SymMatV Me, Ke0, De0;
332  std::vector<fmatvec::SqrMat3> Gr0;
334 
335  fmatvec::SqrMat3 Id;
336  std::vector<fmatvec::Vec3> KrKP, WrRP, Wvrel, Womrel;
337  std::vector<fmatvec::SqrMat3> ARP;
338  std::vector<fmatvec::Mat3xV> Phi, Psi;
339  std::vector<std::vector<fmatvec::SqrMatV>> K0F, K0M;
340  std::vector<fmatvec::Vector<fmatvec::Fixed<6>, double>> sigma0;
341  std::vector<fmatvec::Matrix<fmatvec::General, fmatvec::Fixed<6>, fmatvec::Var, double>> sigmahel;
342  std::vector<std::vector<fmatvec::Matrix<fmatvec::General, fmatvec::Fixed<6>, fmatvec::Var, double>> > sigmahen;
343 
344  // Number of mode shapes
345  int ne{0};
346 
347  MBSim::Frame *K;
348 
353 
354  fmatvec::Vec3 PjhT, PjhR, PjbT, PjbR;
355 
359  fmatvec::SqrMat3 APK;
360 
364  fmatvec::Vec3 PrPK, WrPK;
365 
369  fmatvec::Vec3 WvPKrel, WomPK;
370 
371  MBSim::Function<fmatvec::MatV(fmatvec::VecV)> *fTR{0};
372 
376  MBSim::Function<fmatvec::Vec3(fmatvec::VecV, double)> *fPrPK{0};
377 
381  MBSim::Function<fmatvec::RotMat3(fmatvec::VecV, double)> *fAPK{0};
382 
383  void (GenericFlexibleFfrBody::*updateJacobians_[2])(MBSim::Frame *frame);
384 
385  fmatvec::Vec aT, aR;
386 
387  fmatvec::VecV qTRel, qRRel, qERel, uTRel, uRRel, uERel, qdTRel, qdRRel, qdERel, udERel;
388  fmatvec::Mat3xV WJTrel, WJRrel, PJTT, PJRR;
389 
390  MBSim::Frame *frameForJacobianOfRotation{0};
391 
392  fmatvec::Range<fmatvec::Var,fmatvec::Var> iqT, iqR, iqE, iuT, iuR, iuE;
393 
394  bool translationDependentRotation{false}, constJT{false}, constJR{false}, constjT{false}, constjR{false};
395 
396  bool updPjb{true}, updGC{true}, updMb{true}, updKJ[2];
397 
398  fmatvec::SymMatV M_;
399  fmatvec::VecV h_;
400  fmatvec::MatV KJ[2];
401  fmatvec::VecV Ki;
402 
403  void determineSID();
404  void prefillMassMatrix();
405 
406  GeneralizedVelocityOfRotation generalizedVelocityOfRotation{derivativeOfGeneralizedPositionOfRotation};
407 
408  OpenMBVFlexibleBody::ColorRepresentation ombvColorRepresentation{OpenMBVFlexibleBody::none};
409 
410  fmatvec::VecVI plotNodes;
411 
412  bool modalReduction{false};
413  fmatvec::Vec2 mRange;
414  fmatvec::VecV mDamping;
415 
416  private:
417  double (GenericFlexibleFfrBody::*evalOMBVColorRepresentation[12])(int i);
418  double evalNone(int i) { return 0; }
419  double evalXDisplacement(int i) { return evalNodalDisplacement(i)(0); }
420  double evalYDisplacement(int i) { return evalNodalDisplacement(i)(1); }
421  double evalZDisplacement(int i) { return evalNodalDisplacement(i)(2); }
422  double evalTotalDisplacement(int i) { return fmatvec::nrm2(evalNodalDisplacement(i)); }
423  double evalXXStress(int i) { return evalNodalStress(i)(0); }
424  double evalYYStress(int i) { return evalNodalStress(i)(1); }
425  double evalZZStress(int i) { return evalNodalStress(i)(2); }
426  double evalXYStress(int i) { return evalNodalStress(i)(3); }
427  double evalYZStress(int i) { return evalNodalStress(i)(4); }
428  double evalZXStress(int i) { return evalNodalStress(i)(5); }
429  double evalEquivalentStress(int i);
430  };
431 
432 }
433 
434 #endif
MBSim::Function< fmatvec::Vec3(fmatvec::VecV, double)> * getTranslation()
get Kinematic for translational motion
Definition: generic_flexible_ffr_body.h:185
void setStateDependentTranslation(MBSim::Function< fmatvec::Vec3(fmatvec::VecV)> *fPrPK_)
set Kinematic for only state dependent translational motion
Definition: generic_flexible_ffr_body.h:147
void setStateDependentRotation(MBSim::Function< fmatvec::RotMat3(fmatvec::VecV)> *fAPK_)
set Kinematic for only state dependent rotational motion
Definition: generic_flexible_ffr_body.h:173
Definition: generic_flexible_ffr_body.h:36
fmatvec::SymMat Mbuf
TODO.
Definition: generic_flexible_ffr_body.h:352
fmatvec::Mat T
fmatvec::Vec3 PrPK
translation from parent to kinematic Frame in parent and world system
Definition: generic_flexible_ffr_body.h:364
fmatvec::Vec3 WvPKrel
translational and angular velocity from parent to kinematic Frame in world system
Definition: generic_flexible_ffr_body.h:369
fmatvec::Vec q
~GenericFlexibleFfrBody() override
destructor
Definition: generic_flexible_ffr_body.cc:88
void setGeneralRotation(MBSim::Function< fmatvec::RotMat3(fmatvec::VecV, double)> *fAPK_)
set Kinematic for general rotational motion
Definition: generic_flexible_ffr_body.h:159
void setGeneralTranslation(MBSim::Function< fmatvec::Vec3(fmatvec::VecV, double)> *fPrPK_)
set Kinematic for genral translational motion
Definition: generic_flexible_ffr_body.h:131
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:359
std::string name
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:376
void setTimeDependentTranslation(MBSim::Function< fmatvec::Vec3(double)> *fPrPK_)
set Kinematic for only time dependent translational motion
Definition: generic_flexible_ffr_body.h:140
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:381
void setName(const std::string &str)
Definition: node_based_body.h:30
double nrm2(const Vector< Ref, double > &x)
void setTimeDependentRotation(MBSim::Function< fmatvec::RotMat3(double)> *fAPK_)
set Kinematic for only time dependent rotational motion
Definition: generic_flexible_ffr_body.h:168
int rows() const
MBSim::Function< fmatvec::RotMat3(fmatvec::VecV, double)> * getRotation()
get Kinematic for rotational motion
Definition: generic_flexible_ffr_body.h:190
fmatvec::SymMat M