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 <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
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
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; }
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
00967