maxwell_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 _MAXWELL_CONTACT_H_
#define _MAXWELL_CONTACT_H_
 
#include <mbsim/links/single_contact.h>
#include <mbsim/numerics/linear_complementarity_problem/linear_complementarity_problem.h>
#include <map>
 
namespace MBSim {
 
  class ContactKinematics;
  class GeneralizedForceLaw;
  class GeneralizedImpactLaw;
  class FrictionForceLaw;
  class FrictionImpactLaw;
  class InfluenceFunction;
 
  class MaxwellContact : public Link {
    public:
      MaxwellContact(const std::string &name = "");
 
      ~MaxwellContact() override;
 
      /* INHERITED INTERFACE OF LINKINTERFACE */
      void updatewb() override;
      void updateW(int i = 0) override;
      void updateV(int i = 0) override;
      void updateh(int i = 0) override;
      void updateg() override;
      void updategd() override;
      void updateStopVector() override;
      void updateJacobians(int j = 0) override;
      /***************************************************/
 
      /* INHERITED INTERFACE OF LINK */
      void updateWRef(fmatvec::Mat &ref, int j = 0) override;
      void updateVRef(fmatvec::Mat &ref, int j = 0) override;
      void updatehRef(fmatvec::Vec &hRef, int j = 0) override;
      void updaterRef(fmatvec::Vec &hRef, int j = 0) override;
      void updatewbRef(fmatvec::Vec &ref) override;
      void updatelaRef(fmatvec::Vec& ref) override;
      void updateLaRef(fmatvec::Vec& ref) override;
      void updategRef(fmatvec::Vec& ref) override;
      void updategdRef(fmatvec::Vec& ref) override;
      void updateresRef(fmatvec::Vec& ref) override;
      void updaterFactorRef(fmatvec::Vec &ref) override;
      void updatesvRef(fmatvec::Vec &ref) override;
      void updatejsvRef(fmatvec::VecInt &ref) override;
      void updateLinkStatusRef(fmatvec::VecInt &LinkStatusParent) override;
      void updateLinkStatusRegRef(fmatvec::VecInt &LinkStatusRegParent) 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 setGeneralizedForceTolerance(double tol) override;
      void setGeneralizedImpulseTolerance(double tol) override;
      void setGeneralizedRelativePositionTolerance(double tol) override;
      void setGeneralizedRelativeVelocityTolerance(double tol) override;
      void setGeneralizedRelativeAccelerationTolerance(double tol) override;
      void setrMax(double rMax_) override;
      void setLinkStatusInd(int LinkStatusInd_) override;
      void setLinkStatusRegInd(int LinkStatusRegInd_) override;
      void setsvInd(int svInd_) override;
      void setlaInd(int laInd_) override;
      void setgInd(int gInd_) override;
      void setgdInd(int gdInd_) override;
      void setrFactorInd(int rFactorInd_) 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;
      void updatecorrRef(fmatvec::Vec& ref) override;
      void updatecorr(int j) override;
      void calccorrSize(int j) override;
      void setcorrInd(int corrInd_) override;
      void checkRoot() override;
      /***************************************************/
 
      /* INHERITED INTERFACE OF ELEMENT */
      void plot() override;
      void setDynamicSystemSolver(DynamicSystemSolver *sys) override;
      /***************************************************/
 
      void resetUpToDate() override;
 
      /* GETTER / SETTER */
 
      void setNormalForceLaw(GeneralizedForceLaw *fcl_);
      GeneralizedForceLaw * getNormalForceLaw() const { return fcl; }
      void setNormalImpactLaw(GeneralizedImpactLaw *fnil_);
      void setTangentialForceLaw(FrictionForceLaw *fdf_);
      void setTangentialImpactLaw(FrictionImpactLaw *ftil_);
      void setContactKinematics(ContactKinematics* ck, size_t index = 0) {
        assert(index < contactKinematics.size());
        contactKinematics[index] = ck;
      }
      ContactKinematics* getContactKinematics(size_t index = 0) const {
        assert(index < contactKinematics.size());
        return contactKinematics[index];
      }
 
