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