MBSim

Project Page
constitutive_laws.h
00001 /* Copyright (C) 2004-2014 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 <mbsim/numerics/linear_complementarity_problem/linear_complementarity_problem.h>
00026 #include <mbsim/contour.h>
00027 #include <mbsim/contact.h>
00028 #include <mbsim/functions/function.h>
00029 #include <fmatvec/atom.h>
00030 
00031 namespace MBSim {
00032 
00033   class SingleContact;
00034   class InfluenceFunction;
00035 
00041   class GeneralizedForceLaw : virtual public fmatvec::Atom {
00042     public:
00046       GeneralizedForceLaw() : Atom(), forceFunc(NULL) {};
00047 
00048       GeneralizedForceLaw(Function<double(double,double)> *forceFunc_) : Atom(), forceFunc(forceFunc_) {};
00049 
00053       virtual ~GeneralizedForceLaw() { if(forceFunc) delete forceFunc; forceFunc = NULL; };
00054 
00055       /* INTERFACE FOR DERIVED CLASSES */
00062       virtual bool isActive(double g, double gTol) { return true; }
00063       virtual bool remainsActive(double s, double sTol) { return true; }
00064 
00073       virtual double project(double la, double gdn, double r, double laMin=0) { return 0; }
00074       virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0) { return fmatvec::Vec(2, fmatvec::INIT, 0); }
00075       virtual double solve(double G, double gdn) { return 0; }
00076 
00084       virtual bool isFulfilled(double la,  double gdn, double tolla, double tolgd, double laMin=0) { return true; }
00085 
00089       virtual bool isSetValued() const = 0;
00090 
00095       virtual void initializeUsingXML(xercesc::DOMElement *element) {}
00096       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00097 
00101       virtual std::string getType() const { return "GeneralizedForceLaw"; }
00102       /***************************************************/
00103       
00111       double operator()(double g, double gd) { assert(forceFunc); return (*forceFunc)(g,gd); }
00112 
00118       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contact) {};
00119 
00125       void setForceFunction(Function<double(double,double)> *forceFunc_) { forceFunc=forceFunc_; }
00126 
00127     protected:
00131       Function<double(double,double)> *forceFunc;
00132   };
00133 
00139   class UnilateralConstraint : public GeneralizedForceLaw {
00140     public:
00144       UnilateralConstraint() {};
00145 
00149       virtual ~UnilateralConstraint() {};
00150 
00151       /* INHERITED INTERFACE */
00152       virtual bool isActive(double g, double gTol) { return g<=gTol; }
00153       virtual bool remainsActive(double gd, double gdTol) { return gd<=gdTol; }
00154       virtual double project(double la, double gdn, double r, double laMin=0);
00155       virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0);
00156       virtual double solve(double G, double gdn);
00157       virtual bool isFulfilled(double la,  double gdn, double tolla, double tolgd, double laMin=0);
00158       virtual bool isSetValued() const { return true; }
00159       /***************************************************/
00160 
00161       bool remainsClosed(double s, double sTol) { return s<=sTol; }  // s = gd/gdd
00162 
00163       virtual std::string getType() const { return "UnilateralConstraint"; }
00164   };
00165 
00172   class BilateralConstraint : public GeneralizedForceLaw {
00173     public:
00177       BilateralConstraint() {};
00178 
00182       virtual ~BilateralConstraint() {};
00183 
00184       /* INHERITED INTERFACE */
00185       virtual bool isActive(double g, double gTol) { return true; }
00186       virtual double project(double la, double gdn, double r, double laMin=0);
00187       virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0);
00188       virtual double solve(double G, double gdn);
00189       virtual bool isFulfilled(double la,  double gdn, double tolla, double tolgd, double laMin=0);
00190       virtual bool isSetValued() const { return true; }
00191       /***************************************************/
00192 
00193       bool remainsClosed(double s, double sTol) { return true; }
00194 
00195       virtual std::string getType() const { return "BilateralConstraint"; }
00196   };
00197 
00203   class GeneralizedImpactLaw : virtual public fmatvec::Atom {
00204     public:
00208       GeneralizedImpactLaw() : fmatvec::Atom() {};
00209 
00213       virtual ~GeneralizedImpactLaw() {};
00214 
00215       /* INTERFACE FOR DERIVED CLASSES */
00216       virtual double project(double la, double gdn, double gda, double r, double laMin=0) = 0;
00217       virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0) = 0;
00218       virtual double solve(double G, double gdn, double gda) = 0;
00219       virtual bool isFulfilled(double la,  double gdn, double gda, double tolla, double tolgd, double laMin=0) = 0;
00220       virtual void initializeUsingXML(xercesc::DOMElement *element) {}
00221       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00222 
00226       virtual std::string getType() const { return "GeneralizedImpactLaw"; }
00227       /***************************************************/
00228   };
00229 
00236   class UnilateralNewtonImpact : public GeneralizedImpactLaw {
00237     public:
00241       UnilateralNewtonImpact() : epsilon(0), gd_limit(1e-2) {};
00242 
00246       UnilateralNewtonImpact(double epsilon_) : epsilon(epsilon_), gd_limit(1e-2) {};
00247 
00251       UnilateralNewtonImpact(double epsilon_, double gd_limit_) : epsilon(epsilon_), gd_limit(gd_limit_) {};
00252 
00256       virtual ~UnilateralNewtonImpact() {};
00257 
00258       /* INHERITED INTERFACE */
00259       virtual double project(double la, double gdn, double gda, double r, double laMin=0);
00260       virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0);
00261       virtual double solve(double G, double gdn, double gda);
00262       virtual bool isFulfilled(double la,  double gdn, double gda, double tolla, double tolgd, double laMin=0);
00263       virtual void initializeUsingXML(xercesc::DOMElement *element);
00264       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00265       virtual std::string getType() const { return "UnilateralNewtonImpact"; }
00266       /***************************************************/
00267 
00268     protected:
00269       double epsilon, gd_limit;
00270   };
00271 
00277   class BilateralImpact : public GeneralizedImpactLaw {
00278     public:
00282       BilateralImpact() {};
00283 
00287       virtual ~BilateralImpact() {};
00288 
00289       /* INHERITED INTERFACE */
00290       virtual double project(double la, double gdn, double gda, double r, double laMin=0);
00291       virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0);
00292       virtual double solve(double G, double gdn, double gda);
00293       virtual bool isFulfilled(double la,  double gdn, double gda, double tolla, double tolgd, double laMin=0);
00294 
00295       virtual std::string getType() const { return "BilateralImpact"; }
00296   };
00297 
00303   class FrictionForceLaw : virtual public fmatvec::Atom {
00304     public:
00308       FrictionForceLaw() : Atom(), frictionForceFunc(NULL) {};
00309 
00310       FrictionForceLaw(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_) : frictionForceFunc(frictionForceFunc_) {};
00311 
00315       virtual ~FrictionForceLaw() { if(frictionForceFunc) delete frictionForceFunc; frictionForceFunc = NULL; };
00316 
00317       /* INTERFACE FOR DERIVED CLASSES */
00318       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r) { return fmatvec::Vec(2); }
00319       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r) { return fmatvec::Mat(2,2); }
00320       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN) { return fmatvec::Vec(2); }
00321       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd) { return true; }
00322       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN) { return fmatvec::Vec(2); }
00323       virtual int getFrictionDirections() = 0;
00324       virtual bool isSticking(const fmatvec::Vec& s, double sTol) = 0;
00325       virtual double getFrictionCoefficient(double gd) { return 0; }
00326       virtual bool isSetValued() const = 0;
00327       virtual void initializeUsingXML(xercesc::DOMElement *element) {}
00328       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00329 
00333       virtual std::string getType() const { return "FrictionForceLaw"; }
00334       /***************************************************/
00335       
00336       fmatvec::Vec operator()(const fmatvec::Vec &gd, double laN) { assert(frictionForceFunc); return (*frictionForceFunc)(gd,laN); }
00337 
00343       void setFrictionForceFunction(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_) { frictionForceFunc=frictionForceFunc_; }
00344 
00345     protected:
00346       Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc;
00347   };
00348 
00354   class PlanarCoulombFriction : public FrictionForceLaw {
00355     public:
00359       PlanarCoulombFriction() : mu(0) {};
00360 
00364       PlanarCoulombFriction(double mu_) : mu(mu_) {};
00365 
00369       virtual ~PlanarCoulombFriction() {}
00370 
00371       /* INHERITED INTERFACE */
00372       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00373       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00374       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00375       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00376       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00377       virtual int getFrictionDirections() { return 1; }
00378       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
00379       virtual double getFrictionCoefficient(double gd) { return mu; }
00380       virtual bool isSetValued() const { return true; }
00381       virtual void initializeUsingXML(xercesc::DOMElement *element);
00382       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00383       virtual std::string getType() const { return "PlanarCoulombFriction"; }
00384       /***************************************************/
00385 
00386       void setFrictionCoefficient(double mu_) { mu = mu_; }
00387 
00388     protected:
00389       double mu;
00390   };
00391 
00397   class SpatialCoulombFriction : public FrictionForceLaw {
00398     public:
00402       SpatialCoulombFriction() : mu(0) {};
00403 
00407       SpatialCoulombFriction(double mu_) : mu(mu_) {};
00408 
00412       virtual ~SpatialCoulombFriction() {}
00413 
00414       /* INHERITED INTERFACE */
00415       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00416       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00417       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00418       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00419       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00420       virtual int getFrictionDirections() { return 2; }
00421       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
00422       virtual double getFrictionCoefficient(double gd) { return mu; }
00423       virtual bool isSetValued() const { return true; }
00424       virtual void initializeUsingXML(xercesc::DOMElement *element);
00425       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00426       virtual std::string getType() const { return "SpatialCoulombFriction"; }
00427       /***************************************************/
00428 
00429       void setFrictionCoefficient(double mu_) { mu = mu_; }
00430 
00431     protected:
00432       double mu;
00433   };
00434 
00441   class PlanarStribeckFriction : public FrictionForceLaw {
00442     public:
00446       PlanarStribeckFriction() : fmu(0) {};
00447 
00451       PlanarStribeckFriction(Function<double(double)> *fmu_) : fmu(fmu_) {};
00452 
00456       virtual ~PlanarStribeckFriction() { if(fmu) delete fmu; fmu=0; }
00457 
00458       /* INHERITED INTERFACE */
00459       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00460       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00461       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00462       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00463       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00464       virtual int getFrictionDirections() { return 1; }
00465       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
00466       virtual double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00467       virtual bool isSetValued() const { return true; }
00468       /***************************************************/
00469 
00470     protected:
00474       Function<double(double)> *fmu;
00475   };
00476 
00483   class SpatialStribeckFriction : public FrictionForceLaw {
00484     public:
00488       SpatialStribeckFriction() : fmu(0) {};
00489 
00493       SpatialStribeckFriction(Function<double(double)> *fmu_) : fmu(fmu_) {};
00494 
00498       virtual ~SpatialStribeckFriction() { if(fmu) delete fmu; fmu=0; }
00499 
00500       /* INHERITED INTERFACE */
00501       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00502       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00503       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00504       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00505       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00506       virtual int getFrictionDirections() { return 2; }
00507       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
00508       virtual double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00509       virtual bool isSetValued() const { return true; }
00510       /***************************************************/
00511 
00512     protected:
00516       Function<double(double)> *fmu;
00517   };
00518 
00524   class FrictionImpactLaw : virtual public fmatvec::Atom {
00525     public:
00529       FrictionImpactLaw() : fmatvec::Atom() {};
00530 
00534       virtual ~FrictionImpactLaw() {};
00535 
00536       /* INTERFACE FOR DERIVED CLASSES */
00537       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r) = 0;
00538       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r) = 0;
00539       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN) = 0;
00540       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd) = 0;
00541       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol) = 0;
00542       virtual int getFrictionDirections() = 0;
00543       virtual void initializeUsingXML(xercesc::DOMElement *element) {}
00544       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00545 
00549       virtual std::string getType() const { return "FrictionImpactLaw"; }
00550       /***************************************************/
00551   };
00552 
00558   class PlanarCoulombImpact : public FrictionImpactLaw {
00559     public:
00563       PlanarCoulombImpact() : mu(0) {};
00564 
00568       PlanarCoulombImpact(double mu_) : mu(mu_) {};
00569 
00573       virtual ~PlanarCoulombImpact() {}
00574 
00575       /* INHERITED INTERFACE */
00576       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00577       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00578       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00579       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00580       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00581       virtual int getFrictionDirections() { return 1; }
00582       virtual void initializeUsingXML(xercesc::DOMElement *element);
00583       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00584       virtual std::string getType() const { return "PlanarCoulombImpact"; }
00585       /***************************************************/
00586 
00587       void setFrictionCoefficient(double mu_) { mu = mu_; }
00588       double getFrictionCoefficient(double gd) { return mu; }
00589 
00590     protected:
00591       double mu;
00592   };
00593 
00599   class SpatialCoulombImpact : public FrictionImpactLaw {
00600     public:
00604       SpatialCoulombImpact() : mu(0) {};
00605 
00609       SpatialCoulombImpact(double mu_) : mu(mu_) {};
00610 
00614       virtual ~SpatialCoulombImpact() {}
00615 
00616       /* INHERITED INTERFACE */
00617       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00618       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00619       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00620       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00621       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00622       virtual int getFrictionDirections() { return 2; }
00623       virtual void initializeUsingXML(xercesc::DOMElement *element);
00624       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00625       virtual std::string getType() const { return "SpatialCoulombImpact"; }
00626       /***************************************************/
00627 
00628       void setFrictionCoefficient(double mu_) { mu = mu_; }
00629       double getFrictionCoefficient(double gd) { return mu; }
00630 
00631     protected:
00632       double mu;
00633   };
00634 
00641   class PlanarStribeckImpact : public FrictionImpactLaw {
00642     public:
00646       PlanarStribeckImpact() : fmu(0) {};
00647 
00651       PlanarStribeckImpact(Function<double(double)> *fmu_) : fmu(fmu_) {};
00652 
00656       virtual ~PlanarStribeckImpact() { if(fmu) delete fmu; fmu=0; }
00657 
00658       /* INHERITED INTERFACE */
00659       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00660       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00661       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00662       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00663       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00664       virtual int getFrictionDirections() { return 1; }
00665       /***************************************************/
00666 
00667       double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00668 
00669     protected:
00673       Function<double(double)> *fmu;
00674   };
00675 
00682   class SpatialStribeckImpact : public FrictionImpactLaw {
00683     public:
00687       SpatialStribeckImpact() : fmu(0) {};
00688 
00692       SpatialStribeckImpact(Function<double(double)> *fmu_) : fmu(fmu_) {};
00693 
00697       virtual ~SpatialStribeckImpact() { if(fmu) delete fmu; fmu=0; }
00698 
00699       /* INHERITED INTERFACE */
00700       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00701       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00702       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00703       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00704       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00705       virtual int getFrictionDirections() { return 2; }
00706       /***************************************************/
00707 
00708       double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00709 
00710     protected:
00714       Function<double(double)> *fmu;
00715   };
00716 
00722   class RegularizedUnilateralConstraint : public GeneralizedForceLaw {
00723     public:
00727       RegularizedUnilateralConstraint() {};
00728 
00729       RegularizedUnilateralConstraint(Function<double(double,double)> *forceFunc_) : GeneralizedForceLaw(forceFunc_) {};
00730 
00734       virtual ~RegularizedUnilateralConstraint() {};
00735 
00736       /* INHERITED INTERFACE */
00737       virtual bool isActive(double g, double gTol) { return g<=gTol; }
00738       virtual bool remainsActive(double s, double sTol) { return s<=sTol; }
00739       virtual bool isSetValued() const { return false; }
00740       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contacts);
00741       /***************************************************/
00742 
00743       virtual void initializeUsingXML(xercesc::DOMElement *element);
00744   };
00745 
00751   class MaxwellUnilateralConstraint : public GeneralizedForceLaw {
00752     public:
00756       MaxwellUnilateralConstraint(const double & damping = 0, const double & gapLimit = 0);
00757 
00761       virtual ~MaxwellUnilateralConstraint();
00762 
00763       /* INHERITED INTERFACE */
00764       virtual bool isActive(double g, double gTol) { return g < gTol ? true : false; }
00765       virtual bool remainsActive(double s, double sTol) {return true; }
00766       virtual bool isSetValued() const { return false; }
00767       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contacts);
00768       /***************************************************/
00769 
00770       virtual void initializeUsingXML(xercesc::DOMElement *element);
00771 
00777       virtual void initializeContourCouplings(Contact* parent);
00778 
00779       /*GETTER - SETTER*/
00780       void setDebuglevel(int debuglevel) {
00781         DEBUGLEVEL = debuglevel;
00782       }
00783       void setLCPSolvingStrategy(LinearComplementarityProblem::LCPSolvingStrategy strategy) {
00784         LCP.setStrategy(strategy);
00785       }
00786       void setLCPJacobianType(LinearComplementarityProblem::JacobianType type) {
00787         LCP.setJacobianType(type);
00788       }
00789       /*****************/
00790 
00799       void addContourCoupling(Contour *contour1, Contour *contour2, InfluenceFunction *fct);
00800 
00801     protected:
00805       virtual void updatePossibleContactPoints(const std::vector<std::vector<SingleContact> > & contacts);
00806 
00812       virtual void updateInfluenceMatrix(std::vector<std::vector<SingleContact> > & contacts);
00813 
00817       void updateRigidBodyGap(const std::vector<std::vector<SingleContact> > & contacts);
00818 
00825       virtual double computeInfluenceCoefficient(std::vector<std::vector<SingleContact> > & contacts, const std::pair<int, int> & contactIndex);
00826 
00834       virtual double computeInfluenceCoefficient(std::vector<std::vector<SingleContact> > & contacts, const std::pair<int, int> & contactIndex, const std::pair<int, int> & couplingContactIndex);
00835 
00836       /*
00837        * \brief computes the "material constant" to have a good guess for the lambda-vector
00838        */
00839       virtual void computeMaterialConstant();
00840 
00847       std::vector<std::pair<int, int> > possibleContactPoints;
00848 
00852       LinearComplementarityProblem LCP;
00853 
00857       fmatvec::SymMat C;
00858 
00859       /*
00860        * \brief vector of rigid body distances(gaps) for the active contacts
00861        */
00862       fmatvec::Vec rigidBodyGap;
00863 
00867       std::map<std::pair<Contour*, Contour*>, InfluenceFunction*> influenceFunctions;
00868 
00872       fmatvec::Vec solution0;
00873 
00877       double dampingCoefficient;
00878 
00882       double gLim;
00883 
00887       double matConst;
00888 
00892       bool matConstSetted;
00893 
00903       int DEBUGLEVEL;
00904 
00905       struct xmlInfo {
00906           InfluenceFunction * function;
00907           std::string name1;
00908           std::string name2;
00909       };
00910       std::vector<xmlInfo> referenceXML;
00911 
00912   };
00913 
00919   class RegularizedBilateralConstraint : public GeneralizedForceLaw {
00920     public:
00924       RegularizedBilateralConstraint() {};
00925 
00926       RegularizedBilateralConstraint(Function<double(double,double)> *forceFunc_) : GeneralizedForceLaw(forceFunc_) {};
00927 
00931       virtual ~RegularizedBilateralConstraint() {};
00932 
00933       /* INHERITED INTERFACE */
00934       virtual bool isActive(double g, double gTol) { return true; }
00935       virtual bool remainsActive(double s, double sTol) { return true; }
00936       virtual bool isSetValued() const { return false; }
00937       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contact);
00938       /***************************************************/
00939 
00940       virtual void initializeUsingXML(xercesc::DOMElement *element);
00941 
00942       virtual std::string getType() const { return "RegularizedBilateralConstraint"; }
00943   };
00944 
00945   class RegularizedPlanarFriction : public FrictionForceLaw {
00946     public:
00947       RegularizedPlanarFriction() {};
00948       RegularizedPlanarFriction(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_) : FrictionForceLaw(frictionForceFunc_) {};
00949       virtual ~RegularizedPlanarFriction() {}
00950       int getFrictionDirections() { return 1; }
00951       bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
00952       bool isSetValued() const { return false; }
00953       virtual void initializeUsingXML(xercesc::DOMElement *element);
00954   };
00955 
00956   class RegularizedSpatialFriction : public FrictionForceLaw {
00957     public:
00958       RegularizedSpatialFriction() {};
00959       RegularizedSpatialFriction(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_) : FrictionForceLaw(frictionForceFunc_) {};
00960       virtual ~RegularizedSpatialFriction() {}
00961       int getFrictionDirections() { return 2; }
00962       bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
00963       bool isSetValued() const { return false; }
00964       virtual void initializeUsingXML(xercesc::DOMElement *element);
00965   };
00966 
00967 }
00968 
00969 #endif /* _CONSTITUTIVE_LAWS_H_ */
00970