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 FINITE_ELEMENT_1S_REFERENCE_CURVE_H_
#define FINITE_ELEMENT_1S_REFERENCE_CURVE_H_
 
#include <mbsimFlexibleBody/flexible_body/1S_reference_curve.h>
 
#include <mbsimFlexibleBody/contours/nc/contour_1s_neutral_reference_curve.h>
 
#include <mbsim/discretization_interface.h>
 
#include <mbsim/functions/function.h>
 
namespace MBSimFlexibleBody {
 
  class FlexibleBody1SReferenceCurveFE : public DiscretizationInterface {
      friend class funcPTP;
      friend class funcPTdPdxi;
      friend class funcPTdPdt;
      friend class funcPTdPdqk;
      friend class funcForWgamma;
      friend class funcForWb;
 
    public:
      FlexibleBody1SReferenceCurveFE(FlexibleBody1SReferenceCurve * parent, int eleNo, Vec2 alpha, int order, int nodeDofs);
 
      virtual ~FlexibleBody1SReferenceCurveFE();
 
      virtual void init(MBSim::Element::InitStage stage, const MBSim::InitConfigSet &config);
      virtual int getqSize() const {
        throw std::runtime_error("Not implemented" + string(__func__));
      }
 
      virtual fmatvec::Vec getq() const {
        return parent->qElement[element];
      }
 
      virtual int getuSize() const {
        throw std::runtime_error("Not implemented" + string(__func__));
      }
 
      virtual const fmatvec::SymMat& getM() const {
        return M;
      }
      virtual const fmatvec::Vec& geth() const {
        return h;
      }
 
      virtual const fmatvec::SqrMat& getdhdq() const {
        throw std::runtime_error("Not implemented" + string(__func__));
      }
      virtual const fmatvec::SqrMat& getdhdu() const {
        throw std::runtime_error("Not implemented");
      }
      virtual void computeM(const fmatvec::Vec& q);
      virtual void computeh(const fmatvec::Vec& q, const fmatvec::Vec& u);
      virtual void computedhdz(const fmatvec::Vec& q, const fmatvec::Vec& u) {
        throw std::runtime_error("Not implemented");
      }
      virtual double computeKineticEnergy(const fmatvec::Vec& q, const fmatvec::Vec& u) {
        throw std::runtime_error("Not implemented");
      }
      virtual double computeGravitationalEnergy(const fmatvec::Vec& q) {
        throw std::runtime_error("Not implemented");
      }
      virtual double computeElasticEnergy(const fmatvec::Vec& q) {
        throw std::runtime_error("Not implemented");
      }
      virtual fmatvec::Vec computePosition(const fmatvec::Vec& q, const MBSim::ContourPointData &data) {
        throw std::runtime_error("Not implemented");
      }
      virtual fmatvec::SqrMat computeOrientation(const fmatvec::Vec& q, const MBSim::ContourPointData &data) {
        throw std::runtime_error("Not implemented");
      }
      virtual fmatvec::Vec computeVelocity(const fmatvec::Vec& q, const fmatvec::Vec& u, const MBSim::ContourPointData &data) {
        throw std::runtime_error("Not implemented");
      }
      virtual fmatvec::Vec computeAngularVelocity(const fmatvec::Vec& q, const fmatvec::Vec& u, const MBSim::ContourPointData &data) {
        throw std::runtime_error("Not implemented");
      }
      virtual fmatvec::Mat computeJacobianOfMotion(const fmatvec::Vec& q, const MBSim::ContourPointData &data) {
        throw std::runtime_error("Not implemented");
      }
 
      virtual void setDofDir(fmatvec::VecInt dofDirElement_) {
        dofDirs = dofDirElement_;
      }
 
      virtual fmatvec::VecInt getDofDirs() {
        return dofDirs;
      }
 
      virtual int getAddDoFSizeMax() const {
        return getNodesSize() * nodeDirs;
      }
 
      virtual int getNodesSize() const {
        return (order + 1);
      }
 
