All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Pages
flexible_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: thorsten.schindler@mytum.de
18  * martin.o.foerg@googlemail.com
19  */
20 
21 #ifndef _FLEXIBLE_BODY_H_
22 #define _FLEXIBLE_BODY_H_
23 
24 #include "mbsim/objects/body.h"
25 #include "namespace.h"
26 
27 namespace MBSim {
28  class FixedRelativeFrame;
29  class ContourFrame;
30 }
31 
32 namespace MBSimFlexibleBody {
33 
34  class DiscretizationInterface;
35  class NodeFrame;
36 
52  class FlexibleBody : public MBSim::Body {
53  public:
58  FlexibleBody(const std::string &name);
59 
63  virtual ~FlexibleBody();
64 
65  /* INHERITED INTERFACE OF OBJECTINTERFACE */
66  virtual void updatedq() { dq = u*getStepSize(); }
67  virtual void updateqd() { qd = u; }
68  virtual void updateh(int k=0);
69  virtual void updateM();
70  virtual void updatedhdz();
71  virtual void updatePositions(NodeFrame* frame);
72  virtual void updateVelocities(NodeFrame* frame);
73  virtual void updateAccelerations(NodeFrame* frame);
74  virtual void updateJacobians(NodeFrame* frame, int j=0);
75  virtual void updateGyroscopicAccelerations(NodeFrame* frame);
76 
77  /* INHERITED INTERFACE OF ELEMENT */
78  virtual void plot();
79  virtual std::string getType() const { return "FlexibleBody"; }
80  virtual void initializeUsingXML(xercesc::DOMElement *element);
81  /***************************************************/
82 
83  /* INHERITED INTERFACE OF OBJECT */
84  virtual void init(InitStage stage);
85  virtual double computeKineticEnergy();
86  virtual double computePotentialEnergy();
87  virtual void setFrameOfReference(MBSim::Frame *frame);
88  virtual void setq0(fmatvec::Vec q0_) { if(q0_.size()) MBSim::Body::setGeneralizedInitialPosition(q0_); q<<q0; }
89  virtual void setu0(fmatvec::Vec u0_) { if(u0_.size()) MBSim::Body::setGeneralizedInitialVelocity(u0_); u<<u0; }
90  /***************************************************/
91 
92  /* INTERFACE TO BE DEFINED IN DERIVED CLASSES */
96  virtual void BuildElements() = 0;
97 
98  const fmatvec::Vec& getqElement(int i) { if(updEle) BuildElements(); return qElement[i]; }
99 
100  const fmatvec::Vec& getuElement(int i) { if(updEle) BuildElements(); return uElement[i]; }
101 
102  virtual fmatvec::Vec3 getAngles(int i) { return fmatvec::Vec3(); }
103  virtual fmatvec::Vec3 getDerivativeOfAngles(int i) { return fmatvec::Vec3(); }
104 
111  virtual void GlobalVectorContribution(int CurrentElement, const fmatvec::Vec &locVec, fmatvec::Vec &gloVec) = 0;
112 
119  virtual void GlobalMatrixContribution(int CurrentElement, const fmatvec::Mat &locMat, fmatvec::Mat &gloMat) = 0;
120 
127  virtual void GlobalMatrixContribution(int CurrentElement, const fmatvec::SymMat &locMat, fmatvec::SymMat &gloMat) = 0;
128 
129 // /**
130 // * \brief cartesian kinematic for contour or external frame (normal, tangent, binormal) is set by implementation class
131 // * \param data contour parameter
132 // * \param ff selection of specific calculations for frames
133 // * \param frame optional: external frame, otherwise contour parameters are changed
134 // */
135 // virtual void updateKinematicsForFrame(MBSim::ContourPointData &data, MBSim::Frame::Frame::Feature ff, MBSim::Frame *frame=0) = 0;
136 //
137 // /*!
138 // * \brief cartesian kinematic on a node
139 // */
140 // virtual void updateKinematicsAtNode(NodeFrame *frame, MBSim::Frame::Feature ff) {
141 // THROW_MBSIMERROR("updateKinematicsAtNode(): Not implemented for " + getType()); //TODO: make that interface prettier
142 // }
143 //
144 // /**
145 // * \brief Jacobians and gyroscopes for contour or external frame are set by implementation class
146 // * \param data contour parameter
147 // * \param frame: optional external frame, otherwise contour parameters are changed
148 // */
149 // virtual void updateJacobiansForFrame(MBSim::ContourPointData &data, MBSim::Frame *frame=0) = 0;
150 // /***************************************************/
151 
152  /* GETTER / SETTER */
158  void setMassProportionalDamping(const double d_) { d_massproportional = d_; }
159  /***************************************************/
160 
164  void addFrame(NodeFrame *frame);
165 
166  void addFrame(MBSim::ContourFrame *frame);
167 
171  void addFrame(MBSim::FixedRelativeFrame *frame);
172 
173  void addContour(MBSim::Contour *contour);
174 
184  virtual void exportPositionVelocity(const std::string & filenamePos, const std::string & filenameVel = std::string(), const int & deg = 3, const bool &writePsFile = false){throw MBSim::MBSimError("exportPositionVelocity(const std::string& filenamePos, const std::string& filenameVel, const int& deg, const bool& writePsFile) is not implemented for " + this->getType()) ;}
185 
191  virtual void importPositionVelocity(const std::string& filenamePos, const std::string& filenameVel = std::string()){throw MBSim::MBSimError("importPositionVelocity(const std::string& filenamePos, const std::string& filenameVel) is not implemented for " + this->getType()) ;}
192 
193  void resetUpToDate();
194 
195  protected:
199  std::vector<DiscretizationInterface*> discretization;
200 
204  std::vector<fmatvec::Vec> qElement;
205 
209  std::vector<fmatvec::Vec> uElement;
210 
215 
219 // std::vector<MBSim::ContourPointData> S_Frame;
220 
221  // Workaround to free memory of contourFrame in dtor.
222  // TODO: provide a consistent solution and remove the following line
223 // MBSim::Frame *contourFrame;
224 
230  bool updEle;
231  };
232 
239  template <class AT>
241  public:
246  FlexibleBodyContinuum<AT>(const std::string &name) : FlexibleBody(name) {}
247 
248  /* INHERITED INTERFACE OF ELEMENT */
249  virtual std::string getType() const { return "FlexibleBodyContinuum"; }
250 
251  /* GETTER / SETTER */
252  void setContourNodes(const std::vector<AT> nodes) { userContourNodes = nodes; }
253 
254  void setNodeOffset(const AT nodeOffset_){ nodeOffset = nodeOffset_;} // TODO:: call this function in the init() of flexible body.
255  AT getNodeOffset() const { return nodeOffset;}
256 
257  protected:
261  std::vector<AT> userContourNodes;
262 
267  };
268 }
269 
270 #endif /* _FLEXIBLE_BODY_H_ */
virtual void BuildElements()=0
references finite element coordinates to assembled coordinates
upmost class for flexible body implementation
Definition: flexible_body.h:52
std::vector< DiscretizationInterface * > discretization
stl-vector of discretizations/finite elements
Definition: flexible_body.h:199
double d_massproportional
damping factor for mass proportion, see BodyFlexible::setMassProportionalDamping() ...
Definition: flexible_body.h:214
void addFrame(NodeFrame *frame)
Definition: flexible_body.cc:148
FlexibleBody(const std::string &name)
constructor
Definition: flexible_body.cc:44
AT nodeOffset
offset of the ROTNODE from the TRANSNODE
Definition: flexible_body.h:266
virtual void GlobalMatrixContribution(int CurrentElement, const fmatvec::Mat &locMat, fmatvec::Mat &gloMat)=0
insert &#39;local&#39; information in global matrices
fmatvec::Vec q
virtual void importPositionVelocity(const std::string &filenamePos, const std::string &filenameVel=std::string())
imports the interpolated position and optional the velocity files (created with exportPositionVelocit...
Definition: flexible_body.h:191
virtual ~FlexibleBody()
destructor
Definition: flexible_body.cc:46
flexible body entirely described within MBSim holding all informations about continuum approximations...
Definition: flexible_body.h:240
void setMassProportionalDamping(const double d_)
cartesian kinematic for contour or external frame (normal, tangent, binormal) is set by implementatio...
Definition: flexible_body.h:158
std::vector< fmatvec::Vec > uElement
stl-vector of finite element wise velocities
Definition: flexible_body.h:209
std::vector< fmatvec::Vec > qElement
stl-vector of finite element wise positions
Definition: flexible_body.h:204
std::vector< AT > userContourNodes
grid for contact point detection
Definition: flexible_body.h:261
bool updEle
vector of contour parameters each describing a frame
Definition: flexible_body.h:230
std::vector< Frame * > frame
virtual void GlobalVectorContribution(int CurrentElement, const fmatvec::Vec &locVec, fmatvec::Vec &gloVec)=0
insert &#39;local&#39; information in global vectors
cartesian frame on nodes of flexible bodies
Definition: node_frame.h:31
virtual void exportPositionVelocity(const std::string &filenamePos, const std::string &filenameVel=std::string(), const int &deg=3, const bool &writePsFile=false)
interpolates the position and optional the velocity coordinates of the flexible body with Nurbs-packa...
Definition: flexible_body.h:184
fmatvec::Vec qd
fmatvec::Vec q0

Impressum / Disclaimer / Datenschutz Generated by doxygen 1.8.5 Valid HTML