0024428: Implementation of LGPL license
[occt.git] / src / AdvApp2Var / AdvApp2Var_Patch.cxx
1 // Created on: 1996-07-02
2 // Created by: Joelle CHAUVET
3 // Copyright (c) 1996-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
9 // under the terms of the GNU Lesser General Public 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 // Modified:    Wed Jan 15 10:04:41 1997
18 //   by:        Joelle CHAUVET
19 //              G1135 : Methods CutSense with criterion, Coefficients,
20 //                              CritValue, SetCritValue
21 // Modified:    Tue May 19 10:22:44 1998
22 //   by:        Joelle CHAUVET / Jean-Marc LACHAUME
23 //              Initialisation de myCritValue pour OSF
24
25 #include <AdvApp2Var_Patch.ixx>
26 #include <AdvApp2Var_Node.hxx>
27 #include <AdvApp2Var_Iso.hxx>
28 #include <gp_Pnt.hxx>
29 #include <TColgp_HArray2OfPnt.hxx>
30 #include <TColgp_Array2OfPnt.hxx>
31 #include <TColStd_HArray1OfInteger.hxx>
32 #include <TColStd_HArray1OfReal.hxx>
33 #include <TColStd_HArray2OfReal.hxx>
34 #include <TColStd_Array2OfReal.hxx>
35 #include <Convert_GridPolynomialToPoles.hxx>
36 #include <Standard_ConstructionError.hxx>
37
38 #include <AdvApp2Var_ApproxF2var.hxx>
39 #include <AdvApp2Var_MathBase.hxx>
40
41
42 //============================================================================
43 //function : AdvApp2Var_Patch
44 //purpose  :
45 //============================================================================
46
47 AdvApp2Var_Patch::AdvApp2Var_Patch() :
48 myU0(0.),
49 myU1(1.),
50 myV0(0.),
51 myV1(1.),
52 myOrdInU(0),
53 myOrdInV(0),
54 myNbCoeffInU(0),
55 myNbCoeffInV(0),
56 myApprIsDone(Standard_False),
57 myHasResult(Standard_False),
58 myCutSense(0),
59 myDiscIsDone(Standard_False),
60 myCritValue(0.)
61 {
62 }
63
64 //============================================================================
65 //function : AdvApp2Var_Patch
66 //purpose  :
67 //============================================================================
68
69 AdvApp2Var_Patch::AdvApp2Var_Patch(const Standard_Real U0,
70                                    const Standard_Real U1,
71                                    const Standard_Real V0,
72                                    const Standard_Real V1,
73                                    const Standard_Integer iu,
74                                    const Standard_Integer iv) :
75 myU0(U0),
76 myU1(U1),
77 myV0(V0),
78 myV1(V1),
79 myOrdInU(iu),
80 myOrdInV(iv),
81 myNbCoeffInU(0),
82 myNbCoeffInV(0),
83 myApprIsDone(Standard_False),
84 myHasResult(Standard_False),
85 myCutSense(0),
86 myDiscIsDone(Standard_False),
87 myCritValue(0.)
88 {
89 }
90
91 //============================================================================
92 //function : IsDiscretised
93 //purpose  :
94 //============================================================================
95
96 Standard_Boolean AdvApp2Var_Patch::IsDiscretised() const 
97 {
98   return myDiscIsDone; 
99 }
100
101 //============================================================================
102 //function : Discretise
103 //purpose  : 
104 //============================================================================
105
106 void AdvApp2Var_Patch::Discretise(const AdvApp2Var_Context& Conditions,
107                                   const AdvApp2Var_Framework& Constraints,
108                                   const AdvApp2Var_EvaluatorFunc2Var& Func) 
109 {
110
111 // data stored in the Context
112   Standard_Integer NDIMEN, NBSESP, NDIMSE, ISOFAV;
113   NDIMEN = Conditions.TotalDimension();
114   NBSESP = Conditions.TotalNumberSSP();
115 // Attention : works only for 3D
116   NDIMSE = 3;
117   ISOFAV = Conditions.FavorIso();
118
119 // data related to the patch to be discretized
120   Standard_Integer NBPNTU, NBPNTV;
121   Standard_Integer IORDRU = myOrdInU, IORDRV = myOrdInV;
122   Handle (TColStd_HArray1OfReal) HUROOT  = Conditions.URoots();
123   Handle (TColStd_HArray1OfReal) HVROOT  = Conditions.VRoots();
124   Standard_Real * UROOT;
125     UROOT =  (Standard_Real *) &HUROOT ->ChangeArray1()(HUROOT ->Lower());
126   NBPNTU = (Conditions.URoots())->Length();
127   if (myOrdInU>-1) NBPNTU -= 2;
128   Standard_Real * VROOT;
129     VROOT =  (Standard_Real *) &HVROOT ->ChangeArray1()(HVROOT ->Lower());
130   NBPNTV = (Conditions.VRoots())->Length();
131   if (myOrdInV>-1) NBPNTV -= 2;
132
133 // data stored in the Framework Constraints cad Nodes and Isos 
134 // C1, C2, C3 and C4 are dimensionnes in FORTRAN with (NDIMEN,IORDRU+2,IORDRV+2)
135   Standard_Integer SIZE=NDIMEN*(IORDRU+2)*(IORDRV+2);
136   Handle (TColStd_HArray1OfReal) HCOINS  =
137     new TColStd_HArray1OfReal(1,SIZE*4);
138   HCOINS->Init(0.);
139
140   Standard_Integer iu,iv;
141   Standard_Real du=(myU1-myU0)/2,dv=(myV1-myV0)/2,rho,valnorm;
142
143   for (iu=0;iu<=myOrdInU;iu++) {
144     for (iv=0;iv<=myOrdInV;iv++) {
145 // factor of normalization
146       rho = pow(du,iu)*pow(dv,iv);
147
148 // F(U0,V0) and its derivatives normalized on (-1,1)
149       valnorm = rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).X();
150       HCOINS->SetValue( 1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv , valnorm );
151       valnorm = rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Y();
152       HCOINS->SetValue( 2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
153       valnorm = rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Z();
154       HCOINS->SetValue( 3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
155
156 // F(U1,V0) and its derivatives normalized on (-1,1)
157       valnorm = rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).X();
158       HCOINS->SetValue( SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
159       valnorm = rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Y();
160       HCOINS->SetValue( SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
161       valnorm = rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Z();
162       HCOINS->SetValue( SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
163
164 // F(U0,V1) and its derivatives normalized on (-1,1)
165       valnorm = rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).X();
166       HCOINS->SetValue( 2*SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
167       valnorm = rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Y();
168       HCOINS->SetValue( 2*SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
169       valnorm = rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Z();
170       HCOINS->SetValue( 2*SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
171
172 // F(U1,V1) and its derivatives normalized on (-1,1)
173       valnorm = rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).X();
174       HCOINS->SetValue( 3*SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
175       valnorm = rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Y();
176       HCOINS->SetValue( 3*SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
177       valnorm = rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Z();
178       HCOINS->SetValue( 3*SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
179     }
180   }
181   Standard_Real *C1 = 
182     (Standard_Real *) &HCOINS ->ChangeArray1()(HCOINS ->Lower());
183   Standard_Real *C2 = C1 + SIZE;
184   Standard_Real *C3 = C2 + SIZE;
185   Standard_Real *C4 = C3 + SIZE;
186
187 // tables SomTab and Diftab of discretization of isos U=U0 and U=U1
188 // SU0, SU1, DU0 and DU1 are dimensioned in FORTRAN to 
189 // (1+NBPNTV/2)*NDIMEN*(IORDRU+1)
190
191   SIZE = (1+NBPNTV/2)*NDIMEN;
192
193   Handle (TColStd_HArray1OfReal) HSU0
194     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
195   HSU0 ->ChangeArray1() =
196     ( (Constraints.IsoU(myU0,myV0,myV1)).SomTab() ) ->Array1();
197
198   Handle (TColStd_HArray1OfReal) HDU0
199     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
200   HDU0 ->ChangeArray1() =
201     ( (Constraints.IsoU(myU0,myV0,myV1)).DifTab() ) ->Array1();
202
203   Handle (TColStd_HArray1OfReal) HSU1
204     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
205   HSU1 ->ChangeArray1() =
206     ( (Constraints.IsoU(myU1,myV0,myV1)).SomTab() ) ->Array1();
207
208   Handle (TColStd_HArray1OfReal) HDU1
209     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
210   HDU1 ->ChangeArray1() =
211     ( (Constraints.IsoU(myU1,myV0,myV1)).DifTab() ) ->Array1();
212
213 // normalization
214   Standard_Integer ideb1,ideb2,ideb3,ideb4,jj;
215   for (iu=1;iu<=IORDRU;iu++) {
216     rho = pow(du,iu);
217     ideb1 = HSU0->Lower() + iu*SIZE -1;
218     ideb2 = HDU0->Lower() + iu*SIZE -1;
219     ideb3 = HSU1->Lower() + iu*SIZE -1;
220     ideb4 = HDU1->Lower() + iu*SIZE -1;
221     for (jj=1;jj<=SIZE;jj++) {
222       HSU0 ->SetValue(ideb1+jj,rho*HSU0->Value(ideb1+jj));
223       HDU0 ->SetValue(ideb2+jj,rho*HDU0->Value(ideb2+jj));
224       HSU1 ->SetValue(ideb3+jj,rho*HSU1->Value(ideb3+jj));
225       HDU1 ->SetValue(ideb4+jj,rho*HDU1->Value(ideb4+jj));
226     }
227   }
228
229   Standard_Real *SU0 = 
230     (Standard_Real *) &HSU0 ->ChangeArray1()(HSU0 ->Lower());
231   Standard_Real *DU0 = 
232     (Standard_Real *) &HDU0 ->ChangeArray1()(HDU0 ->Lower());
233   Standard_Real *SU1 = 
234     (Standard_Real *) &HSU1 ->ChangeArray1()(HSU1 ->Lower());
235   Standard_Real *DU1 = 
236     (Standard_Real *) &HDU1 ->ChangeArray1()(HDU1 ->Lower());
237
238 // tables SomTab and Diftab of discretization of isos V=V0 and V=V1
239 // SU0, SU1, DU0 and DU1 are dimensioned in FORTRAN at
240 // (1+NBPNTU/2)*NDIMEN*(IORDRV+1)
241
242   SIZE = (1+NBPNTU/2)*NDIMEN;
243
244   Handle (TColStd_HArray1OfReal) HSV0
245     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
246   HSV0 ->ChangeArray1() =
247     ( (Constraints.IsoV(myU0,myU1,myV0)).SomTab() ) ->Array1();
248
249   Handle (TColStd_HArray1OfReal) HDV0
250     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
251   HDV0 ->ChangeArray1() =
252     ( (Constraints.IsoV(myU0,myU1,myV0)).DifTab() ) ->Array1();
253
254   Handle (TColStd_HArray1OfReal) HSV1
255     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
256   HSV1 ->ChangeArray1() =
257     ( (Constraints.IsoV(myU0,myU1,myV1)).SomTab() ) ->Array1();
258
259   Handle (TColStd_HArray1OfReal) HDV1
260     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
261   HDV1 ->ChangeArray1() =
262     ( (Constraints.IsoV(myU0,myU1,myV1)).DifTab() ) ->Array1();
263
264 // normalisation
265   for (iv=1;iv<=IORDRV;iv++) {
266     rho = pow(dv,iv);
267     ideb1 = HSV0->Lower() + iv*SIZE -1;
268     ideb2 = HDV0->Lower() + iv*SIZE -1;
269     ideb3 = HSV1->Lower() + iv*SIZE -1;
270     ideb4 = HDV1->Lower() + iv*SIZE -1;
271     for (jj=1;jj<=SIZE;jj++) {
272       HSV0 ->SetValue(ideb1+jj,rho*HSV0->Value(ideb1+jj));
273       HDV0 ->SetValue(ideb2+jj,rho*HDV0->Value(ideb2+jj));
274       HSV1 ->SetValue(ideb3+jj,rho*HSV1->Value(ideb3+jj));
275       HDV1 ->SetValue(ideb4+jj,rho*HDV1->Value(ideb4+jj));
276     }
277   }
278
279   Standard_Real *SV0 = 
280     (Standard_Real *) &HSV0 ->ChangeArray1()(HSV0 ->Lower());
281   Standard_Real *DV0 = 
282     (Standard_Real *) &HDV0 ->ChangeArray1()(HDV0 ->Lower());
283   Standard_Real *SV1 = 
284     (Standard_Real *) &HSV1 ->ChangeArray1()(HSV1 ->Lower());
285   Standard_Real *DV1 = 
286     (Standard_Real *) &HDV1 ->ChangeArray1()(HDV1 ->Lower());
287
288 // SOSOTB and DIDITB are dimensioned in FORTRAN at 
289 // (0:NBPNTU/2,0:NBPNTV/2,NDIMEN)
290
291   SIZE=(1+NBPNTU/2)*(1+NBPNTV/2)*NDIMEN;
292
293   Handle (TColStd_HArray1OfReal) HSOSO  =
294     new TColStd_HArray1OfReal(1,SIZE);
295   Standard_Real *SOSOTB  =  
296     (Standard_Real *) &HSOSO ->ChangeArray1()(HSOSO ->Lower());
297   HSOSO->Init(0.);
298   Handle (TColStd_HArray1OfReal) HDIDI  =
299     new TColStd_HArray1OfReal(1,SIZE);
300   Standard_Real *DIDITB  =  
301     (Standard_Real *) &HDIDI ->ChangeArray1()(HDIDI ->Lower());
302   HDIDI->Init(0.);
303
304 // SODITB and DISOTB are dimensioned in FORTRAN at
305 // (1:NBPNTU/2,1:NBPNTV/2,NDIMEN)
306
307   SIZE=(NBPNTU/2)*(NBPNTV/2)*NDIMEN;
308
309   Handle (TColStd_HArray1OfReal) HSODI  =
310     new TColStd_HArray1OfReal(1,SIZE);
311   Standard_Real *SODITB  =  
312     (Standard_Real *) &HSODI ->ChangeArray1()(HSODI ->Lower());
313   HSODI->Init(0.);
314   Handle (TColStd_HArray1OfReal) HDISO  =
315     new TColStd_HArray1OfReal(1,SIZE);
316   Standard_Real *DISOTB  =  
317     (Standard_Real *) &HDISO ->ChangeArray1()(HDISO ->Lower());
318   HDISO->Init(0.);
319
320   Standard_Integer IERCOD=0;
321
322 //  discretization of polynoms of interpolation
323   AdvApp2Var_ApproxF2var::mma2cdi_(&NDIMEN,&NBPNTU,UROOT,&NBPNTV,VROOT,&IORDRU,&IORDRV,
324          C1,C2,C3,C4,SU0,SU1,DU0,DU1,SV0,SV1,DV0,DV1,
325          SOSOTB,SODITB,DISOTB,DIDITB,&IERCOD);
326
327 //  discretization of the square
328   Standard_Real UDBFN[2],VDBFN[2];
329   UDBFN[0] = myU0;
330   UDBFN[1] = myU1;
331   VDBFN[0] = myV0;
332   VDBFN[1] = myV1;
333
334   SIZE = Max(NBPNTU,NBPNTV);
335   Handle (TColStd_HArray1OfReal) HTABLE  =
336     new TColStd_HArray1OfReal(1,SIZE);
337   Standard_Real *TAB  =  
338     (Standard_Real *) &HTABLE ->ChangeArray1()(HTABLE ->Lower());
339
340   Handle (TColStd_HArray1OfReal) HPOINTS  =
341     new TColStd_HArray1OfReal(1,SIZE*NDIMEN);
342   Standard_Real *PTS  =  
343     (Standard_Real *) &HPOINTS ->ChangeArray1()(HPOINTS ->Lower());
344
345   // GCC 3.0 would not accept this line without the void
346   // pointer cast.  Perhaps the real problem is a definition
347   // somewhere that has a void * in it.
348   AdvApp2Var_ApproxF2var::mma2ds1_(&NDIMEN,
349                                    UDBFN,
350                                    VDBFN,
351                                    /*(void *)*/Func,
352                                    &NBPNTU,
353                                    &NBPNTV,
354                                    UROOT,
355                                    VROOT,
356                                    &ISOFAV,
357                                    SOSOTB,
358                                    DISOTB,
359                                    SODITB,
360                                    DIDITB,
361                                    PTS,
362                                    TAB,
363                                    &IERCOD);
364
365 // the results are stored
366   if (IERCOD == 0) {
367     myDiscIsDone = Standard_True;
368     mySosoTab = HSOSO;
369     myDisoTab = HDISO;
370     mySodiTab = HSODI;
371     myDidiTab = HDIDI;
372   }
373   else {
374     myDiscIsDone = Standard_False;
375   }
376 }
377
378 //============================================================================
379 //function : HasResult
380 //purpose  :
381 //============================================================================
382
383 Standard_Boolean AdvApp2Var_Patch::HasResult() const 
384 {
385   return myHasResult; 
386 }
387
388 //============================================================================
389 //function : IsApproximated
390 //purpose  :
391 //============================================================================
392
393 Standard_Boolean AdvApp2Var_Patch::IsApproximated() const 
394 {
395   return myApprIsDone;
396 }
397
398 //============================================================================
399 //function : AddConstraints
400 //purpose  :
401 //============================================================================
402
403 void AdvApp2Var_Patch::AddConstraints(const AdvApp2Var_Context& Conditions,
404                                       const AdvApp2Var_Framework& Constraints)
405 {
406 // data stored in the  Context
407   Standard_Integer NDIMEN, NBSESP, NDIMSE;
408   Standard_Integer IERCOD, NCFLMU, NCFLMV, NDegU, NDegV;
409   NDIMEN = Conditions.TotalDimension();
410   NBSESP = Conditions.TotalNumberSSP();
411 // Attention : works only for 3D
412   NDIMSE = 3;
413   NCFLMU = Conditions.ULimit();
414   NCFLMV = Conditions.VLimit();
415   NDegU = NCFLMU - 1;
416   NDegV = NCFLMV - 1;
417
418 // data relative to the patch 
419   Standard_Integer IORDRU = myOrdInU, IORDRV = myOrdInV;
420   Standard_Real *PATCAN  =  
421     (Standard_Real *) &myEquation ->ChangeArray1()(myEquation ->Lower());
422
423 // curves of approximation of Isos U
424   Standard_Integer SIZE = NCFLMV*NDIMEN;
425   Handle (TColStd_HArray1OfReal) HIsoU0
426     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
427   HIsoU0 -> ChangeArray1() =
428     (Constraints.IsoU(myU0,myV0,myV1)).Polynom() -> Array1();
429   Standard_Real *IsoU0 = 
430     (Standard_Real *) &HIsoU0 ->ChangeArray1()(HIsoU0 ->Lower());
431   Handle (TColStd_HArray1OfInteger) HCFU0
432     = new TColStd_HArray1OfInteger(1,IORDRU+1);
433   Standard_Integer *NCFU0 = 
434     (Standard_Integer *) &HCFU0 ->ChangeArray1()(HCFU0 ->Lower());
435   HCFU0->Init( (Constraints.IsoU(myU0,myV0,myV1)).NbCoeff() );
436
437   Handle (TColStd_HArray1OfReal) HIsoU1
438     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
439   HIsoU1 -> ChangeArray1() =
440     (Constraints.IsoU(myU1,myV0,myV1)).Polynom() -> Array1();
441   Standard_Real *IsoU1 = 
442     (Standard_Real *) &HIsoU1 ->ChangeArray1()(HIsoU1 ->Lower());
443   Handle (TColStd_HArray1OfInteger) HCFU1
444     = new TColStd_HArray1OfInteger(1,IORDRU+1);
445   Standard_Integer *NCFU1 = 
446     (Standard_Integer *) &HCFU1 ->ChangeArray1()(HCFU1 ->Lower());
447   HCFU1->Init( (Constraints.IsoU(myU1,myV0,myV1)).NbCoeff() );
448
449 // normalization of Isos U
450   Standard_Integer iu,iv;
451   Standard_Real du=(myU1-myU0)/2,dv=(myV1-myV0)/2,rho,valnorm;
452   Standard_Integer ideb0,ideb1,jj;
453
454   for (iu=1;iu<=IORDRU;iu++) {
455     rho = pow(du,iu);
456     ideb0 = HIsoU0->Lower() + iu*SIZE -1;
457     ideb1 = HIsoU1->Lower() + iu*SIZE -1;
458     for (jj=1;jj<=SIZE;jj++) {
459       HIsoU0->SetValue(ideb0+jj,rho*HIsoU0->Value(ideb0+jj));
460       HIsoU1->SetValue(ideb1+jj,rho*HIsoU1->Value(ideb1+jj));
461     }
462   }
463
464 // curves of approximation of Isos V
465   SIZE = NCFLMU*NDIMEN;
466   Handle (TColStd_HArray1OfReal) HIsoV0
467     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
468   HIsoV0 -> ChangeArray1() =
469     (Constraints.IsoV(myU0,myU1,myV0)).Polynom() -> Array1();
470   Standard_Real *IsoV0 = 
471     (Standard_Real *) &HIsoV0 ->ChangeArray1()(HIsoV0 ->Lower());
472   Handle (TColStd_HArray1OfInteger) HCFV0
473     = new TColStd_HArray1OfInteger(1,IORDRV+1);
474   Standard_Integer *NCFV0 = 
475     (Standard_Integer *) &HCFV0 ->ChangeArray1()(HCFV0 ->Lower());
476   HCFV0->Init( (Constraints.IsoV(myU0,myU1,myV0)).NbCoeff() );
477
478   Handle (TColStd_HArray1OfReal) HIsoV1
479     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
480   HIsoV1 -> ChangeArray1() =
481     (Constraints.IsoV(myU0,myU1,myV1)).Polynom() -> Array1();
482   Standard_Real *IsoV1 = 
483     (Standard_Real *) &HIsoV1 ->ChangeArray1()(HIsoV1 ->Lower());
484   Handle (TColStd_HArray1OfInteger) HCFV1
485     = new TColStd_HArray1OfInteger(1,IORDRV+1);
486   Standard_Integer *NCFV1 = 
487     (Standard_Integer *) &HCFV1 ->ChangeArray1()(HCFV1 ->Lower());
488   HCFV1->Init( (Constraints.IsoV(myU0,myU1,myV1)).NbCoeff() );
489
490 //  normalization of Isos V
491   for (iv=1;iv<=IORDRV;iv++) {
492     rho = pow(dv,iv);
493     ideb0 = HIsoV0->Lower() + iv*SIZE -1;
494     ideb1 = HIsoV1->Lower() + iv*SIZE -1;
495     for (jj=1;jj<=SIZE;jj++) {
496       HIsoV0 ->SetValue(ideb0+jj,rho*HIsoV0->Value(ideb0+jj));
497       HIsoV1->SetValue(ideb1+jj,rho*HIsoV1->Value(ideb1+jj));
498     }
499   }
500
501 // add constraints to constant V
502   Handle (TColStd_HArray1OfReal) HHERMV 
503     = new TColStd_HArray1OfReal(1,(2*IORDRV+2)*(2*IORDRV+2));
504   Standard_Real *HermV = 
505     (Standard_Real *) &HHERMV ->ChangeArray1()(HHERMV ->Lower());
506   if (IORDRV>=0) {
507     AdvApp2Var_ApproxF2var::mma1her_(&IORDRV,HermV,&IERCOD);
508     if (IERCOD!=0) {
509       Standard_ConstructionError::Raise
510            ("AdvApp2Var_Patch::AddConstraints : Error in FORTRAN");
511     }
512     AdvApp2Var_ApproxF2var::mma2ac2_(&NDIMEN,
513                                      &NDegU,
514                                      &NDegV,
515                                      &IORDRV,
516                                      &NCFLMU,
517                                      NCFV0,
518                                      IsoV0,
519                                      NCFV1,
520                                      IsoV1,
521                                      HermV,
522                                      PATCAN);
523   }
524
525 // add constraints to constant U
526   Handle (TColStd_HArray1OfReal) HHERMU 
527     = new TColStd_HArray1OfReal(1,(2*IORDRU+2)*(2*IORDRU+2));
528   Standard_Real *HermU = 
529     (Standard_Real *) &HHERMU ->ChangeArray1()(HHERMU ->Lower());
530   if (IORDRU>=0) {
531     AdvApp2Var_ApproxF2var::mma1her_(&IORDRU,HermU,&IERCOD);
532     if (IERCOD!=0) {
533       Standard_ConstructionError::Raise
534            ("AdvApp2Var_Patch::AddConstraints : Error in FORTRAN");
535     }
536     AdvApp2Var_ApproxF2var::mma2ac3_(&NDIMEN,&NDegU,&NDegV,&IORDRU,&NCFLMV,
537                                      NCFU0,IsoU0,NCFU1,IsoU1,HermU,PATCAN);
538   }
539
540 // add constraints at the corners
541   Standard_Integer ideb;
542   SIZE=NDIMEN*(IORDRU+2)*(IORDRV+2);
543   Handle (TColStd_HArray1OfReal) HCOINS  =
544     new TColStd_HArray1OfReal(1,SIZE*4);
545
546   for (iu=0;iu<=myOrdInU;iu++) {
547     for (iv=0;iv<=myOrdInV;iv++) {
548       rho = pow(du,iu)*pow(dv,iv);
549
550 // -F(U0,V0) and its derivatives normalized on (-1,1)
551       ideb = HCOINS->Lower() + NDIMEN*iu+NDIMEN*(IORDRU+2)*iv - 1;
552       valnorm = -rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).X();
553       HCOINS->SetValue( 1+ideb , valnorm );
554       valnorm = -rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Y();
555       HCOINS->SetValue( 2+ideb , valnorm );
556       valnorm = -rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Z();
557       HCOINS->SetValue( 3+ideb , valnorm );
558
559 // -F(U1,V0) and its derivatives normalized on (-1,1)
560       ideb += SIZE;
561       valnorm = -rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).X();
562       HCOINS->SetValue( 1+ideb , valnorm );
563       valnorm = -rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Y();
564       HCOINS->SetValue( 2+ideb , valnorm );
565       valnorm = -rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Z();
566       HCOINS->SetValue( 3+ideb , valnorm );
567
568 // -F(U0,V1) and its derivatives normalized on (-1,1)
569       ideb += SIZE;
570       valnorm = -rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).X();
571       HCOINS->SetValue( 1+ideb , valnorm );
572       valnorm = -rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Y();
573       HCOINS->SetValue( 2+ideb , valnorm );
574       valnorm = -rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Z();
575       HCOINS->SetValue( 3+ideb , valnorm );
576
577 // -F(U1,V1) and its derivatives normalized on (-1,1)
578       ideb += SIZE;
579       valnorm = -rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).X();
580       HCOINS->SetValue( 1+ideb , valnorm );
581       valnorm = -rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Y();
582       HCOINS->SetValue( 2+ideb , valnorm );
583       valnorm = -rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Z();
584       HCOINS->SetValue( 3+ideb , valnorm );
585     }
586   }
587
588 //  tables required for FORTRAN
589   Standard_Integer IORDMX = Max(IORDRU,IORDRV);
590   Handle (TColStd_HArray1OfReal) HEXTR =
591     new TColStd_HArray1OfReal(1,2*IORDMX+2);
592   Standard_Real *EXTR = 
593     (Standard_Real *) &HEXTR ->ChangeArray1()(HEXTR ->Lower());
594   Handle (TColStd_HArray1OfReal) HFACT =
595     new TColStd_HArray1OfReal(1,IORDMX+1);
596   Standard_Real *FACT = 
597     (Standard_Real *) &HFACT ->ChangeArray1()(HFACT ->Lower());
598
599   Standard_Integer idim,ncf0,ncf1,iun=1;
600   Standard_Real *Is;
601
602 // add extremities of isos U
603   for (iu=1;iu<=IORDRU+1;iu++) {
604     ncf0 = HCFU0->Value(HCFU0->Lower()+iu-1);
605     ncf1 = HCFU1->Value(HCFU1->Lower()+iu-1);
606     for (idim=1;idim<=NDIMEN;idim++) {
607       Is = IsoU0 + NCFLMV*(idim-1) + NCFLMV*NDIMEN*(iu-1);
608       AdvApp2Var_MathBase::mmdrc11_(&IORDRV,&iun,&ncf0,Is,EXTR,FACT);
609       for (iv=1;iv<=IORDRV+1;iv++) {
610         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
611         HCOINS->ChangeValue(idim+ideb) += HEXTR->Value(1+2*(iv-1));
612         HCOINS->ChangeValue(2*SIZE+idim+ideb) += HEXTR->Value(2+2*(iv-1));
613       }
614       Is = IsoU1 + NCFLMV*(idim-1) + NCFLMV*NDIMEN*(iu-1);
615       AdvApp2Var_MathBase::mmdrc11_(&IORDRV,&iun,&ncf1,Is,EXTR,FACT);
616       for (iv=1;iv<=IORDRV+1;iv++) {
617         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
618         HCOINS->ChangeValue(SIZE+idim+ideb) += HEXTR->Value(1+2*(iv-1));
619         HCOINS->ChangeValue(3*SIZE+idim+ideb) += HEXTR->Value(2+2*(iv-1));
620       }
621     }
622   }
623
624 // add extremities of isos V
625   for (iv=1;iv<=IORDRV+1;iv++) {
626     ncf0 = HCFV0->Value(HCFV0->Lower()+iv-1);
627     ncf1 = HCFV1->Value(HCFV1->Lower()+iv-1);
628     for (idim=1;idim<=NDIMEN;idim++) {
629       Is = IsoV0 + NCFLMU*(idim-1) + NCFLMU*NDIMEN*(iv-1);
630       AdvApp2Var_MathBase::mmdrc11_(&IORDRU,&iun,&ncf0,Is,EXTR,FACT);
631       for (iu=1;iu<=IORDRU+1;iu++) {
632         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
633         HCOINS->ChangeValue(idim+ideb) += HEXTR->Value(1+2*(iu-1));
634         HCOINS->ChangeValue(SIZE+idim+ideb) += HEXTR->Value(2+2*(iu-1));
635       }
636       Is = IsoV1 + NCFLMU*(idim-1) + NCFLMU*NDIMEN*(iv-1);
637       AdvApp2Var_MathBase::mmdrc11_(&IORDRU,&iun,&ncf1,Is,EXTR,FACT);
638       for (iu=1;iu<=IORDRU+1;iu++) {
639         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
640         HCOINS->ChangeValue(2*SIZE+idim+ideb) += HEXTR->Value(1+2*(iu-1));
641         HCOINS->ChangeValue(3*SIZE+idim+ideb) += HEXTR->Value(2+2*(iu-1));
642       }
643     }
644   }
645
646 // add all to PATCAN
647   Standard_Real *C1 = 
648     (Standard_Real *) &HCOINS ->ChangeArray1()(HCOINS ->Lower());
649   Standard_Real *C2 = C1 + SIZE;
650   Standard_Real *C3 = C2 + SIZE;
651   Standard_Real *C4 = C3 + SIZE;
652   if ( IORDRU>=0 && IORDRV>=0 ) {
653     AdvApp2Var_ApproxF2var::mma2ac1_(&NDIMEN,&NDegU,&NDegV,&IORDRU,&IORDRV,
654                                      C1,C2,C3,C4,HermU,HermV,PATCAN);
655   }
656 }
657
658 //============================================================================
659 //function : AddErrors
660 //purpose  :
661 //============================================================================
662
663 void AdvApp2Var_Patch::AddErrors(const AdvApp2Var_Framework& Constraints)
664 {
665   Standard_Integer NBSESP = 1, iesp;
666   Standard_Integer iu,iv;
667
668   Standard_Real errU,errV,error,hmax[4];
669   hmax[0] = 0;
670   hmax[1] = 1;
671   hmax[2] = 1.5;
672   hmax[3] = 1.75;
673
674   for (iesp=1;iesp<=NBSESP;iesp++) {
675     //  error max in sub-space iesp
676     errU=0.;
677     for (iv=1;iv<=myOrdInV+1;iv++) {
678       error = ((Constraints.IsoV(myU0,myU1,myV0)).MaxErrors())->Value(iesp,iv);
679       errU = Max(errU,error);
680       error = ((Constraints.IsoV(myU0,myU1,myV1)).MaxErrors())->Value(iesp,iv);
681       errU = Max(errU,error);
682     }
683     errV=0.;
684     for (iu=1;iu<=myOrdInU+1;iu++) {
685       error = ((Constraints.IsoU(myU0,myV0,myV1)).MaxErrors())->Value(iesp,iu);
686       errV = Max(errV,error);
687       error = ((Constraints.IsoU(myU1,myV0,myV1)).MaxErrors())->Value(iesp,iu);
688       errV = Max(errV,error);
689     }
690     myMaxErrors->ChangeValue(iesp) +=
691       errU * hmax[myOrdInV+1]  +  errV * hmax[myOrdInU+1];
692
693     // average error in sub-space iesp
694     errU=0.;
695     for (iv=1;iv<=myOrdInV+1;iv++) {
696       error = ((Constraints.IsoV(myU0,myU1,myV0)).MoyErrors())->Value(iesp,iv);
697       errU = Max(errU,error);
698       error = ((Constraints.IsoV(myU0,myU1,myV1)).MoyErrors())->Value(iesp,iv);
699       errU = Max(errU,error);
700     }
701     errV=0.;
702     for (iu=1;iu<=myOrdInU+1;iu++) {
703       error = ((Constraints.IsoU(myU0,myV0,myV1)).MoyErrors())->Value(iesp,iu);
704       errV = Max(errV,error);
705       error = ((Constraints.IsoU(myU1,myV0,myV1)).MoyErrors())->Value(iesp,iu);
706       errV = Max(errV,error);
707     }
708     error = myMoyErrors->Value(iesp);
709     error *= error;
710     error += errU*hmax[myOrdInV+1] * errU*hmax[myOrdInV+1]
711                    + errV*hmax[myOrdInU+1] * errV*hmax[myOrdInU+1];
712     myMoyErrors->SetValue(iesp,Sqrt(error));
713
714     // max errors at iso-borders
715     Handle (TColStd_HArray2OfReal) HERISO
716       = new TColStd_HArray2OfReal(1,NBSESP,1,4);
717     HERISO->SetValue(iesp,1,
718               ((Constraints.IsoV(myU0,myU1,myV0)).MaxErrors())->Value(iesp,1));
719     HERISO->SetValue(iesp,2,
720               ((Constraints.IsoV(myU0,myU1,myV1)).MaxErrors())->Value(iesp,1));
721     HERISO->SetValue(iesp,3,
722               ((Constraints.IsoU(myU0,myV0,myV1)).MaxErrors())->Value(iesp,1));
723     HERISO->SetValue(iesp,4,
724               ((Constraints.IsoU(myU1,myV0,myV1)).MaxErrors())->Value(iesp,1));
725
726 // calculate max errors at the corners
727     Standard_Real emax1=0.,emax2=0.,emax3=0.,emax4=0.,err1,err2,err3,err4;
728     for (iu=0;iu<=myOrdInU;iu++) {
729       for (iv=0;iv<=myOrdInV;iv++) {
730         error = (Constraints.Node(myU0,myV0)).Error(iu,iv);
731         emax1 = Max(emax1,error);
732         error = (Constraints.Node(myU1,myV0)).Error(iu,iv);
733         emax2 = Max(emax2,error);
734         error = (Constraints.Node(myU0,myV1)).Error(iu,iv);
735         emax3 = Max(emax3,error);
736         error = (Constraints.Node(myU1,myV1)).Error(iu,iv);
737         emax4 = Max(emax4,error);
738       }
739     }
740
741 // calculate max errors on borders
742     err1 = Max(emax1,emax2);
743     err2 = Max(emax3,emax4);
744     err3 = Max(emax1,emax3);
745     err4 = Max(emax2,emax4);
746
747 //   calculate final errors on internal isos
748     if ( (Constraints.IsoV(myU0,myU1,myV0)).Position() == 0 ) {
749       HERISO ->ChangeValue(iesp,1) += err1*hmax[myOrdInU+1];
750     }
751     if ( (Constraints.IsoV(myU0,myU1,myV1)).Position() == 0 ) {
752       HERISO ->ChangeValue(iesp,2) += err2*hmax[myOrdInU+1];
753     }
754     if ( (Constraints.IsoU(myU0,myV0,myV1)).Position() == 0 ) {
755       HERISO ->ChangeValue(iesp,3) += err3*hmax[myOrdInV+1];
756     }
757     if ( (Constraints.IsoU(myU1,myV0,myV1)).Position() == 0 ) {
758       HERISO ->ChangeValue(iesp,4) += err4*hmax[myOrdInV+1];
759     }
760     myIsoErrors = HERISO;
761   }
762 }
763
764 //============================================================================
765 //function : MakeApprox
766 //purpose  :
767 //============================================================================
768
769 void AdvApp2Var_Patch::MakeApprox(const AdvApp2Var_Context& Conditions,
770                                   const AdvApp2Var_Framework& Constraints,
771                                   const Standard_Integer NumDec)
772 {
773
774 // data stored in the Context
775   Standard_Integer NDIMEN, NBSESP, NDIMSE;
776   Standard_Integer NBPNTU, NBPNTV, NCFLMU, NCFLMV, NDJACU, NDJACV;
777   Standard_Integer NDegU, NDegV, NJacU, NJacV;
778   NDIMEN = Conditions.TotalDimension();
779   NBSESP = Conditions.TotalNumberSSP();
780   NDIMSE = 3;
781   NBPNTU = (Conditions.URoots())->Length();
782   if (myOrdInU>-1) NBPNTU -= 2;
783   NBPNTV = (Conditions.VRoots())->Length();
784   if (myOrdInV>-1) NBPNTV -= 2;
785   NCFLMU = Conditions.ULimit();
786   NCFLMV = Conditions.VLimit();
787   NDegU = NCFLMU - 1;
788   NDegV = NCFLMV - 1;
789   NDJACU = Conditions.UJacDeg();
790   NDJACV = Conditions.VJacDeg();
791   NJacU = NDJACU + 1;
792   NJacV = NDJACV + 1;
793
794 // data relative to the processed patch
795   Standard_Integer IORDRU = myOrdInU, IORDRV = myOrdInV,
796                    NDMINU = 1, NDMINV = 1, NCOEFU, NCOEFV;
797 // NDMINU and NDMINV depend on the nb of coeff of neighboring isos
798 // and of the required order of continuity
799   NDMINU = Max(1,2*IORDRU+1);
800   NCOEFU = (Constraints.IsoV(myU0,myU1,myV0)).NbCoeff()-1;
801   NDMINU = Max(NDMINU,NCOEFU);
802   NCOEFU = (Constraints.IsoV(myU0,myU1,myV1)).NbCoeff()-1;
803   NDMINU = Max(NDMINU,NCOEFU);
804
805   NDMINV = Max(1,2*IORDRV+1);
806   NCOEFV = (Constraints.IsoU(myU0,myV0,myV1)).NbCoeff()-1;
807   NDMINV = Max(NDMINV,NCOEFV);
808   NCOEFV = (Constraints.IsoU(myU1,myV0,myV1)).NbCoeff()-1;
809   NDMINV = Max(NDMINV,NCOEFV);
810
811 // tables of approximations
812   Handle (TColStd_HArray1OfReal) HEPSAPR =
813     new TColStd_HArray1OfReal(1,NBSESP);
814   Handle (TColStd_HArray1OfReal) HEPSFRO =
815     new TColStd_HArray1OfReal(1,NBSESP*8);
816   Standard_Integer iesp;
817   for (iesp=1;iesp<=NBSESP;iesp++) {
818     HEPSAPR->SetValue(iesp,(Conditions.IToler())->Value(iesp));
819     HEPSFRO->SetValue(iesp,(Conditions.FToler())->Value(iesp,1));
820     HEPSFRO->SetValue(iesp+NBSESP,(Conditions.FToler())->Value(iesp,2));
821     HEPSFRO->SetValue(iesp+2*NBSESP,(Conditions.FToler())->Value(iesp,3));
822     HEPSFRO->SetValue(iesp+3*NBSESP,(Conditions.FToler())->Value(iesp,4));
823     HEPSFRO->SetValue(iesp+4*NBSESP,(Conditions.CToler())->Value(iesp,1));
824     HEPSFRO->SetValue(iesp+5*NBSESP,(Conditions.CToler())->Value(iesp,2));
825     HEPSFRO->SetValue(iesp+6*NBSESP,(Conditions.CToler())->Value(iesp,3));
826     HEPSFRO->SetValue(iesp+7*NBSESP,(Conditions.CToler())->Value(iesp,4));
827   }
828   Standard_Real *EPSAPR  =
829     (Standard_Real *) &HEPSAPR ->ChangeArray1()(HEPSAPR ->Lower());
830   Standard_Real *EPSFRO  =
831     (Standard_Real *) &HEPSFRO ->ChangeArray1()(HEPSFRO ->Lower());
832
833   Standard_Integer SIZE=(1+NDJACU)*(1+NDJACV)*NDIMEN;
834   Handle (TColStd_HArray1OfReal) HPJAC  =
835     new TColStd_HArray1OfReal(1,SIZE);
836   Standard_Real *PATJAC  =  
837     (Standard_Real *) &HPJAC ->ChangeArray1()(HPJAC ->Lower());
838   SIZE=2*SIZE;
839   Handle (TColStd_HArray1OfReal) HPAUX  =
840     new TColStd_HArray1OfReal(1,SIZE);
841   Standard_Real *PATAUX  =  
842     (Standard_Real *) &HPAUX ->ChangeArray1()(HPAUX ->Lower());
843   SIZE=NCFLMU*NCFLMV*NDIMEN;
844   Handle (TColStd_HArray1OfReal) HPCAN  =
845     new TColStd_HArray1OfReal(1,SIZE);
846   Standard_Real *PATCAN  =  
847     (Standard_Real *) &HPCAN ->ChangeArray1()(HPCAN ->Lower());
848   Handle (TColStd_HArray1OfReal) HERRMAX  =  
849     new TColStd_HArray1OfReal(1,NBSESP);
850   Standard_Real *ERRMAX =
851     (Standard_Real *) &HERRMAX ->ChangeArray1()(HERRMAX ->Lower());
852   Handle (TColStd_HArray1OfReal) HERRMOY  =  
853     new TColStd_HArray1OfReal(1,NBSESP);
854   Standard_Real *ERRMOY =
855     (Standard_Real *) &HERRMOY ->ChangeArray1()(HERRMOY ->Lower());
856
857 // tables of discretization of the square
858   Standard_Real *SOSOTB  =  
859     (Standard_Real *) &mySosoTab ->ChangeArray1()(mySosoTab ->Lower());
860   Standard_Real *DISOTB  =  
861     (Standard_Real *) &myDisoTab ->ChangeArray1()(myDisoTab ->Lower());
862   Standard_Real *SODITB  =  
863     (Standard_Real *) &mySodiTab ->ChangeArray1()(mySodiTab ->Lower());
864   Standard_Real *DIDITB  =  
865     (Standard_Real *) &myDidiTab ->ChangeArray1()(myDidiTab ->Lower());
866
867 //  approximation
868   Standard_Integer ITYDEC=0, IERCOD=0;
869   Standard_Integer iun=1,itrois=3;
870   NCOEFU=0;
871   NCOEFV=0;
872   AdvApp2Var_ApproxF2var::mma2ce1_((integer *)&NumDec,
873                                    &NDIMEN,
874                                    &NBSESP,
875                                    &NDIMSE,
876                                    &NDMINU,
877                                    &NDMINV,
878                                    &NDegU,
879                                    &NDegV,
880                                    &NDJACU,
881                                    &NDJACV,
882                                    &IORDRU,
883                                    &IORDRV,
884                                    &NBPNTU,
885                                    &NBPNTV,
886                                    EPSAPR,
887                                    SOSOTB,
888                                    DISOTB,
889                                    SODITB,
890                                    DIDITB,
891                                    PATJAC,
892                                    ERRMAX,
893                                    ERRMOY,
894                                    &NCOEFU,
895                                    &NCOEFV,
896                                    &ITYDEC,
897                                    &IERCOD);
898
899 // results
900   myCutSense = ITYDEC;
901   if (ITYDEC == 0 && IERCOD<=0) {
902     myHasResult  = Standard_True;
903     myApprIsDone = (IERCOD==0);
904     myNbCoeffInU  = NCOEFU+1;
905     myNbCoeffInV  = NCOEFV+1;
906     myMaxErrors = HERRMAX;
907     myMoyErrors = HERRMOY;
908
909 // Passage to canonic on [-1,1]
910     AdvApp2Var_MathBase::mmfmca9_(&NJacU,&NJacV,&NDIMEN,&myNbCoeffInU,&myNbCoeffInV,
911                                   &NDIMEN,PATJAC,PATJAC);
912     AdvApp2Var_ApproxF2var::mma2can_(&NCFLMU,&NCFLMV,&NDIMEN,
913                                      &myOrdInU,&myOrdInV,&myNbCoeffInU,
914                                      &myNbCoeffInV,
915                                      PATJAC,PATAUX,PATCAN,&IERCOD);
916     if (IERCOD !=0) {
917       Standard_ConstructionError::Raise
918               ("AdvApp2Var_Patch::MakeApprox : Error in FORTRAN");
919     }
920     myEquation = HPCAN;
921
922 // Add constraints and errors
923     AddConstraints(Conditions,Constraints);
924     AddErrors(Constraints);
925
926 // Reduction of degrees if possible
927     PATCAN = (Standard_Real *) 
928       &myEquation->ChangeArray1()(myEquation ->Lower());
929
930     AdvApp2Var_ApproxF2var::mma2fx6_(&NCFLMU,
931                                      &NCFLMV,
932                                      &NDIMEN,
933                                      &NBSESP,
934                                      &itrois,
935                                      &iun,
936                                      &iun,
937                                      &IORDRU,
938                                      &IORDRV,
939                                      EPSAPR,
940                                      EPSFRO,
941                                      PATCAN,
942                                      ERRMAX,
943                                      &myNbCoeffInU,
944                                      &myNbCoeffInV);
945     
946 // transposition (NCFLMU,NCFLMV,NDIMEN)Fortran-C++
947     Standard_Integer aIU, aIN, dim, ii, jj;
948     for (dim=1; dim<=NDIMEN; dim++){
949        aIN = (dim-1)*NCFLMU*NCFLMV;
950        for (ii=1; ii<=NCFLMU; ii++) {
951          aIU = (ii-1)*NDIMEN*NCFLMV;
952          for (jj=1; jj<=NCFLMV; jj++) {
953            HPAUX->SetValue(dim+NDIMEN*(jj-1)+aIU ,
954                            myEquation->Value(ii+NCFLMU*(jj-1)+aIN) );
955          }
956        }
957      }
958     myEquation = HPAUX;
959   } 
960   else { 
961     myApprIsDone = Standard_False;
962     myHasResult  = Standard_False;
963   } 
964 }
965
966 //============================================================================
967 //function : ChangeDomain
968 //purpose  :
969 //============================================================================
970
971 void AdvApp2Var_Patch::ChangeDomain(const Standard_Real a,
972                                     const Standard_Real b,
973                                     const Standard_Real c,
974                                     const Standard_Real d)
975 {
976   myU0 = a;
977   myU1 = b;
978   myV0 = c;
979   myV1 = d;
980 }
981
982 //============================================================================
983 //function : ResetApprox
984 //purpose  : allows removing a result when it is necessary to cut
985 //============================================================================
986
987 void AdvApp2Var_Patch::ResetApprox()
988 {
989   myApprIsDone = Standard_False;
990   myHasResult = Standard_False;
991 }
992
993 //============================================================================
994 //function : OverwriteApprox
995 //purpose  : allows preserving a result even if the precision is not satisfactory
996 //============================================================================
997
998 void AdvApp2Var_Patch::OverwriteApprox()
999 {
1000   if (myHasResult) myApprIsDone = Standard_True;
1001 }
1002
1003 //============================================================================
1004 //function : U0
1005 //purpose  :
1006 //============================================================================
1007
1008 Standard_Real AdvApp2Var_Patch::U0() const 
1009 {
1010   return myU0;
1011 }
1012
1013 //============================================================================
1014 //function : U1
1015 //purpose  :
1016 //============================================================================
1017
1018 Standard_Real AdvApp2Var_Patch::U1() const 
1019 {
1020   return myU1;
1021 }
1022
1023 //============================================================================
1024 //function : V0
1025 //purpose  :
1026 //============================================================================
1027
1028 Standard_Real AdvApp2Var_Patch::V0() const 
1029 {
1030   return myV0;
1031 }
1032
1033 //============================================================================
1034 //function : V1
1035 //purpose  :
1036 //============================================================================
1037
1038 Standard_Real AdvApp2Var_Patch::V1() const 
1039 {
1040   return myV1;
1041 }
1042
1043 //============================================================================
1044 //function : UOrder
1045 //purpose  : 
1046 //============================================================================
1047
1048 Standard_Integer AdvApp2Var_Patch::UOrder() const 
1049 {
1050   return myOrdInU;
1051 }
1052
1053
1054 //============================================================================
1055 //function : VOrder
1056 //purpose  : 
1057 //============================================================================
1058
1059 Standard_Integer AdvApp2Var_Patch::VOrder() const 
1060 {
1061   return myOrdInV;
1062 }
1063
1064
1065 //============================================================================
1066 //function : CutSense without Critere
1067 //purpose  : 0 : OK; 1 : required cut by U;
1068 //           2 : required cut by V; 3 : required cut by U and by V
1069 //============================================================================
1070
1071 Standard_Integer AdvApp2Var_Patch::CutSense() const 
1072 {
1073   return myCutSense;
1074 }
1075
1076
1077 //============================================================================
1078 //function : CutSense with critere
1079 //purpose  : 0 : OK; 1 : required cut by U;
1080 //           2 : required cut by V; 3 : required cut by U and by V
1081 //============================================================================
1082
1083 Standard_Integer AdvApp2Var_Patch::CutSense(const AdvApp2Var_Criterion& Crit,
1084                                             const Standard_Integer NumDec) const 
1085 {
1086   Standard_Boolean CritRel = (Crit.Type() == AdvApp2Var_Relative);
1087   if ( CritRel && !IsApproximated()) {
1088     return myCutSense;
1089   }
1090   else {
1091     if (Crit.IsSatisfied(*this)) {
1092       return 0;
1093     } 
1094     else {
1095       return NumDec;
1096     } 
1097   }
1098 }
1099
1100
1101 //============================================================================
1102 //function : NbCoeffInU
1103 //purpose  :
1104 //============================================================================
1105
1106 Standard_Integer AdvApp2Var_Patch::NbCoeffInU() const 
1107 {
1108   return myNbCoeffInU;
1109 }
1110
1111 //============================================================================
1112 //function : NbCoeffInV
1113 //purpose  :
1114 //============================================================================
1115
1116 Standard_Integer AdvApp2Var_Patch::NbCoeffInV() const 
1117 {
1118   return myNbCoeffInV;
1119 }
1120
1121 //============================================================================
1122 //function : ChangeNbCoeff
1123 //purpose  : allows increasing the nb of coeff (cf Network)
1124 //============================================================================
1125
1126 void AdvApp2Var_Patch::ChangeNbCoeff(const Standard_Integer NbCoeffU,
1127                                      const Standard_Integer NbCoeffV)
1128 {
1129   if (myNbCoeffInU<NbCoeffU) myNbCoeffInU = NbCoeffU;
1130   if (myNbCoeffInV<NbCoeffV) myNbCoeffInV = NbCoeffV;
1131 }
1132
1133 //============================================================================
1134 //function : MaxErrors
1135 //purpose  : returns max errors of polynomial approximation
1136 //============================================================================
1137
1138 Handle(TColStd_HArray1OfReal) 
1139 AdvApp2Var_Patch::MaxErrors() const 
1140 {
1141   return myMaxErrors;
1142 }
1143
1144 //============================================================================
1145 //function : AverageErrors
1146 //purpose  : returns average errors of polynomial approximation
1147 //============================================================================
1148
1149 Handle(TColStd_HArray1OfReal) 
1150 AdvApp2Var_Patch::AverageErrors() const 
1151 {
1152   return myMoyErrors;
1153 }
1154
1155 //============================================================================
1156 //function : IsoErrors
1157 //purpose  : returns max errors on borders of polynomial approximation
1158 //============================================================================
1159
1160 Handle(TColStd_HArray2OfReal) 
1161 AdvApp2Var_Patch::IsoErrors() const 
1162 {
1163   return myIsoErrors;
1164 }
1165
1166 //============================================================================
1167 //function : Poles
1168 //purpose  : returns poles of the polynomial approximation 
1169 //============================================================================
1170
1171 Handle(TColgp_HArray2OfPnt) 
1172 AdvApp2Var_Patch::Poles(const Standard_Integer SSPIndex,
1173                         const  AdvApp2Var_Context & Cond) const 
1174 {
1175   Handle(TColStd_HArray1OfReal) SousEquation;
1176   if ( Cond.TotalNumberSSP( ) == 1 && SSPIndex == 1 ) {
1177     SousEquation = myEquation;
1178   }
1179   else {
1180     Standard_ConstructionError::Raise
1181                ("AdvApp2Var_Patch::Poles :  SSPIndex out of range");
1182   }
1183   Handle(TColStd_HArray1OfReal) Intervalle = 
1184     new (TColStd_HArray1OfReal) (1,2);
1185   Intervalle->SetValue(1, -1);
1186   Intervalle->SetValue(2, 1);
1187
1188
1189   Handle(TColStd_HArray1OfInteger) NbCoeff = 
1190     new (TColStd_HArray1OfInteger) (1,2);
1191   NbCoeff->SetValue(1, myNbCoeffInU);
1192   NbCoeff->SetValue(2, myNbCoeffInV);
1193
1194 // Conversion
1195   Convert_GridPolynomialToPoles 
1196      Conv (Cond.ULimit()-1,
1197            Cond.VLimit()-1,
1198            NbCoeff,
1199            SousEquation,
1200            Intervalle,
1201            Intervalle);
1202
1203   return Conv.Poles();  
1204 }
1205
1206
1207 //============================================================================
1208 //function : Coefficients
1209 //purpose  : returns coeff. of the equation of polynomial approximation
1210 //============================================================================
1211
1212 Handle(TColStd_HArray1OfReal) 
1213 AdvApp2Var_Patch::Coefficients(const Standard_Integer SSPIndex,
1214                                const  AdvApp2Var_Context & Cond) const 
1215 {
1216   Handle(TColStd_HArray1OfReal) SousEquation;
1217   if ( Cond.TotalNumberSSP( ) == 1 && SSPIndex == 1 ) {
1218     SousEquation = myEquation;
1219   }
1220   else {
1221     Standard_ConstructionError::Raise
1222                ("AdvApp2Var_Patch::Poles :  SSPIndex out of range");
1223   }
1224   return SousEquation;
1225 }
1226
1227
1228 //============================================================================
1229 //function : CritValue
1230 //purpose  :
1231 //============================================================================
1232
1233 Standard_Real AdvApp2Var_Patch::CritValue() const 
1234 {
1235   return myCritValue;
1236 }
1237
1238
1239 //============================================================================
1240 //function : SetCritValue
1241 //purpose  :
1242 //============================================================================
1243
1244 void AdvApp2Var_Patch::SetCritValue(const Standard_Real dist) 
1245 {
1246   myCritValue = dist;
1247 }
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258