Salome HOME
Correct some memory leaks
[modules/smesh.git] / src / SMESH / SMESH_Gen.cxx
1 //  SMESH SMESH : implementaion of SMESH idl descriptions
2 //
3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
5 // 
6 //  This library is free software; you can redistribute it and/or 
7 //  modify it under the terms of the GNU Lesser General Public 
8 //  License as published by the Free Software Foundation; either 
9 //  version 2.1 of the License. 
10 // 
11 //  This library is distributed in the hope that it will be useful, 
12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of 
13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
14 //  Lesser General Public License for more details. 
15 // 
16 //  You should have received a copy of the GNU Lesser General Public 
17 //  License along with this library; if not, write to the Free Software 
18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
19 // 
20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
21 //
22 //
23 //
24 //  File   : SMESH_Gen.cxx
25 //  Author : Paul RASCLE, EDF
26 //  Module : SMESH
27 //  $Header$
28
29 #include "SMESH_Gen.hxx"
30 #include "SMESH_subMesh.hxx"
31 #include "SMDS_MeshElement.hxx"
32 #include "SMDS_MeshNode.hxx"
33
34 #include <gp_Pnt.hxx>
35 #include <BRep_Tool.hxx>
36
37 #include "utilities.h"
38 #include "OpUtil.hxx"
39
40 //=============================================================================
41 /*!
42  *  default constructor:
43  */
44 //=============================================================================
45
46 SMESH_Gen::SMESH_Gen()
47 {
48         MESSAGE("SMESH_Gen::SMESH_Gen");
49         _localId = 0;
50         _hypothesisFactory.SetGen(this);
51 }
52
53 //=============================================================================
54 /*!
55  * 
56  */
57 //=============================================================================
58
59 SMESH_Gen::~SMESH_Gen()
60 {
61         MESSAGE("SMESH_Gen::~SMESH_Gen");
62 }
63
64 //=============================================================================
65 /*!
66  * 
67  */
68 //=============================================================================
69
70 SMESH_Hypothesis *SMESH_Gen::CreateHypothesis(const char *anHyp, int studyId)
71         throw(SALOME_Exception)
72 {
73
74         MESSAGE("CreateHypothesis("<<anHyp<<","<<studyId<<")");
75         // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
76
77         StudyContextStruct *myStudyContext = GetStudyContext(studyId);
78
79         // create a new hypothesis object, store its ref. in studyContext
80
81         SMESH_Hypothesis *myHypothesis = _hypothesisFactory.Create(anHyp, studyId);
82         int hypId = myHypothesis->GetID();
83         myStudyContext->mapHypothesis[hypId] = myHypothesis;
84         SCRUTE(studyId);
85         SCRUTE(hypId);
86
87         // store hypothesis in SMESHDS document
88
89         myStudyContext->myDocument->AddHypothesis(myHypothesis);
90         return myHypothesis;
91 }
92
93 //=============================================================================
94 /*!
95  * 
96  */
97 //=============================================================================
98
99 SMESH_Mesh *SMESH_Gen::Init(int studyId, const TopoDS_Shape & aShape)
100 throw(SALOME_Exception)
101 {
102         MESSAGE("SMESH_Gen::Init");
103 //   if (aShape.ShapeType() == TopAbs_COMPOUND)
104 //     {
105 //       INFOS("Mesh Compound not yet implemented!");
106 //       throw(SALOME_Exception(LOCALIZED("Mesh Compound not yet implemented!")));
107 //     }
108
109         // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
110
111         StudyContextStruct *myStudyContext = GetStudyContext(studyId);
112
113         // create a new SMESH_mesh object 
114
115         SMESH_Mesh *mesh = new SMESH_Mesh(_localId++,
116                 studyId,
117                 this,
118                 myStudyContext->myDocument);
119         myStudyContext->mapMesh[_localId] = mesh;
120
121         // associate a TopoDS_Shape to the mesh
122
123         mesh->ShapeToMesh(aShape);
124         return mesh;
125 }
126
127 //=============================================================================
128 /*!
129  * 
130  */
131 //=============================================================================
132
133 bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
134 throw(SALOME_Exception)
135 {
136         MESSAGE("SMESH_Gen::Compute");
137 //   bool isDone = false;
138 /* 
139 Algo : s'appuie ou non sur une geometrie
140 Si geometrie:
141 Vertex : rien à faire (range le point)
142 Edge, Wire, collection d'edge et wire : 1D
143 Face, Shell, collection de Face et Shells : 2D
144 Solid, Collection de Solid : 3D
145 */
146 // *** corriger commentaires
147         // check hypothesis associated to the mesh :
148         // - only one algo : type compatible with the type of the shape
149         // - hypothesis = compatible with algo
150         //    - check if hypothesis are applicable to this algo
151         //    - check contradictions within hypothesis
152         //    (test if enough hypothesis is done further)
153
154         bool ret = true;
155
156         SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);
157 //   SCRUTE(sm);
158         SMESH_subMesh *smToCompute = sm->GetFirstToCompute();
159         while (smToCompute)
160         {
161                 TopoDS_Shape subShape = smToCompute->GetSubShape();
162                 int dim = GetShapeDim(subShape);
163                 //SCRUTE(dim);
164                 if (dim > 0)
165                 {
166                         bool ret1 = smToCompute->ComputeStateEngine(SMESH_subMesh::COMPUTE);
167                         ret = ret && ret1;
168                 }
169                 else
170                 {
171                         ASSERT(dim == 0);
172                         ASSERT(smToCompute->_vertexSet == false);
173                         TopoDS_Vertex V1 = TopoDS::Vertex(subShape);
174                         gp_Pnt P1 = BRep_Tool::Pnt(V1);
175                         SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
176                         //MESSAGE("point "<<nodeId<<" "<<P1.X()<<" "<<P1.Y()<<" "<<P1.Z());
177                         SMDS_MeshNode * node = meshDS->AddNode(P1.X(), P1.Y(), P1.Z());
178                         meshDS->SetNodeOnVertex(node, V1);
179                         smToCompute->GetSubMeshDS();
180                         smToCompute->_vertexSet = true;
181                         smToCompute->ComputeStateEngine(SMESH_subMesh::COMPUTE);
182                 }
183                 smToCompute = sm->GetFirstToCompute();
184         }
185
186         return ret;
187 }
188
189 //=============================================================================
190 /*!
191  * 
192  */
193 //=============================================================================
194
195 SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
196 {
197         //MESSAGE("SMESH_Gen::GetAlgo");
198
199         const SMESHDS_Hypothesis *theHyp = NULL;
200         SMESH_Algo *algo = NULL;
201         const SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
202         int hypType;
203         int hypId;
204         int algoDim;
205
206         // try shape first, then main shape
207
208         TopoDS_Shape mainShape = meshDS->ShapeToMesh();
209         const TopoDS_Shape *shapeToTry[2] = { &aShape, &mainShape };
210
211         for (int iShape = 0; iShape < 2; iShape++)
212         {
213                 TopoDS_Shape tryShape = (*shapeToTry[iShape]);
214
215                 const list<const SMESHDS_Hypothesis*>& listHyp =
216                         meshDS->GetHypothesis(tryShape);
217                 list<const SMESHDS_Hypothesis*>::const_iterator it=listHyp.begin();
218                 
219                 int nb_algo = 0;
220                 int shapeDim = GetShapeDim(aShape);
221                 int typeOfShape = aShape.ShapeType();
222
223                 while (it!=listHyp.end())
224                 {
225                         const SMESHDS_Hypothesis *anHyp = *it;
226                         hypType = anHyp->GetType();
227                         //SCRUTE(hypType);
228                         if (hypType > SMESHDS_Hypothesis::PARAM_ALGO)
229                         {
230                                 switch (hypType)
231                                 {
232                                 case SMESHDS_Hypothesis::ALGO_1D:
233                                         algoDim = 1;
234                                         break;
235                                 case SMESHDS_Hypothesis::ALGO_2D:
236                                         algoDim = 2;
237                                         break;
238                                 case SMESHDS_Hypothesis::ALGO_3D:
239                                         algoDim = 3;
240                                         break;
241                                 default:
242                                         algoDim = 0;
243                                         break;
244                                 }
245                                 //SCRUTE(algoDim);
246                                 //SCRUTE(shapeDim);
247                                 //SCRUTE(typeOfShape);
248                                 if (shapeDim == algoDim)        // count only algos of shape dim.
249                                 {                               // discard algos for subshapes
250                                         hypId = anHyp->GetID(); // (of lower dim.)
251                                         ASSERT(_mapAlgo.find(hypId) != _mapAlgo.end());
252                                         SMESH_Algo *anAlgo = _mapAlgo[hypId];
253                                         //SCRUTE(anAlgo->GetShapeType());
254                                         //if (anAlgo->GetShapeType() == typeOfShape)
255                                         if ((anAlgo->GetShapeType()) & (1 << typeOfShape))
256                                         {                       // only specific TopoDS_Shape
257                                                 nb_algo++;
258                                                 theHyp = anHyp;
259                                         }
260                                 }
261                         }
262                         if (nb_algo > 1) return NULL;   // more than one algo
263                         it++;
264                 }
265                 if (nb_algo == 1)               // one algo found : OK
266                         break;                          // do not try a parent shape
267         }
268
269         if (!theHyp)
270                 return NULL;                    // no algo found
271
272         hypType = theHyp->GetType();
273         hypId = theHyp->GetID();
274
275         ASSERT(_mapAlgo.find(hypId) != _mapAlgo.end());
276         algo = _mapAlgo[hypId];
277         //MESSAGE("Algo found " << algo->GetName() << " Id " << hypId);
278         return algo;
279 }
280
281 //=============================================================================
282 /*!
283  * 
284  */
285 //=============================================================================
286
287 StudyContextStruct *SMESH_Gen::GetStudyContext(int studyId)
288 {
289         // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
290
291         if (_mapStudyContext.find(studyId) == _mapStudyContext.end())
292         {
293                 _mapStudyContext[studyId] = new StudyContextStruct;
294                 _mapStudyContext[studyId]->myDocument = new SMESHDS_Document(studyId);
295         }
296         StudyContextStruct *myStudyContext = _mapStudyContext[studyId];
297 //   ASSERT(_mapStudyContext.find(studyId) != _mapStudyContext.end());
298         return myStudyContext;
299 }
300
301 //=============================================================================
302 /*!
303  * 
304  */
305 //=============================================================================
306
307 void SMESH_Gen::Save(int studyId, const char *aUrlOfFile)
308 {
309 }
310
311 //=============================================================================
312 /*!
313  * 
314  */
315 //=============================================================================
316
317 void SMESH_Gen::Load(int studyId, const char *aUrlOfFile)
318 {
319 }
320
321 //=============================================================================
322 /*!
323  * 
324  */
325 //=============================================================================
326
327 void SMESH_Gen::Close(int studyId)
328 {
329 }
330
331 //=============================================================================
332 /*!
333  * 
334  */
335 //=============================================================================
336
337 const char *SMESH_Gen::ComponentDataType()
338 {
339 }
340
341 //=============================================================================
342 /*!
343  * 
344  */
345 //=============================================================================
346
347 const char *SMESH_Gen::IORToLocalPersistentID(const char *IORString,
348         bool & IsAFile)
349 {
350 }
351
352 //=============================================================================
353 /*!
354  * 
355  */
356 //=============================================================================
357
358 const char *SMESH_Gen::LocalPersistentIDToIOR(const char *aLocalPersistentID)
359 {
360 }
361
362 //=============================================================================
363 /*!
364  * 
365  */
366 //=============================================================================
367
368 int SMESH_Gen::GetShapeDim(const TopoDS_Shape & aShape)
369 {
370         int shapeDim = -1;                      // Shape dimension: 0D, 1D, 2D, 3D
371         int type = aShape.ShapeType();
372         switch (type)
373         {
374 //     case TopAbs_COMPOUND:
375 //       {
376 //  break;
377 //       }
378         case TopAbs_COMPOUND:
379         case TopAbs_COMPSOLID:
380         case TopAbs_SOLID:
381         case TopAbs_SHELL:
382         {
383                 shapeDim = 3;
384                 break;
385         }
386                 //    case TopAbs_SHELL:
387         case TopAbs_FACE:
388         {
389                 shapeDim = 2;
390                 break;
391         }
392         case TopAbs_WIRE:
393         case TopAbs_EDGE:
394         {
395                 shapeDim = 1;
396                 break;
397         }
398         case TopAbs_VERTEX:
399         {
400                 shapeDim = 0;
401                 break;
402         }
403         }
404 //   SCRUTE(shapeDim);
405         return shapeDim;
406 }