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 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 // 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_ApproxF2var.hxx>
  26 #include <AdvApp2Var_Context.hxx>
  27 #include <AdvApp2Var_Criterion.hxx>
  28 #include <AdvApp2Var_Framework.hxx>
  29 #include <AdvApp2Var_Iso.hxx>
  30 #include <AdvApp2Var_MathBase.hxx>
  31 #include <AdvApp2Var_Node.hxx>
  32 #include <AdvApp2Var_Patch.hxx>
  33 #include <Convert_GridPolynomialToPoles.hxx>
  34 #include <gp_Pnt.hxx>
  35 #include <Standard_ConstructionError.hxx>
  36 #include <TColgp_Array2OfPnt.hxx>
  37 #include <TColgp_HArray2OfPnt.hxx>
  38 #include <TColStd_Array2OfReal.hxx>
  39 #include <TColStd_HArray1OfInteger.hxx>
  40 #include <TColStd_HArray1OfReal.hxx>
  41 #include <TColStd_HArray2OfReal.hxx>
  42
  43 IMPLEMENT_STANDARD_RTTIEXT(AdvApp2Var_Patch, Standard_Transient)
  44
  45 //============================================================================
  46 //function : AdvApp2Var_Patch
  47 //purpose  :
  48 //============================================================================
  49 AdvApp2Var_Patch::AdvApp2Var_Patch() :
  50 myU0(0.),
  51 myU1(1.),
  52 myV0(0.),
  53 myV1(1.),
  54 myOrdInU(0),
  55 myOrdInV(0),
  56 myNbCoeffInU(0),
  57 myNbCoeffInV(0),
  58 myApprIsDone(Standard_False),
  59 myHasResult(Standard_False),
  60 myCutSense(0),
  61 myDiscIsDone(Standard_False),
  62 myCritValue(0.)
  63 {
  64 }
  65
  66 //============================================================================
  67 //function : AdvApp2Var_Patch
  68 //purpose  :
  69 //============================================================================
  70
  71 AdvApp2Var_Patch::AdvApp2Var_Patch(const Standard_Real U0,
  72                                    const Standard_Real U1,
  73                                    const Standard_Real V0,
  74                                    const Standard_Real V1,
  75                                    const Standard_Integer iu,
  76                                    const Standard_Integer iv) :
  77 myU0(U0),
  78 myU1(U1),
  79 myV0(V0),
  80 myV1(V1),
  81 myOrdInU(iu),
  82 myOrdInV(iv),
  83 myNbCoeffInU(0),
  84 myNbCoeffInV(0),
  85 myApprIsDone(Standard_False),
  86 myHasResult(Standard_False),
  87 myCutSense(0),
  88 myDiscIsDone(Standard_False),
  89 myCritValue(0.)
  90 {
  91 }
  92
  93 //============================================================================
  94 //function : IsDiscretised
  95 //purpose  :
  96 //============================================================================
  97
  98 Standard_Boolean AdvApp2Var_Patch::IsDiscretised() const
  99 {
 100   return myDiscIsDone;
 101 }
 102
 103 //============================================================================
 104 //function : Discretise
 105 //purpose  :
 106 //============================================================================
 107
 108 void AdvApp2Var_Patch::Discretise(const AdvApp2Var_Context& Conditions,
 109                                   const AdvApp2Var_Framework& Constraints,
 110                                   const AdvApp2Var_EvaluatorFunc2Var& Func)
 111 {
 112
 113 // data stored in the Context
 114   Standard_Integer NDIMEN, ISOFAV;
 115   NDIMEN = Conditions.TotalDimension();
 116 // Attention : works only for 3D
 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;
 408   Standard_Integer IERCOD, NCFLMU, NCFLMV, NDegU, NDegV;
 409   NDIMEN = Conditions.TotalDimension();
 410 // Attention : works only for 3D
 411   NCFLMU = Conditions.ULimit();
 412   NCFLMV = Conditions.VLimit();
 413   NDegU = NCFLMU - 1;
 414   NDegV = NCFLMV - 1;
 415
 416 // data relative to the patch
 417   Standard_Integer IORDRU = myOrdInU, IORDRV = myOrdInV;
 418   Standard_Real *PATCAN  =
 419     (Standard_Real *) &myEquation ->ChangeArray1()(myEquation ->Lower());
 420
 421 // curves of approximation of Isos U
 422   Standard_Integer SIZE = NCFLMV*NDIMEN;
 423   Handle (TColStd_HArray1OfReal) HIsoU0
 424     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
 425   HIsoU0 -> ChangeArray1() =
 426     (Constraints.IsoU(myU0,myV0,myV1)).Polynom() -> Array1();
 427   Standard_Real *IsoU0 =
 428     (Standard_Real *) &HIsoU0 ->ChangeArray1()(HIsoU0 ->Lower());
 429   Handle (TColStd_HArray1OfInteger) HCFU0
 430     = new TColStd_HArray1OfInteger(1,IORDRU+1);
 431   Standard_Integer *NCFU0 =
 432     (Standard_Integer *) &HCFU0 ->ChangeArray1()(HCFU0 ->Lower());
 433   HCFU0->Init( (Constraints.IsoU(myU0,myV0,myV1)).NbCoeff() );
 434
 435   Handle (TColStd_HArray1OfReal) HIsoU1
 436     = new TColStd_HArray1OfReal(1,SIZE*(IORDRU+1));
 437   HIsoU1 -> ChangeArray1() =
 438     (Constraints.IsoU(myU1,myV0,myV1)).Polynom() -> Array1();
 439   Standard_Real *IsoU1 =
 440     (Standard_Real *) &HIsoU1 ->ChangeArray1()(HIsoU1 ->Lower());
 441   Handle (TColStd_HArray1OfInteger) HCFU1
 442     = new TColStd_HArray1OfInteger(1,IORDRU+1);
 443   Standard_Integer *NCFU1 =
 444     (Standard_Integer *) &HCFU1 ->ChangeArray1()(HCFU1 ->Lower());
 445   HCFU1->Init( (Constraints.IsoU(myU1,myV0,myV1)).NbCoeff() );
 446
 447 // normalization of Isos U
 448   Standard_Integer iu,iv;
 449   Standard_Real du=(myU1-myU0)/2,dv=(myV1-myV0)/2,rho,valnorm;
 450   Standard_Integer ideb0,ideb1,jj;
 451
 452   for (iu=1;iu<=IORDRU;iu++) {
 453     rho = pow(du,iu);
 454     ideb0 = HIsoU0->Lower() + iu*SIZE -1;
 455     ideb1 = HIsoU1->Lower() + iu*SIZE -1;
 456     for (jj=1;jj<=SIZE;jj++) {
 457       HIsoU0->SetValue(ideb0+jj,rho*HIsoU0->Value(ideb0+jj));
 458       HIsoU1->SetValue(ideb1+jj,rho*HIsoU1->Value(ideb1+jj));
 459     }
 460   }
 461
 462 // curves of approximation of Isos V
 463   SIZE = NCFLMU*NDIMEN;
 464   Handle (TColStd_HArray1OfReal) HIsoV0
 465     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
 466   HIsoV0 -> ChangeArray1() =
 467     (Constraints.IsoV(myU0,myU1,myV0)).Polynom() -> Array1();
 468   Standard_Real *IsoV0 =
 469     (Standard_Real *) &HIsoV0 ->ChangeArray1()(HIsoV0 ->Lower());
 470   Handle (TColStd_HArray1OfInteger) HCFV0
 471     = new TColStd_HArray1OfInteger(1,IORDRV+1);
 472   Standard_Integer *NCFV0 =
 473     (Standard_Integer *) &HCFV0 ->ChangeArray1()(HCFV0 ->Lower());
 474   HCFV0->Init( (Constraints.IsoV(myU0,myU1,myV0)).NbCoeff() );
 475
 476   Handle (TColStd_HArray1OfReal) HIsoV1
 477     = new TColStd_HArray1OfReal(1,SIZE*(IORDRV+1));
 478   HIsoV1 -> ChangeArray1() =
 479     (Constraints.IsoV(myU0,myU1,myV1)).Polynom() -> Array1();
 480   Standard_Real *IsoV1 =
 481     (Standard_Real *) &HIsoV1 ->ChangeArray1()(HIsoV1 ->Lower());
 482   Handle (TColStd_HArray1OfInteger) HCFV1
 483     = new TColStd_HArray1OfInteger(1,IORDRV+1);
 484   Standard_Integer *NCFV1 =
 485     (Standard_Integer *) &HCFV1 ->ChangeArray1()(HCFV1 ->Lower());
 486   HCFV1->Init( (Constraints.IsoV(myU0,myU1,myV1)).NbCoeff() );
 487
 488 //  normalization of Isos V
 489   for (iv=1;iv<=IORDRV;iv++) {
 490     rho = pow(dv,iv);
 491     ideb0 = HIsoV0->Lower() + iv*SIZE -1;
 492     ideb1 = HIsoV1->Lower() + iv*SIZE -1;
 493     for (jj=1;jj<=SIZE;jj++) {
 494       HIsoV0 ->SetValue(ideb0+jj,rho*HIsoV0->Value(ideb0+jj));
 495       HIsoV1->SetValue(ideb1+jj,rho*HIsoV1->Value(ideb1+jj));
 496     }
 497   }
 498
 499 // add constraints to constant V
 500   Handle (TColStd_HArray1OfReal) HHERMV
 501     = new TColStd_HArray1OfReal(1,(2*IORDRV+2)*(2*IORDRV+2));
 502   Standard_Real *HermV =
 503     (Standard_Real *) &HHERMV ->ChangeArray1()(HHERMV ->Lower());
 504   if (IORDRV>=0) {
 505     AdvApp2Var_ApproxF2var::mma1her_(&IORDRV,HermV,&IERCOD);
 506     if (IERCOD!=0) {
 507       throw Standard_ConstructionError("AdvApp2Var_Patch::AddConstraints : Error in FORTRAN");
 508     }
 509     AdvApp2Var_ApproxF2var::mma2ac2_(&NDIMEN,
 510                                      &NDegU,
 511                                      &NDegV,
 512                                      &IORDRV,
 513                                      &NCFLMU,
 514                                      NCFV0,
 515                                      IsoV0,
 516                                      NCFV1,
 517                                      IsoV1,
 518                                      HermV,
 519                                      PATCAN);
 520   }
 521
 522 // add constraints to constant U
 523   Handle (TColStd_HArray1OfReal) HHERMU
 524     = new TColStd_HArray1OfReal(1,(2*IORDRU+2)*(2*IORDRU+2));
 525   Standard_Real *HermU =
 526     (Standard_Real *) &HHERMU ->ChangeArray1()(HHERMU ->Lower());
 527   if (IORDRU>=0) {
 528     AdvApp2Var_ApproxF2var::mma1her_(&IORDRU,HermU,&IERCOD);
 529     if (IERCOD!=0) {
 530       throw Standard_ConstructionError("AdvApp2Var_Patch::AddConstraints : Error in FORTRAN");
 531     }
 532     AdvApp2Var_ApproxF2var::mma2ac3_(&NDIMEN,&NDegU,&NDegV,&IORDRU,&NCFLMV,
 533                                      NCFU0,IsoU0,NCFU1,IsoU1,HermU,PATCAN);
 534   }
 535
 536 // add constraints at the corners
 537   Standard_Integer ideb;
 538   SIZE=NDIMEN*(IORDRU+2)*(IORDRV+2);
 539   Handle (TColStd_HArray1OfReal) HCOINS  =
 540     new TColStd_HArray1OfReal(1,SIZE*4);
 541
 542   for (iu=0;iu<=myOrdInU;iu++) {
 543     for (iv=0;iv<=myOrdInV;iv++) {
 544       rho = pow(du,iu)*pow(dv,iv);
 545
 546 // -F(U0,V0) and its derivatives normalized on (-1,1)
 547       ideb = HCOINS->Lower() + NDIMEN*iu+NDIMEN*(IORDRU+2)*iv - 1;
 548       valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).X();
 549       HCOINS->SetValue( 1+ideb , valnorm );
 550       valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Y();
 551       HCOINS->SetValue( 2+ideb , valnorm );
 552       valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Z();
 553       HCOINS->SetValue( 3+ideb , valnorm );
 554
 555 // -F(U1,V0) and its derivatives normalized on (-1,1)
 556       ideb += SIZE;
 557       valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).X();
 558       HCOINS->SetValue( 1+ideb , valnorm );
 559       valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Y();
 560       HCOINS->SetValue( 2+ideb , valnorm );
 561       valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Z();
 562       HCOINS->SetValue( 3+ideb , valnorm );
 563
 564 // -F(U0,V1) and its derivatives normalized on (-1,1)
 565       ideb += SIZE;
 566       valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).X();
 567       HCOINS->SetValue( 1+ideb , valnorm );
 568       valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Y();
 569       HCOINS->SetValue( 2+ideb , valnorm );
 570       valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Z();
 571       HCOINS->SetValue( 3+ideb , valnorm );
 572
 573 // -F(U1,V1) and its derivatives normalized on (-1,1)
 574       ideb += SIZE;
 575       valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).X();
 576       HCOINS->SetValue( 1+ideb , valnorm );
 577       valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Y();
 578       HCOINS->SetValue( 2+ideb , valnorm );
 579       valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Z();
 580       HCOINS->SetValue( 3+ideb , valnorm );
 581     }
 582   }
 583
 584 //  tables required for FORTRAN
 585   Standard_Integer IORDMX = Max(IORDRU,IORDRV);
 586   Handle (TColStd_HArray1OfReal) HEXTR =
 587     new TColStd_HArray1OfReal(1,2*IORDMX+2);
 588   Standard_Real *EXTR =
 589     (Standard_Real *) &HEXTR ->ChangeArray1()(HEXTR ->Lower());
 590   Handle (TColStd_HArray1OfReal) HFACT =
 591     new TColStd_HArray1OfReal(1,IORDMX+1);
 592   Standard_Real *FACT =
 593     (Standard_Real *) &HFACT ->ChangeArray1()(HFACT ->Lower());
 594
 595   Standard_Integer idim,ncf0,ncf1,iun=1;
 596   Standard_Real *Is;
 597
 598 // add extremities of isos U
 599   for (iu=1;iu<=IORDRU+1;iu++) {
 600     ncf0 = HCFU0->Value(HCFU0->Lower()+iu-1);
 601     ncf1 = HCFU1->Value(HCFU1->Lower()+iu-1);
 602     for (idim=1;idim<=NDIMEN;idim++) {
 603       Is = IsoU0 + NCFLMV*(idim-1) + NCFLMV*NDIMEN*(iu-1);
 604       AdvApp2Var_MathBase::mmdrc11_(&IORDRV,&iun,&ncf0,Is,EXTR,FACT);
 605       for (iv=1;iv<=IORDRV+1;iv++) {
 606         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
 607         HCOINS->ChangeValue(idim+ideb) += HEXTR->Value(1+2*(iv-1));
 608         HCOINS->ChangeValue(2*SIZE+idim+ideb) += HEXTR->Value(2+2*(iv-1));
 609       }
 610       Is = IsoU1 + NCFLMV*(idim-1) + NCFLMV*NDIMEN*(iu-1);
 611       AdvApp2Var_MathBase::mmdrc11_(&IORDRV,&iun,&ncf1,Is,EXTR,FACT);
 612       for (iv=1;iv<=IORDRV+1;iv++) {
 613         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
 614         HCOINS->ChangeValue(SIZE+idim+ideb) += HEXTR->Value(1+2*(iv-1));
 615         HCOINS->ChangeValue(3*SIZE+idim+ideb) += HEXTR->Value(2+2*(iv-1));
 616       }
 617     }
 618   }
 619
 620 // add extremities of isos V
 621   for (iv=1;iv<=IORDRV+1;iv++) {
 622     ncf0 = HCFV0->Value(HCFV0->Lower()+iv-1);
 623     ncf1 = HCFV1->Value(HCFV1->Lower()+iv-1);
 624     for (idim=1;idim<=NDIMEN;idim++) {
 625       Is = IsoV0 + NCFLMU*(idim-1) + NCFLMU*NDIMEN*(iv-1);
 626       AdvApp2Var_MathBase::mmdrc11_(&IORDRU,&iun,&ncf0,Is,EXTR,FACT);
 627       for (iu=1;iu<=IORDRU+1;iu++) {
 628         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
 629         HCOINS->ChangeValue(idim+ideb) += HEXTR->Value(1+2*(iu-1));
 630         HCOINS->ChangeValue(SIZE+idim+ideb) += HEXTR->Value(2+2*(iu-1));
 631       }
 632       Is = IsoV1 + NCFLMU*(idim-1) + NCFLMU*NDIMEN*(iv-1);
 633       AdvApp2Var_MathBase::mmdrc11_(&IORDRU,&iun,&ncf1,Is,EXTR,FACT);
 634       for (iu=1;iu<=IORDRU+1;iu++) {
 635         ideb = HCOINS->Lower() + NDIMEN*(iu-1)+NDIMEN*(IORDRU+2)*(iv-1) - 1;
 636         HCOINS->ChangeValue(2*SIZE+idim+ideb) += HEXTR->Value(1+2*(iu-1));
 637         HCOINS->ChangeValue(3*SIZE+idim+ideb) += HEXTR->Value(2+2*(iu-1));
 638       }
 639     }
 640   }
 641
 642 // add all to PATCAN
 643   Standard_Real *C1 =
 644     (Standard_Real *) &HCOINS ->ChangeArray1()(HCOINS ->Lower());
 645   Standard_Real *C2 = C1 + SIZE;
 646   Standard_Real *C3 = C2 + SIZE;
 647   Standard_Real *C4 = C3 + SIZE;
 648   if ( IORDRU>=0 && IORDRV>=0 ) {
 649     AdvApp2Var_ApproxF2var::mma2ac1_(&NDIMEN,&NDegU,&NDegV,&IORDRU,&IORDRV,
 650                                      C1,C2,C3,C4,HermU,HermV,PATCAN);
 651   }
 652 }
 653
 654 //============================================================================
 655 //function : AddErrors
 656 //purpose  :
 657 //============================================================================
 658
 659 void AdvApp2Var_Patch::AddErrors(const AdvApp2Var_Framework& Constraints)
 660 {
 661   Standard_Integer NBSESP = 1, iesp;
 662   Standard_Integer iu,iv;
 663
 664   Standard_Real errU,errV,error,hmax[4];
 665   hmax[0] = 0;
 666   hmax[1] = 1;
 667   hmax[2] = 1.5;
 668   hmax[3] = 1.75;
 669
 670   for (iesp=1;iesp<=NBSESP;iesp++) {
 671     //  error max in sub-space iesp
 672     errU=0.;
 673     for (iv=1;iv<=myOrdInV+1;iv++) {
 674       error = ((Constraints.IsoV(myU0,myU1,myV0)).MaxErrors())->Value(iesp,iv);
 675       errU = Max(errU,error);
 676       error = ((Constraints.IsoV(myU0,myU1,myV1)).MaxErrors())->Value(iesp,iv);
 677       errU = Max(errU,error);
 678     }
 679     errV=0.;
 680     for (iu=1;iu<=myOrdInU+1;iu++) {
 681       error = ((Constraints.IsoU(myU0,myV0,myV1)).MaxErrors())->Value(iesp,iu);
 682       errV = Max(errV,error);
 683       error = ((Constraints.IsoU(myU1,myV0,myV1)).MaxErrors())->Value(iesp,iu);
 684       errV = Max(errV,error);
 685     }
 686     myMaxErrors->ChangeValue(iesp) +=
 687       errU * hmax[myOrdInV+1]  +  errV * hmax[myOrdInU+1];
 688
 689     // average error in sub-space iesp
 690     errU=0.;
 691     for (iv=1;iv<=myOrdInV+1;iv++) {
 692       error = ((Constraints.IsoV(myU0,myU1,myV0)).MoyErrors())->Value(iesp,iv);
 693       errU = Max(errU,error);
 694       error = ((Constraints.IsoV(myU0,myU1,myV1)).MoyErrors())->Value(iesp,iv);
 695       errU = Max(errU,error);
 696     }
 697     errV=0.;
 698     for (iu=1;iu<=myOrdInU+1;iu++) {
 699       error = ((Constraints.IsoU(myU0,myV0,myV1)).MoyErrors())->Value(iesp,iu);
 700       errV = Max(errV,error);
 701       error = ((Constraints.IsoU(myU1,myV0,myV1)).MoyErrors())->Value(iesp,iu);
 702       errV = Max(errV,error);
 703     }
 704     error = myMoyErrors->Value(iesp);
 705     error *= error;
 706     error += errU*hmax[myOrdInV+1] * errU*hmax[myOrdInV+1]
 707                    + errV*hmax[myOrdInU+1] * errV*hmax[myOrdInU+1];
 708     myMoyErrors->SetValue(iesp,Sqrt(error));
 709
 710     // max errors at iso-borders
 711     Handle (TColStd_HArray2OfReal) HERISO
 712       = new TColStd_HArray2OfReal(1,NBSESP,1,4);
 713     HERISO->SetValue(iesp,1,
 714               ((Constraints.IsoV(myU0,myU1,myV0)).MaxErrors())->Value(iesp,1));
 715     HERISO->SetValue(iesp,2,
 716               ((Constraints.IsoV(myU0,myU1,myV1)).MaxErrors())->Value(iesp,1));
 717     HERISO->SetValue(iesp,3,
 718               ((Constraints.IsoU(myU0,myV0,myV1)).MaxErrors())->Value(iesp,1));
 719     HERISO->SetValue(iesp,4,
 720               ((Constraints.IsoU(myU1,myV0,myV1)).MaxErrors())->Value(iesp,1));
 721
 722 // calculate max errors at the corners
 723     Standard_Real emax1=0.,emax2=0.,emax3=0.,emax4=0.,err1,err2,err3,err4;
 724     for (iu=0;iu<=myOrdInU;iu++) {
 725       for (iv=0;iv<=myOrdInV;iv++) {
 726     error = (Constraints.Node(myU0,myV0))->Error(iu,iv);
 727         emax1 = Max(emax1,error);
 728     error = (Constraints.Node(myU1,myV0))->Error(iu,iv);
 729         emax2 = Max(emax2,error);
 730     error = (Constraints.Node(myU0,myV1))->Error(iu,iv);
 731         emax3 = Max(emax3,error);
 732     error = (Constraints.Node(myU1,myV1))->Error(iu,iv);
 733         emax4 = Max(emax4,error);
 734       }
 735     }
 736
 737 // calculate max errors on borders
 738     err1 = Max(emax1,emax2);
 739     err2 = Max(emax3,emax4);
 740     err3 = Max(emax1,emax3);
 741     err4 = Max(emax2,emax4);
 742
 743 //   calculate final errors on internal isos
 744     if ( (Constraints.IsoV(myU0,myU1,myV0)).Position() == 0 ) {
 745       HERISO ->ChangeValue(iesp,1) += err1*hmax[myOrdInU+1];
 746     }
 747     if ( (Constraints.IsoV(myU0,myU1,myV1)).Position() == 0 ) {
 748       HERISO ->ChangeValue(iesp,2) += err2*hmax[myOrdInU+1];
 749     }
 750     if ( (Constraints.IsoU(myU0,myV0,myV1)).Position() == 0 ) {
 751       HERISO ->ChangeValue(iesp,3) += err3*hmax[myOrdInV+1];
 752     }
 753     if ( (Constraints.IsoU(myU1,myV0,myV1)).Position() == 0 ) {
 754       HERISO ->ChangeValue(iesp,4) += err4*hmax[myOrdInV+1];
 755     }
 756     myIsoErrors = HERISO;
 757   }
 758 }
 759
 760 //============================================================================
 761 //function : MakeApprox
 762 //purpose  :
 763 //============================================================================
 764
 765 void AdvApp2Var_Patch::MakeApprox(const AdvApp2Var_Context& Conditions,
 766                                   const AdvApp2Var_Framework& Constraints,
 767                                   const Standard_Integer NumDec)
 768 {
 769
 770 // data stored in the Context
 771   Standard_Integer NDIMEN, NBSESP, NDIMSE;
 772   Standard_Integer NBPNTU, NBPNTV, NCFLMU, NCFLMV, NDJACU, NDJACV;
 773   Standard_Integer NDegU, NDegV, NJacU, NJacV;
 774   NDIMEN = Conditions.TotalDimension();
 775   NBSESP = Conditions.TotalNumberSSP();
 776   NDIMSE = 3;
 777   NBPNTU = (Conditions.URoots())->Length();
 778   if (myOrdInU>-1) NBPNTU -= 2;
 779   NBPNTV = (Conditions.VRoots())->Length();
 780   if (myOrdInV>-1) NBPNTV -= 2;
 781   NCFLMU = Conditions.ULimit();
 782   NCFLMV = Conditions.VLimit();
 783   NDegU = NCFLMU - 1;
 784   NDegV = NCFLMV - 1;
 785   NDJACU = Conditions.UJacDeg();
 786   NDJACV = Conditions.VJacDeg();
 787   NJacU = NDJACU + 1;
 788   NJacV = NDJACV + 1;
 789
 790 // data relative to the processed patch
 791   Standard_Integer IORDRU = myOrdInU, IORDRV = myOrdInV,
 792                    NDMINU = 1, NDMINV = 1, NCOEFU, NCOEFV;
 793 // NDMINU and NDMINV depend on the nb of coeff of neighboring isos
 794 // and of the required order of continuity
 795   NDMINU = Max(1,2*IORDRU+1);
 796   NCOEFU = (Constraints.IsoV(myU0,myU1,myV0)).NbCoeff()-1;
 797   NDMINU = Max(NDMINU,NCOEFU);
 798   NCOEFU = (Constraints.IsoV(myU0,myU1,myV1)).NbCoeff()-1;
 799   NDMINU = Max(NDMINU,NCOEFU);
 800
 801   NDMINV = Max(1,2*IORDRV+1);
 802   NCOEFV = (Constraints.IsoU(myU0,myV0,myV1)).NbCoeff()-1;
 803   NDMINV = Max(NDMINV,NCOEFV);
 804   NCOEFV = (Constraints.IsoU(myU1,myV0,myV1)).NbCoeff()-1;
 805   NDMINV = Max(NDMINV,NCOEFV);
 806
 807 // tables of approximations
 808   Handle (TColStd_HArray1OfReal) HEPSAPR =
 809     new TColStd_HArray1OfReal(1,NBSESP);
 810   Handle (TColStd_HArray1OfReal) HEPSFRO =
 811     new TColStd_HArray1OfReal(1,NBSESP*8);
 812   Standard_Integer iesp;
 813   for (iesp=1;iesp<=NBSESP;iesp++) {
 814     HEPSAPR->SetValue(iesp,(Conditions.IToler())->Value(iesp));
 815     HEPSFRO->SetValue(iesp,(Conditions.FToler())->Value(iesp,1));
 816     HEPSFRO->SetValue(iesp+NBSESP,(Conditions.FToler())->Value(iesp,2));
 817     HEPSFRO->SetValue(iesp+2*NBSESP,(Conditions.FToler())->Value(iesp,3));
 818     HEPSFRO->SetValue(iesp+3*NBSESP,(Conditions.FToler())->Value(iesp,4));
 819     HEPSFRO->SetValue(iesp+4*NBSESP,(Conditions.CToler())->Value(iesp,1));
 820     HEPSFRO->SetValue(iesp+5*NBSESP,(Conditions.CToler())->Value(iesp,2));
 821     HEPSFRO->SetValue(iesp+6*NBSESP,(Conditions.CToler())->Value(iesp,3));
 822     HEPSFRO->SetValue(iesp+7*NBSESP,(Conditions.CToler())->Value(iesp,4));
 823   }
 824   Standard_Real *EPSAPR  =
 825     (Standard_Real *) &HEPSAPR ->ChangeArray1()(HEPSAPR ->Lower());
 826   Standard_Real *EPSFRO  =
 827     (Standard_Real *) &HEPSFRO ->ChangeArray1()(HEPSFRO ->Lower());
 828
 829   Standard_Integer SIZE=(1+NDJACU)*(1+NDJACV)*NDIMEN;
 830   Handle (TColStd_HArray1OfReal) HPJAC  =
 831     new TColStd_HArray1OfReal(1,SIZE);
 832   Standard_Real *PATJAC  =
 833     (Standard_Real *) &HPJAC ->ChangeArray1()(HPJAC ->Lower());
 834   SIZE=2*SIZE;
 835   Handle (TColStd_HArray1OfReal) HPAUX  =
 836     new TColStd_HArray1OfReal(1,SIZE);
 837   Standard_Real *PATAUX  =
 838     (Standard_Real *) &HPAUX ->ChangeArray1()(HPAUX ->Lower());
 839   SIZE=NCFLMU*NCFLMV*NDIMEN;
 840   Handle (TColStd_HArray1OfReal) HPCAN  =
 841     new TColStd_HArray1OfReal(1,SIZE);
 842   Standard_Real *PATCAN  =
 843     (Standard_Real *) &HPCAN ->ChangeArray1()(HPCAN ->Lower());
 844   Handle (TColStd_HArray1OfReal) HERRMAX  =
 845     new TColStd_HArray1OfReal(1,NBSESP);
 846   Standard_Real *ERRMAX =
 847     (Standard_Real *) &HERRMAX ->ChangeArray1()(HERRMAX ->Lower());
 848   Handle (TColStd_HArray1OfReal) HERRMOY  =
 849     new TColStd_HArray1OfReal(1,NBSESP);
 850   Standard_Real *ERRMOY =
 851     (Standard_Real *) &HERRMOY ->ChangeArray1()(HERRMOY ->Lower());
 852
 853 // tables of discretization of the square
 854   Standard_Real *SOSOTB  =
 855     (Standard_Real *) &mySosoTab ->ChangeArray1()(mySosoTab ->Lower());
 856   Standard_Real *DISOTB  =
 857     (Standard_Real *) &myDisoTab ->ChangeArray1()(myDisoTab ->Lower());
 858   Standard_Real *SODITB  =
 859     (Standard_Real *) &mySodiTab ->ChangeArray1()(mySodiTab ->Lower());
 860   Standard_Real *DIDITB  =
 861     (Standard_Real *) &myDidiTab ->ChangeArray1()(myDidiTab ->Lower());
 862
 863 //  approximation
 864   Standard_Integer ITYDEC=0, IERCOD=0;
 865   Standard_Integer iun=1,itrois=3;
 866   NCOEFU=0;
 867   NCOEFV=0;
 868   AdvApp2Var_ApproxF2var::mma2ce1_((integer *)&NumDec,
 869                                    &NDIMEN,
 870                                    &NBSESP,
 871                                    &NDIMSE,
 872                                    &NDMINU,
 873                                    &NDMINV,
 874                                    &NDegU,
 875                                    &NDegV,
 876                                    &NDJACU,
 877                                    &NDJACV,
 878                                    &IORDRU,
 879                                    &IORDRV,
 880                                    &NBPNTU,
 881                                    &NBPNTV,
 882                                    EPSAPR,
 883                                    SOSOTB,
 884                                    DISOTB,
 885                                    SODITB,
 886                                    DIDITB,
 887                                    PATJAC,
 888                                    ERRMAX,
 889                                    ERRMOY,
 890                                    &NCOEFU,
 891                                    &NCOEFV,
 892                                    &ITYDEC,
 893                                    &IERCOD);
 894
 895 // results
 896   myCutSense = ITYDEC;
 897   if (ITYDEC == 0 && IERCOD<=0) {
 898     myHasResult  = Standard_True;
 899     myApprIsDone = (IERCOD==0);
 900     myNbCoeffInU  = NCOEFU+1;
 901     myNbCoeffInV  = NCOEFV+1;
 902     myMaxErrors = HERRMAX;
 903     myMoyErrors = HERRMOY;
 904
 905 // Passage to canonic on [-1,1]
 906     AdvApp2Var_MathBase::mmfmca9_(&NJacU,&NJacV,&NDIMEN,&myNbCoeffInU,&myNbCoeffInV,
 907                                   &NDIMEN,PATJAC,PATJAC);
 908     AdvApp2Var_ApproxF2var::mma2can_(&NCFLMU,&NCFLMV,&NDIMEN,
 909                                      &myOrdInU,&myOrdInV,&myNbCoeffInU,
 910                                      &myNbCoeffInV,
 911                                      PATJAC,PATAUX,PATCAN,&IERCOD);
 912     if (IERCOD !=0) {
 913       throw Standard_ConstructionError("AdvApp2Var_Patch::MakeApprox : Error in FORTRAN");
 914     }
 915     myEquation = HPCAN;
 916
 917 // Add constraints and errors
 918     AddConstraints(Conditions,Constraints);
 919     AddErrors(Constraints);
 920
 921 // Reduction of degrees if possible
 922     PATCAN = (Standard_Real *)
 923       &myEquation->ChangeArray1()(myEquation ->Lower());
 924
 925     AdvApp2Var_ApproxF2var::mma2fx6_(&NCFLMU,
 926                                      &NCFLMV,
 927                                      &NDIMEN,
 928                                      &NBSESP,
 929                                      &itrois,
 930                                      &iun,
 931                                      &iun,
 932                                      &IORDRU,
 933                                      &IORDRV,
 934                                      EPSAPR,
 935                                      EPSFRO,
 936                                      PATCAN,
 937                                      ERRMAX,
 938                                      &myNbCoeffInU,
 939                                      &myNbCoeffInV);
 940
 941 // transposition (NCFLMU,NCFLMV,NDIMEN)Fortran-C++
 942     Standard_Integer aIU, aIN, dim, ii, jj;
 943     for (dim=1; dim<=NDIMEN; dim++){
 944        aIN = (dim-1)*NCFLMU*NCFLMV;
 945        for (ii=1; ii<=NCFLMU; ii++) {
 946          aIU = (ii-1)*NDIMEN*NCFLMV;
 947          for (jj=1; jj<=NCFLMV; jj++) {
 948            HPAUX->SetValue(dim+NDIMEN*(jj-1)+aIU ,
 949                            myEquation->Value(ii+NCFLMU*(jj-1)+aIN) );
 950          }
 951        }
 952      }
 953     myEquation = HPAUX;
 954   }
 955   else {
 956     myApprIsDone = Standard_False;
 957     myHasResult  = Standard_False;
 958   }
 959 }
 960
 961 //============================================================================
 962 //function : ChangeDomain
 963 //purpose  :
 964 //============================================================================
 965
 966 void AdvApp2Var_Patch::ChangeDomain(const Standard_Real a,
 967                                     const Standard_Real b,
 968                                     const Standard_Real c,
 969                                     const Standard_Real d)
 970 {
 971   myU0 = a;
 972   myU1 = b;
 973   myV0 = c;
 974   myV1 = d;
 975 }
 976
 977 //============================================================================
 978 //function : ResetApprox
 979 //purpose  : allows removing a result when it is necessary to cut
 980 //============================================================================
 981
 982 void AdvApp2Var_Patch::ResetApprox()
 983 {
 984   myApprIsDone = Standard_False;
 985   myHasResult = Standard_False;
 986 }
 987
 988 //============================================================================
 989 //function : OverwriteApprox
 990 //purpose  : allows preserving a result even if the precision is not satisfactory
 991 //============================================================================
 992
 993 void AdvApp2Var_Patch::OverwriteApprox()
 994 {
 995   if (myHasResult) myApprIsDone = Standard_True;
 996 }
 997
 998 //============================================================================
 999 //function : U0