      FlexibleBody1SReferenceCurve * getParent() {
        return parent;
      }
 
      const std::vector<int> getFreeDofs() {
        return freeDoFs;
      }
 
      const fmatvec::Vec2 getAlpha() {
        return alpha;
      }
 
      int findLocalDof(int globalDof) {
        for (size_t i = 0; i < freeDoFs.size(); i++) {
          if (dofDirs(freeDoFs[i]) == globalDof)
            return freeDoFs[i];
        }
        return -1;
      }
 
      virtual double computeXiLoc(double xiGlob);
 
      virtual double computeXiGlob(double xiLoc);
 
      fmatvec::Vec3 computer(double xi, int derXi = 0, int derTheta = 0);
 
      fmatvec::Vec3 computev(double xi, int derXi = 0);
 
      fmatvec::Vec3 computedrdqk(double xi, int derXi, int qIndLoc);
 
      virtual double computeN(int j, double xiLoc, int derXi);
 
      virtual double computeLegendre(int j, double xiLoc, int derXi);
 
      fmatvec::Vec3 computeB(int dofDirLocal, double xiGlob, int derXi, int derTheta);
 
      fmatvec::Vec3 computeBqf(double xi, int derXi, int derTheta);
 
      fmatvec::Vec3 computeBuf(double xi, int derXi, int derTheta);
 
      virtual fmatvec::Vec3 computeS(int columnEle, double xiGlob, int derXi);
 
      virtual fmatvec::Vec3 computeSTimeslocVec(double xiGlob, int derXi, const fmatvec::Vec & locVec);
 
      virtual fmatvec::Vec3 computeAnodeTimesSTimeslocVec(double xiGlob, int derXi, int derTheta, const fmatvec::Vec & locVec);
 
      fmatvec::Mat3xV computeP(double xi, int derXi);
 
      fmatvec::Mat3xV computedPdqk(double xi, int dofDirLocal);
 
      double computeeps(double xiGlob);
 
      double computedepsdqk(int localDofDir, double xiGlob);
 
      double computeKappan(double xiGlob);
 
      double computeKappab(double xiGlob);
 
      double computedKappandqk(double xiGlob, int qIndLocal);
 
      double computedKappabdqk(double xiGlob, int qIndLocal);
 
      double dWndqk(double xiGlob, int qInd);
 
      void updateIntegrationBorders(double t);
 
    private:
      FlexibleBody1SReferenceCurve * parent;
 
      int element;
 
      fmatvec::VecInt dofDirs;
 
      /*
       * \brief start and end node in the global system
       */
      fmatvec::Vec2 alpha;
 
      std::vector<double> borders;
 
      int order;
 
      int nodeDirs;
 
      std::vector<int> freeDoFs;
 
      std::vector<std::vector<std::vector<double>> > coeffs;
 
      std::vector<double> getLagrangeCoeffs(int nodeNo);
 
      std::vector<double> getHermiteCoeffs(int nodeNo);
 
      fmatvec::SymMat M;
 
      fmatvec::Vec h;
 
      fmatvec::VecV hT1;
 
      fmatvec::VecV hT2;
 
      fmatvec::VecV hT3;
 
      fmatvec::VecV hV1;
 
      fmatvec::VecV hV2;
 
      fmatvec::VecV hV3;
 
      fmatvec::VecV hV4;
 
      fmatvec::SymMatV integratePTP();
 
      fmatvec::SqrMatV integratePTdPdxi();
 
      fmatvec::SqrMatV integratePTdPdt();
 
      fmatvec::SqrMatV integratePTdPdqk(int qInd);
 
      double integrateForWgamma(int qInd);
 
      double integrateForWn(int qIndLoc);
 
      double integrateForWb(int qIndLoc);
 
      /*
       * \brief compute the global xi value of the given local dof direction
       * \remark the input values [0,1] have to global xi-values!
       */
      double computeXiOfDOF(int dofDirLocal);
 
      int AVers = 2;
  };
 
}
 
#endif /* FINITE_ELEMENT_1S_REFERENCE_CURVE_H_ */