0021543: EDF 1978 SMESH: Viscous layer for 2D meshes

[modules/smesh.git] / src / OBJECT / SMESH_Object.cxx

diff --git a/src/OBJECT/SMESH_Object.cxx b/src/OBJECT/SMESH_Object.cxx
index 1912c9156e91eabdd08f12061a4a28423bcaa9ae..30bef057940ff267aebc4eed6203d4e94baf83a5 100644 (file)
--- a/src/OBJECT/SMESH_Object.cxx
+++ b/src/OBJECT/SMESH_Object.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -82,13 +82,14 @@ static int MYDEBUGWITHFILES = 0;
 // purpose  : Get type of VTK cell
 //=================================================================================
 static inline vtkIdType getCellType( const SMDSAbs_ElementType theType,
-                                     const bool thePoly,
-                                     const int theNbNodes )
+                                     const bool                thePoly,
+                                     const int                 theNbNodes )
 {
   switch( theType )
   {
-    case SMDSAbs_0DElement: 
-      return VTK_VERTEX;
+    case SMDSAbs_0DElement:         return VTK_VERTEX;
+
+    case SMDSAbs_Ball:              return VTK_POLY_VERTEX;
 
     case SMDSAbs_Edge: 
       if( theNbNodes == 2 )         return VTK_LINE;
@@ -344,23 +345,29 @@ void SMESH_VisualObjDef::buildElemPrs()
 
   // Calculate cells size
 
-  static SMDSAbs_ElementType aTypes[ 4 ] =
-    { SMDSAbs_0DElement, SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume };
+  const int nbTypes = 5;
+  static SMDSAbs_ElementType aTypes[ nbTypes ] =
+    { SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume, SMDSAbs_Ball, SMDSAbs_0DElement };
 
   // get entity data
   map<SMDSAbs_ElementType,int> nbEnts;
   map<SMDSAbs_ElementType,TEntityList> anEnts;
 
-  for ( int i = 0; i <= 3; i++ )
-    nbEnts[ aTypes[ i ] ] = GetEntities( aTypes[ i ], anEnts[ aTypes[ i ] ] );
+  vtkIdType aNbCells = 0;
 
+  for ( int i = 0; i < nbTypes; i++ )
+  {
+    nbEnts[ aTypes[ i ] ] = GetEntities( aTypes[ i ], anEnts[ aTypes[ i ] ] );
+    aNbCells += nbEnts[ aTypes [ i ]];
+  }
   // PAL16631: without swap, bad_alloc is not thrown but hung up and crash instead,
   // so check remaining memory size for safety
   SMDS_Mesh::CheckMemory(); // PAL16631
 
   vtkIdType aCellsSize =  2 * nbEnts[ SMDSAbs_0DElement ] + 3 * nbEnts[ SMDSAbs_Edge ];
+  aCellsSize += 2 * nbEnts[ SMDSAbs_Ball ];
 
-  for ( int i = 2; i <= 3; i++ ) // iterate through faces and volumes
+  for ( int i = 1; i <= 2; i++ ) // iterate through faces and volumes
   {
     if ( nbEnts[ aTypes[ i ] ] )
     {
@@ -386,10 +393,6 @@ void SMESH_VisualObjDef::buildElemPrs()
       }
     }
   }
-  
-  vtkIdType aNbCells = nbEnts[ SMDSAbs_0DElement ] + nbEnts[ SMDSAbs_Edge ] +
-                       nbEnts[ SMDSAbs_Face ] + nbEnts[ SMDSAbs_Volume ];
-
   if ( MYDEBUG )
     MESSAGE( "Update - aNbCells = "<<aNbCells<<"; aCellsSize = "<<aCellsSize );
 
@@ -414,7 +417,7 @@ void SMESH_VisualObjDef::buildElemPrs()
 
   SMDS_Mesh::CheckMemory(); // PAL16631
 
-  for ( int i = 0; i <= 3; i++ ) // iterate through 0d elements, edges, faces and volumes
+  for ( int i = 0; i < nbTypes; i++ ) // iterate through all types of elements
   {
     if ( nbEnts[ aTypes[ i ] ] > 0 ) {
       
@@ -566,6 +569,7 @@ bool SMESH_VisualObjDef::IsValid() const
         //MESSAGE("SMESH_VisualObjDef::IsValid");
   return GetNbEntities(SMDSAbs_Node) > 0      || 
          GetNbEntities(SMDSAbs_0DElement) > 0 || 
+         GetNbEntities(SMDSAbs_Ball) > 0 || 
          GetNbEntities(SMDSAbs_Edge) > 0      || 
          GetNbEntities(SMDSAbs_Face) > 0      ||
          GetNbEntities(SMDSAbs_Volume) > 0 ;
@@ -586,6 +590,9 @@ void SMESH_VisualObjDef::updateEntitiesFlags() {
         if( myEntitiesCache[SMDSAbs_0DElement] != 0 ||  myEntitiesCache[SMDSAbs_0DElement] >= entities[SMDSAbs_0DElement] )
                 myEntitiesState &= ~SMESH_Actor::e0DElements;
 
+        if( myEntitiesCache[SMDSAbs_Ball] != 0 ||  myEntitiesCache[SMDSAbs_Ball] >= entities[SMDSAbs_Ball] )
+                myEntitiesState &= ~SMESH_Actor::eBallElem;
+
         if( myEntitiesCache[SMDSAbs_Edge] != 0 || myEntitiesCache[SMDSAbs_Edge] >= entities[SMDSAbs_Edge] )
                 myEntitiesState &= ~SMESH_Actor::eEdges; 
 
@@ -701,6 +708,7 @@ int SMESH_MeshObj::GetElemDimension( const int theObjId )
   switch ( aType )
   {
     case SMDSAbs_0DElement : return 0;
+    case SMDSAbs_Ball : return 0;
     case SMDSAbs_Edge  : return 1;
     case SMDSAbs_Face  : return 2;
     case SMDSAbs_Volume: return 3;
@@ -725,6 +733,10 @@ int SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
     {
       return myClient->Nb0DElements();
     }
+    case SMDSAbs_Ball:
+    {
+      return myClient->NbBalls();
+    }
     break;
     case SMDSAbs_Edge:
     {
@@ -761,7 +773,13 @@ int SMESH_MeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList&
     break;
     case SMDSAbs_0DElement:
     {
-      SMDS_0DElementIteratorPtr anIter = myClient->elements0dIterator();
+      SMDS_ElemIteratorPtr anIter = myClient->elementsIterator(SMDSAbs_0DElement);
+      while ( anIter->more() ) theObjs.push_back( anIter->next() );
+    }
+    break;
+    case SMDSAbs_Ball:
+    {
+      SMDS_ElemIteratorPtr anIter = myClient->elementGeomIterator(SMDSGeom_BALL);
       while ( anIter->more() ) theObjs.push_back( anIter->next() );
     }
     break;
@@ -805,7 +823,7 @@ void SMESH_MeshObj::UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor
 //=================================================================================
 bool SMESH_MeshObj::IsNodePrs() const
 {
-  return myClient->Nb0DElements() == 0 && myClient->NbEdges() == 0 && myClient->NbFaces() == 0 && myClient->NbVolumes() == 0 ;
+  return myClient->Nb0DElements() + myClient->NbEdges() + myClient->NbFaces() + myClient->NbVolumes() + myClient->NbBalls() == 0 ;
 }
 
 
@@ -845,29 +863,7 @@ int SMESH_SubMeshObj::GetElemDimension( const int theObjId )
 
 void SMESH_SubMeshObj::UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunctor )
 {
-  if ( SMESH::Controls::CoincidentNodes* cn =
-       dynamic_cast<SMESH::Controls::CoincidentNodes*>(theFunctor.get()) )
-  {
-    TEntityList theResList;
-    GetEntities( SMDSAbs_Node, theResList );
-    TIDSortedNodeSet nodeSet;
-    TEntityList::iterator e = theResList.begin();
-    for ( ; e != theResList.end(); ++e )
-      nodeSet.insert( nodeSet.end(), (const SMDS_MeshNode* ) *e );
-    cn->SetMesh( myMeshObj->GetMesh(), &nodeSet );
-  }
-  else if ( SMESH::Controls::CoincidentElements* ce =
-            dynamic_cast<SMESH::Controls::CoincidentElements*>(theFunctor.get()) )
-  {
-    TEntityList theResList;
-    GetEntities( ce->GetType(), theResList );
-    TIDSortedElemSet elemSet( theResList.begin(), theResList.end() );
-    ce->SetMesh( myMeshObj->GetMesh(), &elemSet );
-  }
-  else
-  {
-    theFunctor->SetMesh( myMeshObj->GetMesh() );
-  }
+  theFunctor->SetMesh( myMeshObj->GetMesh() );
 }
 
 //=================================================================================
@@ -985,9 +981,12 @@ static int getPointers( const SMDSAbs_ElementType            theRequestType,
 //=================================================================================
 int SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
 {
-  if(SMDSAbs_ElementType(myGroupServer->GetType()) == theType){
+  if(SMDSAbs_ElementType(myGroupServer->GetType()) == theType) {
     return myGroupServer->Size();
   }
+  if ( theType == SMDSAbs_Node ) {
+    return myGroupServer->GetNumberOfNodes();
+  }
   return 0;
 }
 
@@ -1047,9 +1046,10 @@ int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
   {
     case SMDSAbs_Node:
     {
-      return mySubMeshServer->GetNumberOfNodes( false );
+      return mySubMeshServer->GetNumberOfNodes( /*all=*/true );
     }
     break;
+    case SMDSAbs_Ball:
     case SMDSAbs_0DElement:
     case SMDSAbs_Edge:
     case SMDSAbs_Face: