All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Pages
functions_contact.h
1 /* Copyright (C) 2004-2010 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  * rzander@users.berlios.de
19  */
20 
21 #ifndef FUNCTIONS_CONTACT_H_
22 #define FUNCTIONS_CONTACT_H_
23 
24 #include <mbsim/contour.h>
25 #include <mbsim/contours/contour1s.h>
26 #include <mbsim/contours/point.h>
27 #include "mbsim/contours/line.h"
28 #include <mbsim/contours/circle_solid.h>
29 #include "mbsim/contours/circle_hollow.h"
30 #include "mbsim/contours/circle.h"
31 #include "mbsim/contours/frustum2d.h"
32 #include "mbsim/contours/edge.h"
33 #include "mbsim/contours/frustum.h"
34 #include "mbsim/contours/plane.h"
35 #include "mbsim/contours/contour2s.h"
36 #include "mbsim/contours/planewithfrustum.h"
37 #include "mbsim/contours/contour_interpolation.h"
38 #include "mbsim/contours/contour_quad.h"
39 #include "mbsim/contours/cuboid.h"
40 #include "mbsim/contours/compound_contour.h"
41 #include "mbsim/mbsim_event.h"
42 #include <mbsim/functions/function.h>
43 
44 namespace MBSim {
45 
46  template <typename Sig> class DistanceFunction;
47 
53  template <typename Ret, typename Arg>
54  class DistanceFunction<Ret(Arg)> : public Function<Ret(Arg)> {
55  public:
56  virtual ~DistanceFunction() {
57  }
58  /* INTERFACE FOR DERIVED CLASSES */
63  virtual Ret operator()(const Arg &x) = 0;
64 
69  virtual double operator[](const Arg& x) { return nrm2(computeWrD(x)); }
70 
75  virtual fmatvec::Vec3 computeWrD(const Arg& x) = 0;
76  /*************************************************/
77  };
78 
86  class FuncPairContour1sPoint : public DistanceFunction<double(double)> {
87  public:
93  FuncPairContour1sPoint(Point* point_, Contour1s *contour_) : contour(contour_), point(point_), cp() {}
94 
95  /* INHERITED INTERFACE OF DISTANCEFUNCTION */
96  double operator()(const double &alpha) {
97  fmatvec::Vec3 Wd = computeWrD(alpha);
98  fmatvec::Vec3 Wt = cp.getFrameOfReference().getOrientation().col(1);
99  return Wt.T() * Wd;
100  }
101 
102  fmatvec::Vec3 computeWrD(const double &alpha) {
103  //if(fabs(alpha-cp.getLagrangeParameterPosition()(0))>epsroot()) { TODO this is not working in all cases
104  cp.getLagrangeParameterPosition()(0) = alpha;
105  contour->computeRootFunctionPosition(cp);
106  contour->computeRootFunctionFirstTangent(cp);
107  //}
108  return point->getFrame()->getPosition() - cp.getFrameOfReference().getPosition();
109  }
110  /*************************************************/
111 
112  private:
116  Contour1s *contour;
117  Point *point;
118 
123  };
124 
130  class FuncPairContour2sPoint : public DistanceFunction<fmatvec::Vec(fmatvec::Vec)> {
131  public:
137  FuncPairContour2sPoint(Point* point_, Contour2s *contour_) :
138  contour(contour_), point(point_), cp() {
139  }
140 
141  /* INHERITED INTERFACE OF DISTANCEFUNCTION */
142  fmatvec::Vec operator()(const fmatvec::Vec &alpha) { // Vec2: U and V direction
143  fmatvec::Vec3 Wd = computeWrD(alpha);
144  fmatvec::Vec3 Wt1 = cp.getFrameOfReference().getOrientation().col(1);
145  fmatvec::Vec3 Wt2 = cp.getFrameOfReference().getOrientation().col(2);
146  fmatvec::Vec Wt(2, fmatvec::NONINIT); // TODO:: check this?
147  Wt(0) = Wt1.T() * Wd; // the projection of distance vector Wd into the first tangent direction: scalar value
148  Wt(1) = Wt2.T() * Wd; // the projection of distance vector Wd into the second tangent direction: scalar value
149  return Wt;
150  }
151 
152  fmatvec::Vec3 computeWrD(const fmatvec::Vec &alpha) {
153  cp.getLagrangeParameterPosition()(0) = alpha(0);
154  cp.getLagrangeParameterPosition()(1) = alpha(1);
155  contour->computeRootFunctionPosition(cp);
156  contour->computeRootFunctionFirstTangent(cp); // TODO:: move these two line into operator() ?? maybe not possible, as when opertor[] is called, the orientation need to be updated
157  contour->computeRootFunctionSecondTangent(cp);
158  return point->getFrame()->getPosition() - cp.getFrameOfReference().getPosition();
159  }
160  /*************************************************/
161 
162  private:
166  Contour2s *contour;
167  Point *point;
172  };
173 
181  class FuncPairContour1sCircleHollow : public DistanceFunction<double(double)> {
182  public:
188  FuncPairContour1sCircleHollow(CircleHollow* circle_, Contour1s *contour_) : contour(contour_), circle(circle_) {}
189 
190  /* INHERITED INTERFACE OF DISTANCEFUNCTION */
191  double operator()(const double &alpha) {
192  fmatvec::Vec3 Wd = computeWrD(alpha);
193  return circle->getReferenceOrientation().col(2).T() * Wd;
194  }
195 
196  fmatvec::Vec3 computeWrD(const double &alpha) {
197  //if(fabs(alpha-cp.getLagrangeParameterPosition()(0))>epsroot()) { TODO this is not working in all cases
198  cp.getLagrangeParameterPosition()(0) = alpha;
199  contour->computeRootFunctionPosition(cp);
200  //}
201  return circle->getFrame()->getPosition() - cp.getFrameOfReference().getPosition();
202  }
203  /*************************************************/
204 
205  private:
209  Contour1s *contour;
210  CircleHollow *circle;
211 
216  };
217 
223  class FuncPairPointContourInterpolation : public DistanceFunction<fmatvec::VecV(fmatvec::VecV)> {
224  public:
230  FuncPairPointContourInterpolation(Point* point_, ContourInterpolation *contour_) : contour(contour_), point(point_) {}
231 
232  /* INHERITED INTERFACE OF DISTANCEFUNCTION */
233  fmatvec::VecV operator()(const fmatvec::VecV &alpha) {
234  fmatvec::Mat3xV Wt = contour->computeWt(alpha);
235  fmatvec::Vec3 WrOC[2];
236  WrOC[0] = point->getFrame()->getPosition();
237  WrOC[1] = contour->computeWrOC(alpha);
238  return Wt.T() * (WrOC[1] - WrOC[0]);
239  }
240 
241  fmatvec::Vec3 computeWrD(const fmatvec::VecV &alpha) {
242  return contour->computeWrOC(alpha) - point->getFrame()->getPosition();
243  }
244  /*************************************************/
245 
246  private:
250  ContourInterpolation *contour;
251  Point *point;
252  };
253 
259  class FuncPairConeSectionCircle : public DistanceFunction<double(double)> {
260  public:
268  FuncPairConeSectionCircle(double R_,double a_,double b_) : R(R_), a(a_), b(b_), sec_IN_ci(true) {}
269 
277  FuncPairConeSectionCircle(double R_, double a_, double b_, bool sec_IN_ci_) :
278  R(R_), a(a_), b(b_), sec_IN_ci(sec_IN_ci_) {
279  }
280 
281  /* INHERITED INTERFACE OF DISTANCEFUNCTION */
282  virtual double operator()(const double &phi) = 0;
283  double operator[](const double &phi);
284  virtual fmatvec::Vec3 computeWrD(const double &phi) = 0;
285  /*************************************************/
286 
287  /* GETTER / SETTER */
288  void setDiffVec(fmatvec::Vec3 d_);
289 
290  void setSectionCOS(fmatvec::Vec3 b1_, fmatvec::Vec3 b2_);
291  /*************************************************/
292 
293  protected:
297  double R, a, b;
298 
302  bool sec_IN_ci;
303 
307  fmatvec::Vec3 b1, b2;
308 
312  fmatvec::Vec3 d;
313  };
314 
315  inline void FuncPairConeSectionCircle::setDiffVec(fmatvec::Vec3 d_) {
316  d = d_;
317  }
318  inline void FuncPairConeSectionCircle::setSectionCOS(fmatvec::Vec3 b1_, fmatvec::Vec3 b2_) {
319  b1 = b1_;
320  b2 = b2_;
321  }
322  inline double FuncPairConeSectionCircle::operator[](const double &phi) {
323  if (sec_IN_ci)
324  return R - nrm2(computeWrD(phi));
325  else
326  return nrm2(computeWrD(phi)) - R;
327  }
328 
336  public:
344  FuncPairEllipseCircle(double R_, double a_, double b_) :
345  FuncPairConeSectionCircle(R_, a_, b_) {
346  }
347 
355  FuncPairEllipseCircle(double R_, double a_, double b_, bool el_IN_ci_) :
356  FuncPairConeSectionCircle(R_, a_, b_, el_IN_ci_) {
357  }
358 
359  /* INHERITED INTERFACE OF DISTANCEFUNCTION */
360  double operator()(const double &phi);
361  fmatvec::Vec3 computeWrD(const double &phi);
362  /*************************************************/
363 
364  /* GETTER / SETTER */
365  void setEllipseCOS(fmatvec::Vec3 b1e_, fmatvec::Vec3 b2e_);
366  /*************************************************/
367  };
368 
369  inline void FuncPairEllipseCircle::setEllipseCOS(fmatvec::Vec3 b1e_, fmatvec::Vec3 b2e_) {
370  setSectionCOS(b1e_, b2e_);
371  }
372  inline double FuncPairEllipseCircle::operator()(const double &phi) {
373  return -2 * b * (b2(0) * d(0) + b2(1) * d(1) + b2(2) * d(2)) * cos(phi) + 2 * a * (b1(0) * d(0) + b1(1) * d(1) + b1(2) * d(2)) * sin(phi) + ((a * a) - (b * b)) * sin(2 * phi);
374  }
375  inline fmatvec::Vec3 FuncPairEllipseCircle::computeWrD(const double &phi) {
376  return d + b1 * a * cos(phi) + b2 * b * sin(phi);
377  }
378 
385  public:
393  FuncPairHyperbolaCircle(double R_, double a_, double b_) :
394  FuncPairConeSectionCircle(R_, a_, b_) {
395  }
396 
404  FuncPairHyperbolaCircle(double R_, double a_, double b_, bool hy_IN_ci_) :
405  FuncPairConeSectionCircle(R_, a_, b_, hy_IN_ci_) {
406  }
407 
408  /* INHERITED INTERFACE OF DISTANCEFUNCTION */
409  double operator()(const double &phi);
410  fmatvec::Vec3 computeWrD(const double &phi);
411  /*************************************************/
412  };
413 
414  inline double FuncPairHyperbolaCircle::operator()(const double &phi) {
415  return -2 * b * (b2(0) * d(0) + b2(1) * d(1) + b2(2) * d(2)) * cosh(phi) - 2 * a * (b1(0) * d(0) + b1(1) * d(1) + b1(2) * d(2)) * sinh(phi) - ((a * a) + (b * b)) * sinh(2 * phi);
416  }
417  inline fmatvec::Vec3 FuncPairHyperbolaCircle::computeWrD(const double &phi) {
418  return d + b1 * a * cosh(phi) + b2 * b * sinh(phi);
419  }
420 
426  class JacobianPairConeSectionCircle : public Function<double(double)> {
427  public:
433  JacobianPairConeSectionCircle(double a_, double b_) :
434  a(a_), b(b_) {
435  }
436 
437  /* GETTER / SETTER */
438  void setDiffVec(fmatvec::Vec3 d_);
439  void setSectionCOS(fmatvec::Vec3 b1_, fmatvec::Vec3 b2_);
440  /*************************************************/
441 
442  protected:
446  double a, b;
447 
451  fmatvec::Vec3 b1, b2;
452 
456  fmatvec::Vec3 d;
457  };
458 
459  inline void JacobianPairConeSectionCircle::setDiffVec(fmatvec::Vec3 d_) {
460  d = d_;
461  }
462  inline void JacobianPairConeSectionCircle::setSectionCOS(fmatvec::Vec3 b1_, fmatvec::Vec3 b2_) {
463  b1 = b1_;
464  b2 = b2_;
465  }
466 
473  public:
479  JacobianPairEllipseCircle(double a_, double b_) :
481  }
482 
483  /* INHERITED INTERFACE OF FUNCTION */
484  double operator()(const double &phi);
485  /*************************************************/
486  };
487 
488  inline double JacobianPairEllipseCircle::operator()(const double &phi) {
489  return 2. * (b * (b2(0) * d(0) + b2(1) * d(1) + b2(2) * d(2)) * sin(phi) + a * (b1(0) * d(0) + b1(1) * d(1) + b1(2) * d(2)) * cos(phi) + ((a * a) - (b * b)) * cos(2 * phi));
490  }
491 
498  public:
504  JacobianPairHyperbolaCircle(double a_, double b_) :
506  }
507 
508  /* INHERITED INTERFACE OF FUNCTION */
509  double operator()(const double &phi);
510  /*************************************************/
511  };
512 
513  inline double JacobianPairHyperbolaCircle::operator()(const double &phi) {
514  return -2 * (b * (b2(0) * d(0) + b2(1) * d(1) + b2(2) * d(2)) * sinh(phi) + a * (b1(0) * d(0) + b1(1) * d(1) + b1(2) * d(2)) * cosh(phi) + ((a * a) + (b * b)) * cosh(2 * phi));
515  }
516 
523  class FuncPairContour1sLine : public DistanceFunction<double(double)> {
524  public:
530  FuncPairContour1sLine(Line* line_, Contour1s *contour_) :
531  contour(contour_), line(line_) {
532  }
533 
534  /* INHERITED INTERFACE OF DISTANCEFUNCTION */
535  virtual double operator()(const double &s) {
536  THROW_MBSIMERROR("(FuncPairContour1sLine::operator): Not implemented!");
537  //fmatvec::Vec WtC = (contour->computeWt(s)).col(0);
538  //fmatvec::Vec WnL = line->computeWn();
539  //return trans(WtC)*WnL;
540  }
541 
542  virtual fmatvec::Vec3 computeWrD(const double &s) {
543  THROW_MBSIMERROR("(FuncPairContour1sLine::computeWrD): Not implemented!");
544  //fmatvec::Vec WrOCContour = contour->computeWrOC(s);
545  //fmatvec::Vec Wn = contour->computeWn(s);
546  //double g =trans(Wn)*(WrOCContour-line->getFrame()->getPosition());
547  //return Wn*g;
548  }
549 
550  virtual double operator[](const double &s) {
551  return nrm2(computeWrD(s));
552  }
553  /*************************************************/
554 
555  private:
556  Contour1s *contour;
557  Line *line;
558  };
559 
565  class FuncPairContour1sCircleSolid : public DistanceFunction<double(double)> {
566  public:
572  FuncPairContour1sCircleSolid(CircleSolid* circle_, Contour1s *contour_) :
573  contour(contour_), circle(circle_) {
574  }
575 
576  /* INHERITED INTERFACE OF DISTANCEFUNCTION */
577  double operator()(const double &alpha) {
578  cp.getLagrangeParameterPosition()(0) = alpha;
579  fmatvec::Vec3 Wd = computeWrD(alpha);
580  fmatvec::Vec3 Wt = contour->computeTangent(cp);
581  return Wt.T() * Wd;
582  }
583 
584  fmatvec::Vec3 computeWrD(const double &alpha) {
585  cp.getLagrangeParameterPosition()(0) = alpha;
586  contour->computeRootFunctionPosition(cp);
587  contour->computeRootFunctionFirstTangent(cp);
588  contour->computeRootFunctionNormal(cp);
589  WrOC[0] = circle->getFrame()->getPosition() - circle->getRadius() * cp.getFrameOfReference().getOrientation().col(0);
590  WrOC[1] = cp.getFrameOfReference().getPosition();
591  return WrOC[1] - WrOC[0];
592  }
593  /***************************************************/
594 
595  private:
599  Contour1s *contour;
600  CircleSolid *circle;
601 
606 
610  fmatvec::Vec3 WrOC[2];
611  };
612 
624  public:
629  func(0), jac(0), s0(0.), searchAll(false) {
630  }
631 
638  Contact1sSearch(DistanceFunction<double(double)> *func_) :
639  func(func_), jac(0), s0(0.), searchAll(false) {
640  }
641 
648  Contact1sSearch(DistanceFunction<double(double)> *func_, Function<double(double)> *jac_) :
649  func(func_), jac(jac_), s0(0.), searchAll(false) {
650  }
651 
652  /* GETTER / SETTER */
653  void setFunction(DistanceFunction<double(double)> *func_) {
654  func = func_;
655  }
656 
657  void setJacobianFunction(Function<double(double)> *jac_) {
658  jac = jac_;
659  }
660 
661  void setInitialValue(const double &s0_) {
662  s0 = s0_;
663  }
664  void setNodes(const fmatvec::Vec &nodes_) {
665  nodes = nodes_;
666  }
667  void setSearchAll(bool searchAll_) {
668  searchAll = searchAll_;
669  }
670  /*************************************************/
671 
678  void setEqualSpacing(const int &n, const double &x0, const double &dx);
679 
684  double slv();
690 
691  private:
696 
700  Function<double(double)> *jac;
701 
705  double s0;
706 
711 
715  bool searchAll;
716  };
717 
727  public:
735  func(func_), jac(0), s0(2), searchAll(false) {
736  }
737 
745  func(func_), jac(jac_), s0(2), searchAll(false) {
746  }
747 
748  /* GETTER / SETTER */
749  void setInitialValue(const fmatvec::Vec2 &s0_) {
750  s0 = s0_;
751  }
752  void setNodes(const fmatvec::Vec &nodesU_, const fmatvec::Vec &nodesV_) {
753  nodesU = nodesU_;
754  nodesV = nodesV_;
755  }
756  void setSearchAll(bool searchAll_) {
757  searchAll = searchAll_;
758  }
759  /*************************************************/
760 
770  void setEqualSpacing(const int nU, const int nV, const double U0, const double V0, const double dU, const double dV);
771 
776  fmatvec::Vec2 slv();
777 
778 // /*!
779 // * \brief solve for all potential contact points
780 // * \return matrix holding LagrangeParameterPosition in col(0) and respective distances in col(1)
781 // */
782 // fmatvec::Mat slvAll();
783 
784  protected:
788  std::vector<double> searchVdirection(double u);
789 
790  private:
795 
799  Function<fmatvec::Mat(fmatvec::Mat)> *jac; // TODO::check the template type
800 
804  fmatvec::Vec2 s0;
805 
810 
814  bool searchAll;
815  };
816 }
817 
818 #endif /* FUNCTIONS_CONTACT_H_ */
819 
DistanceFunction< double(double)> * func
distance-function holding all information for contact-search
Definition: functions_contact.h:695
JacobianPairHyperbolaCircle(double a_, double b_)
constructor
Definition: functions_contact.h:504
double a
length in b1- and b2-direction
Definition: functions_contact.h:446
JacobianPairEllipseCircle(double a_, double b_)
constructor
Definition: functions_contact.h:479
double s0
initial value for Newton method
Definition: functions_contact.h:705
Definition: functions_contact.h:46
root function for planar pairing Ellipse and Circle
Definition: functions_contact.h:335
general class for contact search with respect to two contour-parameter
Definition: functions_contact.h:726
Contour1s * contour
contours
Definition: functions_contact.h:116
Function< fmatvec::Mat(fmatvec::Mat)> * jac
Jacobian of root function part of distance function.
Definition: functions_contact.h:799
FuncPairContour1sCircleHollow(CircleHollow *circle_, Contour1s *contour_)
constructor
Definition: functions_contact.h:188
virtual double operator[](const Arg &x)
Definition: functions_contact.h:69
fmatvec::Mat slvAll()
solve for all potential contact points
Definition: functions_contact.cc:92
fmatvec::Vec3 d
distance-vector of circle- and cone-section-midpoint
Definition: functions_contact.h:456
Contact1sSearch()
standard constructor
Definition: functions_contact.h:628
root function for pairing CylinderFlexible and CircleHollow
Definition: functions_contact.h:181
FuncPairPointContourInterpolation(Point *point_, ContourInterpolation *contour_)
constructor
Definition: functions_contact.h:230
FuncPairEllipseCircle(double R_, double a_, double b_, bool el_IN_ci_)
constructor
Definition: functions_contact.h:355
double nrm2(const Vector< Ref, double > &x)
FuncPairContour1sPoint(Point *point_, Contour1s *contour_)
constructor
Definition: functions_contact.h:93
DistanceFunction< fmatvec::Vec(fmatvec::Vec)> * func
distance-function holding all information for contact-search
Definition: functions_contact.h:794
root function for pairing Contour1s and Point
Definition: functions_contact.h:86
fmatvec::Vec2 s0
initial value for Newton method
Definition: functions_contact.h:804
root function for pairing Contour1s and Line
Definition: functions_contact.h:523
Contour1s * contour
contours
Definition: functions_contact.h:209
ContourPointData cp
contour point data for saving old values
Definition: functions_contact.h:605
FuncPairEllipseCircle(double R_, double a_, double b_)
constructor
Definition: functions_contact.h:344
FuncPairContour1sLine(Line *line_, Contour1s *contour_)
constructor
Definition: functions_contact.h:530
root function for pairing Contour1s and Circle
Definition: functions_contact.h:565
void setEqualSpacing(const int nU, const int nV, const double U0, const double V0, const double dU, const double dV)
set equally distanced nodes
Definition: functions_contact.cc:130
fmatvec::Vec nodesU
nodes defining search-areas for Regula-Falsi
Definition: functions_contact.h:809
double slv()
solve for the one potential contact point with minimal distance (might be negative) ...
Definition: functions_contact.cc:35
JacobianPairConeSectionCircle(double a_, double b_)
constructor
Definition: functions_contact.h:433
FuncPairHyperbolaCircle(double R_, double a_, double b_, bool hy_IN_ci_)
constructor
Definition: functions_contact.h:404
base root function for planar pairing ConeSection and Circle
Definition: functions_contact.h:259
fmatvec::Vec nodes
Definition: functions_contact.h:710
Jacobian of root function for planar pairing Ellipse and Circle.
Definition: functions_contact.h:472
fmatvec::Vec2 slv()
solve for the one potential contact point with minimal distance (might be negative) ...
Definition: functions_contact.cc:142
base Jacobian of root function for planar pairing ConeSection and Circle
Definition: functions_contact.h:426
root function for pairing Contour2s and Point
Definition: functions_contact.h:130
fmatvec::Vec3 b1
normed base-vectors of cone-section
Definition: functions_contact.h:451
Function< double(double)> * jac
Jacobian of root function part of distance function.
Definition: functions_contact.h:700
Contour1s * contour
contours
Definition: functions_contact.h:599
fmatvec::Vec3 b1
normed base-vectors of cone-section
Definition: functions_contact.h:307
general class for contact search with respect to one contour-parameter
Definition: functions_contact.h:623
Jacobian of root function for planar pairing Hyperbola and Circle.
Definition: functions_contact.h:497
ContourPointData cp
contour point data for saving old values
Definition: functions_contact.h:171
FuncPairContour2sPoint(Point *point_, Contour2s *contour_)
constructor
Definition: functions_contact.h:137
Contour2s * contour
contours
Definition: functions_contact.h:166
ContourInterpolation * contour
contours
Definition: functions_contact.h:250
bool searchAll
all area searching by Regular-Falsi or known initial value for Newton-Method?
Definition: functions_contact.h:715
FuncPairHyperbolaCircle(double R_, double a_, double b_)
constructor
Definition: functions_contact.h:393
ContourPointData cp
contour point data for saving old values
Definition: functions_contact.h:122
FuncPairConeSectionCircle(double R_, double a_, double b_, bool sec_IN_ci_)
constructor
Definition: functions_contact.h:277
struct for data-management for single point on a contour to describe contact kinematics ...
Definition: contour_pdata.h:38
root function for pairing ContourInterpolation and Point
Definition: functions_contact.h:223
Contact2sSearch(DistanceFunction< fmatvec::Vec(fmatvec::Vec)> *func_, Function< fmatvec::Mat(fmatvec::Mat)> *jac_)
constructor
Definition: functions_contact.h:744
Contact1sSearch(DistanceFunction< double(double)> *func_, Function< double(double)> *jac_)
constructor
Definition: functions_contact.h:648
ContourPointData cp
contour point data for saving old values
Definition: functions_contact.h:215
Contact1sSearch(DistanceFunction< double(double)> *func_)
constructor
Definition: functions_contact.h:638
std::vector< double > searchVdirection(double u)
solve for all potential contact points
Definition: functions_contact.cc:246
FuncPairContour1sCircleSolid(CircleSolid *circle_, Contour1s *contour_)
constructor
Definition: functions_contact.h:572
fmatvec::Vec3 d
distance-vector of cone-section- and circle-midpoint
Definition: functions_contact.h:312
FuncPairConeSectionCircle(double R_, double a_, double b_)
constructor
Definition: functions_contact.h:268
bool searchAll
all area searching by Regular-Falsi or known initial value for Newton-Method?
Definition: functions_contact.h:814
void setEqualSpacing(const int &n, const double &x0, const double &dx)
set equally distanced nodes
Definition: functions_contact.cc:28
Contact2sSearch(DistanceFunction< fmatvec::Vec(fmatvec::Vec)> *func_)
constructor
Definition: functions_contact.h:734
root function for planar pairing Hyperbola and Circle
Definition: functions_contact.h:384
double R
radius of circle as well as length in b1- and b2-direction
Definition: functions_contact.h:297
bool sec_IN_ci
cone-section in circle
Definition: functions_contact.h:302

Impressum / Disclaimer / Datenschutz Generated by doxygen 1.8.5 Valid HTML