ForkMaster/netgenplugin
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merging from V3_2_6pre4

Browse Source
This commit is contained in:
abd 2007-04-18 15:47:16 +00:00
parent b7ca47a69a
commit ee0caf7948
9 changed files with 103 additions and 633 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

433
configure.in.base
View File

@ -1,433 +0,0 @@
#
# PLEASE DO NOT MODIFY configure.in FILE
#
# ALL CHANGES WILL BE DISCARDED BY THE NEXT
# build_configure COMMAND
#
# CHANGES MUST BE MADE IN configure.in.base FILE
#
#
# Author : Marc Tajchman (CEA)
# Date : 28/06/2001
# Modified by : Patrick GOLDBRONN (CEA)
# Modified by : Marc Tajchman (CEA)
#
# Created from configure.in.base
#
AC_INIT(src)
AC_CONFIG_AUX_DIR(${KERNEL_ROOT_DIR}/salome_adm/unix/config_files)
AC_CANONICAL_HOST
PACKAGE=salome
AC_SUBST(PACKAGE)
VERSION=4.0.0
XVERSION=0x040000
AC_SUBST(VERSION)
AC_SUBST(XVERSION)
# set up MODULE_NAME variable for dynamic construction of directories (resources, etc.)
MODULE_NAME=netgenplugin
AC_SUBST(MODULE_NAME)
dnl
dnl Initialize source and build root directories
dnl
ROOT_BUILDDIR=`pwd`
ROOT_SRCDIR=`echo $0 | sed -e "s,[[^/]]*$,,;s,/$,,;s,^$,.,"`
cd $ROOT_SRCDIR
ROOT_SRCDIR=`pwd`
cd $ROOT_BUILDDIR
AC_SUBST(ROOT_SRCDIR)
AC_SUBST(ROOT_BUILDDIR)
echo
echo Source root directory : $ROOT_SRCDIR
echo Build root directory : $ROOT_BUILDDIR
echo
echo
if test -z "$AR"; then
AC_CHECK_PROGS(AR,ar xar,:,$PATH)
fi
AC_SUBST(AR)
dnl Export the AR macro so that it will be placed in the libtool file
dnl correctly.
export AR
echo
echo ---------------------------------------------
echo testing make
echo ---------------------------------------------
echo
AC_PROG_MAKE_SET
AC_PROG_INSTALL
dnl
dnl libtool macro check for CC, LD, NM, LN_S, RANLIB, STRIP + pour les librairies dynamiques !
AC_ENABLE_DEBUG(yes)
AC_DISABLE_PRODUCTION
echo ---------------------------------------------
echo testing libtool
echo ---------------------------------------------
dnl first, we set static to no!
dnl if we want it, use --enable-static
AC_ENABLE_STATIC(no)
AC_LIBTOOL_DLOPEN
AC_PROG_LIBTOOL
dnl Fix up the INSTALL macro if it s a relative path. We want the
dnl full-path to the binary instead.
case "$INSTALL" in
*install-sh*)
INSTALL='\${KERNEL_ROOT_DIR}'/salome_adm/unix/config_files/install-sh
;;
esac
echo
echo ---------------------------------------------
echo testing C/C++
echo ---------------------------------------------
echo
cc_ok=no
dnl inutil car libtool
dnl AC_PROG_CC
AC_PROG_CXX
AC_DEPEND_FLAG
# AC_CC_WARNINGS([ansi])
cc_ok=yes
dnl Library libdl :
AC_CHECK_LIB(dl,dlopen)
dnl add library libm :
AC_CHECK_LIB(m,ceil)
dnl
dnl Well we use sstream which is not in gcc pre-2.95.3
dnl We must test if it exists. If not, add it in include !
dnl
AC_CXX_HAVE_SSTREAM
echo
echo ---------------------------------------------
echo BOOST Library
echo ---------------------------------------------
echo
CHECK_BOOST
dnl
dnl ---------------------------------------------
dnl testing MPICH
dnl ---------------------------------------------
dnl
CHECK_MPICH
echo
echo ---------------------------------------------
echo testing LEX \& YACC
echo ---------------------------------------------
echo
lex_yacc_ok=no
AC_PROG_YACC
AC_PROG_LEX
lex_yacc_ok=yes
echo
echo ---------------------------------------------
echo testing python
echo ---------------------------------------------
echo
CHECK_PYTHON
dnl echo
dnl echo ---------------------------------------------
dnl echo testing java
dnl echo ---------------------------------------------
dnl echo
dnl CHECK_JAVA
echo
echo ---------------------------------------------
echo testing swig
echo ---------------------------------------------
echo
CHECK_SWIG
echo
echo ---------------------------------------------
echo testing threads
echo ---------------------------------------------
echo
ENABLE_PTHREADS
echo
echo ---------------------------------------------
echo testing omniORB
echo ---------------------------------------------
echo
CHECK_OMNIORB
dnl echo
dnl echo ---------------------------------------------
dnl echo testing mico
dnl echo ---------------------------------------------
dnl echo
dnl CHECK_MICO
echo
echo ---------------------------------------------
echo default ORB : omniORB
echo ---------------------------------------------
echo
DEFAULT_ORB=omniORB
CHECK_CORBA
AC_SUBST_FILE(CORBA)
corba=make_$ORB
CORBA=adm_local/unix/$corba
echo
echo ---------------------------------------------
echo testing openGL
echo ---------------------------------------------
echo
CHECK_OPENGL
echo
echo ---------------------------------------------
echo testing QT
echo ---------------------------------------------
echo
CHECK_QT
echo
echo ---------------------------------------------
echo testing MSG2QM
echo ---------------------------------------------
echo
CHECK_MSG2QM
echo
echo ---------------------------------------------
echo testing VTK
echo ---------------------------------------------
echo
CHECK_VTK
echo
echo ---------------------------------------------
echo testing HDF5
echo ---------------------------------------------
echo
CHECK_HDF5
echo
echo ---------------------------------------------
echo Testing OpenCascade
echo ---------------------------------------------
echo
CHECK_CAS
echo
echo ---------------------------------------------
echo Testing html generators
echo ---------------------------------------------
echo
CHECK_HTML_GENERATORS
echo
echo ---------------------------------------------
echo Testing GUI
echo ---------------------------------------------
echo
CHECK_SALOME_GUI
echo
echo ---------------------------------------------
echo Testing full GUI
echo ---------------------------------------------
echo
CHECK_CORBA_IN_GUI
if test "x${CORBA_IN_GUI}" != "xyes"; then
echo "failed : For configure NETGENPLUGIN module necessary full GUI !"
exit
fi
echo
echo ---------------------------------------------
echo Testing Kernel
echo ---------------------------------------------
echo
CHECK_KERNEL
echo
echo ---------------------------------------------
echo Testing Geom
echo ---------------------------------------------
echo
CHECK_GEOM
# echo
# echo ---------------------------------------------
# echo Testing Med
# echo ---------------------------------------------
# echo
#
# CHECK_MED
echo
echo ---------------------------------------------
echo Testing Netgen
echo ---------------------------------------------
echo
CHECK_NETGEN
echo
echo ---------------------------------------------
echo Testing SMesh
echo ---------------------------------------------
echo
CHECK_SMESH
echo
echo ---------------------------------------------
echo Summary
echo ---------------------------------------------
echo
echo Configure
variables="cc_ok boost_ok lex_yacc_ok python_ok swig_ok threads_ok OpenGL_ok qt_ok vtk_ok hdf5_ok omniORB_ok occ_ok doxygen_ok graphviz_ok Kernel_ok Geom_ok SMesh_ok Netgen_ok"
for var in $variables
do
printf " %10s : " `echo \$var | sed -e "s,_ok,,"`
eval echo \$$var
done
echo
echo "Default ORB : $DEFAULT_ORB"
echo
dnl generals files which could be included in every makefile
AC_SUBST_FILE(COMMENCE) COMMENCE=adm_local/unix/make_commence
AC_SUBST_FILE(CONCLUDE) CONCLUDE=salome_adm/unix/make_conclude
AC_SUBST_FILE(MODULE) MODULE=salome_adm/unix/make_module
dnl les dependences
AC_SUBST_FILE(DEPEND) DEPEND=salome_adm/unix/depend
dnl We don t need to say when we re entering directories if we re using
dnl GNU make becuase make does it for us.
if test "X$GMAKE" = "Xyes"; then
AC_SUBST(SETX) SETX=":"
else
AC_SUBST(SETX) SETX="set -x"
fi
# make other build directories
for rep in salome_adm adm_local doc bin/salome include/salome lib${LIB_LOCATION_SUFFIX}/salome share/salome/resources/${MODULE_NAME} idl
do
# if test ! -d $rep ; then
# eval mkdir $rep
# fi
$INSTALL -d $rep
done
echo
echo ---------------------------------------------
echo copying resource files, shell scripts, and
echo xml files
echo ---------------------------------------------
echo
dnl copy resources directories
#for i in `find $ROOT_SRCDIR -name 'resources' -print`
#do
# local_res=`echo $i | sed -e "s,$ROOT_SRCDIR,.,"`
# local_res_dir=`echo $local_res | sed -e "s,[[^/]]*$,,;s,/$,,;s,^$,.,"`
# mkdir -p $local_res_dir
# cd $local_res_dir
# ln -fs $i
# echo $local_res
# cd $ROOT_BUILDDIR
#done
dnl copy shells and utilities contained in the bin directory
dnl excluding .in files (treated in AC-OUTPUT below) and CVS
dnl directory
#mkdir -p bin/salome
#cd bin/salome
#for i in $ROOT_SRCDIR/bin/*
#do
# local_bin=`echo $i | sed -e "s,$ROOT_SRCDIR,.,"`
# case "$local_bin" in
# *.in | *~) ;;
# ./bin/CVS | ./bin/salome) ;;
# *) /usr/bin/install -C $i .; echo $local_bin ;;
# esac
#done
#cd $ROOT_BUILDDIR
AC_SUBST_FILE(ENVSCRIPT) ENVSCRIPT=salome_adm/unix/envScript
dnl copy xml files to the build tree (lib directory)
dnl pourquoi ????
#cd lib
#for i in `find $ROOT_SRCDIR -name "*.xml" -print`
#do
# ln -fs $i
# echo `echo $i | sed -e "s,$ROOT_SRCDIR,.,"`
#done
#cd $ROOT_BUILDDIR
echo
echo ---------------------------------------------
echo generating Makefiles and configure files
echo ---------------------------------------------
echo
#AC_OUTPUT_COMMANDS([ \
# chmod +x ./bin/* \
#])
## do not delete this line

