PAL11200, 11544. optimize a little

src/SMESH/SMESH_Gen.cxx

@@ -702,37 +702,20 @@ void SMESH_Gen::Close(int studyId)
 
 int SMESH_Gen::GetShapeDim(const TopAbs_ShapeEnum & aShapeType)
 {
-	int shapeDim = -1;			// Shape dimension: 0D, 1D, 2D, 3D
+  static vector<int> dim;
-	int type = aShapeType;//.ShapeType();
+  if ( dim.empty() )
-	switch (type)
+  {
-	{
+    dim.resize( TopAbs_SHAPE, -1 );
-	case TopAbs_COMPOUND:
+    dim[ TopAbs_COMPOUND ]  = 3;
-	case TopAbs_COMPSOLID:
+    dim[ TopAbs_COMPSOLID ] = 3;
-	case TopAbs_SOLID:
+    dim[ TopAbs_SOLID ]     = 3;
-	case TopAbs_SHELL:
+    dim[ TopAbs_SHELL ]     = 3;
-	{
+    dim[ TopAbs_FACE  ]     = 2;
-		shapeDim = 3;
+    dim[ TopAbs_WIRE ]      = 1;
-		break;
+    dim[ TopAbs_EDGE ]      = 1;
-	}
+    dim[ TopAbs_VERTEX ]    = 0;
-		//    case TopAbs_SHELL:
+  }
-	case TopAbs_FACE:
+  return dim[ aShapeType ];
-	{
-		shapeDim = 2;
-		break;
-	}
-	case TopAbs_WIRE:
-	case TopAbs_EDGE:
-	{
-		shapeDim = 1;
-		break;
-	}
-	case TopAbs_VERTEX:
-	{
-		shapeDim = 0;
-		break;
-	}
-	}
-	return shapeDim;
 }
 
 //=============================================================================

src/SMESH/SMESH_Mesh.cxx

@@ -149,7 +149,7 @@ void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape)
   // fill _mapAncestors
   _mapAncestors.Clear();
   int desType, ancType;
-  for ( desType = TopAbs_EDGE; desType > TopAbs_COMPOUND; desType-- )
+  for ( desType = TopAbs_VERTEX; desType > TopAbs_COMPOUND; desType-- )
     for ( ancType = desType - 1; ancType >= TopAbs_COMPOUND; ancType-- )
       TopExp::MapShapesAndAncestors ( aShape,
                                      (TopAbs_ShapeEnum) desType,
@@ -616,12 +616,12 @@ SMESH_Gen *SMESH_Mesh::GetGen()
 //=============================================================================
 
 SMESH_subMesh *SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
-throw(SALOME_Exception)
+  throw(SALOME_Exception)
 {
   Unexpect aCatch(SalomeException);
   SMESH_subMesh *aSubMesh;
   int index = _myMeshDS->ShapeToIndex(aSubShape);
-  
+
   // for submeshes on GEOM Group
   if ( !index && aSubShape.ShapeType() == TopAbs_COMPOUND ) {
     TopoDS_Iterator it( aSubShape );
@@ -629,15 +629,16 @@ throw(SALOME_Exception)
       index = _myMeshDS->AddCompoundSubmesh( aSubShape, it.Value().ShapeType() );
   }
 
-  if (_mapSubMesh.find(index) != _mapSubMesh.end())
+  map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.find(index);
-    {
+  if ( i_sm != _mapSubMesh.end())
-      aSubMesh = _mapSubMesh[index];
+  {
-    }
+    aSubMesh = i_sm->second;
+  }
   else
-    {
+  {
-      aSubMesh = new SMESH_subMesh(index, this, _myMeshDS, aSubShape);
+    aSubMesh = new SMESH_subMesh(index, this, _myMeshDS, aSubShape);
-      _mapSubMesh[index] = aSubMesh;
+    _mapSubMesh[index] = aSubMesh;
-    }
+  }
   return aSubMesh;
 }
 
@@ -649,20 +650,17 @@ throw(SALOME_Exception)
 //=============================================================================
 
 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape)
