MBSim

Project Page
constitutive_laws.h
00001 /* Copyright (C) 2004-2009 MBSim Development Team
00002  * 
00003  * This library is free software; you can redistribute it and/or 
00004  * modify it under the terms of the GNU Lesser General Public 
00005  * License as published by the Free Software Foundation; either 
00006  * version 2.1 of the License, or (at your option) any later version. 
00007  * 
00008  * This library is distributed in the hope that it will be useful, 
00009  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
00010  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00011  * Lesser General Public License for more details. 
00012  *
00013  * You should have received a copy of the GNU Lesser General Public 
00014  * License along with this library; if not, write to the Free Software 
00015  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
00016  *
00017  * Contact: martin.o.foerg@googlemail.com
00018  */
00019 
00020 #ifndef _CONSTITUTIVE_LAWS_H_
00021 #define _CONSTITUTIVE_LAWS_H_
00022 
00023 #include <map>
00024 
00025 #include "fmatvec/fmatvec.h"
00026 
00027 #include <mbsim/numerics/linear_complementarity_problem/linear_complementarity_problem.h>
00028 #include <mbsim/contour.h>
00029 #include <mbsim/contact.h>
00030 #include "mbsim/utils/function.h"
00031 
00032 namespace MBSim {
00033 
00034   class SingleContact;
00035 
00041   class GeneralizedForceLaw {
00042     public:
00046       GeneralizedForceLaw() : forceFunc(NULL) {};
00047 
00048       GeneralizedForceLaw(Function2<double,double,double> *forceFunc_) : forceFunc(forceFunc_) {};
00049 
00053       virtual ~GeneralizedForceLaw() { if(forceFunc) delete forceFunc; forceFunc = NULL; };
00054 
00055       /* INTERFACE FOR DERIVED CLASSES */
00061       virtual bool isActive(double g, double gTol) { return true; }
00062       virtual bool remainsActive(double s, double sTol) { return true; }
00063       virtual double project(double la, double gdn, double r, double laMin=0) { return 0; }
00064       virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0) { return fmatvec::Vec(2, fmatvec::INIT, 0); }
00065       virtual double solve(double G, double gdn) { return 0; }
00066 
00074       virtual bool isFulfilled(double la,  double gdn, double tolla, double tolgd, double laMin=0) { return true; }
00075 
00079       virtual bool isSetValued() const = 0;
00080 
00085       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element) {}
00086       virtual MBXMLUtils::TiXmlElement* writeXMLFile(MBXMLUtils::TiXmlNode *parent);
00087 
00091       virtual std::string getType() const { return "GeneralizedForceLaw"; }
00092       /***************************************************/
00093       
00101       double operator()(double g, double gd, const void * additional=NULL) { assert(forceFunc); return (*forceFunc)(g,gd,additional); }
00102 
00108       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contact) {};
00109 
00115       void setForceFunction(Function2<double,double,double> *forceFunc_) { forceFunc=forceFunc_; }
00116 
00117     protected:
00121       Function2<double,double,double> *forceFunc;
00122   };
00123 
00129   class UnilateralConstraint : public GeneralizedForceLaw {
00130     public:
00134       UnilateralConstraint() {};
00135 
00139       virtual ~UnilateralConstraint() {};
00140 
00141       /* INHERITED INTERFACE */
00142       virtual bool isActive(double g, double gTol) { return g<=gTol; }
00143       virtual bool remainsActive(double gd, double gdTol) { return gd<=gdTol; }
00144       virtual double project(double la, double gdn, double r, double laMin=0);
00145       virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0);
00146       virtual double solve(double G, double gdn);
00147       virtual bool isFulfilled(double la,  double gdn, double tolla, double tolgd, double laMin=0);
00148       virtual bool isSetValued() const { return true; }
00149       /***************************************************/
00150 
00151       bool remainsClosed(double s, double sTol) { return s<=sTol; }  // s = gd/gdd
00152 
00153       virtual std::string getType() const { return "UnilateralConstraint"; }
00154   };
00155 
00162   class BilateralConstraint : public GeneralizedForceLaw {
00163     public:
00167       BilateralConstraint() {};
00168 
00172       virtual ~BilateralConstraint() {};
00173 
00174       /* INHERITED INTERFACE */
00175       virtual bool isActive(double g, double gTol) { return true; }
00176       virtual double project(double la, double gdn, double r, double laMin=0);
00177       virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0);
00178       virtual double solve(double G, double gdn);
00179       virtual bool isFulfilled(double la,  double gdn, double tolla, double tolgd, double laMin=0);
00180       virtual bool isSetValued() const { return true; }
00181       /***************************************************/
00182 
00183       bool remainsClosed(double s, double sTol) { return true; }
00184 
00185       virtual std::string getType() const { return "BilateralConstraint"; }
00186   };
00187 
00193   class GeneralizedImpactLaw {
00194     public:
00198       GeneralizedImpactLaw() {};
00199 
00203       virtual ~GeneralizedImpactLaw() {};
00204 
00205       /* INTERFACE FOR DERIVED CLASSES */
00206       virtual double project(double la, double gdn, double gda, double r, double laMin=0) = 0;
00207       virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0) = 0;
00208       virtual double solve(double G, double gdn, double gda) = 0;
00209       virtual bool isFulfilled(double la,  double gdn, double gda, double tolla, double tolgd, double laMin=0) = 0;
00210       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element) {}
00211       virtual MBXMLUtils::TiXmlElement* writeXMLFile(MBXMLUtils::TiXmlNode *parent);
00212 
00216       virtual std::string getType() const { return "GeneralizedImpactLaw"; }
00217       /***************************************************/
00218   };
00219 
00226   class UnilateralNewtonImpact : public GeneralizedImpactLaw {
00227     public:
00231       UnilateralNewtonImpact() : epsilon(0), gd_limit(1e-2) {};
00232 
00236       UnilateralNewtonImpact(double epsilon_) : epsilon(epsilon_), gd_limit(1e-2) {};
00237 
00241       UnilateralNewtonImpact(double epsilon_, double gd_limit_) : epsilon(epsilon_), gd_limit(gd_limit_) {};
00242 
00246       virtual ~UnilateralNewtonImpact() {};
00247 
00248       /* INHERITED INTERFACE */
00249       virtual double project(double la, double gdn, double gda, double r, double laMin=0);
00250       virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0);
00251       virtual double solve(double G, double gdn, double gda);
00252       virtual bool isFulfilled(double la,  double gdn, double gda, double tolla, double tolgd, double laMin=0);
00253       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00254       virtual MBXMLUtils::TiXmlElement* writeXMLFile(MBXMLUtils::TiXmlNode *parent);
00255       virtual std::string getType() const { return "UnilateralNewtonImpact"; }
00256       /***************************************************/
00257 
00258     protected:
00259       double epsilon, gd_limit;
00260   };
00261 
00267   class BilateralImpact : public GeneralizedImpactLaw {
00268     public:
00272       BilateralImpact() {};
00273 
00277       virtual ~BilateralImpact() {};
00278 
00279       /* INHERITED INTERFACE */
00280       virtual double project(double la, double gdn, double gda, double r, double laMin=0);
00281       virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0);
00282       virtual double solve(double G, double gdn, double gda);
00283       virtual bool isFulfilled(double la,  double gdn, double gda, double tolla, double tolgd, double laMin=0);
00284 
00285       virtual std::string getType() const { return "BilateralImpact"; }
00286   };
00287 
00293   class FrictionForceLaw {
00294     public:
00298       FrictionForceLaw() : frictionForceFunc(NULL) {};
00299 
00300       FrictionForceLaw(Function2<fmatvec::Vec,fmatvec::Vec,double> *frictionForceFunc_) : frictionForceFunc(frictionForceFunc_) {};
00301 
00305       virtual ~FrictionForceLaw() { if(frictionForceFunc) delete frictionForceFunc; frictionForceFunc = NULL; };
00306 
00307       /* INTERFACE FOR DERIVED CLASSES */
00308       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r) { return fmatvec::Vec(2); }
00309       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r) { return fmatvec::Mat(2,2); }
00310       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN) { return fmatvec::Vec(2); }
00311       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd) { return true; }
00312       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN) { return fmatvec::Vec(2); }
00313       virtual int getFrictionDirections() = 0;
00314       virtual bool isSticking(const fmatvec::Vec& s, double sTol) = 0;
00315       virtual double getFrictionCoefficient(double gd) { return 0; }
00316       virtual bool isSetValued() const = 0;
00317       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element) {}
00318       virtual MBXMLUtils::TiXmlElement* writeXMLFile(MBXMLUtils::TiXmlNode *parent);
00319 
00323       virtual std::string getType() const { return "FrictionForceLaw"; }
00324       /***************************************************/
00325       
00326       fmatvec::Vec operator()(const fmatvec::Vec &gd, double laN) { assert(frictionForceFunc); return (*frictionForceFunc)(gd,laN); }
00327 
00333       void setFrictionForceFunction(Function2<fmatvec::Vec,fmatvec::Vec,double> *frictionForceFunc_) { frictionForceFunc=frictionForceFunc_; }
00334 
00335     protected:
00336       Function2<fmatvec::Vec,fmatvec::Vec,double> *frictionForceFunc;
00337   };
00338 
00344   class PlanarCoulombFriction : public FrictionForceLaw {
00345     public:
00349       PlanarCoulombFriction() : mu(0) {};
00350 
00354       PlanarCoulombFriction(double mu_) : mu(mu_) {};
00355 
00359       virtual ~PlanarCoulombFriction() {}
00360 
00361       /* INHERITED INTERFACE */
00362       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00363       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00364       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00365       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00366       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00367       virtual int getFrictionDirections() { return 1; }
00368       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
00369       virtual double getFrictionCoefficient(double gd) { return mu; }
00370       virtual bool isSetValued() const { return true; }
00371       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00372       virtual MBXMLUtils::TiXmlElement* writeXMLFile(MBXMLUtils::TiXmlNode *parent);
00373       virtual std::string getType() const { return "PlanarCoulombFriction"; }
00374       /***************************************************/
00375 
00376       void setFrictionCoefficient(double mu_) { mu = mu_; }
00377 
00378     protected:
00379       double mu;
00380   };
00381 
00387   class SpatialCoulombFriction : public FrictionForceLaw {
00388     public:
00392       SpatialCoulombFriction() : mu(0) {};
00393 
00397       SpatialCoulombFriction(double mu_) : mu(mu_) {};
00398 
00402       virtual ~SpatialCoulombFriction() {}
00403 
00404       /* INHERITED INTERFACE */
00405       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00406       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00407       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00408       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00409       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00410       virtual int getFrictionDirections() { return 2; }
00411       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
00412       virtual double getFrictionCoefficient(double gd) { return mu; }
00413       virtual bool isSetValued() const { return true; }
00414       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00415       virtual MBXMLUtils::TiXmlElement* writeXMLFile(MBXMLUtils::TiXmlNode *parent);
00416       virtual std::string getType() const { return "SpatialCoulombFriction"; }
00417       /***************************************************/
00418 
00419       void setFrictionCoefficient(double mu_) { mu = mu_; }
00420 
00421     protected:
00422       double mu;
00423   };
00424 
00431   class PlanarStribeckFriction : public FrictionForceLaw {
00432     public:
00436       PlanarStribeckFriction() : fmu(0) {};
00437 
00441       PlanarStribeckFriction(Function1<double,double> *fmu_) : fmu(fmu_) {};
00442 
00446       virtual ~PlanarStribeckFriction() { if(fmu) delete fmu; fmu=0; }
00447 
00448       /* INHERITED INTERFACE */
00449       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00450       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00451       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00452       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00453       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00454       virtual int getFrictionDirections() { return 1; }
00455       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
00456       virtual double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00457       virtual bool isSetValued() const { return true; }
00458       /***************************************************/
00459 
00460     protected:
00464       Function1<double,double> *fmu;
00465   };
00466 
00473   class SpatialStribeckFriction : public FrictionForceLaw {
00474     public:
00478       SpatialStribeckFriction() : fmu(0) {};
00479 
00483       SpatialStribeckFriction(Function1<double,double> *fmu_) : fmu(fmu_) {};
00484 
00488       virtual ~SpatialStribeckFriction() { if(fmu) delete fmu; fmu=0; }
00489 
00490       /* INHERITED INTERFACE */
00491       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00492       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00493       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00494       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00495       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00496       virtual int getFrictionDirections() { return 2; }
00497       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
00498       virtual double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00499       virtual bool isSetValued() const { return true; }
00500       /***************************************************/
00501 
00502     protected:
00506       Function1<double,double> *fmu;
00507   };
00508 
00514   class FrictionImpactLaw {
00515     public:
00519       FrictionImpactLaw() {};
00520 
00524       virtual ~FrictionImpactLaw() {};
00525 
00526       /* INTERFACE FOR DERIVED CLASSES */
00527       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r) = 0;
00528       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r) = 0;
00529       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN) = 0;
00530       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd) = 0;
00531       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol) = 0;
00532       virtual int getFrictionDirections() = 0;
00533       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element) {}
00534       virtual MBXMLUtils::TiXmlElement* writeXMLFile(MBXMLUtils::TiXmlNode *parent);
00535 
00539       virtual std::string getType() const { return "FrictionImpactLaw"; }
00540       /***************************************************/
00541   };
00542 
00548   class PlanarCoulombImpact : public FrictionImpactLaw {
00549     public:
00553       PlanarCoulombImpact() : mu(0) {};
00554 
00558       PlanarCoulombImpact(double mu_) : mu(mu_) {};
00559 
00563       virtual ~PlanarCoulombImpact() {}
00564 
00565       /* INHERITED INTERFACE */
00566       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00567       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00568       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00569       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00570       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00571       virtual int getFrictionDirections() { return 1; }
00572       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00573       virtual MBXMLUtils::TiXmlElement* writeXMLFile(MBXMLUtils::TiXmlNode *parent);
00574       virtual std::string getType() const { return "PlanarCoulombImpact"; }
00575       /***************************************************/
00576 
00577       void setFrictionCoefficient(double mu_) { mu = mu_; }
00578       double getFrictionCoefficient(double gd) { return mu; }
00579 
00580     protected:
00581       double mu;
00582   };
00583 
00589   class SpatialCoulombImpact : public FrictionImpactLaw {
00590     public:
00594       SpatialCoulombImpact() : mu(0) {};
00595 
00599       SpatialCoulombImpact(double mu_) : mu(mu_) {};
00600 
00604       virtual ~SpatialCoulombImpact() {}
00605 
00606       /* INHERITED INTERFACE */
00607       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00608       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00609       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00610       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00611       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00612       virtual int getFrictionDirections() { return 2; }
00613       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00614       virtual MBXMLUtils::TiXmlElement* writeXMLFile(MBXMLUtils::TiXmlNode *parent);
00615       virtual std::string getType() const { return "SpatialCoulombImpact"; }
00616       /***************************************************/
00617 
00618       void setFrictionCoefficient(double mu_) { mu = mu_; }
00619       double getFrictionCoefficient(double gd) { return mu; }
00620 
00621     protected:
00622       double mu;
00623   };
00624 
00631   class PlanarStribeckImpact : public FrictionImpactLaw {
00632     public:
00636       PlanarStribeckImpact() : fmu(0) {};
00637 
00641       PlanarStribeckImpact(Function1<double,double> *fmu_) : fmu(fmu_) {};
00642 
00646       virtual ~PlanarStribeckImpact() { if(fmu) delete fmu; fmu=0; }
00647 
00648       /* INHERITED INTERFACE */
00649       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00650       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00651       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00652       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00653       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00654       virtual int getFrictionDirections() { return 1; }
00655       /***************************************************/
00656 
00657       double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00658 
00659     protected:
00663       Function1<double,double> *fmu;
00664   };
00665 
00672   class SpatialStribeckImpact : public FrictionImpactLaw {
00673     public:
00677       SpatialStribeckImpact() : fmu(0) {};
00678 
00682       SpatialStribeckImpact(Function1<double,double> *fmu_) : fmu(fmu_) {};
00683 
00687       virtual ~SpatialStribeckImpact() { if(fmu) delete fmu; fmu=0; }
00688 
00689       /* INHERITED INTERFACE */
00690       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00691       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00692       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00693       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00694       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00695       virtual int getFrictionDirections() { return 2; }
00696       /***************************************************/
00697 
00698       double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00699 
00700     protected:
00704       Function1<double,double> *fmu;
00705   };
00706 
00712   class RegularizedUnilateralConstraint : public GeneralizedForceLaw {
00713     public:
00717       RegularizedUnilateralConstraint() {};
00718 
00719       RegularizedUnilateralConstraint(Function2<double,double,double> *forceFunc_) : GeneralizedForceLaw(forceFunc_) {};
00720 
00724       virtual ~RegularizedUnilateralConstraint() {};
00725 
00726       /* INHERITED INTERFACE */
00727       virtual bool isActive(double g, double gTol) { return g<=gTol; }
00728       virtual bool remainsActive(double s, double sTol) { return s<=sTol; }
00729       virtual bool isSetValued() const { return false; }
00730       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contacts);
00731       /***************************************************/
00732 
00733       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00734   };
00735 
00741   class MaxwellUnilateralConstraint : public GeneralizedForceLaw {
00742     public:
00746       MaxwellUnilateralConstraint(const double & damping = 0, const double & gapLimit = 0);
00747 
00751       virtual ~MaxwellUnilateralConstraint() {};
00752 
00753       /* INHERITED INTERFACE */
00754       virtual bool isActive(double g, double gTol) { return g < gTol ? true : false; }
00755       virtual bool remainsActive(double s, double sTol) {return true; }
00756       virtual bool isSetValued() const { return false; }
00757       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contacts);
00758       /***************************************************/
00759 
00760       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00761 
00767       virtual void initializeContourCouplings(Contact* parent);
00768 
00769       /*GETTER - SETTER*/
00770       void setDebuglevel(int debuglevel) {
00771         DEBUGLEVEL = debuglevel;
00772       }
00773       void setLCPSolvingStrategy(LCPSolvingStrategy strategy) {
00774         LCP.setStrategy(strategy);
00775       }
00776       /*****************/
00777 
00786       void addContourCoupling(Contour *contour1, Contour *contour2, InfluenceFunction *fct);
00787 
00788     protected:
00792       virtual void updatePossibleContactPoints(const std::vector<std::vector<SingleContact> > & contacts);
00793 
00799       virtual void updateInfluenceMatrix(std::vector<std::vector<SingleContact> > & contacts);
00800 
00804       void updateRigidBodyGap(const std::vector<std::vector<SingleContact> > & contacts);
00805 
00812       virtual double computeInfluenceCoefficient(std::vector<std::vector<SingleContact> > & contacts, const std::pair<int, int> & contactIndex);
00813 
00821       virtual double computeInfluenceCoefficient(std::vector<std::vector<SingleContact> > & contacts, const std::pair<int, int> & contactIndex, const std::pair<int, int> & couplingContactIndex);
00822 
00823       /*
00824        * \brief computes the "material constant" to have a good guess for the lambda-vector
00825        */
00826       virtual void computeMaterialConstant();
00827 
00834       std::vector<std::pair<int, int> > possibleContactPoints;
00835 
00839       LinearComplementarityProblem LCP;
00840 
00844       fmatvec::SymMat C;
00845 
00846       /*
00847        * \brief vector of rigid body distances(gaps) for the active contacts
00848        */
00849       fmatvec::Vec rigidBodyGap;
00850 
00854       std::map<std::pair<Contour*, Contour*>, InfluenceFunction*> influenceFunctions;
00855 
00859       fmatvec::Vec solution0;
00860 
00864       double dampingCoefficient;
00865 
00869       double gLim;
00870 
00874       double matConst;
00875 
00879       bool matConstSetted;
00880 
00890       int DEBUGLEVEL;
00891 
00892       struct xmlInfo {
00893           InfluenceFunction * function;
00894           std::string name1;
00895           std::string name2;
00896       };
00897       std::vector<xmlInfo> referenceXML;
00898 
00899   };
00900 
00906   class RegularizedBilateralConstraint : public GeneralizedForceLaw {
00907     public:
00911       RegularizedBilateralConstraint() {};
00912 
00913       RegularizedBilateralConstraint(Function2<double,double,double> *forceFunc_) : GeneralizedForceLaw(forceFunc_) {};
00914 
00918       virtual ~RegularizedBilateralConstraint() {};
00919 
00920       /* INHERITED INTERFACE */
00921       virtual bool isActive(double g, double gTol) { return true; }
00922       virtual bool remainsActive(double s, double sTol) { return true; }
00923       virtual bool isSetValued() const { return false; }
00924       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contact);
00925       /***************************************************/
00926 
00927       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00928 
00929       virtual std::string getType() const { return "RegularizedBilateralConstraint"; }
00930   };
00931 
00932   class RegularizedPlanarFriction : public FrictionForceLaw {
00933     public:
00934       RegularizedPlanarFriction() {};
00935       RegularizedPlanarFriction(Function2<fmatvec::Vec,fmatvec::Vec,double> *frictionForceFunc_) : FrictionForceLaw(frictionForceFunc_) {};
00936       virtual ~RegularizedPlanarFriction() {}
00937       int getFrictionDirections() { return 1; }
00938       bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
00939       bool isSetValued() const { return false; }
00940       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00941   };
00942 
00943   class RegularizedSpatialFriction : public FrictionForceLaw {
00944     public:
00945       RegularizedSpatialFriction() {};
00946       RegularizedSpatialFriction(Function2<fmatvec::Vec,fmatvec::Vec,double> *frictionForceFunc_) : FrictionForceLaw(frictionForceFunc_) {};
00947       virtual ~RegularizedSpatialFriction() {}
00948       int getFrictionDirections() { return 2; }
00949       bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
00950       bool isSetValued() const { return false; }
00951       virtual void initializeUsingXML(MBXMLUtils::TiXmlElement *element);
00952   };
00953 
00954 }
00955 
00956 #endif /* _CONSTITUTIVE_LAWS_H_ */
00957