src/GccIter/GccIter_FunctionTanCuCuOnCu.gxx

   1 // File:        GccIter_FunctionTanCuCuOnCu.cxx
   2 // Created:     Mon Jan 20 16:35:40 1992
   3 // Author:      Remi GILET
   4 //              <reg@phobox>
   5
   6 #include <Standard_ConstructionError.hxx>
   7 #include <ElCLib.hxx>
   8
   9 void GccIter_FunctionTanCuCuOnCu::
  10   InitDerivative(const math_Vector&  X,
  11                        gp_Pnt2d&     Point1,
  12                        gp_Pnt2d&     Point2,
  13                        gp_Pnt2d&     Point3,
  14                        gp_Vec2d&     Tan1,
  15                        gp_Vec2d&     Tan2,
  16                        gp_Vec2d&     Tan3,
  17                        gp_Vec2d&     D21,
  18                        gp_Vec2d&     D22,
  19                        gp_Vec2d&     D23) {
  20   switch (TheType) {
  21   case GccIter_CuCuOnCu:
  22     {
  23       TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
  24       TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
  25       TheCurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
  26     }
  27     break;
  28   case GccIter_CiCuOnCu:
  29     {
  30       ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
  31       TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
  32       TheCurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
  33     }
  34     break;
  35   case GccIter_LiCuOnCu:
  36     {
  37       ElCLib::D1(X(1),Lin1,Point1,Tan1);
  38       D21 = gp_Vec2d(0.,0.);
  39       TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
  40       TheCurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
  41     }
  42     break;
  43   case GccIter_CuPtOnCu:
  44     {
  45       TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
  46       TheCurveTool::D2(Curvon,X(3),Point3,Tan3,D23);
  47       Point2 = Pnt2;
  48       Tan2 = gp_Vec2d(0.,0.);
  49       D22 = gp_Vec2d(0.,0.);
  50     }
  51     break;
  52   case GccIter_CuCuOnCi:
  53     {
  54       TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
  55       TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
  56       ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
  57     }
  58     break;
  59   case GccIter_CiCuOnCi:
  60     {
  61       ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
  62       TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
  63       ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
  64     }
  65     break;
  66   case GccIter_LiCuOnCi:
  67     {
  68       ElCLib::D1(X(1),Lin1,Point1,Tan1);
  69       D21 = gp_Vec2d(0.,0.);
  70       TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
  71       ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
  72     }
  73     break;
  74   case GccIter_CuPtOnCi:
  75     {
  76       TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
  77       Point2 = Pnt2;
  78       Tan2 = gp_Vec2d(0.,0.);
  79       D22 = gp_Vec2d(0.,0.);
  80       ElCLib::D2(X(3),Circon,Point3,Tan3,D23);
  81     }
  82     break;
  83   case GccIter_CuCuOnLi:
  84     {
  85       TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
  86       TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
  87       ElCLib::D1(X(3),Linon,Point3,Tan3);
  88       D23 = gp_Vec2d(0.,0.);
  89     }
  90     break;
  91   case GccIter_CiCuOnLi:
  92     {
  93       ElCLib::D2(X(1),Circ1,Point1,Tan1,D21);
  94       TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
  95       ElCLib::D1(X(3),Linon,Point3,Tan3);
  96       D23 = gp_Vec2d(0.,0.);
  97     }
  98     break;
  99   case GccIter_LiCuOnLi:
 100     {
 101       ElCLib::D1(X(1),Lin1,Point1,Tan1);
 102       TheCurveTool::D2(Curv2,X(2),Point2,Tan2,D22);
 103       D21 = gp_Vec2d(0.,0.);
 104       ElCLib::D1(X(3),Linon,Point3,Tan3);
 105       D23 = gp_Vec2d(0.,0.);
 106     }
 107     break;
 108   case GccIter_CuPtOnLi:
 109     {
 110       TheCurveTool::D2(Curv1,X(1),Point1,Tan1,D21);
 111       Point2 = Pnt2;
 112       Tan2 = gp_Vec2d(0.,0.);
 113       D22 = gp_Vec2d(0.,0.);
 114       ElCLib::D1(X(3),Linon,Point3,Tan3);
 115       D23 = gp_Vec2d(0.,0.);
 116     }
 117     break;
 118   default:
 119     {
 120       Standard_ConstructionError::Raise();
 121     }
 122   }
 123 }
 124
 125 GccIter_FunctionTanCuCuOnCu::
 126   GccIter_FunctionTanCuCuOnCu(const TheCurve&     C1  ,
 127                              const TheCurve&     C2  ,
 128                              const TheCurve&     C3  ,
 129                              const Standard_Real Rad ) {
 130   Curv1  = C1;
 131   Curv2  = C2;
 132   Curvon = C3;
 133   FirstRad = Rad;
 134   TheType = GccIter_CuCuOnCu;
 135 }
 136
 137 GccIter_FunctionTanCuCuOnCu::
 138   GccIter_FunctionTanCuCuOnCu(const gp_Circ2d&    C1  ,
 139                              const TheCurve&     C2  ,
 140                              const TheCurve&     C3  ,
 141                              const Standard_Real Rad ) {
 142   Circ1  = C1;
 143   Curv2  = C2;
 144   Curvon = C3;
 145   FirstRad = Rad;
 146   TheType = GccIter_CiCuOnCu;
 147 }
 148
 149 GccIter_FunctionTanCuCuOnCu::
 150   GccIter_FunctionTanCuCuOnCu(const gp_Lin2d&     L1  ,
 151                              const TheCurve&     C2  ,
 152                              const TheCurve&     C3  ,
 153                              const Standard_Real Rad ) {
 154   Lin1  = L1;
 155   Curv2  = C2;
 156   Curvon = C3;
 157   FirstRad = Rad;
 158   TheType = GccIter_LiCuOnCu;
 159 }
 160
 161 GccIter_FunctionTanCuCuOnCu::
 162   GccIter_FunctionTanCuCuOnCu(const TheCurve& C1  ,
 163                              const gp_Pnt2d&  P2  ,
 164                              const TheCurve&  C3  ,
 165                              const Standard_Real       Rad ) {
 166   Curv1  = C1;
 167   Pnt2  = P2;
 168   Curvon = C3;
 169   FirstRad = Rad;
 170   TheType = GccIter_CuPtOnCu;
 171 }
 172
 173 GccIter_FunctionTanCuCuOnCu::
 174   GccIter_FunctionTanCuCuOnCu(const TheCurve& C1   ,
 175                              const TheCurve&  C2   ,
 176                              const gp_Lin2d&  OnLi ,
 177                              const Standard_Real       Rad  ) {
 178   Curv1  = C1;
 179   Curv2  = C2;
 180   Linon = OnLi;
 181   FirstRad = Rad;
 182   TheType = GccIter_CuCuOnLi;
 183 }
 184
 185 GccIter_FunctionTanCuCuOnCu::
 186   GccIter_FunctionTanCuCuOnCu(const gp_Circ2d&           C1   ,
 187                                const TheCurve& C2   ,
 188                                const gp_Lin2d&            OnLi ,
 189                                const Standard_Real                 Rad  ) {
 190   Circ1  = C1;
 191   Curv2  = C2;
 192   Linon = OnLi;
 193   FirstRad = Rad;
 194   TheType = GccIter_CiCuOnLi;
 195 }
 196
 197 GccIter_FunctionTanCuCuOnCu::
 198   GccIter_FunctionTanCuCuOnCu(const gp_Lin2d& L1  ,
 199                                const TheCurve&  C2  ,
 200                                const gp_Lin2d&  OnLi ,
 201                                const Standard_Real       Rad ) {
 202   Lin1  = L1;
 203   Curv2  = C2;
 204   Linon = OnLi;
 205   FirstRad = Rad;
 206   TheType = GccIter_LiCuOnLi;
 207 }
 208
 209 GccIter_FunctionTanCuCuOnCu::
 210   GccIter_FunctionTanCuCuOnCu(const TheCurve& C1  ,
 211                                const gp_Pnt2d&            P2  ,
 212                                const gp_Lin2d&            OnLi ,
 213                                const Standard_Real                 Rad ) {
 214   Curv1  = C1;
 215   Pnt2  = P2;
 216   Linon = OnLi;
 217   FirstRad = Rad;
 218   TheType = GccIter_CuPtOnLi;
 219 }
 220
 221 GccIter_FunctionTanCuCuOnCu::
 222   GccIter_FunctionTanCuCuOnCu(const TheCurve& C1   ,
 223                                const TheCurve& C2   ,
 224                                const gp_Circ2d&           OnCi ,
 225                                const Standard_Real                 Rad  ) {
 226   Curv1  = C1;
 227   Curv2  = C2;
 228   Circon = OnCi;
 229   FirstRad = Rad;
 230   TheType = GccIter_CuCuOnCi;
 231 }
 232
 233 GccIter_FunctionTanCuCuOnCu::
 234   GccIter_FunctionTanCuCuOnCu(const gp_Circ2d&           C1  ,
 235                                const TheCurve& C2  ,
 236                                const gp_Circ2d&           OnCi ,
 237                                const Standard_Real                 Rad ) {
 238   Circ1  = C1;
 239   Curv2  = C2;
 240   Circon = OnCi;
 241   FirstRad = Rad;
 242   TheType = GccIter_CuCuOnCi;
 243 }
 244
 245 GccIter_FunctionTanCuCuOnCu::
 246   GccIter_FunctionTanCuCuOnCu(const gp_Lin2d& L1  ,
 247                                const TheCurve&  C2  ,
 248                                const gp_Circ2d& OnCi ,
 249                                const Standard_Real       Rad ) {
 250   Lin1  = L1;
 251   Curv2  = C2;
 252   Circon = OnCi;
 253   FirstRad = Rad;
 254   TheType = GccIter_LiCuOnCi;
 255 }
 256
 257 GccIter_FunctionTanCuCuOnCu::
 258   GccIter_FunctionTanCuCuOnCu(const TheCurve& C1  ,
 259                                const gp_Pnt2d&            P2  ,
 260                                const gp_Circ2d&           OnCi ,
 261                                const Standard_Real                 Rad ) {
 262   Curv1  = C1;
 263   Pnt2  = P2;
 264   Circon = OnCi;
 265   FirstRad = Rad;
 266   TheType = GccIter_CuPtOnCi;
 267 }
 268
 269 Standard_Integer GccIter_FunctionTanCuCuOnCu::
 270   NbVariables () const { return 4; }
 271
 272 Standard_Integer GccIter_FunctionTanCuCuOnCu::
 273   NbEquations () const { return 4; }
 274
 275 Standard_Boolean GccIter_FunctionTanCuCuOnCu::
 276   Value (const math_Vector& X    ,
 277                math_Vector& Fval ) {
 278   gp_Pnt2d Point1,Point2,Point3;
 279   gp_Vec2d Tan1,Tan2,Tan3,D21,D22,D23;
 280   InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23);
 281 //pipj (normes) et PiPj (non Normes).
 282   gp_Vec2d P1P2(Point1,Point2);
 283   gp_Vec2d P2P3(Point2,Point3);
 284   gp_Vec2d P3P1(Point3,Point1);
 285   gp_Vec2d p1p2,p2p3,p3p1;
 286 //  if (FirstRad < 1.) {FirstRad = 1.; }
 287   p1p2 = P1P2/FirstRad;
 288   p2p3 = P2P3/FirstRad;
 289   p3p1 = P3P1/FirstRad;
 290 //norme des Tani.
 291   Standard_Real nnor1 = Tan1.Magnitude();
 292   Standard_Real nnor2 = Tan2.Magnitude();
 293 // Fonctions Fui.
 294 // ==============
 295   Fval(1) = (P3P1.Dot(P3P1)-X(4)*X(4))/(FirstRad*FirstRad);
 296   Fval(2) = (P2P3.Dot(P2P3)-X(4)*X(4))/(FirstRad*FirstRad);
 297   Fval(3) = P3P1.Dot(Tan1)/(nnor1*FirstRad);
 298   Fval(4) = P2P3.Dot(Tan2)/(nnor2*FirstRad);
 299   return Standard_True;
 300 }
 301
 302 Standard_Boolean GccIter_FunctionTanCuCuOnCu::
 303   Derivatives (const math_Vector& X     ,
 304                      math_Matrix& Deriv ) {
 305   gp_Pnt2d Point1,Point2,Point3;
 306   gp_Vec2d Tan1,Tan2,Tan3;
 307   gp_Vec2d D21,D22,D23;
 308   InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23);
 309 //pipj (normes) et PiPj (non Normes).
 310   gp_Vec2d P1P2(Point1,Point2);
 311   gp_Vec2d P2P3(Point2,Point3);
 312   gp_Vec2d P3P1(Point3,Point1);
 313   gp_Vec2d p1p2,p2p3,p3p1;
 314 //  if (FirstRad < 1.) {FirstRad = 1.; }
 315   p1p2 = P1P2/FirstRad;
 316   p2p3 = P2P3/FirstRad;
 317   p3p1 = P3P1/FirstRad;
 318 //normales au courbes normees Nori et non nromees nori et norme des nori.
 319   Standard_Real nnor1 = Tan1.Magnitude();
 320   Standard_Real nnor2 = Tan2.Magnitude();
 321 // Derivees dFui/uj  1 <= ui <= 3 , 1 <= uj <= 3
 322 // =============================================
 323   Deriv(1,1) = 2.*Tan1.Dot(P3P1)/(FirstRad*FirstRad);
 324   Deriv(1,2) = 0.;
 325   Deriv(1,3) = -2.*Tan3.Dot(P3P1)/(FirstRad*FirstRad);
 326   Deriv(1,4) = -2.*X(4)/(FirstRad*FirstRad);
 327
 328   Deriv(2,1) = 0.;
 329   Deriv(2,2) = -2.*Tan2.Dot(P2P3)/(FirstRad*FirstRad);
 330   Deriv(2,3) = 2.*Tan3.Dot(P2P3)/(FirstRad*FirstRad);
 331   Deriv(2,4) = -2.*X(4)/(FirstRad*FirstRad);
 332
 333   Deriv(3,1) = (P3P1.Dot(D21)+Tan1.Dot(Tan1))/(FirstRad*nnor1)-
 334     (P3P1.Dot(Tan1)*D21.Dot(Tan1))/(FirstRad*nnor1*nnor1*nnor1);
 335   Deriv(3,2) = 0.;
 336   Deriv(3,3) = -(Tan3.Dot(Tan1))/(FirstRad*nnor1);
 337   Deriv(3,4) = 0.;
 338
 339   Deriv(4,1) = 0.;
 340   Deriv(4,2) = (P2P3.Dot(D22)-Tan2.Dot(Tan2))/(FirstRad*nnor2)-
 341     P2P3.Dot(Tan2)*Tan2.Dot(D22)/(FirstRad*nnor2*nnor2*nnor2);
 342   Deriv(4,3) = Tan3.Dot(Tan2)/(FirstRad*nnor1);
 343   Deriv(4,4) = 0.;
 344   return Standard_True;
 345 }
 346
 347 Standard_Boolean GccIter_FunctionTanCuCuOnCu::
 348   Values (const math_Vector& X     ,
 349                 math_Vector& Fval  ,
 350                 math_Matrix& Deriv ) {
 351   gp_Pnt2d Point1,Point2,Point3;
 352   gp_Vec2d Tan1,Tan2,Tan3;
 353   gp_Vec2d D21,D22,D23;
 354   InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23);
 355 //pipj (normes) et PiPj (non Normes).
 356   gp_Vec2d P1P2(Point1,Point2);
 357   gp_Vec2d P2P3(Point2,Point3);
 358   gp_Vec2d P3P1(Point3,Point1);
 359   gp_Vec2d p1p2,p2p3,p3p1;
 360 //  if (FirstRad < 1.) {FirstRad = 1.; }
 361   p1p2 = P1P2/FirstRad;
 362   p2p3 = P2P3/FirstRad;
 363   p3p1 = P3P1/FirstRad;
 364 //normales au courbes normees Nori et non nromees nori et norme des nori.
 365   Standard_Real nnor1 = Tan1.Magnitude();
 366   Standard_Real nnor2 = Tan2.Magnitude();
 367 // Fonctions Fui.
 368 // ==============
 369   Fval(1) = (P3P1.Dot(P3P1)-X(4)*X(4))/(FirstRad*FirstRad);
 370   Fval(2) = (P2P3.Dot(P2P3)-X(4)*X(4))/(FirstRad*FirstRad);
 371   Fval(3) = P3P1.Dot(Tan1)/(nnor1*FirstRad);
 372   Fval(4) = P2P3.Dot(Tan2)/(nnor2*FirstRad);
 373 // Derivees dFui/uj  1 <= ui <= 3 , 1 <= uj <= 3
 374 // =============================================
 375   Deriv(1,1) = 2.*Tan1.Dot(P3P1)/(FirstRad*FirstRad);
 376   Deriv(1,2) = 0.;
 377   Deriv(1,3) = -2.*Tan3.Dot(P3P1)/(FirstRad*FirstRad);
 378   Deriv(1,4) = -2.*X(4)/(FirstRad*FirstRad);
 379
 380   Deriv(2,1) = 0.;
 381   Deriv(2,2) = -2.*Tan2.Dot(P2P3)/(FirstRad*FirstRad);
 382   Deriv(2,3) = 2.*Tan3.Dot(P2P3)/(FirstRad*FirstRad);
 383   Deriv(2,4) = -2.*X(4)/(FirstRad*FirstRad);
 384
 385   Deriv(3,1) = (P3P1.Dot(D21)+Tan1.Dot(Tan1))/(FirstRad*nnor1)-
 386     (P3P1.Dot(Tan1)*D21.Dot(Tan1))/(FirstRad*nnor1*nnor1*nnor1);
 387   Deriv(3,2) = 0.;
 388   Deriv(3,3) = -(Tan3.Dot(Tan1))/(FirstRad*nnor1);
 389   Deriv(3,4) = 0.;
 390
 391   Deriv(4,1) = 0.;
 392   Deriv(4,2) = (P2P3.Dot(D22)-Tan2.Dot(Tan2))/(FirstRad*nnor2)-
 393     P2P3.Dot(Tan2)*Tan2.Dot(D22)/(FirstRad*nnor2*nnor2*nnor2);
 394   Deriv(4,3) = Tan3.Dot(Tan2)/(FirstRad*nnor1);
 395   Deriv(4,4) = 0.;
 396   return Standard_True;
 397 }
 398