-throw(SALOME_Exception)
+  throw(SALOME_Exception)
 {
   Unexpect aCatch(SalomeException);
-  bool isFound = false;
   SMESH_subMesh *aSubMesh = NULL;
   
   int index = _myMeshDS->ShapeToIndex(aSubShape);
-  if (_mapSubMesh.find(index) != _mapSubMesh.end())
+
-    {
+  map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.find(index);
-      aSubMesh = _mapSubMesh[index];
+  if ( i_sm != _mapSubMesh.end())
-      isFound = true;
+    aSubMesh = i_sm->second;
-    }
+
-  if (!isFound)
-    aSubMesh = NULL;
   return aSubMesh;
 }
 
@@ -1152,7 +1150,7 @@ void SMESH_Mesh::CleanMeshOnPropagationChain (const TopoDS_Shape& theMainEdge)
     SMESH_subMesh *subMesh = GetSubMesh(anEdge);
     SMESHDS_SubMesh *subMeshDS = subMesh->GetSubMeshDS();
     if (subMeshDS && subMeshDS->NbElements() > 0) {
-      subMesh->ComputeStateEngine(SMESH_subMesh::CLEANDEP);
+      subMesh->ComputeStateEngine(SMESH_subMesh::CLEAN);
     }
   }
 }

src/SMESH/SMESH_Pattern.cxx

