linear_external_ffr.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 _FLEXIBLE_BODY_LINEAR_EXTERNAL_FFR_H_
#define _FLEXIBLE_BODY_LINEAR_EXTERNAL_FFR_H_
 
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cstdlib>
 
#include "mbsim/frames/frame.h"
 
#include "mbsimFlexibleBody/flexible_body.h"
#include "mbsimFlexibleBody/flexible_body/fe/linear_external_lumped_node.h"
 
#include "mbsimFlexibleBody/frames/node_frame.h"
 
//namespace unitTest{
//  class linearExternalFFRTest;
//}
 
namespace MBSimFlexibleBody {
 
  class NodeFrame;
  
  class FlexibleBodyLinearExternalFFR : public FlexibleBodyContinuum<fmatvec::Vec> /*, public FlexibleContourBody */{
    public:
      FlexibleBodyLinearExternalFFR(const std::string &name);
 
      ~FlexibleBodyLinearExternalFFR() override = default;
 
      /* INHERITED INTERFACE OF FLEIBLE BODY CONTOUR */
      virtual int getNumberElements() const { return nNodes; }
      virtual double getLength() const;
      virtual bool isOpenStructure() const { return openStructure; }
      /***************************************************/
 
      /* INHERITED INTERFACE OF FLEXIBLE BODY CONTINUUM */
      using FlexibleBodyContinuum<fmatvec::Vec>::addFrame;
      /***************************************************/
 
      /* INHERITED INTERFACE OF OBJECTINTERFACE */
      void updateM() override;
      /***************************************************/
 
      /* INHERITED INTERFACE OF FLEXIBLE BODY */
      void BuildElements() override;
      void GlobalVectorContribution(int CurrentElement, const fmatvec::Vec& locVec, fmatvec::Vec& gloVec) override;
      void GlobalMatrixContribution(int CurrentElement, const fmatvec::Mat& locMat, fmatvec::Mat& gloMat) override;
      void GlobalMatrixContribution(int CurrentElement, const fmatvec::SymMat& locMat, fmatvec::SymMat& gloMat) override;
      void updateh(int k = 0) override;
      /***************************************************/
 
      /* INHERITED INTERFACE OF OBJECT */
      void init(InitStage stage, const MBSim::InitConfigSet &config) override;
      void calcqSize() override;
      void calcuSize(int j) override;
      /***************************************************/
 
      /* INHERITED INTERFACE OF ELEMENT */
      /***************************************************/
 
      /* GETTER AND SETTER */
      void setNumberOfModes(int nf_) {
        nf = nf_;
      }
 
      int getNumberModes() const {
        return nf;
      }
 
      MBSim::Frame * getFloatingFrameOfReference() {
        return FFR;
      }
 
      const fmatvec::Vec3 getModeShapeVector(int node, int column) const;
 
      void readFEMData(const std::string &inFilePath, const bool millimeterUnits, bool output = false);
 
      void enableFramePlot(double size = 1e-3, fmatvec::VecInt numbers = fmatvec::VecInt(0));
 
      void resetUpToDate() override;
      const fmatvec::SqrMat3& evalA() { if(updAG) updateAGbarGbardot(); return A; }
      const fmatvec::SqrMat3& evalG_bar() { if(updAG) updateAGbarGbardot(); return G_bar; }
      const fmatvec::SqrMat3& evalG_bar_Dot() { if(updAG) updateAGbarGbardot(); return G_bar_Dot; }
      const fmatvec::Vec& evalQv() { if(updQv) updateQv(); return Qv; }
 
      void updatePositions(MBSim::Frame *frame) override;
      void updateVelocities(MBSim::Frame *frame) override;
      void updateAccelerations(MBSim::Frame *frame) override;
      void updateJacobians(MBSim::Frame *frame, int j=0) override;
      void updateGyroscopicAccelerations(MBSim::Frame *frame) override;
 
      void updatePositions(int nodeIndex) override;
      void updateVelocities(int nodeIndex) override;
      void updateAccelerations(int nodeIndex) override;
      void updateJacobians(int nodeIndex, int j=0) override;
      void updateGyroscopicAccelerations(int nodeIndex) override;
 
      fmatvec::Vec3 evalLocalPosition(int i);
 
    protected:
      void initM();
 
      void initQv();
 
      void updateQv();
 
      void computeShapeIntegrals();
 
      void updateAGbarGbardot();
 
      int nNodes;
 
      MBSim::Frame * FFR;
 
      fmatvec::Vec3 I_1;
 
      fmatvec::SymMat3 I_kl;
 
      fmatvec::Mat S_bar;
 
      fmatvec::SqrMat S_kl_bar[3][3];
 
      fmatvec::RowVec I_kl_bar[3][3];
 
      fmatvec::SymMat3 I_ThetaTheta_bar;
 
      fmatvec::Mat I_ThetaF_bar;
 
      fmatvec::SymMat K;
 
      fmatvec::SymMat KFull;
 
      fmatvec::SqrMat3 G_bar;
 
      fmatvec::SqrMat3 G_bar_Dot;
 
      fmatvec::SqrMat3 A;
 
      double M_RR{0};
 
      fmatvec::SymMat M_FF;
 
      fmatvec::Vec Qv;
 
      fmatvec::Vec mij;
 
      fmatvec::Mat phiFull;
 
      fmatvec::Mat phi;
 
      std::vector<fmatvec::Vec3> u0;
 
      int nf;
 
      bool openStructure;
 
      bool updAG, updQv;
  };
  
}
 
#endif /* _FLEXIBLE_BODY_LINEAR_EXTERNAL_FFR_H_ */