1000 //purpose  :
1001 //============================================================================
1002
1003 Standard_Real AdvApp2Var_Patch::U0() const
1004 {
1005   return myU0;
1006 }
1007
1008 //============================================================================
1009 //function : U1
1010 //purpose  :
1011 //============================================================================
1012
1013 Standard_Real AdvApp2Var_Patch::U1() const
1014 {
1015   return myU1;
1016 }
1017
1018 //============================================================================
1019 //function : V0
1020 //purpose  :
1021 //============================================================================
1022
1023 Standard_Real AdvApp2Var_Patch::V0() const
1024 {
1025   return myV0;
1026 }
1027
1028 //============================================================================
1029 //function : V1
1030 //purpose  :
1031 //============================================================================
1032
1033 Standard_Real AdvApp2Var_Patch::V1() const
1034 {
1035   return myV1;
1036 }
1037
1038 //============================================================================
1039 //function : UOrder
1040 //purpose  :
1041 //============================================================================
1042
1043 Standard_Integer AdvApp2Var_Patch::UOrder() const
1044 {
1045   return myOrdInU;
1046 }
1047
1048
1049 //============================================================================
1050 //function : VOrder
1051 //purpose  :
1052 //============================================================================
1053
1054 Standard_Integer AdvApp2Var_Patch::VOrder() const
1055 {
1056   return myOrdInV;
1057 }
1058
1059
1060 //============================================================================
1061 //function : CutSense without Critere
1062 //purpose  : 0 : OK; 1 : required cut by U;
1063 //           2 : required cut by V; 3 : required cut by U and by V
1064 //============================================================================
1065
1066 Standard_Integer AdvApp2Var_Patch::CutSense() const
1067 {
1068   return myCutSense;
1069 }
1070
1071
1072 //============================================================================
1073 //function : CutSense with critere
1074 //purpose  : 0 : OK; 1 : required cut by U;
1075 //           2 : required cut by V; 3 : required cut by U and by V
1076 //============================================================================
1077
1078 Standard_Integer AdvApp2Var_Patch::CutSense(const AdvApp2Var_Criterion& Crit,
1079                                             const Standard_Integer NumDec) const
1080 {
1081   Standard_Boolean CritRel = (Crit.Type() == AdvApp2Var_Relative);
1082   if ( CritRel && !IsApproximated()) {
1083     return myCutSense;
1084   }
1085   else {
1086     if (Crit.IsSatisfied(*this)) {
1087       return 0;
1088     }
1089     else {
1090       return NumDec;
1091     }
1092   }
1093 }
1094
1095
1096 //============================================================================
1097 //function : NbCoeffInU
1098 //purpose  :
1099 //============================================================================
1100
1101 Standard_Integer AdvApp2Var_Patch::NbCoeffInU() const
1102 {
1103   return myNbCoeffInU;
1104 }
1105
1106 //============================================================================
1107 //function : NbCoeffInV
1108 //purpose  :
1109 //============================================================================
1110
1111 Standard_Integer AdvApp2Var_Patch::NbCoeffInV() const
1112 {
1113   return myNbCoeffInV;
1114 }
1115
1116 //============================================================================
1117 //function : ChangeNbCoeff
1118 //purpose  : allows increasing the nb of coeff (cf Network)
1119 //============================================================================
1120
1121 void AdvApp2Var_Patch::ChangeNbCoeff(const Standard_Integer NbCoeffU,
1122                                      const Standard_Integer NbCoeffV)
1123 {
1124   if (myNbCoeffInU<NbCoeffU) myNbCoeffInU = NbCoeffU;
1125   if (myNbCoeffInV<NbCoeffV) myNbCoeffInV = NbCoeffV;
1126 }
1127
1128 //============================================================================
1129 //function : MaxErrors
1130 //purpose  : returns max errors of polynomial approximation
1131 //============================================================================
1132
1133 Handle(TColStd_HArray1OfReal)
1134 AdvApp2Var_Patch::MaxErrors() const
1135 {
1136   return myMaxErrors;
1137 }
1138
1139 //============================================================================
1140 //function : AverageErrors
1141 //purpose  : returns average errors of polynomial approximation
1142 //============================================================================
1143
1144 Handle(TColStd_HArray1OfReal)
1145 AdvApp2Var_Patch::AverageErrors() const
1146 {
1147   return myMoyErrors;
1148 }
1149
1150 //============================================================================
1151 //function : IsoErrors
1152 //purpose  : returns max errors on borders of polynomial approximation
1153 //============================================================================
1154
1155 Handle(TColStd_HArray2OfReal)
1156 AdvApp2Var_Patch::IsoErrors() const
1157 {
1158   return myIsoErrors;
1159 }
1160
1161 //============================================================================
1162 //function : Poles
1163 //purpose  : returns poles of the polynomial approximation
1164 //============================================================================
1165
1166 Handle(TColgp_HArray2OfPnt)
1167 AdvApp2Var_Patch::Poles(const Standard_Integer SSPIndex,
1168                         const  AdvApp2Var_Context & Cond) const
1169 {
1170   Handle(TColStd_HArray1OfReal) SousEquation;
1171   if ( Cond.TotalNumberSSP( ) == 1 && SSPIndex == 1 ) {
1172     SousEquation = myEquation;
1173   }
1174   else {
1175     throw Standard_ConstructionError("AdvApp2Var_Patch::Poles :  SSPIndex out of range");
1176   }
1177   Handle(TColStd_HArray1OfReal) Intervalle =
1178     new (TColStd_HArray1OfReal) (1,2);
1179   Intervalle->SetValue(1, -1);
1180   Intervalle->SetValue(2, 1);
1181
1182
1183   Handle(TColStd_HArray1OfInteger) NbCoeff =
1184     new (TColStd_HArray1OfInteger) (1,2);
1185   NbCoeff->SetValue(1, myNbCoeffInU);
1186   NbCoeff->SetValue(2, myNbCoeffInV);
1187
1188 // Conversion
1189   Convert_GridPolynomialToPoles
1190      Conv (Cond.ULimit()-1,
1191            Cond.VLimit()-1,
1192            NbCoeff,
1193            SousEquation,
1194            Intervalle,
1195            Intervalle);
1196
1197   return Conv.Poles();
1198 }
1199
1200
1201 //============================================================================
1202 //function : Coefficients
1203 //purpose  : returns coeff. of the equation of polynomial approximation
1204 //============================================================================
1205
1206 Handle(TColStd_HArray1OfReal)
1207 AdvApp2Var_Patch::Coefficients(const Standard_Integer SSPIndex,
1208                                const  AdvApp2Var_Context & Cond) const
1209 {
1210   Handle(TColStd_HArray1OfReal) SousEquation;
1211   if ( Cond.TotalNumberSSP( ) == 1 && SSPIndex == 1 ) {
1212     SousEquation = myEquation;
1213   }
1214   else {
1215     throw Standard_ConstructionError("AdvApp2Var_Patch::Poles :  SSPIndex out of range");
1216   }
1217   return SousEquation;
1218 }
1219
1220
1221 //============================================================================
1222 //function : CritValue
1223 //purpose  :
1224 //============================================================================
1225
1226 Standard_Real AdvApp2Var_Patch::CritValue() const
1227 {
1228   return myCritValue;
1229 }
1230
1231
1232 //============================================================================
1233 //function : SetCritValue
1234 //purpose  :
1235 //============================================================================
1236
1237 void AdvApp2Var_Patch::SetCritValue(const Standard_Real dist)
1238 {
1239   myCritValue = dist;
1240 }
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251