@@ -3505,7 +3505,7 @@ void SMESH_Pattern::clearMesh(SMESH_Mesh* theMesh) const
   {
     if ( SMESH_subMesh * aSubMesh = theMesh->GetSubMesh/*Containing*/( myShape ))
     {
-      aSubMesh->ComputeStateEngine( SMESH_subMesh::CLEANDEP );
+      aSubMesh->ComputeStateEngine( SMESH_subMesh::CLEAN );
     }
     else {
       SMESHDS_Mesh* aMeshDS = theMesh->GetMeshDS();

src/SMESH/SMESH_subMesh.cxx

@@ -53,6 +53,9 @@ using namespace std;
 #include <TopTools_IndexedMapOfShape.hxx>
 #endif
 
+#include <Standard_Failure.hxx>
+#include <Standard_ErrorHandler.hxx>
+
 //=============================================================================
 /*!
  *  default constructor:
@@ -76,8 +79,8 @@ SMESH_subMesh::SMESH_subMesh(int Id, SMESH_Mesh * father, SMESHDS_Mesh * meshDS,
 	}
 	else
 	{
-		_algoState = NO_ALGO;
+          _algoState = NO_ALGO;
-		_computeState = NOT_READY;
+          _computeState = NOT_READY;
 	}
 }
 
@@ -89,8 +92,8 @@ SMESH_subMesh::SMESH_subMesh(int Id, SMESH_Mesh * father, SMESHDS_Mesh * meshDS,
 
 SMESH_subMesh::~SMESH_subMesh()
 {
-	MESSAGE("SMESH_subMesh::~SMESH_subMesh");
+  MESSAGE("SMESH_subMesh::~SMESH_subMesh");
-	// ****
+  // ****
 }
 
 //=============================================================================
@@ -101,8 +104,8 @@ SMESH_subMesh::~SMESH_subMesh()
 
 int SMESH_subMesh::GetId() const
 {
-	//MESSAGE("SMESH_subMesh::GetId");
+  //MESSAGE("SMESH_subMesh::GetId");
-	return _Id;
+  return _Id;
 }
 
 //=============================================================================
@@ -113,19 +116,16 @@ int SMESH_subMesh::GetId() const
 
 SMESHDS_SubMesh * SMESH_subMesh::GetSubMeshDS()
 {
-	//MESSAGE("SMESH_subMesh::GetSubMeshDS");
+  // submesh appears in DS only when a mesher set nodes and elements on it
-	if (_subMeshDS==NULL)
+  if (_subMeshDS==NULL)
-	{
+  {
-		//MESSAGE("subMesh pointer still null, trying to get it...");
+    _subMeshDS = _meshDS->MeshElements(_subShape);	// may be null ...
-		_subMeshDS = _meshDS->MeshElements(_subShape);	// may be null ...
+//     if (_subMeshDS==NULL)
-		if (_subMeshDS==NULL)
+//     {
-		{
+//       MESSAGE("problem... subMesh still empty");
-			MESSAGE("problem... subMesh still empty");
+//     }
-			//NRI   ASSERT(0);
+  }
-			//NRI   throw SALOME_Exception(LOCALIZED(subMesh still empty));
+  return _subMeshDS;
-		}
-	}
-	return _subMeshDS;
 }
 
 //=============================================================================
@@ -150,7 +150,6 @@ SMESHDS_SubMesh* SMESH_subMesh::CreateSubMeshDS()
 
 SMESH_subMesh *SMESH_subMesh::GetFirstToCompute()
 {
-  //MESSAGE("SMESH_subMesh::GetFirstToCompute");
   const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
   SMESH_subMesh *firstToCompute = 0;
 
@@ -158,13 +157,10 @@ SMESH_subMesh *SMESH_subMesh::GetFirstToCompute()
   for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
   {
     SMESH_subMesh *sm = (*itsub).second;
-    //       SCRUTE(sm->GetId());
-    //       SCRUTE(sm->GetComputeState());
     bool readyToCompute = (sm->GetComputeState() == READY_TO_COMPUTE);
     if (readyToCompute)
     {
       firstToCompute = sm;
-      //SCRUTE(sm->GetId());
       break;
     }
   }
@@ -423,20 +419,12 @@ void SMESH_subMesh::InsertDependence(const TopoDS_Shape aSubShape)
   int ordType = 9 - type;               // 2 = Vertex, 8 = CompSolid
   int cle = aSubMesh->GetId();
   cle += 10000000 * ordType;    // sort map by ordType then index
-  if (_mapDepend.find(cle) == _mapDepend.end())
+  if ( _mapDepend.find( cle ) == _mapDepend.end())
   {
     _mapDepend[cle] = aSubMesh;
-    const map < int, SMESH_subMesh * >&subMap = aSubMesh->DependsOn();
+    const map < int, SMESH_subMesh * > & subMap = aSubMesh->DependsOn();
-    map < int, SMESH_subMesh * >::const_iterator im;
+    _mapDepend.insert( subMap.begin(), subMap.end() );
-    for (im = subMap.begin(); im != subMap.end(); im++)
-    {
-      int clesub = (*im).first;
-      SMESH_subMesh *sm = (*im).second;
-      if (_mapDepend.find(clesub) == _mapDepend.end())
-        _mapDepend[clesub] = sm;
-    }
   }
-
 }
 
 //=============================================================================
@@ -483,20 +471,18 @@ bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
     return ( theHypothesis->GetShapeType() & (1<< theShapeType));
 
   // hypothesis
-  int aShapeDim = 100;
   switch ( theShapeType ) {
-  case TopAbs_EDGE: aShapeDim = 1; break;
+  case TopAbs_EDGE: 
-  case TopAbs_FACE: aShapeDim = 2; break;
+  case TopAbs_FACE: 
-  case TopAbs_SHELL:aShapeDim = 3; break;
+  case TopAbs_SHELL:
-  case TopAbs_SOLID:aShapeDim = 3; break;
+  case TopAbs_SOLID:
-//   case TopAbs_VERTEX:
+    return SMESH_Gen::GetShapeDim( theShapeType ) == theHypothesis->GetDim();
 //   case TopAbs_WIRE:
 //   case TopAbs_COMPSOLID:
 //   case TopAbs_COMPOUND:
-  default:  return false;
+  default:;
   }
-
+  return false;
-  return ( theHypothesis->GetDim() == aShapeDim );
 }
 
 //=============================================================================
@@ -1000,9 +986,7 @@ bool SMESH_subMesh::IsConform(const SMESH_Algo* theAlgo)
 
 void SMESH_subMesh::SetAlgoState(int state)
 {
-//	if (state != _oldAlgoState)
+  _algoState = state;
-//     int retc = ComputeStateEngine(MODIF_ALGO_STATE);
-		_algoState = state;
 }
 
 //=============================================================================
@@ -1018,7 +1002,7 @@ SMESH_Hypothesis::Hypothesis_Status
   SMESH_Hypothesis::Hypothesis_Status ret = SMESH_Hypothesis::HYP_OK;
   //EAP: a wire (dim==1) should notify edges (dim==1)
   //EAP: int dim = SMESH_Gen::GetShapeDim(_subShape);
-  if (/*EAP:dim > 1*/ _subShape.ShapeType() < TopAbs_EDGE )
+  if (_subShape.ShapeType() < TopAbs_EDGE ) // wire,face etc
   {
     const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
 
@@ -1043,7 +1027,7 @@ SMESH_Hypothesis::Hypothesis_Status
 
 void SMESH_subMesh::CleanDependsOn()
 {
-	MESSAGE("SMESH_subMesh::CleanDependsOn");
+  //MESSAGE("SMESH_subMesh::CleanDependsOn");
 	// **** parcourir les ancetres dans l'ordre de dépendance
 
 	ComputeStateEngine(CLEAN);
@@ -1109,33 +1093,35 @@ void SMESH_subMesh::DumpAlgoState(bool isMain)
 	}
 }
 
-//=============================================================================
+//================================================================================
 /*!
- *
+ * \brief Remove nodes and elements bound to submesh
+  * \param subMesh - submesh containing nodes and elements
  */
-//=============================================================================
+//================================================================================
 
-static void removeSubMesh( SMESHDS_Mesh * meshDS, const TopoDS_Shape& subShape)
+static void cleanSubMesh( SMESH_subMesh * subMesh )
 {
-  SMESHDS_SubMesh * subMeshDS = meshDS->MeshElements(subShape);
+  if ( subMesh )
-  if (subMeshDS!=NULL)
+    if (SMESHDS_SubMesh * subMeshDS = subMesh->GetSubMeshDS())
-  {
-    SMDS_ElemIteratorPtr ite=subMeshDS->GetElements();
-    while(ite->more())
     {
-      const SMDS_MeshElement * elt = ite->next();
+      SMESHDS_Mesh * meshDS = subMesh->GetFather()->GetMeshDS();
-      //MESSAGE( " RM elt: "<<elt->GetID()<<" ( "<<elt->NbNodes()<<" )" );
+      SMDS_ElemIteratorPtr ite=subMeshDS->GetElements();
-      meshDS->RemoveElement(elt);
+      while(ite->more())
-    }
+      {
+        const SMDS_MeshElement * elt = ite->next();
+        //MESSAGE( " RM elt: "<<elt->GetID()<<" ( "<<elt->NbNodes()<<" )" );
+        meshDS->RemoveElement(elt);
+      }
 
-    SMDS_NodeIteratorPtr itn=subMeshDS->GetNodes();
+      SMDS_NodeIteratorPtr itn=subMeshDS->GetNodes();
-    while(itn->more())
+      while(itn->more())
-    {
+      {
-      const SMDS_MeshNode * node = itn->next();
+        const SMDS_MeshNode * node = itn->next();
-      //MESSAGE( " RM node: "<<node->GetID());
+        //MESSAGE( " RM node: "<<node->GetID());
-      meshDS->RemoveNode(node);
+        meshDS->RemoveNode(node);
+      }
     }
-  }
 }
 
 //=============================================================================
@@ -1185,7 +1171,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
       break;
     case CLEAN:
       RemoveSubMeshElementsAndNodes();
-      break;
+      //break; submeshes dependent on me should be cleaned as well
     case CLEANDEP:
       CleanDependants();
       break;
@@ -1245,13 +1231,17 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
         }
         // compute
         CleanDependants();
