1 // SMESH SMESH : implementaion of SMESH idl descriptions
3 // Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
24 // File : SMESH_Mesh.cxx
25 // Author : Paul RASCLE, EDF
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"
40 #include "utilities.h"
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"
47 #include "DriverMED_R_SMESHDS_Mesh.h"
48 #include "DriverUNV_R_SMDS_Mesh.h"
49 #include "DriverSTL_R_SMDS_Mesh.h"
51 #include <BRepTools_WireExplorer.hxx>
52 #include <BRep_Builder.hxx>
55 #include <TCollection_AsciiString.hxx>
57 #include <TopTools_ListOfShape.hxx>
58 #include <TopTools_Array1OfShape.hxx>
59 #include <TopTools_ListIteratorOfListOfShape.hxx>
60 #include <TopTools_MapOfShape.hxx>
64 #include "Utils_ExceptHandlers.hxx"
66 // maximum stored group name length in MED file
67 #define MAX_MED_GROUP_NAME_LENGTH 80
70 static int MYDEBUG = 0;
72 static int MYDEBUG = 0;
75 #define cSMESH_Hyp(h) static_cast<const SMESH_Hypothesis*>(h)
77 //=============================================================================
81 //=============================================================================
83 SMESH_Mesh::SMESH_Mesh(int theLocalId,
86 bool theIsEmbeddedMode,
87 SMESHDS_Document* theDocument):
90 INFOS("SMESH_Mesh::SMESH_Mesh(int localId)");
92 _studyId = theStudyId;
94 _myDocument = theDocument;
95 _idDoc = theDocument->NewMesh(theIsEmbeddedMode);
96 _myMeshDS = theDocument->GetMesh(_idDoc);
97 _isShapeToMesh = false;
100 //=============================================================================
104 //=============================================================================
106 SMESH_Mesh::~SMESH_Mesh()
108 INFOS("SMESH_Mesh::~SMESH_Mesh");
111 map < int, SMESH_Group * >::iterator itg;
112 for (itg = _mapGroup.begin(); itg != _mapGroup.end(); itg++) {
113 SMESH_Group *aGroup = (*itg).second;
118 //=============================================================================
122 //=============================================================================
124 void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape)
126 if(MYDEBUG) MESSAGE("SMESH_Mesh::ShapeToMesh");
128 if ( !_myMeshDS->ShapeToMesh().IsNull() && aShape.IsNull() )
130 // removal of a shape to mesh, delete objects referring to sub-shapes:
132 map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
133 for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
136 // - groups on geometry
137 map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
138 while ( i_gr != _mapGroup.end() ) {
139 if ( dynamic_cast<SMESHDS_GroupOnGeom*>( i_gr->second->GetGroupDS() )) {
140 _myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() );
142 _mapGroup.erase( i_gr++ );
147 _mapPropagationChains.Clear();
152 throw SALOME_Exception(LOCALIZED ("a shape to mesh has already been defined"));
154 _isShapeToMesh = true;
155 _myMeshDS->ShapeToMesh(aShape);
157 // fill _mapAncestors
158 _mapAncestors.Clear();
159 int desType, ancType;
160 for ( desType = TopAbs_VERTEX; desType > TopAbs_COMPOUND; desType-- )
161 for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
162 TopExp::MapShapesAndAncestors ( aShape,
163 (TopAbs_ShapeEnum) desType,
164 (TopAbs_ShapeEnum) ancType,
168 //EAP: 1/9/04 TopExp::MapShapes(aShape, _subShapes); USE the same map of _myMeshDS
171 //=======================================================================
172 //function : UNVToMesh
174 //=======================================================================
176 int SMESH_Mesh::UNVToMesh(const char* theFileName)
178 if(MYDEBUG) MESSAGE("UNVToMesh - theFileName = "<<theFileName);
180 throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
181 _isShapeToMesh = true;
182 DriverUNV_R_SMDS_Mesh myReader;
183 myReader.SetMesh(_myMeshDS);
184 myReader.SetFile(theFileName);
185 myReader.SetMeshId(-1);
188 MESSAGE("UNVToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
189 MESSAGE("UNVToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
190 MESSAGE("UNVToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
191 MESSAGE("UNVToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
193 SMDS_MeshGroup* aGroup = (SMDS_MeshGroup*) myReader.GetGroup();
195 TGroupNamesMap aGroupNames = myReader.GetGroupNamesMap();
196 //const TGroupIdMap& aGroupId = myReader.GetGroupIdMap();
197 aGroup->InitSubGroupsIterator();
198 while (aGroup->MoreSubGroups()) {
199 SMDS_MeshGroup* aSubGroup = (SMDS_MeshGroup*) aGroup->NextSubGroup();
200 std::string aName = aGroupNames[aSubGroup];
203 SMESH_Group* aSMESHGroup = AddGroup( aSubGroup->GetType(), aName.c_str(), aId );
205 if(MYDEBUG) MESSAGE("UNVToMesh - group added: "<<aName);
206 SMESHDS_Group* aGroupDS = dynamic_cast<SMESHDS_Group*>( aSMESHGroup->GetGroupDS() );
208 aGroupDS->SetStoreName(aName.c_str());
209 aSubGroup->InitIterator();
210 const SMDS_MeshElement* aElement = 0;
211 while (aSubGroup->More()) {
212 aElement = aSubGroup->Next();
214 aGroupDS->SMDSGroup().Add(aElement);
218 aGroupDS->SetType(aElement->GetType());
226 //=======================================================================
227 //function : MEDToMesh
229 //=======================================================================
231 int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName)
233 if(MYDEBUG) MESSAGE("MEDToMesh - theFileName = "<<theFileName<<", mesh name = "<<theMeshName);
235 throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
236 _isShapeToMesh = true;
237 DriverMED_R_SMESHDS_Mesh myReader;
238 myReader.SetMesh(_myMeshDS);
239 myReader.SetMeshId(-1);
240 myReader.SetFile(theFileName);
241 myReader.SetMeshName(theMeshName);
242 Driver_Mesh::Status status = myReader.Perform();
244 MESSAGE("MEDToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
245 MESSAGE("MEDToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
246 MESSAGE("MEDToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
247 MESSAGE("MEDToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
250 // Reading groups (sub-meshes are out of scope of MED import functionality)
251 list<TNameAndType> aGroupNames = myReader.GetGroupNamesAndTypes();
252 if(MYDEBUG) MESSAGE("MEDToMesh - Nb groups = "<<aGroupNames.size());
254 list<TNameAndType>::iterator name_type = aGroupNames.begin();
255 for ( ; name_type != aGroupNames.end(); name_type++ ) {
256 SMESH_Group* aGroup = AddGroup( name_type->second, name_type->first.c_str(), anId );
258 if(MYDEBUG) MESSAGE("MEDToMesh - group added: "<<name_type->first.c_str());
259 SMESHDS_Group* aGroupDS = dynamic_cast<SMESHDS_Group*>( aGroup->GetGroupDS() );
261 aGroupDS->SetStoreName( name_type->first.c_str() );
262 myReader.GetGroup( aGroupDS );
269 //=======================================================================
270 //function : STLToMesh
272 //=======================================================================
274 int SMESH_Mesh::STLToMesh(const char* theFileName)
276 if(MYDEBUG) MESSAGE("STLToMesh - theFileName = "<<theFileName);
278 throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
279 _isShapeToMesh = true;
280 DriverSTL_R_SMDS_Mesh myReader;
281 myReader.SetMesh(_myMeshDS);
282 myReader.SetFile(theFileName);
283 myReader.SetMeshId(-1);
286 MESSAGE("STLToMesh - _myMeshDS->NbNodes() = "<<_myMeshDS->NbNodes());
287 MESSAGE("STLToMesh - _myMeshDS->NbEdges() = "<<_myMeshDS->NbEdges());
288 MESSAGE("STLToMesh - _myMeshDS->NbFaces() = "<<_myMeshDS->NbFaces());
289 MESSAGE("STLToMesh - _myMeshDS->NbVolumes() = "<<_myMeshDS->NbVolumes());
294 //=============================================================================
298 //=============================================================================
300 SMESH_Hypothesis::Hypothesis_Status
301 SMESH_Mesh::AddHypothesis(const TopoDS_Shape & aSubShape,
302 int anHypId ) throw(SALOME_Exception)
304 Unexpect aCatch(SalomeException);
305 if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis");
307 SMESH_subMesh *subMesh = GetSubMesh(aSubShape);
308 if ( !subMesh || !subMesh->GetId())
309 return SMESH_Hypothesis::HYP_BAD_SUBSHAPE;
311 SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
312 if ( subMeshDS && subMeshDS->IsComplexSubmesh() ) // group of sub-shapes and maybe of not sub-
314 MESSAGE("AddHypothesis() to complex submesh");
315 // return the worst but not fatal state of all group memebers
316 SMESH_Hypothesis::Hypothesis_Status aBestRet, aWorstNotFatal, ret;
317 aBestRet = SMESH_Hypothesis::HYP_BAD_DIM;
318 aWorstNotFatal = SMESH_Hypothesis::HYP_OK;
319 for ( TopoDS_Iterator itS ( aSubShape ); itS.More(); itS.Next())
321 if ( !GetMeshDS()->ShapeToIndex( itS.Value() ))
322 continue; // not sub-shape
323 ret = AddHypothesis( itS.Value(), anHypId );
324 if ( !SMESH_Hypothesis::IsStatusFatal( ret ) && ret > aWorstNotFatal )
325 aWorstNotFatal = ret;
326 if ( ret < aBestRet )
329 if ( SMESH_Hypothesis::IsStatusFatal( aBestRet ))
331 return aWorstNotFatal;
334 StudyContextStruct *sc = _gen->GetStudyContext(_studyId);
335 if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end())
337 if(MYDEBUG) MESSAGE("Hypothesis ID does not give an hypothesis");
342 throw SALOME_Exception(LOCALIZED("hypothesis does not exist"));
345 SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
346 MESSAGE( "SMESH_Mesh::AddHypothesis " << anHyp->GetName() );
348 bool isGlobalHyp = IsMainShape( aSubShape );
350 // NotConformAllowed can be only global
353 string hypName = anHyp->GetName();
354 if ( hypName == "NotConformAllowed" )
356 if(MYDEBUG) MESSAGE( "Hypotesis <NotConformAllowed> can be only global" );
357 return SMESH_Hypothesis::HYP_INCOMPATIBLE;
363 bool isAlgo = ( !anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO );
364 int event = isAlgo ? SMESH_subMesh::ADD_ALGO : SMESH_subMesh::ADD_HYP;
366 SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
369 if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
370 anHyp->GetDim() <= SMESH_Gen::GetShapeDim(aSubShape)) // is added on father
372 event = isAlgo ? SMESH_subMesh::ADD_FATHER_ALGO : SMESH_subMesh::ADD_FATHER_HYP;
374 SMESH_Hypothesis::Hypothesis_Status ret2 =
375 subMesh->SubMeshesAlgoStateEngine(event, anHyp);
379 // check concurent hypotheses on ansestors
380 if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp )
382 const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
383 map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
384 for ( ; smIt != smMap.end(); smIt++ ) {
385 if ( smIt->second->IsApplicableHypotesis( anHyp )) {
386 ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
396 if(MYDEBUG) subMesh->DumpAlgoState(true);
401 //=============================================================================
405 //=============================================================================
407 SMESH_Hypothesis::Hypothesis_Status
408 SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
409 int anHypId)throw(SALOME_Exception)
411 Unexpect aCatch(SalomeException);
412 if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis");
414 SMESH_subMesh *subMesh = GetSubMesh(aSubShape);
415 SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
416 if ( subMeshDS && subMeshDS->IsComplexSubmesh() )
418 // return the worst but not fatal state of all group memebers
419 SMESH_Hypothesis::Hypothesis_Status aBestRet, aWorstNotFatal, ret;
420 aBestRet = SMESH_Hypothesis::HYP_BAD_DIM;
421 aWorstNotFatal = SMESH_Hypothesis::HYP_OK;
422 for ( TopoDS_Iterator itS ( aSubShape ); itS.More(); itS.Next())
424 if ( !GetMeshDS()->ShapeToIndex( itS.Value() ))
425 continue; // not sub-shape
426 ret = RemoveHypothesis( itS.Value(), anHypId );
427 if ( !SMESH_Hypothesis::IsStatusFatal( ret ) && ret > aWorstNotFatal )
428 aWorstNotFatal = ret;
429 if ( ret < aBestRet )
432 if ( SMESH_Hypothesis::IsStatusFatal( aBestRet ))
434 return aWorstNotFatal;
437 StudyContextStruct *sc = _gen->GetStudyContext(_studyId);
438 if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end())
439 throw SALOME_Exception(LOCALIZED("hypothesis does not exist"));
441 SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
442 int hypType = anHyp->GetType();
443 if(MYDEBUG) SCRUTE(hypType);
447 bool isAlgo = ( !anHyp->GetType() == SMESHDS_Hypothesis::PARAM_ALGO );
448 int event = isAlgo ? SMESH_subMesh::REMOVE_ALGO : SMESH_subMesh::REMOVE_HYP;
450 SMESH_Hypothesis::Hypothesis_Status ret = subMesh->AlgoStateEngine(event, anHyp);
452 // there may appear concurrent hyps that were covered by the removed hyp
453 if (ret < SMESH_Hypothesis::HYP_CONCURENT &&
454 subMesh->IsApplicableHypotesis( anHyp ) &&
455 subMesh->CheckConcurentHypothesis( anHyp->GetType() ) != SMESH_Hypothesis::HYP_OK)
456 ret = SMESH_Hypothesis::HYP_CONCURENT;
459 if (!SMESH_Hypothesis::IsStatusFatal(ret) &&
460 anHyp->GetDim() <= SMESH_Gen::GetShapeDim(aSubShape)) // is removed from father
462 event = isAlgo ? SMESH_subMesh::REMOVE_FATHER_ALGO : SMESH_subMesh::REMOVE_FATHER_HYP;
464 SMESH_Hypothesis::Hypothesis_Status ret2 =
465 subMesh->SubMeshesAlgoStateEngine(event, anHyp);
466 if (ret2 > ret) // more severe
469 // check concurent hypotheses on ansestors
470 if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) )
472 const map < int, SMESH_subMesh * >& smMap = subMesh->DependsOn();
473 map < int, SMESH_subMesh * >::const_iterator smIt = smMap.begin();
474 for ( ; smIt != smMap.end(); smIt++ ) {
475 if ( smIt->second->IsApplicableHypotesis( anHyp )) {
476 ret2 = smIt->second->CheckConcurentHypothesis( anHyp->GetType() );
486 if(MYDEBUG) subMesh->DumpAlgoState(true);
487 if(MYDEBUG) SCRUTE(ret);
491 //=============================================================================
495 //=============================================================================
497 SMESHDS_Mesh * SMESH_Mesh::GetMeshDS()
502 //=============================================================================
506 //=============================================================================
508 const list<const SMESHDS_Hypothesis*>&
509 SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
510 throw(SALOME_Exception)
512 Unexpect aCatch(SalomeException);
513 return _myMeshDS->GetHypothesis(aSubShape);
516 //=======================================================================
518 * \brief Return the hypothesis assigned to the shape
519 * \param aSubShape - the shape to check
520 * \param aFilter - the hypothesis filter
521 * \param andAncestors - flag to check hypos assigned to ancestors of the shape
522 * \retval SMESH_Hypothesis* - the first hypo passed through aFilter
524 //=======================================================================
526 const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape & aSubShape,
527 const SMESH_HypoFilter& aFilter,
528 const bool andAncestors) const
531 const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
532 list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
533 for ( ; hyp != hypList.end(); hyp++ ) {
534 const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp );
535 if ( aFilter.IsOk( h, aSubShape))
541 TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
542 for (; it.More(); it.Next() )
544 const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
545 list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
546 for ( ; hyp != hypList.end(); hyp++ ) {
547 const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp );
548 if (aFilter.IsOk( h, it.Value() ))
556 //================================================================================
558 * \brief Return hypothesis assigned to the shape
559 * \param aSubShape - the shape to check
560 * \param aFilter - the hypothesis filter
561 * \param aHypList - the list of the found hypotheses
562 * \param andAncestors - flag to check hypos assigned to ancestors of the shape
563 * \retval int - number of unique hypos in aHypList
565 //================================================================================
567 int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape,
568 const SMESH_HypoFilter& aFilter,
569 list <const SMESHDS_Hypothesis * >& aHypList,
570 const bool andAncestors) const
572 set<string> hypTypes; // to exclude same type hypos from the result list
575 // only one main hypothesis is allowed
576 bool mainHypFound = false;
579 list<const SMESHDS_Hypothesis*>::const_iterator hyp;
580 for ( hyp = aHypList.begin(); hyp != aHypList.end(); hyp++ ) {
581 if ( hypTypes.insert( (*hyp)->GetName() ).second )
583 if ( !cSMESH_Hyp(*hyp)->IsAuxiliary() )
587 // get hypos from aSubShape
589 const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
590 for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
591 if ( aFilter.IsOk (cSMESH_Hyp( *hyp ), aSubShape) &&
592 ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
593 hypTypes.insert( (*hyp)->GetName() ).second )
595 aHypList.push_back( *hyp );
597 if ( !cSMESH_Hyp(*hyp)->IsAuxiliary() )
602 // get hypos from ancestors of aSubShape
605 TopTools_MapOfShape map;
606 TopTools_ListIteratorOfListOfShape it( GetAncestors( aSubShape ));
607 for (; it.More(); it.Next() )
609 if ( !map.Add( it.Value() ))
611 const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(it.Value());
612 for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
613 if (aFilter.IsOk( cSMESH_Hyp( *hyp ), it.Value() ) &&
614 ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
615 hypTypes.insert( (*hyp)->GetName() ).second )
617 aHypList.push_back( *hyp );
619 if ( !cSMESH_Hyp(*hyp)->IsAuxiliary() )
627 //=============================================================================
631 //=============================================================================
633 const list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
635 Unexpect aCatch(SalomeException);
636 if(MYDEBUG) MESSAGE("SMESH_Mesh::GetLog");
637 return _myMeshDS->GetScript()->GetCommands();
640 //=============================================================================
644 //=============================================================================
645 void SMESH_Mesh::ClearLog() throw(SALOME_Exception)
647 Unexpect aCatch(SalomeException);
648 if(MYDEBUG) MESSAGE("SMESH_Mesh::ClearLog");
649 _myMeshDS->GetScript()->Clear();
652 //=============================================================================
656 //=============================================================================
658 int SMESH_Mesh::GetId()
660 if(MYDEBUG) MESSAGE("SMESH_Mesh::GetId");
664 //=============================================================================
668 //=============================================================================
670 SMESH_Gen *SMESH_Mesh::GetGen()
675 //=============================================================================
677 * Get or Create the SMESH_subMesh object implementation
679 //=============================================================================
681 SMESH_subMesh *SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
682 throw(SALOME_Exception)
684 Unexpect aCatch(SalomeException);
685 SMESH_subMesh *aSubMesh;
686 int index = _myMeshDS->ShapeToIndex(aSubShape);
688 // for submeshes on GEOM Group
689 if ( !index && aSubShape.ShapeType() == TopAbs_COMPOUND ) {
690 TopoDS_Iterator it( aSubShape );
692 index = _myMeshDS->AddCompoundSubmesh( aSubShape, it.Value().ShapeType() );
695 // return NULL; // neither sub-shape nor a group
697 map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.find(index);
698 if ( i_sm != _mapSubMesh.end())
700 aSubMesh = i_sm->second;
704 aSubMesh = new SMESH_subMesh(index, this, _myMeshDS, aSubShape);
705 _mapSubMesh[index] = aSubMesh;
710 //=============================================================================
712 * Get the SMESH_subMesh object implementation. Dont create it, return null
713 * if it does not exist.
715 //=============================================================================
717 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape)
718 throw(SALOME_Exception)
720 Unexpect aCatch(SalomeException);
721 SMESH_subMesh *aSubMesh = NULL;
723 int index = _myMeshDS->ShapeToIndex(aSubShape);
725 map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.find(index);
726 if ( i_sm != _mapSubMesh.end())
727 aSubMesh = i_sm->second;
732 //=============================================================================
734 * Get the SMESH_subMesh object implementation. Dont create it, return null
735 * if it does not exist.
737 //=============================================================================
739 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID)
740 throw(SALOME_Exception)
742 Unexpect aCatch(SalomeException);
744 map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.find(aShapeID);
745 if (i_sm == _mapSubMesh.end())
750 //=======================================================================
751 //function : IsUsedHypothesis
752 //purpose : Return True if anHyp is used to mesh aSubShape
753 //=======================================================================
755 bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp,
756 const SMESH_subMesh* aSubMesh)
758 SMESH_Hypothesis* hyp = static_cast<SMESH_Hypothesis*>(anHyp);
760 // check if anHyp can be used to mesh aSubMesh
761 if ( !aSubMesh || !aSubMesh->IsApplicableHypotesis( hyp ))
764 const TopoDS_Shape & aSubShape = const_cast<SMESH_subMesh*>( aSubMesh )->GetSubShape();
766 SMESH_Algo *algo = _gen->GetAlgo(*this, aSubShape );
769 if (anHyp->GetType() > SMESHDS_Hypothesis::PARAM_ALGO)
770 return ( anHyp == algo );
772 // algorithm parameter
775 // look trough hypotheses used by algo
776 SMESH_HypoFilter hypoKind;
777 if ( algo->InitCompatibleHypoFilter( hypoKind, !hyp->IsAuxiliary() )) {
778 list <const SMESHDS_Hypothesis * > usedHyps;
779 if ( GetHypotheses( aSubShape, hypoKind, usedHyps, true ))
780 return ( find( usedHyps.begin(), usedHyps.end(), anHyp ) != usedHyps.end() );
784 // look through all assigned hypotheses
785 //SMESH_HypoFilter filter( SMESH_HypoFilter::Is( hyp ));
786 return false; //GetHypothesis( aSubShape, filter, true );
789 //=============================================================================
793 //=============================================================================
795 const list < SMESH_subMesh * >&
796 SMESH_Mesh::GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp)
797 throw(SALOME_Exception)
799 Unexpect aCatch(SalomeException);
800 if(MYDEBUG) MESSAGE("SMESH_Mesh::GetSubMeshUsingHypothesis");
801 map < int, SMESH_subMesh * >::iterator itsm;
802 _subMeshesUsingHypothesisList.clear();
803 for (itsm = _mapSubMesh.begin(); itsm != _mapSubMesh.end(); itsm++)
805 SMESH_subMesh *aSubMesh = (*itsm).second;
806 if ( IsUsedHypothesis ( anHyp, aSubMesh ))
807 _subMeshesUsingHypothesisList.push_back(aSubMesh);
809 return _subMeshesUsingHypothesisList;
812 //=======================================================================
813 //function : NotifySubMeshesHypothesisModification
814 //purpose : Say all submeshes using theChangedHyp that it has been modified
815 //=======================================================================
817 void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* theChangedHyp)
819 Unexpect aCatch(SalomeException);
821 const SMESH_Hypothesis* hyp = cSMESH_Hyp(theChangedHyp);
823 const SMESH_Algo *foundAlgo = 0;
824 SMESH_HypoFilter algoKind( SMESH_HypoFilter::IsAlgo() );
825 SMESH_HypoFilter compatibleHypoKind;
826 list <const SMESHDS_Hypothesis * > usedHyps;
829 map < int, SMESH_subMesh * >::iterator itsm;
830 for (itsm = _mapSubMesh.begin(); itsm != _mapSubMesh.end(); itsm++)
832 SMESH_subMesh *aSubMesh = (*itsm).second;
833 if ( aSubMesh->IsApplicableHypotesis( hyp ))
835 const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape();
837 if ( !foundAlgo ) // init filter for algo search
838 algoKind.And( algoKind.IsApplicableTo( aSubShape ));
840 const SMESH_Algo *algo = static_cast<const SMESH_Algo*>
841 ( GetHypothesis( aSubShape, algoKind, true ));
845 bool sameAlgo = ( algo == foundAlgo );
846 if ( !sameAlgo && foundAlgo )
847 sameAlgo = ( strcmp( algo->GetName(), foundAlgo->GetName() ) == 0);
849 if ( !sameAlgo ) { // init filter for used hypos search
850 if ( !algo->InitCompatibleHypoFilter( compatibleHypoKind, !hyp->IsAuxiliary() ))
851 continue; // algo does not use any hypothesis
855 // check if hyp is used by algo
857 if ( GetHypotheses( aSubShape, compatibleHypoKind, usedHyps, true ) &&
858 find( usedHyps.begin(), usedHyps.end(), hyp ) != usedHyps.end() )
860 aSubMesh->ComputeStateEngine(SMESH_subMesh::MODIF_HYP);
862 if ( algo->GetDim() == 1 && IsPropagationHypothesis( aSubShape ))
863 CleanMeshOnPropagationChain( aSubShape );
870 //=============================================================================
872 * To store mesh contents on disk in different formats.
874 //=============================================================================
876 bool SMESH_Mesh::HasDuplicatedGroupNamesMED()
878 set<string> aGroupNames;
879 for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
880 SMESH_Group* aGroup = it->second;
881 string aGroupName = aGroup->GetName();
882 aGroupName.resize(MAX_MED_GROUP_NAME_LENGTH);
883 if (!aGroupNames.insert(aGroupName).second)
890 void SMESH_Mesh::ExportMED(const char *file,
891 const char* theMeshName,
894 throw(SALOME_Exception)
896 Unexpect aCatch(SalomeException);
898 DriverMED_W_SMESHDS_Mesh myWriter;
899 myWriter.SetFile ( file, MED::EVersion(theVersion) );
900 myWriter.SetMesh ( _myMeshDS );
902 myWriter.SetMeshId ( _idDoc );
904 myWriter.SetMeshId ( -1 );
905 myWriter.SetMeshName( theMeshName );
908 if ( theAutoGroups ) {
909 myWriter.AddGroupOfNodes();
910 myWriter.AddGroupOfEdges();
911 myWriter.AddGroupOfFaces();
912 myWriter.AddGroupOfVolumes();
915 // Pass groups to writer. Provide unique group names.
916 set<string> aGroupNames;
918 int maxNbIter = 10000; // to guarantee cycle finish
919 for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
920 SMESH_Group* aGroup = it->second;
921 SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
923 string aGroupName0 = aGroup->GetName();
924 aGroupName0.resize(MAX_MED_GROUP_NAME_LENGTH);
925 string aGroupName = aGroupName0;
926 for (int i = 1; !aGroupNames.insert(aGroupName).second && i < maxNbIter; i++) {
927 sprintf(&aString[0], "GR_%d_%s", i, aGroupName0.c_str());
928 aGroupName = aString;
929 aGroupName.resize(MAX_MED_GROUP_NAME_LENGTH);
931 aGroupDS->SetStoreName( aGroupName.c_str() );
932 myWriter.AddGroup( aGroupDS );
940 void SMESH_Mesh::ExportDAT(const char *file) throw(SALOME_Exception)
942 Unexpect aCatch(SalomeException);
943 DriverDAT_W_SMDS_Mesh myWriter;
944 myWriter.SetFile(string(file));
945 myWriter.SetMesh(_myMeshDS);
946 myWriter.SetMeshId(_idDoc);
950 void SMESH_Mesh::ExportUNV(const char *file) throw(SALOME_Exception)
952 Unexpect aCatch(SalomeException);
953 DriverUNV_W_SMDS_Mesh myWriter;
954 myWriter.SetFile(string(file));
955 myWriter.SetMesh(_myMeshDS);
956 myWriter.SetMeshId(_idDoc);
957 // myWriter.SetGroups(_mapGroup);
959 for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
960 SMESH_Group* aGroup = it->second;
961 SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
963 string aGroupName = aGroup->GetName();
964 aGroupDS->SetStoreName( aGroupName.c_str() );
965 myWriter.AddGroup( aGroupDS );
971 void SMESH_Mesh::ExportSTL(const char *file, const bool isascii) throw(SALOME_Exception)
973 Unexpect aCatch(SalomeException);
974 DriverSTL_W_SMDS_Mesh myWriter;
975 myWriter.SetFile(string(file));
976 myWriter.SetIsAscii( isascii );
977 myWriter.SetMesh(_myMeshDS);
978 myWriter.SetMeshId(_idDoc);
982 //=============================================================================
986 //=============================================================================
987 int SMESH_Mesh::NbNodes() throw(SALOME_Exception)
989 Unexpect aCatch(SalomeException);
990 return _myMeshDS->NbNodes();
993 //=============================================================================
997 //=============================================================================
998 int SMESH_Mesh::NbEdges(ElementOrder order) throw(SALOME_Exception)
1000 Unexpect aCatch(SalomeException);
1001 if (order == ORDER_ANY)
1002 return _myMeshDS->NbEdges();
1005 SMDS_EdgeIteratorPtr it = _myMeshDS->edgesIterator();
1006 while (it->more()) {
1007 const SMDS_MeshEdge* cur = it->next();
1008 if ( order == ORDER_LINEAR && !cur->IsQuadratic() ||
1009 order == ORDER_QUADRATIC && cur->IsQuadratic() )
1015 //=============================================================================
1019 //=============================================================================
1020 int SMESH_Mesh::NbFaces(ElementOrder order) throw(SALOME_Exception)
1022 Unexpect aCatch(SalomeException);
1023 if (order == ORDER_ANY)
1024 return _myMeshDS->NbFaces();
1027 SMDS_FaceIteratorPtr it = _myMeshDS->facesIterator();
1028 while (it->more()) {
1029 const SMDS_MeshFace* cur = it->next();
1030 if ( order == ORDER_LINEAR && !cur->IsQuadratic() ||
1031 order == ORDER_QUADRATIC && cur->IsQuadratic() )
1037 ///////////////////////////////////////////////////////////////////////////////
1038 /// Return the number of 3 nodes faces in the mesh. This method run in O(n)
1039 ///////////////////////////////////////////////////////////////////////////////
1040 int SMESH_Mesh::NbTriangles(ElementOrder order) throw(SALOME_Exception)
1042 Unexpect aCatch(SalomeException);
1045 SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
1046 while (itFaces->more()) {
1047 const SMDS_MeshFace* curFace = itFaces->next();
1048 int nbnod = curFace->NbNodes();
1049 if ( !curFace->IsPoly() &&
1050 ( order == ORDER_ANY && (nbnod==3 || nbnod==6) ||
1051 order == ORDER_LINEAR && nbnod==3 ||
1052 order == ORDER_QUADRATIC && nbnod==6 ) )
1058 ///////////////////////////////////////////////////////////////////////////////
1059 /// Return the number of 4 nodes faces in the mesh. This method run in O(n)
1060 ///////////////////////////////////////////////////////////////////////////////
1061 int SMESH_Mesh::NbQuadrangles(ElementOrder order) throw(SALOME_Exception)
1063 Unexpect aCatch(SalomeException);
1066 SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
1067 while (itFaces->more()) {
1068 const SMDS_MeshFace* curFace = itFaces->next();
1069 int nbnod = curFace->NbNodes();
1070 if ( !curFace->IsPoly() &&
1071 ( order == ORDER_ANY && (nbnod==4 || nbnod==8) ||
1072 order == ORDER_LINEAR && nbnod==4 ||
1073 order == ORDER_QUADRATIC && nbnod==8 ) )
1079 ///////////////////////////////////////////////////////////////////////////////
1080 /// Return the number of polygonal faces in the mesh. This method run in O(n)
1081 ///////////////////////////////////////////////////////////////////////////////
1082 int SMESH_Mesh::NbPolygons() throw(SALOME_Exception)
1084 Unexpect aCatch(SalomeException);
1086 SMDS_FaceIteratorPtr itFaces = _myMeshDS->facesIterator();
1087 while (itFaces->more())
1088 if (itFaces->next()->IsPoly()) Nb++;
1092 //=============================================================================
1096 //=============================================================================
1097 int SMESH_Mesh::NbVolumes(ElementOrder order) throw(SALOME_Exception)
1099 Unexpect aCatch(SalomeException);
1100 if (order == ORDER_ANY)
1101 return _myMeshDS->NbVolumes();
1104 SMDS_VolumeIteratorPtr it = _myMeshDS->volumesIterator();
1105 while (it->more()) {
1106 const SMDS_MeshVolume* cur = it->next();
1107 if ( order == ORDER_LINEAR && !cur->IsQuadratic() ||
1108 order == ORDER_QUADRATIC && cur->IsQuadratic() )
1114 int SMESH_Mesh::NbTetras(ElementOrder order) throw(SALOME_Exception)
1116 Unexpect aCatch(SalomeException);
1118 SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1119 while (itVolumes->more()) {
1120 const SMDS_MeshVolume* curVolume = itVolumes->next();
1121 int nbnod = curVolume->NbNodes();
1122 if ( !curVolume->IsPoly() &&
1123 ( order == ORDER_ANY && (nbnod==4 || nbnod==10) ||
1124 order == ORDER_LINEAR && nbnod==4 ||
1125 order == ORDER_QUADRATIC && nbnod==10 ) )
1131 int SMESH_Mesh::NbHexas(ElementOrder order) throw(SALOME_Exception)
1133 Unexpect aCatch(SalomeException);
1135 SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1136 while (itVolumes->more()) {
1137 const SMDS_MeshVolume* curVolume = itVolumes->next();
1138 int nbnod = curVolume->NbNodes();
1139 if ( !curVolume->IsPoly() &&
1140 ( order == ORDER_ANY && (nbnod==8 || nbnod==20) ||
1141 order == ORDER_LINEAR && nbnod==8 ||
1142 order == ORDER_QUADRATIC && nbnod==20 ) )
1148 int SMESH_Mesh::NbPyramids(ElementOrder order) throw(SALOME_Exception)
1150 Unexpect aCatch(SalomeException);
1152 SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1153 while (itVolumes->more()) {
1154 const SMDS_MeshVolume* curVolume = itVolumes->next();
1155 int nbnod = curVolume->NbNodes();
1156 if ( !curVolume->IsPoly() &&
1157 ( order == ORDER_ANY && (nbnod==5 || nbnod==13) ||
1158 order == ORDER_LINEAR && nbnod==5 ||
1159 order == ORDER_QUADRATIC && nbnod==13 ) )
1165 int SMESH_Mesh::NbPrisms(ElementOrder order) throw(SALOME_Exception)
1167 Unexpect aCatch(SalomeException);
1169 SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1170 while (itVolumes->more()) {
1171 const SMDS_MeshVolume* curVolume = itVolumes->next();
1172 int nbnod = curVolume->NbNodes();
1173 if ( !curVolume->IsPoly() &&
1174 ( order == ORDER_ANY && (nbnod==6 || nbnod==15) ||
1175 order == ORDER_LINEAR && nbnod==6 ||
1176 order == ORDER_QUADRATIC && nbnod==15 ) )
1182 int SMESH_Mesh::NbPolyhedrons() throw(SALOME_Exception)
1184 Unexpect aCatch(SalomeException);
1186 SMDS_VolumeIteratorPtr itVolumes = _myMeshDS->volumesIterator();
1187 while (itVolumes->more())
1188 if (itVolumes->next()->IsPoly()) Nb++;
1192 //=============================================================================
1196 //=============================================================================
1197 int SMESH_Mesh::NbSubMesh() throw(SALOME_Exception)
1199 Unexpect aCatch(SalomeException);
1200 return _myMeshDS->NbSubMesh();
1203 //=======================================================================
1204 //function : IsNotConformAllowed
1205 //purpose : check if a hypothesis alowing notconform mesh is present
1206 //=======================================================================
1208 bool SMESH_Mesh::IsNotConformAllowed() const
1210 if(MYDEBUG) MESSAGE("SMESH_Mesh::IsNotConformAllowed");
1212 SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "NotConformAllowed" ));
1213 return GetHypothesis( _myMeshDS->ShapeToMesh(), filter, false );
1216 //=======================================================================
1217 //function : IsMainShape
1219 //=======================================================================
1221 bool SMESH_Mesh::IsMainShape(const TopoDS_Shape& theShape) const
1223 return theShape.IsSame(_myMeshDS->ShapeToMesh() );
1226 //=============================================================================
1230 //=============================================================================
1232 SMESH_Group* SMESH_Mesh::AddGroup (const SMDSAbs_ElementType theType,
1233 const char* theName,
1235 const TopoDS_Shape& theShape)
1237 if (_mapGroup.find(_groupId) != _mapGroup.end())
1240 SMESH_Group* aGroup = new SMESH_Group (theId, this, theType, theName, theShape);
1241 GetMeshDS()->AddGroup( aGroup->GetGroupDS() );
1242 _mapGroup[_groupId++] = aGroup;
1246 //=============================================================================
1250 //=============================================================================
1252 SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID)
1254 if (_mapGroup.find(theGroupID) == _mapGroup.end())
1256 return _mapGroup[theGroupID];
1260 //=============================================================================
1264 //=============================================================================
1266 list<int> SMESH_Mesh::GetGroupIds()
1269 for ( map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
1270 anIds.push_back( it->first );
1276 //=============================================================================
1280 //=============================================================================
1282 void SMESH_Mesh::RemoveGroup (const int theGroupID)
1284 if (_mapGroup.find(theGroupID) == _mapGroup.end())
1286 GetMeshDS()->RemoveGroup( _mapGroup[theGroupID]->GetGroupDS() );
1287 delete _mapGroup[theGroupID];
1288 _mapGroup.erase (theGroupID);
1291 //=============================================================================
1293 * IsLocal1DHypothesis
1294 * Returns a local 1D hypothesis used for theEdge
1296 //=============================================================================
1297 const SMESH_Hypothesis* SMESH_Mesh::IsLocal1DHypothesis (const TopoDS_Shape& theEdge)
1299 SMESH_HypoFilter hypo ( SMESH_HypoFilter::HasDim( 1 ));
1300 hypo.AndNot( hypo.IsAlgo() ).AndNot( hypo.IsAssignedTo( GetMeshDS()->ShapeToMesh() ));
1302 return GetHypothesis( theEdge, hypo, true );
1305 //=============================================================================
1307 * IsPropagationHypothesis
1309 //=============================================================================
1310 bool SMESH_Mesh::IsPropagationHypothesis (const TopoDS_Shape& theEdge)
1312 return _mapPropagationChains.Contains(theEdge);
1315 //=============================================================================
1317 * IsPropagatedHypothesis
1319 //=============================================================================
1320 bool SMESH_Mesh::IsPropagatedHypothesis (const TopoDS_Shape& theEdge,
1321 TopoDS_Shape& theMainEdge)
1323 int nbChains = _mapPropagationChains.Extent();
1324 for (int i = 1; i <= nbChains; i++) {
1325 //const TopTools_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromIndex(i);
1326 const SMESH_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromIndex(i);
1327 if (aChain.Contains(theEdge)) {
1328 theMainEdge = _mapPropagationChains.FindKey(i);
1335 //=============================================================================
1339 //=============================================================================
1341 bool SMESH_Mesh::IsReversedInChain (const TopoDS_Shape& theEdge,
1342 const TopoDS_Shape& theMainEdge)
1344 if ( !theMainEdge.IsNull() && !theEdge.IsNull() &&
1345 _mapPropagationChains.Contains( theMainEdge ))
1347 const SMESH_IndexedMapOfShape& aChain =
1348 _mapPropagationChains.FindFromKey( theMainEdge );
1349 int index = aChain.FindIndex( theEdge );
1351 return aChain(index).Orientation() == TopAbs_REVERSED;
1356 //=============================================================================
1358 * CleanMeshOnPropagationChain
1360 //=============================================================================
1361 void SMESH_Mesh::CleanMeshOnPropagationChain (const TopoDS_Shape& theMainEdge)
1363 const SMESH_IndexedMapOfShape& aChain = _mapPropagationChains.FindFromKey(theMainEdge);
1364 int i, nbEdges = aChain.Extent();
1365 for (i = 1; i <= nbEdges; i++) {
1366 TopoDS_Shape anEdge = aChain.FindKey(i);
1367 SMESH_subMesh *subMesh = GetSubMesh(anEdge);
1368 SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
1369 if (subMeshDS && subMeshDS->NbElements() > 0) {
1370 subMesh->ComputeStateEngine(SMESH_subMesh::CLEAN);
1375 //=============================================================================
1377 * RebuildPropagationChains
1378 * Rebuild all existing propagation chains.
1379 * Have to be used, if 1D hypothesis have been assigned/removed to/from any edge
1381 //=============================================================================
1382 bool SMESH_Mesh::RebuildPropagationChains()
1386 // Clean all chains, because they can be not up-to-date
1387 int i, nbChains = _mapPropagationChains.Extent();
1388 for (i = 1; i <= nbChains; i++) {
1389 TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
1390 CleanMeshOnPropagationChain(aMainEdge);
1391 _mapPropagationChains.ChangeFromIndex(i).Clear();
1395 for (i = 1; i <= nbChains; i++) {
1396 TopoDS_Shape aMainEdge = _mapPropagationChains.FindKey(i);
1397 if (!BuildPropagationChain(aMainEdge))
1399 CleanMeshOnPropagationChain(aMainEdge);
1405 //=============================================================================
1407 * RemovePropagationChain
1408 * Have to be used, if Propagation hypothesis is removed from <theMainEdge>
1410 //=============================================================================
1411 bool SMESH_Mesh::RemovePropagationChain (const TopoDS_Shape& theMainEdge)
1413 if (!_mapPropagationChains.Contains(theMainEdge))
1416 // Clean mesh elements and nodes, built on the chain
1417 CleanMeshOnPropagationChain(theMainEdge);
1420 _mapPropagationChains.ChangeFromKey(theMainEdge).Clear();
1422 // Remove the chain from the map
1423 int i = _mapPropagationChains.FindIndex(theMainEdge);
1424 if ( i == _mapPropagationChains.Extent() )
1425 _mapPropagationChains.RemoveLast();
1427 TopoDS_Vertex anEmptyShape;
1429 BB.MakeVertex(anEmptyShape, gp_Pnt(0,0,0), 0.1);
1430 SMESH_IndexedMapOfShape anEmptyMap;
1431 _mapPropagationChains.Substitute(i, anEmptyShape, anEmptyMap);
1437 //=============================================================================
1439 * BuildPropagationChain
1441 //=============================================================================
1442 bool SMESH_Mesh::BuildPropagationChain (const TopoDS_Shape& theMainEdge)
1444 if (theMainEdge.ShapeType() != TopAbs_EDGE) return true;
1446 // Add new chain, if there is no
1447 if (!_mapPropagationChains.Contains(theMainEdge)) {
1448 SMESH_IndexedMapOfShape aNewChain;
1449 _mapPropagationChains.Add(theMainEdge, aNewChain);
1452 // Check presence of 1D hypothesis to be propagated
1453 const SMESH_Hypothesis* aMainHyp = IsLocal1DHypothesis(theMainEdge);
1455 MESSAGE("Warning: There is no 1D hypothesis to propagate. Please, assign.");
1459 // Edges, on which the 1D hypothesis will be propagated from <theMainEdge>
1460 SMESH_IndexedMapOfShape& aChain = _mapPropagationChains.ChangeFromKey(theMainEdge);
1461 if (aChain.Extent() > 0) {
1462 CleanMeshOnPropagationChain(theMainEdge);
1466 // At first put <theMainEdge> in the chain
1467 aChain.Add(theMainEdge);
1469 // List of edges, added to chain on the previous cycle pass
1470 TopTools_ListOfShape listPrevEdges;
1471 listPrevEdges.Append(theMainEdge.Oriented( TopAbs_FORWARD ));
1473 // 5____4____3____4____5____6
1476 // 4____3____2____3____4____5
1477 // | | | | | | Number in the each knot of
1478 // | | | | | | grid indicates cycle pass,
1479 // 3____2____1____2____3____4 on which corresponding edge
1480 // | | | | | | (perpendicular to the plane
1481 // | | | | | | of view) will be found.
1482 // 2____1____0____1____2____3
1485 // 3____2____1____2____3____4
1487 // Collect all edges pass by pass
1488 while (listPrevEdges.Extent() > 0) {
1489 // List of edges, added to chain on this cycle pass
1490 TopTools_ListOfShape listCurEdges;
1492 // Find the next portion of edges
1493 TopTools_ListIteratorOfListOfShape itE (listPrevEdges);
1494 for (; itE.More(); itE.Next()) {
1495 TopoDS_Shape anE = itE.Value();
1497 // Iterate on faces, having edge <anE>
1498 TopTools_ListIteratorOfListOfShape itA (GetAncestors(anE));
1499 for (; itA.More(); itA.Next()) {
1500 TopoDS_Shape aW = itA.Value();
1502 // There are objects of different type among the ancestors of edge
1503 if (aW.ShapeType() == TopAbs_WIRE) {
1504 TopoDS_Shape anOppE;
1506 BRepTools_WireExplorer aWE (TopoDS::Wire(aW));
1507 Standard_Integer nb = 1, found = 0;
1508 TopTools_Array1OfShape anEdges (1,4);
1509 for (; aWE.More(); aWE.Next(), nb++) {
1514 anEdges(nb) = aWE.Current();
1515 if (!_mapAncestors.Contains(anEdges(nb))) {
1516 MESSAGE("WIRE EXPLORER HAVE GIVEN AN INVALID EDGE !!!");
1519 if (anEdges(nb).IsSame(anE)) found = nb;
1522 if (nb == 5 && found > 0) {
1523 // Quadrangle face found, get an opposite edge
1524 Standard_Integer opp = found + 2;
1525 if (opp > 4) opp -= 4;
1526 anOppE = anEdges(opp);
1528 // add anOppE to aChain if ...
1529 if (!aChain.Contains(anOppE)) { // ... anOppE is not in aChain
1530 if (!IsLocal1DHypothesis(anOppE)) { // ... no other 1d hyp on anOppE
1531 TopoDS_Shape aMainEdgeForOppEdge; // ... no other hyp is propagated to anOppE
1532 if (!IsPropagatedHypothesis(anOppE, aMainEdgeForOppEdge))
1534 // Add found edge to the chain oriented so that to
1535 // have it co-directed with a forward MainEdge
1536 TopAbs_Orientation ori = anE.Orientation();
1537 if ( anEdges(opp).Orientation() == anEdges(found).Orientation() )
1538 ori = TopAbs::Reverse( ori );
1539 anOppE.Orientation( ori );
1541 listCurEdges.Append(anOppE);
1545 MESSAGE("Error: Collision between propagated hypotheses");
1546 CleanMeshOnPropagationChain(theMainEdge);
1548 return ( aMainHyp == IsLocal1DHypothesis(aMainEdgeForOppEdge) );
1552 } // if (nb == 5 && found > 0)
1553 } // if (aF.ShapeType() == TopAbs_WIRE)
1554 } // for (; itF.More(); itF.Next())
1555 } // for (; itE.More(); itE.Next())
1557 listPrevEdges = listCurEdges;
1558 } // while (listPrevEdges.Extent() > 0)
1560 CleanMeshOnPropagationChain(theMainEdge);
1564 //=======================================================================
1565 //function : GetAncestors
1566 //purpose : return list of ancestors of theSubShape in the order
1567 // that lower dimention shapes come first.
1568 //=======================================================================
1570 const TopTools_ListOfShape& SMESH_Mesh::GetAncestors(const TopoDS_Shape& theS) const
1572 if ( _mapAncestors.Contains( theS ) )
1573 return _mapAncestors.FindFromKey( theS );
1575 static TopTools_ListOfShape emptyList;
1579 //=======================================================================
1581 //purpose : dumps contents of mesh to stream [ debug purposes ]
1582 //=======================================================================
1583 ostream& SMESH_Mesh::Dump(ostream& save)
1586 save << "========================== Dump contents of mesh ==========================" << endl << endl;
1587 save << ++clause << ") Total number of nodes: \t" << NbNodes() << endl;
1588 save << ++clause << ") Total number of edges: \t" << NbEdges() << endl;
1589 save << ++clause << ") Total number of faces: \t" << NbFaces() << endl;
1590 save << ++clause << ") Total number of polygons:\t" << NbPolygons() << endl;
1591 save << ++clause << ") Total number of volumes:\t" << NbVolumes() << endl;
1592 save << ++clause << ") Total number of polyhedrons:\t" << NbPolyhedrons() << endl << endl;
1593 for ( int isQuadratic = 0; isQuadratic < 2; ++isQuadratic )
1595 string orderStr = isQuadratic ? "quadratic" : "linear";
1596 ElementOrder order = isQuadratic ? ORDER_QUADRATIC : ORDER_LINEAR;
1598 save << ++clause << ") Total number of " << orderStr << " edges:\t" << NbEdges(order) << endl;
1599 save << ++clause << ") Total number of " << orderStr << " faces:\t" << NbFaces(order) << endl;
1600 if ( NbFaces(order) > 0 ) {
1601 int nb3 = NbTriangles(order);
1602 int nb4 = NbQuadrangles(order);
1603 save << clause << ".1) Number of " << orderStr << " triangles: \t" << nb3 << endl;
1604 save << clause << ".2) Number of " << orderStr << " quadrangles:\t" << nb4 << endl;
1605 if ( nb3 + nb4 != NbFaces(order) ) {
1606 map<int,int> myFaceMap;
1607 SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
1608 while( itFaces->more( ) ) {
1609 int nbNodes = itFaces->next()->NbNodes();
1610 if ( myFaceMap.find( nbNodes ) == myFaceMap.end() )
1611 myFaceMap[ nbNodes ] = 0;
1612 myFaceMap[ nbNodes ] = myFaceMap[ nbNodes ] + 1;
1614 save << clause << ".3) Faces in detail: " << endl;
1615 map <int,int>::iterator itF;
1616 for (itF = myFaceMap.begin(); itF != myFaceMap.end(); itF++)
1617 save << "--> nb nodes: " << itF->first << " - nb elemens:\t" << itF->second << endl;
1620 save << ++clause << ") Total number of " << orderStr << " volumes:\t" << NbVolumes(order) << endl;
1621 if ( NbVolumes(order) > 0 ) {
1622 int nb8 = NbHexas(order);
1623 int nb4 = NbTetras(order);
1624 int nb5 = NbPyramids(order);
1625 int nb6 = NbPrisms(order);
1626 save << clause << ".1) Number of " << orderStr << " hexahedrons:\t" << nb8 << endl;
1627 save << clause << ".2) Number of " << orderStr << " tetrahedrons:\t" << nb4 << endl;
1628 save << clause << ".3) Number of " << orderStr << " prisms: \t" << nb6 << endl;
1629 save << clause << ".4) Number of " << orderStr << " pyramids:\t" << nb5 << endl;
1630 if ( nb8 + nb4 + nb5 + nb6 != NbVolumes(order) ) {
1631 map<int,int> myVolumesMap;
1632 SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
1633 while( itVolumes->more( ) ) {
1634 int nbNodes = itVolumes->next()->NbNodes();
1635 if ( myVolumesMap.find( nbNodes ) == myVolumesMap.end() )
1636 myVolumesMap[ nbNodes ] = 0;
1637 myVolumesMap[ nbNodes ] = myVolumesMap[ nbNodes ] + 1;
1639 save << clause << ".5) Volumes in detail: " << endl;
1640 map <int,int>::iterator itV;
1641 for (itV = myVolumesMap.begin(); itV != myVolumesMap.end(); itV++)
1642 save << "--> nb nodes: " << itV->first << " - nb elemens:\t" << itV->second << endl;
1647 save << "===========================================================================" << endl;
1651 //=======================================================================
1652 //function : GetElementType
1653 //purpose : Returns type of mesh element with certain id
1654 //=======================================================================
1655 SMDSAbs_ElementType SMESH_Mesh::GetElementType( const int id, const bool iselem )
1657 return _myMeshDS->GetElementType( id, iselem );