1s_21_cosserat.h

/* Copyright (C) 2004-2012 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: thomas.cebulla@mytum.de
 */
 
#ifndef _FLEXIBLE_BODY_1S_21_COSSERAT_H_
#define _FLEXIBLE_BODY_1S_21_COSSERAT_H_
 
#include <fmatvec/fmatvec.h>
#include "mbsimFlexibleBody/flexible_body/1s_cosserat.h"
#include "mbsimFlexibleBody/flexible_body.h"
#include "mbsimFlexibleBody/pointer.h"
#include "mbsimFlexibleBody/contours/flexible_band.h"
#include "mbsimFlexibleBody/flexible_body/fe/1s_21_cosserat_translation.h"
#include "mbsimFlexibleBody/flexible_body/fe/1s_21_cosserat_rotation.h"
#include <openmbvcppinterface/spineextrusion.h>
 
namespace MBSimFlexibleBody {
 
  class NodeFrame;
 
  class FlexibleBody1s21Cosserat : public FlexibleBody1sCosserat {
    public:
 
      FlexibleBody1s21Cosserat(const std::string &name, bool openStructure);
 
       ~FlexibleBody1s21Cosserat() override;
 
      /* INHERITED INTERFACE OF FLEXIBLE BODY */
       void BuildElements() override;
      const fmatvec::Vec& evalqFull() { if(updEle) BuildElements(); return qFull; }
      const fmatvec::Vec& evaluFull() { if(updEle) BuildElements(); return uFull; }
       void GlobalVectorContribution(int n, const fmatvec::Vec& locVec, fmatvec::Vec& gloVec) override;
       void GlobalMatrixContribution(int n, const fmatvec::Mat& locMat, fmatvec::Mat& gloMat) override;
       void GlobalMatrixContribution(int n, const fmatvec::SymMat& locMat, fmatvec::SymMat& gloMat) override;
       void exportPositionVelocity(const std::string & filenamePos, const std::string & filenameVel = std::string(), const int & deg = 3, const bool & writePsFile = false) override;
       void importPositionVelocity(const std::string & filenamePos, const std::string & filenameVel = std::string()) override;
 
       void updatePositions(Frame1s* frame) override;
       void updateVelocities(Frame1s* frame) override;
       void updateAccelerations(Frame1s* frame) override;
       void updateJacobians(Frame1s* frame, int j=0) override;
       void updateGyroscopicAccelerations(Frame1s* frame) override;
 
      void updatePositions(int node) override;
      void updateVelocities(int node) override;
      void updateAccelerations(int node) override;
      void updateJacobians(int node, int j=0) override;
      void updateGyroscopicAccelerations(int node) override;
 
//      virtual fmatvec::Vec3 getAngles(int i);
//      virtual fmatvec::Vec3 getDerivativeOfAngles(int i);
 
      /* INHERITED INTERFACE OF OBJECT */
       void init(InitStage stage, const MBSim::InitConfigSet &config) override;
       double computePotentialEnergy() override;
       void updateM() override;
       void updateLLM() override;
//      virtual void updatedu();
      /***************************************************/
 
      /* INHERITED INTERFACE OF OBJECTINTERFACE */
       void updateh(int i = 0) override;
 
      /* INHERITED INTERFACE OF ELEMENT */
      /***************************************************/
 
      /* GETTER / SETTER */
      void setNumberElements(int n) override;
 
      void setMomentsInertia(double I1_) override;
      void setCurlRadius(double R1_) override;
      void setMaterialDamping(double cEps0D_, double cEps1D_) override;
 
       fmatvec::Mat3xV transformJacobian(fmatvec::Mat3xV J) override {
        if (PODreduced)
          return J * U;
        return J;
      }
 
       int getNumberOfElementDOF() const override {
        return 3;
      }
 
      int getNumberElements() const override {
        return Elements;
      }
      double getLength() const {
        return L;
      }
       int getqSizeFull() const override {
        return qFull.size();
      }
      bool isOpenStructure() const {
        return openStructure;
      }
 
      /* \brief Set SVD=true for POD model reduction
       * \param  reduced mass matrix
       */
      void enablePOD(const std::string & h5Path, int reduceMode = 0, int POMSize = 0);
      /***************************************************/
 
      fmatvec::Vector<fmatvec::Fixed<6>, double> getPositions(double x);
 
      fmatvec::Vector<fmatvec::Fixed<6>, double> getVelocities(double x);
 
      fmatvec::Vec3 computeAngles(double sGlobal, const fmatvec::Vec & vec);
 
      void initInfo() override;
 
      void BuildElementTranslation(const double& sGlobal, double& sLocal, int& currentElementTranslation) override;
 
    protected:
 
      fmatvec::SymMat MConst;
 
      fmatvec::SymMat LLMConst;
 
      bool JInterp;
 
      bool PODreduced;
 
      fmatvec::Mat U;
 
      fmatvec::Vec qFull;
 
      fmatvec::Vec uFull;
 
      fmatvec::Vec hFull;
 
      FlexibleBody1s21Cosserat(); // standard constructor
      FlexibleBody1s21Cosserat(const FlexibleBody1s21Cosserat&); // copy constructor
      FlexibleBody1s21Cosserat& operator=(const FlexibleBody1s21Cosserat&); // assignment operator
 
      void initM() override;
 
      void computeBoundaryCondition() override;
 
      void GlobalVectorContributionRotation(int n, const fmatvec::Vec& locVec, fmatvec::Vec& gloVec) override;
 
      fmatvec::Mat readPositionMatrix(const std::string & h5File, const std::string & job);
 
      int findPOMSize(const fmatvec::Mat & POM, const fmatvec::Mat &SVD, double precission = 1 - 1.e-3);
 
  }
  ;
 
  inline void FlexibleBody1s21Cosserat::updateM() {
    M = MConst;
  }
 
  inline void FlexibleBody1s21Cosserat::updateLLM() {
    LLM = LLMConst;
  }
 
  inline void FlexibleBody1s21Cosserat::setMomentsInertia(double I1_) {
    I1 = I1_;
  }
 
  inline void FlexibleBody1s21Cosserat::setCurlRadius(double R1_) {
    R1 = R1_;
    if (initialised)
      for (int i = 0; i < Elements; i++)
        static_cast<FiniteElement1s21CosseratRotation*>(rotationDiscretization[i])->setCurlRadius(R1);
  }
  inline void FlexibleBody1s21Cosserat::setMaterialDamping(double cEps0D_, double cEps1D_) {
    cEps0D = cEps0D_;
    cEps1D = cEps1D_;
    if (initialised)
      for (int i = 0; i < Elements; i++)
        static_cast<FiniteElement1s21CosseratTranslation*>(discretization[i])->setMaterialDamping(Elements * cEps0D, cEps1D);
  }
 
}
 
#endif /* _FLEXIBLE_BODY_1S_21_COSSERAT_H_ */