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/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
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
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; }
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
00970