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/functions/function.h>
00028 #include <fmatvec/atom.h>
00029 
00030 namespace MBSim {
00031 
00032   class Contact;
00033   class SingleContact;
00034   class InfluenceFunction;
00035 
00041   class GeneralizedForceLaw : public Element {
00042     public:
00046       GeneralizedForceLaw(Function<double(double,double)> *forceFunc_=NULL) : Element(uniqueDummyName(this)), forceFunc(forceFunc_) { 
00047         if(forceFunc)
00048           forceFunc->setParent(this);
00049       }
00050 
00054       virtual ~GeneralizedForceLaw() { if(forceFunc) delete forceFunc; forceFunc = NULL; };
00055 
00056       void init(Element::InitStage stage) {
00057         Element::init(stage);
00058         if(forceFunc)
00059           forceFunc->init(stage);
00060       }
00061 
00062       /* INTERFACE FOR DERIVED CLASSES */
00069       virtual bool isActive(double g, double gTol) { return true; }
00070       virtual bool remainsActive(double s, double sTol) { return true; }
00071 
00080       virtual double project(double la, double gdn, double r, double laMin=0) { return 0; }
00081       virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0) { return fmatvec::Vec(2, fmatvec::INIT, 0); }
00082       virtual double solve(double G, double gdn) { return 0; }
00083 
00091       virtual bool isFulfilled(double la,  double gdn, double tolla, double tolgd, double laMin=0) { return true; }
00092 
00096       virtual bool isSetValued() const = 0;
00097 
00102       virtual void initializeUsingXML(xercesc::DOMElement *element) {}
00103       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00104 
00108       virtual std::string getType() const { return "GeneralizedForceLaw"; }
00109       /***************************************************/
00110       
00118       double operator()(double g, double gd) { assert(forceFunc); return (*forceFunc)(g,gd); }
00119 
00125       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contact) {};
00126 
00132       void setForceFunction(Function<double(double,double)> *forceFunc_) { 
00133         forceFunc=forceFunc_; 
00134         forceFunc->setParent(this);
00135       }
00136 
00137     protected:
00141       Function<double(double,double)> *forceFunc;
00142   };
00143 
00149   class UnilateralConstraint : public GeneralizedForceLaw {
00150     public:
00154       UnilateralConstraint() { }
00155 
00159       virtual ~UnilateralConstraint() { }
00160 
00161       /* INHERITED INTERFACE */
00162       virtual bool isActive(double g, double gTol) { return g<=gTol; }
00163       virtual bool remainsActive(double gd, double gdTol) { return gd<=gdTol; }
00164       virtual double project(double la, double gdn, double r, double laMin=0);
00165       virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0);
00166       virtual double solve(double G, double gdn);
00167       virtual bool isFulfilled(double la,  double gdn, double tolla, double tolgd, double laMin=0);
00168       virtual bool isSetValued() const { return true; }
00169       /***************************************************/
00170 
00171       bool remainsClosed(double s, double sTol) { return s<=sTol; }  // s = gd/gdd
00172 
00173       virtual std::string getType() const { return "UnilateralConstraint"; }
00174   };
00175 
00182   class BilateralConstraint : public GeneralizedForceLaw {
00183     public:
00187       BilateralConstraint() { }
00188 
00192       virtual ~BilateralConstraint() { }
00193 
00194       /* INHERITED INTERFACE */
00195       virtual bool isActive(double g, double gTol) { return true; }
00196       virtual double project(double la, double gdn, double r, double laMin=0);
00197       virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0);
00198       virtual double solve(double G, double gdn);
00199       virtual bool isFulfilled(double la,  double gdn, double tolla, double tolgd, double laMin=0);
00200       virtual bool isSetValued() const { return true; }
00201       /***************************************************/
00202 
00203       bool remainsClosed(double s, double sTol) { return true; }
00204 
00205       virtual std::string getType() const { return "BilateralConstraint"; }
00206   };
00207 
00213   class GeneralizedImpactLaw : public Element {
00214     public:
00218       GeneralizedImpactLaw() : Element(uniqueDummyName(this)) { }
00219 
00223       virtual ~GeneralizedImpactLaw() { }
00224 
00225       /* INTERFACE FOR DERIVED CLASSES */
00226       virtual double project(double la, double gdn, double gda, double r, double laMin=0) = 0;
00227       virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0) = 0;
00228       virtual double solve(double G, double gdn, double gda) = 0;
00229       virtual bool isFulfilled(double la,  double gdn, double gda, double tolla, double tolgd, double laMin=0) = 0;
00230       virtual void initializeUsingXML(xercesc::DOMElement *element) {}
00231       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00232 
00236       virtual std::string getType() const { return "GeneralizedImpactLaw"; }
00237       /***************************************************/
00238   };
00239 
00246   class UnilateralNewtonImpact : public GeneralizedImpactLaw {
00247     public:
00251       UnilateralNewtonImpact(double epsilon_=0) : epsilon(epsilon_), gd_limit(1e-2) { }
00252 
00256       UnilateralNewtonImpact(double epsilon_, double gd_limit_) : epsilon(epsilon_), gd_limit(gd_limit_) { }
00257 
00261       virtual ~UnilateralNewtonImpact() { }
00262 
00263       /* INHERITED INTERFACE */
00264       virtual double project(double la, double gdn, double gda, double r, double laMin=0);
00265       virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0);
00266       virtual double solve(double G, double gdn, double gda);
00267       virtual bool isFulfilled(double la,  double gdn, double gda, double tolla, double tolgd, double laMin=0);
00268       virtual void initializeUsingXML(xercesc::DOMElement *element);
00269       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00270       virtual std::string getType() const { return "UnilateralNewtonImpact"; }
00271       /***************************************************/
00272 
00273     protected:
00274       double epsilon, gd_limit;
00275   };
00276 
00282   class BilateralImpact : public GeneralizedImpactLaw {
00283     public:
00287       BilateralImpact() { }
00288 
00292       virtual ~BilateralImpact() { }
00293 
00294       /* INHERITED INTERFACE */
00295       virtual double project(double la, double gdn, double gda, double r, double laMin=0);
00296       virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0);
00297       virtual double solve(double G, double gdn, double gda);
00298       virtual bool isFulfilled(double la,  double gdn, double gda, double tolla, double tolgd, double laMin=0);
00299 
00300       virtual std::string getType() const { return "BilateralImpact"; }
00301   };
00302 
00308   class FrictionForceLaw : public Element {
00309     public:
00313       FrictionForceLaw(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_=NULL) : Element(uniqueDummyName(this)), frictionForceFunc(frictionForceFunc_) {
00314         if(frictionForceFunc)
00315           frictionForceFunc->setParent(this);
00316       }
00317 
00321       virtual ~FrictionForceLaw() { if(frictionForceFunc) delete frictionForceFunc; frictionForceFunc = NULL; };
00322 
00323       void init(Element::InitStage stage) {
00324         Element::init(stage);
00325         if(frictionForceFunc)
00326           frictionForceFunc->init(stage);
00327       }
00328 
00329       /* INTERFACE FOR DERIVED CLASSES */
00330       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r) { return fmatvec::Vec(2); }
00331       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r) { return fmatvec::Mat(2,2); }
00332       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN) { return fmatvec::Vec(2); }
00333       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd) { return true; }
00334       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN) { return fmatvec::Vec(2); }
00335       virtual int getFrictionDirections() = 0;
00336       virtual bool isSticking(const fmatvec::Vec& s, double sTol) = 0;
00337       virtual double getFrictionCoefficient(double gd) { return 0; }
00338       virtual bool isSetValued() const = 0;
00339       virtual void initializeUsingXML(xercesc::DOMElement *element) {}
00340       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00341 
00345       virtual std::string getType() const { return "FrictionForceLaw"; }
00346       /***************************************************/
00347       
00348       fmatvec::Vec operator()(const fmatvec::Vec &gd, double laN) { assert(frictionForceFunc); return (*frictionForceFunc)(gd,laN); }
00349 
00355       void setFrictionForceFunction(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_) { 
00356         frictionForceFunc=frictionForceFunc_; 
00357         frictionForceFunc->setParent(this);
00358       }
00359 
00360     protected:
00361       Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc;
00362   };
00363 
00369   class PlanarCoulombFriction : public FrictionForceLaw {
00370     public:
00374       PlanarCoulombFriction(double mu_=0) : mu(mu_) { }
00375 
00379       virtual ~PlanarCoulombFriction() { }
00380 
00381       /* INHERITED INTERFACE */
00382       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00383       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00384       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00385       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00386       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00387       virtual int getFrictionDirections() { return 1; }
00388       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
00389       virtual double getFrictionCoefficient(double gd) { return mu; }
00390       virtual bool isSetValued() const { return true; }
00391       virtual void initializeUsingXML(xercesc::DOMElement *element);
00392       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00393       virtual std::string getType() const { return "PlanarCoulombFriction"; }
00394       /***************************************************/
00395 
00396       void setFrictionCoefficient(double mu_) { mu = mu_; }
00397 
00398     protected:
00399       double mu;
00400   };
00401 
00407   class SpatialCoulombFriction : public FrictionForceLaw {
00408     public:
00412       SpatialCoulombFriction(double mu_=0) : mu(mu_) { }
00413 
00417       virtual ~SpatialCoulombFriction() { }
00418 
00419       /* INHERITED INTERFACE */
00420       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00421       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00422       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00423       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00424       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00425       virtual int getFrictionDirections() { return 2; }
00426       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
00427       virtual double getFrictionCoefficient(double gd) { return mu; }
00428       virtual bool isSetValued() const { return true; }
00429       virtual void initializeUsingXML(xercesc::DOMElement *element);
00430       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00431       virtual std::string getType() const { return "SpatialCoulombFriction"; }
00432       /***************************************************/
00433 
00434       void setFrictionCoefficient(double mu_) { mu = mu_; }
00435 
00436     protected:
00437       double mu;
00438   };
00439 
00446   class PlanarStribeckFriction : public FrictionForceLaw {
00447     public:
00451       PlanarStribeckFriction(Function<double(double)> *fmu_=NULL) : fmu(fmu_) {
00452         fmu->setParent(this);
00453       }
00454 
00458       virtual ~PlanarStribeckFriction() { if(fmu) delete fmu; fmu=0; }
00459 
00460       void init(Element::InitStage stage) {
00461         FrictionForceLaw::init(stage);
00462         fmu->init(stage);
00463       }
00464 
00465       /* INHERITED INTERFACE */
00466       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00467       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00468       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00469       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00470       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00471       virtual int getFrictionDirections() { return 1; }
00472       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
00473       virtual double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00474       virtual bool isSetValued() const { return true; }
00475       /***************************************************/
00476 
00477     protected:
00481       Function<double(double)> *fmu;
00482   };
00483 
00490   class SpatialStribeckFriction : public FrictionForceLaw {
00491     public:
00495       SpatialStribeckFriction(Function<double(double)> *fmu_=NULL) : fmu(fmu_) {
00496         fmu->setParent(this);
00497       }
00498 
00502       virtual ~SpatialStribeckFriction() { if(fmu) delete fmu; fmu=0; }
00503 
00504       void init(Element::InitStage stage) {
00505         FrictionForceLaw::init(stage);
00506         fmu->init(stage);
00507       }
00508 
00509       /* INHERITED INTERFACE */
00510       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00511       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
00512       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
00513       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
00514       virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
00515       virtual int getFrictionDirections() { return 2; }
00516       virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
00517       virtual double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00518       virtual bool isSetValued() const { return true; }
00519       /***************************************************/
00520 
00521     protected:
00525       Function<double(double)> *fmu;
00526   };
00527 
00533   class FrictionImpactLaw : public Element {
00534     public:
00538       FrictionImpactLaw() : Element(uniqueDummyName(this)) { }
00539 
00543       virtual ~FrictionImpactLaw() { }
00544 
00545       /* INTERFACE FOR DERIVED CLASSES */
00546       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r) = 0;
00547       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r) = 0;
00548       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN) = 0;
00549       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd) = 0;
00550       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol) = 0;
00551       virtual int getFrictionDirections() = 0;
00552       virtual void initializeUsingXML(xercesc::DOMElement *element) {}
00553       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00554 
00558       virtual std::string getType() const { return "FrictionImpactLaw"; }
00559       /***************************************************/
00560   };
00561 
00567   class PlanarCoulombImpact : public FrictionImpactLaw {
00568     public:
00572       PlanarCoulombImpact(double mu_=0) : mu(mu_) { }
00573 
00577       virtual ~PlanarCoulombImpact() { }
00578 
00579       /* INHERITED INTERFACE */
00580       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00581       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00582       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00583       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00584       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00585       virtual int getFrictionDirections() { return 1; }
00586       virtual void initializeUsingXML(xercesc::DOMElement *element);
00587       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00588       virtual std::string getType() const { return "PlanarCoulombImpact"; }
00589       /***************************************************/
00590 
00591       void setFrictionCoefficient(double mu_) { mu = mu_; }
00592       double getFrictionCoefficient(double gd) { return mu; }
00593 
00594     protected:
00595       double mu;
00596   };
00597 
00603   class SpatialCoulombImpact : public FrictionImpactLaw {
00604     public:
00608       SpatialCoulombImpact(double mu_=0) : mu(mu_) { }
00609 
00613       virtual ~SpatialCoulombImpact() { }
00614 
00615       /* INHERITED INTERFACE */
00616       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00617       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00618       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00619       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00620       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00621       virtual int getFrictionDirections() { return 2; }
00622       virtual void initializeUsingXML(xercesc::DOMElement *element);
00623       virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
00624       virtual std::string getType() const { return "SpatialCoulombImpact"; }
00625       /***************************************************/
00626 
00627       void setFrictionCoefficient(double mu_) { mu = mu_; }
00628       double getFrictionCoefficient(double gd) { return mu; }
00629 
00630     protected:
00631       double mu;
00632   };
00633 
00640   class PlanarStribeckImpact : public FrictionImpactLaw {
00641     public:
00645       PlanarStribeckImpact(Function<double(double)> *fmu_=NULL) : fmu(fmu_) {
00646         fmu->setParent(this);
00647       }
00648 
00652       virtual ~PlanarStribeckImpact() { if(fmu) delete fmu; fmu=0; }
00653 
00654       void init(Element::InitStage stage) {
00655         FrictionImpactLaw::init(stage);
00656         fmu->init(stage);
00657       }
00658 
00659       /* INHERITED INTERFACE */
00660       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00661       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00662       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00663       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00664       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00665       virtual int getFrictionDirections() { return 1; }
00666       /***************************************************/
00667 
00668       double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00669 
00670     protected:
00674       Function<double(double)> *fmu;
00675   };
00676 
00683   class SpatialStribeckImpact : public FrictionImpactLaw {
00684     public:
00688       SpatialStribeckImpact(Function<double(double)> *fmu_=NULL) : fmu(fmu_) {
00689         fmu->setParent(this);
00690       }
00691 
00695       virtual ~SpatialStribeckImpact() { if(fmu) delete fmu; fmu=0; }
00696 
00697       void init(Element::InitStage stage) {
00698         FrictionImpactLaw::init(stage);
00699         fmu->init(stage);
00700       }
00701 
00702       /* INHERITED INTERFACE */
00703       virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00704       virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
00705       virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
00706       virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
00707       virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
00708       virtual int getFrictionDirections() { return 2; }
00709       /***************************************************/
00710 
00711       double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
00712 
00713     protected:
00717       Function<double(double)> *fmu;
00718   };
00719 
00725   class RegularizedUnilateralConstraint : public GeneralizedForceLaw {
00726     public:
00730       RegularizedUnilateralConstraint(Function<double(double,double)> *forceFunc_=NULL) : GeneralizedForceLaw(forceFunc_) { }
00731 
00735       virtual ~RegularizedUnilateralConstraint() {};
00736 
00737       /* INHERITED INTERFACE */
00738       virtual bool isActive(double g, double gTol) { return g<=gTol; }
00739       virtual bool remainsActive(double s, double sTol) { return s<=sTol; }
00740       virtual bool isSetValued() const { return false; }
00741       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contacts);
00742       /***************************************************/
00743 
00744       virtual void initializeUsingXML(xercesc::DOMElement *element);
00745   };
00746 
00752   class MaxwellUnilateralConstraint : public GeneralizedForceLaw {
00753     public:
00757       MaxwellUnilateralConstraint(const double & damping = 0, const double & gapLimit = 0);
00758 
00762       virtual ~MaxwellUnilateralConstraint();
00763 
00764       /* INHERITED INTERFACE */
00765       virtual bool isActive(double g, double gTol) { return g < gTol ? true : false; }
00766       virtual bool remainsActive(double s, double sTol) {return true; }
00767       virtual bool isSetValued() const { return false; }
00768       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contacts);
00769       /***************************************************/
00770 
00771       virtual void initializeUsingXML(xercesc::DOMElement *element);
00772 
00778       virtual void initializeContourCouplings(Contact* parent);
00779 
00780       /*GETTER - SETTER*/
00781       void setDebuglevel(int debuglevel) {
00782         DEBUGLEVEL = debuglevel;
00783       }
00784       void setLCPSolvingStrategy(LinearComplementarityProblem::LCPSolvingStrategy strategy) {
00785         LCP.setStrategy(strategy);
00786       }
00787       void setLCPJacobianType(LinearComplementarityProblem::JacobianType type) {
00788         LCP.setJacobianType(type);
00789       }
00790       /*****************/
00791 
00800       void addContourCoupling(Contour *contour1, Contour *contour2, InfluenceFunction *fct);
00801 
00802     protected:
00806       virtual void updatePossibleContactPoints(const std::vector<std::vector<SingleContact> > & contacts);
00807 
00813       virtual void updateInfluenceMatrix(std::vector<std::vector<SingleContact> > & contacts);
00814 
00818       void updateRigidBodyGap(const std::vector<std::vector<SingleContact> > & contacts);
00819 
00826       virtual double computeInfluenceCoefficient(std::vector<std::vector<SingleContact> > & contacts, const std::pair<int, int> & contactIndex);
00827 
00835       virtual double computeInfluenceCoefficient(std::vector<std::vector<SingleContact> > & contacts, const std::pair<int, int> & contactIndex, const std::pair<int, int> & couplingContactIndex);
00836 
00837       /*
00838        * \brief computes the "material constant" to have a good guess for the lambda-vector
00839        */
00840       virtual void computeMaterialConstant();
00841 
00848       std::vector<std::pair<int, int> > possibleContactPoints;
00849 
00853       LinearComplementarityProblem LCP;
00854 
00858       fmatvec::SymMat C;
00859 
00860       /*
00861        * \brief vector of rigid body distances(gaps) for the active contacts
00862        */
00863       fmatvec::Vec rigidBodyGap;
00864 
00868       std::map<std::pair<Contour*, Contour*>, InfluenceFunction*> influenceFunctions;
00869 
00873       fmatvec::Vec solution0;
00874 
00878       double dampingCoefficient;
00879 
00883       double gLim;
00884 
00888       double matConst;
00889 
00893       bool matConstSetted;
00894 
00904       int DEBUGLEVEL;
00905 
00906       struct xmlInfo {
00907           InfluenceFunction * function;
00908           std::string name1;
00909           std::string name2;
00910       };
00911       std::vector<xmlInfo> referenceXML;
00912 
00913   };
00914 
00920   class RegularizedBilateralConstraint : public GeneralizedForceLaw {
00921     public:
00925       RegularizedBilateralConstraint(Function<double(double,double)> *forceFunc_=NULL) : GeneralizedForceLaw(forceFunc_) { }
00926 
00930       virtual ~RegularizedBilateralConstraint() {};
00931 
00932       /* INHERITED INTERFACE */
00933       virtual bool isActive(double g, double gTol) { return true; }
00934       virtual bool remainsActive(double s, double sTol) { return true; }
00935       virtual bool isSetValued() const { return false; }
00936       virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contact);
00937       /***************************************************/
00938 
00939       virtual void initializeUsingXML(xercesc::DOMElement *element);
00940 
00941       virtual std::string getType() const { return "RegularizedBilateralConstraint"; }
00942   };
00943 
00944   class RegularizedPlanarFriction : public FrictionForceLaw {
00945     public:
00946       RegularizedPlanarFriction(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_=NULL) : FrictionForceLaw(frictionForceFunc_) { }
00947       virtual ~RegularizedPlanarFriction() {}
00948       int getFrictionDirections() { return 1; }
00949       bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
00950       bool isSetValued() const { return false; }
00951       virtual void initializeUsingXML(xercesc::DOMElement *element);
00952   };
00953 
00954   class RegularizedSpatialFriction : public FrictionForceLaw {
00955     public:
00956       RegularizedSpatialFriction(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_=NULL) : FrictionForceLaw(frictionForceFunc_) { }
00957       virtual ~RegularizedSpatialFriction() {}
00958       int getFrictionDirections() { return 2; }
00959       bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
00960       bool isSetValued() const { return false; }
00961       virtual void initializeUsingXML(xercesc::DOMElement *element);
00962   };
00963 
00964 }
00965 
00966 #endif /* _CONSTITUTIVE_LAWS_H_ */
00967