1s_33_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: thorsten.schindler@mytum.de
 */
 
#ifndef _FLEXIBLE_BODY_1S_33_COSSERAT_H_
#define _FLEXIBLE_BODY_1S_33_COSSERAT_H_
 
#include "1s_cosserat.h"
#include "mbsimFlexibleBody/pointer.h"
#include "mbsimFlexibleBody/flexible_body/fe/1s_33_cosserat_translation.h"
#include "mbsimFlexibleBody/flexible_body/fe/1s_33_cosserat_rotation.h"
 
namespace MBSimFlexibleBody {
 
  class NodeFrame;
 
//  class NurbsCurve1s;
 
  class FlexibleBody1s33Cosserat : public FlexibleBody1sCosserat {
    public:
 
      FlexibleBody1s33Cosserat(const std::string &name, bool openStructure);
 
       ~FlexibleBody1s33Cosserat() override;
 
      /* INHERITED INTERFACE OF FLEXIBLE BODY */
       void BuildElements() override;
       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;
 
       fmatvec::Vec3 getAngles(int i) override;
       fmatvec::Vec3 getDerivativeOfAngles(int i) override;
 
      /* INHERITED INTERFACE OF OBJECT */
       void init(InitStage stage, const MBSim::InitConfigSet &config) override;
       double computePotentialEnergy() override;
      /***************************************************/
 
      /* INHERITED INTERFACE OF OBJECTINTERFACE */
       void updateLLM() override;
 
      /* INHERITED INTERFACE OF ELEMENT */
      /***************************************************/
 
      /* GETTER / SETTER */
      void setNumberElements(int n) override;
 
      void setMomentsInertia(double I1_, double I2_, double I0_) override;
 
      void setCurlRadius(double R1_, double R2_) override;
      void setMaterialDamping(double cEps0D_, double cEps1D_, double cEps2D_) override;
 
       int getNumberOfElementDOF() const override { return 6; }
 
      int getNumberElements() const override { return Elements; }
      int getNumberDOFs() const { return qSize; }
      /***************************************************/
 
      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:
 
      bool JTransInterp;
 
      double I2, I0;
 
      double R2;
 
      double cEps2D;
 
      FlexibleBody1s33Cosserat(); // standard constructor
      FlexibleBody1s33Cosserat(const FlexibleBody1s33Cosserat&); // copy constructor
      FlexibleBody1s33Cosserat& operator=(const FlexibleBody1s33Cosserat&); // assignment operator
 
      void initM() override;
 
      void computeBoundaryCondition() override;
 
      void GlobalVectorContributionRotation(int n, const fmatvec::Vec& locVec, fmatvec::Vec& gloVec) override;
  };
 
  inline void FlexibleBody1s33Cosserat::setMomentsInertia(double I1_, double I2_, double I0_) {
    I1 = I1_;
    I2 = I2_;
    I0 = I0_;
  }
 
  inline void FlexibleBody1s33Cosserat::setCurlRadius(double R1_, double R2_) {
    R1 = R1_;
    R2 = R2_;
    if (initialised)
      for (int i = 0; i < Elements; i++)
        static_cast<FiniteElement1s33CosseratRotation*>(rotationDiscretization[i])->setCurlRadius(R1, R2);
  }
  inline void FlexibleBody1s33Cosserat::setMaterialDamping(double cEps0D_, double cEps1D_, double cEps2D_) {
    cEps0D = cEps0D_;
    cEps1D = cEps1D_;
    cEps2D = cEps2D_;
    if (initialised)
      for (int i = 0; i < Elements; i++)
        static_cast<FiniteElement1s33CosseratTranslation*>(discretization[i])->setMaterialDamping(Elements * cEps0D, cEps1D, cEps2D);
  }
 
}
 
#endif /* _FLEXIBLE_BODY_1S_33_COSSERAT_H_ */