00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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
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
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; }
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
00957