-        //RemoveSubMeshElementsAndNodes();
+        RemoveSubMeshElementsAndNodes();
-        //removeSubMesh( _meshDS, _subShape );
+        try {
-        if (!algo->NeedDescretBoundary() && !algo->OnlyUnaryInput())
+          if (!algo->NeedDescretBoundary() && !algo->OnlyUnaryInput())
-          ret = ApplyToCollection( algo, GetCollection( gen, algo ) );
+            ret = ApplyToCollection( algo, GetCollection( gen, algo ) );
-        else
+          else
-          ret = algo->Compute((*_father), _subShape);
+            ret = algo->Compute((*_father), _subShape);
-
+        }
+        catch (Standard_Failure) {
+          MESSAGE( "Exception in algo->Compute() ");
+          ret = false;
+        }
         if (!ret)
         {
           MESSAGE("problem in algo execution: failed to compute");
@@ -1289,7 +1279,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
         if (ret)
           _computeState = READY_TO_COMPUTE;
       }
-      break;
+      //break; submeshes dependent on me should be cleaned as well
     case CLEANDEP:
       CleanDependants();
       break;
@@ -1319,13 +1309,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
     switch (event)
     {
     case MODIF_HYP:
-      CleanDependants();        // recursive recall with event CLEANDEP
-      algo = gen->GetAlgo((*_father), _subShape);
-      if (algo && !algo->NeedDescretBoundary())
-        CleanDependsOn(); // remove sub-mesh with event CLEANDEP
-      break;
     case MODIF_ALGO_STATE:
-      CleanDependants();        // recursive recall with event CLEANDEP
+      ComputeStateEngine( CLEAN );
       algo = gen->GetAlgo((*_father), _subShape);
       if (algo && !algo->NeedDescretBoundary())
         CleanDependsOn(); // remove sub-mesh with event CLEANDEP
@@ -1342,7 +1327,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
         if (ret)
           _computeState = READY_TO_COMPUTE;
       }
