2s_13.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
 *
 * Contact: thorsten.schindler@mytum.de
 */
 
#ifndef FLEXIBLEBODY2S13_H_
#define FLEXIBLEBODY2S13_H_
 
#include "mbsimFlexibleBody/flexible_body/2s.h"
 
namespace MBSimFlexibleBody {
 
  class NurbsDisk2s;
 
  fmatvec::Mat condenseMatrixRows(const fmatvec::Mat &A, const fmatvec::RangeV &I);
 
  fmatvec::Mat condenseMatrixCols(const fmatvec::Mat &A, const fmatvec::RangeV &I);
 
  fmatvec::SymMat condenseMatrix(const fmatvec::SymMat &A,const fmatvec::RangeV &I);
 
  void MapleOutput(const fmatvec::Mat &A, const std::string &MatName, const std::string &file);
 
  void MapleOutput(const fmatvec::SymMat &C, const std::string &MatName, const std::string &file);
 
  class FlexibleBody2s13 : public FlexibleBody2s {
 
    public:
      enum LockType { innerring,outerring };
 
      FlexibleBody2s13(const std::string &name);
 
       ~FlexibleBody2s13() override = default;
 
      /* INHERITED INTERFACE OF OBJECTINTERFACE */
       void updateh(int j=0) override;
       void updatedhdz() override;
      /******************************************/
 
      /* INHERITED INTERFACE OF OBJECT */
       void updateM() override;
       void updateLLM() override { }
 
      /* INHERITED INTERFACE OF ELEMENT */
       void plot() override;
      /***************************************************/
 
      /* GETTER/SETTER */
      void setRadius(double Ri_,double Ra_) { Ri = Ri_; Ra = Ra_; }
      void setEModul(double E_) { E = E_; }
      void setPoissonRatio(double nu_) { nu = nu_; }
      void setThickness(const fmatvec::Vec &d_) { d = d_; }
      fmatvec::Vec getThickness() const { return d; }
      void setDensity(double rho_) { rho = rho_; }
      int getReferenceDegreesOfFreedom() const { return RefDofs; }
      int getRadialNumberOfElements() const { return nr; }
      int getAzimuthalNumberOfElements() const { return nj; }
      double getInnerRadius() const { return Ri; }
      double getOuterRadius() const { return Ra; }
      double getAzimuthalDegree() const { return degU; }
      double getRadialDegree() const { return degV; }
      fmatvec::SqrMat3& evalA() { if(updAG) updateAG(); return A; }
      fmatvec::SqrMat3& evalG() { if(updAG) updateAG(); return G; }
      void setReferenceInertia(double m0_, fmatvec::SymMat3 J0_) { m0 = m0_; J0 = J0_; }
      void setLockType(LockType LT_) { LType = LT_; }
      /***************************************************/
 
      void setNumberElements(int nr_,int nj_);
 
      double computePotentialEnergy() override { return 0.5*q.T()*K*q; }
 
      virtual fmatvec::Vec transformCW(const fmatvec::Vec& WrPoint) = 0;
 
      void resetUpToDate() override;
 
      void updateExt();
 
      const fmatvec::Vec& evalqExt() { if(updExt) updateExt(); return qext; }
      const fmatvec::Vec& evaluExt() { if(updExt) updateExt(); return uext; }
 
      virtual fmatvec::Vec3 evalPosition() { return fmatvec::Vec3(); }
      virtual fmatvec::SqrMat3 evalOrientation() { return fmatvec::SqrMat3(fmatvec::EYE); }
 
    protected:
      int Elements;
 
      int NodeDofs;
 
      int RefDofs;
 
      double E;
 
      double nu;
 
      double rho;
 
      fmatvec::Vec d;
 
      double Ri, Ra;
 
      double dr, dj;
 
      double m0;
 
      fmatvec::SymMat3 J0;
 
      int degV, degU;
 
      int drawDegree;
 
      std::vector<fmatvec::Vec> ElementalNodes;
 
      int currentElement;
 
      fmatvec::SymMat MConst;
 
      fmatvec::SymMat K;
 
      int nr, nj, Nodes;
 
      fmatvec::Mat NodeCoordinates;
 
      fmatvec::Matrix<fmatvec::General,fmatvec::Ref,fmatvec::Ref,int> ElementNodeList;
 
      int Dofs;
 
      LockType LType;
 
      fmatvec::RangeV ILocked;
 
      fmatvec::Vec qext, uext;
 
      fmatvec::SqrMat3 A;
 
      fmatvec::SqrMat3 G;
 
      /*
       * \brief Jacobian for condensation with size Dofs x qSize
       */
      fmatvec::Mat Jext;
 
      NurbsDisk2s *contour;
 
      void BuildElement(const fmatvec::Vec &s);
 
      virtual void initMatrices() = 0;
 
      virtual void updateAG() = 0;
 
      double computeThickness(const double &r_);
 
      bool updExt, updAG;
  };
 
}
 
#endif /* FLEXIBLEBODY2S13_H_ */