1s_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_COSSERAT_H_
#define FLEXIBLE_BODY_1S_COSSERAT_H_
 
#include "mbsimFlexibleBody/flexible_body/1s.h"
#include "mbsimFlexibleBody/pointer.h"
//#include <mbsimFlexibleBody/contours/nc/contour_1s_neutral_cosserat.h>
//#include "mbsimFlexibleBody/flexible_body/fe/1s_33_cosserat_translation.h"
//#include "mbsimFlexibleBody/flexible_body/fe/1s_33_cosserat_rotation.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>
//
//#include "mbsimFlexibleBody/contours/nurbs_curve_1s.h"
 
namespace MBSimFlexibleBody {
 
  class Contour1sNeutralCosserat;
 
  class FlexibleBody1sCosserat : public FlexibleBody1s {
    public:
 
      FlexibleBody1sCosserat(const std::string &name, bool openStructure);
 
      /* INHERITED INTERFACE OF FLEXIBLE BODY */
       void BuildElements() override =0;
      const fmatvec::Vec& evalqRotationElement(int i) { if(updEle) BuildElements(); return qRotationElement[i]; }
      const fmatvec::Vec& evaluRotationElement(int i) { if(updEle) BuildElements(); return uRotationElement[i]; }
       void GlobalVectorContribution(int n, const fmatvec::Vec& locVec, fmatvec::Vec& gloVec) override =0;
       void GlobalMatrixContribution(int n, const fmatvec::Mat& locMat, fmatvec::Mat& gloMat) override =0;
       void GlobalMatrixContribution(int n, const fmatvec::SymMat& locMat, fmatvec::SymMat& gloMat) override =0;
       void exportPositionVelocity(const std::string & filenamePos, const std::string & filenameVel = std::string(), const int & deg = 3, const bool & writePsFile = false) override =0;
       void importPositionVelocity(const std::string & filenamePos, const std::string & filenameVel = std::string()) override =0;
      /***************************************************/
 
      /* INHERITED INTERFACE OF OBJECTINTERFACE */
       void updateh(int i = 0) override;
 
      /* INHERITED INTERFACE OF ELEMENT */
      /***************************************************/
 
      /* GETTER / SETTER */
      virtual void setNumberElements(int n)=0;
      void setEGModuls(double E_, double G_) { E = E_; G = G_; }
      void setDensity(double rho_) { rho = rho_; }
      void setCrossSectionalArea(double A_) { A = A_; }
 
      virtual void setMomentsInertia(double I1_, double I2_, double I0_) { }
      virtual void setMomentsInertia(double I1_) { }
 
      virtual void setCurlRadius(double R1_, double R2_) { }
      virtual void setCurlRadius(double R1_) { }
      virtual void setMaterialDamping(double cEps0D_, double cEps1D_, double cEps2D_) { }
      virtual void setMaterialDamping(double cEps0D_, double cEps1D_) { }
 
      virtual Contour1sNeutralCosserat* createNeutralPhase(const std::string & contourName = "Neutral");
 
      virtual fmatvec::Mat3xV transformJacobian(fmatvec::Mat3xV J) { return J; }
 
      virtual int getNumberOfElementDOF() const { throwError("(FlexibleBody1sCosserat::getNumberOfElementDOF): Not implemented!"); }
      virtual int getNumberElements() const { return Elements; }
      virtual int getqSizeFull() const { return getqSize(); }
 
      /***************************************************/
 
//      /**
//       * \brief compute state (positions, angles, velocities, differentiated angles) at Lagrangian coordinate in local FE coordinates
//       * \param Lagrangian coordinate
//       */
//      virtual fmatvec::Vec computeState(double s)=0;
//
//      /**
//       * \brief compute angles at Lagrangian coordinate in local FE coordinates
//       * \param Lagrangian coordinate
//       */
//      virtual fmatvec::Vec3 computeAngles(double sGlobal, const fmatvec::Vec & vec)=0;
 
      virtual void initInfo()=0;
 
      virtual void BuildElementTranslation(const double& sGlobal, double& sLocal, int& currentElementTranslation) = 0;
 
    protected:
 
      std::vector<DiscretizationInterface*> rotationDiscretization;
 
      std::vector<fmatvec::Vec> qRotationElement;
 
      std::vector<fmatvec::Vec> uRotationElement;
 
      CardanPtr angle;
 
      int Elements;
 
      int rotationalElements;
 
      double l0;
 
      double E, G;
 
      double A;
 
      double I1;
 
      double rho;
 
      double R1;
 
      double cEps0D, cEps1D;
 
      bool initialised;
 
      fmatvec::Vec bound_ang_start;
      fmatvec::Vec bound_ang_end;
      fmatvec::Vec bound_ang_vel_start;
      fmatvec::Vec bound_ang_vel_end;
 
      Contour1sNeutralCosserat* ncc;
 
      FlexibleBody1sCosserat(); // standard constructor
      FlexibleBody1sCosserat(const FlexibleBody1sCosserat&); // copy constructor
      FlexibleBody1sCosserat& operator=(const FlexibleBody1sCosserat&); // assignment operator
 
      virtual void initM()=0;
 
      virtual void computeBoundaryCondition()=0;
 
      virtual void GlobalVectorContributionRotation(int n, const fmatvec::Vec& locVec, fmatvec::Vec& gloVec)=0;
  };
}
 
#endif /* FLEXIBLE_BODY_1S_COSSERAT_H_ */