0022550: Fixing data races
[occt.git] / src / Plate / Plate_Plate.cxx
1 // File:        Plate_Plate.cxx
2 // Created:     Thu Oct 19 19:28:16 1995
3 // Author:      Andre LIEUTIER
4 //              <ds@sgi63>
5 // 26-Mar-96 : xab : inclusion des inlines trop gros 
6 // 15-Oct-96 : alr : extraction des inlines (pas tous ceux inclus par xab)
7 // 19-Fev-97 : jct : ajout des methodes UVBox et UVConstraints (G1134)
8 // 10-Dec-97 : jag : Gros debug sur delete, et sur la methode Copy...
9 // 13-Jan-98 : alr : ajout des derivees pour contraintes G3 et approx. C2
10 // 28-Avr-98 : alr : Prise en compte des Linear*Constraint, methodes SolveTI1,SolveTI2,SolveTI3
11
12 #include <Standard_ErrorHandler.hxx>
13
14 #include <gp_XY.hxx>
15 #include <gp_XYZ.hxx>
16 #include <math_Matrix.hxx>
17 #include <math_Vector.hxx>
18 #include <math_Gauss.hxx>
19
20 #include <Plate_Plate.ixx>
21
22
23 //=======================================================================
24 //function : Plate_Plate
25 //purpose  : 
26 //=======================================================================
27
28 Plate_Plate::Plate_Plate()
29 : order(0), n_el(0), n_dim(0),
30   solution(0),points(0),deru(0),derv(0),
31   OK(Standard_False),maxConstraintOrder(0),
32   Uold (1.e20),
33   Vold (1.e20),
34   U2 (0.0),
35   R (0.0),
36   L (0.0)
37 {
38   PolynomialPartOnly = Standard_False;
39 }
40
41 //=======================================================================
42 //function : Plate_Plate
43 //purpose  : 
44 //=======================================================================
45
46 Plate_Plate::Plate_Plate(const Plate_Plate& Ref)
47 : order(Ref.order),n_el(Ref.n_el),n_dim(Ref.n_dim),
48   solution(0),points(0),deru(0),derv(0),
49   OK (Ref.OK),
50   Uold (1.e20),
51   Vold (1.e20),
52   U2 (0.0),
53   R (0.0),
54   L (0.0)
55 {
56   Standard_Integer i;
57   if (Ref.OK) {
58     if (n_dim >0 && Ref.solution != 0) {
59       solution = new gp_XYZ[n_dim];
60       for(i=0; i<n_dim ;i++) {
61         Solution(i) = Ref.Solution(i);
62       }
63     }
64     
65     if (n_el >0) {
66       if (Ref.points != 0) {
67         points = new gp_XY[n_el];
68         for(i=0; i<n_el;i++) {
69           Points(i) = Ref.Points(i);
70         }
71       }
72       
73       if (Ref.deru != 0) {
74         deru = new Standard_Integer[n_el] ;
75         for (i = 0 ; i < n_el ; i++) {
76           Deru(i) = Ref.Deru(i);
77         }
78       }
79       
80       if (Ref.derv != 0) {
81         derv = new Standard_Integer[n_el] ;
82         for (i = 0 ; i < n_el ; i++) {
83           Derv(i) = Ref.Derv(i);
84         }
85       }
86     }
87   }
88
89   myConstraints = Ref.myConstraints;
90   myLXYZConstraints = Ref.myLXYZConstraints;
91   myLScalarConstraints = Ref.myLScalarConstraints;
92   maxConstraintOrder = Ref.maxConstraintOrder;
93   PolynomialPartOnly = Ref.PolynomialPartOnly;
94   for (i=0; i<10;i++) {
95     ddu[i]=Ref.ddu[i];
96     ddv[i]=Ref.ddv[i];
97   }
98 }
99 //=======================================================================
100 //function : Copy
101 //purpose  : 
102 //=======================================================================
103  Plate_Plate& Plate_Plate::Copy(const Plate_Plate& Ref) 
104 {
105   Init();
106    order = Ref.order;
107    n_el = Ref.n_el;
108    n_dim = Ref.n_dim;
109    OK = Ref.OK;
110   Standard_Integer i;
111   if (Ref.OK) {
112     if (n_dim >0 && Ref.solution != 0) {
113       solution = new gp_XYZ[n_dim];
114       for(i=0; i<n_dim ;i++) {
115         Solution(i) = Ref.Solution(i);
116       }
117     }
118     
119     if (n_el >0) {
120       if (Ref.points != 0) {
121         points = new gp_XY[n_el];
122         for(i=0; i<n_el;i++) {
123           Points(i) = Ref.Points(i);
124         }
125       }
126       
127       if (Ref.deru != 0) {
128         deru = new Standard_Integer[n_el] ;
129         for (i = 0 ; i < n_el ; i++) {
130           Deru(i) = Ref.Deru(i);
131         }
132       }
133       
134       if (Ref.derv != 0) {
135         derv = new Standard_Integer[n_el] ;
136         for (i = 0 ; i < n_el ; i++) {
137           Derv(i) = Ref.Derv(i);
138         }
139       }
140     }
141   }
142
143   myConstraints = Ref.myConstraints;
144   myLXYZConstraints = Ref.myLXYZConstraints;
145   myLScalarConstraints = Ref.myLScalarConstraints;
146   maxConstraintOrder = Ref.maxConstraintOrder;
147   PolynomialPartOnly = Ref.PolynomialPartOnly;
148
149    for (i=0; i<10;i++) {
150     ddu[i]=Ref.ddu[i];
151     ddv[i]=Ref.ddv[i];
152   }
153   return *this;
154 }
155 //=======================================================================
156 //function : Load
157 //purpose  : 
158 //=======================================================================
159
160 void Plate_Plate::Load(const Plate_PinpointConstraint& PConst)
161 {
162   OK = Standard_False;
163   n_el++;
164   myConstraints.Append(PConst);
165   Standard_Integer OrdreConst = PConst.Idu() + PConst.Idv();
166   if(maxConstraintOrder<OrdreConst) maxConstraintOrder = OrdreConst;
167 }
168
169  void Plate_Plate::Load(const Plate_LinearXYZConstraint& LXYZConst) 
170 {
171   OK = Standard_False;
172   n_el += LXYZConst.Coeff().RowLength();
173
174   myLXYZConstraints.Append(LXYZConst);
175   for(Standard_Integer j=1;j <= LXYZConst.GetPPC().Length() ; j++)
176     {
177       Standard_Integer OrdreConst = LXYZConst.GetPPC()(j).Idu() + LXYZConst.GetPPC()(j).Idv();
178       if(maxConstraintOrder<OrdreConst) maxConstraintOrder = OrdreConst;
179   }
180 }
181
182  void Plate_Plate::Load(const Plate_LinearScalarConstraint& LScalarConst) 
183 {
184   OK = Standard_False;
185   n_el += LScalarConst.Coeff().RowLength();
186   myLScalarConstraints.Append(LScalarConst);
187   for(Standard_Integer j=1;j <= LScalarConst.GetPPC().Length() ; j++)
188     {
189       Standard_Integer OrdreConst = LScalarConst.GetPPC()(j).Idu() + LScalarConst.GetPPC()(j).Idv();
190       if(maxConstraintOrder<OrdreConst) maxConstraintOrder = OrdreConst;
191   }
192 }
193
194 void Plate_Plate::Load(const Plate_LineConstraint& LConst)
195 {
196   Load(LConst.LSC());
197 }
198
199 void Plate_Plate::Load(const Plate_PlaneConstraint& PConst)
200 {
201   Load(PConst.LSC());
202 }
203
204 void Plate_Plate::Load(const Plate_SampledCurveConstraint& SCConst)
205 {
206   Load(SCConst.LXYZC());
207 }
208
209 void Plate_Plate::Load(const Plate_GtoCConstraint& GtoCConst)
210 {
211   for(Standard_Integer i=0;i< GtoCConst.nb_PPC();i++) 
212     Load(GtoCConst.GetPPC(i));
213 }
214
215 void Plate_Plate::Load(const Plate_FreeGtoCConstraint& FGtoCConst) 
216 {
217   Standard_Integer i ;
218   for( i=0;i< FGtoCConst.nb_PPC();i++) 
219     Load(FGtoCConst.GetPPC(i));
220   for(i=0;i< FGtoCConst.nb_LSC();i++) 
221     Load(FGtoCConst.LSC(i));
222 }
223
224 void Plate_Plate::Load(const Plate_GlobalTranslationConstraint& GTConst) 
225 {
226   Load(GTConst.LXYZC());
227 }
228
229 //=======================================================================
230 //function : SolveTI
231 //purpose  : to solve the set of constraints
232 //=======================================================================
233
234 void Plate_Plate::SolveTI(const Standard_Integer ord, 
235                           const Standard_Real anisotropie)
236 {
237   Standard_Integer IterationNumber=0;
238   OK = Standard_False;
239   order = ord;
240   if(ord <=1) return;
241   if(ord > 9) return;
242   if(n_el<1) return;
243   if(anisotropie < 1.e-6) return;
244   if(anisotropie > 1.e+6) return;
245
246 // computation of the bounding box of the 2d PPconstraints
247   Standard_Real xmin,xmax,ymin,ymax;
248   UVBox(xmin,xmax,ymin,ymax);
249
250   Standard_Real du = 0.5*(xmax - xmin);
251   if(anisotropie >1.) du *= anisotropie;
252   if(du < 1.e-10) return;
253   ddu[0] = 1;
254   Standard_Integer i ;
255   for( i=1;i<=9;i++) ddu[i] = ddu[i-1] / du;
256
257   Standard_Real dv = 0.5*(ymax - ymin);
258   if(anisotropie <1.) dv /= anisotropie;
259   if(dv < 1.e-10) return;
260   ddv[0] = 1;
261   for(i=1;i<=9;i++) ddv[i] = ddv[i-1] / dv;
262
263
264   if(myLScalarConstraints.IsEmpty())
265     {
266       if(myLXYZConstraints.IsEmpty())
267         SolveTI1(IterationNumber);
268       else
269         SolveTI2(IterationNumber);
270     }
271   else
272     SolveTI3(IterationNumber);
273
274 }
275
276 //=======================================================================
277 //function : SolveTI1
278 //purpose  : to solve the set of constraints in the easiest case,
279 //           only PinPointConstraints are loaded
280 //=======================================================================
281
282 void Plate_Plate::SolveTI1(const Standard_Integer IterationNumber)
283 {
284 // computation of square matrix members
285
286
287   n_dim = n_el + order*(order+1)/2;
288   math_Matrix mat(0, n_dim-1, 0, n_dim-1, 0.);
289   
290   delete [] (gp_XY*)points;
291   points = new gp_XY[n_el];
292   Standard_Integer i ;
293   for( i=0; i<n_el;i++)  Points(i) = myConstraints(i+1).Pnt2d();
294
295   delete [] (Standard_Integer*)deru;
296   deru = new Standard_Integer[n_el];
297   for(i=0; i<n_el;i++)  Deru(i) = myConstraints(i+1).Idu();
298
299   delete [] (Standard_Integer*)derv;
300   derv = new Standard_Integer[n_el];
301   for(i=0; i<n_el;i++)  Derv(i) = myConstraints(i+1).Idv();
302
303   for(i=0; i<n_el;i++) {
304     for(Standard_Integer j=0;j<i;j++) {
305       Standard_Real signe = 1;
306       if ( ((Deru(j)+Derv(j))%2) == 1) signe = -1;
307       Standard_Integer iu =  Deru(i) + Deru(j);
308       Standard_Integer iv =  Derv(i) + Derv(j);
309       mat(i,j) = signe * SolEm(Points(i) - Points(j),iu,iv);
310     }
311   }
312   
313   i = n_el;
314   for(Standard_Integer iu = 0; iu< order; iu++) {
315     for(Standard_Integer iv =0; iu+iv < order; iv++) {
316       for(Standard_Integer j=0;j<n_el;j++) {
317         Standard_Integer idu = Deru(j);
318         Standard_Integer idv = Derv(j);
319         mat(i,j) = Polm (Points(j), iu, iv, idu, idv);
320       }
321       i++;
322     }
323   }
324
325   for(i=0;i<n_dim;i++) {
326     for(Standard_Integer j = i+1; j<n_dim;j++) {
327       mat(i,j) = mat(j,i);
328     }
329   }
330
331 // initialisation of the Gauss algorithm
332   Standard_Real pivot_max = 1.e-12;
333   OK = Standard_True;     
334
335   math_Gauss algo_gauss(mat,pivot_max);
336   if(!algo_gauss.IsDone()) {
337     Standard_Integer nbm = order*(order+1)/2;
338     for(i=n_el;i<n_el+nbm;i++) {
339       mat(i,i) = 1.e-8;
340     }
341     pivot_max = 1.e-18;
342     math_Gauss thealgo(mat,pivot_max);
343     algo_gauss = thealgo;
344     OK = algo_gauss.IsDone();
345   }
346
347   if (OK) {
348 //   computation of the linear system solution for the X, Y and Z coordinates
349     math_Vector sec_member( 0, n_dim-1, 0.);
350     math_Vector sol(0,n_dim-1);
351
352     delete [] (gp_XYZ*) solution;
353     solution = new gp_XYZ[n_dim];
354     
355     for(Standard_Integer icoor=1; icoor<=3;icoor++) {
356       for(i=0;i<n_el;i++) {
357         sec_member(i) = myConstraints(i+1).Value().Coord(icoor);
358       }
359       algo_gauss.Solve(sec_member, sol);
360       //alr iteration pour affiner la solution
361       {
362         math_Vector sol1(0,n_dim-1);
363         math_Vector sec_member1(0,n_dim-1);
364         for(i=1;i<=IterationNumber;i++)
365           {
366             sec_member1 = sec_member - mat*sol;
367             algo_gauss.Solve(sec_member1, sol1);
368             sol += sol1;
369           }
370       }
371       //finalr
372  
373       for(i=0;i<n_dim;i++) {
374         Solution(i).SetCoord (icoor, sol(i));
375       }
376     }
377   }
378 }
379
380 //=======================================================================
381 //function : SolveTI2
382 //purpose  : to solve the set of constraints in the medium case,
383 //           LinearXYZ constraints are provided but no LinearScalar one
384 //=======================================================================
385
386 void Plate_Plate::SolveTI2(const Standard_Integer IterationNumber)
387 {
388 // computation of square matrix members
389
390   Standard_Integer nCC1 = myConstraints.Length();
391   Standard_Integer nCC2 = 0;
392   Standard_Integer i ;
393   for( i = 1; i<= myLXYZConstraints.Length(); i++)
394     nCC2 += myLXYZConstraints(i).Coeff().ColLength();
395
396   Standard_Integer n_dimat = nCC1 + nCC2 + order*(order+1)/2;
397
398   
399   delete [] (gp_XY*)points;
400   points = new gp_XY[n_el];
401   delete [] (Standard_Integer*)deru;
402   deru = new Standard_Integer[n_el];
403   delete [] (Standard_Integer*)derv;
404   derv = new Standard_Integer[n_el];
405
406
407   for(i=0; i< nCC1;i++)
408     {
409       Points(i) = myConstraints(i+1).Pnt2d();
410       Deru(i) = myConstraints(i+1).Idu();
411       Derv(i) = myConstraints(i+1).Idv();
412     }
413
414   Standard_Integer k = nCC1;
415   for( i = 1; i<= myLXYZConstraints.Length(); i++)
416     for(Standard_Integer j=1;j <= myLXYZConstraints(i).GetPPC().Length() ; j++)
417       {
418         Points(k) = myLXYZConstraints(i).GetPPC()(j).Pnt2d();
419         Deru(k) =  myLXYZConstraints(i).GetPPC()(j).Idu();
420         Derv(k) =  myLXYZConstraints(i).GetPPC()(j).Idv();
421         k++;
422       }
423
424   math_Matrix mat(0, n_dimat-1, 0, n_dimat-1, 0.);
425
426   fillXYZmatrix(mat,0,0,nCC1,nCC2);
427
428
429 // initialisation of the Gauss algorithm
430   Standard_Real pivot_max = 1.e-12;
431   OK = Standard_True;      // ************ JHH
432
433   math_Gauss algo_gauss(mat,pivot_max);
434   if(!algo_gauss.IsDone()) {
435     for(i=nCC1+nCC2;i<n_dimat;i++) {
436       mat(i,i) = 1.e-8;
437     }
438     pivot_max = 1.e-18;
439     math_Gauss thealgo1(mat,pivot_max);
440     algo_gauss = thealgo1; 
441     OK = algo_gauss.IsDone();
442   }
443
444   if (OK) {
445 //   computation of the linear system solution for the X, Y and Z coordinates
446     math_Vector sec_member( 0, n_dimat-1, 0.);
447     math_Vector sol(0,n_dimat-1);
448
449     delete [] (gp_XYZ*) solution;
450     n_dim = n_el+order*(order+1)/2;
451     solution = new gp_XYZ[n_dim];
452     
453     for(Standard_Integer icoor=1; icoor<=3;icoor++) {
454       for(i=0;i<nCC1;i++) {
455         sec_member(i) = myConstraints(i+1).Value().Coord(icoor);
456       }
457
458       k = nCC1;
459       for(i = 1; i<= myLXYZConstraints.Length(); i++) {
460         for(Standard_Integer irow =1; irow <= myLXYZConstraints(i).Coeff().ColLength(); irow++) {
461           for(Standard_Integer icol=1; icol<=myLXYZConstraints(i).Coeff().RowLength();icol++)
462             sec_member(k) += myLXYZConstraints(i).Coeff()(irow,icol) 
463               *  myLXYZConstraints(i).GetPPC()(icol).Value().Coord(icoor);
464           k++;
465         }
466       }
467
468       algo_gauss.Solve(sec_member, sol);
469       //alr iteration pour affiner la solution
470       {
471         math_Vector sol1(0,n_dimat-1);
472         math_Vector sec_member1(0,n_dimat-1);
473         for(i=1;i<=IterationNumber;i++)
474           {
475             sec_member1 = sec_member - mat*sol;
476             algo_gauss.Solve(sec_member1, sol1);
477             sol += sol1;
478         }
479       }
480       //finalr
481
482       for(i=0;i<nCC1;i++) Solution(i).SetCoord (icoor, sol(i));
483
484       Standard_Integer kSolution = nCC1;
485       Standard_Integer ksol = nCC1;
486
487       for(i = 1; i<= myLXYZConstraints.Length(); i++) {
488         for(Standard_Integer icol=1; icol<=myLXYZConstraints(i).Coeff().RowLength();icol++){
489           Standard_Real vsol = 0;
490           for(Standard_Integer irow =1; irow <= myLXYZConstraints(i).Coeff().ColLength(); irow++)
491             vsol += myLXYZConstraints(i).Coeff()(irow,icol)*sol(ksol+irow-1);
492           Solution(kSolution).SetCoord (icoor, vsol);
493           kSolution++;
494         }
495         ksol += myLXYZConstraints(i).Coeff().ColLength();
496       }
497
498       for(i=0;i<order*(order+1)/2; i++) {
499         Solution(n_el+i).SetCoord (icoor, sol(ksol+i));
500       }
501     }
502   }
503 }
504
505 //=======================================================================
506 //function : SolveTI3
507 //purpose  : to solve the set of constraints in the most general situation
508 //=======================================================================
509
510 void Plate_Plate::SolveTI3(const Standard_Integer IterationNumber)
511 {
512 // computation of square matrix members
513
514   Standard_Integer nCC1 = myConstraints.Length();
515
516   Standard_Integer nCC2 = 0;
517   Standard_Integer i ;
518   for( i = 1; i<= myLXYZConstraints.Length(); i++)
519     nCC2 += myLXYZConstraints(i).Coeff().ColLength();
520
521   Standard_Integer nCC3 = 0;
522   for(i = 1; i<= myLScalarConstraints.Length(); i++)
523     nCC3 += myLScalarConstraints(i).Coeff().ColLength();
524
525   Standard_Integer nbm = order*(order+1)/2;
526   Standard_Integer n_dimsousmat = nCC1 + nCC2 + nbm ;
527   Standard_Integer n_dimat =3*n_dimsousmat + nCC3;
528
529   
530   delete [] (gp_XY*)points;
531   points = new gp_XY[n_el];
532   delete [] (Standard_Integer*)deru;
533   deru = new Standard_Integer[n_el];
534   delete [] (Standard_Integer*)derv;
535   derv = new Standard_Integer[n_el];
536
537
538   for(i=0; i< nCC1;i++)
539     {
540       Points(i) = myConstraints(i+1).Pnt2d();
541       Deru(i) = myConstraints(i+1).Idu();
542       Derv(i) = myConstraints(i+1).Idv();
543     }
544
545   Standard_Integer k = nCC1;
546   for(i = 1; i<= myLXYZConstraints.Length(); i++)
547     for(Standard_Integer j=1;j <= myLXYZConstraints(i).GetPPC().Length() ; j++)
548       {
549         Points(k) = myLXYZConstraints(i).GetPPC()(j).Pnt2d();
550         Deru(k) =  myLXYZConstraints(i).GetPPC()(j).Idu();
551         Derv(k) =  myLXYZConstraints(i).GetPPC()(j).Idv();
552         k++;
553       }
554   Standard_Integer nPPC2 = k;
555   for(i = 1; i<= myLScalarConstraints.Length(); i++)
556     for(Standard_Integer j=1;j <= myLScalarConstraints(i).GetPPC().Length() ; j++)
557       {
558         Points(k) = myLScalarConstraints(i).GetPPC()(j).Pnt2d();
559         Deru(k) =  myLScalarConstraints(i).GetPPC()(j).Idu();
560         Derv(k) =  myLScalarConstraints(i).GetPPC()(j).Idv();
561         k++;
562       }
563
564   math_Matrix mat(0, n_dimat-1, 0, n_dimat-1, 0.);
565
566   fillXYZmatrix(mat,0,0,nCC1,nCC2);
567   fillXYZmatrix(mat,n_dimsousmat,n_dimsousmat,nCC1,nCC2);
568   fillXYZmatrix(mat,2*n_dimsousmat,2*n_dimsousmat,nCC1,nCC2);
569
570   k = 3*n_dimsousmat;
571   Standard_Integer kppc = nPPC2;
572   Standard_Integer j ;
573   for(i = 1; i<= myLScalarConstraints.Length(); i++) {
574     for( j=0;j<nCC1;j++){
575
576       math_Vector vmat(1,myLScalarConstraints(i).GetPPC().Length());
577
578       for(Standard_Integer ippc=1;ippc <= myLScalarConstraints(i).GetPPC().Length() ; ippc++) {
579         Standard_Real signe = 1;
580         if ( ((Deru(j)+Derv(j))%2) == 1) signe = -1;
581         Standard_Integer iu =  Deru(kppc+ippc-1) + Deru(j);
582         Standard_Integer iv =  Derv(kppc+ippc-1) + Derv(j);
583         vmat(ippc) =  signe * SolEm(Points(kppc+ippc-1) - Points(j),iu,iv);
584       }
585
586       for(Standard_Integer irow=1;irow <= myLScalarConstraints(i).Coeff().ColLength() ; irow++)
587         for(Standard_Integer icol=1;icol <= myLScalarConstraints(i).Coeff().RowLength() ; icol++){
588           mat(k+irow-1,j) += myLScalarConstraints(i).Coeff()(irow,icol).X()*vmat(icol);
589           mat(k+irow-1,n_dimsousmat+j) += myLScalarConstraints(i).Coeff()(irow,icol).Y()*vmat(icol);
590           mat(k+irow-1,2*n_dimsousmat+j) += myLScalarConstraints(i).Coeff()(irow,icol).Z()*vmat(icol);
591         }
592     }
593
594     Standard_Integer k2 = nCC1;
595     Standard_Integer kppc2 = nCC1;
596     Standard_Integer i2 ;
597     for( i2 = 1; i2<=myLXYZConstraints.Length() ; i2++){
598
599       math_Matrix tmpmat(1,myLScalarConstraints(i).GetPPC().Length(),1,myLXYZConstraints(i2).GetPPC().Length() );
600
601       for(Standard_Integer ippc=1;ippc <= myLScalarConstraints(i).GetPPC().Length() ; ippc++)
602         for(Standard_Integer ippc2=1;ippc2 <= myLXYZConstraints(i2).GetPPC().Length() ; ippc2++){
603           Standard_Real signe = 1;
604           if ( ((Deru(kppc2+ippc2-1)+Derv(kppc2+ippc2-1))%2) == 1) signe = -1;
605           Standard_Integer iu =  Deru(kppc+ippc-1) + Deru(kppc2+ippc2-1);
606           Standard_Integer iv =  Derv(kppc+ippc-1) + Derv(kppc2+ippc2-1);
607           tmpmat(ippc,ippc2) = signe * SolEm(Points(kppc+ippc-1) - Points(kppc2+ippc2-1),iu,iv);
608         }
609
610       for(Standard_Integer irow=1;irow <= myLScalarConstraints(i).Coeff().ColLength() ; irow++)
611         for(Standard_Integer irow2=1;irow2 <= myLXYZConstraints(i2).Coeff().ColLength() ; irow2++)
612           for(Standard_Integer icol=1;icol <= myLScalarConstraints(i).Coeff().RowLength() ; icol++)
613             for(Standard_Integer icol2=1;icol2 <= myLXYZConstraints(i2).Coeff().RowLength() ; icol2++){
614               mat(k+irow-1,k2+irow2-1) += 
615                 myLScalarConstraints(i).Coeff()(irow,icol).X()*myLXYZConstraints(i2).Coeff()(irow2,icol2)*tmpmat(icol,icol2);
616               mat(k+irow-1,n_dimsousmat+k2+irow2-1) += 
617                 myLScalarConstraints(i).Coeff()(irow,icol).Y()*myLXYZConstraints(i2).Coeff()(irow2,icol2)*tmpmat(icol,icol2);
618               mat(k+irow-1,2*n_dimsousmat+k2+irow2-1) += 
619                 myLScalarConstraints(i).Coeff()(irow,icol).Z()*myLXYZConstraints(i2).Coeff()(irow2,icol2)*tmpmat(icol,icol2);
620             }
621
622       k2 += myLXYZConstraints(i2).Coeff().ColLength();
623       kppc2 += myLXYZConstraints(i2).Coeff().RowLength();
624     }
625
626
627
628     j = nCC1+nCC2;
629     for(Standard_Integer iu = 0; iu< order; iu++)
630       for(Standard_Integer iv =0; iu+iv < order; iv++) {
631
632         math_Vector vmat(1,myLScalarConstraints(i).GetPPC().Length());
633         for(Standard_Integer ippc=1;ippc <= myLScalarConstraints(i).GetPPC().Length() ; ippc++){
634           Standard_Integer idu = Deru(kppc+ippc-1);
635           Standard_Integer idv = Derv(kppc+ippc-1);
636           vmat(ippc) = Polm (Points(kppc+ippc-1),iu,iv,idu,idv);
637         }
638
639         for(Standard_Integer irow=1;irow <= myLScalarConstraints(i).Coeff().ColLength() ; irow++)
640           for(Standard_Integer icol=1;icol <= myLScalarConstraints(i).Coeff().RowLength() ; icol++){
641             mat(k+irow-1,j) += myLScalarConstraints(i).Coeff()(irow,icol).X()*vmat(icol);
642             mat(k+irow-1,n_dimsousmat+j) += myLScalarConstraints(i).Coeff()(irow,icol).Y()*vmat(icol);
643             mat(k+irow-1,2*n_dimsousmat+j) += myLScalarConstraints(i).Coeff()(irow,icol).Z()*vmat(icol);
644           }
645
646       j++;
647     }
648
649
650     k2 = 3*n_dimsousmat;
651     kppc2 = nPPC2;
652     for(i2 = 1; i2<=i ; i2++){
653
654       math_Matrix tmpmat(1,myLScalarConstraints(i).GetPPC().Length(),1,myLScalarConstraints(i2).GetPPC().Length() );
655
656       for(Standard_Integer ippc=1;ippc <= myLScalarConstraints(i).GetPPC().Length() ; ippc++)
657         for(Standard_Integer ippc2=1;ippc2 <= myLScalarConstraints(i2).GetPPC().Length() ; ippc2++){
658           Standard_Real signe = 1;
659           if ( ((Deru(kppc2+ippc2-1)+Derv(kppc2+ippc2-1))%2) == 1) signe = -1;
660           Standard_Integer a_iu =  Deru(kppc+ippc-1) + Deru(kppc2+ippc2-1);
661           Standard_Integer iv =  Derv(kppc+ippc-1) + Derv(kppc2+ippc2-1);
662           tmpmat(ippc,ippc2) = signe * SolEm(Points(kppc+ippc-1) - Points(kppc2+ippc2-1),a_iu,iv);
663         }
664
665       for(Standard_Integer irow=1;irow <= myLScalarConstraints(i).Coeff().ColLength() ; irow++)
666         for(Standard_Integer irow2=1;irow2 <= myLScalarConstraints(i2).Coeff().ColLength() ; irow2++)
667           for(Standard_Integer icol=1;icol <= myLScalarConstraints(i).Coeff().RowLength() ; icol++)
668             for(Standard_Integer icol2=1;icol2 <= myLScalarConstraints(i2).Coeff().RowLength() ; icol2++){
669               mat(k+irow-1,k2+irow2-1) += 
670                 myLScalarConstraints(i).Coeff()(irow,icol)*myLScalarConstraints(i2).Coeff()(irow2,icol2)*tmpmat(icol,icol2);
671             }
672
673       k2 += myLScalarConstraints(i2).Coeff().ColLength();
674       kppc2 += myLScalarConstraints(i2).Coeff().RowLength();
675     }
676
677     k += myLScalarConstraints(i).Coeff().ColLength();
678     kppc += myLScalarConstraints(i).Coeff().RowLength();
679   }
680
681   for( j=3*n_dimsousmat;j<n_dimat;j++)
682     for(i=0;i<j;i++)
683       mat(i,j)= mat(j,i);
684
685
686
687 // initialisation of the Gauss algorithm
688   Standard_Real pivot_max = 1.e-12;
689   OK = Standard_True;      // ************ JHH
690
691   math_Gauss algo_gauss(mat,pivot_max);
692   if(!algo_gauss.IsDone()) {
693     for(i=nCC1+nCC2;i<nCC1+nCC2+nbm;i++) {
694       mat(i,i) = 1.e-8;
695       mat(n_dimsousmat+i,n_dimsousmat+i) = 1.e-8;
696       mat(2*n_dimsousmat+i,2*n_dimsousmat+i) = 1.e-8;
697     }
698     pivot_max = 1.e-18;
699     math_Gauss thealgo2(mat,pivot_max);
700     algo_gauss = thealgo2;
701     OK = algo_gauss.IsDone();
702   }
703
704   if (OK) {
705 //   computation of the linear system solution for the X, Y and Z coordinates
706     math_Vector sec_member( 0, n_dimat-1, 0.);
707     math_Vector sol(0,n_dimat-1);
708
709     delete [] (gp_XYZ*) solution;
710     n_dim = n_el+order*(order+1)/2;
711     solution = new gp_XYZ[n_dim];
712     
713     Standard_Integer icoor ;
714     for( icoor=1; icoor<=3;icoor++){
715       for(i=0;i<nCC1;i++)
716         sec_member((icoor-1)*n_dimsousmat+i) = myConstraints(i+1).Value().Coord(icoor);
717    
718
719       k = nCC1;
720       for(i = 1; i<= myLXYZConstraints.Length(); i++)
721         for(Standard_Integer irow =1; irow <= myLXYZConstraints(i).Coeff().ColLength(); irow++) {
722           for(Standard_Integer icol=1; icol<=myLXYZConstraints(i).Coeff().RowLength();icol++)
723             sec_member((icoor-1)*n_dimsousmat+k) += myLXYZConstraints(i).Coeff()(irow,icol) 
724               *  myLXYZConstraints(i).GetPPC()(icol).Value().Coord(icoor);
725           k++;
726         }
727     }
728     k = 3*n_dimsousmat;
729     for(i = 1; i<= myLScalarConstraints.Length(); i++)
730       for(Standard_Integer irow =1; irow <= myLScalarConstraints(i).Coeff().ColLength(); irow++) {
731         for(Standard_Integer icol=1; icol<=myLScalarConstraints(i).Coeff().RowLength();icol++)
732           sec_member(k) += myLScalarConstraints(i).Coeff()(irow,icol) 
733             *  myLScalarConstraints(i).GetPPC()(icol).Value();
734         k++;
735       }
736     
737     algo_gauss.Solve(sec_member, sol);
738     //alr iteration pour affiner la solution
739     {
740       math_Vector sol1(0,n_dimat-1);
741       math_Vector sec_member1(0,n_dimat-1);
742       for(i=1;i<=IterationNumber;i++)
743         {
744           sec_member1 = sec_member - mat*sol;
745           algo_gauss.Solve(sec_member1, sol1);
746           sol += sol1;
747         }
748     }
749     //finalr
750     
751     for(icoor=1; icoor<=3;icoor++){
752       for(i=0;i<nCC1;i++) Solution(i).SetCoord (icoor, sol((icoor-1)*n_dimsousmat+i));
753
754       Standard_Integer kSolution = nCC1;
755       Standard_Integer ksol = nCC1;
756
757       for(i = 1; i<= myLXYZConstraints.Length(); i++) {
758         for(Standard_Integer icol=1; icol<=myLXYZConstraints(i).Coeff().RowLength();icol++){
759           Standard_Real vsol = 0;
760           for(Standard_Integer irow =1; irow <= myLXYZConstraints(i).Coeff().ColLength(); irow++)
761             vsol += myLXYZConstraints(i).Coeff()(irow,icol)*sol((icoor-1)*n_dimsousmat+ksol+irow-1);
762           Solution(kSolution).SetCoord (icoor, vsol);
763           kSolution++;
764         }
765         ksol += myLXYZConstraints(i).Coeff().ColLength();
766       }
767
768       ksol = nCC1+nCC2;
769       for(i=0;i<order*(order+1)/2; i++) {
770         Solution(n_el+i).SetCoord (icoor, sol((icoor-1)*n_dimsousmat+ksol+i));
771       }
772     }
773
774     Standard_Integer ksol = 3*n_dimsousmat;
775     Standard_Integer kSolution = nPPC2;
776     for(i = 1; i<= myLScalarConstraints.Length(); i++) {
777       for(Standard_Integer icol=1; icol<=myLScalarConstraints(i).Coeff().RowLength();icol++){
778         gp_XYZ Vsol(0.,0.,0.);
779         for(Standard_Integer irow =1; irow <= myLScalarConstraints(i).Coeff().ColLength(); irow++)
780           Vsol += myLScalarConstraints(i).Coeff()(irow,icol)*sol(ksol+irow-1);
781         Solution(kSolution) = Vsol;
782         kSolution++;
783       }
784       ksol += myLScalarConstraints(i).Coeff().ColLength();
785     }
786   }
787 }
788
789 //=======================================================================
790 //function : fillXYZmatrix
791 //purpose  : 
792 //=======================================================================
793 void Plate_Plate::fillXYZmatrix(math_Matrix &mat, 
794                                 const Standard_Integer i0,
795                                 const Standard_Integer j0,
796                                 const Standard_Integer ncc1,
797                                 const Standard_Integer ncc2) const
798 {
799   Standard_Integer i,j ;
800   for( i=0; i<ncc1;i++) {
801     for( j=0;j<i;j++) {
802       Standard_Real signe = 1;
803       if ( ((Deru(j)+Derv(j))%2) == 1) signe = -1;
804       Standard_Integer iu =  Deru(i) + Deru(j);
805       Standard_Integer iv =  Derv(i) + Derv(j);
806       mat(i0+i,j0+j) = signe * SolEm(Points(i) - Points(j),iu,iv);
807     }
808   }
809   
810   Standard_Integer k = ncc1;
811   Standard_Integer kppc = ncc1;
812   for( i = 1; i<= myLXYZConstraints.Length(); i++){
813
814     for(Standard_Integer a_j=0; a_j < ncc1; a_j++){
815
816       math_Vector vmat(1,myLXYZConstraints(i).GetPPC().Length());
817
818       for(Standard_Integer ippc=1;ippc <= myLXYZConstraints(i).GetPPC().Length() ; ippc++) {
819         Standard_Real signe = 1;
820         if ( ((Deru(a_j)+Derv(a_j))%2) == 1) signe = -1;
821         Standard_Integer iu =  Deru(kppc+ippc-1) + Deru(a_j);
822         Standard_Integer iv =  Derv(kppc+ippc-1) + Derv(a_j);
823         vmat(ippc) =  signe * SolEm(Points(kppc+ippc-1) - Points(a_j),iu,iv);
824       }
825
826       for(Standard_Integer irow=1;irow <= myLXYZConstraints(i).Coeff().ColLength() ; irow++)
827         for(Standard_Integer icol=1;icol <= myLXYZConstraints(i).Coeff().RowLength() ; icol++)
828           mat(i0+k+irow-1,j0+a_j) += myLXYZConstraints(i).Coeff()(irow,icol)*vmat(icol);
829     }
830
831     Standard_Integer k2 = ncc1;
832     Standard_Integer kppc2 = ncc1;
833     for(Standard_Integer i2 = 1; i2<= i; i2++){
834
835       math_Matrix tmpmat(1,myLXYZConstraints(i).GetPPC().Length(),1,myLXYZConstraints(i2).GetPPC().Length() );
836
837       for(Standard_Integer ippc=1;ippc <= myLXYZConstraints(i).GetPPC().Length() ; ippc++)
838         for(Standard_Integer ippc2=1;ippc2 <= myLXYZConstraints(i2).GetPPC().Length() ; ippc2++){
839           Standard_Real signe = 1;
840           if ( ((Deru(kppc2+ippc2-1)+Derv(kppc2+ippc2-1))%2) == 1) signe = -1;
841           Standard_Integer iu =  Deru(kppc+ippc-1) + Deru(kppc2+ippc2-1);
842           Standard_Integer iv =  Derv(kppc+ippc-1) + Derv(kppc2+ippc2-1);
843           tmpmat(ippc,ippc2) = signe * SolEm(Points(kppc+ippc-1) - Points(kppc2+ippc2-1),iu,iv);
844         }
845
846       for(Standard_Integer irow=1;irow <= myLXYZConstraints(i).Coeff().ColLength() ; irow++)
847         for(Standard_Integer irow2=1;irow2 <= myLXYZConstraints(i2).Coeff().ColLength() ; irow2++)
848           for(Standard_Integer icol=1;icol <= myLXYZConstraints(i).Coeff().RowLength() ; icol++)
849             for(Standard_Integer icol2=1;icol2 <= myLXYZConstraints(i2).Coeff().RowLength() ; icol2++)
850               mat(i0+k+irow-1,j0+k2+irow2-1) += 
851                 myLXYZConstraints(i).Coeff()(irow,icol)*myLXYZConstraints(i2).Coeff()(irow2,icol2)*tmpmat(icol,icol2);
852       
853
854       k2 += myLXYZConstraints(i2).Coeff().ColLength();
855       kppc2 += myLXYZConstraints(i2).Coeff().RowLength();
856     }
857
858     k += myLXYZConstraints(i).Coeff().ColLength();
859     kppc += myLXYZConstraints(i).Coeff().RowLength();
860   }
861
862
863
864
865   i = ncc1+ncc2;
866   for(Standard_Integer iu = 0; iu< order; iu++)
867     for(Standard_Integer iv =0; iu+iv < order; iv++) {
868       for(Standard_Integer a_j=0; a_j < ncc1; a_j++) {
869         Standard_Integer idu = Deru(a_j);
870         Standard_Integer idv = Derv(a_j);
871         mat(i0+i,j0+a_j) = Polm (Points(a_j), iu, iv, idu, idv);
872       }
873
874       Standard_Integer k2 = ncc1;
875       Standard_Integer kppc2 = ncc1;
876       for(Standard_Integer i2 = 1; i2<= myLXYZConstraints.Length(); i2++){
877         math_Vector vmat(1,myLXYZConstraints(i2).GetPPC().Length());
878         for(Standard_Integer ippc2=1;ippc2 <= myLXYZConstraints(i2).GetPPC().Length() ; ippc2++){
879           Standard_Integer idu = Deru(kppc2+ippc2-1);
880           Standard_Integer idv = Derv(kppc2+ippc2-1);
881           vmat(ippc2) = Polm (Points(kppc2+ippc2-1),iu,iv,idu,idv);
882         }
883
884         for(Standard_Integer irow2=1;irow2 <= myLXYZConstraints(i2).Coeff().ColLength() ; irow2++)
885           for(Standard_Integer icol2=1;icol2 <= myLXYZConstraints(i2).Coeff().RowLength() ; icol2++)
886             mat(i0+i,j0+k2+irow2-1) += myLXYZConstraints(i2).Coeff()(irow2,icol2)*vmat(icol2);
887
888         k2 += myLXYZConstraints(i2).Coeff().ColLength();
889         kppc2 += myLXYZConstraints(i2).Coeff().RowLength();
890         }
891
892       i++;
893     }
894
895   Standard_Integer n_dimat = ncc1 + ncc2 + order*(order+1)/2;
896
897   for(i=0;i<n_dimat;i++) {
898     for(Standard_Integer a_j = i+1; a_j < n_dimat; a_j++) {
899       mat(i0+i,j0+a_j) = mat(i0+a_j,j0+i);
900     }
901   }
902
903 }
904
905 //=======================================================================
906 //function : IsDone
907 //purpose  : 
908 //=======================================================================
909
910 Standard_Boolean Plate_Plate::IsDone() const 
911 {
912   return OK;
913 }
914
915
916 //=======================================================================
917 //function : destroy
918 //purpose  : 
919 //=======================================================================
920
921 void Plate_Plate::destroy()
922 {
923   Init();
924 }
925
926 //=======================================================================
927 //function : Init
928 //purpose  : 
929 //=======================================================================
930
931 void Plate_Plate::Init()
932
933   myConstraints.Clear();
934   myLXYZConstraints.Clear();
935   myLScalarConstraints.Clear();
936
937
938   delete [] (gp_XYZ*)solution;
939   solution = 0;
940
941   delete [] (gp_XY*)points;
942   points = 0;
943
944   delete [] (Standard_Integer*)deru;
945   deru = 0;
946
947   delete [] (Standard_Integer*)derv;
948   derv = 0;
949
950   order = 0;
951   n_el = 0;
952   n_dim = 0;
953   OK = Standard_True;
954   maxConstraintOrder=0;
955 }
956
957 //=======================================================================
958 //function : Evaluate
959 //purpose  : 
960 //=======================================================================
961
962 gp_XYZ Plate_Plate::Evaluate(const gp_XY& point2d) const 
963 {
964   if(solution == 0) return gp_XYZ(0,0,0);
965   if(!OK) return gp_XYZ(0,0,0);
966
967   gp_XYZ valeur(0,0,0);
968
969   if(!PolynomialPartOnly)
970     {
971       for(Standard_Integer i=0; i<n_el;i++)
972         {
973           Standard_Real signe = 1;
974           if ( ((Deru(i)+Derv(i))%2) == 1) signe = -1;
975           valeur += Solution(i) *  (signe*SolEm(point2d - Points(i), Deru(i), Derv(i))) ;
976         }
977     }
978   Standard_Integer i = n_el;
979   for(Standard_Integer idu = 0; idu< order; idu++)
980   for(Standard_Integer idv =0; idu+idv < order; idv++)
981   {
982     valeur += Solution(i) * Polm( point2d, idu,idv,0,0);
983     i++;
984   }
985   return valeur;
986 }
987
988 //=======================================================================
989 //function : EvaluateDerivative
990 //purpose  : 
991 //=======================================================================
992
993 gp_XYZ Plate_Plate::EvaluateDerivative(const gp_XY& point2d, const Standard_Integer iu, const Standard_Integer iv) const 
994 {
995   if(solution == 0) return gp_XYZ(0,0,0);
996   if(!OK) return gp_XYZ(0,0,0);
997
998   gp_XYZ valeur(0,0,0);
999   if(!PolynomialPartOnly)
1000     {
1001       for(Standard_Integer i=0; i<n_el;i++)
1002         {
1003           Standard_Real signe = 1;
1004           if ( ((Deru(i)+Derv(i))%2) == 1) signe = -1;
1005           valeur += Solution(i) *  (signe*SolEm(point2d - Points(i), Deru(i)+iu, Derv(i)+iv)) ;
1006         }
1007     }
1008   Standard_Integer i = n_el;
1009   for(Standard_Integer idu = 0; idu< order; idu++)
1010   for(Standard_Integer idv =0; idu+idv < order; idv++)
1011   {
1012     valeur += Solution(i) * Polm( point2d, idu,idv, iu,iv);
1013     i++;
1014   }
1015   return valeur;
1016 }
1017 //=======================================================================
1018 //function : Plate_Plate::CoefPol
1019 //purpose  :give back the array of power basis coefficient of
1020 // the polynomial part of the Plate function
1021 //=======================================================================
1022
1023  void Plate_Plate::CoefPol(Handle_TColgp_HArray2OfXYZ& Coefs) const
1024 {
1025   Coefs = new TColgp_HArray2OfXYZ(0,order-1,0,order-1,gp_XYZ(0.,0.,0.));
1026   Standard_Integer i = n_el;
1027   for(Standard_Integer iu = 0; iu< order; iu++)
1028   for(Standard_Integer iv =0; iu+iv < order; iv++)
1029   {
1030     Coefs->ChangeValue(iu,iv) = Solution(i)*ddu[iu]*ddv[iv];
1031     //Coefs->ChangeValue(idu,idv) = Solution(i);
1032     // il faut remettre cette ligne si on enleve ls facteurs dans
1033     // la methode Polm.
1034     i++;
1035   }
1036   
1037 }
1038 //=======================================================================
1039 //function : Plate_Plate::Continuity
1040 //purpose  :give back the continuity order of the Plate function
1041 //=======================================================================
1042
1043  Standard_Integer Plate_Plate::Continuity() const
1044 {
1045   return 2*order - 3 - maxConstraintOrder;
1046 }
1047
1048 //=======================================================================
1049 //function : Plate_Plate::SolEm
1050 //purpose  : compute the (iu,iv)th derivative of the fondamental solution
1051 // of Laplcian at the power order
1052 //=======================================================================
1053
1054
1055 Standard_Real Plate_Plate::SolEm(const gp_XY& point2d, const Standard_Integer iu, const Standard_Integer iv) const 
1056 {
1057   Plate_Plate* aThis = const_cast<Plate_Plate*>(this);
1058   Standard_Real U,V;
1059   Standard_Integer IU,IV;
1060
1061   if(iv>iu)
1062   {
1063     // SolEm is symetric in (u<->v) : we swap u and v if iv>iu
1064     // to avoid some code 
1065     IU = iv;
1066     IV = iu;
1067     U = point2d.Y() *ddv[1];
1068     V = point2d.X() *ddu[1];
1069   }
1070   else
1071   {
1072     IU = iu;
1073     IV = iv;
1074     U = point2d.X() *ddu[1];
1075     V = point2d.Y() *ddv[1];
1076   }
1077   
1078    if((U==Uold)&&(V==Vold) )
1079      {
1080        if (R<1.e-20) return 0;
1081      }
1082   else
1083     {
1084         aThis->Uold = U;
1085         aThis->Vold = V;
1086         aThis->U2 = U*U;
1087         aThis->R = U2+V*V;
1088         if (R<1.e-20) return 0;
1089         aThis->L = log(R);
1090       }
1091   Standard_Real DUV = 0;
1092
1093   Standard_Integer m = order;
1094   Standard_Integer mm1 = m-1;
1095   Standard_Real &r = aThis->R;
1096
1097
1098   //Standard_Real pr = pow(R, mm1 - IU - IV);
1099   // cette expression prend beaucoup  de temps 
1100   //(ne tient pas compte de la petite valeur entiere de l'exposant)
1101   //
1102
1103   Standard_Integer expo =  mm1 - IU - IV;
1104   Standard_Real pr;
1105   if(expo<0)
1106         {
1107         pr = R;
1108         for(Standard_Integer i=1;i<-expo;i++) pr *= R;
1109         pr = 1./pr;
1110         }
1111   else if(expo>0)
1112         {
1113         pr = R;
1114         for(Standard_Integer i=1;i<expo;i++) pr *= R;
1115         }
1116   else pr = 1.;
1117         
1118
1119   switch (IU)
1120   {
1121   case 0:
1122     switch (IV)
1123     {
1124     case 0:
1125       {
1126       DUV = pr*L;
1127       }
1128       break;
1129
1130     default:
1131       break;
1132     }
1133   break;
1134
1135   case 1:
1136     switch (IV)
1137     {
1138     case 0:
1139       {
1140       DUV = 2*pr*U*(1+L*mm1);
1141       }
1142       break;
1143
1144     case 1:
1145       {
1146       Standard_Real m2 = m*m;
1147       //DUV = 4*pr*U*V*(-3+2*L+2*m-3*L*m+L*m2);
1148       DUV = 4*pr*U*V*((2*m-3)+(m2-3*m+2)*L);
1149       }
1150       break;
1151
1152     default:
1153       break;
1154     }
1155     break;
1156
1157   case 2:
1158     switch (IV)
1159     {
1160     case 0:
1161       {
1162       Standard_Real m2 = m*m;
1163       DUV = 2*pr*(R-L*R+L*m*R-6*U2+4*L*U2+4*m*U2-6*L*m*U2+2*L*m2*U2);
1164       }
1165       break;
1166
1167     case 1:
1168       {
1169       Standard_Real m2 = m*m;
1170       Standard_Real m3 = m2*m;
1171       DUV = -3*R+2*L*R+2*m*R-3*L*m*R+L*m2*R+22*U2-12*L*U2-24*m*U2+22*L*m*U2+6*m2*U2-12*L*m2*U2+2*L*m3*U2;
1172       DUV = DUV * 4* pr*V;
1173       }
1174       break;
1175
1176     case 2:
1177       {
1178       Standard_Real m2 = m*m;
1179       Standard_Real m3 = m2*m;
1180       Standard_Real m4 = m2*m2;
1181       Standard_Real V2 = V*V;
1182       Standard_Real R2 = R*R;
1183       DUV = -3*R2+2*L*R2+2*m*R2-3*L*m*R2+L*m2*R2+22*R*U2-12*L*R*U2-24*m*R*U2+22*L*m*R*U2+6*m2*R*U2-12*L*m2*R*U2;
1184       DUV += 2*L*m3*R*U2+22*R*V2-12*L*R*V2-24*m*R*V2+22*L*m*R*V2+6*m2*R*V2-12*L*m2*R*V2+2*L*m3*R*V2-200*U2*V2+96*L*U2*V2;
1185       DUV += 280*m*U2*V2-200*L*m*U2*V2-120*m2*U2*V2+140*L*m2*U2*V2+16*m3*U2*V2-40*L*m3*U2*V2+4*L*m4*U2*V2;
1186       DUV = 4*pr*DUV;
1187       }
1188       break;
1189
1190     default:
1191       break;
1192     }
1193     break;
1194
1195   case 3:
1196     switch (IV)
1197     {
1198     case 0:
1199       {
1200       Standard_Real m2 = m*m;
1201       Standard_Real m3 = m2*m;
1202       DUV = -9*R+6*L*R+6*m*R-9*L*m*R+3*L*m2*R+22*U2-12*L*U2-24*m*U2+22*L*m*U2+6*m2*U2-12*L*m2*U2+2*L*m3*U2;
1203       DUV = DUV * 4* pr*U;
1204       }
1205       break;
1206
1207     case 1:      
1208       {
1209       Standard_Real m2 = m*m;
1210       Standard_Real m3 = m2*m;
1211       Standard_Real m4 = m2*m2;
1212       DUV = 33*R-18*L*R-36*m*R+33*L*m*R+9*m2*R-18*L*m2*R+3*L*m3*R-100*U2+48*L*U2+140*m*U2-100*L*m*U2-60*m2*U2+70*L*m2*U2;
1213       DUV += 8*m3*U2-20*L*m3*U2+2*L*m4*U2;
1214       DUV = 8*pr*U*V*DUV;
1215       }
1216       break;
1217
1218     case 2:      
1219       {
1220       Standard_Real m2 = m*m;
1221       Standard_Real m3 = m2*m;
1222       Standard_Real m4 = m2*m2;
1223       Standard_Real m5 = m4*m;
1224       Standard_Real ru2 = R*U2;
1225       Standard_Real v2 = V*V;
1226       Standard_Real rv2 = R*v2;
1227       Standard_Real u2v2 = v2*U2;
1228       Standard_Real r2 = r*r;
1229
1230       // copier-coller de mathematica 
1231           DUV = 
1232      -100*ru2 + 48*L*ru2 + 140*m*ru2 - 100*L*m*ru2 - 60*m2*ru2 + 70*L*m2*ru2 + 8*m3*ru2 - 
1233      20*L*m3*ru2 + 2*L*m4*ru2 - 300*rv2 + 144*L*rv2 + 420*m*rv2 - 300*L*m*rv2 - 180*m2*rv2 + 210*L*m2*rv2 + 
1234      24*m3*rv2 - 60*L*m3*rv2 + 6*L*m4*rv2 + 33*r2 - 18*L*r2 - 36*m*r2 + 33*L*m*r2 + 9*m2*r2 - 18*L*m2*r2 + 
1235      3*L*m3*r2 + 1096*u2v2 - 480*L*u2v2 - 1800*m*u2v2 + 1096*L*m*u2v2 + 1020*m2*u2v2 - 900*L*m2*u2v2 - 
1236      240*m3*u2v2 + 340*L*m3*u2v2 + 20*m4*u2v2 - 60*L*m4*u2v2 + 4*L*m5*u2v2;
1237
1238       DUV = 8*pr*U*DUV;
1239       }
1240       break;
1241
1242     case 3:      
1243       {
1244       Standard_Real m2 = m*m;
1245       Standard_Real m3 = m2*m;
1246       Standard_Real m4 = m2*m2;
1247       Standard_Real m5 = m3*m2;
1248       Standard_Real m6 = m3*m3;
1249       Standard_Real ru2 = r*U2;
1250       Standard_Real v2 = V*V;
1251       Standard_Real rv2 = R*v2;
1252       Standard_Real u2v2 = v2*U2;
1253       Standard_Real r2 = r*r;
1254
1255      // copier-coller de mathematica 
1256       DUV = 
1257                 1644*ru2 - 720*L*ru2 - 2700*m*ru2 + 1644*L*m*ru2 + 1530*m2*ru2 - 1350*L*m2*ru2 - 
1258      360*m3*ru2 + 510*L*m3*ru2 + 30*m4*ru2 - 90*L*m4*ru2 + 6*L*m5*ru2 + 1644*rv2 - 720*L*rv2 - 2700*m*rv2 + 
1259      1644*L*m*rv2 + 1530*m2*rv2 - 1350*L*m2*rv2 - 360*m3*rv2 + 510*L*m3*rv2 + 30*m4*rv2 - 90*L*m4*rv2 + 
1260      6*L*m5*rv2 - 450*r2 + 216*L*r2 + 630*m*r2 - 450*L*m*r2 - 270*m2*r2 + 315*L*m2*r2 + 36*m3*r2 - 90*L*m3*r2 + 
1261      9*L*m4*r2 - 7056*u2v2 + 2880*L*u2v2 + 12992*m*u2v2 - 7056*L*m*u2v2 - 8820*m2*u2v2 + 6496*L*m2*u2v2 + 
1262      2800*m3*u2v2 - 2940*L*m3*u2v2 - 420*m4*u2v2 + 700*L*m4*u2v2 + 24*m5*u2v2 - 84*L*m5*u2v2 + 4*L*m6*u2v2;
1263          
1264       DUV = 16*pr*U*V*DUV;
1265       }
1266       break;
1267
1268     default:
1269       break;
1270     }
1271   break;
1272
1273   case 4:
1274     switch (IV)
1275     {
1276     case 0:     
1277       { 
1278       Standard_Real m2 = m*m;
1279       Standard_Real m3 = m2*m;
1280       Standard_Real m4 = m2*m2;
1281       Standard_Real U4 = U2*U2;
1282       Standard_Real R2 = R*R;
1283       DUV = -9*R2+6*L*R2+6*m*R2-9*L*m*R2+3*L*m2*R2+132*R*U2-72*L*R*U2-144*m*R*U2+132*L*m*R*U2+36*m2*R*U2-72*L*m2*R*U2;
1284       DUV += 12*L*m3*R*U2-200*U4+96*L*U4+280*m*U4-200*L*m*U4-120*m2*U4+140*L*m2*U4+16*m3*U4-40*L*m3*U4+4*L*m4*U4;
1285       DUV = 4*pr*DUV;
1286       }
1287       break;
1288
1289    case 1:     
1290       { 
1291       Standard_Real m2 = m*m;
1292       Standard_Real m3 = m2*m;
1293       Standard_Real m4 = m2*m2;
1294       Standard_Real m5 = m2*m3;
1295       Standard_Real u4 = U2*U2;
1296       Standard_Real ru2 = R*U2;
1297       Standard_Real r2 = R*R;
1298  
1299           // copier-coller de mathematica 
1300           DUV = 
1301                 -600*ru2 + 288*L*ru2 + 840*m*ru2 - 600*L*m*ru2 - 360*m2*ru2 + 420*L*m2*ru2 + 48*m3*ru2 - 
1302      120*L*m3*ru2 + 12*L*m4*ru2 + 33*r2 - 18*L*r2 - 36*m*r2 + 33*L*m*r2 + 9*m2*r2 - 18*L*m2*r2 + 3*L*m3*r2 + 
1303      1096*u4 - 480*L*u4 - 1800*m*u4 + 1096*L*m*u4 + 1020*m2*u4 - 900*L*m2*u4 - 240*m3*u4 + 340*L*m3*u4 + 20*m4*u4 - 
1304      60*L*m4*u4 + 4*L*m5*u4;  
1305
1306       DUV = 8*pr*V*DUV;
1307       }
1308       break;
1309
1310   case 2:     
1311       { 
1312       Standard_Real m2 = m*m;
1313       Standard_Real m3 = m2*m;
1314       Standard_Real m4 = m2*m2;
1315       Standard_Real m5 = m2*m3;
1316       Standard_Real m6 = m3*m3;
1317       Standard_Real u4 = U2*U2;
1318       Standard_Real r2 = r*r;
1319       Standard_Real r3 = r2*r;
1320       Standard_Real v2 = V*V;
1321       Standard_Real u2v2 = v2*U2;
1322       Standard_Real ru2v2 = R*u2v2;
1323       Standard_Real u4v2 = u4*v2;
1324       Standard_Real r2u2 = r2*U2;
1325       Standard_Real ru4 = r*u4;
1326       Standard_Real r2v2 = r2*v2;
1327
1328           // copier-coller de mathematica 
1329           DUV = 
1330                   6576*ru2v2 - 2880*L*ru2v2 - 10800*m*ru2v2 + 6576*L*m*ru2v2 + 6120*m2*ru2v2 - 5400*L*m2*ru2v2 - 
1331      1440*m3*ru2v2 + 2040*L*m3*ru2v2 + 120*m4*ru2v2 - 360*L*m4*ru2v2 + 24*L*m5*ru2v2 + 1096*ru4 - 480*L*ru4 - 
1332      1800*m*ru4 + 1096*L*m*ru4 + 1020*m2*ru4 - 900*L*m2*ru4 - 240*m3*ru4 + 340*L*m3*ru4 + 20*m4*ru4 - 60*L*m4*ru4 + 
1333      4*L*m5*ru4 - 600*r2u2 + 288*L*r2u2 + 840*m*r2u2 - 600*L*m*r2u2 - 360*m2*r2u2 + 420*L*m2*r2u2 + 48*m3*r2u2 - 
1334      120*L*m3*r2u2 + 12*L*m4*r2u2 - 300*r2v2 + 144*L*r2v2 + 420*m*r2v2 - 300*L*m*r2v2 - 180*m2*r2v2 + 210*L*m2*r2v2 + 
1335      24*m3*r2v2 - 60*L*m3*r2v2 + 6*L*m4*r2v2 + 33*r3 - 18*L*r3 - 36*m*r3 + 33*L*m*r3 + 9*m2*r3 - 18*L*m2*r3 + 
1336      3*L*m3*r3 - 14112*u4v2 + 5760*L*u4v2 + 25984*m*u4v2 - 14112*L*m*u4v2 - 17640*m2*u4v2 + 12992*L*m2*u4v2 + 
1337      5600*m3*u4v2 - 5880*L*m3*u4v2 - 840*m4*u4v2 + 1400*L*m4*u4v2 + 48*m5*u4v2 - 168*L*m5*u4v2 + 8*L*m6*u4v2;
1338
1339       DUV = 8*pr*DUV;
1340       }
1341       break;
1342
1343  case 3:     
1344       { 
1345       Standard_Real m2 = m*m;
1346       Standard_Real m3 = m2*m;
1347       Standard_Real m4 = m2*m2;
1348       Standard_Real m5 = m2*m3;
1349       Standard_Real m6 = m3*m3;
1350       Standard_Real m7 = m3*m4;
1351       Standard_Real u4 = U2*U2;
1352       Standard_Real r2 = r*r;
1353       Standard_Real r3 = r2*r;
1354       Standard_Real v2 = V*V;
1355       Standard_Real u2v2 = v2*U2;
1356       Standard_Real ru2v2 = R*u2v2;
1357       Standard_Real u4v2 = u4*v2;
1358       Standard_Real r2u2 = r2*U2;
1359       Standard_Real r2v2 = r2*v2;
1360       Standard_Real ru4 = r*u4;
1361
1362           // copier-coller de mathematica 
1363       DUV = 
1364                   -42336*ru2v2 + 17280*L*ru2v2 + 77952*m*ru2v2 - 42336*L*m*ru2v2 - 52920*m2*ru2v2 + 
1365      38976*L*m2*ru2v2 + 16800*m3*ru2v2 - 17640*L*m3*ru2v2 - 2520*m4*ru2v2 + 4200*L*m4*ru2v2 + 144*m5*ru2v2 - 
1366      504*L*m5*ru2v2 + 24*L*m6*ru2v2 - 21168*ru4 + 8640*L*ru4 + 38976*m*ru4 - 21168*L*m*ru4 - 26460*m2*ru4 + 
1367      19488*L*m2*ru4 + 8400*m3*ru4 - 8820*L*m3*ru4 - 1260*m4*ru4 + 2100*L*m4*ru4 + 72*m5*ru4 - 252*L*m5*ru4 + 
1368      12*L*m6*ru4 + 9864*r2u2 - 4320*L*r2u2 - 16200*m*r2u2 + 9864*L*m*r2u2 + 9180*m2*r2u2 - 8100*L*m2*r2u2 - 
1369      2160*m3*r2u2 + 3060*L*m3*r2u2 + 180*m4*r2u2 - 540*L*m4*r2u2 + 36*L*m5*r2u2 + 1644*r2v2 - 720*L*r2v2 - 
1370      2700*m*r2v2 + 1644*L*m*r2v2 + 1530*m2*r2v2 - 1350*L*m2*r2v2 - 360*m3*r2v2 + 510*L*m3*r2v2 + 30*m4*r2v2 - 
1371      90*L*m4*r2v2 + 6*L*m5*r2v2 - 450*r3 + 216*L*r3 + 630*m*r3 - 450*L*m*r3 - 270*m2*r3 + 315*L*m2*r3 + 36*m3*r3 - 
1372      90*L*m3*r3 + 9*L*m4*r3 + 104544*u4v2 - 40320*L*u4v2 - 210112*m*u4v2 + 104544*L*m*u4v2 + 162456*m2*u4v2 - 
1373      105056*L*m2*u4v2 - 62720*m3*u4v2 + 54152*L*m3*u4v2 + 12880*m4*u4v2 - 15680*L*m4*u4v2 - 1344*m5*u4v2 + 
1374      2576*L*m5*u4v2 + 56*m6*u4v2 - 224*L*m6*u4v2 + 8*L*m7*u4v2;
1375
1376       DUV = 16*pr*V*DUV;
1377       }
1378       break;
1379
1380    default:
1381       break;
1382     }
1383   break;
1384
1385   case 5:
1386     switch (IV)
1387     {
1388     case 0:     
1389       { 
1390       Standard_Real m2 = m*m;
1391       Standard_Real m3 = m2*m;
1392       Standard_Real m4 = m2*m2;
1393       Standard_Real m5 = m2*m3;
1394       Standard_Real u4 = U2*U2;
1395       Standard_Real r2 = R*R;
1396       Standard_Real ru2 = R*U2;
1397
1398           // copier-coller de mathematica 
1399       DUV = 
1400      -1000*ru2 + 480*L*ru2 + 1400*m*ru2 - 1000*L*m*ru2 - 600*m2*ru2 + 700*L*m2*ru2 + 80*m3*ru2 - 
1401      200*L*m3*ru2 + 20*L*m4*ru2 + 165*r2 - 90*L*r2 - 180*m*r2 + 165*L*m*r2 + 45*m2*r2 - 90*L*m2*r2 + 15*L*m3*r2 + 
1402      1096*u4 - 480*L*u4 - 1800*m*u4 + 1096*L*m*u4 + 1020*m2*u4 - 900*L*m2*u4 - 240*m3*u4 + 340*L*m3*u4 + 20*m4*u4 - 
1403      60*L*m4*u4 + 4*L*m5*u4;
1404           
1405           DUV = 8*pr*U*DUV;
1406       }
1407       break;
1408
1409    case 1:     
1410       { 
1411       Standard_Real m2 = m*m;
1412       Standard_Real m3 = m2*m;
1413       Standard_Real m4 = m2*m2;
1414       Standard_Real m5 = m2*m3;
1415       Standard_Real m6 = m3*m3;
1416       Standard_Real u4 = U2*U2;
1417       Standard_Real ru2 = r*U2;
1418       Standard_Real r2 = r*r;
1419
1420
1421           // copier-coller de mathematica 
1422      DUV = 
1423      5480*ru2 - 2400*L*ru2 - 9000*m*ru2 + 5480*L*m*ru2 + 5100*m2*ru2 - 4500*L*m2*ru2 - 1200*m3*ru2 + 
1424      1700*L*m3*ru2 + 100*m4*ru2 - 300*L*m4*ru2 + 20*L*m5*ru2 - 750*r2 + 360*L*r2 + 1050*m*r2 - 750*L*m*r2 - 
1425      450*m2*r2 + 525*L*m2*r2 + 60*m3*r2 - 150*L*m3*r2 + 15*L*m4*r2 - 7056*u4 + 2880*L*u4 + 12992*m*u4 - 7056*L*m*u4 - 
1426      8820*m2*u4 + 6496*L*m2*u4 + 2800*m3*u4 - 2940*L*m3*u4 - 420*m4*u4 + 700*L*m4*u4 + 24*m5*u4 - 84*L*m5*u4 + 
1427      4*L*m6*u4;          
1428
1429       DUV = 16*pr*U*V*DUV;
1430       }
1431       break;
1432
1433   case 2:     
1434       { 
1435       Standard_Real m2 = m*m;
1436       Standard_Real m3 = m2*m;
1437       Standard_Real m4 = m2*m2;
1438       Standard_Real m5 = m2*m3;
1439       Standard_Real m6 = m3*m3;
1440       Standard_Real m7 = m3*m4;
1441       Standard_Real u4 = U2*U2;
1442       Standard_Real r2 = r*r;
1443       Standard_Real r3 = r2*r;
1444       Standard_Real v2 = V*V;
1445       Standard_Real u2v2 = v2*U2;
1446       Standard_Real ru2v2 = R*u2v2;
1447       Standard_Real u4v2 = u4*v2;
1448       Standard_Real r2u2 = r2*U2;
1449       Standard_Real r2v2 = r2*v2;
1450       Standard_Real ru4 = r*u4;
1451
1452           // copier-coller de mathematica 
1453           DUV = 
1454                   
1455      -70560*ru2v2 + 28800*L*ru2v2 + 129920*m*ru2v2 - 70560*L*m*ru2v2 - 88200*m2*ru2v2 + 
1456      64960*L*m2*ru2v2 + 28000*m3*ru2v2 - 29400*L*m3*ru2v2 - 4200*m4*ru2v2 + 7000*L*m4*ru2v2 + 240*m5*ru2v2 - 
1457      840*L*m5*ru2v2 + 40*L*m6*ru2v2 - 7056*ru4 + 2880*L*ru4 + 12992*m*ru4 - 7056*L*m*ru4 - 8820*m2*ru4 + 
1458      6496*L*m2*ru4 + 2800*m3*ru4 - 2940*L*m3*ru4 - 420*m4*ru4 + 700*L*m4*ru4 + 24*m5*ru4 - 84*L*m5*ru4 + 4*L*m6*ru4 + 
1459      5480*r2u2 - 2400*L*r2u2 - 9000*m*r2u2 + 5480*L*m*r2u2 + 5100*m2*r2u2 - 4500*L*m2*r2u2 - 1200*m3*r2u2 + 
1460      1700*L*m3*r2u2 + 100*m4*r2u2 - 300*L*m4*r2u2 + 20*L*m5*r2u2 + 8220*r2v2 - 3600*L*r2v2 - 13500*m*r2v2 + 
1461      8220*L*m*r2v2 + 7650*m2*r2v2 - 6750*L*m2*r2v2 - 1800*m3*r2v2 + 2550*L*m3*r2v2 + 150*m4*r2v2 - 450*L*m4*r2v2 + 
1462      30*L*m5*r2v2 - 750*r3 + 360*L*r3 + 1050*m*r3 - 750*L*m*r3 - 450*m2*r3 + 525*L*m2*r3 + 60*m3*r3 - 150*L*m3*r3 + 
1463      15*L*m4*r3 + 104544*u4v2 - 40320*L*u4v2 - 210112*m*u4v2 + 104544*L*m*u4v2 + 162456*m2*u4v2 - 105056*L*m2*u4v2 - 
1464      62720*m3*u4v2 + 54152*L*m3*u4v2 + 12880*m4*u4v2 - 15680*L*m4*u4v2 - 1344*m5*u4v2 + 2576*L*m5*u4v2 + 56*m6*u4v2 - 
1465      224*L*m6*u4v2 + 8*L*m7*u4v2;
1466           
1467      DUV = 16*pr*U*DUV;
1468       }
1469       break;
1470
1471    default:
1472       break;
1473     }
1474   break;
1475
1476   case 6:
1477     switch (IV)
1478     {
1479     case 0:     
1480       { 
1481       Standard_Real m2 = m*m;
1482       Standard_Real m3 = m2*m;
1483       Standard_Real m4 = m2*m2;
1484       Standard_Real m5 = m2*m3;
1485       Standard_Real m6 = m3*m3;
1486       Standard_Real u4 = U2*U2;
1487       Standard_Real u6 = U2*u4;
1488       Standard_Real r2 = r*r;
1489       Standard_Real r3 = r2*r;
1490       Standard_Real r2u2 = r2*U2;
1491       Standard_Real ru4 = r*u4;
1492  
1493           // copier-coller de mathematica 
1494       DUV = 
1495                 16440*ru4 - 7200*L*ru4 - 27000*m*ru4 + 16440*L*m*ru4 + 15300*m2*ru4 - 13500*L*m2*ru4 - 
1496      3600*m3*ru4 + 5100*L*m3*ru4 + 300*m4*ru4 - 900*L*m4*ru4 + 60*L*m5*ru4 - 4500*r2u2 + 2160*L*r2u2 + 6300*m*r2u2 - 
1497      4500*L*m*r2u2 - 2700*m2*r2u2 + 3150*L*m2*r2u2 + 360*m3*r2u2 - 900*L*m3*r2u2 + 90*L*m4*r2u2 + 165*r3 - 90*L*r3 - 
1498      180*m*r3 + 165*L*m*r3 + 45*m2*r3 - 90*L*m2*r3 + 15*L*m3*r3 - 14112*u6 + 5760*L*u6 + 25984*m*u6 - 14112*L*m*u6 - 
1499      17640*m2*u6 + 12992*L*m2*u6 + 5600*m3*u6 - 5880*L*m3*u6 - 840*m4*u6 + 1400*L*m4*u6 + 48*m5*u6 - 168*L*m5*u6 + 
1500      8*L*m6*u6;
1501
1502       DUV = 8*pr*DUV;
1503       }
1504       break;
1505
1506    default:
1507       break;
1508     }
1509   break;
1510
1511   default:
1512   break;
1513   }
1514   
1515   return DUV * ddu[iu]*ddv[iv];
1516
1517 }
1518
1519
1520 //=======================================================================
1521 //function : UVBox
1522 //purpose  : 
1523 //=======================================================================
1524
1525 void Plate_Plate::UVBox(Standard_Real& UMin, Standard_Real& UMax,
1526                         Standard_Real& VMin, Standard_Real& VMax) const 
1527 {
1528   Standard_Integer i ;
1529   const Standard_Real Bmin = 1.e-3;
1530   UMin =  myConstraints(1).Pnt2d().X();
1531   UMax =  UMin;
1532   VMin =  myConstraints(1).Pnt2d().Y();
1533   VMax =  VMin;
1534
1535   for( i=2; i<=myConstraints.Length();i++)
1536   {
1537     Standard_Real x = myConstraints(i).Pnt2d().X();
1538     if(x<UMin) UMin = x;
1539     if(x>UMax) UMax = x;
1540     Standard_Real y = myConstraints(i).Pnt2d().Y();
1541     if(y<VMin) VMin = y;
1542     if(y>VMax) VMax = y; 
1543   }
1544
1545   for(i=1; i<=myLXYZConstraints.Length();i++)
1546     for(Standard_Integer j=1;j<= myLXYZConstraints(i).GetPPC().Length(); j++)
1547   {
1548     Standard_Real x = myLXYZConstraints(i).GetPPC()(j).Pnt2d().X();
1549     if(x<UMin) UMin = x;
1550     if(x>UMax) UMax = x;
1551     Standard_Real y = myLXYZConstraints(i).GetPPC()(j).Pnt2d().Y();
1552     if(y<VMin) VMin = y;
1553     if(y>VMax) VMax = y; 
1554   }
1555
1556   for(i=1; i<=myLScalarConstraints.Length();i++)
1557     for(Standard_Integer j=1;j<= myLScalarConstraints(i).GetPPC().Length(); j++)
1558   {
1559     Standard_Real x = myLScalarConstraints(i).GetPPC()(j).Pnt2d().X();
1560     if(x<UMin) UMin = x;
1561     if(x>UMax) UMax = x;
1562     Standard_Real y = myLScalarConstraints(i).GetPPC()(j).Pnt2d().Y();
1563     if(y<VMin) VMin = y;
1564     if(y>VMax) VMax = y; 
1565   }
1566  
1567
1568   if(UMax-UMin < Bmin)
1569     {
1570       Standard_Real UM = 0.5*(UMin+UMax);
1571       UMin = UM - 0.5*Bmin;
1572       UMax = UM + 0.5*Bmin;
1573     }
1574   if(VMax-VMin < Bmin)
1575     {
1576       Standard_Real VM = 0.5*(VMin+VMax);
1577       VMin = VM - 0.5*Bmin;
1578       VMax = VM + 0.5*Bmin;
1579     }
1580 }
1581
1582 //=======================================================================
1583 //function : UVConstraints
1584 //purpose  : 
1585 //=======================================================================
1586
1587 void Plate_Plate::UVConstraints(TColgp_SequenceOfXY& Seq) const 
1588 {
1589   for (Standard_Integer i=1;i<=myConstraints.Length();i++) {
1590     if ((myConstraints.Value(i).Idu()==0) && (myConstraints.Value(i).Idv()==0))
1591       Seq.Append((myConstraints.Value(i)).Pnt2d());
1592   }
1593 }
1594 //=======================================================================
1595
1596 void Plate_Plate::SetPolynomialPartOnly(const Standard_Boolean PPOnly)
1597 {
1598   PolynomialPartOnly = PPOnly;
1599 }