7fd59977 |
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 | #ifdef DEB |
294 | Standard_Real nnor3 = Tan3.Magnitude(); |
295 | #else |
296 | Tan3.Magnitude(); |
297 | #endif |
298 | // Fonctions Fui. |
299 | // ============== |
300 | Fval(1) = (P3P1.Dot(P3P1)-X(4)*X(4))/(FirstRad*FirstRad); |
301 | Fval(2) = (P2P3.Dot(P2P3)-X(4)*X(4))/(FirstRad*FirstRad); |
302 | Fval(3) = P3P1.Dot(Tan1)/(nnor1*FirstRad); |
303 | Fval(4) = P2P3.Dot(Tan2)/(nnor2*FirstRad); |
304 | return Standard_True; |
305 | } |
306 | |
307 | Standard_Boolean GccIter_FunctionTanCuCuOnCu:: |
308 | Derivatives (const math_Vector& X , |
309 | math_Matrix& Deriv ) { |
310 | gp_Pnt2d Point1,Point2,Point3; |
311 | gp_Vec2d Tan1,Tan2,Tan3; |
312 | gp_Vec2d D21,D22,D23; |
313 | InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23); |
314 | //pipj (normes) et PiPj (non Normes). |
315 | gp_Vec2d P1P2(Point1,Point2); |
316 | gp_Vec2d P2P3(Point2,Point3); |
317 | gp_Vec2d P3P1(Point3,Point1); |
318 | gp_Vec2d p1p2,p2p3,p3p1; |
319 | // if (FirstRad < 1.) {FirstRad = 1.; } |
320 | p1p2 = P1P2/FirstRad; |
321 | p2p3 = P2P3/FirstRad; |
322 | p3p1 = P3P1/FirstRad; |
323 | //normales au courbes normees Nori et non nromees nori et norme des nori. |
324 | Standard_Real nnor1 = Tan1.Magnitude(); |
325 | Standard_Real nnor2 = Tan2.Magnitude(); |
326 | #ifdef DEB |
327 | Standard_Real nnor3 = Tan3.Magnitude(); |
328 | #else |
329 | Tan3.Magnitude(); |
330 | #endif |
331 | // Derivees dFui/uj 1 <= ui <= 3 , 1 <= uj <= 3 |
332 | // ============================================= |
333 | Deriv(1,1) = 2.*Tan1.Dot(P3P1)/(FirstRad*FirstRad); |
334 | Deriv(1,2) = 0.; |
335 | Deriv(1,3) = -2.*Tan3.Dot(P3P1)/(FirstRad*FirstRad); |
336 | Deriv(1,4) = -2.*X(4)/(FirstRad*FirstRad); |
337 | |
338 | Deriv(2,1) = 0.; |
339 | Deriv(2,2) = -2.*Tan2.Dot(P2P3)/(FirstRad*FirstRad); |
340 | Deriv(2,3) = 2.*Tan3.Dot(P2P3)/(FirstRad*FirstRad); |
341 | Deriv(2,4) = -2.*X(4)/(FirstRad*FirstRad); |
342 | |
343 | Deriv(3,1) = (P3P1.Dot(D21)+Tan1.Dot(Tan1))/(FirstRad*nnor1)- |
344 | (P3P1.Dot(Tan1)*D21.Dot(Tan1))/(FirstRad*nnor1*nnor1*nnor1); |
345 | Deriv(3,2) = 0.; |
346 | Deriv(3,3) = -(Tan3.Dot(Tan1))/(FirstRad*nnor1); |
347 | Deriv(3,4) = 0.; |
348 | |
349 | Deriv(4,1) = 0.; |
350 | Deriv(4,2) = (P2P3.Dot(D22)-Tan2.Dot(Tan2))/(FirstRad*nnor2)- |
351 | P2P3.Dot(Tan2)*Tan2.Dot(D22)/(FirstRad*nnor2*nnor2*nnor2); |
352 | Deriv(4,3) = Tan3.Dot(Tan2)/(FirstRad*nnor1); |
353 | Deriv(4,4) = 0.; |
354 | return Standard_True; |
355 | } |
356 | |
357 | Standard_Boolean GccIter_FunctionTanCuCuOnCu:: |
358 | Values (const math_Vector& X , |
359 | math_Vector& Fval , |
360 | math_Matrix& Deriv ) { |
361 | gp_Pnt2d Point1,Point2,Point3; |
362 | gp_Vec2d Tan1,Tan2,Tan3; |
363 | gp_Vec2d D21,D22,D23; |
364 | InitDerivative(X,Point1,Point2,Point3,Tan1,Tan2,Tan3,D21,D22,D23); |
365 | //pipj (normes) et PiPj (non Normes). |
366 | gp_Vec2d P1P2(Point1,Point2); |
367 | gp_Vec2d P2P3(Point2,Point3); |
368 | gp_Vec2d P3P1(Point3,Point1); |
369 | gp_Vec2d p1p2,p2p3,p3p1; |
370 | // if (FirstRad < 1.) {FirstRad = 1.; } |
371 | p1p2 = P1P2/FirstRad; |
372 | p2p3 = P2P3/FirstRad; |
373 | p3p1 = P3P1/FirstRad; |
374 | //normales au courbes normees Nori et non nromees nori et norme des nori. |
375 | Standard_Real nnor1 = Tan1.Magnitude(); |
376 | Standard_Real nnor2 = Tan2.Magnitude(); |
377 | #ifdef DEB |
378 | Standard_Real nnor3 = Tan3.Magnitude(); |
379 | #else |
380 | Tan3.Magnitude(); |
381 | #endif |
382 | // Fonctions Fui. |
383 | // ============== |
384 | Fval(1) = (P3P1.Dot(P3P1)-X(4)*X(4))/(FirstRad*FirstRad); |
385 | Fval(2) = (P2P3.Dot(P2P3)-X(4)*X(4))/(FirstRad*FirstRad); |
386 | Fval(3) = P3P1.Dot(Tan1)/(nnor1*FirstRad); |
387 | Fval(4) = P2P3.Dot(Tan2)/(nnor2*FirstRad); |
388 | // Derivees dFui/uj 1 <= ui <= 3 , 1 <= uj <= 3 |
389 | // ============================================= |
390 | Deriv(1,1) = 2.*Tan1.Dot(P3P1)/(FirstRad*FirstRad); |
391 | Deriv(1,2) = 0.; |
392 | Deriv(1,3) = -2.*Tan3.Dot(P3P1)/(FirstRad*FirstRad); |
393 | Deriv(1,4) = -2.*X(4)/(FirstRad*FirstRad); |
394 | |
395 | Deriv(2,1) = 0.; |
396 | Deriv(2,2) = -2.*Tan2.Dot(P2P3)/(FirstRad*FirstRad); |
397 | Deriv(2,3) = 2.*Tan3.Dot(P2P3)/(FirstRad*FirstRad); |
398 | Deriv(2,4) = -2.*X(4)/(FirstRad*FirstRad); |
399 | |
400 | Deriv(3,1) = (P3P1.Dot(D21)+Tan1.Dot(Tan1))/(FirstRad*nnor1)- |
401 | (P3P1.Dot(Tan1)*D21.Dot(Tan1))/(FirstRad*nnor1*nnor1*nnor1); |
402 | Deriv(3,2) = 0.; |
403 | Deriv(3,3) = -(Tan3.Dot(Tan1))/(FirstRad*nnor1); |
404 | Deriv(3,4) = 0.; |
405 | |
406 | Deriv(4,1) = 0.; |
407 | Deriv(4,2) = (P2P3.Dot(D22)-Tan2.Dot(Tan2))/(FirstRad*nnor2)- |
408 | P2P3.Dot(Tan2)*Tan2.Dot(D22)/(FirstRad*nnor2*nnor2*nnor2); |
409 | Deriv(4,3) = Tan3.Dot(Tan2)/(FirstRad*nnor1); |
410 | Deriv(4,4) = 0.; |
411 | return Standard_True; |
412 | } |
413 | |