single_contact.h

/* Copyright (C) 2004-2014 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 _SINGLE_CONTACT_H_
#define _SINGLE_CONTACT_H_
 
#include <mbsim/links/contour_link.h>
 
namespace MBSim {
 
  class GeneralizedForceLaw;
  class GeneralizedImpactLaw;
  class FrictionForceLaw;
  class FrictionImpactLaw;
 
  class SingleContact: public ContourLink {
 
    friend class Contact;
    friend class MaxwellContact;
 
    public:
      SingleContact(const std::string &name="") : ContourLink(name) { }
 
      void resetUpToDate() override;
 
      bool isSticking() const;
 
      const double& evalGeneralizedNormalForce() { if(updlaN) updateGeneralizedNormalForce(); return lambdaN; }
      const fmatvec::VecV& evalGeneralizedTangentialForce() { if(updlaT) updateGeneralizedTangentialForce(); return lambdaT; }
 
      double& getGeneralizedNormalForce(bool check=true) {  assert((not check) or (not updlaN)); return lambdaN; }
 
      const double& evallaN();
      const fmatvec::Vec& evallaT();
 
      const double& evalLaN();
      const fmatvec::Vec& evalLaT();
 
      const double& evalgdnN();
      const fmatvec::Vec& evalgdnT();
 
      const double& evalgddN();
      const fmatvec::Vec& evalgddT();
 
      /* INHERITED INTERFACE OF LINKINTERFACE */
      void updateGeneralizedNormalForce() { (this->*updateGeneralizedNormalForce_)(); updlaN = false; }
      void updateGeneralizedTangentialForce() { (this->*updateGeneralizedTangentialForce_)(); updlaT = false; }
      void updateGeneralizedNormalForceS();
      void updateGeneralizedNormalForceM();
      void updateGeneralizedNormalForceP();
      void updateGeneralizedTangentialForceS();
      void updateGeneralizedTangentialForceM();
      void updateGeneralizedTangentialForce0() { }
      void (SingleContact::*updateGeneralizedNormalForce_)();
      void (SingleContact::*updateGeneralizedTangentialForce_)();
      void updateGeneralizedForces() override;
      void updateGeneralizedPositions() override;
      void updateGeneralizedVelocities() override;
      void updatePositions(Frame *frame) override;
      void updateg() override;
      void updategd() override;
      void updateh(int i=0) override;
      void updateW(int i=0) override;
      void updateV(int i=0) override;
      void updatewb() override;
      void updateStopVector() override;
      void updateStopVectorParameters() override;
      /***************************************************/
 
      /* INHERITED INTERFACE OF LINK */
      void updatelaRef(fmatvec::Vec& ref) override;
      void updateLaRef(fmatvec::Vec& ref) override;
      void updategdRef(fmatvec::Vec& ref) override;
      void calcSize() override;
      void calclaSize(int j) override;
      void calcgSize(int j) override;
      void calcgdSize(int j) override;
      void calcrFactorSize(int j) override;
      void calcsvSize() override;
      void calcLinkStatusSize() override;
      void calcLinkStatusRegSize() override;
      void init(InitStage stage, const InitConfigSet &config) override;
      bool isSetValued() const override;
      bool isSingleValued() const override;
      void updateLinkStatus() override;
      void updateLinkStatusReg() override;
      bool isActive() const override;
      bool gActiveChanged() override;
      bool detectImpact() override;
      void solveImpactsFixpointSingle() override;
      void solveConstraintsFixpointSingle() override;
      void solveImpactsGaussSeidel() override;
      void solveConstraintsGaussSeidel() override;
      void solveImpactsRootFinding() override;
      void solveConstraintsRootFinding() override;
      void jacobianConstraints() override;
      void jacobianImpacts() override;
      void updaterFactors() override;
      void checkConstraintsForTermination() override;
      void checkImpactsForTermination() override;
      void checkActive(int j) override;
      void LinearImpactEstimation(double t, fmatvec::Vec &gInActive_,fmatvec::Vec &gdInActive_,int *IndInActive_,fmatvec::Vec &gAct_,int *IndActive_) override;
      void SizeLinearImpactEstimation(int *sizeInActive_, int *sizeActive_) override;
 
      /***************************************************/
 
      /* INHERITED INTERFACE OF ELEMENT */
      /***************************************************/
 
      /* GETTER / SETTER */
      void setNormalForceLaw(GeneralizedForceLaw *fcl_) { fcl = fcl_; }
      GeneralizedForceLaw * getNormalForceLaw() const { return fcl; }
      void setNormalImpactLaw(GeneralizedImpactLaw *fnil_) { fnil = fnil_; }
      void setTangentialForceLaw(FrictionForceLaw *fdf_) { fdf = fdf_; }
      FrictionForceLaw * getTangentialForceLaw() const { return fdf; }
      void setTangentialImpactLaw(FrictionImpactLaw *ftil_) { ftil = ftil_; }
      /***************************************************/
 
      virtual int getFrictionDirections() const;
 
      void calccorrSize(int j) override;
      void updatecorr(int j) override;
 
      void checkRoot() override;
 
      bool isNormalForceLawSetValued() const;
      bool isTangentialForceLawSetValued() const;
      bool isNormalForceLawSetValuedAndActive() const { return isNormalForceLawSetValued() and gdActive[normal]; }
      bool isTangentialForceLawSetValuedAndActive() const { return isTangentialForceLawSetValued() and gdActive[tangential]; }
 
    protected:
      GeneralizedForceLaw *fcl{nullptr};
 
      FrictionForceLaw *fdf{nullptr};
      
      GeneralizedImpactLaw *fnil{nullptr};
      
      FrictionImpactLaw *ftil{nullptr};
 
      fmatvec::Vec laN, LaN;
 
      fmatvec::Vec laT, LaT;
 
      fmatvec::Vec gdN;
 
      fmatvec::Vec gdT;
 
      unsigned int gActive{0}, gActive0{0};
 
      enum Direction {
        normal,
        tangential,
        DirectionDIM
      };
 
      std::array<unsigned int, DirectionDIM> gdActive;
 
      std::array<unsigned int, DirectionDIM> gddActive;
 
      fmatvec::Vec gdnN, gdnT;
      
      fmatvec::Vec gddN, gddT;
 
      double lambdaN;
      fmatvec::VecV lambdaT;
 
      bool updlaN{true}, updlaT{true};
 
      fmatvec::Vec gdTDir;
 
      int rootID{0};
  };
 
}
 
#endif /* _SINGLE_CONTACT_H_ */