      ContactKinematics* findContactKinematics(const std::string& cKName) const {
        int pos = find(ckNames.begin(), ckNames.end(), cKName) - ckNames.begin();
        if (pos < static_cast<int>(ckNames.size())) {
          return contactKinematics[pos];
        }
        throwError("Name of contact Kinematics is not valid");
        return nullptr;
      }
 
      const std::vector<std::vector<SingleContact>> & getSubcontacts() const {
        return contacts;
      }
 
      virtual void setPlotFeatureContactKinematics(std::string cKName, std::size_t pf, bool value);
      /***************************************************/
 
      virtual int getFrictionDirections();
 
      void connect(Contour *contour1, Contour* contour2, ContactKinematics* contactKinematics = nullptr, const std::string & name = "");
 
      Contour* getContour(int i, int j=0) { return contour[i][j]; }
 
      SingleContact& getSingleContact(int i, int j=0) { return contacts[i][j]; }
 
      void initializeUsingXML(xercesc::DOMElement *element) override;
 
      void setGlobalSearch(bool gS_) { gS = gS_; }
      void setInitialGlobalSearch(bool iGS_) { iGS = iGS_; }
      void setInitialGuess(const fmatvec::MatV &zeta0_) { zeta0 <<= zeta0_; }
 
      void setTolerance(double tol_) { tol = tol_; }
 
      virtual void initializeContourCouplings();
 
      void addContourCoupling(Contour *contour1, Contour *contour2, InfluenceFunction *fct);
 
      void setDampingCoefficient(double d) { dampingCoefficient = d; }
 
      void setGapLimit(double gLim_) { gLim = gLim_; }
 
      virtual void updatePossibleContactPoints();
 
      virtual void updateInfluenceMatrix();
 
      void updateRigidBodyGap();
 
      virtual double computeInfluenceCoefficient(const std::pair<int, int> & contactIndex);
 
      virtual double computeInfluenceCoefficient(const std::pair<int, int> & contactIndex, const std::pair<int, int> & couplingContactIndex);
 
      /*
       * \brief computes the "material constant" to have a good guess for the lambda-vector
       */
      virtual void computeMaterialConstant();
 
      void updateGeneralizedPositions() override;
      void updateGeneralizedForces() override;
 
      std::shared_ptr<OpenMBV::Group> getLinksOpenMBVGrp() override { return getOpenMBVGrp(); }
      H5::GroupBase *getLinksPlotGroup() override { return getPlotGroup(); }
 
    protected:
      std::vector<std::vector<SingleContact>> contacts;
 
      std::vector<ContactKinematics*> contactKinematics;
 
      std::vector<std::vector<Contour*>> contour;
 
      std::vector<std::string> ckNames;
 
      std::map<std::pair<std::string, std::size_t>, bool> plotFeatureMap;
 
      GeneralizedForceLaw *fcl;
 
      FrictionForceLaw *fdf;
 
      GeneralizedImpactLaw *fnil;
 
      FrictionImpactLaw *ftil;
 
      bool gS;
      bool iGS;
 
      fmatvec::MatV zeta0;
 
      double tol;
 
      std::vector<std::pair<int, int>> possibleContactPoints;
 
      LinearComplementarityProblem LCP;
 
      fmatvec::SymMat C;
 
      /*
       * \brief vector of rigid body distances(gaps) for the active contacts
       */
      fmatvec::Vec rigidBodyGap;
 
      std::map<std::pair<Contour*, Contour*>, InfluenceFunction*> influenceFunctions;
 
      fmatvec::Vec solution0;
 
      double dampingCoefficient;
 
      double gLim;
 
      double matConst;
 
      bool matConstSetted;
 
    private:
      struct saved_references {
          std::string name1;
          std::string name2;
          std::string contourPairingName;
      };
      std::vector<saved_references> saved_ref;
      struct xmlInfo {
          InfluenceFunction * function;
          std::string name1;
          std::string name2;
      };
      std::vector<xmlInfo> referenceXML;
  };
 
}
 
#endif