-      break;
+      // break; submeshes dependent on me should be cleaned as well
     case CLEANDEP:
       CleanDependants();        // recursive recall with event CLEANDEP
       break;
@@ -1395,7 +1380,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
         _computeState = READY_TO_COMPUTE;
       else
         _computeState = NOT_READY;
-      break;
+      // break; submeshes dependent on me should be cleaned as well
     case CLEANDEP:
       CleanDependants();
       break;
@@ -1534,19 +1519,22 @@ void SMESH_subMesh::UpdateDependantsState(const compute_event theEvent)
 
 void SMESH_subMesh::CleanDependants()
 {
+  int dimToClean = SMESH_Gen::GetShapeDim( _subShape ) + 1;
+
   TopTools_ListIteratorOfListOfShape it( _father->GetAncestors( _subShape ));
   for (; it.More(); it.Next())
   {
     const TopoDS_Shape& ancestor = it.Value();
-    // PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEANDEP)
+    if ( SMESH_Gen::GetShapeDim( ancestor ) == dimToClean ) {
-    // will erase mesh on other shapes in a compound
+      // PAL8021. do not go upper than SOLID, else ComputeStateEngine(CLEAN)
-    if ( ancestor.ShapeType() >= TopAbs_SOLID ) {
+      // will erase mesh on other shapes in a compound
-      SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor);
+      if ( ancestor.ShapeType() >= TopAbs_SOLID ) {
-      if (aSubMesh)
+        SMESH_subMesh *aSubMesh = _father->GetSubMeshContaining(ancestor);
-        aSubMesh->ComputeStateEngine(CLEANDEP);
+        if (aSubMesh)
+          aSubMesh->ComputeStateEngine(CLEAN);
+      }
     }
   }
-  ComputeStateEngine(CLEAN);
 }
 
 //=============================================================================
@@ -1559,7 +1547,7 @@ void SMESH_subMesh::RemoveSubMeshElementsAndNodes()
 {
   //SCRUTE(_subShape.ShapeType());
 
-  removeSubMesh( _meshDS, _subShape );
+  cleanSubMesh( this );
 
   // algo may bind a submesh not to _subShape, eg 3D algo
   // sets nodes on SHELL while _subShape may be SOLID
@@ -1571,7 +1559,7 @@ void SMESH_subMesh::RemoveSubMeshElementsAndNodes()
     {
       TopExp_Explorer exp( _subShape, (TopAbs_ShapeEnum) type );
       for ( ; exp.More(); exp.Next() )
-        removeSubMesh( _meshDS, exp.Current() );
+        cleanSubMesh( _father->GetSubMeshContaining( exp.Current() ));
     }
     else
       break;