Implementation of new pattern mapping algorthm (mesh refinement)

idl/SMESH_Pattern.idl

@@ -174,8 +174,9 @@ module SMESH
 
     /*!
      * Return nodal connectivity of the elements of the pattern
+     * or of all elements to be crated
      */
-    array_of_long_array GetElementPoints();
+    array_of_long_array GetElementPoints(in boolean all);
   };
 };
 

src/SMDS/SMDS_Mesh.cxx

@@ -1604,9 +1604,7 @@ static set<const SMDS_MeshElement*> * intersectionOfSets(
 static set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement * element)
 {
 	int numberOfSets=element->NbNodes();
-	auto_ptr<set<const SMDS_MeshElement*> > pInitSet
+ 	set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];
-	  (new set<const SMDS_MeshElement*>[numberOfSets]);
-	set<const SMDS_MeshElement*> *initSet = &(*pInitSet);
 
 	SMDS_ElemIteratorPtr itNodes=element->nodesIterator();
 
@@ -1622,8 +1620,9 @@ static set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement *
 
 		i++;
 	}
-	
+	set<const SMDS_MeshElement*> *retSet=intersectionOfSets(initSet, numberOfSets);
-	return intersectionOfSets(initSet, numberOfSets);
+        delete [] initSet;
+	return retSet;
 }
 
 ///////////////////////////////////////////////////////////////////////////////

src/SMESH/SMESH_Pattern.cxx

@@ -3306,17 +3306,37 @@ bool SMESH_Pattern::MakeMesh(SMESH_Mesh* theMesh)
       }
     }
     // set element on a shape
-    if ( elem && onMeshElements )
+    if ( elem && onMeshElements ) // applied to mesh elements
     {
       int elemIndex = iElem / nbElems;
-      if ( shapeIDs[ elemIndex ] > 0 )
+      int shapeID = shapeIDs[ elemIndex ];
-        aMeshDS->SetMeshElementOnShape( elem, shapeIDs[ elemIndex ] );
+      if ( shapeID > 0 ) {
+        aMeshDS->SetMeshElementOnShape( elem, shapeID );
+        // set nodes on a shape
+        TopoDS_Shape S = aMeshDS->IndexToShape( shapeID );
+        if ( S.ShapeType() == TopAbs_SOLID ) {
+          TopoDS_Iterator shellIt( S );
+          if ( shellIt.More() )
+            shapeID = aMeshDS->ShapeToIndex( shellIt.Value() );
+        }
+        SMDS_ElemIteratorPtr noIt = elem->nodesIterator();
+        while ( noIt->more() ) {
+          SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>
+            ( static_cast<const SMDS_MeshNode*>( noIt->next() ));
+          if ( !node->GetPosition() || !node->GetPosition()->GetShapeId() ) {
+            if ( S.ShapeType() == TopAbs_FACE )
+              aMeshDS->SetNodeOnFace( node, shapeID );
+            else
+              aMeshDS->SetNodeInVolume( node, shapeID );
+          }
+        }
+      }
       // add elem in groups
       list< SMESHDS_Group* >::iterator g = groups[ elemIndex ].begin();
       for ( ; g != groups[ elemIndex ].end(); ++g )
         (*g)->SMDSGroup().Add( elem );
     }
-    if ( elem && !myShape.IsNull() )
+    if ( elem && !myShape.IsNull() ) // applied to shape
       aMeshDS->SetMeshElementOnShape( elem, myShape );
   }
 
@@ -3342,7 +3362,7 @@ bool SMESH_Pattern::MakeMesh(SMESH_Mesh* theMesh)
       }
       elemIDs.push_back( myElements[ i ]->GetID() );
     }
-    // remove refined elements and their nodes
+    // remove refined elements
     editor.Remove( elemIDs, false );
   }
 
@@ -3768,9 +3788,13 @@ bool SMESH_Pattern::GetMappedPoints ( list< const gp_XYZ * > & thePoints ) const
       thePoints.push_back( & (*pVecIt).myXYZ.XYZ() );
   }
   else { // applied to mesh elements
+    const gp_XYZ * definedXYZ = & myPoints[ myKeyPointIDs.front() ].myXYZ.XYZ();
     vector<gp_XYZ>::const_iterator xyz = myXYZ.begin();
     for ( ; xyz != myXYZ.end(); ++xyz )
-      thePoints.push_back( & (*xyz) );
+      if ( !isDefined( *xyz ))
+        thePoints.push_back( definedXYZ );
+      else
+        thePoints.push_back( & (*xyz) );
   }
   return !thePoints.empty();
 }

src/SMESH/SMESH_Pattern.hxx

@@ -190,8 +190,8 @@ class SMESH_Pattern {
   // Return indices of key-points within the sequences returned by
   // GetPoints() and GetMappedPoints()
   
-  const std::list< std::list< int > >& GetElementPointIDs () const
+  const std::list< std::list< int > >& GetElementPointIDs (bool applied) const
-  { return myElemXYZIDs.empty() ? myElemPointIDs : myElemXYZIDs; }
+  { return myElemXYZIDs.empty() || !applied ? myElemPointIDs : myElemXYZIDs; }
   // Return nodal connectivity of the elements of the pattern
 
   void DumpPoints() const;

src/SMESHGUI/SMESHGUI_CreatePatternDlg.cxx

@@ -677,7 +677,7 @@ void SMESHGUI_CreatePatternDlg::displayPreview()
     {
       SMESH::point_array_var pnts = myPattern->GetPoints();
       SMESH::long_array_var keyPoints = myPattern->GetKeyPoints();
-      SMESH::array_of_long_array_var elemPoints = myPattern->GetElementPoints();
+      SMESH::array_of_long_array_var elemPoints = myPattern->GetElementPoints(false);
 
       if ( pnts->length()       == 0 ||
            keyPoints->length()  == 0 ||

src/SMESH_I/SMESH_Pattern_i.cxx

@@ -374,11 +374,11 @@ SMESH::long_array* SMESH_Pattern_i::GetKeyPoints()
 //purpose  : 
 //=======================================================================
 
-SMESH::array_of_long_array* SMESH_Pattern_i::GetElementPoints()
+SMESH::array_of_long_array* SMESH_Pattern_i::GetElementPoints(CORBA::Boolean applied)
 {
   SMESH::array_of_long_array_var arrayOfArray = new SMESH::array_of_long_array;
 
-  const list< list< int > >& listOfIdList = myPattern.GetElementPointIDs();
+  const list< list< int > >& listOfIdList = myPattern.GetElementPointIDs(applied);
   arrayOfArray->length( listOfIdList.size() );
   list< list< int > >::const_iterator llIt = listOfIdList.begin();
   for ( int i = 0 ; llIt != listOfIdList.end(); llIt++, i++ )

src/SMESH_I/SMESH_Pattern_i.hxx

@@ -87,7 +87,7 @@ class SMESH_Pattern_i:
 
   SMESH::long_array* GetKeyPoints();
 
-  SMESH::array_of_long_array* GetElementPoints();
+  SMESH::array_of_long_array* GetElementPoints(CORBA::Boolean applied);
 
 
  private: