All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Pages
constitutive_laws.h
1 /* Copyright (C) 2004-2014 MBSim Development Team
2  *
3  * This library is free software; you can redistribute it and/or
4  * modify it under the terms of the GNU Lesser General Public
5  * License as published by the Free Software Foundation; either
6  * version 2.1 of the License, or (at your option) any later version.
7  *
8  * This library is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  * Lesser General Public License for more details.
12  *
13  * You should have received a copy of the GNU Lesser General Public
14  * License along with this library; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16  *
17  * Contact: martin.o.foerg@googlemail.com
18  */
19 
20 #ifndef _CONSTITUTIVE_LAWS_H_
21 #define _CONSTITUTIVE_LAWS_H_
22 
23 #include <map>
24 
25 #include <mbsim/numerics/linear_complementarity_problem/linear_complementarity_problem.h>
26 #include <mbsim/contour.h>
27 #include <mbsim/functions/function.h>
28 #include <fmatvec/atom.h>
29 
30 namespace MBSim {
31 
32  class Contact;
33  class SingleContact;
34  class InfluenceFunction;
35 
41  class GeneralizedForceLaw : public Element {
42  public:
46  GeneralizedForceLaw(Function<double(double,double)> *forceFunc_=NULL) : Element(uniqueDummyName(this)), forceFunc(forceFunc_) {
47  if(forceFunc)
48  forceFunc->setParent(this);
49  }
50 
54  virtual ~GeneralizedForceLaw() { if(forceFunc) delete forceFunc; forceFunc = NULL; };
55 
56  void init(Element::InitStage stage) {
57  Element::init(stage);
58  if(forceFunc)
59  forceFunc->init(stage);
60  }
61 
62  /* INTERFACE FOR DERIVED CLASSES */
69  virtual bool isActive(double g, double gTol) { return true; }
70  virtual bool remainsActive(double s, double sTol) { return true; }
71 
80  virtual double project(double la, double gdn, double r, double laMin=0) { return 0; }
81  virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0) { return fmatvec::Vec(2, fmatvec::INIT, 0); }
82  virtual double solve(double G, double gdn) { return 0; }
83 
91  virtual bool isFulfilled(double la, double gdn, double tolla, double tolgd, double laMin=0) { return true; }
92 
96  virtual bool isSetValued() const = 0;
97 
102  virtual void initializeUsingXML(xercesc::DOMElement *element) {}
103  virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
104 
108  virtual std::string getType() const { return "GeneralizedForceLaw"; }
109  /***************************************************/
110 
118  double operator()(double g, double gd) { assert(forceFunc); return (*forceFunc)(g,gd); }
119 
125  virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contact) {};
126 
132  void setForceFunction(Function<double(double,double)> *forceFunc_) {
133  forceFunc=forceFunc_;
134  forceFunc->setParent(this);
135  }
136 
137  protected:
141  Function<double(double,double)> *forceFunc;
142  };
143 
150  public:
155 
159  virtual ~UnilateralConstraint() { }
160 
161  /* INHERITED INTERFACE */
162  virtual bool isActive(double g, double gTol) { return g<=gTol; }
163  virtual bool remainsActive(double gd, double gdTol) { return gd<=gdTol; }
164  virtual double project(double la, double gdn, double r, double laMin=0);
165  virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0);
166  virtual double solve(double G, double gdn);
167  virtual bool isFulfilled(double la, double gdn, double tolla, double tolgd, double laMin=0);
168  virtual bool isSetValued() const { return true; }
169  /***************************************************/
170 
171  bool remainsClosed(double s, double sTol) { return s<=sTol; } // s = gd/gdd
172 
173  virtual std::string getType() const { return "UnilateralConstraint"; }
174  };
175 
183  public:
188 
192  virtual ~BilateralConstraint() { }
193 
194  /* INHERITED INTERFACE */
195  virtual bool isActive(double g, double gTol) { return true; }
196  virtual double project(double la, double gdn, double r, double laMin=0);
197  virtual fmatvec::Vec diff(double la, double gdn, double r, double laMin=0);
198  virtual double solve(double G, double gdn);
199  virtual bool isFulfilled(double la, double gdn, double tolla, double tolgd, double laMin=0);
200  virtual bool isSetValued() const { return true; }
201  /***************************************************/
202 
203  bool remainsClosed(double s, double sTol) { return true; }
204 
205  virtual std::string getType() const { return "BilateralConstraint"; }
206  };
207 
213  class GeneralizedImpactLaw : public Element {
214  public:
218  GeneralizedImpactLaw() : Element(uniqueDummyName(this)) { }
219 
223  virtual ~GeneralizedImpactLaw() { }
224 
225  /* INTERFACE FOR DERIVED CLASSES */
226  virtual double project(double la, double gdn, double gda, double r, double laMin=0) = 0;
227  virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0) = 0;
228  virtual double solve(double G, double gdn, double gda) = 0;
229  virtual bool isFulfilled(double la, double gdn, double gda, double tolla, double tolgd, double laMin=0) = 0;
230  virtual void initializeUsingXML(xercesc::DOMElement *element) {}
231  virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
232 
236  virtual std::string getType() const { return "GeneralizedImpactLaw"; }
237  /***************************************************/
238  };
239 
247  public:
251  UnilateralNewtonImpact(double epsilon_=0) : epsilon(epsilon_), gd_limit(1e-2) { }
252 
256  UnilateralNewtonImpact(double epsilon_, double gd_limit_) : epsilon(epsilon_), gd_limit(gd_limit_) { }
257 
262 
263  /* INHERITED INTERFACE */
264  virtual double project(double la, double gdn, double gda, double r, double laMin=0);
265  virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0);
266  virtual double solve(double G, double gdn, double gda);
267  virtual bool isFulfilled(double la, double gdn, double gda, double tolla, double tolgd, double laMin=0);
268  virtual void initializeUsingXML(xercesc::DOMElement *element);
269  virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
270  virtual std::string getType() const { return "UnilateralNewtonImpact"; }
271  /***************************************************/
272 
273  protected:
274  double epsilon, gd_limit;
275  };
276 
283  public:
288 
292  virtual ~BilateralImpact() { }
293 
294  /* INHERITED INTERFACE */
295  virtual double project(double la, double gdn, double gda, double r, double laMin=0);
296  virtual fmatvec::Vec diff(double la, double gdn, double gda, double r, double laMin=0);
297  virtual double solve(double G, double gdn, double gda);
298  virtual bool isFulfilled(double la, double gdn, double gda, double tolla, double tolgd, double laMin=0);
299 
300  virtual std::string getType() const { return "BilateralImpact"; }
301  };
302 
308  class FrictionForceLaw : public Element {
309  public:
313  FrictionForceLaw(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_=NULL) : Element(uniqueDummyName(this)), frictionForceFunc(frictionForceFunc_) {
314  if(frictionForceFunc)
315  frictionForceFunc->setParent(this);
316  }
317 
321  virtual ~FrictionForceLaw() { if(frictionForceFunc) delete frictionForceFunc; frictionForceFunc = NULL; };
322 
323  void init(Element::InitStage stage) {
324  Element::init(stage);
325  if(frictionForceFunc)
326  frictionForceFunc->init(stage);
327  }
328 
329  /* INTERFACE FOR DERIVED CLASSES */
330  virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r) { return fmatvec::Vec(2); }
331  virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r) { return fmatvec::Mat(2,2); }
332  virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN) { return fmatvec::Vec(2); }
333  virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd) { return true; }
334  virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN) { return fmatvec::Vec(2); }
335  virtual int getFrictionDirections() = 0;
336  virtual bool isSticking(const fmatvec::Vec& s, double sTol) = 0;
337  virtual double getFrictionCoefficient(double gd) { return 0; }
338  virtual bool isSetValued() const = 0;
339  virtual void initializeUsingXML(xercesc::DOMElement *element) {}
340  virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
341 
345  virtual std::string getType() const { return "FrictionForceLaw"; }
346  /***************************************************/
347 
348  fmatvec::Vec operator()(const fmatvec::Vec &gd, double laN) { assert(frictionForceFunc); return (*frictionForceFunc)(gd,laN); }
349 
355  void setFrictionForceFunction(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_) {
356  frictionForceFunc=frictionForceFunc_;
357  frictionForceFunc->setParent(this);
358  }
359 
360  protected:
361  Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc;
362  };
363 
370  public:
374  PlanarCoulombFriction(double mu_=0) : mu(mu_) { }
375 
380 
381  /* INHERITED INTERFACE */
382  virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
383  virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
384  virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
385  virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
386  virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
387  virtual int getFrictionDirections() { return 1; }
388  virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
389  virtual double getFrictionCoefficient(double gd) { return mu; }
390  virtual bool isSetValued() const { return true; }
391  virtual void initializeUsingXML(xercesc::DOMElement *element);
392  virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
393  virtual std::string getType() const { return "PlanarCoulombFriction"; }
394  /***************************************************/
395 
396  void setFrictionCoefficient(double mu_) { mu = mu_; }
397 
398  protected:
399  double mu;
400  };
401 
408  public:
412  SpatialCoulombFriction(double mu_=0) : mu(mu_) { }
413 
418 
419  /* INHERITED INTERFACE */
420  virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
421  virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
422  virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
423  virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
424  virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
425  virtual int getFrictionDirections() { return 2; }
426  virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
427  virtual double getFrictionCoefficient(double gd) { return mu; }
428  virtual bool isSetValued() const { return true; }
429  virtual void initializeUsingXML(xercesc::DOMElement *element);
430  virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
431  virtual std::string getType() const { return "SpatialCoulombFriction"; }
432  /***************************************************/
433 
434  void setFrictionCoefficient(double mu_) { mu = mu_; }
435 
436  protected:
437  double mu;
438  };
439 
447  public:
451  PlanarStribeckFriction(Function<double(double)> *fmu_=NULL) : fmu(fmu_) {
452  if(fmu) fmu->setParent(this);
453  }
454 
458  virtual ~PlanarStribeckFriction() { if(fmu) delete fmu; fmu=0; }
459 
460  void init(Element::InitStage stage) {
461  FrictionForceLaw::init(stage);
462  fmu->init(stage);
463  }
464 
465  /* INHERITED INTERFACE */
466  virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
467  virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
468  virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
469  virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
470  virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
471  virtual int getFrictionDirections() { return 1; }
472  virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
473  virtual double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
474  virtual bool isSetValued() const { return true; }
475  virtual void initializeUsingXML(xercesc::DOMElement *element);
476  virtual std::string getType() const { return "PlanarStribeckFriction"; }
477  /***************************************************/
478 
479  void setFrictionFunction(Function<double(double)> *fmu_) {
480  fmu = fmu_;
481  if(fmu) fmu->setParent(this);
482  }
483 
484  protected:
488  Function<double(double)> *fmu;
489  };
490 
498  public:
502  SpatialStribeckFriction(Function<double(double)> *fmu_=NULL) : fmu(fmu_) {
503  if(fmu) fmu->setParent(this);
504  }
505 
509  virtual ~SpatialStribeckFriction() { if(fmu) delete fmu; fmu=0; }
510 
511  void init(Element::InitStage stage) {
512  FrictionForceLaw::init(stage);
513  fmu->init(stage);
514  }
515 
516  /* INHERITED INTERFACE */
517  virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
518  virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double r);
519  virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, double laN);
520  virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, double laN, double tolla, double tolgd);
521  virtual fmatvec::Vec dlaTdlaN(const fmatvec::Vec& gd, double laN);
522  virtual int getFrictionDirections() { return 2; }
523  virtual bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
524  virtual double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
525  virtual bool isSetValued() const { return true; }
526  virtual void initializeUsingXML(xercesc::DOMElement *element);
527  virtual std::string getType() const { return "SpatialStribeckFriction"; }
528  /***************************************************/
529 
530  void setFrictionFunction(Function<double(double)> *fmu_) {
531  fmu = fmu_;
532  if(fmu) fmu->setParent(this);
533  }
534 
535  protected:
539  Function<double(double)> *fmu;
540  };
541 
547  class FrictionImpactLaw : public Element {
548  public:
552  FrictionImpactLaw() : Element(uniqueDummyName(this)) { }
553 
557  virtual ~FrictionImpactLaw() { }
558 
559  /* INTERFACE FOR DERIVED CLASSES */
560  virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r) = 0;
561  virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r) = 0;
562  virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN) = 0;
563  virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd) = 0;
564  virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol) = 0;
565  virtual int getFrictionDirections() = 0;
566  virtual void initializeUsingXML(xercesc::DOMElement *element) {}
567  virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
568 
572  virtual std::string getType() const { return "FrictionImpactLaw"; }
573  /***************************************************/
574  };
575 
582  public:
586  PlanarCoulombImpact(double mu_=0) : mu(mu_) { }
587 
591  virtual ~PlanarCoulombImpact() { }
592 
593  /* INHERITED INTERFACE */
594  virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
595  virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
596  virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
597  virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
598  virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
599  virtual int getFrictionDirections() { return 1; }
600  virtual void initializeUsingXML(xercesc::DOMElement *element);
601  virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
602  virtual std::string getType() const { return "PlanarCoulombImpact"; }
603  /***************************************************/
604 
605  void setFrictionCoefficient(double mu_) { mu = mu_; }
606  double getFrictionCoefficient(double gd) { return mu; }
607 
608  protected:
609  double mu;
610  };
611 
618  public:
622  SpatialCoulombImpact(double mu_=0) : mu(mu_) { }
623 
627  virtual ~SpatialCoulombImpact() { }
628 
629  /* INHERITED INTERFACE */
630  virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
631  virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
632  virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
633  virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
634  virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
635  virtual int getFrictionDirections() { return 2; }
636  virtual void initializeUsingXML(xercesc::DOMElement *element);
637  virtual xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent);
638  virtual std::string getType() const { return "SpatialCoulombImpact"; }
639  /***************************************************/
640 
641  void setFrictionCoefficient(double mu_) { mu = mu_; }
642  double getFrictionCoefficient(double gd) { return mu; }
643 
644  protected:
645  double mu;
646  };
647 
655  public:
659  PlanarStribeckImpact(Function<double(double)> *fmu_=NULL) : fmu(fmu_) {
660  if(fmu) fmu->setParent(this);
661  }
662 
666  virtual ~PlanarStribeckImpact() { if(fmu) delete fmu; fmu=0; }
667 
668  void init(Element::InitStage stage) {
670  fmu->init(stage);
671  }
672 
673  /* INHERITED INTERFACE */
674  virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
675  virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
676  virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
677  virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
678  virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
679  virtual int getFrictionDirections() { return 1; }
680  virtual void initializeUsingXML(xercesc::DOMElement *element);
681  virtual std::string getType() const { return "PlanarStribeckImpact"; }
682  /***************************************************/
683 
684  double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
685 
686  void setFrictionFunction(Function<double(double)> *fmu_) {
687  fmu = fmu_;
688  if(fmu) fmu->setParent(this);
689  }
690 
691  protected:
695  Function<double(double)> *fmu;
696  };
697 
705  public:
709  SpatialStribeckImpact(Function<double(double)> *fmu_=NULL) : fmu(fmu_) {
710  if(fmu) fmu->setParent(this);
711  }
712 
716  virtual ~SpatialStribeckImpact() { if(fmu) delete fmu; fmu=0; }
717 
718  void init(Element::InitStage stage) {
720  fmu->init(stage);
721  }
722 
723  /* INHERITED INTERFACE */
724  virtual fmatvec::Vec project(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
725  virtual fmatvec::Mat diff(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double r);
726  virtual fmatvec::Vec solve(const fmatvec::SqrMat& G, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN);
727  virtual bool isFulfilled(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double tolla, double tolgd);
728  virtual int isSticking(const fmatvec::Vec& la, const fmatvec::Vec& gdn, const fmatvec::Vec& gda, double laN, double laTol, double gdTol);
729  virtual int getFrictionDirections() { return 2; }
730  virtual void initializeUsingXML(xercesc::DOMElement *element);
731  virtual std::string getType() const { return "SpatialStribeckImpact"; }
732  /***************************************************/
733 
734  double getFrictionCoefficient(double gd) { return (*fmu)(gd); }
735 
736  void setFrictionFunction(Function<double(double)> *fmu_) {
737  fmu = fmu_;
738  if(fmu) fmu->setParent(this);
739  }
740 
741  protected:
745  Function<double(double)> *fmu;
746  };
747 
754  public:
758  RegularizedUnilateralConstraint(Function<double(double,double)> *forceFunc_=NULL) : GeneralizedForceLaw(forceFunc_) { }
759 
764 
765  /* INHERITED INTERFACE */
766  virtual bool isActive(double g, double gTol) { return g<=gTol; }
767  virtual bool remainsActive(double s, double sTol) { return s<=sTol; }
768  virtual bool isSetValued() const { return false; }
769  virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contacts);
770  /***************************************************/
771 
772  virtual void initializeUsingXML(xercesc::DOMElement *element);
773  };
774 
781  public:
785  MaxwellUnilateralConstraint(const double & damping = 0, const double & gapLimit = 0);
786 
791 
792  /* INHERITED INTERFACE */
793  virtual bool isActive(double g, double gTol) { return g < gTol ? true : false; }
794  virtual bool remainsActive(double s, double sTol) {return true; }
795  virtual bool isSetValued() const { return false; }
796  virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contacts);
797  /***************************************************/
798 
799  virtual void initializeUsingXML(xercesc::DOMElement *element);
800 
806  virtual void initializeContourCouplings(Contact* parent);
807 
808  /*GETTER - SETTER*/
809  void setDebuglevel(int debuglevel) {
810  DEBUGLEVEL = debuglevel;
811  }
812  void setLCPSolvingStrategy(LinearComplementarityProblem::LCPSolvingStrategy strategy) {
813  LCP.setStrategy(strategy);
814  }
815  void setLCPJacobianType(LinearComplementarityProblem::JacobianType type) {
816  LCP.setJacobianType(type);
817  }
818  /*****************/
819 
828  void addContourCoupling(Contour *contour1, Contour *contour2, InfluenceFunction *fct);
829 
830  protected:
834  virtual void updatePossibleContactPoints(const std::vector<std::vector<SingleContact> > & contacts);
835 
841  virtual void updateInfluenceMatrix(std::vector<std::vector<SingleContact> > & contacts);
842 
846  void updateRigidBodyGap(const std::vector<std::vector<SingleContact> > & contacts);
847 
854  virtual double computeInfluenceCoefficient(std::vector<std::vector<SingleContact> > & contacts, const std::pair<int, int> & contactIndex);
855 
863  virtual double computeInfluenceCoefficient(std::vector<std::vector<SingleContact> > & contacts, const std::pair<int, int> & contactIndex, const std::pair<int, int> & couplingContactIndex);
864 
865  /*
866  * \brief computes the "material constant" to have a good guess for the lambda-vector
867  */
868  virtual void computeMaterialConstant();
869 
876  std::vector<std::pair<int, int> > possibleContactPoints;
877 
881  LinearComplementarityProblem LCP;
882 
887 
888  /*
889  * \brief vector of rigid body distances(gaps) for the active contacts
890  */
891  fmatvec::Vec rigidBodyGap;
892 
896  std::map<std::pair<Contour*, Contour*>, InfluenceFunction*> influenceFunctions;
897 
902 
907 
911  double gLim;
912 
916  double matConst;
917 
922 
933 
934  struct xmlInfo {
935  InfluenceFunction * function;
936  std::string name1;
937  std::string name2;
938  };
939  std::vector<xmlInfo> referenceXML;
940 
941  };
942 
949  public:
953  RegularizedBilateralConstraint(Function<double(double,double)> *forceFunc_=NULL) : GeneralizedForceLaw(forceFunc_) { }
954 
959 
960  /* INHERITED INTERFACE */
961  virtual bool isActive(double g, double gTol) { return true; }
962  virtual bool remainsActive(double s, double sTol) { return true; }
963  virtual bool isSetValued() const { return false; }
964  virtual void computeSmoothForces(std::vector<std::vector<SingleContact> > & contact);
965  /***************************************************/
966 
967  virtual void initializeUsingXML(xercesc::DOMElement *element);
968 
969  virtual std::string getType() const { return "RegularizedBilateralConstraint"; }
970  };
971 
973  public:
974  RegularizedPlanarFriction(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_=NULL) : FrictionForceLaw(frictionForceFunc_) { }
975  virtual ~RegularizedPlanarFriction() {}
976  int getFrictionDirections() { return 1; }
977  bool isSticking(const fmatvec::Vec& s, double sTol) { return fabs(s(0)) <= sTol; }
978  bool isSetValued() const { return false; }
979  virtual void initializeUsingXML(xercesc::DOMElement *element);
980  };
981 
983  public:
984  RegularizedSpatialFriction(Function<fmatvec::Vec(fmatvec::Vec,double)> *frictionForceFunc_=NULL) : FrictionForceLaw(frictionForceFunc_) { }
985  virtual ~RegularizedSpatialFriction() {}
986  int getFrictionDirections() { return 2; }
987  bool isSticking(const fmatvec::Vec& s, double sTol) { return nrm2(s(0,1)) <= sTol; }
988  bool isSetValued() const { return false; }
989  virtual void initializeUsingXML(xercesc::DOMElement *element);
990  };
991 
992 }
993 
994 #endif /* _CONSTITUTIVE_LAWS_H_ */
995 
virtual ~PlanarStribeckFriction()
destructor
Definition: constitutive_laws.h:458
basic force law on acceleration level for constraint description
Definition: constitutive_laws.h:41
virtual ~UnilateralConstraint()
destructor
Definition: constitutive_laws.h:159
virtual bool isSetValued() const
Definition: constitutive_laws.h:200
virtual bool isFulfilled(double la, double gdn, double tolla, double tolgd, double laMin=0)
Definition: constitutive_laws.h:91
virtual void updateInfluenceMatrix(std::vector< std::vector< SingleContact > > &contacts)
updates the influence matrix C
Definition: constitutive_laws.cc:922
LinearComplementarityProblem LCP
variable for the LCP
Definition: constitutive_laws.h:881
PlanarStribeckFriction(Function< double(double)> *fmu_=NULL)
constructor
Definition: constitutive_laws.h:451
basic planar friction force law on velocity level for constraint description
Definition: constitutive_laws.h:581
void setFrictionForceFunction(Function< fmatvec::Vec(fmatvec::Vec, double)> *frictionForceFunc_)
Set the friction force function for use in regularisized constitutive friction laws The first input p...
Definition: constitutive_laws.h:355
virtual std::string getType() const
Definition: constitutive_laws.h:300
virtual void updatePossibleContactPoints(const std::vector< std::vector< SingleContact > > &contacts)
saves all possible contacts in a vector
Definition: constitutive_laws.cc:911
virtual ~FrictionForceLaw()
destructor
Definition: constitutive_laws.h:321
virtual double project(double la, double gdn, double r, double laMin=0)
prox function evaluation
Definition: constitutive_laws.h:80
double matConst
parameter for guessing starting values of contact force (average eigenvalue of influence-matrix) ...
Definition: constitutive_laws.h:916
virtual ~GeneralizedImpactLaw()
destructor
Definition: constitutive_laws.h:223
Function< double(double)> * fmu
Definition: constitutive_laws.h:695
void init(Element::InitStage stage)
plots time series header
Definition: constitutive_laws.h:718
class for contacts
Definition: contact.h:54
void updateRigidBodyGap(const std::vector< std::vector< SingleContact > > &contacts)
update the rigid body distances (gaps) for the single contacts
Definition: constitutive_laws.cc:945
Vector< Ref, double > Vec
Definition: constitutive_laws.h:934
virtual void initializeUsingXML(xercesc::DOMElement *element)
initialize the force law using XML
Definition: constitutive_laws.cc:895
Function< double(double, double)> * forceFunc
force function for a regularized contact law
Definition: constitutive_laws.h:141
virtual bool isSetValued() const
Definition: constitutive_laws.h:168
virtual std::string getType() const
Definition: constitutive_laws.h:431
basic bilateral force law on acceleration level for constraint description
Definition: constitutive_laws.h:182
virtual ~FrictionImpactLaw()
destructor
Definition: constitutive_laws.h:557
virtual std::string getType() const
Definition: constitutive_laws.h:345
virtual std::string getType() const
Definition: constitutive_laws.h:681
SpatialCoulombImpact(double mu_=0)
constructor
Definition: constitutive_laws.h:622
bool matConstSetted
parameter to save if matConst has been computed already
Definition: constitutive_laws.h:921
virtual bool isActive(double g, double gTol)
decides, if force law is active
Definition: constitutive_laws.h:195
basic planar friction force law on acceleration level for constraint description
Definition: constitutive_laws.h:369
UnilateralNewtonImpact(double epsilon_=0)
constructor
Definition: constitutive_laws.h:251
GeneralizedForceLaw(Function< double(double, double)> *forceFunc_=NULL)
constructor
Definition: constitutive_laws.h:46
FrictionImpactLaw()
constructor
Definition: constitutive_laws.h:552
FrictionForceLaw(Function< fmatvec::Vec(fmatvec::Vec, double)> *frictionForceFunc_=NULL)
constructor
Definition: constitutive_laws.h:313
virtual ~BilateralImpact()
destructor
Definition: constitutive_laws.h:292
void init(Element::InitStage stage)
plots time series header
Definition: constitutive_laws.h:668
planar Stribeck friction force law on acceleration level for constraint description ...
Definition: constitutive_laws.h:446
virtual ~PlanarCoulombFriction()
destructor
Definition: constitutive_laws.h:379
virtual std::string getType() const
Definition: constitutive_laws.h:602
virtual double computeInfluenceCoefficient(std::vector< std::vector< SingleContact > > &contacts, const std::pair< int, int > &contactIndex)
computes the coupling factor for the influence matrix on one contact point (two contours) ...
Definition: constitutive_laws.cc:956
basic class of MBSim mainly for plotting
Definition: element.h:58
virtual void initializeUsingXML(xercesc::DOMElement *element)
initialize the force law using XML
Definition: constitutive_laws.h:102
virtual ~RegularizedBilateralConstraint()
destructor
Definition: constitutive_laws.h:958
virtual std::string getType() const
Definition: constitutive_laws.h:527
virtual ~SpatialStribeckFriction()
destructor
Definition: constitutive_laws.h:509
basic bilateral force law on velocity level for constraint description
Definition: constitutive_laws.h:282
void addContourCoupling(Contour *contour1, Contour *contour2, InfluenceFunction *fct)
add a function that represents the coupling between two contours
Definition: constitutive_laws.cc:839
virtual double project(double la, double gdn, double r, double laMin=0)
prox function evaluation
Definition: constitutive_laws.cc:93
std::vector< std::pair< int, int > > possibleContactPoints
saves the indices of all active contacts in pairs
Definition: constitutive_laws.h:876
SpatialStribeckImpact(Function< double(double)> *fmu_=NULL)
constructor
Definition: constitutive_laws.h:709
int DEBUGLEVEL
print INFO output?
Definition: constitutive_laws.h:932
virtual double project(double la, double gdn, double r, double laMin=0)
prox function evaluation
Definition: constitutive_laws.cc:142
basic regularized bilateral force law on acceleration level for constraint description ...
Definition: constitutive_laws.h:948
UnilateralConstraint()
constructor
Definition: constitutive_laws.h:154
basic unilateral force law on acceleration level for constraint description
Definition: constitutive_laws.h:149
basic unilateral force law on velocity level for constraint description
Definition: constitutive_laws.h:246
void init(Element::InitStage stage)
plots time series header
Definition: constitutive_laws.h:460
fmatvec::SymMat C
Influence matrix between contact points.
Definition: constitutive_laws.h:886
spatial Stribeck friction force law on acceleration level for constraint description ...
Definition: constitutive_laws.h:497
Definition: constitutive_laws.h:972
virtual std::string getType() const
Definition: constitutive_laws.h:572
SpatialCoulombFriction(double mu_=0)
constructor
Definition: constitutive_laws.h:412
virtual void computeSmoothForces(std::vector< std::vector< SingleContact > > &contacts)
computes the normal forces for smooth constitutive law on every contact point
Definition: constitutive_laws.cc:811
virtual void computeSmoothForces(std::vector< std::vector< SingleContact > > &contact)
computes the normal forces for smooth constitutive law on every contact point
Definition: constitutive_laws.cc:1044
Matrix< General, Ref, Ref, double > Mat
void init(Element::InitStage stage)
plots time series header
Definition: constitutive_laws.h:56
virtual ~BilateralConstraint()
destructor
Definition: constitutive_laws.h:192
virtual std::string getType() const
Definition: constitutive_laws.h:638
RegularizedUnilateralConstraint(Function< double(double, double)> *forceFunc_=NULL)
constructor
Definition: constitutive_laws.h:758
virtual ~SpatialCoulombFriction()
destructor
Definition: constitutive_laws.h:417
basic friction force law on velocity level for constraint description
Definition: constitutive_laws.h:547
InitStage
The stages of the initialization.
Definition: element.h:97
basic friction force law on acceleration level for constraint description
Definition: constitutive_laws.h:308
virtual ~GeneralizedForceLaw()
destructor
Definition: constitutive_laws.h:54
basic spatial friction force law on velocity level for constraint description
Definition: constitutive_laws.h:617
RegularizedBilateralConstraint(Function< double(double, double)> *forceFunc_=NULL)
constructor
Definition: constitutive_laws.h:953
virtual bool isFulfilled(double la, double gdn, double tolla, double tolgd, double laMin=0)
Definition: constitutive_laws.cc:157
basic regularized unilateral force law on acceleration level for constraint description ...
Definition: constitutive_laws.h:753
basic force law on velocity level for constraint description
Definition: constitutive_laws.h:213
std::map< std::pair< Contour *, Contour * >, InfluenceFunction * > influenceFunctions
saves the influence functions for a pair of contours. The key is the pair of contour names ...
Definition: constitutive_laws.h:896
BilateralConstraint()
constructor
Definition: constitutive_laws.h:187
virtual bool isFulfilled(double la, double gdn, double tolla, double tolgd, double laMin=0)
Definition: constitutive_laws.cc:115
GeneralizedImpactLaw()
constructor
Definition: constitutive_laws.h:218
double operator()(double g, double gd)
Definition: constitutive_laws.h:118
virtual void initializeUsingXML(xercesc::DOMElement *element)
initialize the force law using XML
Definition: constitutive_laws.cc:803
virtual bool isActive(double g, double gTol)
decides, if force law is active
Definition: constitutive_laws.h:162
void init(Element::InitStage stage)
plots time series header
Definition: constitutive_laws.h:511
double gLim
relative contact point distance limit under which damping is active
Definition: constitutive_laws.h:911
virtual bool isSetValued() const
Definition: constitutive_laws.h:768
double dampingCoefficient
coefficient for possible contact damping
Definition: constitutive_laws.h:906
Function< double(double)> * fmu
Definition: constitutive_laws.h:539
UnilateralNewtonImpact(double epsilon_, double gd_limit_)
constructor
Definition: constitutive_laws.h:256
virtual ~UnilateralNewtonImpact()
destructor
Definition: constitutive_laws.h:261
virtual bool isActive(double g, double gTol)
decides, if force law is active
Definition: constitutive_laws.h:766
Function< double(double)> * fmu
Definition: constitutive_laws.h:488
virtual std::string getType() const
Definition: constitutive_laws.h:393
virtual ~PlanarCoulombImpact()
destructor
Definition: constitutive_laws.h:591
virtual void init(InitStage stage)
plots time series header
Definition: element.cc:70
virtual std::string getType() const
Definition: constitutive_laws.h:270
virtual bool isSetValued() const
Definition: constitutive_laws.h:963
Function< double(double)> * fmu
Definition: constitutive_laws.h:745
virtual ~RegularizedUnilateralConstraint()
destructor
Definition: constitutive_laws.h:763
PlanarStribeckImpact(Function< double(double)> *fmu_=NULL)
constructor
Definition: constitutive_laws.h:659
virtual void initializeContourCouplings(Contact *parent)
initialize all saved contour couplings in the map
Definition: constitutive_laws.cc:831
basic spatial friction force law on acceleration level for constraint description ...
Definition: constitutive_laws.h:407
virtual std::string getType() const
Definition: constitutive_laws.h:969
SpatialStribeckFriction(Function< double(double)> *fmu_=NULL)
constructor
Definition: constitutive_laws.h:502
fmatvec::Vec solution0
Solution of the last time, where contact has to be solved (can be used as starting guess for the next...
Definition: constitutive_laws.h:901
PlanarCoulombImpact(double mu_=0)
constructor
Definition: constitutive_laws.h:586
virtual ~PlanarStribeckImpact()
destructor
Definition: constitutive_laws.h:666
virtual ~SpatialCoulombImpact()
destructor
Definition: constitutive_laws.h:627
BilateralImpact()
constructor
Definition: constitutive_laws.h:287
virtual std::string getType() const
Definition: constitutive_laws.h:205
virtual void computeSmoothForces(std::vector< std::vector< SingleContact > > &contacts)
computes the normal forces for smooth constitutive law on every contact point
Definition: constitutive_laws.cc:854
MaxwellUnilateralConstraint(const double &damping=0, const double &gapLimit=0)
constructor
Definition: constitutive_laws.cc:821
virtual std::string getType() const
Definition: constitutive_laws.h:108
spatial Stribeck friction force law on velocity level for constraint description
Definition: constitutive_laws.h:704
void init(Element::InitStage stage)
plots time series header
Definition: constitutive_laws.h:323
virtual std::string getType() const
Definition: constitutive_laws.h:173
virtual ~MaxwellUnilateralConstraint()
destructor
Definition: constitutive_laws.cc:826
virtual bool isActive(double g, double gTol)
decides, if force law is active
Definition: constitutive_laws.h:793
A force law that computes the normal force of many contact kinematics based on the Maxwell-Force-Law...
Definition: constitutive_laws.h:780
virtual bool isSetValued() const =0
virtual std::string getType() const
Definition: constitutive_laws.h:476
PlanarCoulombFriction(double mu_=0)
constructor
Definition: constitutive_laws.h:374
virtual bool isActive(double g, double gTol)
decides, if force law is active
Definition: constitutive_laws.h:69
virtual std::string getType() const
Definition: constitutive_laws.h:731
planar Stribeck friction force law on velocity level for constraint description
Definition: constitutive_laws.h:654
virtual std::string getType() const
Definition: constitutive_laws.h:236
virtual bool isActive(double g, double gTol)
decides, if force law is active
Definition: constitutive_laws.h:961
virtual ~SpatialStribeckImpact()
destructor
Definition: constitutive_laws.h:716
void setForceFunction(Function< double(double, double)> *forceFunc_)
Set the force function for use in regularisized constitutive laws The first input parameter to the fo...
Definition: constitutive_laws.h:132
virtual void computeSmoothForces(std::vector< std::vector< SingleContact > > &contact)
computes the normal forces for smooth constitutive law on every contact point
Definition: constitutive_laws.h:125
virtual void initializeUsingXML(xercesc::DOMElement *element)
initialize the force law using XML
Definition: constitutive_laws.cc:1036
virtual bool isSetValued() const
Definition: constitutive_laws.h:795
Definition: constitutive_laws.h:982

Impressum / Disclaimer / Datenschutz Generated by doxygen 1.8.5 Valid HTML