plate_polynomialfrustum.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: martin.o.foerg@googlemail.com
 */
 
#ifndef AREA_POLYNOMIALFRUSTUM_H_
#define AREA_POLYNOMIALFRUSTUM_H_
 
#include "contact_kinematics.h"
 
#include <mbsim/contours/polynomial_frustum.h>
#include <mbsim/contours/plate.h>
#include <mbsim/numerics/nonlinear_algebra/multi_dimensional_newton_method.h>
#include <mbsim/contact_kinematics/point_polynomialfrustum.h>
 
namespace MBSim {
 
  class edgePolyFrustum : public Function<fmatvec::Vec(fmatvec::Vec)> {
    public:
      edgePolyFrustum(const PolynomialFrustum * frustum_);
 
      ~edgePolyFrustum() override;
 
      void setAdir(const fmatvec::Vec3 & A_, const fmatvec::Vec3 & dir_);
 
      fmatvec::Vec operator()(const fmatvec::Vec &xin) override;
 
    protected:
      const PolynomialFrustum * frustum;
 
      fmatvec::Vec A;
 
      fmatvec::Vec dir;
  };
 
  class edgePolyFrustumCriteria : public CriteriaFunction {
    public:
      edgePolyFrustumCriteria(const double & tolerance_ = 1e-10);
 
      ~edgePolyFrustumCriteria() override= default;;
 
      void setFrustumHeight(const double & frustumHeight_) {
        frustumHeight = frustumHeight_;
      }
 
      void setStartingXCoordinate(const double & ax_) {
        ax = ax_;
      }
 
      void setdirectionXCoordinate(const double & dx_) {
        dx = dx_;
      }
 
      /* INHERITED INTERFACE */
      int operator ()(const fmatvec::Vec &xin) override;
      bool isBetter(const fmatvec::Vec &x, const fmatvec::Vec & fVal = fmatvec::Vec(0,fmatvec::NONINIT)) override;
      void clear() override{criteriaResults.clear();}
      /*END - INHERITED INTERFACE*/
 
      const std::vector<double> & getResults() {
        return criteriaResults;
      }
 
    protected:
      bool inBounds(const double & t);
      double tolerance;
 
      double frustumHeight{-1};
 
      std::vector<double> criteriaResults;
 
      double ax{0.};
 
      double dx{0.};
  };
 
  class ContactKinematicsPlatePolynomialFrustum : public MBSim::ContactKinematics {
    public:
      ContactKinematicsPlatePolynomialFrustum();
      ~ContactKinematicsPlatePolynomialFrustum() override;
 
      /* INHERITED INTERFACE OF CONTACTKINEAMTICS */
      void assignContours(const std::vector<Contour*> &contour) override;
      void updateg(SingleContact &contact, int i=0) override;
 
      void setGridSizeY(int gridSizeY_);
      void setGridSizeZ(int gridSizeZ_);
 
    protected:
      void setFrustumOrienationKinematics(const double & x, const double & phi, SingleContact &contact);
 
      /***************************************************/
      bool cpLocationInPlate(SingleContact &contact);
 
      bool gridContact(SingleContact &contact);
 
      bool cornerContact(SingleContact &contact);
 
      bool edgeContact(SingleContact &contact);
 
      fmatvec::Vec3 computeContourPointFrustum(const double & x, const fmatvec::Vec3 & n);
 
      fmatvec::Vec3 computeContourPoint(const double & x, const fmatvec::Vec3 & n);
 
      int checkPossibleContactPoint(const double & x, const fmatvec::Vec3 & n);
 
      double distance2Plate(const fmatvec::Vec3 & point);
 
      void updateGrid();
 
      int iplate{-1};
 
      int ifrustum{-1};
 
      Plate *plate{nullptr};
 
      PolynomialFrustum *frustum{nullptr};
 
      double signh{1.};
 
      int gridSizeY{5};
 
      int gridSizeZ{5};
 
      double x1{-1};
 
      double x2{-1};
 
      fmatvec::Vec3 cornerPoints[4];
 
      std::vector<std::vector<fmatvec::Vec3>> gridPoints;
 
      MBSim::projectPointAlongNormal * funcProjectAlongNormal{nullptr};
 
      MBSim::MultiDimensionalNewtonMethod newtonProjectAlongNormal;
 
      MBSim::projectPointAlongNormalJacobian * jacobianProjectAlongNormal{nullptr};
 
      GlobalResidualCriteriaFunction criteriaProjectAlongNormal;
 
      MBSim::StandardDampingFunction dampingProjectAlongNormal;
 
      edgePolyFrustum * funcEdge{nullptr};
 
      MBSim::MultiDimensionalNewtonMethod newtonEdge;
 
      MBSim::NumericalNewtonJacobianFunction jacobianEdge;
 
      edgePolyFrustumCriteria criteriaEdge;
 
      MBSim::StandardDampingFunction dampingEdge;
 
      int ilast{-1};
 
      fmatvec::Vec xi;
 
      fmatvec::Vec2 zeta;
  };
 
} /* namespace MBSim */
#endif /* AREA_POLYNOMIALFRUSTUM_H_ */