#ifndef _SMESH_NETGENALGORITHM_IDL_
#define _SMESH_NETGENALGORITHM_IDL_
+#include "SALOME_Exception.idl"
#include "SMESH_Hypothesis.idl"
/*!
boolean GetQuadAllowed();
};
+ /*!
+ * NETGENPlugin_Hypothesis: interface of "NETGEN 2D simple parameters" hypothesis
+ */
+ interface NETGENPlugin_SimpleHypothesis_2D : SMESH::SMESH_Hypothesis
+ {
+ /*!
+ * Sets <number of segments> value
+ */
+ void SetNumberOfSegments(in short nb) raises (SALOME::SALOME_Exception);
+ /*!
+ * Returns <number of segments> value.
+ * Can be zero in case if LocalLength() has been set
+ */
+ short GetNumberOfSegments();
+
+ /*!
+ * Sets <segment length> value
+ */
+ void SetLocalLength(in double segmentLength);
+ /*!
+ * Returns <segment length> value.
+ * Can be zero in case if NumberOfSegments() has been set
+ */
+ double GetLocalLength();
+
+ /*!
+ * Sets <maximum element area> to be dependent on 1D discretization
+ */
+ void LengthFromEdges();
+ /*!
+ * Sets <maximum element area> value.
+ * Zero or negative value means same as LengthFromEdges().
+ */
+ void SetMaxElementArea(in double area);
+ /*!
+ * Returns <maximum element area> value.
+ * Can be zero in case of LengthFromEdges()
+ */
+ double GetMaxElementArea();
+ };
+
+ /*!
+ * NETGENPlugin_SimpleHypothesis_3D: interface of "NETGEN 3D simple parameters" hypothesis
+ */
+ interface NETGENPlugin_SimpleHypothesis_3D : NETGENPlugin_SimpleHypothesis_2D
+ {
+ /*!
+ * Sets <maximum element volume> to be dependent on 2D discretization
+ */
+ void LengthFromFaces();
+ /*!
+ * Sets <maximum element volume> value.
+ * Zero or negative value means same as LengthFromFaces().
+ */
+ void SetMaxElementVolume(in double volume);
+
+ /*!
+ * Returns <maximum element volume> value
+ * Can be zero in case of LengthFromFaces()
+ */
+ double GetMaxElementVolume();
+ };
+
};
#endif
label-id="NETGEN 2D Parameters"
icon-id="mesh_hypo_netgen_2d.png"
dim="2"/>
+ <hypothesis type="NETGEN_SimpleParameters_2D"
+ label-id="NETGEN 2D Simple Parameters"
+ icon-id="mesh_hypo_netgen_2d.png"
+ dim="2"/>
+ <hypothesis type="NETGEN_SimpleParameters_3D"
+ label-id="NETGEN 3D Simple Parameters"
+ icon-id="mesh_hypo_netgen.png"
+ dim="3"/>
</hypotheses>
<algorithms>
<algorithm type="NETGEN_3D"
<algorithm type="NETGEN_2D"
label-id="Netgen 1D-2D"
icon-id="mesh_algo_netgen_2d.png"
- hypos="NETGEN_Parameters_2D"
+ hypos="NETGEN_Parameters_2D, NETGEN_SimpleParameters_2D"
output="TRIA,QUAD"
- dim="2"/>
+ dim="2"
+ support-submeshes="true"
+ />
<algorithm type="NETGEN_2D3D"
label-id="Netgen 1D-2D-3D"
icon-id="mesh_algo_netgen_2d3d.png"
- hypos="NETGEN_Parameters"
- dim="3"/>
+ hypos="NETGEN_Parameters, NETGEN_SimpleParameters_3D"
+ dim="3"
+ support-submeshes="true"
+ />
<algorithm type="NETGEN_2D_ONLY"
label-id="Netgen 2D"
icon-id="mesh_algo_netgen_2d.png"
dist_libNETGENPluginGUI_la_SOURCES = \
NETGENPluginGUI.cxx \
- NETGENPluginGUI_HypothesisCreator.cxx
+ NETGENPluginGUI_HypothesisCreator.cxx \
+ NETGENPluginGUI_SimpleCreator.cxx
MOC_FILES = \
- NETGENPluginGUI_HypothesisCreator_moc.cxx
+ NETGENPluginGUI_HypothesisCreator_moc.cxx \
+ NETGENPluginGUI_SimpleCreator_moc.cxx
nodist_libNETGENPluginGUI_la_SOURCES= \
$(MOC_FILES)
//#include "SMESHGUI_Hypotheses.h"
#include "NETGENPluginGUI_HypothesisCreator.h"
+#include "NETGENPluginGUI_SimpleCreator.h"
//=============================================================================
/*! GetHypothesisCreator
SMESHGUI_GenericHypothesisCreator* aCreator = NULL;
if( aHypType=="NETGEN_Parameters_2D" || aHypType=="NETGEN_Parameters" )
aCreator = new NETGENPluginGUI_HypothesisCreator( aHypType );
+ else if ( aHypType=="NETGEN_SimpleParameters_2D" ||
+ aHypType=="NETGEN_SimpleParameters_3D" )
+ aCreator = new NETGENPluginGUI_SimpleCreator( aHypType );
return aCreator;
}
}
<source>ICON_DLG_NETGEN_PARAMETERS_2D</source>
<translation>mesh_hypo_netgen_2d.png</translation>
</message>
+ <message>
+ <source>ICON_DLG_NETGEN_SimpleParameters_3D</source>
+ <translation>mesh_hypo_netgen.png</translation>
+ </message>
+ <message>
+ <source>ICON_DLG_NETGEN_SimpleParameters_2D</source>
+ <translation>mesh_hypo_netgen_2d.png</translation>
+ </message>
<message>
<source>ICON_SMESH_TREE_ALGO_NETGEN_2D</source>
<translation>mesh_tree_algo_netgen_2d.png</translation>
<source>ICON_SMESH_TREE_HYPO_NETGEN_Parameters_2D</source>
<translation>mesh_tree_hypo_netgen_2d.png</translation>
</message>
+ <message>
+ <source>ICON_SMESH_TREE_HYPO_NETGEN_SimpleParameters_3D</source>
+ <translation>mesh_tree_hypo_netgen.png</translation>
+ </message>
+ <message>
+ <source>ICON_SMESH_TREE_HYPO_NETGEN_SimpleParameters_2D</source>
+ <translation>mesh_tree_hypo_netgen_2d.png</translation>
+ </message>
</context>
</TS>
<source>NETGEN_3D_TITLE</source>
<translation>Hypothesis Construction</translation>
</message>
+ <message>
+ <source>NETGEN_SimpleParameters_3D_HYPOTHESIS</source>
+ <translation>Netgen 3D simple parameters</translation>
+ </message>
+ <message>
+ <source>NETGEN_SimpleParameters_3D_TITLE</source>
+ <translation>Hypothesis Construction</translation>
+ </message>
+ <message>
+ <source>NETGEN_SimpleParameters_2D_HYPOTHESIS</source>
+ <translation>Netgen 2D simple parameters</translation>
+ </message>
+ <message>
+ <source>NETGEN_SimpleParameters_2D_TITLE</source>
+ <translation>Hypothesis Construction</translation>
+ </message>
<message>
<source>NETGEN_ALLOW_QUADRANGLES</source>
<translation>Allow Quadrangles</translation>
<source>NETGEN_VERYFINE</source>
<translation>Very Fine</translation>
</message>
+ <message>
+ <source>NG_1D</source>
+ <translation>1D</translation>
+ </message>
+ <message>
+ <source>NG_2D</source>
+ <translation>2D</translation>
+ </message>
+ <message>
+ <source>NG_3D</source>
+ <translation>3D</translation>
+ </message>
+ <message>
+ <source>NG_LENGTH_FROM_EDGES</source>
+ <translation>Length from edges</translation>
+ </message>
+ <message>
+ <source>NG_LENGTH_FROM_FACES</source>
+ <translation>Length from faces</translation>
+ </message>
</context>
</TS>
#include "NETGENPlugin_Mesher.hxx"
#include "NETGENPlugin_Hypothesis_2D.hxx"
+#include "NETGENPlugin_SimpleHypothesis_3D.hxx"
#include <SMESH_Mesh.hxx>
#include <SMESH_Comment.hxx>
#include <SMESH_ComputeError.hxx>
#include <SMESH_subMesh.hxx>
+#include <SMESH_MesherHelper.hxx>
#include <SMESHDS_Mesh.hxx>
#include <SMDS_MeshElement.hxx>
#include <SMDS_MeshNode.hxx>
#include <OSD_Path.hxx>
#include <OSD_File.hxx>
#include <TCollection_AsciiString.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
// Netgen include files
namespace nglib {
NETGENPlugin_Mesher::NETGENPlugin_Mesher (SMESH_Mesh* mesh,
const TopoDS_Shape& aShape,
const bool isVolume)
- : _mesh (mesh),
+ : _mesh (mesh),
_shape (aShape),
_isVolume(isVolume),
- _optimize(true)
+ _optimize(true),
+ _simpleHyp(NULL)
+{
+ defaultParameters();
+}
+
+//================================================================================
+/*!
+ * \brief Initialize global NETGEN parameters with default values
+ */
+//================================================================================
+
+void NETGENPlugin_Mesher::defaultParameters()
{
#ifdef WNT
netgen::MeshingParameters& mparams = netgen::GlobalMeshingParameters();
#else
netgen::MeshingParameters& mparams = netgen::mparam;
#endif
- // Initialize global NETGEN parameters by default values:
// maximal mesh edge size
mparams.maxh = NETGENPlugin_Hypothesis::GetDefaultMaxSize();
// minimal number of segments per edge
mparams.quad = static_cast<const NETGENPlugin_Hypothesis_2D*>
(hyp)->GetQuadAllowed() ? 1 : 0;
_optimize = hyp->GetOptimize();
+ _simpleHyp = NULL;
}
}
+//=============================================================================
+/*!
+ * Pass simple parameters to NETGEN
+ */
+//=============================================================================
+
+void NETGENPlugin_Mesher::SetParameters(const NETGENPlugin_SimpleHypothesis_2D* hyp)
+{
+ _simpleHyp = hyp;
+ if ( _simpleHyp )
+ defaultParameters();
+}
+
//=============================================================================
/*!
* Link - a pair of integer numbers
*/
//================================================================================
-void NETGENPlugin_Mesher::PrepareOCCgeometry(netgen::OCCGeometry& occgeo,
- const TopoDS_Shape& shape)
+void NETGENPlugin_Mesher::PrepareOCCgeometry(netgen::OCCGeometry& occgeo,
+ const TopoDS_Shape& shape,
+ SMESH_Mesh& mesh,
+ list< SMESH_subMesh* > * meshedSM)
{
- occgeo.shape = shape;
- occgeo.changed = 1;
- occgeo.BuildFMap();
-
BRepTools::Clean (shape);
BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh (shape, 0.01, true);
Bnd_Box bb;
netgen::Point<3> p1 = netgen::Point<3> (x1,y1,z1);
netgen::Point<3> p2 = netgen::Point<3> (x2,y2,z2);
occgeo.boundingbox = netgen::Box<3> (p1,p2);
+
+ occgeo.shape = shape;
+ occgeo.changed = 1;
+ //occgeo.BuildFMap();
+
+ // fill maps of shapes of occgeo with not yet meshed subshapes
+
+ // get root submeshes
+ list< SMESH_subMesh* > rootSM;
+ if ( SMESH_subMesh* sm = mesh.GetSubMeshContaining( shape )) {
+ rootSM.push_back( sm );
+ }
+ else {
+ for ( TopoDS_Iterator it( shape ); it.More(); it.Next() )
+ rootSM.push_back( mesh.GetSubMesh( it.Value() ));
+ }
+
+ // add subshapes of empty submeshes
+ list< SMESH_subMesh* >::iterator rootIt = rootSM.begin(), rootEnd = rootSM.end();
+ for ( ; rootIt != rootEnd; ++rootIt ) {
+ SMESH_subMesh * root = *rootIt;
+ SMESH_subMeshIteratorPtr smIt = root->getDependsOnIterator(/*includeSelf=*/true,
+ /*complexShapeFirst=*/true);
+ while ( smIt->more() ) {
+ SMESH_subMesh* sm = smIt->next();
+ if ( sm->IsEmpty() ) {
+ switch ( sm->GetSubShape().ShapeType() ) {
+ case TopAbs_FACE : occgeo.fmap.Add( sm->GetSubShape() ); break;
+ case TopAbs_EDGE : occgeo.emap.Add( sm->GetSubShape() ); break;
+ case TopAbs_VERTEX: occgeo.vmap.Add( sm->GetSubShape() ); break;
+ case TopAbs_SOLID :occgeo.somap.Add( sm->GetSubShape() ); break;
+ default:;
+ }
+ }
+ // collect submeshes of meshed shapes
+ else if (meshedSM) {
+ meshedSM->push_back( sm );
+ }
+ }
+ }
+ occgeo.facemeshstatus.SetSize (occgeo.fmap.Extent());
+ occgeo.facemeshstatus = 0;
+
+}
+
+//================================================================================
+/*!
+ * \brief return id of netgen point corresponding to SMDS node
+ */
+//================================================================================
+
+static int ngNodeId( const SMDS_MeshNode* node,
+ netgen::Mesh& ngMesh,
+ map< const SMDS_MeshNode*, int >& nodeNgIdMap)
+{
+ int newNgId = ngMesh.GetNP() + 1;
+
+ pair< map< const SMDS_MeshNode*, int >::iterator, bool > it_isNew =
+ nodeNgIdMap.insert( make_pair( node, newNgId ));
+
+ if ( it_isNew.second ) {
+ netgen::MeshPoint p( netgen::Point<3> (node->X(), node->Y(), node->Z()) );
+ ngMesh.AddPoint( p );
+ }
+ return it_isNew.first->second;
+}
+
+//================================================================================
+/*!
+ * \brief fill ngMesh with nodes and elements of computed submeshes
+ */
+//================================================================================
+
+bool NETGENPlugin_Mesher::fillNgMesh(netgen::OCCGeometry& occgeom,
+ netgen::Mesh& ngMesh,
+ vector<SMDS_MeshNode*>& nodeVec,
+ const list< SMESH_subMesh* > & meshedSM)
+{
+ map< const SMDS_MeshNode*, int > nodeNgIdMap;
+
+ TopTools_MapOfShape visitedShapes;
+
+ SMESH_MesherHelper helper (*_mesh);
+
+ int faceID = occgeom.fmap.Extent();
+ _faceDescriptors.clear();
+
+ list< SMESH_subMesh* >::const_iterator smIt, smEnd = meshedSM.end();
+ for ( smIt = meshedSM.begin(); smIt != smEnd; ++smIt )
+ {
+ SMESH_subMesh* sm = *smIt;
+ if ( !visitedShapes.Add( sm->GetSubShape() ))
+ continue;
+
+ SMESHDS_SubMesh * smDS = sm->GetSubMeshDS();
+
+ switch ( sm->GetSubShape().ShapeType() )
+ {
+ case TopAbs_EDGE: { // EDGE
+ // ----------------------
+ const TopoDS_Edge& geomEdge = TopoDS::Edge( sm->GetSubShape() );
+
+ // Add ng segments for each not meshed face the edge bounds
+ TopTools_MapOfShape visitedAncestors;
+ const TopTools_ListOfShape& ancestors = _mesh->GetAncestors( geomEdge );
+ TopTools_ListIteratorOfListOfShape ancestorIt ( ancestors );
+ for ( ; ancestorIt.More(); ancestorIt.Next() )
+ {
+ const TopoDS_Shape & ans = ancestorIt.Value();
+ if ( ans.ShapeType() != TopAbs_FACE || !visitedAncestors.Add( ans ))
+ continue;
+ const TopoDS_Face& face = TopoDS::Face( ans );
+
+ int faceID = occgeom.fmap.FindIndex( face );
+ if ( faceID < 1 )
+ continue; // meshed face
+
+ // find out orientation of geomEdge within face
+ bool isForwad = false;
+ for ( TopExp_Explorer exp( face, TopAbs_EDGE ); exp.More(); exp.Next() ) {
+ if ( geomEdge.IsSame( exp.Current() )) {
+ isForwad = ( exp.Current().Orientation() == geomEdge.Orientation() );
+ break;
+ }
+ }
+ bool isQuad = smDS->GetElements()->next()->IsQuadratic();
+
+ // get all nodes from geomEdge
+ StdMeshers_FaceSide fSide( face, geomEdge, _mesh, isForwad, isQuad );
+ const vector<UVPtStruct>& points = fSide.GetUVPtStruct();
+ int i, nbSeg = fSide.NbSegments();
+
+ double otherSeamParam = 0;
+ helper.SetSubShape( face );
+ bool isSeam = helper.IsRealSeam( geomEdge );
+ if ( isSeam )
+ otherSeamParam =
+ helper.GetOtherParam( helper.GetPeriodicIndex() == 1 ? points[0].u : points[0].v );
+
+ // add segments
+
+ int prevNgId = ngNodeId( points[0].node, ngMesh, nodeNgIdMap );
+
+ for ( i = 0; i < nbSeg; ++i )
+ {
+ const UVPtStruct& p1 = points[ i ];
+ const UVPtStruct& p2 = points[ i+1 ];
+
+ netgen::Segment seg;
+ // ng node ids
+ seg.p1 = prevNgId;
+ seg.p2 = prevNgId = ngNodeId( p2.node, ngMesh, nodeNgIdMap );
+ // node param on curve
+ seg.epgeominfo[ 0 ].dist = p1.param;
+ seg.epgeominfo[ 1 ].dist = p2.param;
+ // uv on face
+ seg.epgeominfo[ 0 ].u = p1.u;
+ seg.epgeominfo[ 0 ].v = p1.v;
+ seg.epgeominfo[ 1 ].u = p2.u;
+ seg.epgeominfo[ 1 ].v = p2.v;
+
+ //seg.epgeominfo[ iEnd ].edgenr = edgeID; // = geom.emap.FindIndex(edge);
+ seg.si = faceID; // = geom.fmap.FindIndex (face);
+ seg.edgenr = ngMesh.GetNSeg() + 1; // segment id
+ ngMesh.AddSegment (seg);
+
+ if ( isSeam )
+ {
+ if ( helper.GetPeriodicIndex() == 1 ) {
+ seg.epgeominfo[ 0 ].u = otherSeamParam;
+ seg.epgeominfo[ 1 ].u = otherSeamParam;
+ swap (seg.epgeominfo[0].v, seg.epgeominfo[1].v);
+ } else {
+ seg.epgeominfo[ 0 ].v = otherSeamParam;
+ seg.epgeominfo[ 1 ].v = otherSeamParam;
+ swap (seg.epgeominfo[0].u, seg.epgeominfo[1].u);
+ }
+ swap (seg.p1, seg.p2);
+ swap (seg.epgeominfo[0].dist, seg.epgeominfo[1].dist);
+ seg.edgenr = ngMesh.GetNSeg() + 1; // segment id
+ ngMesh.AddSegment (seg);
+ }
+ }
+ } // loop on geomEdge ancestors
+
+ break;
+ } // case TopAbs_EDGE
+
+ case TopAbs_FACE: { // FACE
+ // ----------------------
+ const TopoDS_Face& geomFace = TopoDS::Face( sm->GetSubShape() );
+ helper.SetSubShape( geomFace );
+
+ // find solids geomFace bounds
+ int solidID1 = 0, solidID2 = 0;
+ const TopTools_ListOfShape& ancestors = _mesh->GetAncestors( geomFace );
+ TopTools_ListIteratorOfListOfShape ancestorIt ( ancestors );
+ for ( ; ancestorIt.More(); ancestorIt.Next() )
+ {
+ const TopoDS_Shape & solid = ancestorIt.Value();
+ if ( solid.ShapeType() == TopAbs_SOLID ) {
+ int id = occgeom.somap.FindIndex ( solid );
+ if ( solidID1 && id != solidID1 ) solidID2 = id;
+ else solidID1 = id;
+ }
+ }
+ faceID++;
+ _faceDescriptors[ faceID ].first = solidID1;
+ _faceDescriptors[ faceID ].second = solidID2;
+
+ // add surface elements
+ SMDS_ElemIteratorPtr faces = smDS->GetElements();
+ while ( faces->more() ) {
+
+ const SMDS_MeshElement* f = faces->next();
+ if ( f->NbNodes() % 3 != 0 ) { // not triangle
+ for ( ancestorIt.Initialize(ancestors); ancestorIt.More(); ancestorIt.Next() )
+ if ( ancestorIt.Value().ShapeType() == TopAbs_SOLID ) {
+ sm = _mesh->GetSubMesh( ancestorIt.Value() );
+ break;
+ }
+ SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
+ smError.reset( new SMESH_ComputeError(COMPERR_BAD_INPUT_MESH,"Not triangle submesh"));
+ smError->myBadElements.push_back( f );
+ return false;
+ }
+
+ netgen::Element2d tri(3);
+ tri.SetIndex ( faceID );
+
+ for ( int i = 0; i < 3; ++i ) {
+ const SMDS_MeshNode* node = f->GetNode( i ), * inFaceNode=0;
+ if ( helper.IsSeamShape( node->GetPosition()->GetShapeId() ))
+ if ( helper.IsSeamShape( f->GetNode( i+1 )->GetPosition()->GetShapeId() ))
+ inFaceNode = f->GetNode( i-1 );
+ else
+ inFaceNode = f->GetNode( i+1 );
+
+ gp_XY uv = helper.GetNodeUV( geomFace, node, inFaceNode );
+ tri.GeomInfoPi(i+1).u = uv.X();
+ tri.GeomInfoPi(i+1).v = uv.Y();
+ tri.PNum(i+1) = ngNodeId( node, ngMesh, nodeNgIdMap );
+ }
+
+ ngMesh.AddSurfaceElement (tri);
+
+ }
+ break;
+ } //
+
+ case TopAbs_VERTEX: { // VERTEX
+ // --------------------------
+ SMDS_NodeIteratorPtr nodeIt = smDS->GetNodes();
+ if ( nodeIt->more() )
+ ngNodeId( nodeIt->next(), ngMesh, nodeNgIdMap );
+ break;
+ }
+ default:;
+ } // switch
+ } // loop on submeshes
+
+ // fill nodeVec
+ nodeVec.resize( ngMesh.GetNP() + 1 );
+ map< const SMDS_MeshNode*, int >::iterator node_NgId, nodeNgIdEnd = nodeNgIdMap.end();
+ for ( node_NgId = nodeNgIdMap.begin(); node_NgId != nodeNgIdEnd; ++node_NgId)
+ nodeVec[ node_NgId->second ] = (SMDS_MeshNode*) node_NgId->first;
+
+ return true;
}
//=============================================================================
// -------------------------
netgen::OCCGeometry occgeo;
- PrepareOCCgeometry( occgeo, _shape );
+ list< SMESH_subMesh* > meshedSM;
+ PrepareOCCgeometry( occgeo, _shape, *_mesh, &meshedSM );
// -------------------------
// Generate the mesh
// -------------------------
netgen::Mesh *ngMesh = NULL;
- // we start always with ANALYSE,
- // but end depending on _optimize and _isVolume
- int startWith = netgen::MESHCONST_ANALYSE;
- int endWith = (_optimize
- ? (_isVolume ? netgen::MESHCONST_OPTVOLUME : netgen::MESHCONST_OPTSURFACE)
- : netgen::MESHCONST_MESHSURFACE);
- char *optstr = 0;
- int err = 0;
SMESH_Comment comment;
+ int err = 0;
+ int nbInitNod = 0;
+ int nbInitSeg = 0;
+ int nbInitFac = 0;
+ // vector of nodes in which node index == netgen ID
+ vector< SMDS_MeshNode* > nodeVec;
try
{
+ // ----------------
+ // compute 1D mesh
+ // ----------------
+ // pass 1D simple parameters to NETGEN
+ if ( _simpleHyp ) {
+ if ( int nbSeg = _simpleHyp->GetNumberOfSegments() ) {
+ // nb of segments
+ mparams.segmentsperedge = nbSeg + 0.1;
+ mparams.maxh = occgeo.boundingbox.Diam();
+ mparams.grading = 0;
+ }
+ else {
+ // segment length
+ mparams.segmentsperedge = 1;
+ mparams.maxh = _simpleHyp->GetLocalLength();
+ }
+ }
+ // let netgen create ngMesh and calculate element size on not meshed shapes
+ char *optstr = 0;
+ int startWith = netgen::MESHCONST_ANALYSE;
+ int endWith = netgen::MESHCONST_ANALYSE;
err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
- if (err) comment << "Error in netgen::OCCGenerateMesh()";
- if (!err && !_optimize)
+ if (err) comment << "Error in netgen::OCCGenerateMesh() at MESHCONST_ANALYSE step";
+
+ // fill ngMesh with nodes and elements of computed submeshes
+ err = ! fillNgMesh(occgeo, *ngMesh, nodeVec, meshedSM);
+ nbInitNod = ngMesh->GetNP();
+ nbInitSeg = ngMesh->GetNSeg();
+ nbInitFac = ngMesh->GetNSE();
+
+ // compute mesh
+ if (!err)
{
- // we have got surface mesh only, so generate volume mesh
- startWith = endWith = netgen::MESHCONST_MESHVOLUME;
+ startWith = endWith = netgen::MESHCONST_MESHEDGES;
+ err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
+ if (err) comment << "Error in netgen::OCCGenerateMesh() at 1D mesh generation";
+ }
+ // ---------------------
+ // compute surface mesh
+ // ---------------------
+ if (!err)
+ {
+ // pass 2D simple parameters to NETGEN
+ if ( _simpleHyp ) {
+ if ( double area = _simpleHyp->GetMaxElementArea() ) {
+ // face area
+ mparams.maxh = sqrt(2. * area/sqrt(3.0));
+ mparams.grading = 0.4; // moderate size growth
+ }
+ else {
+ // length from edges
+ double length = 0;
+ for ( TopExp_Explorer exp( _shape, TopAbs_EDGE ); exp.More(); exp.Next() )
+ length += SMESH_Algo::EdgeLength( TopoDS::Edge( exp.Current() ));
+ if ( ngMesh->GetNSeg() )
+ mparams.maxh = length / ngMesh->GetNSeg();
+ else
+ mparams.maxh = 1000;
+ mparams.grading = 0.2; // slow size growth
+ }
+ mparams.maxh = min( mparams.maxh, occgeo.boundingbox.Diam()/2 );
+ ngMesh->SetGlobalH (mparams.maxh);
+ netgen::Box<3> bb = occgeo.GetBoundingBox();
+ bb.Increase (bb.Diam()/20);
+ ngMesh->SetLocalH (bb.PMin(), bb.PMax(), mparams.grading);
+ }
+ // let netgen compute 2D mesh
+ startWith = netgen::MESHCONST_MESHSURFACE;
+ endWith = _optimize ? netgen::MESHCONST_OPTSURFACE : netgen::MESHCONST_MESHSURFACE;
+ err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
+ if (err) comment << "Error in netgen::OCCGenerateMesh() at surface mesh generation";
+ }
+ // ---------------------
+ // generate volume mesh
+ // ---------------------
+ if (!err && _isVolume)
+ {
+ // add ng face descriptors of meshed faces
+ std::map< int, std::pair<int,int> >::iterator fId_soIds = _faceDescriptors.begin();
+ for ( ; fId_soIds != _faceDescriptors.end(); ++fId_soIds ) {
+ int faceID = fId_soIds->first;
+ int solidID1 = fId_soIds->second.first;
+ int solidID2 = fId_soIds->second.second;
+ ngMesh->AddFaceDescriptor (netgen::FaceDescriptor(faceID, solidID1, solidID2, 0));
+ }
+ // pass 3D simple parameters to NETGEN
+ const NETGENPlugin_SimpleHypothesis_3D* simple3d =
+ dynamic_cast< const NETGENPlugin_SimpleHypothesis_3D* > ( _simpleHyp );
+ if ( simple3d ) {
+ if ( double vol = simple3d->GetMaxElementVolume() ) {
+ // max volume
+ mparams.maxh = pow( 72 * vol * vol, 1/3. );
+ mparams.maxh = min( mparams.maxh, occgeo.boundingbox.Diam()/2 );
+ }
+ else {
+ // length from faces
+ mparams.maxh = ngMesh->AverageH();
+ }
+// netgen::ARRAY<double> maxhdom;
+// maxhdom.SetSize (occgeo.NrSolids());
+// maxhdom = mparams.maxh;
+// ngMesh->SetMaxHDomain (maxhdom);
+ ngMesh->SetGlobalH (mparams.maxh);
+ mparams.grading = 0.4;
+ ngMesh->CalcLocalH();
+ }
+ // let netgen compute 3D mesh
+ startWith = netgen::MESHCONST_MESHVOLUME;
+ endWith = _optimize ? netgen::MESHCONST_OPTVOLUME : netgen::MESHCONST_MESHVOLUME;
err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr);
if (err) comment << "Error in netgen::OCCGenerateMesh()";
}
bool isOK = ( !err && (_isVolume ? (nbVol > 0) : (nbFac > 0)) );
if ( true /*isOK*/ ) // get whatever built
{
- // vector of nodes in which node index == netgen ID
- vector< SMDS_MeshNode* > nodeVec ( nbNod + 1 );
// map of nodes assigned to submeshes
NCollection_Map<int> pindMap;
// create and insert nodes into nodeVec
+ nodeVec.resize( nbNod + 1 );
int i;
- for (i = 1; i <= nbNod /*&& isOK*/; ++i )
+ for (i = nbInitNod+1; i <= nbNod /*&& isOK*/; ++i )
{
const netgen::MeshPoint& ngPoint = ngMesh->Point(i);
SMDS_MeshNode* node = NULL;
bool newNodeOnVertex = false;
TopoDS_Vertex aVert;
- if (i <= occgeo.vmap.Extent())
+ if (i-nbInitNod <= occgeo.vmap.Extent())
{
// point on vertex
- aVert = TopoDS::Vertex(occgeo.vmap(i));
+ aVert = TopoDS::Vertex(occgeo.vmap(i-nbInitNod));
SMESHDS_SubMesh * submesh = meshDS->MeshElements(aVert);
if (submesh)
{
// create mesh segments along geometric edges
NCollection_Map<Link> linkMap;
- for (i = 1; i <= nbSeg/* && isOK*/; ++i )
+ for (i = nbInitSeg+1; i <= nbSeg/* && isOK*/; ++i )
{
const netgen::Segment& seg = ngMesh->LineSegment(i);
Link link(seg.p1, seg.p2);
}
else
param = param2 * 0.5;
- if (pindMap.Contains(pind))
+ if (pind <= nbInitNod || pindMap.Contains(pind))
continue;
if (!aEdge.IsNull())
{
}
// create mesh faces along geometric faces
- for (i = 1; i <= nbFac/* && isOK*/; ++i )
+ for (i = nbInitFac+1; i <= nbFac/* && isOK*/; ++i )
{
const netgen::Element2d& elem = ngMesh->SurfaceElement(i);
int aGeomFaceInd = elem.GetIndex();
int pind = elem.PNum(j);
SMDS_MeshNode* node = nodeVec.at(pind);
nodes.push_back(node);
- if (pindMap.Contains(pind))
+ if (pind <= nbInitNod || pindMap.Contains(pind))
continue;
if (!aFace.IsNull())
{
int pind = elem.PNum(j);
SMDS_MeshNode* node = nodeVec.at(pind);
nodes.push_back(node);
- if (pindMap.Contains(pind))
+ if (pind <= nbInitNod || pindMap.Contains(pind))
continue;
if (!aSolid.IsNull())
{
#include "NETGENPlugin_Defs.hxx"
#include "StdMeshers_FaceSide.hxx"
+#include <map>
class SMESH_Mesh;
class SMESHDS_Mesh;
class TopoDS_Shape;
class NETGENPlugin_Hypothesis;
+class NETGENPlugin_SimpleHypothesis_2D;
namespace netgen {
class OCCGeometry;
+ class Mesh;
}
/*!
const bool isVolume);
void SetParameters(const NETGENPlugin_Hypothesis* hyp);
+ void SetParameters(const NETGENPlugin_SimpleHypothesis_2D* hyp);
bool Compute();
- static void PrepareOCCgeometry(netgen::OCCGeometry& occgeom,
- const TopoDS_Shape& shape);
+ static void PrepareOCCgeometry(netgen::OCCGeometry& occgeom,
+ const TopoDS_Shape& shape,
+ SMESH_Mesh& mesh,
+ std::list< SMESH_subMesh* > * meshedSM=0);
static void RemoveTmpFiles();
+protected:
+
+ bool fillNgMesh(netgen::OCCGeometry& occgeom,
+ netgen::Mesh& ngMesh,
+ std::vector<SMDS_MeshNode*>& nodeVec,
+ const std::list< SMESH_subMesh* > & meshedSM);
+
+ void defaultParameters();
+
+
private:
SMESH_Mesh* _mesh;
const TopoDS_Shape& _shape;
bool _isVolume;
bool _optimize;
+
+ const NETGENPlugin_SimpleHypothesis_2D * _simpleHyp;
+ std::map< int, std::pair<int,int> > _faceDescriptors;
};
#endif
//=============================================================================
#include "NETGENPlugin_NETGEN_2D.hxx"
#include "NETGENPlugin_Hypothesis_2D.hxx"
+#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
#include "NETGENPlugin_Mesher.hxx"
#include <SMESH_Gen.hxx>
_name = "NETGEN_2D";
_shapeType = (1 << TopAbs_FACE); // 1 bit /shape type
_compatibleHypothesis.push_back("NETGEN_Parameters_2D");
+ _compatibleHypothesis.push_back("NETGEN_SimpleParameters_2D");
_requireDescretBoundary = false;
_onlyUnaryInput = false;
_hypothesis = NULL;
+ _supportSubmeshes = true;
}
//=============================================================================
{
_hypothesis = NULL;
- list<const SMESHDS_Hypothesis*>::const_iterator itl;
- const SMESHDS_Hypothesis* theHyp;
-
const list<const SMESHDS_Hypothesis*>& hyps = GetUsedHypothesis(aMesh, aShape);
int nbHyp = hyps.size();
if (!nbHyp)
aStatus = SMESH_Hypothesis::HYP_OK;
return true; // can work with no hypothesis
}
-
- itl = hyps.begin();
- theHyp = (*itl); // use only the first hypothesis
+ // use only the first hypothesis
+ const SMESHDS_Hypothesis* theHyp = hyps.front();
string hypName = theHyp->GetName();
-
- if (hypName == "NETGEN_Parameters_2D")
+ if ( find( _compatibleHypothesis.begin(), _compatibleHypothesis.end(),
+ hypName ) != _compatibleHypothesis.end() )
{
- _hypothesis = static_cast<const NETGENPlugin_Hypothesis_2D*> (theHyp);
- ASSERT(_hypothesis);
+ _hypothesis = theHyp;
aStatus = SMESH_Hypothesis::HYP_OK;
}
else
+ {
aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+ }
return aStatus == SMESH_Hypothesis::HYP_OK;
}
NETGENPlugin_Mesher mesher(&aMesh, aShape, false);
// NETGENPlugin_Mesher mesher(meshDS, aShape, false);
- mesher.SetParameters(_hypothesis);
+ mesher.SetParameters(dynamic_cast<const NETGENPlugin_Hypothesis*>(_hypothesis));
+ mesher.SetParameters(dynamic_cast<const NETGENPlugin_SimpleHypothesis_2D*>(_hypothesis));
return mesher.Compute();
}
#include "StdMeshers_MaxElementVolume.hxx"
#include "Utils_SALOME_Exception.hxx"
-class NETGENPlugin_Hypothesis_2D;
+//class NETGENPlugin_Hypothesis_2D;
class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D: public SMESH_2D_Algo
{
const TopoDS_Shape& aShape);
protected:
- const NETGENPlugin_Hypothesis_2D* _hypothesis;
+ const SMESHDS_Hypothesis* _hypothesis;
};
#endif
//=============================================================================
#include "NETGENPlugin_NETGEN_2D3D.hxx"
#include "NETGENPlugin_Hypothesis.hxx"
+#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
#include "NETGENPlugin_Mesher.hxx"
#include <SMESH_Gen.hxx>
_name = "NETGEN_2D3D";
_shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID);// 1 bit /shape type
_compatibleHypothesis.push_back("NETGEN_Parameters");
+ _compatibleHypothesis.push_back("NETGEN_SimpleParameters_3D");
_requireDescretBoundary = false;
_onlyUnaryInput = false;
_hypothesis = NULL;
+ _supportSubmeshes = true;
}
//=============================================================================
_hypothesis = NULL;
- list<const SMESHDS_Hypothesis*>::const_iterator itl;
- const SMESHDS_Hypothesis* theHyp;
-
const list<const SMESHDS_Hypothesis*>& hyps = GetUsedHypothesis(aMesh, aShape);
int nbHyp = hyps.size();
if (!nbHyp)
return true; // can work with no hypothesis
}
- itl = hyps.begin();
- theHyp = (*itl); // use only the first hypothesis
+ const SMESHDS_Hypothesis* theHyp = hyps.front(); // use only the first hypothesis
string hypName = theHyp->GetName();
- if (hypName == "NETGEN_Parameters")
+ if ( find( _compatibleHypothesis.begin(), _compatibleHypothesis.end(),
+ hypName ) != _compatibleHypothesis.end() )
{
- _hypothesis = static_cast<const NETGENPlugin_Hypothesis*> (theHyp);
- ASSERT(_hypothesis);
+ _hypothesis = theHyp;
aStatus = SMESH_Hypothesis::HYP_OK;
}
else
+ {
aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+ }
return aStatus == SMESH_Hypothesis::HYP_OK;
}
NETGENPlugin_Mesher mesher(&aMesh, aShape, true);
// NETGENPlugin_Mesher mesher(meshDS, aShape, true);
- mesher.SetParameters(_hypothesis);
+ mesher.SetParameters(dynamic_cast<const NETGENPlugin_Hypothesis*>(_hypothesis));
+ mesher.SetParameters(dynamic_cast<const NETGENPlugin_SimpleHypothesis_2D*>(_hypothesis));
return mesher.Compute();
}
#include "StdMeshers_MaxElementVolume.hxx"
#include "Utils_SALOME_Exception.hxx"
-class NETGENPlugin_Hypothesis;
+//class NETGENPlugin_Hypothesis;
class NETGENPLUGIN_EXPORT NETGENPlugin_NETGEN_2D3D: public SMESH_3D_Algo
{
const TopoDS_Shape& aShape);
protected:
- const NETGENPlugin_Hypothesis* _hypothesis;
+ const SMESHDS_Hypothesis* _hypothesis;
};
#endif
netgen::Mesh * ngMesh = new netgen::Mesh ();
netgen::OCCGeometry occgeo;
- NETGENPlugin_Mesher::PrepareOCCgeometry( occgeo, F );
+ NETGENPlugin_Mesher::PrepareOCCgeometry( occgeo, F, aMesh );
vector< const SMDS_MeshNode* > nodeVec;
problem = AddSegmentsToMesh( *ngMesh, occgeo, wires, helper, nodeVec );
--- /dev/null
+// NETGENPlugin : C++ implementation
+//
+// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+// File : NETGENPlugin_SimpleHypothesis_2D.cxx
+// Author : Edward AGAPOV
+// Project : SALOME
+//=============================================================================
+
+#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
+#include "NETGENPlugin_Hypothesis.hxx"
+
+#include <SMESH_Mesh.hxx>
+#include <SMESH_subMesh.hxx>
+#include <SMESH_ControlsDef.hxx>
+
+#include <TopExp_Explorer.hxx>
+
+#include <utilities.h>
+
+using namespace std;
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+NETGENPlugin_SimpleHypothesis_2D::NETGENPlugin_SimpleHypothesis_2D (int hypId,
+ int studyId,
+ SMESH_Gen * gen)
+ : SMESH_Hypothesis(hypId, studyId, gen),
+ _nbSegments ((int)NETGENPlugin_Hypothesis::GetDefaultNbSegPerEdge()),
+ _segmentLength(0),
+ _area (0.)
+{
+ _name = "NETGEN_SimpleParameters_2D";
+ _param_algo_dim = 2;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_2D::SetNumberOfSegments(int nb) throw (SALOME_Exception)
+{
+ if ( nb < 1 )
+ throw SALOME_Exception("Number of segments must be positive");
+ if (nb != _nbSegments)
+ {
+ _nbSegments = nb;
+ if ( _nbSegments ) _segmentLength = 0.;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_2D::SetLocalLength(double segmentLength)
+ throw (SALOME_Exception)
+{
+ if ( segmentLength < DBL_MIN )
+ throw SALOME_Exception("segment length must be more than zero");
+ if (segmentLength != _segmentLength)
+ {
+ _segmentLength = segmentLength;
+ if ( _segmentLength > DBL_MIN ) _nbSegments = 0;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_2D::LengthFromEdges()
+{
+ if (_area > DBL_MIN )
+ {
+ _area = 0;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_2D::SetMaxElementArea(double area)
+{
+ if ( area < DBL_MIN )
+ area = 0.;
+ if (_area != area)
+ {
+ _area = area;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+ostream & NETGENPlugin_SimpleHypothesis_2D::SaveTo(ostream & save)
+{
+ save << _nbSegments << " " << _segmentLength << " " << _area;
+
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+istream & NETGENPlugin_SimpleHypothesis_2D::LoadFrom(istream & load)
+{
+ bool isOK = true;
+ double val;
+
+ isOK = (load >> val);
+ if (isOK)
+ _nbSegments = (int) val;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> val);
+ if (isOK)
+ _segmentLength = val;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ isOK = (load >> val);
+ if (isOK)
+ _area = val;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ return load;
+}
+
+//================================================================================
+/*!
+ * \brief Does nothing
+ * \param theMesh - the built mesh
+ * \param theShape - the geometry of interest
+ * \retval bool - always false
+ */
+//================================================================================
+bool NETGENPlugin_SimpleHypothesis_2D::SetParametersByMesh(const SMESH_Mesh* theMesh,
+ const TopoDS_Shape& theShape)
+{
+ // Find out nb of segments.
+ int nbSeg = 0, nbEdges = 0;
+ TopExp_Explorer exp( theShape, TopAbs_EDGE );
+ for ( ; exp.More(); exp.Next() ) {
+ SMESH_subMesh* sm = theMesh->GetSubMeshContaining( exp.Current() );
+ if ( sm && !sm->IsEmpty() ) {
+ nbSeg += sm->GetSubMeshDS()->NbElements();
+ nbEdges++;
+ }
+ }
+ if ( nbEdges )
+ _nbSegments = nbSeg / nbEdges;
+
+ // Find out max face area
+ _area = 0;
+ SMESH::Controls::Area areaControl;
+ SMESH::Controls::TSequenceOfXYZ nodesCoords;
+ const int nbFacesToCheck = 100;
+ for ( exp.Init( theShape, TopAbs_FACE ); exp.More(); exp.Next() ) {
+ SMESH_subMesh* sm = theMesh->GetSubMeshContaining( exp.Current() );
+ if ( sm && !sm->IsEmpty() ) {
+ SMDS_ElemIteratorPtr fIt = sm->GetSubMeshDS()->GetElements();
+ int nbCheckedFaces = 0;
+ while ( fIt->more() && nbCheckedFaces++ < nbFacesToCheck ) {
+ const SMDS_MeshElement* elem = fIt->next();
+ areaControl.GetPoints( elem, nodesCoords );
+ _area = max( _area, areaControl.GetValue( nodesCoords ));
+ }
+ }
+ }
+ return nbEdges;
+}
--- /dev/null
+// NETGENPlugin : C++ implementation
+//
+// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+// File : NETGENPlugin_SimpleHypothesis_2D.hxx
+// Author : Edward AGAPOV
+// Project : SALOME
+//=============================================================================
+
+#ifndef _NETGENPlugin_SimpleHypothesis_2D_HXX_
+#define _NETGENPlugin_SimpleHypothesis_2D_HXX_
+
+#include "NETGENPlugin_Defs.hxx"
+
+#include "SMESH_Hypothesis.hxx"
+#include "Utils_SALOME_Exception.hxx"
+
+// Simplified parameters of NETGEN
+//
+
+using namespace std;
+
+class NETGENPLUGIN_EXPORT NETGENPlugin_SimpleHypothesis_2D: public SMESH_Hypothesis
+{
+public:
+
+ NETGENPlugin_SimpleHypothesis_2D(int hypId, int studyId, SMESH_Gen * gen);
+
+ /*!
+ * Sets <number of segments> value
+ */
+ void SetNumberOfSegments(int nb) throw (SALOME_Exception);
+ /*!
+ * Returns <number of segments> value.
+ * Can be zero in case if LocalLength() has been set
+ */
+ int GetNumberOfSegments() const { return _nbSegments; }
+
+ /*!
+ * Sets <segment length> value
+ */
+ void SetLocalLength(double segmentLength) throw (SALOME_Exception);
+ /*!
+ * Returns <segment length> value.
+ * Can be zero in case if NumberOfSegments() has been set
+ */
+ double GetLocalLength() const { return _segmentLength; }
+
+ /*!
+ * Sets <maximum element area> to be dependent on 1D discretization
+ */
+ void LengthFromEdges();
+
+ /*!
+ * Sets <maximum element area> value.
+ * Zero or negative value means same as LengthFromEdges().
+ */
+ void SetMaxElementArea(double area);
+ /*!
+ * Returns <maximum element area> value.
+ * Can be zero in case of LengthFromEdges()
+ */
+ double GetMaxElementArea() const { return _area; }
+
+ // Persistence
+ virtual ostream & SaveTo(ostream & save);
+ virtual istream & LoadFrom(istream & load);
+
+ /*!
+ * \brief Set parameters by mesh
+ * \param theMesh - the built mesh
+ * \param theShape - the geometry of interest
+ * \retval bool - true if theShape is meshed
+ */
+ virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
+
+private:
+ int _nbSegments;
+ double _segmentLength, _area;
+};
+
+#endif
--- /dev/null
+// NETGENPlugin : C++ implementation
+//
+// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+// File : NETGENPlugin_SimpleHypothesis_2D_i.cxx
+// Author : Edward AGAPOV
+// Project : SALOME
+//=============================================================================
+
+#include "NETGENPlugin_SimpleHypothesis_2D_i.hxx"
+#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
+
+#include <SMESH_Gen.hxx>
+#include <SMESH_PythonDump.hxx>
+
+#include <Utils_CorbaException.hxx>
+#include <utilities.h>
+
+using namespace std;
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_2D_i::NETGENPlugin_SimpleHypothesis_2D_i
+ *
+ * Constructor
+ */
+//=============================================================================
+NETGENPlugin_SimpleHypothesis_2D_i::
+NETGENPlugin_SimpleHypothesis_2D_i (PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl)
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA )
+{
+ MESSAGE( "NETGENPlugin_SimpleHypothesis_2D_i::NETGENPlugin_SimpleHypothesis_2D_i" );
+ myBaseImpl = new ::NETGENPlugin_SimpleHypothesis_2D (theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl);
+}
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_2D_i::~NETGENPlugin_SimpleHypothesis_2D_i
+ *
+ * Destructor
+ */
+//=============================================================================
+NETGENPlugin_SimpleHypothesis_2D_i::~NETGENPlugin_SimpleHypothesis_2D_i()
+{
+ MESSAGE( "NETGENPlugin_SimpleHypothesis_2D_i::~NETGENPlugin_SimpleHypothesis_2D_i" );
+}
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_2D_i::SetNumberOfSegments
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_2D_i::SetNumberOfSegments(CORBA::Short nb)
+ throw ( SALOME::SALOME_Exception )
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::SetNumberOfSegments");
+ ASSERT(myBaseImpl);
+ try {
+ this->GetImpl()->SetNumberOfSegments(nb);
+ }
+ catch (SALOME_Exception& S_ex) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
+ }
+ SMESH::TPythonDump() << _this() << ".SetNumberOfSegments( " << nb << " )";
+}
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_2D_i::GetNumberOfSegments()
+ */
+//=============================================================================
+CORBA::Short NETGENPlugin_SimpleHypothesis_2D_i::GetNumberOfSegments()
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::GetNumberOfSegments");
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetNumberOfSegments();
+}
+
+//================================================================================
+/*!
+ * LocalLength()
+ */
+//================================================================================
+
+void NETGENPlugin_SimpleHypothesis_2D_i::SetLocalLength(CORBA::Double segmentLength)
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::SetLocalLength");
+ ASSERT(myBaseImpl);
+ try {
+ this->GetImpl()->SetLocalLength(segmentLength);
+ }
+ catch (SALOME_Exception& S_ex) {
+ THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
+ }
+ SMESH::TPythonDump() << _this() << ".LocalLength( " << segmentLength << " )";
+}
+
+//================================================================================
+/*!
+ * GetLocalLength()
+ */
+//================================================================================
+
+CORBA::Double NETGENPlugin_SimpleHypothesis_2D_i::GetLocalLength()
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::GetLocalLength");
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetLocalLength();
+}
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_2D_i::LengthFromEdges()
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_2D_i::LengthFromEdges()
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::LengthFromEdges");
+ ASSERT(myBaseImpl);
+ this->GetImpl()->LengthFromEdges();
+ SMESH::TPythonDump() << _this() << ".LengthFromEdges()";
+}
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_2D_i::SetMaxElementArea()
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_2D_i::SetMaxElementArea(CORBA::Double area)
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::SetMaxElementArea");
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetMaxElementArea(area);
+ SMESH::TPythonDump() << _this() << ".SetMaxElementArea( " << area << " )";
+}
+
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_2D_i::GetMaxElementArea()
+ */
+//=============================================================================
+CORBA::Double NETGENPlugin_SimpleHypothesis_2D_i::GetMaxElementArea()
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::GetMaxElementArea");
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetMaxElementArea();
+}
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_2D_i::GetImpl
+ */
+//=============================================================================
+::NETGENPlugin_SimpleHypothesis_2D* NETGENPlugin_SimpleHypothesis_2D_i::GetImpl()
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_2D_i::GetImpl");
+ return (::NETGENPlugin_SimpleHypothesis_2D*)myBaseImpl;
+}
+
+//================================================================================
+/*!
+ * \brief Verify whether hypothesis supports given entity type
+ * \param type - dimension (see SMESH::Dimension enumeration)
+ * \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
+ *
+ * Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
+ */
+//================================================================================
+CORBA::Boolean NETGENPlugin_SimpleHypothesis_2D_i::IsDimSupported( SMESH::Dimension type )
+{
+ return type == SMESH::DIM_2D;
+}
--- /dev/null
+// NETGENPlugin : C++ implementation
+//
+// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+// File : NETGENPlugin_SimpleHypothesis_2D_i.hxx
+// Author : Edward AGAPOV
+// Project : SALOME
+//=============================================================================
+
+#ifndef _NETGENPlugin_SimpleHypothesis_2D_i_HXX_
+#define _NETGENPlugin_SimpleHypothesis_2D_i_HXX_
+
+#include "NETGENPlugin_Defs.hxx"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(NETGENPlugin_Algorithm)
+
+#include "SMESH_Hypothesis_i.hxx"
+
+class SMESH_Gen;
+class NETGENPlugin_SimpleHypothesis_2D;
+
+// Simplified NETGEN parameters (2D case)
+
+class NETGENPLUGIN_EXPORT NETGENPlugin_SimpleHypothesis_2D_i:
+ public virtual POA_NETGENPlugin::NETGENPlugin_SimpleHypothesis_2D,
+ public virtual SMESH_Hypothesis_i
+{
+ public:
+ // Constructor
+ NETGENPlugin_SimpleHypothesis_2D_i (PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl);
+ // Destructor
+ virtual ~NETGENPlugin_SimpleHypothesis_2D_i();
+
+ void SetNumberOfSegments(CORBA::Short nb) throw ( SALOME::SALOME_Exception );
+ CORBA::Short GetNumberOfSegments();
+
+ void SetLocalLength(CORBA::Double segmentLength);
+ CORBA::Double GetLocalLength();
+
+
+ void LengthFromEdges();
+
+ void SetMaxElementArea(CORBA::Double area);
+ CORBA::Double GetMaxElementArea();
+
+
+ // Get implementation
+ ::NETGENPlugin_SimpleHypothesis_2D* GetImpl();
+
+ // Verify whether hypothesis supports given entity type
+ CORBA::Boolean IsDimSupported( SMESH::Dimension type );
+};
+
+#endif
--- /dev/null
+// NETGENPlugin : C++ implementation
+//
+// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+// File : NETGENPlugin_SimpleHypothesis_3D.cxx
+// Author : Edward AGAPOV
+// Project : SALOME
+//=============================================================================
+
+#include "NETGENPlugin_SimpleHypothesis_3D.hxx"
+#include "NETGENPlugin_Hypothesis.hxx"
+
+#include <SMESH_ControlsDef.hxx>
+#include <SMESH_Mesh.hxx>
+#include <SMESH_subMesh.hxx>
+
+#include <TopExp_Explorer.hxx>
+
+#include <utilities.h>
+
+using namespace std;
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+NETGENPlugin_SimpleHypothesis_3D::NETGENPlugin_SimpleHypothesis_3D (int hypId,
+ int studyId,
+ SMESH_Gen * gen)
+ : NETGENPlugin_SimpleHypothesis_2D(hypId, studyId, gen),
+ _volume(0)
+{
+ _name = "NETGEN_SimpleParameters_3D";
+ _param_algo_dim = 3;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_3D::LengthFromFaces()
+{
+ if (_volume > DBL_MIN )
+ {
+ _volume = 0;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_3D::SetMaxElementVolume(double value)
+{
+ if ( value < DBL_MIN )
+ value = 0.;
+ if (_volume != value)
+ {
+ _volume = value;
+ NotifySubMeshesHypothesisModification();
+ }
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+ostream & NETGENPlugin_SimpleHypothesis_3D::SaveTo(ostream & save)
+{
+ NETGENPlugin_SimpleHypothesis_2D::SaveTo( save );
+ save << " " << _volume;
+
+ return save;
+}
+
+//=============================================================================
+/*!
+ *
+ */
+//=============================================================================
+istream & NETGENPlugin_SimpleHypothesis_3D::LoadFrom(istream & load)
+{
+ NETGENPlugin_SimpleHypothesis_2D::LoadFrom(load);
+
+ bool isOK = true;
+ double val;
+
+ isOK = (load >> val);
+ if (isOK)
+ _volume = val;
+ else
+ load.clear(ios::badbit | load.rdstate());
+
+ return load;
+}
+
+//================================================================================
+/*!
+ * \brief Does nothing
+ * \param theMesh - the built mesh
+ * \param theShape - the geometry of interest
+ * \retval bool - always false
+ */
+//================================================================================
+bool NETGENPlugin_SimpleHypothesis_3D::SetParametersByMesh(const SMESH_Mesh* theMesh,
+ const TopoDS_Shape& theShape)
+{
+ if ( NETGENPlugin_SimpleHypothesis_2D::SetParametersByMesh(theMesh, theShape) )
+ {
+ // Find out max volume
+ _volume = 0;
+ SMESH::Controls::Volume volControl;
+ volControl.SetMesh( ((SMESH_Mesh*)theMesh)->GetMeshDS() );
+ const int nbElemToCheck = 100;
+ for ( TopExp_Explorer exp( theShape, TopAbs_SOLID ); exp.More(); exp.Next() ) {
+ SMESH_subMesh* sm = theMesh->GetSubMeshContaining( exp.Current() );
+ if ( sm && !sm->IsEmpty() ) {
+ SMDS_ElemIteratorPtr fIt = sm->GetSubMeshDS()->GetElements();
+ int nbCheckedElems = 0;
+ while ( fIt->more() && nbCheckedElems++ < nbElemToCheck ) {
+ const SMDS_MeshElement* elem = fIt->next();
+ _volume = max( _volume, volControl.GetValue( elem->GetID() ));
+ }
+ }
+ }
+ return int( _volume );
+ }
+ return false;
+}
--- /dev/null
+// NETGENPlugin : C++ implementation
+//
+// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+// File : NETGENPlugin_SimpleHypothesis_3D.hxx
+// Author : Edward AGAPOV
+// Project : SALOME
+//=============================================================================
+
+#ifndef _NETGENPlugin_SimpleHypothesis_3D_HXX_
+#define _NETGENPlugin_SimpleHypothesis_3D_HXX_
+
+#include "NETGENPlugin_Defs.hxx"
+#include "NETGENPlugin_SimpleHypothesis_2D.hxx"
+
+#include <Utils_SALOME_Exception.hxx>
+
+// Simplified parameters of NETGEN
+//
+
+using namespace std;
+
+class NETGENPLUGIN_EXPORT NETGENPlugin_SimpleHypothesis_3D: public NETGENPlugin_SimpleHypothesis_2D
+{
+public:
+
+ NETGENPlugin_SimpleHypothesis_3D(int hypId, int studyId, SMESH_Gen * gen);
+
+ void LengthFromFaces();
+
+ void SetMaxElementVolume(double value);
+ double GetMaxElementVolume() const { return _volume; }
+
+ // Persistence
+ virtual ostream & SaveTo(ostream & save);
+ virtual istream & LoadFrom(istream & load);
+
+ /*!
+ * \brief Set parameters by mesh
+ * \param theMesh - the built mesh
+ * \param theShape - the geometry of interest
+ * \retval bool - true if theShape is meshed
+ */
+ virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
+
+private:
+ double _volume;
+};
+
+#endif
--- /dev/null
+// NETGENPlugin : C++ implementation
+//
+// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+// File : NETGENPlugin_SimpleHypothesis_3D_i.cxx
+// Author : Edward AGAPOV
+// Project : SALOME
+//=============================================================================
+
+#include "NETGENPlugin_SimpleHypothesis_3D_i.hxx"
+#include "NETGENPlugin_SimpleHypothesis_3D.hxx"
+
+#include <SMESH_Gen.hxx>
+#include <SMESH_PythonDump.hxx>
+
+#include <Utils_CorbaException.hxx>
+#include <utilities.h>
+
+using namespace std;
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_3D_i::NETGENPlugin_SimpleHypothesis_3D_i
+ *
+ * Constructor
+ */
+//=============================================================================
+NETGENPlugin_SimpleHypothesis_3D_i::
+NETGENPlugin_SimpleHypothesis_3D_i (PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl)
+ : SALOME::GenericObj_i( thePOA ),
+ SMESH_Hypothesis_i( thePOA ),
+ NETGENPlugin_SimpleHypothesis_2D_i( thePOA,theStudyId,theGenImpl )
+{
+ MESSAGE( "NETGENPlugin_SimpleHypothesis_3D_i::NETGENPlugin_SimpleHypothesis_3D_i" );
+ if ( myBaseImpl )
+ delete myBaseImpl;
+ myBaseImpl = new ::NETGENPlugin_SimpleHypothesis_3D (theGenImpl->GetANewId(),
+ theStudyId,
+ theGenImpl);
+}
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_3D_i::~NETGENPlugin_SimpleHypothesis_3D_i
+ *
+ * Destructor
+ */
+//=============================================================================
+NETGENPlugin_SimpleHypothesis_3D_i::~NETGENPlugin_SimpleHypothesis_3D_i()
+{
+ MESSAGE( "NETGENPlugin_SimpleHypothesis_3D_i::~NETGENPlugin_SimpleHypothesis_3D_i" );
+}
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_3D_i::LengthFromFaces()
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_3D_i::LengthFromFaces()
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_3D_i::LengthFromFaces");
+ ASSERT(myBaseImpl);
+ this->GetImpl()->LengthFromFaces();
+ SMESH::TPythonDump() << _this() << ".LengthFromFaces()";
+}
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_3D_i::SetMaxElementVolume()
+ */
+//=============================================================================
+void NETGENPlugin_SimpleHypothesis_3D_i::SetMaxElementVolume(CORBA::Double value)
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_3D_i::SetMaxElementVolume");
+ ASSERT(myBaseImpl);
+ this->GetImpl()->SetMaxElementVolume(value);
+ SMESH::TPythonDump() << _this() << ".SetMaxElementVolume( " << value << " )";
+}
+
+
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_3D_i::GetMaxElementVolume()
+ */
+//=============================================================================
+CORBA::Double NETGENPlugin_SimpleHypothesis_3D_i::GetMaxElementVolume()
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_3D_i::GetMaxElementVolume");
+ ASSERT(myBaseImpl);
+ return this->GetImpl()->GetMaxElementVolume();
+}
+//=============================================================================
+/*!
+ * NETGENPlugin_SimpleHypothesis_3D_i::GetImpl
+ */
+//=============================================================================
+::NETGENPlugin_SimpleHypothesis_3D* NETGENPlugin_SimpleHypothesis_3D_i::GetImpl()
+{
+ MESSAGE("NETGENPlugin_SimpleHypothesis_3D_i::GetImpl");
+ return (::NETGENPlugin_SimpleHypothesis_3D*)myBaseImpl;
+}
+
+//================================================================================
+/*!
+ * \brief Verify whether hypothesis supports given entity type
+ * \param type - dimension (see SMESH::Dimension enumeration)
+ * \retval CORBA::Boolean - TRUE if dimension is supported, FALSE otherwise
+ *
+ * Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
+ */
+//================================================================================
+CORBA::Boolean NETGENPlugin_SimpleHypothesis_3D_i::IsDimSupported( SMESH::Dimension type )
+{
+ return type == SMESH::DIM_3D;
+}
--- /dev/null
+// NETGENPlugin : C++ implementation
+//
+// Copyright (C) 2006 OPEN CASCADE, CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+// File : NETGENPlugin_SimpleHypothesis_3D_i.hxx
+// Author : Edward AGAPOV
+// Project : SALOME
+//=============================================================================
+
+#ifndef _NETGENPlugin_SimpleHypothesis_3D_i_HXX_
+#define _NETGENPlugin_SimpleHypothesis_3D_i_HXX_
+
+#include "NETGENPlugin_Defs.hxx"
+#include "NETGENPlugin_SimpleHypothesis_2D_i.hxx"
+
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(NETGENPlugin_Algorithm)
+
+class SMESH_Gen;
+class NETGENPlugin_SimpleHypothesis_3D;
+
+// Simplified NETGEN parameters (3D case)
+
+class NETGENPLUGIN_EXPORT NETGENPlugin_SimpleHypothesis_3D_i:
+ public virtual POA_NETGENPlugin::NETGENPlugin_SimpleHypothesis_3D,
+ public virtual NETGENPlugin_SimpleHypothesis_2D_i
+{
+ public:
+ // Constructor
+ NETGENPlugin_SimpleHypothesis_3D_i (PortableServer::POA_ptr thePOA,
+ int theStudyId,
+ ::SMESH_Gen* theGenImpl);
+ // Destructor
+ virtual ~NETGENPlugin_SimpleHypothesis_3D_i();
+
+ void LengthFromFaces();
+
+ void SetMaxElementVolume(CORBA::Double value);
+ CORBA::Double GetMaxElementVolume();
+
+ // Get implementation
+ ::NETGENPlugin_SimpleHypothesis_3D* GetImpl();
+
+ // Verify whether hypothesis supports given entity type
+ CORBA::Boolean IsDimSupported( SMESH::Dimension type );
+};
+
+#endif
#include "NETGENPlugin_NETGEN_2D3D_i.hxx"
#include "NETGENPlugin_Hypothesis_i.hxx"
#include "NETGENPlugin_Hypothesis_2D_i.hxx"
+#include "NETGENPlugin_SimpleHypothesis_2D_i.hxx"
+#include "NETGENPlugin_SimpleHypothesis_3D_i.hxx"
template <class T> class NETGENPlugin_Creator_i:public HypothesisCreator_i<T>
{
aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_Hypothesis_i>;
else if (strcmp(aHypName, "NETGEN_Parameters_2D") == 0)
aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_Hypothesis_2D_i>;
+ else if (strcmp(aHypName, "NETGEN_SimpleParameters_2D") == 0)
+ aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_SimpleHypothesis_2D_i>;
+ else if (strcmp(aHypName, "NETGEN_SimpleParameters_3D") == 0)
+ aCreator = new NETGENPlugin_Creator_i<NETGENPlugin_SimpleHypothesis_3D_i>;
else ;
return aCreator;
