1S_reference_curve.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
 *
 * Created on: Jul 30, 2013
 * Contact: kilian.grundl@gmail.com
 */
 
#ifndef FLEXIBLE_BODY_1S_REFERENCE_CURVE_H_
#define FLEXIBLE_BODY_1S_REFERENCE_CURVE_H_
 
#include <mbsimFlexibleBody/contours/nc/contour_1s_neutral_reference_curve.h>
 
#include <mbsimFlexibleBody/flexible_body.h>
 
#include <mbsim/functions/function.h>
 
namespace MBSimFlexibleBody {
 
  class ReferenceCurve {
    public:
      ReferenceCurve();
      virtual ~ReferenceCurve();
 
      virtual void computeReference() = 0;
 
      virtual fmatvec::Vec3 computeVecAt(double xi, double Theta, int derXi, int derTheta) = 0;
 
      virtual fmatvec::VecV computeC1Positions(const fmatvec::Vec & qRef) = 0;
 
    protected:
      double length;
  };
 
  class FlexibleBody1SReferenceCurve : public FlexibleBodyContinuum<double> {
      friend class FlexibleBody1SReferenceCurveFE;
      friend class Contour1sNeutralFlexibleBody1SReferenceCurve;
      friend class funcForWgamma;
      friend class gethFunc;
 
    public:
      FlexibleBody1SReferenceCurve(const std::string & name, ReferenceCurve * refCurve);
 
      virtual ~FlexibleBody1SReferenceCurve();
 
      virtual void init(MBSim::Element::InitStage stage, const MBSim::InitConfigSet &config);
      virtual void initInfo(fmatvec::Vec q0 = fmatvec::Vec(0,fmatvec::NONINIT), fmatvec::Vec u0 = fmatvec::Vec(0,fmatvec::NONINIT));
 
      /*INHERITED INTERFACE*/
      virtual void BuildElements();
      virtual void updateh(int k = 0);
      virtual void updateM();
      virtual void updatedq();
      virtual void updatedu();
      virtual void updateud();
      virtual void updateqd();
      virtual void initz();
      virtual void plot(double t, double dt = 1.);
 
      virtual void GlobalVectorContribution(int, const fmatvec::Vec&, fmatvec::Vec&);
 
      virtual void GlobalMatrixContribution(int, const fmatvec::Mat3xV&, fmatvec::Mat3xV&);
 
      virtual void GlobalMatrixContribution(int, const fmatvec::Mat&, fmatvec::Mat&) {
        throw MBSim::MBSimError("NOT IMPLEMENTED: " + std::string(__func__));
      }
      virtual void GlobalMatrixContribution(int, const fmatvec::SymMat&, fmatvec::SymMat&);
 
//      virtual void updateKinematicsForFrame(MBSim::ContourPointData&, MBSim::Frame::Feature, MBSim::Frame*);
//      virtual void updateJacobiansForFrame(MBSim::ContourPointData&, MBSim::Frame*) {
//        throw MBSim::MBSimError("NOT IMPLEMENTED: " + std::string(__func__));
//      }
//
//      virtual void updateKinematicsAtNode(MBSimFlexibleBody::NodeFrame *frame, MBSim::Frame::Feature ff);
 
      virtual void setq0(fmatvec::Vec q0_) {
        FlexibleBodyContinuum<double>::setq0(q0_);
        qF << q0;
      }
      virtual void setu0(fmatvec::Vec u0_) {
        FlexibleBodyContinuum<double>::setu0(u0_);
        uF << u0;
      }
 
      /*GETTER and SETTER*/
      void setLength(double length_) {
        length = length_;
      }
      double getlength() const {
        return length;
      }
      void setDensity(double rho_) {
        rho = rho_;
      }
      double getrho() const {
        return rho;
      }
      void setCrossSectionalArea(double A_) {
        A = A_;
      }
      double getA() const {
        return A;
      }
      void setEModul(double E_) {
        E = E_;
      }
      double getE() const {
        return E;
      }
      void setNu(double nu_) {
        nu = nu_;
      }
      double getNu() const {
        return nu;
      }
      void setIn(double In_) {
        In = In_;
      }
      double getIn() const {
        return In;
      }
      void setIb(double Ib_) {
        Ib = Ib_;
      }
      double getIb() const {
        return Ib;
      }
      void setIt(double It_) {
        It = It_;
      }
      double getIt() const {
        return It;
      }
      void setdPulley(double dPulley_) {
        dPulley = dPulley_;
      }
      double getdPulley() const {
        return dPulley;
      }
 
      void setNumberElements(int elements_) {
        elements = elements_;
      }
 
      void setElementOrder(int elementOrder_) {
        elementOrder = elementOrder_;
      }
 
