src/NLPlate/NLPlate_NLPlate.cxx

   1 // Created on: 1998-04-09
   2 // Created by: Andre LIEUTIER
   3 // Copyright (c) 1998-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 #include <math_Matrix.hxx>
  18 #include <math_Vector.hxx>
  19 #include <math_Gauss.hxx>
  20 #include <gp_Vec.hxx>
  21 #include <gp_Pnt.hxx>
  22
  23 #include <Plate_D1.hxx>
  24 #include <Plate_D2.hxx>
  25 #include <Plate_D3.hxx>
  26 #include <Plate_Plate.hxx>
  27 #include <Plate_PinpointConstraint.hxx>
  28 #include <Plate_FreeGtoCConstraint.hxx>
  29
  30 #include <NLPlate_ListIteratorOfStackOfPlate.hxx>
  31
  32 #include <NLPlate_NLPlate.ixx>
  33
  34
  35 NLPlate_NLPlate::NLPlate_NLPlate(const Handle(Geom_Surface)& InitialSurface) :
  36  myInitialSurface(InitialSurface),OK(Standard_False) {}
  37 //=======================================================================
  38
  39  void NLPlate_NLPlate::Load(const Handle(NLPlate_HGPPConstraint)& GConst)
  40 {
  41   if(!GConst.IsNull()) myHGPPConstraints.Append(GConst);
  42   OK = Standard_False;
  43 }
  44
  45 //=======================================================================
  46 //function : Solve
  47 //purpose  :
  48 //=======================================================================
  49  void NLPlate_NLPlate::Solve(const Standard_Integer ord, const Standard_Integer InitialConsraintOrder)
  50 {
  51   Standard_Integer maxOrder = MaxActiveConstraintOrder();
  52   Standard_Integer ordre = ord;
  53   if(ordre<maxOrder+2) ordre = maxOrder+2;
  54
  55   for(Standard_Integer iterOrder=InitialConsraintOrder;iterOrder<=maxOrder;iterOrder++)
  56     {
  57      if(!Iterate(iterOrder,ordre+iterOrder-maxOrder))
  58        {
  59         OK = Standard_False;
  60         break;
  61        }
  62     }
  63   OK = Standard_True;
  64 }
  65 //=======================================================================
  66 //function : Solve2
  67 //purpose  :
  68 //=======================================================================
  69  void NLPlate_NLPlate::Solve2(const Standard_Integer ord, const Standard_Integer InitialConsraintOrder)
  70 {
  71   Standard_Integer maxOrder = MaxActiveConstraintOrder();
  72   Standard_Integer ordre = ord;
  73   if(ordre<maxOrder+2) ordre = maxOrder+2;
  74   if(Iterate(0,ord))
  75     {
  76       mySOP.First().SetPolynomialPartOnly(Standard_True);
  77       ConstraintsSliding();
  78     }
  79
  80
  81   for(Standard_Integer iterOrder=InitialConsraintOrder;iterOrder<=maxOrder;iterOrder++)
  82     {
  83      if(!Iterate(iterOrder,ordre+iterOrder-maxOrder))
  84        {
  85         OK = Standard_False;
  86         break;
  87        }
  88     }
  89   OK = Standard_True;
  90 }
  91
  92 //=======================================================================
  93 //function : IncrementalSolve
  94 //purpose  :
  95 //=======================================================================
  96  void NLPlate_NLPlate::IncrementalSolve(const Standard_Integer ord, const Standard_Integer /*InitialConsraintOrder*/,
  97                              const Standard_Integer NbIncrements, const Standard_Boolean UVSliding)
  98 {
  99   Standard_Integer maxOrder = MaxActiveConstraintOrder();
 100   Standard_Integer ordre = ord;
 101   if(ordre<maxOrder+2) ordre = maxOrder+2;
 102   Standard_Real IncrementalLoad = 1.;
 103
 104   for(Standard_Integer increment=0;increment < NbIncrements;increment++)
 105     {
 106       IncrementalLoad = 1./Standard_Real(NbIncrements-increment);
 107 //      for(Standard_Integer iterOrder=InitialConsraintOrder;iterOrder<=maxOrder;iterOrder++)
 108       Standard_Integer iterOrder=maxOrder;
 109         {
 110           if(!Iterate(iterOrder,ordre+iterOrder-maxOrder,IncrementalLoad))
 111             {
 112               OK = Standard_False;
 113               return;
 114             }
 115         }
 116       if(UVSliding) ConstraintsSliding();
 117     }
 118   OK = Standard_True;
 119 }
 120
 121 //=======================================================================
 122  Standard_Boolean NLPlate_NLPlate::IsDone() const
 123 {
 124   return OK;
 125 }
 126 //=======================================================================
 127
 128  void NLPlate_NLPlate::destroy()
 129 {
 130   Init();
 131 }
 132 //=======================================================================
 133
 134  void NLPlate_NLPlate::Init()
 135 {
 136   mySOP.Clear();
 137   myHGPPConstraints.Clear();
 138 }
 139 //=======================================================================
 140
 141  gp_XYZ NLPlate_NLPlate::Evaluate(const gp_XY& point2d) const
 142 {
 143   return EvaluateDerivative(point2d,0,0);
 144 }
 145 //=======================================================================
 146
 147  gp_XYZ NLPlate_NLPlate::EvaluateDerivative(const gp_XY& point2d,const Standard_Integer iu,const Standard_Integer iv) const
 148 {
 149   gp_XYZ Value(0.,0.,0.);
 150   if((iu==0)&&(iv==0))
 151     Value = myInitialSurface->Value(point2d.X(),point2d.Y()).XYZ();
 152   else
 153     Value = myInitialSurface->DN(point2d.X(),point2d.Y(),iu,iv).XYZ();
 154
 155   for(NLPlate_ListIteratorOfStackOfPlate SI(mySOP);SI.More();SI.Next())
 156     {
 157       if(SI.Value().IsDone())
 158         Value += SI.Value().EvaluateDerivative(point2d,iu,iv);
 159     }
 160   return Value;
 161 }
 162 //=======================================================================
 163
 164  Standard_Integer NLPlate_NLPlate::Continuity() const
 165 {
 166   Standard_Integer cont ;
 167   for( cont=-1; cont<10;cont++)
 168     {
 169       if(!(myInitialSurface->IsCNu(cont+1)&&myInitialSurface->IsCNv(cont+1)))break;
 170     }
 171   for(NLPlate_ListIteratorOfStackOfPlate SI(mySOP);SI.More();SI.Next())
 172     {
 173       if((SI.Value().IsDone())&&(cont > SI.Value().Continuity())) cont = SI.Value().Continuity();
 174     }
 175   return cont;
 176 }
 177 //=======================================================================
 178
 179 Standard_Boolean NLPlate_NLPlate::Iterate(const Standard_Integer ConstraintOrder,
 180 const Standard_Integer ResolutionOrder,
 181 const Standard_Real IncrementalLoading)
 182 {
 183   Plate_Plate EmptyPlate;
 184   mySOP.Prepend(EmptyPlate);
 185   Plate_Plate &TopP = mySOP.First();
 186   for(Standard_Integer index =1; index <= myHGPPConstraints.Length(); index++)
 187     {
 188       const Handle(NLPlate_HGPPConstraint) &HGPP = myHGPPConstraints(index);
 189       Standard_Integer Order = HGPP->ActiveOrder();
 190       if(ConstraintOrder<Order) Order = ConstraintOrder;
 191       const gp_XY &UV = HGPP->UV();
 192
 193       if((Order >=0)&& HGPP->IsG0())
 194         {
 195           if(HGPP->IncrementalLoadAllowed())
 196             TopP.Load(Plate_PinpointConstraint(UV, (HGPP->G0Target()-Evaluate(UV))*IncrementalLoading));
 197           else
 198             TopP.Load(Plate_PinpointConstraint(UV, HGPP->G0Target()-Evaluate(UV)));
 199         }
 200
 201       if((IncrementalLoading != 1.) && HGPP->IncrementalLoadAllowed() && (Order>=1))
 202         {
 203           switch(Order)
 204             {
 205             case 1:
 206               {
 207                 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
 208                 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target(),IncrementalLoading,HGPP->Orientation()));
 209               }
 210               break;
 211             case 2:
 212               {
 213                 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
 214                 Plate_D2 D2S(EvaluateDerivative(UV,2,0),EvaluateDerivative(UV,1,1),EvaluateDerivative(UV,0,2));
 215                 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target(),D2S,HGPP->G2Target(),
 216                                                    IncrementalLoading,HGPP->Orientation()));
 217               }
 218               break;
 219             case 3:
 220               {
 221                 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
 222                 Plate_D2 D2S(EvaluateDerivative(UV,2,0),EvaluateDerivative(UV,1,1),EvaluateDerivative(UV,0,2));
 223                 Plate_D3 D3S(EvaluateDerivative(UV,3,0),EvaluateDerivative(UV,2,1),
 224                              EvaluateDerivative(UV,1,2),EvaluateDerivative(UV,0,3));
 225                 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target(),D2S,HGPP->G2Target(),D3S,HGPP->G3Target(),
 226                                                    IncrementalLoading,HGPP->Orientation()));
 227               }
 228               break;
 229             default:
 230               break;
 231             }
 232         }
 233       else
 234         {
 235           switch(Order)
 236             {
 237             case 1:
 238               {
 239                 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
 240                 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target()));
 241               }
 242               break;
 243             case 2:
 244               {
 245                 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
 246                 Plate_D2 D2S(EvaluateDerivative(UV,2,0),EvaluateDerivative(UV,1,1),EvaluateDerivative(UV,0,2));
 247                 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target(),D2S,HGPP->G2Target()));
 248               }
 249               break;
 250             case 3:
 251               {
 252                 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
 253                 Plate_D2 D2S(EvaluateDerivative(UV,2,0),EvaluateDerivative(UV,1,1),EvaluateDerivative(UV,0,2));
 254                 Plate_D3 D3S(EvaluateDerivative(UV,3,0),EvaluateDerivative(UV,2,1),
 255                              EvaluateDerivative(UV,1,2),EvaluateDerivative(UV,0,3));
 256                 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target(),D2S,HGPP->G2Target(),D3S,HGPP->G3Target()));
 257               }
 258               break;
 259             default:
 260               break;
 261             }
 262         }
 263     }
 264
 265   TopP.SolveTI(ResolutionOrder);
 266   if(!TopP.IsDone())
 267     {
 268       mySOP.RemoveFirst();
 269       return Standard_False;
 270     }
 271   else
 272     return Standard_True;
 273 }
 274 //=======================================================================
 275
 276  void NLPlate_NLPlate::ConstraintsSliding(const Standard_Integer NbIterations)
 277 {
 278   for(Standard_Integer index =1; index <= myHGPPConstraints.Length(); index++)
 279     {
 280       const Handle(NLPlate_HGPPConstraint) &HGPP = myHGPPConstraints(index);
 281       if(HGPP->UVFreeSliding() && HGPP->IsG0())
 282         {
 283           gp_XY UV = HGPP->UV();
 284           gp_XYZ P0 = Evaluate(UV);
 285           const gp_XYZ P1 = HGPP->G0Target();
 286           for(Standard_Integer iter=1;iter<=NbIterations;iter++)
 287             {
 288               // on itere au premier ordre, ce qui suffit si on est assez pres de la surface ??
 289               gp_XYZ DP = P1 - P0;
 290               gp_XYZ Du = EvaluateDerivative(UV,1,0);
 291               gp_XYZ Dv = EvaluateDerivative(UV,0,1);
 292               math_Matrix mat(0,1,0,1);
 293               mat(0,0) = Du*Du;
 294               mat(0,1) = Du*Dv;
 295               mat(1,0) = Du*Dv;
 296               mat(1,1) = Dv*Dv;
 297               math_Gauss gauss(mat);
 298               if(!gauss.IsDone()) break;
 299
 300               math_Vector vec(0,1);
 301               vec(0) = Du*DP;
 302               vec(1) = Dv*DP;
 303               math_Vector sol(0,1);
 304               gauss.Solve(vec,sol);
 305               UV.SetX(UV.X()+sol(0));
 306               UV.SetY(UV.Y()+sol(1));
 307               P0 = Evaluate(UV);
 308             }
 309           HGPP->SetUV(UV);
 310         }
 311     }
 312 }
 313
 314 //=======================================================================
 315
 316  Standard_Integer NLPlate_NLPlate::MaxActiveConstraintOrder() const
 317 {
 318   Standard_Integer MaxOrder = -1;
 319   for(Standard_Integer index =1; index <= myHGPPConstraints.Length(); index++)
 320     {
 321       Standard_Integer CAOrder = myHGPPConstraints(index)->ActiveOrder();
 322       if(CAOrder > MaxOrder) MaxOrder = CAOrder;
 323     }
 324   return MaxOrder;
 325 }