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
6 // This file is part of Open CASCADE Technology software library.
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.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
18 #include <Geom_Surface.hxx>
23 #include <math_Gauss.hxx>
24 #include <math_Matrix.hxx>
25 #include <math_Vector.hxx>
26 #include <NLPlate_HGPPConstraint.hxx>
27 #include <NLPlate_ListIteratorOfStackOfPlate.hxx>
28 #include <NLPlate_NLPlate.hxx>
29 #include <Plate_D1.hxx>
30 #include <Plate_D2.hxx>
31 #include <Plate_D3.hxx>
32 #include <Plate_FreeGtoCConstraint.hxx>
33 #include <Plate_PinpointConstraint.hxx>
34 #include <Plate_Plate.hxx>
36 NLPlate_NLPlate::NLPlate_NLPlate(const Handle(Geom_Surface)& InitialSurface) :
37 myInitialSurface(InitialSurface),OK(Standard_False) {}
38 //=======================================================================
40 void NLPlate_NLPlate::Load(const Handle(NLPlate_HGPPConstraint)& GConst)
42 if(!GConst.IsNull()) myHGPPConstraints.Append(GConst);
46 //=======================================================================
49 //=======================================================================
50 void NLPlate_NLPlate::Solve(const Standard_Integer ord, const Standard_Integer InitialConsraintOrder)
52 Standard_Integer maxOrder = MaxActiveConstraintOrder();
53 Standard_Integer ordre = ord;
54 if(ordre<maxOrder+2) ordre = maxOrder+2;
56 for(Standard_Integer iterOrder=InitialConsraintOrder;iterOrder<=maxOrder;iterOrder++)
58 if(!Iterate(iterOrder,ordre+iterOrder-maxOrder))
66 //=======================================================================
69 //=======================================================================
70 void NLPlate_NLPlate::Solve2(const Standard_Integer ord, const Standard_Integer InitialConsraintOrder)
72 Standard_Integer maxOrder = MaxActiveConstraintOrder();
73 Standard_Integer ordre = ord;
74 if(ordre<maxOrder+2) ordre = maxOrder+2;
77 mySOP.First().SetPolynomialPartOnly(Standard_True);
82 for(Standard_Integer iterOrder=InitialConsraintOrder;iterOrder<=maxOrder;iterOrder++)
84 if(!Iterate(iterOrder,ordre+iterOrder-maxOrder))
93 //=======================================================================
94 //function : IncrementalSolve
96 //=======================================================================
97 void NLPlate_NLPlate::IncrementalSolve(const Standard_Integer ord, const Standard_Integer /*InitialConsraintOrder*/,
98 const Standard_Integer NbIncrements, const Standard_Boolean UVSliding)
100 Standard_Integer maxOrder = MaxActiveConstraintOrder();
101 Standard_Integer ordre = ord;
102 if(ordre<maxOrder+2) ordre = maxOrder+2;
103 Standard_Real IncrementalLoad = 1.;
105 for(Standard_Integer increment=0;increment < NbIncrements;increment++)
107 IncrementalLoad = 1./Standard_Real(NbIncrements-increment);
108 // for(Standard_Integer iterOrder=InitialConsraintOrder;iterOrder<=maxOrder;iterOrder++)
109 Standard_Integer iterOrder=maxOrder;
111 if(!Iterate(iterOrder,ordre+iterOrder-maxOrder,IncrementalLoad))
117 if(UVSliding) ConstraintsSliding();
122 //=======================================================================
123 Standard_Boolean NLPlate_NLPlate::IsDone() const
127 //=======================================================================
129 void NLPlate_NLPlate::destroy()
133 //=======================================================================
135 void NLPlate_NLPlate::Init()
138 myHGPPConstraints.Clear();
140 //=======================================================================
142 gp_XYZ NLPlate_NLPlate::Evaluate(const gp_XY& point2d) const
144 return EvaluateDerivative(point2d,0,0);
146 //=======================================================================
148 gp_XYZ NLPlate_NLPlate::EvaluateDerivative(const gp_XY& point2d,const Standard_Integer iu,const Standard_Integer iv) const
150 gp_XYZ Value(0.,0.,0.);
152 Value = myInitialSurface->Value(point2d.X(),point2d.Y()).XYZ();
154 Value = myInitialSurface->DN(point2d.X(),point2d.Y(),iu,iv).XYZ();
156 for(NLPlate_ListIteratorOfStackOfPlate SI(mySOP);SI.More();SI.Next())
158 if(SI.Value().IsDone())
159 Value += SI.Value().EvaluateDerivative(point2d,iu,iv);
163 //=======================================================================
165 Standard_Integer NLPlate_NLPlate::Continuity() const
167 Standard_Integer cont ;
168 for( cont=-1; cont<10;cont++)
170 if(!(myInitialSurface->IsCNu(cont+1)&&myInitialSurface->IsCNv(cont+1)))break;
172 for(NLPlate_ListIteratorOfStackOfPlate SI(mySOP);SI.More();SI.Next())
174 if((SI.Value().IsDone())&&(cont > SI.Value().Continuity())) cont = SI.Value().Continuity();
178 //=======================================================================
180 Standard_Boolean NLPlate_NLPlate::Iterate(const Standard_Integer ConstraintOrder,
181 const Standard_Integer ResolutionOrder,
182 const Standard_Real IncrementalLoading)
184 Plate_Plate EmptyPlate;
185 mySOP.Prepend(EmptyPlate);
186 Plate_Plate &TopP = mySOP.First();
187 for(Standard_Integer index =1; index <= myHGPPConstraints.Length(); index++)
189 const Handle(NLPlate_HGPPConstraint) &HGPP = myHGPPConstraints(index);
190 Standard_Integer Order = HGPP->ActiveOrder();
191 if(ConstraintOrder<Order) Order = ConstraintOrder;
192 const gp_XY &UV = HGPP->UV();
194 if((Order >=0)&& HGPP->IsG0())
196 if(HGPP->IncrementalLoadAllowed())
197 TopP.Load(Plate_PinpointConstraint(UV, (HGPP->G0Target()-Evaluate(UV))*IncrementalLoading));
199 TopP.Load(Plate_PinpointConstraint(UV, HGPP->G0Target()-Evaluate(UV)));
202 if((IncrementalLoading != 1.) && HGPP->IncrementalLoadAllowed() && (Order>=1))
208 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
209 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target(),IncrementalLoading,HGPP->Orientation()));
214 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
215 Plate_D2 D2S(EvaluateDerivative(UV,2,0),EvaluateDerivative(UV,1,1),EvaluateDerivative(UV,0,2));
216 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target(),D2S,HGPP->G2Target(),
217 IncrementalLoading,HGPP->Orientation()));
222 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
223 Plate_D2 D2S(EvaluateDerivative(UV,2,0),EvaluateDerivative(UV,1,1),EvaluateDerivative(UV,0,2));
224 Plate_D3 D3S(EvaluateDerivative(UV,3,0),EvaluateDerivative(UV,2,1),
225 EvaluateDerivative(UV,1,2),EvaluateDerivative(UV,0,3));
226 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target(),D2S,HGPP->G2Target(),D3S,HGPP->G3Target(),
227 IncrementalLoading,HGPP->Orientation()));
240 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
241 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target()));
246 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
247 Plate_D2 D2S(EvaluateDerivative(UV,2,0),EvaluateDerivative(UV,1,1),EvaluateDerivative(UV,0,2));
248 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target(),D2S,HGPP->G2Target()));
253 Plate_D1 D1S(EvaluateDerivative(UV,1,0),EvaluateDerivative(UV,0,1));
254 Plate_D2 D2S(EvaluateDerivative(UV,2,0),EvaluateDerivative(UV,1,1),EvaluateDerivative(UV,0,2));
255 Plate_D3 D3S(EvaluateDerivative(UV,3,0),EvaluateDerivative(UV,2,1),
256 EvaluateDerivative(UV,1,2),EvaluateDerivative(UV,0,3));
257 TopP.Load(Plate_FreeGtoCConstraint(UV,D1S,HGPP->G1Target(),D2S,HGPP->G2Target(),D3S,HGPP->G3Target()));
266 TopP.SolveTI(ResolutionOrder);
270 return Standard_False;
273 return Standard_True;
275 //=======================================================================
277 void NLPlate_NLPlate::ConstraintsSliding(const Standard_Integer NbIterations)
279 for(Standard_Integer index =1; index <= myHGPPConstraints.Length(); index++)
281 const Handle(NLPlate_HGPPConstraint) &HGPP = myHGPPConstraints(index);
282 if(HGPP->UVFreeSliding() && HGPP->IsG0())
284 gp_XY UV = HGPP->UV();
285 gp_XYZ P0 = Evaluate(UV);
286 const gp_XYZ P1 = HGPP->G0Target();
287 for(Standard_Integer iter=1;iter<=NbIterations;iter++)
289 // on itere au premier ordre, ce qui suffit si on est assez pres de la surface ??
291 gp_XYZ Du = EvaluateDerivative(UV,1,0);
292 gp_XYZ Dv = EvaluateDerivative(UV,0,1);
293 math_Matrix mat(0,1,0,1);
298 math_Gauss gauss(mat);
299 if(!gauss.IsDone()) break;
301 math_Vector vec(0,1);
304 math_Vector sol(0,1);
305 gauss.Solve(vec,sol);
306 UV.SetX(UV.X()+sol(0));
307 UV.SetY(UV.Y()+sol(1));
315 //=======================================================================
317 Standard_Integer NLPlate_NLPlate::MaxActiveConstraintOrder() const
319 Standard_Integer MaxOrder = -1;
320 for(Standard_Integer index =1; index <= myHGPPConstraints.Length(); index++)
322 Standard_Integer CAOrder = myHGPPConstraints(index)->ActiveOrder();
323 if(CAOrder > MaxOrder) MaxOrder = CAOrder;