97
src/NETGENPlugin/NETGENPlugin_Mesher.cxx
View File

@ -28,6 +28,9 @@
#include "NETGENPlugin_Mesher.hxx" #include "NETGENPlugin_Mesher.hxx"
#include "NETGENPlugin_Hypothesis_2D.hxx" #include "NETGENPlugin_Hypothesis_2D.hxx"
#include <SMESH_Mesh.hxx>
#include <SMESH_Comment.hxx>
#include <SMESH_subMesh.hxx>
#include <SMESHDS_Mesh.hxx> #include <SMESHDS_Mesh.hxx>
#include <SMDS_MeshElement.hxx> #include <SMDS_MeshElement.hxx>
#include <SMDS_MeshNode.hxx> #include <SMDS_MeshNode.hxx>
@ -62,10 +65,10 @@ using namespace std;
*/ */
//============================================================================= //=============================================================================
NETGENPlugin_Mesher::NETGENPlugin_Mesher (SMESHDS_Mesh* meshDS, NETGENPlugin_Mesher::NETGENPlugin_Mesher (SMESH_Mesh* mesh,
const TopoDS_Shape& aShape, const TopoDS_Shape& aShape,
const bool isVolume) const bool isVolume)
: _meshDS (meshDS), : _mesh (mesh),
_shape (aShape), _shape (aShape),
_isVolume(isVolume), _isVolume(isVolume),
_optimize(true) _optimize(true)
@ -171,6 +174,7 @@ bool NETGENPlugin_Mesher::Compute()
" second order = " << mparams.secondorder << "\n" " second order = " << mparams.secondorder << "\n"
" quad allowed = " << mparams.quad); " quad allowed = " << mparams.quad);
SMESH_ComputeErrorPtr error = SMESH_ComputeError::New();
nglib::Ng_Init(); nglib::Ng_Init();
// ------------------------- // -------------------------
@ -208,14 +212,17 @@ bool NETGENPlugin_Mesher::Compute()
char *optstr = 0; char *optstr = 0;
int err = 0; int err = 0;
SMESH_Comment comment;
try try
{ {
err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr); err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
if (err) comment << "Error in netgen::OCCGenerateMesh()";
if (!err && !_optimize) if (!err && !_optimize)
{ {
// we have got surface mesh only, so generate volume mesh // we have got surface mesh only, so generate volume mesh
startWith = endWith = netgen::MESHCONST_MESHVOLUME; startWith = endWith = netgen::MESHCONST_MESHVOLUME;
err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr); err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
if (err) comment << "Error in netgen::OCCGenerateMesh()";
} }
if (!err && mparams.secondorder > 0) if (!err && mparams.secondorder > 0)
{ {
@ -225,8 +232,8 @@ bool NETGENPlugin_Mesher::Compute()
} }
catch (netgen::NgException exc) catch (netgen::NgException exc)
{ {
MESSAGE ("Exception in NETGEN: " << exc.What()); error->myName = err = COMPERR_ALGO_FAILED;
err = 1; comment << exc.What();
} }
int nbNod = ngMesh->GetNP(); int nbNod = ngMesh->GetNP();
@ -244,8 +251,9 @@ bool NETGENPlugin_Mesher::Compute()
// Feed back the SMESHDS with the generated Nodes and Elements // Feed back the SMESHDS with the generated Nodes and Elements
// ----------------------------------------------------------- // -----------------------------------------------------------
SMESHDS_Mesh* meshDS = _mesh->GetMeshDS();
bool isOK = ( !err && (_isVolume ? (nbVol > 0) : (nbFac > 0)) ); 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 of nodes in which node index == netgen ID
vector< SMDS_MeshNode* > nodeVec ( nbNod + 1 ); vector< SMDS_MeshNode* > nodeVec ( nbNod + 1 );
@ -253,7 +261,7 @@ bool NETGENPlugin_Mesher::Compute()
NCollection_Map<int> pindMap; NCollection_Map<int> pindMap;
// create and insert nodes into nodeVec // create and insert nodes into nodeVec
int i; int i;
for (i = 1; i <= nbNod && isOK; ++i ) for (i = 1; i <= nbNod /*&& isOK*/; ++i )
{ {
const netgen::MeshPoint& ngPoint = ngMesh->Point(i); const netgen::MeshPoint& ngPoint = ngMesh->Point(i);
SMDS_MeshNode* node = NULL; SMDS_MeshNode* node = NULL;
@ -263,7 +271,7 @@ bool NETGENPlugin_Mesher::Compute()
{ {
// point on vertex // point on vertex
aVert = TopoDS::Vertex(occgeo.vmap(i)); aVert = TopoDS::Vertex(occgeo.vmap(i));
SMESHDS_SubMesh * submesh = _meshDS->MeshElements(aVert); SMESHDS_SubMesh * submesh = meshDS->MeshElements(aVert);
if (submesh) if (submesh)
{ {
SMDS_NodeIteratorPtr it = submesh->GetNodes(); SMDS_NodeIteratorPtr it = submesh->GetNodes();
@ -277,25 +285,26 @@ bool NETGENPlugin_Mesher::Compute()
newNodeOnVertex = true; newNodeOnVertex = true;
} }
if (!node) if (!node)
node = _meshDS->AddNode(ngPoint.X(), ngPoint.Y(), ngPoint.Z()); node = meshDS->AddNode(ngPoint.X(), ngPoint.Y(), ngPoint.Z());
if (!node) if (!node)
{ {
MESSAGE("Cannot create a mesh node"); MESSAGE("Cannot create a mesh node");
isOK = false; if ( !comment.size() ) comment << "Cannot create a mesh node";
nbSeg = nbFac = nbVol = isOK = 0;
break; break;
} }
nodeVec.at(i) = node; nodeVec.at(i) = node;
if (newNodeOnVertex) if (newNodeOnVertex)
{ {
// point on vertex // point on vertex
_meshDS->SetNodeOnVertex(node, aVert); meshDS->SetNodeOnVertex(node, aVert);
pindMap.Add(i); pindMap.Add(i);
} }
} }
// create mesh segments along geometric edges // create mesh segments along geometric edges
NCollection_Map<Link> linkMap; 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); const netgen::Segment& seg = ngMesh->LineSegment(i);
Link link(seg.p1, seg.p2); Link link(seg.p1, seg.p2);
@ -329,28 +338,29 @@ bool NETGENPlugin_Mesher::Compute()
continue; continue;
if (!aEdge.IsNull()) if (!aEdge.IsNull())
{ {
_meshDS->SetNodeOnEdge(nodeVec.at(pind), aEdge, param); meshDS->SetNodeOnEdge(nodeVec.at(pind), aEdge, param);
pindMap.Add(pind); pindMap.Add(pind);
} }
} }
SMDS_MeshEdge* edge; SMDS_MeshEdge* edge;
if (nbp < 3) // second order ? 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 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])); nodeVec.at(pinds[2]));
if (!edge) if (!edge)
{ {
if ( !comment.size() ) comment << "Cannot create a mesh edge";
MESSAGE("Cannot create a mesh edge"); MESSAGE("Cannot create a mesh edge");
isOK = false; nbSeg = nbFac = nbVol = isOK = 0;
break; break;
} }
if (!aEdge.IsNull()) if (!aEdge.IsNull())
_meshDS->SetMeshElementOnShape(edge, aEdge); meshDS->SetMeshElementOnShape(edge, aEdge);
} }
// create mesh faces along geometric faces // 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); const netgen::Element2d& elem = ngMesh->SurfaceElement(i);
int aGeomFaceInd = elem.GetIndex(); int aGeomFaceInd = elem.GetIndex();
@ -368,7 +378,7 @@ bool NETGENPlugin_Mesher::Compute()
if (!aFace.IsNull()) if (!aFace.IsNull())
{ {
const netgen::PointGeomInfo& pgi = elem.GeomInfoPi(j); 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); pindMap.Add(pind);
} }
} }
@ -376,16 +386,16 @@ bool NETGENPlugin_Mesher::Compute()
switch (elem.GetType()) switch (elem.GetType())
{ {
case netgen::TRIG: case netgen::TRIG:
face = _meshDS->AddFace(nodes[0],nodes[1],nodes[2]); face = meshDS->AddFace(nodes[0],nodes[1],nodes[2]);
break; break;
case netgen::QUAD: 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; break;
case netgen::TRIG6: 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; break;
case netgen::QUAD8: 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]); nodes[4],nodes[7],nodes[5],nodes[6]);
break; break;
default: default:
@ -394,16 +404,17 @@ bool NETGENPlugin_Mesher::Compute()
} }
if (!face) if (!face)
{ {
if ( !comment.size() ) comment << "Cannot create a mesh face";
MESSAGE("Cannot create a mesh face"); MESSAGE("Cannot create a mesh face");
isOK = false; nbSeg = nbFac = nbVol = isOK = 0;
break; break;
} }
if (!aFace.IsNull()) if (!aFace.IsNull())
_meshDS->SetMeshElementOnShape(face, aFace); meshDS->SetMeshElementOnShape(face, aFace);
} }
// create tetrahedra // create tetrahedra
for (i = 1; i <= nbVol && isOK; ++i) for (i = 1; i <= nbVol/* && isOK*/; ++i)
{ {
const netgen::Element& elem = ngMesh->VolumeElement(i); const netgen::Element& elem = ngMesh->VolumeElement(i);
int aSolidInd = elem.GetIndex(); int aSolidInd = elem.GetIndex();
@ -421,7 +432,7 @@ bool NETGENPlugin_Mesher::Compute()
if (!aSolid.IsNull()) if (!aSolid.IsNull())
{ {
// point in solid // point in solid
_meshDS->SetNodeInVolume(node, aSolid); meshDS->SetNodeInVolume(node, aSolid);
pindMap.Add(pind); pindMap.Add(pind);
} }
} }
@ -429,10 +440,10 @@ bool NETGENPlugin_Mesher::Compute()
switch (elem.GetType()) switch (elem.GetType())
{ {
case netgen::TET: 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; break;
case netgen::TET10: case netgen::TET10:
vol = _meshDS->AddVolume(nodes[0],nodes[1],nodes[2],nodes[3], vol = meshDS->AddVolume(nodes[0],nodes[1],nodes[2],nodes[3],
nodes[4],nodes[7],nodes[5],nodes[6],nodes[8],nodes[9]); nodes[4],nodes[7],nodes[5],nodes[6],nodes[8],nodes[9]);
break; break;
default: default:
@ -441,17 +452,41 @@ bool NETGENPlugin_Mesher::Compute()
} }
if (!vol) if (!vol)
{ {
if ( !comment.size() ) comment << "Cannot create a mesh volume";
MESSAGE("Cannot create a mesh volume"); MESSAGE("Cannot create a mesh volume");
isOK = false; nbSeg = nbFac = nbVol = isOK = 0;
break; break;
} }
if (!aSolid.IsNull()) 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_DeleteMesh((nglib::Ng_Mesh*)ngMesh);
nglib::Ng_Exit(); nglib::Ng_Exit();
return isOK; return error->IsOK();
} }

7
src/NETGENPlugin/NETGENPlugin_Mesher.hxx
View File

@ -31,6 +31,9 @@
#include "NETGENPlugin_Defs.hxx" #include "NETGENPlugin_Defs.hxx"
#include "SMESH_ComputeError.hxx"
class SMESH_Mesh;
class SMESHDS_Mesh; class SMESHDS_Mesh;
class TopoDS_Shape; class TopoDS_Shape;
class NETGENPlugin_Hypothesis; class NETGENPlugin_Hypothesis;
@ -44,7 +47,7 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_Mesher
public: public:
// ---------- PUBLIC METHODS ---------- // ---------- PUBLIC METHODS ----------
NETGENPlugin_Mesher (SMESHDS_Mesh* meshDS, const TopoDS_Shape& aShape, NETGENPlugin_Mesher (SMESH_Mesh* mesh, const TopoDS_Shape& aShape,
const bool isVolume); const bool isVolume);
void SetParameters(const NETGENPlugin_Hypothesis* hyp); void SetParameters(const NETGENPlugin_Hypothesis* hyp);
@ -52,7 +55,7 @@ class NETGENPLUGIN_EXPORT NETGENPlugin_Mesher
bool Compute(); bool Compute();
private: private:
SMESHDS_Mesh* _meshDS; SMESH_Mesh* _mesh;
const TopoDS_Shape& _shape; const TopoDS_Shape& _shape;
bool _isVolume; bool _isVolume;
bool _optimize; bool _optimize;

