]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESH/SMESH_Mesh.cxx
Salome HOME
Fix for PAL8269(One can't select a pointer on geometry in mesh filters).
[modules/smesh.git] / src / SMESH / SMESH_Mesh.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_Mesh.cxx
25 //  Author : Paul RASCLE, EDF
26 //  Module : SMESH
27 //  $Header$
28
29 #include "SMESH_Mesh.hxx"
30 #include "SMESH_subMesh.hxx"
31 #include "SMESH_Gen.hxx"
32 #include "SMESH_Hypothesis.hxx"
33 #include "SMESH_Group.hxx"
34 #include "SMESH_HypoFilter.hxx"
35 #include "SMESHDS_Group.hxx"
36 #include "SMESHDS_Script.hxx"
37 #include "SMESHDS_GroupOnGeom.hxx"
38 #include "SMDS_MeshVolume.hxx"
39
40 #include "utilities.h"
41
42 #include "DriverMED_W_SMESHDS_Mesh.h"
43 #include "DriverDAT_W_SMDS_Mesh.h"
44 #include "DriverUNV_W_SMDS_Mesh.h"
45 #include "DriverSTL_W_SMDS_Mesh.h"
46
47 #include "DriverMED_R_SMESHDS_Mesh.h"
48 #include "DriverUNV_R_SMDS_Mesh.h"
49 #include "DriverSTL_R_SMDS_Mesh.h"
50
51 #include <BRepTools_WireExplorer.hxx>
52 #include <BRep_Builder.hxx>
53 #include <gp_Pnt.hxx>
54
55 #include <TCollection_AsciiString.hxx>
56 #include <TopExp.hxx>
57 #include <TopTools_ListOfShape.hxx>
58 #include <TopTools_Array1OfShape.hxx>
59 #include <TopTools_ListIteratorOfListOfShape.hxx>
60 #include <TopTools_MapOfShape.hxx>
61
62 #include <memory>
63
64 #include "Utils_ExceptHandlers.hxx"
65
66 #ifdef _DEBUG_
67 static int MYDEBUG = 0;
68 #else
69 static int MYDEBUG = 0;
70 #endif
71
72
73 //=============================================================================
74 /*!
75  * 
76  */
77 //=============================================================================
78
79 SMESH_Mesh::SMESH_Mesh(int localId, int studyId, SMESH_Gen * gen, SMESHDS_Document * myDocument)
80 : _groupId( 0 )
81 {
82   INFOS("SMESH_Mesh::SMESH_Mesh(int localId)");
83         _id = localId;
84         _studyId = studyId;
85         _gen = gen;
86         _myDocument = myDocument;
87         _idDoc = _myDocument->NewMesh();
88         _myMeshDS = _myDocument->GetMesh(_idDoc);
89         _isShapeToMesh = false;
90 }
91
92 //=============================================================================
93 /*!
94  * 
95  */
96 //=============================================================================
97
98 SMESH_Mesh::~SMESH_Mesh()
99 {
100   INFOS("SMESH_Mesh::~SMESH_Mesh");
101
102   // delete groups
103   map < int, SMESH_Group * >::iterator itg;
104   for (itg = _mapGroup.begin(); itg != _mapGroup.end(); itg++) {
105     SMESH_Group *aGroup = (*itg).second;
106     delete aGroup;
107   }
108 }
109
110 //=============================================================================
111 /*!
112  * 
113  */
114 //=============================================================================
115
116 void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape)
117 {
118   if(MYDEBUG) MESSAGE("SMESH_Mesh::ShapeToMesh");
119
120   if ( !_myMeshDS->ShapeToMesh().IsNull() && aShape.IsNull() )
121   {
122     // removal of a shape to mesh, delete objects referring to sub-shapes:
123     // - sub-meshes
124     map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
125     for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
126       delete i_sm->second;
127     _mapSubMesh.clear();
128     //  - groups on geometry
129     map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
130     while ( i_gr != _mapGroup.end() ) {
131       if ( dynamic_cast<SMESHDS_GroupOnGeom*>( i_gr->second->GetGroupDS() )) {
132         _myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() );
133         delete i_gr->second;
134         _mapGroup.erase( i_gr++ );
135       }
136       else
137         i_gr++;
138     }
139     _mapPropagationChains.Clear();
140   }
141   else
142   {
143     if (_isShapeToMesh)
144       throw SALOME_Exception(LOCALIZED ("a shape to mesh has already been defined"));
145   }
146   _isShapeToMesh = true;
147   _myMeshDS->ShapeToMesh(aShape);
148
149   // fill _mapAncestors
150   _mapAncestors.Clear();
151   int desType, ancType;
152   for ( desType = TopAbs_EDGE; desType > TopAbs_COMPOUND; desType-- )
153     for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
154       TopExp::MapShapesAndAncestors ( aShape,
155                                      (TopAbs_ShapeEnum) desType,
156                                      (TopAbs_ShapeEnum) ancType,
157                                      _mapAncestors );
158
159   // NRI : 24/02/03
160   //EAP: 1/9/04 TopExp::MapShapes(aShape, _subShapes); USE the same map of _myMeshDS
161 }
162
163 //=======================================================================
164 //function : UNVToMesh
165 //purpose  : 
166 //=======================================================================
167
168 int SMESH_Mesh::UNVToMesh(const char* theFileName)
169 {
170   if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<<theFileName);
171   if(_isShapeToMesh)
172     throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
173   _isShapeToMesh = true;
174   DriverUNV_R_SMDS_Mesh myReader;
175   myReader.SetMesh(_myMeshDS);
176   myReader.SetFile(theFileName);
177   myReader.SetMeshId(-1);
178   myReader.Perform();
179   if(MYDEBUG){
180     MESSAGE("MEDToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
181     MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
182     MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
183     MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
184   }
185   return 1;
186 }
187
188 //=======================================================================
189 //function : MEDToMesh
190 //purpose  : 
191 //=======================================================================
192
193 int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName)
194 {
195   if(MYDEBUG) MESSAGE("MEDToMesh - theFileName = "<<theFileName<<", mesh name = "<<theMeshName);
196   if(_isShapeToMesh)
197     throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
198   _isShapeToMesh = true;
199   DriverMED_R_SMESHDS_Mesh myReader;
200   myReader.SetMesh(_myMeshDS);
201   myReader.SetMeshId(-1);
202   myReader.SetFile(theFileName);
203   myReader.SetMeshName(theMeshName);
204   Driver_Mesh::Status status = myReader.Perform();
205   if(MYDEBUG){
206     MESSAGE("MEDToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
207     MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
208     MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
209     MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
210   }
211
212   // Reading groups (sub-meshes are out of scope of MED import functionality)
213   list<string> aGroupNames = myReader.GetGroupNames();
214   if(MYDEBUG) MESSAGE("MEDToMesh - Nb groups = "<<aGroupNames.size()); 
215   int anId;
216   for ( list<string>::iterator it = aGroupNames.begin(); it != aGroupNames.end(); it++ ) {
217     SMESH_Group* aGroup = AddGroup( SMDSAbs_All, it->c_str(), anId );
218     if ( aGroup ) {
219       if(MYDEBUG) MESSAGE("MEDToMesh - group added: "<<it->c_str());      
220       SMESHDS_Group* aGroupDS = dynamic_cast<SMESHDS_Group*>( aGroup->GetGroupDS() );
221       if ( aGroupDS ) {
222         aGroupDS->SetStoreName( it->c_str() );
223         myReader.GetGroup( aGroupDS );
224       }
225     }
226   }
227   return (int) status;
228 }
229
230 //=======================================================================
231 //function : STLToMesh
232 //purpose  : 
233 //=======================================================================
234
235 int SMESH_Mesh::STLToMesh(const char* theFileName)
236 {
237   if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<<theFileName);
238   if(_isShapeToMesh)
239     throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
240   _isShapeToMesh = true;
241   DriverSTL_R_SMDS_Mesh myReader;
242   myReader.SetMesh(_myMeshDS);
243   myReader.SetFile(theFileName);
244   myReader.SetMeshId(-1);
245   myReader.Perform();
246   if(MYDEBUG){
247     MESSAGE("MEDToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
248     MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
249     MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
250     MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
251   }
252   return 1;
253 }
254
255 //=============================================================================
256 /*!
257  * 
258  */
259 //=============================================================================
260
261 SMESH_Hypothesis::Hypothesis_Status
262   SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
263                             int                  anHypId  ) throw(SALOME_Exception)
264 {
265   Unexpect aCatch(SalomeException);
266   if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis");
267
268   SMESH_subMesh *subMesh = GetSubMesh(aSubShape);
269   SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
270   if ( subMeshDS && subMeshDS->IsComplexSubmesh() )
271   {
272     // return the worst but not fatal state of all group memebers
273     SMESH_Hypothesis::Hypothesis_Status aBestRet, aWorstNotFatal, ret;
274     aBestRet = SMESH_Hypothesis::HYP_BAD_DIM;
275     aWorstNotFatal = SMESH_Hypothesis::HYP_OK;
276     for ( TopoDS_Iterator itS ( aSubShape ); itS.More(); itS.Next())
277     {
278       ret = AddHypothesis( itS.Value(), anHypId );
279       if ( !SMESH_Hypothesis::IsStatusFatal( ret ) && ret > aWorstNotFatal )
280         aWorstNotFatal = ret;
281       if ( ret < aBestRet )
282         aBestRet = ret;
283     }
284     if ( SMESH_Hypothesis::IsStatusFatal( aBestRet ))
285       return aBestRet;
286     return aWorstNotFatal;
287   }
288
289   StudyContextStruct *sc = _gen->GetStudyContext(_studyId);
290   if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end())
291   {
292     if(MYDEBUG) MESSAGE("Hypothesis ID does not give an hypothesis");
293     if(MYDEBUG) {
294       SCRUTE(_studyId);
295       SCRUTE(anHypId);
296     }
297     throw SALOME_Exception(LOCALIZED("hypothesis does not exist"));
298   }
299
300   SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
301   MESSAGE( "SMESH_Mesh::AddHypothesis " << anHyp->GetName() );
302
303   bool isGlobalHyp = IsMainShape( aSubShape );
304
305   // NotConformAllowed can be only global
306   if ( !isGlobalHyp )
307   {
308     string hypName = anHyp->GetName();
309     if ( hypName == "NotConformAllowed" )
310     {
311       if(MYDEBUG) MESSAGE( "Hypotesis <NotConformAllowed> can be only global" );
312       return SMESH_Hypothesis::HYP_INCOMPATIBLE;
313     }
314   }
315
316   // shape 
317
318   int event;
319   if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
320     event = SMESH_subMesh::ADD_HYP;
321   else
322     event = SMESH_subMesh::ADD_ALGO;
323   SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
324
325   // subShapes
326   if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
327       !subMesh->IsApplicableHypotesis( anHyp )) // is added on father
328   {
329     if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
330       event = SMESH_subMesh::ADD_FATHER_HYP;
331     else
332       event = SMESH_subMesh::ADD_FATHER_ALGO;
333     SMESH_Hypothesis::Hypothesis_Status ret2 =
334       subMesh->SubMeshesAlgoStateEngine(event, anHyp);
335     if (ret2 > ret)
336       ret = ret2;
337
338     // check concurent hypotheses on ansestors
339     if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp )
340     {
341       const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
342       map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
343       for ( ; smIt != smMap.end(); smIt++ ) {
344         if ( smIt->second->IsApplicableHypotesis( anHyp )) {
345           ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
346           if (ret2 > ret) {
347             ret = ret2;
348             break;
349           }
350         }
351       }
352     }
353   }
354
355   if(MYDEBUG) subMesh->DumpAlgoState(true);
356   SCRUTE(ret);
357   return ret;
358 }
359
360 //=============================================================================
361 /*!
362  * 
363  */
364 //=============================================================================
365
366 SMESH_Hypothesis::Hypothesis_Status
367   SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
368                                int anHypId)throw(SALOME_Exception)
369 {
370   Unexpect aCatch(SalomeException);
371   if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis");
372   
373   SMESH_subMesh *subMesh = GetSubMesh(aSubShape);
374   SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
375   if ( subMeshDS && subMeshDS->IsComplexSubmesh() )
376   {
377     // return the worst but not fatal state of all group memebers
378     SMESH_Hypothesis::Hypothesis_Status aBestRet, aWorstNotFatal, ret;
379     aBestRet = SMESH_Hypothesis::HYP_BAD_DIM;
380     aWorstNotFatal = SMESH_Hypothesis::HYP_OK;
381     for ( TopoDS_Iterator itS ( aSubShape ); itS.More(); itS.Next())
382     {
383       ret = RemoveHypothesis( itS.Value(), anHypId );
384       if ( !SMESH_Hypothesis::IsStatusFatal( ret ) && ret > aWorstNotFatal )
385         aWorstNotFatal = ret;
386       if ( ret < aBestRet )
387         aBestRet = ret;
388     }
389     if ( SMESH_Hypothesis::IsStatusFatal( aBestRet ))
390       return aBestRet;
391     return aWorstNotFatal;
392   }
393
394   StudyContextStruct *sc = _gen->GetStudyContext(_studyId);
395   if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end())
396     throw SALOME_Exception(LOCALIZED("hypothesis does not exist"));
397   
398   SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
399   int hypType = anHyp->GetType();
400   if(MYDEBUG) SCRUTE(hypType);
401   int event;
402   
403   // shape 
404   
405   if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
406     event = SMESH_subMesh::REMOVE_HYP;
407   else
408     event = SMESH_subMesh::REMOVE_ALGO;
409   SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
410
411   // there may appear concurrent hyps that were covered by the removed hyp
412   if (ret < SMESH_Hypothesis::HYP_CONCURENT &&
413       subMesh->IsApplicableHypotesis( anHyp ) &&
414       subMesh->CheckConcurentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK)
415     ret = SMESH_Hypothesis::HYP_CONCURENT;
416
417   // subShapes
418   if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
419       !subMesh->IsApplicableHypotesis( anHyp )) // is removed from father
420   {
421     if (anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO)
422       event = SMESH_subMesh::REMOVE_FATHER_HYP;
423     else
424       event = SMESH_subMesh::REMOVE_FATHER_ALGO;
425     SMESH_Hypothesis::Hypothesis_Status ret2 =
426       subMesh->SubMeshesAlgoStateEngine(event, anHyp);
427     if (ret2 > ret) // more severe
428       ret = ret2;
429
430     // check concurent hypotheses on ansestors
431     if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) )
432     {
433       const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
434       map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
435       for ( ; smIt != smMap.end(); smIt++ ) {
436         if ( smIt->second->IsApplicableHypotesis( anHyp )) {
437           ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
438           if (ret2 > ret) {
439             ret = ret2;
440             break;
441           }
442         }
443       }
444     }
445   }
446   
447   if(MYDEBUG) subMesh->DumpAlgoState(true);
448   if(MYDEBUG) SCRUTE(ret);
449   return ret;
450 }
451
452 //=============================================================================
453 /*!
454  * 
455  */
456 //=============================================================================
457
458 SMESHDS_Mesh * SMESH_Mesh::GetMeshDS()
459 {
460   return _myMeshDS;
461 }
462
463 //=============================================================================
464 /*!
465  * 
466  */
467 //=============================================================================
468
469 const list<const SMESHDS_Hypothesis*>&
470 SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
471   throw(SALOME_Exception)
472 {
473   Unexpect aCatch(SalomeException);
474   return _myMeshDS->GetHypothesis(aSubShape);
475 }
476
477 //=======================================================================
478 //function : GetHypothesis
479 //purpose  : 
480 //=======================================================================
481
482 const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape &    aSubShape,
483                                                    const SMESH_HypoFilter& aFilter,
484                                                    const bool              andAncestors) const
485 {
486   {
487     const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
488     list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
489     for ( ; hyp != hypList.end(); hyp++ ) {
490       const SMESH_Hypothesis * h = static_cast<const SMESH_Hypothesis*>( *hyp );
491       if ( aFilter.IsOk( h, aSubShape))
492         return h;
493     }
494   }
495   if ( andAncestors )
496   {
497     TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
498     for (; it.More(); it.Next() )
499     {
500       const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
501       list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
502       for ( ; hyp != hypList.end(); hyp++ ) {
503         const SMESH_Hypothesis * h = static_cast<const SMESH_Hypothesis*>( *hyp );
504         if (aFilter.IsOk( h, it.Value() ))
505           return h;
506       }
507     }
508   }
509   return 0;
510 }
511
512 //=======================================================================
513 //function : GetHypotheses
514 //purpose  : 
515 //=======================================================================
516
517 bool SMESH_Mesh::GetHypotheses(const TopoDS_Shape &                aSubShape,
518                                const SMESH_HypoFilter&             aFilter,
519                                list <const SMESHDS_Hypothesis * >& aHypList,
520                                const bool                          andAncestors) const
521 {
522   int nbHyp = 0;
523   {
524     const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
525     list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
526     for ( ; hyp != hypList.end(); hyp++ )
527       if ( aFilter.IsOk (static_cast<const SMESH_Hypothesis*>( *hyp ), aSubShape)) {
528         aHypList.push_back( *hyp );
529         nbHyp++;
530       }
531   }
532   // get hypos from shape of one type only: if any hypo is found on edge, do
533   // not look up on faces
534   if ( !nbHyp && andAncestors )
535   {
536     TopTools_MapOfShape map;
537     TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
538     int shapeType = it.More() ? it.Value().ShapeType() : TopAbs_SHAPE;
539     for (; it.More(); it.Next() )
540     {
541       if ( nbHyp && shapeType != it.Value().ShapeType() )
542         break;
543       shapeType = it.Value().ShapeType();
544       if ( !map.Add( it.Value() ))
545         continue;
546       const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
547       list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
548       for ( ; hyp != hypList.end(); hyp++ )
549         if (aFilter.IsOk( static_cast<const SMESH_Hypothesis*>( *hyp ), it.Value() )) {
550         aHypList.push_back( *hyp );
551         nbHyp++;
552       }
553     }
554   }
555   return nbHyp;
556 }
557
558 //=============================================================================
559 /*!
560  * 
561  */
562 //=============================================================================
563
564 const list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
565 {
566   Unexpect aCatch(SalomeException);
567   if(MYDEBUG) MESSAGE("SMESH_Mesh::GetLog");
568   return _myMeshDS->GetScript()->GetCommands();
569 }
570
571 //=============================================================================
572 /*!
573  * 
574  */
575 //=============================================================================
576 void SMESH_Mesh::ClearLog() throw(SALOME_Exception)
577 {
578   Unexpect aCatch(SalomeException);
579   if(MYDEBUG) MESSAGE("SMESH_Mesh::ClearLog");
580   _myMeshDS->GetScript()->Clear();
581 }
582
583 //=============================================================================
584 /*!
585  * 
586  */
587 //=============================================================================
588
589 int SMESH_Mesh::GetId()
590 {
591   if(MYDEBUG) MESSAGE("SMESH_Mesh::GetId");
592   return _id;
593 }
594
595 //=============================================================================
596 /*!
597  * 
598  */
599 //=============================================================================
600
601 SMESH_Gen *SMESH_Mesh::GetGen()
602 {
603   return _gen;
604 }
605
606 //=============================================================================
607 /*!
608  * Get or Create the SMESH_subMesh object implementation
609  */
610 //=============================================================================
611
612 SMESH_subMesh *SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
613 throw(SALOME_Exception)
614 {
615   Unexpect aCatch(SalomeException);
616   SMESH_subMesh *aSubMesh;
617   int index = _myMeshDS->ShapeToIndex(aSubShape);
618   
619   // for submeshes on GEOM Group
620   if ( !index && aSubShape.ShapeType() == TopAbs_COMPOUND ) {
621     TopoDS_Iterator it( aSubShape );
622     if ( it.More() )
623       index = _myMeshDS->AddCompoundSubmesh( aSubShape, it.Value().ShapeType() );
624   }
625
626   if (_mapSubMesh.find(index) != _mapSubMesh.end())
627     {
628       aSubMesh = _mapSubMesh[index];
629     }
630   else
631     {
632       aSubMesh = new SMESH_subMesh(index, this, _myMeshDS, aSubShape);
633       _mapSubMesh[index] = aSubMesh;
634     }
635   return aSubMesh;
636 }
637
638 //=============================================================================
639 /*!
640  * Get the SMESH_subMesh object implementation. Dont create it, return null
641  * if it does not exist.
642  */
643 //=============================================================================
644
645 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape)
646 throw(SALOME_Exception)
647 {
648   Unexpect aCatch(SalomeException);
649   bool isFound = false;
650   SMESH_subMesh *aSubMesh = NULL;
651   
652   int index = _myMeshDS->ShapeToIndex(aSubShape);
653   if (_mapSubMesh.find(index) != _mapSubMesh.end())
654     {
655       aSubMesh = _mapSubMesh[index];
656       isFound = true;
657     }
658   if (!isFound)
659     aSubMesh = NULL;
660   return aSubMesh;
661 }
662
663 //=======================================================================
664 //function : IsUsedHypothesis
665 //purpose  : Return True if anHyp is used to mesh aSubShape
666 //=======================================================================
667
668 bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp,
669                                   const TopoDS_Shape & aSubShape)
670 {
671   SMESH_Hypothesis* hyp = static_cast<SMESH_Hypothesis*>(anHyp);
672   // check if anHyp is applicable to aSubShape
673   SMESH_subMesh * subMesh = GetSubMeshContaining( aSubShape );
674   if ( !subMesh || !subMesh->IsApplicableHypotesis( hyp ))
675     return false;
676
677   SMESH_Algo *algo = _gen->GetAlgo(*this, aSubShape);
678
679   // algorithm
680   if (anHyp->GetType() > SMESHDS_Hypothesis::PARAM_ALGO)
681     return ( anHyp == algo );
682
683   // algorithm parameter
684   if (algo)
685   {
686     // look trough hypotheses used by algo
687     const list <const SMESHDS_Hypothesis * >&usedHyps =
688       algo->GetUsedHypothesis(*this, aSubShape);
689     return ( find( usedHyps.begin(), usedHyps.end(), anHyp ) != usedHyps.end() );
690   }
691
692   // look through all assigned hypotheses
693   SMESH_HypoFilter filter( SMESH_HypoFilter::Is( hyp ));
694   return GetHypothesis( aSubShape, filter, true );
695 }
696
697
698 //=============================================================================
699 /*!
700  *
701  */
702 //=============================================================================
703
704 const list < SMESH_subMesh * >&
705         SMESH_Mesh::GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp)
706 throw(SALOME_Exception)
707 {
708   Unexpect aCatch(SalomeException);
709         if(MYDEBUG) MESSAGE("SMESH_Mesh::GetSubMeshUsingHypothesis");
710         map < int, SMESH_subMesh * >::iterator itsm;
711         _subMeshesUsingHypothesisList.clear();
712         for (itsm = _mapSubMesh.begin(); itsm != _mapSubMesh.end(); itsm++)
713         {
714                 SMESH_subMesh *aSubMesh = (*itsm).second;
715                 if ( IsUsedHypothesis ( anHyp, aSubMesh->GetSubShape() ))
716                         _subMeshesUsingHypothesisList.push_back(aSubMesh);
717         }
718         return _subMeshesUsingHypothesisList;
719 }
720
721 //=============================================================================
722 /*!
723  *
724  */
725 //=============================================================================
726
727 void SMESH_Mesh::ExportMED(const char *file, 
728                            const char* theMeshName, 
729                            bool theAutoGroups,
730                            int theVersion) 
731   throw(SALOME_Exception)
732 {
733   Unexpect aCatch(SalomeException);
734   DriverMED_W_SMESHDS_Mesh myWriter;
735   myWriter.SetFile    ( file, MED::EVersion(theVersion) );
736   myWriter.SetMesh    ( _myMeshDS   );
737   if ( !theMeshName ) 
738     myWriter.SetMeshId  ( _idDoc      );
739   else {
740     myWriter.SetMeshId  ( -1          );
741     myWriter.SetMeshName( theMeshName );
742   }
743
744   if ( theAutoGroups ) {
745     myWriter.AddGroupOfNodes();
746     myWriter.AddGroupOfEdges();
747     myWriter.AddGroupOfFaces();
748     myWriter.AddGroupOfVolumes();
749   }
750
751   for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
752     SMESH_Group*       aGroup   = it->second;
753     SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
754     if ( aGroupDS ) {
755       aGroupDS->SetStoreName( aGroup->GetName() );
756       myWriter.AddGroup( aGroupDS );
757     }
758   }
759
760   myWriter.Perform();
761 }
762
763 void SMESH_Mesh::ExportDAT(const char *file) throw(SALOME_Exception)
764 {
765   Unexpect aCatch(SalomeException);
766   DriverDAT_W_SMDS_Mesh myWriter;
767   myWriter.SetFile(string(file));
768   myWriter.SetMesh(_myMeshDS);
769   myWriter.SetMeshId(_idDoc);
770   myWriter.Perform();
771 }
772
773 void SMESH_Mesh::ExportUNV(const char *file) throw(SALOME_Exception)
774 {
775   Unexpect aCatch(SalomeException);
776   DriverUNV_W_SMDS_Mesh myWriter;
777   myWriter.SetFile(string(file));
778   myWriter.SetMesh(_myMeshDS);
779   myWriter.SetMeshId(_idDoc);
780   myWriter.Perform();
781 }
782
783 void SMESH_Mesh::ExportSTL(const char *file, const bool isascii) throw(SALOME_Exception)
784 {
785   Unexpect aCatch(SalomeException);
786   DriverSTL_W_SMDS_Mesh myWriter;
787   myWriter.SetFile(string(file));
788   myWriter.SetIsAscii( isascii );
789   myWriter.SetMesh(_myMeshDS);
790   myWriter.SetMeshId(_idDoc);
791   myWriter.Perform();
792 }
793
794 //=============================================================================
795 /*!
796  *  
797  */
798 //=============================================================================
799 int SMESH_Mesh::NbNodes() throw(SALOME_Exception)
800 {
801   Unexpect aCatch(SalomeException);
802   return _myMeshDS->NbNodes();
803 }
804
805 //=============================================================================
806 /*!
807  *  
808  */
809 //=============================================================================
810 int SMESH_Mesh::NbEdges() throw(SALOME_Exception)
811 {
812   Unexpect aCatch(SalomeException);
813   return _myMeshDS->NbEdges();
814 }
815
816 //=============================================================================
817 /*!
818  *  
819  */
820 //=============================================================================
821 int SMESH_Mesh::NbFaces() throw(SALOME_Exception)
822 {
823   Unexpect aCatch(SalomeException);
824   return _myMeshDS->NbFaces();
825 }
826
827 ///////////////////////////////////////////////////////////////////////////////
828 /// Return the number of 3 nodes faces in the mesh. This method run in O(n)
829 ///////////////////////////////////////////////////////////////////////////////
830 int SMESH_Mesh::NbTriangles() throw(SALOME_Exception)
831 {
832   Unexpect aCatch(SalomeException);
833   int Nb = 0;
834   
835   SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
836   while(itFaces->more()) if(itFaces->next()->NbNodes()==3) Nb++;
837   return Nb;
838 }
839
840 ///////////////////////////////////////////////////////////////////////////////
841 /// Return the number of 4 nodes faces in the mesh. This method run in O(n)
842 ///////////////////////////////////////////////////////////////////////////////
843 int SMESH_Mesh::NbQuadrangles() throw(SALOME_Exception)
844 {
845   Unexpect aCatch(SalomeException);
846   int Nb = 0;
847   
848   SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
849   while(itFaces->more()) if(itFaces->next()->NbNodes()==4) Nb++;
850   return Nb;
851 }
852
853 //=============================================================================
854 /*!
855  *  
856  */
857 //=============================================================================
858 int SMESH_Mesh::NbVolumes() throw(SALOME_Exception)
859 {
860   Unexpect aCatch(SalomeException);
861   return _myMeshDS->NbVolumes();
862 }
863
864 int SMESH_Mesh::NbTetras() throw(SALOME_Exception)
865 {
866   Unexpect aCatch(SalomeException);
867   int Nb = 0;
868   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
869   while(itVolumes->more()) if(itVolumes->next()->NbNodes()==4) Nb++;
870   return Nb;
871 }
872
873 int SMESH_Mesh::NbHexas() throw(SALOME_Exception)
874 {
875   Unexpect aCatch(SalomeException);
876   int Nb = 0;
877   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
878   while(itVolumes->more()) if(itVolumes->next()->NbNodes()==8) Nb++;
879   return Nb;
880 }
881
882 int SMESH_Mesh::NbPyramids() throw(SALOME_Exception)
883 {
884   Unexpect aCatch(SalomeException);
885   int Nb = 0;
886   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
887   while(itVolumes->more()) if(itVolumes->next()->NbNodes()==5) Nb++;
888   return Nb;
889 }
890
891 int SMESH_Mesh::NbPrisms() throw(SALOME_Exception)
892 {
893   Unexpect aCatch(SalomeException);
894   int Nb = 0;
895   SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
896   while(itVolumes->more()) if(itVolumes->next()->NbNodes()==6) Nb++;
897   return Nb;
898 }
899
900 //=============================================================================
901 /*!
902  *  
903  */
904 //=============================================================================
905 int SMESH_Mesh::NbSubMesh() throw(SALOME_Exception)
906 {
907   Unexpect aCatch(SalomeException);
908   return _myMeshDS->NbSubMesh();
909 }
910
911 //=======================================================================
912 //function : IsNotConformAllowed
913 //purpose  : check if a hypothesis alowing notconform mesh is present
914 //=======================================================================
915
916 bool SMESH_Mesh::IsNotConformAllowed() const
917 {
918   if(MYDEBUG) MESSAGE("SMESH_Mesh::IsNotConformAllowed");
919
920   SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "NotConformAllowed" ));
921   return GetHypothesis( _myMeshDS->ShapeToMesh(), filter, false );
922 }
923
924 //=======================================================================
925 //function : IsMainShape
926 //purpose  : 
927 //=======================================================================
928
929 bool SMESH_Mesh::IsMainShape(const TopoDS_Shape& theShape) const
930 {
931   return theShape.IsSame(_myMeshDS->ShapeToMesh() );
932 }
933
934 //=============================================================================
935 /*!
936  *  
937  */
938 //=============================================================================
939
940 SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType,
941                                    const char*               theName,
942                                    int&                      theId,
943                                    const TopoDS_Shape&       theShape)
944 {
945   if (_mapGroup.find(_groupId) != _mapGroup.end())
946     return NULL;
947   theId = _groupId;
948   SMESH_Group* aGroup = new SMESH_Group (theId, this, theType, theName, theShape);
949   GetMeshDS()->AddGroup( aGroup->GetGroupDS() );
950   _mapGroup[_groupId++] = aGroup;
951   return aGroup;
952 }
953
954 //=============================================================================
955 /*!
956  *  
957  */
958 //=============================================================================
959
960 SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID)
961 {
962   if (_mapGroup.find(theGroupID) == _mapGroup.end())
963     return NULL;
964   return _mapGroup[theGroupID];
965 }
966
967
968 //=============================================================================
969 /*!
970  *  
971  */
972 //=============================================================================
973
974 list<int> SMESH_Mesh::GetGroupIds()
975 {
976   list<int> anIds;
977   for ( map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
978     anIds.push_back( it->first );
979   
980   return anIds;
981 }
982
983
984 //=============================================================================
985 /*!
986  *  
987  */
988 //=============================================================================
989
990 void SMESH_Mesh::RemoveGroup (const int theGroupID)
991 {
992   if (_mapGroup.find(theGroupID) == _mapGroup.end())
993     return;
994   GetMeshDS()->RemoveGroup( _mapGroup[theGroupID]->GetGroupDS() );
995   _mapGroup.erase (theGroupID);
996   delete _mapGroup[theGroupID];
997 }
998
999 //=============================================================================
1000 /*!
1001  *  IsLocal1DHypothesis
1002  *  Returns a local 1D hypothesis used for theEdge
1003  */
1004 //=============================================================================
1005 const SMESH_Hypothesis* SMESH_Mesh::IsLocal1DHypothesis (const TopoDS_Shape& theEdge)
1006 {
1007   SMESH_HypoFilter filter( SMESH_HypoFilter::HasDim( 1 ));
1008   filter.AndNot( SMESH_HypoFilter::IsAlgo() );
1009   filter.AndNot( SMESH_HypoFilter::IsGlobal( GetMeshDS()->ShapeToMesh() ));
1010
1011   return GetHypothesis( theEdge, filter, true );
1012 }
1013
1014 //=============================================================================
1015 /*!
1016  *  IsPropagationHypothesis
1017  */
1018 //=============================================================================
1019 bool SMESH_Mesh::IsPropagationHypothesis (const TopoDS_Shape& theEdge)
1020 {
1021   return _mapPropagationChains.Contains(theEdge);
1022 }
1023
1024 //=============================================================================
1025 /*!
1026  *  IsPropagatedHypothesis
1027  */
1028 //=============================================================================
1029 bool SMESH_Mesh::IsPropagatedHypothesis (const TopoDS_Shape& theEdge,
1030                                          TopoDS_Shape&       theMainEdge)
1031 {
1032   int nbChains = _mapPropagationChains.Extent();
1033   for (int i = 1; i <= nbChains; i++) {
1034     const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromIndex(i);
1035     if (aChain.Contains(theEdge)) {
1036       theMainEdge = _mapPropagationChains.FindKey(i);
1037       return true;
1038     }
1039   }
1040
1041   return false;
1042 }
1043 //=============================================================================
1044 /*!
1045  *  IsReversedInChain
1046  */
1047 //=============================================================================
1048
1049 bool SMESH_Mesh::IsReversedInChain (const TopoDS_Shape& theEdge,
1050                                     const TopoDS_Shape& theMainEdge)
1051 {
1052   if ( !theMainEdge.IsNull() && !theEdge.IsNull() &&
1053       _mapPropagationChains.Contains( theMainEdge ))
1054   {
1055     const TopTools_IndexedMapOfShape& aChain =
1056       _mapPropagationChains.FindFromKey( theMainEdge );
1057     int index = aChain.FindIndex( theEdge );
1058     if ( index )
1059       return aChain(index).Orientation() == TopAbs_REVERSED;
1060   }
1061   return false;
1062 }
1063
1064 //=============================================================================
1065 /*!
1066  *  CleanMeshOnPropagationChain
1067  */
1068 //=============================================================================
1069 void SMESH_Mesh::CleanMeshOnPropagationChain (const TopoDS_Shape& theMainEdge)
1070 {
1071   const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromKey(theMainEdge);
1072   int i, nbEdges = aChain.Extent();
1073   for (i = 1; i <= nbEdges; i++) {
1074     TopoDS_Shape anEdge = aChain.FindKey(i);
1075     SMESH_subMesh *subMesh = GetSubMesh(anEdge);
1076     SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
1077     if (subMeshDS && subMeshDS->NbElements() > 0) {
1078       subMesh->ComputeStateEngine(SMESH_subMesh::CLEANDEP);
1079     }
1080   }
1081 }
1082
1083 //=============================================================================
1084 /*!
1085  *  RebuildPropagationChains
1086  *  Rebuild all existing propagation chains.
1087  *  Have to be used, if 1D hypothesis have been assigned/removed to/from any edge
1088  */
1089 //=============================================================================
1090 bool SMESH_Mesh::RebuildPropagationChains()
1091 {
1092   bool ret = true;
1093
1094   // Clean all chains, because they can be not up-to-date
1095   int i, nbChains = _mapPropagationChains.Extent();
1096   for (i = 1; i <= nbChains; i++) {
1097     TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
1098     CleanMeshOnPropagationChain(aMainEdge);
1099     _mapPropagationChains.ChangeFromIndex(i).Clear();
1100   }
1101
1102   // Build all chains
1103   for (i = 1; i <= nbChains; i++) {
1104     TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
1105     if (!BuildPropagationChain(aMainEdge))
1106       ret = false;
1107     CleanMeshOnPropagationChain(aMainEdge);
1108   }
1109
1110   return ret;
1111 }
1112
1113 //=============================================================================
1114 /*!
1115  *  RemovePropagationChain
1116  *  Have to be used, if Propagation hypothesis is removed from <theMainEdge>
1117  */
1118 //=============================================================================
1119 bool SMESH_Mesh::RemovePropagationChain (const TopoDS_Shape& theMainEdge)
1120 {
1121   if (!_mapPropagationChains.Contains(theMainEdge))
1122     return false;
1123
1124   // Clean mesh elements and nodes, built on the chain
1125   CleanMeshOnPropagationChain(theMainEdge);
1126
1127   // Clean the chain
1128   _mapPropagationChains.ChangeFromKey(theMainEdge).Clear();
1129
1130   // Remove the chain from the map
1131   int i = _mapPropagationChains.FindIndex(theMainEdge);
1132   if ( i == _mapPropagationChains.Extent() )
1133     _mapPropagationChains.RemoveLast();
1134   else {
1135     TopoDS_Vertex anEmptyShape;
1136     BRep_Builder BB;
1137     BB.MakeVertex(anEmptyShape, gp_Pnt(0,0,0), 0.1);
1138     TopTools_IndexedMapOfShape anEmptyMap;
1139     _mapPropagationChains.Substitute(i, anEmptyShape, anEmptyMap);
1140   }
1141
1142   return true;
1143 }
1144
1145 //=============================================================================
1146 /*!
1147  *  BuildPropagationChain
1148  */
1149 //=============================================================================
1150 bool SMESH_Mesh::BuildPropagationChain (const TopoDS_Shape& theMainEdge)
1151 {
1152   if (theMainEdge.ShapeType() != TopAbs_EDGE) return true;
1153
1154   // Add new chain, if there is no
1155   if (!_mapPropagationChains.Contains(theMainEdge)) {
1156     TopTools_IndexedMapOfShape aNewChain;
1157     _mapPropagationChains.Add(theMainEdge, aNewChain);
1158   }
1159
1160   // Check presence of 1D hypothesis to be propagated
1161   const SMESH_Hypothesis* aMainHyp = IsLocal1DHypothesis(theMainEdge);
1162   if (!aMainHyp) {
1163     MESSAGE("Warning: There is no 1D hypothesis to propagate. Please, assign.");
1164     return true;
1165   }
1166
1167   // Edges, on which the 1D hypothesis will be propagated from <theMainEdge>
1168   TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.ChangeFromKey(theMainEdge);
1169   if (aChain.Extent() > 0) {
1170     CleanMeshOnPropagationChain(theMainEdge);
1171     aChain.Clear();
1172   }
1173
1174   // At first put <theMainEdge> in the chain
1175   aChain.Add(theMainEdge);
1176
1177   // List of edges, added to chain on the previous cycle pass
1178   TopTools_ListOfShape listPrevEdges;
1179   listPrevEdges.Append(theMainEdge.Oriented( TopAbs_FORWARD ));
1180
1181 //   5____4____3____4____5____6
1182 //   |    |    |    |    |    |
1183 //   |    |    |    |    |    |
1184 //   4____3____2____3____4____5
1185 //   |    |    |    |    |    |      Number in the each knot of
1186 //   |    |    |    |    |    |      grid indicates cycle pass,
1187 //   3____2____1____2____3____4      on which corresponding edge
1188 //   |    |    |    |    |    |      (perpendicular to the plane
1189 //   |    |    |    |    |    |      of view) will be found.
1190 //   2____1____0____1____2____3
1191 //   |    |    |    |    |    |
1192 //   |    |    |    |    |    |
1193 //   3____2____1____2____3____4
1194
1195   // Collect all edges pass by pass
1196   while (listPrevEdges.Extent() > 0) {
1197     // List of edges, added to chain on this cycle pass
1198     TopTools_ListOfShape listCurEdges;
1199
1200     // Find the next portion of edges
1201     TopTools_ListIteratorOfListOfShape itE (listPrevEdges);
1202     for (; itE.More(); itE.Next()) {
1203       TopoDS_Shape anE = itE.Value();
1204
1205       // Iterate on faces, having edge <anE>
1206       TopTools_ListIteratorOfListOfShape itA (GetAncestors(anE));
1207       for (; itA.More(); itA.Next()) {
1208         TopoDS_Shape aW = itA.Value();
1209
1210         // There are objects of different type among the ancestors of edge
1211         if (aW.ShapeType() == TopAbs_WIRE) {
1212           TopoDS_Shape anOppE;
1213
1214           BRepTools_WireExplorer aWE (TopoDS::Wire(aW));
1215           Standard_Integer nb = 1, found = 0;
1216           TopTools_Array1OfShape anEdges (1,4);
1217           for (; aWE.More(); aWE.Next(), nb++) {
1218             if (nb > 4) {
1219               found = 0;
1220               break;
1221             }
1222             anEdges(nb) = aWE.Current();
1223             if (!_mapAncestors.Contains(anEdges(nb))) {
1224               MESSAGE("WIRE EXPLORER HAVE GIVEN AN INVALID EDGE !!!");
1225               break;
1226             }
1227             if (anEdges(nb).IsSame(anE)) found = nb;
1228           }
1229
1230           if (nb == 5 && found > 0) {
1231             // Quadrangle face found, get an opposite edge
1232             Standard_Integer opp = found + 2;
1233             if (opp > 4) opp -= 4;
1234             anOppE = anEdges(opp);
1235
1236             // add anOppE to aChain if ...
1237             if (!aChain.Contains(anOppE)) { // ... anOppE is not in aChain
1238               if (!IsLocal1DHypothesis(anOppE)) { // ... no other 1d hyp on anOppE
1239                 TopoDS_Shape aMainEdgeForOppEdge; // ... no other hyp is propagated to anOppE
1240                 if (!IsPropagatedHypothesis(anOppE, aMainEdgeForOppEdge))
1241                 {
1242                   // Add found edge to the chain oriented so that to
1243                   // have it co-directed with a forward MainEdge
1244                   TopAbs_Orientation ori = anE.Orientation();
1245                   if ( anEdges(opp).Orientation() == anEdges(found).Orientation() )
1246                     ori = TopAbs::Reverse( ori );
1247                   anOppE.Orientation( ori );
1248                   aChain.Add(anOppE);
1249                   listCurEdges.Append(anOppE);
1250                 }
1251                 else {
1252                   // Collision!
1253                   MESSAGE("Error: Collision between propagated hypotheses");
1254                   CleanMeshOnPropagationChain(theMainEdge);
1255                   aChain.Clear();
1256                   return ( aMainHyp == IsLocal1DHypothesis(aMainEdgeForOppEdge) );
1257                 }
1258               }
1259             }
1260           } // if (nb == 5 && found > 0)
1261         } // if (aF.ShapeType() == TopAbs_WIRE)
1262       } // for (; itF.More(); itF.Next())
1263     } // for (; itE.More(); itE.Next())
1264
1265     listPrevEdges = listCurEdges;
1266   } // while (listPrevEdges.Extent() > 0)
1267
1268   CleanMeshOnPropagationChain(theMainEdge);
1269   return true;
1270 }
1271
1272 //=======================================================================
1273 //function : GetAncestors
1274 //purpose  : return list of ancestors of theSubShape in the order
1275 //           that lower dimention shapes come first.
1276 //=======================================================================
1277
1278 const TopTools_ListOfShape& SMESH_Mesh::GetAncestors(const TopoDS_Shape& theS) const
1279 {
1280   if ( _mapAncestors.Contains( theS ) )
1281     return _mapAncestors.FindFromKey( theS );
1282
1283   static TopTools_ListOfShape emptyList;
1284   return emptyList;
1285 }
1286
1287 //=======================================================================
1288 //function : Dump
1289 //purpose  : dumps contents of mesh to stream [ debug purposes ]
1290 //=======================================================================
1291 ostream& SMESH_Mesh::Dump(ostream& save)
1292 {
1293   save << "========================== Dump contents of mesh ==========================" << endl;
1294   save << "1) Total number of nodes:     " << NbNodes() << endl;
1295   save << "2) Total number of edges:     " << NbEdges() << endl;
1296   save << "3) Total number of faces:     " << NbFaces() << endl;
1297   if ( NbFaces() > 0 ) {
1298     int nb3 = NbTriangles();
1299     int nb4 = NbQuadrangles();
1300     save << "3.1.) Number of triangles:    " << nb3 << endl;
1301     save << "3.2.) Number of quadrangles:  " << nb4 << endl;
1302     if ( nb3 + nb4 !=  NbFaces() ) {
1303       map<int,int> myFaceMap;
1304       SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
1305       while( itFaces->more( ) ) {
1306         int nbNodes = itFaces->next()->NbNodes();
1307         if ( myFaceMap.find( nbNodes ) == myFaceMap.end() )
1308           myFaceMap[ nbNodes ] = 0;
1309         myFaceMap[ nbNodes ] = myFaceMap[ nbNodes ] + 1;
1310       }
1311       save << "3.3.) Faces in detail: " << endl;
1312       map <int,int>::iterator itF;
1313       for (itF = myFaceMap.begin(); itF != myFaceMap.end(); itF++)
1314         save << "--> nb nodes: " << itF->first << " - nb elemens: " << itF->second << endl;
1315     }
1316   }
1317   save << "4) Total number of volumes:   " << NbVolumes() << endl;
1318   if ( NbVolumes() > 0 ) {
1319     int nb8 = NbHexas();
1320     int nb4 = NbTetras();
1321     int nb5 = NbPyramids();
1322     int nb6 = NbPrisms();
1323     save << "4.1.) Number of hexahedrons:  " << nb8 << endl;
1324     save << "4.2.) Number of tetrahedrons: " << nb4 << endl;
1325     save << "4.3.) Number of prisms:       " << nb6 << endl;
1326     save << "4.4.) Number of pyramides:    " << nb5 << endl;
1327     if ( nb8 + nb4 + nb5 + nb6 != NbVolumes() ) {
1328       map<int,int> myVolumesMap;
1329       SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1330       while( itVolumes->more( ) ) {
1331         int nbNodes = itVolumes->next()->NbNodes();
1332         if ( myVolumesMap.find( nbNodes ) == myVolumesMap.end() )
1333           myVolumesMap[ nbNodes ] = 0;
1334         myVolumesMap[ nbNodes ] = myVolumesMap[ nbNodes ] + 1;
1335       }
1336       save << "4.5.) Volumes in detail: " << endl;
1337       map <int,int>::iterator itV;
1338       for (itV = myVolumesMap.begin(); itV != myVolumesMap.end(); itV++)
1339         save << "--> nb nodes: " << itV->first << " - nb elemens: " << itV->second << endl;
1340     }
1341   }
1342   save << "===========================================================================" << endl;
1343   return save;
1344 }