      void setNodeDofs(int nodeDofs_) {
        nodeDoFs = nodeDofs_;
      }
 
      void setUseSpatialReferenceKinematics(bool switch_) {
        useSpatialReferenceKinematics = switch_;
      }
 
      void setThetaDamping(double dTheta_) {
        dTheta = dTheta_;
      }
 
      void setLockedDofs(std::set<int> lockedDofs_) {
        lockedDofsFull = lockedDofs_;
      }
 
      void setLambdaqSwitches(const fmatvec::VecV & lambdaqSwitches_) {
        lambdaqFSwitches = lambdaqSwitches_;
      }
 
      void setLambdauSwitches(const fmatvec::VecV & lambdauSwitches_) {
        lambdauFSwitches = lambdauSwitches_;
      }
 
      virtual void setelongationActive(bool val) {
        elongationActive = val;
      }
 
      virtual void setnormalBendingActive(bool val) {
        normalBendingActive = val;
      }
 
      virtual double gets() {
        if (not usePT1)
          return q(0);
        else
          return qF(0);
      }
 
//      virtual void updateStateDependentVariables(double t);
 
      Contour1sNeutralFlexibleBody1SReferenceCurve* createNeutralPhase(const std::string & contourName);
 
      double computePhysicalStrain(double xi);
 
      fmatvec::Vec computeNeutralState(const fmatvec::Vec & q0);
 
    private:
      ReferenceCurve * refCurve;
 
      int elements;
 
      int nodeDoFs;
 
      int elementOrder;
 
      bool useSpatialReferenceKinematics;
 
      double length;
 
      double rho;
 
      double A;
 
      double E;
 
      double nu;
 
      double In;
 
      double Ib;
 
      double It;
 
      double dPulley;
 
      fmatvec::Vec3 b;
 
      double dTheta;
 
      std::set<int> lockedDofsFull;
 
      fmatvec::VecV qF;
 
      fmatvec::VecV uF;
 
      fmatvec::VecV lambdaqFSwitches;
 
      fmatvec::VecV lambdauFSwitches;
 
      fmatvec::VecV lambdaqF;
 
      fmatvec::VecV lambdauF;
 
      bool usePT1 = false;
 
      std::vector<fmatvec::Vec> qElementAll;
 
      std::vector<fmatvec::Vec> uElementAll;
 
      int updateReferenceEvery;
 
      int referenceNotUpdated;
 
      double tLastRefUpdate;
 
      bool elongationActive = true;
 
      bool normalBendingActive = true;
 
      double computeG() const {
        return E / (2 * (1 + nu));
      }
 
      fmatvec::Vec3 computer(double xi, int derXi = 0, int derTheta = 0);
 
      fmatvec::Vec3 computedrdqk(double xi, int derXi, int qInd);
 
      fmatvec::Vec3 computev(double xi);
 
      fmatvec::Vec3 computerRef(double xi, int derXi = 0, int derTheta = 0);
 
      fmatvec::SqrMat3 computeARef(double xi, int derXi = 0, int derTheta = 0);
 
      fmatvec::Vec3 computenRef(double xi, int derXi = 0, int derTheta = 0);
 
      fmatvec::Vec3 computeSElement(int globalDOF, double xi, int derXi);
 
      fmatvec::Vec3 computeSqfElement(double xi, int derXi);
 
      fmatvec::Vec3 computeSufElement(double xi, int derXi);
 
      fmatvec::Mat3xV computeP(double xi, int derXi = 0);
 
      fmatvec::Mat3xV computedPdqk(double xi, int qInd);
 
      fmatvec::SymMatV integratePTP();
 
      fmatvec::SqrMatV integratePTdPdxi();
 
      fmatvec::SqrMatV integratePTdPdt();
 
      fmatvec::SqrMatV integratePTdPdqk(int qInd);
 
      fmatvec::Vec3 integrateForWgammaWnWtau(int qInd);
 
      double integrateForWb(int qInd);
 
      int findElement(double & xi);
 
      std::vector<std::pair<int, int>> getElementAndLocalDoFNo(int globalColumn);
 
      int getEleDofs() const;
  };
 
  class gethFunc : public MBSim::Function<fmatvec::Vec(fmatvec::Vec)> {
    public:
      gethFunc(FlexibleBody1SReferenceCurve * refBody) :
          refBody(refBody) {
      }
 
      ~gethFunc() {
      }
 
      fmatvec::Vec operator()(const fmatvec::Vec & q) {
        refBody->setq(q);
        refBody->updateh(0, 0);
        return refBody->geth(0);
      }
    private:
      FlexibleBody1SReferenceCurve * refBody;
  };
 
}
 
#endif /* FLEXIBLE_BODY_1S_REFERENCE_CURVE_H_ */