PAL13330( When mesh generation does not success, trace where )

   describe problems using SMESH_ComputeError

diff --git a/src/NETGENPlugin/NETGENPlugin_Mesher.cxx b/src/NETGENPlugin/NETGENPlugin_Mesher.cxx
index 09c51aa1d3f582f761fa640abbc7f082e14a3198..61239b38480e337001ce31acff24d31103b40d13 100644 (file)
--- a/src/NETGENPlugin/NETGENPlugin_Mesher.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_Mesher.cxx
@@ -30,6 +30,9 @@ using namespace std;
 #include "NETGENPlugin_Mesher.hxx"
 #include "NETGENPlugin_Hypothesis_2D.hxx"
 
+#include <SMESH_Mesh.hxx>
+#include <SMESH_Comment.hxx>
+#include <SMESH_subMesh.hxx>
 #include <SMESHDS_Mesh.hxx>
 #include <SMDS_MeshElement.hxx>
 #include <SMDS_MeshNode.hxx>
@@ -62,10 +65,10 @@ namespace netgen {
  */
 //=============================================================================
 
-NETGENPlugin_Mesher::NETGENPlugin_Mesher (SMESHDS_Mesh* meshDS,
+NETGENPlugin_Mesher::NETGENPlugin_Mesher (SMESH_Mesh* mesh,
                                           const TopoDS_Shape& aShape,
                                           const bool isVolume)
-  : _meshDS  (meshDS),
+  : _mesh  (mesh),
     _shape   (aShape),
     _isVolume(isVolume),
     _optimize(true)
@@ -156,6 +159,7 @@ bool NETGENPlugin_Mesher::Compute()
           " second order = " << netgen::mparam.secondorder << "\n"
           " quad allowed = " << netgen::mparam.quad);
 
+  SMESH_ComputeErrorPtr error = SMESH_ComputeError::New();
   nglib::Ng_Init();
 
   // -------------------------
@@ -193,14 +197,17 @@ bool NETGENPlugin_Mesher::Compute()
   char *optstr;
 
   int err = 0;
+  SMESH_Comment comment;
   try
   {
     err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
+    if (err) comment << "Error in netgen::OCCGenerateMesh()";
     if (!err && !_optimize)
     {
       // we have got surface mesh only, so generate volume mesh
       startWith = endWith = netgen::MESHCONST_MESHVOLUME;
       err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
+      if (err) comment << "Error in netgen::OCCGenerateMesh()";
     }
     if (!err && netgen::mparam.secondorder > 0)
     {
@@ -210,8 +217,8 @@ bool NETGENPlugin_Mesher::Compute()
   }
   catch (netgen::NgException exc)
   {
-    MESSAGE ("Exception in NETGEN: " << exc.What());
-    err = 1;
+    error->myName = err = COMPERR_ALGO_FAILED;
+    comment << exc.What();
   }
 
   int nbNod = ngMesh->GetNP();
@@ -229,8 +236,9 @@ bool NETGENPlugin_Mesher::Compute()
   // Feed back the SMESHDS with the generated Nodes and Elements
   // -----------------------------------------------------------
 
+  SMESHDS_Mesh* meshDS = _mesh->GetMeshDS();
   bool isOK = ( !err && (_isVolume ? (nbVol > 0) : (nbFac > 0)) );
-  if ( isOK )
+  if ( true /*isOK*/ ) // get whatever built
   {
     // vector of nodes in which node index == netgen ID
     vector< SMDS_MeshNode* > nodeVec ( nbNod + 1 );
@@ -238,7 +246,7 @@ bool NETGENPlugin_Mesher::Compute()
     NCollection_Map<int> pindMap;
     // create and insert nodes into nodeVec
     int i;
-    for (i = 1; i <= nbNod && isOK; ++i )
+    for (i = 1; i <= nbNod /*&& isOK*/; ++i )
     {
       const netgen::MeshPoint& ngPoint = ngMesh->Point(i);
       SMDS_MeshNode* node = NULL;
@@ -248,7 +256,7 @@ bool NETGENPlugin_Mesher::Compute()
       {
         // point on vertex
         aVert = TopoDS::Vertex(occgeo.vmap(i));
-        SMESHDS_SubMesh * submesh = _meshDS->MeshElements(aVert);
+        SMESHDS_SubMesh * submesh = meshDS->MeshElements(aVert);
         if (submesh)
         {
           SMDS_NodeIteratorPtr it = submesh->GetNodes();
@@ -262,25 +270,26 @@ bool NETGENPlugin_Mesher::Compute()
           newNodeOnVertex = true;
       }
       if (!node)
-        node = _meshDS->AddNode(ngPoint.X(), ngPoint.Y(), ngPoint.Z());
+        node = meshDS->AddNode(ngPoint.X(), ngPoint.Y(), ngPoint.Z());
       if (!node)
       {
         MESSAGE("Cannot create a mesh node");
-        isOK = false;
+        if ( !comment.size() ) comment << "Cannot create a mesh node";
+        nbSeg = nbFac = nbVol = isOK = 0;
         break;
       }
       nodeVec.at(i) = node;
       if (newNodeOnVertex)
       {
         // point on vertex
-        _meshDS->SetNodeOnVertex(node, aVert);
+        meshDS->SetNodeOnVertex(node, aVert);
         pindMap.Add(i);
       }
     }
 
     // create mesh segments along geometric edges
     NCollection_Map<Link> linkMap;
-    for (i = 1; i <= nbSeg && isOK; ++i )
+    for (i = 1; i <= nbSeg/* && isOK*/; ++i )
     {
       const netgen::Segment& seg = ngMesh->LineSegment(i);
       Link link(seg.p1, seg.p2);
@@ -314,28 +323,29 @@ bool NETGENPlugin_Mesher::Compute()
           continue;
         if (!aEdge.IsNull())
         {
-          _meshDS->SetNodeOnEdge(nodeVec.at(pind), aEdge, param);
+          meshDS->SetNodeOnEdge(nodeVec.at(pind), aEdge, param);
           pindMap.Add(pind);
         }
       }
       SMDS_MeshEdge* edge;
       if (nbp < 3) // second order ?
-        edge = _meshDS->AddEdge(nodeVec.at(pinds[0]), nodeVec.at(pinds[1]));
+        edge = meshDS->AddEdge(nodeVec.at(pinds[0]), nodeVec.at(pinds[1]));
       else
-        edge = _meshDS->AddEdge(nodeVec.at(pinds[0]), nodeVec.at(pinds[1]),
+        edge = meshDS->AddEdge(nodeVec.at(pinds[0]), nodeVec.at(pinds[1]),
                                 nodeVec.at(pinds[2]));
       if (!edge)
       {
+        if ( !comment.size() ) comment << "Cannot create a mesh edge";
         MESSAGE("Cannot create a mesh edge");
-        isOK = false;
+        nbSeg = nbFac = nbVol = isOK = 0;
         break;
       }
       if (!aEdge.IsNull())
-        _meshDS->SetMeshElementOnShape(edge, aEdge);
+        meshDS->SetMeshElementOnShape(edge, aEdge);
     }
 
     // create mesh faces along geometric faces
-    for (i = 1; i <= nbFac && isOK; ++i )
+    for (i = 1; i <= nbFac/* && isOK*/; ++i )
     {
       const netgen::Element2d& elem = ngMesh->SurfaceElement(i);
       int aGeomFaceInd = elem.GetIndex();
@@ -353,7 +363,7 @@ bool NETGENPlugin_Mesher::Compute()
         if (!aFace.IsNull())
         {
           const netgen::PointGeomInfo& pgi = elem.GeomInfoPi(j);
-          _meshDS->SetNodeOnFace(node, aFace, pgi.u, pgi.v);
+          meshDS->SetNodeOnFace(node, aFace, pgi.u, pgi.v);
           pindMap.Add(pind);
         }
       }
@@ -361,16 +371,16 @@ bool NETGENPlugin_Mesher::Compute()
       switch (elem.GetType())
       {
       case netgen::TRIG:
-        face = _meshDS->AddFace(nodes[0],nodes[1],nodes[2]);
+        face = meshDS->AddFace(nodes[0],nodes[1],nodes[2]);
         break;
       case netgen::QUAD:
-        face = _meshDS->AddFace(nodes[0],nodes[1],nodes[2],nodes[3]);
+        face = meshDS->AddFace(nodes[0],nodes[1],nodes[2],nodes[3]);
         break;
       case netgen::TRIG6:
-        face = _meshDS->AddFace(nodes[0],nodes[1],nodes[2],nodes[5],nodes[3],nodes[4]);
+        face = meshDS->AddFace(nodes[0],nodes[1],nodes[2],nodes[5],nodes[3],nodes[4]);
         break;
       case netgen::QUAD8:
-        face = _meshDS->AddFace(nodes[0],nodes[1],nodes[2],nodes[3],
+        face = meshDS->AddFace(nodes[0],nodes[1],nodes[2],nodes[3],
                                nodes[4],nodes[7],nodes[5],nodes[6]);
         break;
       default:
@@ -379,16 +389,17 @@ bool NETGENPlugin_Mesher::Compute()
       }
       if (!face)
       {
+        if ( !comment.size() ) comment << "Cannot create a mesh face";
         MESSAGE("Cannot create a mesh face");
-        isOK = false;
+        nbSeg = nbFac = nbVol = isOK = 0;
         break;
       }
       if (!aFace.IsNull())
-        _meshDS->SetMeshElementOnShape(face, aFace);
+        meshDS->SetMeshElementOnShape(face, aFace);
     }
 
     // create tetrahedra
-    for (i = 1; i <= nbVol && isOK; ++i)
+    for (i = 1; i <= nbVol/* && isOK*/; ++i)
     {
       const netgen::Element& elem = ngMesh->VolumeElement(i);
       int aSolidInd = elem.GetIndex();
@@ -406,7 +417,7 @@ bool NETGENPlugin_Mesher::Compute()
         if (!aSolid.IsNull())
         {
           // point in solid
-          _meshDS->SetNodeInVolume(node, aSolid);
+          meshDS->SetNodeInVolume(node, aSolid);
           pindMap.Add(pind);
         }
       }
@@ -414,11 +425,11 @@ bool NETGENPlugin_Mesher::Compute()
       switch (elem.GetType())
       {
       case netgen::TET:
-        vol = _meshDS->AddVolume(nodes[0],nodes[1],nodes[2],nodes[3]);
+        vol = meshDS->AddVolume(nodes[0],nodes[1],nodes[2],nodes[3]);
         break;
       case netgen::TET10:
-        vol = _meshDS->AddVolume(nodes[0],nodes[1],nodes[2],nodes[3],
-                                 nodes[4],nodes[7],nodes[5],nodes[6],nodes[8],nodes[9]);
+        vol = meshDS->AddVolume(nodes[0],nodes[1],nodes[2],nodes[3],
+                                nodes[4],nodes[7],nodes[5],nodes[6],nodes[8],nodes[9]);
         break;
       default:
         MESSAGE("NETGEN created a volume of unexpected type, ignoring");
@@ -426,17 +437,41 @@ bool NETGENPlugin_Mesher::Compute()
       }
       if (!vol)
       {
+        if ( !comment.size() ) comment << "Cannot create a mesh volume";
         MESSAGE("Cannot create a mesh volume");
-        isOK = false;
+        nbSeg = nbFac = nbVol = isOK = 0;
         break;
       }
       if (!aSolid.IsNull())
-        _meshDS->SetMeshElementOnShape(vol, aSolid);
+        meshDS->SetMeshElementOnShape(vol, aSolid);
+    }
+  }
+
+  if ( error->IsOK() && ( !isOK || comment.size() > 0 ))
+    error->myName = COMPERR_ALGO_FAILED;
+  if ( !comment.empty() )
+    error->myComment = comment;
+
+  // set bad compute error to subshapes of all failed subshapes shapes
+  if ( !error->IsOK() && err )
+  {
+    for (int i = 1; i <= occgeo.fmap.Extent(); i++) {
+      int status = occgeo.facemeshstatus[i-1];
+      if (status == 1 ) continue;
+      if ( SMESH_subMesh* sm = _mesh->GetSubMeshContaining( occgeo.fmap( i ))) {
+        SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
+        if ( !smError || smError->IsOK() ) {
+          if ( status == -1 )
+            smError.reset( new SMESH_ComputeError( error->myName, error->myComment ));
+          else
+            smError.reset( new SMESH_ComputeError( COMPERR_ALGO_FAILED, "Ignored" ));
+        }
+      }
     }
   }
 
   nglib::Ng_DeleteMesh((nglib::Ng_Mesh*)ngMesh);
   nglib::Ng_Exit();
 
-  return isOK;
+  return error->IsOK();
 }

diff --git a/src/NETGENPlugin/NETGENPlugin_Mesher.hxx b/src/NETGENPlugin/NETGENPlugin_Mesher.hxx
index 4d09177ef180bb2ce463bd3bb4308acadb87cf18..6a18639f031203ff2fdf6114c330550e95355443 100644 (file)
--- a/src/NETGENPlugin/NETGENPlugin_Mesher.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_Mesher.hxx
@@ -29,6 +29,9 @@
 #ifndef _NETGENPlugin_Mesher_HXX_
 #define _NETGENPlugin_Mesher_HXX_
 
+#include "SMESH_ComputeError.hxx"
+
+class SMESH_Mesh;
 class SMESHDS_Mesh;
 class TopoDS_Shape;
 class NETGENPlugin_Hypothesis;
@@ -42,7 +45,7 @@ class NETGENPlugin_Mesher
  public:
   // ---------- PUBLIC METHODS ----------
 
-  NETGENPlugin_Mesher (SMESHDS_Mesh* meshDS, const TopoDS_Shape& aShape,
+  NETGENPlugin_Mesher (SMESH_Mesh* mesh, const TopoDS_Shape& aShape,
                        const bool isVolume);
 
   void SetParameters(const NETGENPlugin_Hypothesis* hyp);
@@ -50,7 +53,7 @@ class NETGENPlugin_Mesher
   bool Compute();
 
  private:
-  SMESHDS_Mesh*        _meshDS;
+  SMESH_Mesh*          _mesh;
   const TopoDS_Shape&  _shape;
   bool                 _isVolume;
   bool                 _optimize;

diff --git a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.cxx b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.cxx
index fcf41532b44d603af6fac2ca5a3ee93a535f7424..0c7276efa5c14351d49abf2c3a10c33a41bd5344 100644 (file)
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.cxx
@@ -119,53 +119,10 @@ bool NETGENPlugin_NETGEN_2D::CheckHypothesis
 bool NETGENPlugin_NETGEN_2D::Compute(SMESH_Mesh&         aMesh,
                                      const TopoDS_Shape& aShape)
 {
-  SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+  //SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
 
-  NETGENPlugin_Mesher mesher(meshDS, aShape, false);
+  NETGENPlugin_Mesher mesher(&aMesh, aShape, false);
+//   NETGENPlugin_Mesher mesher(meshDS, aShape, false);
   mesher.SetParameters(_hypothesis);
   return mesher.Compute();
 }
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-ostream & NETGENPlugin_NETGEN_2D::SaveTo(ostream & save)
-{
-  return save;
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-istream & NETGENPlugin_NETGEN_2D::LoadFrom(istream & load)
-{
-  return load;
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-ostream & operator << (ostream & save, NETGENPlugin_NETGEN_2D & hyp)
-{
-  return hyp.SaveTo( save );
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-istream & operator >> (istream & load, NETGENPlugin_NETGEN_2D & hyp)
-{
-  return hyp.LoadFrom( load );
-}

diff --git a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.hxx b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.hxx
index aafcb2e4e2b804f927e35d834fc9fe697fab52e7..0c08660497e88aae78d8f056963ee9da15e1839a 100644 (file)
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D.hxx
@@ -49,11 +49,6 @@ public:
   virtual bool Compute(SMESH_Mesh& aMesh,
                       const TopoDS_Shape& aShape);
 
-  ostream & SaveTo(ostream & save);
-  istream & LoadFrom(istream & load);
-  friend ostream & operator << (ostream & save, NETGENPlugin_NETGEN_2D & hyp);
-  friend istream & operator >> (istream & load, NETGENPlugin_NETGEN_2D & hyp);
-
 protected:
   const NETGENPlugin_Hypothesis_2D* _hypothesis;
 };

diff --git a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.cxx b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.cxx
index 0f392c1a2f08eaefeb3eebbb9ead6905281ee2cd..c4c0df40d10ede6760320349f09b017d5289b913 100644 (file)
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.cxx
@@ -121,53 +121,10 @@ bool NETGENPlugin_NETGEN_2D3D::CheckHypothesis
 bool NETGENPlugin_NETGEN_2D3D::Compute(SMESH_Mesh&         aMesh,
                                        const TopoDS_Shape& aShape)
 {
-  SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
+//   SMESHDS_Mesh* meshDS = aMesh.GetMeshDS();
 
-  NETGENPlugin_Mesher mesher(meshDS, aShape, true);
+  NETGENPlugin_Mesher mesher(&aMesh, aShape, true);
+//   NETGENPlugin_Mesher mesher(meshDS, aShape, true);
   mesher.SetParameters(_hypothesis);
   return mesher.Compute();
 }
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-ostream & NETGENPlugin_NETGEN_2D3D::SaveTo(ostream & save)
-{
-  return save;
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-istream & NETGENPlugin_NETGEN_2D3D::LoadFrom(istream & load)
-{
-  return load;
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-ostream & operator << (ostream & save, NETGENPlugin_NETGEN_2D3D & hyp)
-{
-  return hyp.SaveTo( save );
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-istream & operator >> (istream & load, NETGENPlugin_NETGEN_2D3D & hyp)
-{
-  return hyp.LoadFrom( load );
-}

diff --git a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.hxx b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.hxx
index 169cb15a0e9fbfc066d84a3b8d587b44a3f21094..403b01e4bd4efea328e66432e11231970a3feb54 100644 (file)
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.hxx
@@ -49,11 +49,6 @@ public:
   virtual bool Compute(SMESH_Mesh& aMesh,
                       const TopoDS_Shape& aShape);
 
-  ostream & SaveTo(ostream & save);
-  istream & LoadFrom(istream & load);
-  friend ostream & operator << (ostream & save, NETGENPlugin_NETGEN_2D3D & hyp);
-  friend istream & operator >> (istream & load, NETGENPlugin_NETGEN_2D3D & hyp);
-
 protected:
   const NETGENPlugin_Hypothesis* _hypothesis;
 };

diff --git a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.cxx b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.cxx
index c9031d88c7a75a0af4b065a186f241e37b9bb90b..560aef1959e06a3a446399c77ec8f63af7628956 100644 (file)
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.cxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.cxx
@@ -30,12 +30,13 @@ using namespace std;
 
 #include "NETGENPlugin_NETGEN_3D.hxx"
 
-#include "SMESH_Gen.hxx"
-#include "SMESH_Mesh.hxx"
-#include "SMESH_ControlsDef.hxx"
-#include "SMESHDS_Mesh.hxx"
 #include "SMDS_MeshElement.hxx"
 #include "SMDS_MeshNode.hxx"
+#include "SMESHDS_Mesh.hxx"
+#include "SMESH_Comment.hxx"
+#include "SMESH_ControlsDef.hxx"
+#include "SMESH_Gen.hxx"
+#include "SMESH_Mesh.hxx"
 #include "SMESH_MesherHelper.hxx"
 
 #include <BRep_Tool.hxx>
@@ -160,7 +161,8 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
   // get triangles on aShell and make a map of nodes to Netgen node IDs
   // -------------------------------------------------------------------
 
-  SMESH_MesherHelper* myTool = new SMESH_MesherHelper(aMesh);
+  SMESH_MesherHelper helper(aMesh);
+  SMESH_MesherHelper* myTool = &helper;
   bool _quadraticMesh = myTool->IsQuadraticSubMesh(aShape);
 
   typedef map< const SMDS_MeshNode*, int> TNodeToIDMap;
@@ -187,12 +189,12 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
       {
         // check element
         const SMDS_MeshElement* elem = iteratorElem->next();
-        if ( !elem ||
-             !( elem->NbNodes()==3 || ( _quadraticMesh && elem->NbNodes()==6) ) ) {
-          INFOS( "NETGENPlugin_NETGEN_3D::Compute(), bad mesh");
-          delete myTool; myTool = 0;
-          return false;
-        }
+        if ( !elem )
+          return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
+        bool isTraingle = ( elem->NbNodes()==3 || (_quadraticMesh && elem->NbNodes()==6 ));
+        if ( !isTraingle )
+          return error( COMPERR_BAD_INPUT_MESH,
+                        SMESH_Comment("Not triangle element ")<<elem->GetID());
         // keep a triangle
         triangles.push_back( elem );
         isReversed.push_back( isRev );
@@ -316,8 +318,18 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
   }
   catch (...) {
     MESSAGE("An exception has been caught during the Volume Mesh Generation ...");
+    error(dfltErr(), "Exception in Ng_GenerateVolumeMesh()");
     status = NG_VOLUME_FAILURE;
   }
+  if ( GetComputeError()->IsOK() ) {
+    switch ( status ) {
+    case NG_SURFACE_INPUT_ERROR:error( status, "NG_SURFACE_INPUT_ERROR");
+    case NG_VOLUME_FAILURE:     error( status, "NG_VOLUME_FAILURE");
+    case NG_STL_INPUT_ERROR:    error( status, "NG_STL_INPUT_ERROR");
+    case NG_SURFACE_FAILURE:    error( status, "NG_SURFACE_FAILURE");
+    case NG_FILE_NOT_FOUND:     error( status, "NG_FILE_NOT_FOUND");
+    };
+  }
 
   int Netgen_NbOfNodesNew = Ng_GetNP(Netgen_mesh);
 
@@ -331,7 +343,7 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
   // Feed back the SMESHDS with the generated Nodes and Volume Elements
   // -------------------------------------------------------------------
 
-  bool isOK = ( status == NG_OK && Netgen_NbOfTetra > 0 );
+  bool isOK = ( /*status == NG_OK &&*/ Netgen_NbOfTetra > 0 );// get whatever built
   if ( isOK )
   {
     // vector of nodes in which node index == netgen ID
@@ -368,51 +380,5 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh&         aMesh,
   Ng_DeleteMesh(Netgen_mesh);
   Ng_Exit();
 
-  delete myTool; myTool = 0;
-
-  return isOK;
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-ostream & NETGENPlugin_NETGEN_3D::SaveTo(ostream & save)
-{
-  return save;
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-istream & NETGENPlugin_NETGEN_3D::LoadFrom(istream & load)
-{
-  return load;
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-ostream & operator << (ostream & save, NETGENPlugin_NETGEN_3D & hyp)
-{
-  return hyp.SaveTo( save );
-}
-
-//=============================================================================
-/*!
- *  
- */
-//=============================================================================
-
-istream & operator >> (istream & load, NETGENPlugin_NETGEN_3D & hyp)
-{
-  return hyp.LoadFrom( load );
+  return (status == NG_OK);
 }

diff --git a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.hxx b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.hxx
index e0d39f3bd37e4fd27e44ed1c314ec8333eb75319..528bc09034c125750aadecf7e247ae25f7033b1a 100644 (file)
--- a/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.hxx
+++ b/src/NETGENPlugin/NETGENPlugin_NETGEN_3D.hxx
@@ -48,11 +48,6 @@ public:
   virtual bool Compute(SMESH_Mesh& aMesh,
                       const TopoDS_Shape& aShape);
 
-  ostream & SaveTo(ostream & save);
-  istream & LoadFrom(istream & load);
-  friend ostream & operator << (ostream & save, NETGENPlugin_NETGEN_3D & hyp);
-  friend istream & operator >> (istream & load, NETGENPlugin_NETGEN_3D & hyp);
-
 protected:
   double _maxElementVolume;