flexible_body.h

/* Copyright (C) 2004-2015 MBSim Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 *
 * Contact: thorsten.schindler@mytum.de
 *          martin.o.foerg@googlemail.com
 */
 
#ifndef _FLEXIBLE_BODY_H_
#define _FLEXIBLE_BODY_H_
 
#include "mbsimFlexibleBody/node_based_body.h"
 
namespace MBSim {
  class FixedRelativeFrame;
  class ContourFrame;
}
 
namespace MBSimFlexibleBody {
 
  class DiscretizationInterface;
 
  class FlexibleBody : public NodeBasedBody {
    public:
      FlexibleBody(const std::string &name);
 
      ~FlexibleBody() override;
 
      /* INHERITED INTERFACE OF OBJECTINTERFACE */
      void updateqd() override { qd = u; }
      void updateh(int k=0) override;
      void updateM() override;
      void updatedhdz() override;
 
      /* INHERITED INTERFACE OF ELEMENT */
      void initializeUsingXML(xercesc::DOMElement *element) override;
      /***************************************************/
 
      /* INHERITED INTERFACE OF OBJECT */
      void init(InitStage stage, const MBSim::InitConfigSet &config) override;
      virtual double computeKineticEnergy();
      virtual double computePotentialEnergy();
      void setFrameOfReference(MBSim::Frame *frame) override;
      virtual void setq0(const fmatvec::Vec &q0_) { if(q0_.size()) MBSim::Body::setGeneralizedInitialPosition(q0_); q <<= q0; }
      virtual void setu0(const fmatvec::Vec &u0_) { if(u0_.size()) MBSim::Body::setGeneralizedInitialVelocity(u0_); u <<= u0; }
      /***************************************************/
 
      /* INTERFACE TO BE DEFINED IN DERIVED CLASSES */
      virtual void BuildElements() = 0;
 
      const fmatvec::Vec& getqElement(int i) { if(updEle) BuildElements(); return qElement[i]; }
 
      const fmatvec::Vec& getuElement(int i) { if(updEle) BuildElements(); return uElement[i]; }
 
      virtual fmatvec::Vec3 getAngles(int i) { return fmatvec::Vec3(); }
      virtual fmatvec::Vec3 getDerivativeOfAngles(int i) { return fmatvec::Vec3(); }
 
      virtual void GlobalVectorContribution(int CurrentElement, const fmatvec::Vec &locVec, fmatvec::Vec &gloVec) = 0;
 
      virtual void GlobalMatrixContribution(int CurrentElement, const fmatvec::Mat &locMat, fmatvec::Mat &gloMat) = 0;
 
      virtual void GlobalMatrixContribution(int CurrentElement, const fmatvec::SymMat &locMat, fmatvec::SymMat &gloMat) = 0;
 
//      /**
//       * \brief cartesian kinematic for contour or external frame (normal, tangent, binormal) is set by implementation class
//       * \param data contour parameter
//       * \param ff selection of specific calculations for frames
//       * \param frame optional: external frame, otherwise contour parameters are changed
//       */
//      virtual void updateKinematicsForFrame(MBSim::ContourPointData &data, MBSim::Frame::Frame::Feature ff, MBSim::Frame *frame=0) = 0;
//
//      /*!
//       * \brief cartesian kinematic on a node
//       */
//      virtual void updateKinematicsAtNode(NodeFrame *frame, MBSim::Frame::Feature ff) {
//        throwError("updateKinematicsAtNode(): Not implemented for " + typid(*this).name()); //TODO: make that interface prettier
//      }
//
//      /**
//       * \brief Jacobians and gyroscopes for contour or external frame are set by implementation class
//       * \param data contour parameter
//       * \param frame: optional external frame, otherwise contour parameters are changed
//       */
//      virtual void updateJacobiansForFrame(MBSim::ContourPointData &data, MBSim::Frame *frame=0) = 0;
//      /***************************************************/
 
      /* GETTER / SETTER */
      void setMassProportionalDamping(const double d_) { d_massproportional = d_; }
      /***************************************************/
 
      using NodeBasedBody::addFrame;
 
      void addFrame(MBSim::ContourFrame *frame);
 
      void addFrame(MBSim::FixedRelativeFrame *frame);
 
      void addContour(MBSim::Contour *contour) override;
 
      virtual void exportPositionVelocity(const std::string & filenamePos, const std::string & filenameVel = std::string(), const int & deg = 3, const bool &writePsFile = false){throwError("exportPositionVelocity(const std::string& filenamePos, const std::string& filenameVel, const int& deg, const bool& writePsFile) is not implemented for " + boost::core::demangle(typeid(*this).name())) ;}
 
      virtual void importPositionVelocity(const std::string& filenamePos, const std::string& filenameVel = std::string()){throwError("importPositionVelocity(const std::string& filenamePos, const std::string& filenameVel) is not implemented for " + boost::core::demangle(typeid(*this).name())) ;}
 
      void resetUpToDate() override;
 
    protected:
      std::vector<DiscretizationInterface*> discretization;
 
      std::vector<fmatvec::Vec> qElement;
 
      std::vector<fmatvec::Vec> uElement;
 
      double d_massproportional;
 
//      std::vector<MBSim::ContourPointData> S_Frame;
 
      // Workaround to free memory of contourFrame in dtor.
      // TODO: provide a consistent solution and remove the following line
//      MBSim::Frame *contourFrame;
 
      bool updEle;
  };
 
  template <class AT>
    class FlexibleBodyContinuum : public FlexibleBody {
      public:
        FlexibleBodyContinuum<AT>(const std::string &name) : FlexibleBody(name) {}
 
        /* INHERITED INTERFACE OF ELEMENT */
 
        /* GETTER / SETTER */
        void setContourNodes(const std::vector<AT> nodes) { userContourNodes = nodes; }
 
        void setNodeOffset(const AT nodeOffset_){ nodeOffset = nodeOffset_;}  // TODO:: call this function in the init() of flexible body.
        AT getNodeOffset() const { return nodeOffset;}
 
      protected:
        std::vector<AT> userContourNodes;
 
        AT nodeOffset;
    };
}
 
#endif /* _FLEXIBLE_BODY_H_ */