49
src/NETGENPlugin/NETGENPlugin_NETGEN_2D.cxx
View File

@ -119,53 +119,10 @@ bool NETGENPlugin_NETGEN_2D::CheckHypothesis
bool NETGENPlugin_NETGEN_2D::Compute(SMESH_Mesh& aMesh, bool NETGENPlugin_NETGEN_2D::Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape) 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); mesher.SetParameters(_hypothesis);
return mesher.Compute(); 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 );
}

5
src/NETGENPlugin/NETGENPlugin_NETGEN_2D.hxx
View File

@ -51,11 +51,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, virtual bool Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape); 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: protected:
const NETGENPlugin_Hypothesis_2D* _hypothesis; const NETGENPlugin_Hypothesis_2D* _hypothesis;
}; };

49
src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.cxx
View File

@ -121,53 +121,10 @@ bool NETGENPlugin_NETGEN_2D3D::CheckHypothesis
bool NETGENPlugin_NETGEN_2D3D::Compute(SMESH_Mesh& aMesh, bool NETGENPlugin_NETGEN_2D3D::Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape) 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); mesher.SetParameters(_hypothesis);
return mesher.Compute(); 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 );
}

5
src/NETGENPlugin/NETGENPlugin_NETGEN_2D3D.hxx
View File

@ -51,11 +51,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, virtual bool Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape); 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: protected:
const NETGENPlugin_Hypothesis* _hypothesis; const NETGENPlugin_Hypothesis* _hypothesis;
}; };

84
src/NETGENPlugin/NETGENPlugin_NETGEN_3D.cxx
View File

@ -28,12 +28,13 @@
//============================================================================= //=============================================================================
#include "NETGENPlugin_NETGEN_3D.hxx" #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_MeshElement.hxx"
#include "SMDS_MeshNode.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 "SMESH_MesherHelper.hxx"
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
@ -158,7 +159,8 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh& aMesh,
// get triangles on aShell and make a map of nodes to Netgen node IDs // 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); bool _quadraticMesh = myTool->IsQuadraticSubMesh(aShape);
typedef map< const SMDS_MeshNode*, int> TNodeToIDMap; typedef map< const SMDS_MeshNode*, int> TNodeToIDMap;
@ -185,12 +187,12 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh& aMesh,
{ {
// check element // check element
const SMDS_MeshElement* elem = iteratorElem->next(); const SMDS_MeshElement* elem = iteratorElem->next();
if ( !elem || if ( !elem )
!( elem->NbNodes()==3 || ( _quadraticMesh && elem->NbNodes()==6) ) ) { return error( COMPERR_BAD_INPUT_MESH, "Null element encounters");
INFOS( "NETGENPlugin_NETGEN_3D::Compute(), bad mesh"); bool isTraingle = ( elem->NbNodes()==3 || (_quadraticMesh && elem->NbNodes()==6 ));
delete myTool; myTool = 0; if ( !isTraingle )
return false; return error( COMPERR_BAD_INPUT_MESH,
} SMESH_Comment("Not triangle element ")<<elem->GetID());
// keep a triangle // keep a triangle
triangles.push_back( elem ); triangles.push_back( elem );
isReversed.push_back( isRev ); isReversed.push_back( isRev );
@ -314,8 +316,18 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh& aMesh,
} }
catch (...) { catch (...) {
MESSAGE("An exception has been caught during the Volume Mesh Generation ..."); MESSAGE("An exception has been caught during the Volume Mesh Generation ...");
error(dfltErr(), "Exception in Ng_GenerateVolumeMesh()");
status = NG_VOLUME_FAILURE; 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); int Netgen_NbOfNodesNew = Ng_GetNP(Netgen_mesh);
@ -329,7 +341,7 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh& aMesh,
// Feed back the SMESHDS with the generated Nodes and Volume Elements // 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 ) if ( isOK )
{ {
// vector of nodes in which node index == netgen ID // vector of nodes in which node index == netgen ID
@ -366,51 +378,5 @@ bool NETGENPlugin_NETGEN_3D::Compute(SMESH_Mesh& aMesh,
Ng_DeleteMesh(Netgen_mesh); Ng_DeleteMesh(Netgen_mesh);
Ng_Exit(); Ng_Exit();
delete myTool; myTool = 0; return (status == NG_OK);
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 );
} }

5
src/NETGENPlugin/NETGENPlugin_NETGEN_3D.hxx
View File

@ -49,11 +49,6 @@ public:
virtual bool Compute(SMESH_Mesh& aMesh, virtual bool Compute(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape); 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: protected:
double _maxElementVolume; double _maxElementVolume;