# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
CMAKE_MINIMUM_REQUIRED(VERSION 2.8.8 FATAL_ERROR)
-PROJECT(SalomeGHS3DPLUGIN C CXX)
+PROJECT(SalomeHYBRIDPLUGIN C CXX)
# Ensure a proper linker behavior:
CMAKE_POLICY(SET CMP0003 NEW)
ENDIF(EXISTS ${KERNEL_ROOT_DIR})
IF(SALOME_LIGHT_ONLY)
- MESSAGE(FATAL_ERROR "GHS3DPLUGIN module can't be built in Light mode (without CORBA)")
+ MESSAGE(FATAL_ERROR "HYBRIDPLUGIN module can't be built in Light mode (without CORBA)")
ENDIF()
# Platform setup
# User options
# ============
OPTION(SALOME_BUILD_TESTS "Build SALOME tests" ON)
-OPTION(SALOME_BUILD_DOC "Generate SALOME GHS3DPLUGIN documentation" ON)
+OPTION(SALOME_BUILD_DOC "Generate SALOME HYBRIDPLUGIN documentation" ON)
IF(SALOME_BUILD_TESTS)
ENABLE_TESTING()
ENDIF(SALOME_BUILD_GUI)
IF(SALOME_BUILD_DOC)
IF(NOT SALOME_SMESH_BUILD_DOC)
- MESSAGE(FATAL_ERROR "We absolutely need a Salome SMESH documentation to build GHS3DPLUGIN documentation. "
- "So, you should either set SALOME_BUILD_DOC=OFF in GHS3DPLUGIN or set SALOME_BUILD_DOC=ON in SMESH module.")
+ MESSAGE(FATAL_ERROR "We absolutely need a Salome SMESH documentation to build HYBRIDPLUGIN documentation. "
+ "So, you should either set SALOME_BUILD_DOC=OFF in HYBRIDPLUGIN or set SALOME_BUILD_DOC=ON in SMESH module.")
ENDIF(NOT SALOME_SMESH_BUILD_DOC)
ENDIF(SALOME_BUILD_DOC)
ELSE(EXISTS ${SMESH_ROOT_DIR})
SET(SALOME_INSTALL_RES "${SALOME_INSTALL_RES}" CACHE PATH "Install path: SALOME resources")
SET(SALOME_INSTALL_DOC "${SALOME_INSTALL_DOC}" CACHE PATH "Install path: SALOME documentation")
-# Specific to GHS3DPLUGIN:
-SET(SALOME_GHS3DPLUGIN_INSTALL_RES_DATA "${SALOME_INSTALL_RES}/ghs3dplugin" CACHE PATH
- "Install path: SALOME GHS3DPLUGIN specific data")
+# Specific to HYBRIDPLUGIN:
+SET(SALOME_HYBRIDPLUGIN_INSTALL_RES_DATA "${SALOME_INSTALL_RES}/hybridplugin" CACHE PATH
+ "Install path: SALOME HYBRIDPLUGIN specific data")
MARK_AS_ADVANCED(SALOME_INSTALL_BINS SALOME_INSTALL_LIBS SALOME_INSTALL_IDLS SALOME_INSTALL_HEADERS)
MARK_AS_ADVANCED(SALOME_INSTALL_SCRIPT_SCRIPTS SALOME_INSTALL_SCRIPT_DATA SALOME_INSTALL_SCRIPT_PYTHON)
MARK_AS_ADVANCED(SALOME_INSTALL_APPLISKEL_SCRIPTS SALOME_INSTALL_APPLISKEL_PYTHON SALOME_INSTALL_CMAKE_LOCAL SALOME_INSTALL_RES)
MARK_AS_ADVANCED(SALOME_INSTALL_PYTHON SALOME_INSTALL_PYTHON_SHARED)
MARK_AS_ADVANCED(SALOME_INSTALL_AMCONFIG_LOCAL SALOME_INSTALL_DOC)
-MARK_AS_ADVANCED(SALOME_GHS3DPLUGIN_INSTALL_RES_DATA)
+MARK_AS_ADVANCED(SALOME_HYBRIDPLUGIN_INSTALL_RES_DATA)
-# Accumulate environment variables for GHS3DPLUGIN module
+# Accumulate environment variables for HYBRIDPLUGIN module
SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_BINS}
${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_PYTHON})
SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${SALOME_INSTALL_LIBS})
# Header configuration
# ====================
SALOME_XVERSION(${PROJECT_NAME})
-SALOME_CONFIGURE_FILE(GHS3DPLUGIN_version.h.in GHS3DPLUGIN_version.h INSTALL ${SALOME_INSTALL_HEADERS})
+SALOME_CONFIGURE_FILE(HYBRIDPLUGIN_version.h.in HYBRIDPLUGIN_version.h INSTALL ${SALOME_INSTALL_HEADERS})
# Configuration export
# (here only the level 1 prerequisites are exposed)
# List of targets in this project we want to make visible to the rest of the world.
# They all have to be INSTALL'd with the option "EXPORT ${PROJECT_NAME}TargetGroup"
SET(_${PROJECT_NAME}_exposed_targets
- GHS3DEngine SalomeIDLGHS3DPLUGIN
+ HYBRIDEngine SalomeIDLHYBRIDPLUGIN
)
IF(SALOME_BUILD_GUI)
LIST(APPEND _${PROJECT_NAME}_exposed_targets
- GHS3DPluginGUI
+ HYBRIDPluginGUI
)
ENDIF(SALOME_BUILD_GUI)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// File : GHS3DPLUGIN_version.h
+// File : HYBRIDPLUGIN_version.h
// Author : Vadim SANDLER
// Module : SALOME
//
-#if !defined(__GHS3DPLUGIN_VERSION_H__)
-#define __GHS3DPLUGIN_VERSION_H__
+#if !defined(__HYBRIDPLUGIN_VERSION_H__)
+#define __HYBRIDPLUGIN_VERSION_H__
/*!
- Specify version of SALOME GHS3DPLUGIN module, as follows
+ Specify version of SALOME HYBRIDPLUGIN module, as follows
- GHS3DPLUGIN_VERSION_MAJOR : (integer) number identifying major version
- GHS3DPLUGIN_VERSION_MINOR : (integer) number identifying minor version
- GHS3DPLUGIN_VERSION_MAINTENANCE : (integer) number identifying maintenance version
- GHS3DPLUGIN_VERSION_STR : (string) complete version number "major.minor.maintenance"
- GHS3DPLUGIN_VERSION : (hex) complete version number (major << 16) + (minor << 8) + maintenance
- GHS3DPLUGIN_DEVELOPMENT : (integer) indicates development version when set to 1
+ HYBRIDPLUGIN_VERSION_MAJOR : (integer) number identifying major version
+ HYBRIDPLUGIN_VERSION_MINOR : (integer) number identifying minor version
+ HYBRIDPLUGIN_VERSION_MAINTENANCE : (integer) number identifying maintenance version
+ HYBRIDPLUGIN_VERSION_STR : (string) complete version number "major.minor.maintenance"
+ HYBRIDPLUGIN_VERSION : (hex) complete version number (major << 16) + (minor << 8) + maintenance
+ HYBRIDPLUGIN_DEVELOPMENT : (integer) indicates development version when set to 1
*/
-#define GHS3DPLUGIN_VERSION_MAJOR @SALOMEGHS3DPLUGIN_MAJOR_VERSION@
-#define GHS3DPLUGIN_VERSION_MINOR @SALOMEGHS3DPLUGIN_MINOR_VERSION@
-#define GHS3DPLUGIN_VERSION_MAINTENANCE @SALOMEGHS3DPLUGIN_PATCH_VERSION@
-#define GHS3DPLUGIN_VERSION_STR "@SALOMEGHS3DPLUGIN_VERSION@"
-#define GHS3DPLUGIN_VERSION @SALOMEGHS3DPLUGIN_XVERSION@
-#define GHS3DPLUGIN_DEVELOPMENT @SALOMEGHS3DPLUGIN_VERSION_DEV@
+#define HYBRIDPLUGIN_VERSION_MAJOR @SALOMEHYBRIDPLUGIN_MAJOR_VERSION@
+#define HYBRIDPLUGIN_VERSION_MINOR @SALOMEHYBRIDPLUGIN_MINOR_VERSION@
+#define HYBRIDPLUGIN_VERSION_MAINTENANCE @SALOMEHYBRIDPLUGIN_PATCH_VERSION@
+#define HYBRIDPLUGIN_VERSION_STR "@SALOMEHYBRIDPLUGIN_VERSION@"
+#define HYBRIDPLUGIN_VERSION @SALOMEHYBRIDPLUGIN_XVERSION@
+#define HYBRIDPLUGIN_DEVELOPMENT @SALOMEHYBRIDPLUGIN_VERSION_DEV@
-#endif // __GHS3DPLUGIN_VERSION_H__
+#endif // __HYBRIDPLUGIN_VERSION_H__
-SALOME2 : GHS3DPLUGIN module (SMESH plugin)
+SALOME2 : HYBRIDPLUGIN module (SMESH plugin)
# Load the dependencies for the libraries of @PROJECT_NAME@
# (contains definitions for IMPORTED targets). This is only
# imported if we are not built as a subproject (in this case targets are already there)
-IF(NOT TARGET GHS3DEngine AND NOT @PROJECT_NAME@_BINARY_DIR)
+IF(NOT TARGET HYBRIDEngine AND NOT @PROJECT_NAME@_BINARY_DIR)
INCLUDE("@PACKAGE_SALOME_INSTALL_CMAKE_LOCAL@/@PROJECT_NAME@Targets.cmake")
ENDIF()
# Package root dir:
-SET_AND_CHECK(GHS3DPLUGIN_ROOT_DIR_EXP "@PACKAGE_CMAKE_INSTALL_PREFIX@")
+SET_AND_CHECK(HYBRIDPLUGIN_ROOT_DIR_EXP "@PACKAGE_CMAKE_INSTALL_PREFIX@")
# Include directories
-SET_AND_CHECK(GHS3DPLUGIN_INCLUDE_DIRS "${GHS3DPLUGIN_ROOT_DIR_EXP}/@SALOME_INSTALL_HEADERS@")
-SET(GHS3DPLUGIN_INCLUDE_DIRS "${GHS3DPLUGIN_INCLUDE_DIRS};@_SalomeGHS3DPLUGIN_EXTRA_HEADERS@")
-SET(GHS3DPLUGIN_DEFINITIONS "@SMESH_DEFINITIONS@")
+SET_AND_CHECK(HYBRIDPLUGIN_INCLUDE_DIRS "${HYBRIDPLUGIN_ROOT_DIR_EXP}/@SALOME_INSTALL_HEADERS@")
+SET(HYBRIDPLUGIN_INCLUDE_DIRS "${HYBRIDPLUGIN_INCLUDE_DIRS};@_SalomeHYBRIDPLUGIN_EXTRA_HEADERS@")
+SET(HYBRIDPLUGIN_DEFINITIONS "@SMESH_DEFINITIONS@")
# Package specific environment variables
-@_SalomeGHS3DPLUGIN_EXTRA_ENV_FULL@
+@_SalomeHYBRIDPLUGIN_EXTRA_ENV_FULL@
#### Now the specificities
# Options exported by the package:
-SET(SALOME_GHS3DPLUGIN_BUILD_TESTS @SALOME_BUILD_TESTS@)
-SET(SALOME_GHS3DPLUGIN_BUILD_DOC @SALOME_BUILD_DOC@)
+SET(SALOME_HYBRIDPLUGIN_BUILD_TESTS @SALOME_BUILD_TESTS@)
+SET(SALOME_HYBRIDPLUGIN_BUILD_DOC @SALOME_BUILD_DOC@)
# Advanced options
-SET(SALOME_GHS3DPLUGIN_BUILD_GUI @SALOME_BUILD_GUI@)
+SET(SALOME_HYBRIDPLUGIN_BUILD_GUI @SALOME_BUILD_GUI@)
# Level 1 prerequisites:
SET_AND_CHECK(SMESH_ROOT_DIR_EXP "@PACKAGE_SMESH_ROOT_DIR@")
INCLUDE("${SMESH_ROOT_DIR_EXP}/${SALOME_INSTALL_CMAKE}/SalomeSMESHTargets.cmake")
ENDIF()
-# Exposed GHS3DPLUGIN targets:
-SET(GHS3DPLUGIN_GHS3DEngine GHS3DEngine)
-SET(GHS3DPLUGIN_GHS3DPluginGUI GHS3DPluginGUI)
-SET(GHS3DPLUGIN_SalomeIDLGHS3DPLUGIN SalomeIDLGHS3DPLUGIN)
\ No newline at end of file
+# Exposed HYBRIDPLUGIN targets:
+SET(HYBRIDPLUGIN_HYBRIDEngine HYBRIDEngine)
+SET(HYBRIDPLUGIN_HYBRIDPluginGUI HYBRIDPluginGUI)
+SET(HYBRIDPLUGIN_SalomeIDLHYBRIDPLUGIN SalomeIDLHYBRIDPLUGIN)
\ No newline at end of file
# These files are data, module or lib files
SET(_adm_data
- FindSalomeGHS3DPLUGIN.cmake
+ FindSalomeHYBRIDPLUGIN.cmake
)
INSTALL(FILES ${_adm_data} DESTINATION ${SALOME_INSTALL_CMAKE_LOCAL})
#
#
-IF(NOT SalomeGHS3DPLUGIN_FIND_QUIETLY)
- MESSAGE(STATUS "Looking for Salome GHS3DPLUGIN ...")
+IF(NOT SalomeHYBRIDPLUGIN_FIND_QUIETLY)
+ MESSAGE(STATUS "Looking for Salome HYBRIDPLUGIN ...")
ENDIF()
-SET(CMAKE_PREFIX_PATH "${GHS3DPLUGIN_ROOT_DIR}")
+SET(CMAKE_PREFIX_PATH "${HYBRIDPLUGIN_ROOT_DIR}")
-SALOME_FIND_PACKAGE(SalomeGHS3DPLUGIN SalomeGHS3DPLUGIN CONFIG)
+SALOME_FIND_PACKAGE(SalomeHYBRIDPLUGIN SalomeHYBRIDPLUGIN CONFIG)
-IF(NOT SalomeGHS3DPLUGIN_FIND_QUIETLY)
- MESSAGE(STATUS "Found Salome GHS3DPLUGIN: ${GHS3DPLUGIN_ROOT_DIR}")
+IF(NOT SalomeHYBRIDPLUGIN_FIND_QUIETLY)
+ MESSAGE(STATUS "Found Salome HYBRIDPLUGIN: ${HYBRIDPLUGIN_ROOT_DIR}")
ENDIF()
-FOREACH(_res ${SalomeGHS3DPLUGIN_EXTRA_ENV})
- SALOME_ACCUMULATE_ENVIRONMENT(${_res} "${SalomeGHS3DPLUGIN_EXTRA_ENV_${_res}}")
+FOREACH(_res ${SalomeHYBRIDPLUGIN_EXTRA_ENV})
+ SALOME_ACCUMULATE_ENVIRONMENT(${_res} "${SalomeHYBRIDPLUGIN_EXTRA_ENV_${_res}}")
ENDFOREACH()
\ No newline at end of file
#
SET(_m4_data
- check_GHS3D.m4
- check_GHS3DPLUGIN.m4
+ check_HYBRID.m4
+ check_HYBRIDPLUGIN.m4
)
INSTALL(FILES ${_m4_data} DESTINATION ${SALOME_INSTALL_AMCONFIG_LOCAL}/config_files)
dnl See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
dnl
-AC_DEFUN([CHECK_GHS3D],[
+AC_DEFUN([CHECK_HYBRID],[
-GHS3D_ok=no
+HYBRID_ok=no
AC_EXEEXT
-AC_CHECK_PROG(GHS3D, ghs3d$EXEEXT,found)
+AC_CHECK_PROG(HYBRID, hybrid$EXEEXT,found)
-if test "x$GHS3D" == x ; then
- AC_MSG_WARN(ghs3d program not found in PATH variable)
+if test "x$HYBRID" == x ; then
+ AC_MSG_WARN(hybrid program not found in PATH variable)
else
- GHS3D_ok=yes
+ HYBRID_ok=yes
fi
-AC_MSG_RESULT(for GHS3D: $GHS3D_ok)
+AC_MSG_RESULT(for HYBRID: $HYBRID_ok)
])dnl
dnl See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
dnl
-# Check availability of GHS3DPLUGIN binary distribution
+# Check availability of HYBRIDPLUGIN binary distribution
#
# Author : Marc Tajchman (CEA, 2002)
#------------------------------------------------------------
-AC_DEFUN([CHECK_GHS3DPLUGIN],[
+AC_DEFUN([CHECK_HYBRIDPLUGIN],[
-GHS3DPLUGIN_LDFLAGS=""
-GHS3DPLUGIN_CXXFLAGS=""
+HYBRIDPLUGIN_LDFLAGS=""
+HYBRIDPLUGIN_CXXFLAGS=""
AC_CHECKING(for GHS3dPlugin)
GHS3dPlugin_ok=no
AC_ARG_WITH(ghs,
- --with-ghs3dPlugin=DIR root directory path of GHS3DPLUGIN build or installation,
- GHS3DPLUGIN_DIR="$withval",GHS3DPLUGIN_DIR="")
+ --with-hybridPlugin=DIR root directory path of HYBRIDPLUGIN build or installation,
+ HYBRIDPLUGIN_DIR="$withval",HYBRIDPLUGIN_DIR="")
-if test "x$GHS3DPLUGIN_DIR" = "x" ; then
+if test "x$HYBRIDPLUGIN_DIR" = "x" ; then
# no --with-gui-dir option used
- if test "x$GHS3DPLUGIN_ROOT_DIR" != "x" ; then
+ if test "x$HYBRIDPLUGIN_ROOT_DIR" != "x" ; then
# SALOME_ROOT_DIR environment variable defined
- GHS3DPLUGIN_DIR=$GHS3DPLUGIN_ROOT_DIR
+ HYBRIDPLUGIN_DIR=$HYBRIDPLUGIN_ROOT_DIR
else
# search Salome binaries in PATH variable
- AC_PATH_PROG(TEMP, libGHS3DEngine.so)
+ AC_PATH_PROG(TEMP, libHYBRIDEngine.so)
if test "x$TEMP" != "x" ; then
- GHS3DPLUGIN_DIR=`dirname $TEMP`
+ HYBRIDPLUGIN_DIR=`dirname $TEMP`
fi
fi
fi
-if test -f ${GHS3DPLUGIN_DIR}/lib/salome/libGHS3DEngine.so ; then
+if test -f ${HYBRIDPLUGIN_DIR}/lib/salome/libHYBRIDEngine.so ; then
GHS3dPlugin_ok=yes
- AC_MSG_RESULT(Using GHS3DPLUGIN module distribution in ${GHS3DPLUGIN_DIR})
+ AC_MSG_RESULT(Using HYBRIDPLUGIN module distribution in ${HYBRIDPLUGIN_DIR})
- if test "x$GHS3DPLUGIN_ROOT_DIR" == "x" ; then
- GHS3DPLUGIN_ROOT_DIR=${GHS3DPLUGIN_DIR}
+ if test "x$HYBRIDPLUGIN_ROOT_DIR" == "x" ; then
+ HYBRIDPLUGIN_ROOT_DIR=${HYBRIDPLUGIN_DIR}
fi
- GHS3DPLUGIN_CXXFLAGS+=-I${GHS3DPLUGIN_ROOT_DIR}/include/salome
- GHS3DPLUGIN_LDFLAGS+=-L${GHS3DPLUGIN_ROOT_DIR}/lib${LIB_LOCATION_SUFFIX}/salome
- AC_SUBST(GHS3DPLUGIN_ROOT_DIR)
- AC_SUBST(GHS3DPLUGIN_LDFLAGS)
- AC_SUBST(GHS3DPLUGIN_CXXFLAGS)
+ HYBRIDPLUGIN_CXXFLAGS+=-I${HYBRIDPLUGIN_ROOT_DIR}/include/salome
+ HYBRIDPLUGIN_LDFLAGS+=-L${HYBRIDPLUGIN_ROOT_DIR}/lib${LIB_LOCATION_SUFFIX}/salome
+ AC_SUBST(HYBRIDPLUGIN_ROOT_DIR)
+ AC_SUBST(HYBRIDPLUGIN_LDFLAGS)
+ AC_SUBST(HYBRIDPLUGIN_CXXFLAGS)
else
- AC_MSG_WARN("Cannot find compiled GHS3DPLUGIN module distribution")
+ AC_MSG_WARN("Cannot find compiled HYBRIDPLUGIN module distribution")
fi
-AC_MSG_RESULT(for GHS3DPLUGIN: $GHS3dPlugin_ok)
+AC_MSG_RESULT(for HYBRIDPLUGIN: $GHS3dPlugin_ok)
])dnl
-[SALOME GHS3DPLUGIN] : @SALOMEGHS3DPLUGIN_VERSION@
-[DEVELOPMENT] : @SALOMEGHS3DPLUGIN_VERSION_DEV@
+[SALOME HYBRIDPLUGIN] : @SALOMEHYBRIDPLUGIN_VERSION@
+[DEVELOPMENT] : @SALOMEHYBRIDPLUGIN_VERSION_DEV@
[DESCRIPTION] : DISTENE TetGen-GHS3d meshing plug-in for SALOME Mesh module
#
FILE(GLOB files "${CMAKE_CURRENT_SOURCE_DIR}/*.py")
-INSTALL(FILES ${files} DESTINATION ${SALOME_INSTALL_DOC}/examples/GHS3DPLUGIN)
+INSTALL(FILES ${files} DESTINATION ${SALOME_INSTALL_DOC}/examples/HYBRIDPLUGIN)
-# It is possible to constrain GHS3D with another mesh or group.
+# It is possible to constrain HYBRID with another mesh or group.
# The constraint can refer to the nodes, edges or faces.
# This feature is available only on 2D meshes without geometry.
# The constraining elements are called enforced elements for the mesh.
BLSURF_Parameters2.SetGeometricMesh( 1 )
# Create the 3D algorithm and hypothesis
-GHS3D = smesh.CreateHypothesis('GHS3D_3D', 'GHS3DEngine')
-GHS3D_Parameters_node = smesh.CreateHypothesis('GHS3D_Parameters', 'GHS3DEngine')
-#GHS3D_Parameters_node.SetToMeshHoles( 1 )
-GHS3D_Parameters_edge = smesh.CreateHypothesis('GHS3D_Parameters', 'GHS3DEngine')
-#GHS3D_Parameters_edge.SetToMeshHoles( 1 )
-GHS3D_Parameters_face = smesh.CreateHypothesis('GHS3D_Parameters', 'GHS3DEngine')
-GHS3D_Parameters_face.SetToMeshHoles( 1 ) # to mesh inside the cylinder
-GHS3D_Parameters_mesh = smesh.CreateHypothesis('GHS3D_Parameters', 'GHS3DEngine')
-GHS3D_Parameters_mesh.SetToMeshHoles( 1 ) # to mesh inside the cylinder
+HYBRID = smesh.CreateHypothesis('HYBRID_3D', 'HYBRIDEngine')
+HYBRID_Parameters_node = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
+#HYBRID_Parameters_node.SetToMeshHoles( 1 )
+HYBRID_Parameters_edge = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
+#HYBRID_Parameters_edge.SetToMeshHoles( 1 )
+HYBRID_Parameters_face = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
+HYBRID_Parameters_face.SetToMeshHoles( 1 ) # to mesh inside the cylinder
+HYBRID_Parameters_mesh = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
+HYBRID_Parameters_mesh.SetToMeshHoles( 1 ) # to mesh inside the cylinder
# Create the mesh on the cylinder
Mesh_cylindre = smesh.Mesh(cylindre)
# Then the 3D algo and hypothesis are assigned to them.
mesh_mesh = smesh.CopyMesh( Mesh_box_tri, 'Enforced by faces of mesh', 0, 0)
-mesh_mesh.AddHypothesis( GHS3D )
-mesh_mesh.AddHypothesis( GHS3D_Parameters_mesh)
+mesh_mesh.AddHypothesis( HYBRID )
+mesh_mesh.AddHypothesis( HYBRID_Parameters_mesh)
mesh_node = smesh.CopyMesh( Mesh_box_tri, 'Enforced by group of nodes', 0, 0)
-mesh_node.AddHypothesis( GHS3D )
-mesh_node.AddHypothesis( GHS3D_Parameters_node)
+mesh_node.AddHypothesis( HYBRID )
+mesh_node.AddHypothesis( HYBRID_Parameters_node)
mesh_edge = smesh.CopyMesh( Mesh_box_tri, 'Enforced by group of edges', 0, 0)
-mesh_edge.AddHypothesis( GHS3D )
-mesh_edge.AddHypothesis( GHS3D_Parameters_edge)
+mesh_edge.AddHypothesis( HYBRID )
+mesh_edge.AddHypothesis( HYBRID_Parameters_edge)
mesh_face = smesh.CopyMesh( Mesh_box_tri, 'Enforced by group of faces', 0, 0)
-mesh_face.AddHypothesis( GHS3D )
-mesh_face.AddHypothesis( GHS3D_Parameters_face)
+mesh_face.AddHypothesis( HYBRID )
+mesh_face.AddHypothesis( HYBRID_Parameters_face)
# Add the enforced elements
-GHS3D_Parameters_mesh.SetEnforcedMeshWithGroup(Mesh_cylindre.GetMesh(),SMESH.FACE,"faces from cylinder")
-GHS3D_Parameters_node.SetEnforcedMeshWithGroup(face_cyl_nodes,SMESH.NODE,"nodes from face_cyl_nodes")
-GHS3D_Parameters_edge.SetEnforcedMeshWithGroup(face_cyl_edges,SMESH.EDGE,"edges from face_cyl_edges")
-GHS3D_Parameters_face.SetEnforcedMeshWithGroup(face_cyl_faces,SMESH.FACE,"faces from face_cyl_faces")
+HYBRID_Parameters_mesh.SetEnforcedMeshWithGroup(Mesh_cylindre.GetMesh(),SMESH.FACE,"faces from cylinder")
+HYBRID_Parameters_node.SetEnforcedMeshWithGroup(face_cyl_nodes,SMESH.NODE,"nodes from face_cyl_nodes")
+HYBRID_Parameters_edge.SetEnforcedMeshWithGroup(face_cyl_edges,SMESH.EDGE,"edges from face_cyl_edges")
+HYBRID_Parameters_face.SetEnforcedMeshWithGroup(face_cyl_faces,SMESH.FACE,"faces from face_cyl_faces")
#Compute the meshes
mesh_node.Compute()
box = geompy.MakeBoxDXDYDZ(200., 200., 200.)
geompy.addToStudy(box, "box")
# create a mesh on the box
-ghs3dMesh = smesh.Mesh(box,"box: Ghs3D and BLSurf mesh")
+hybridMesh = smesh.Mesh(box,"box: Ghs3D and BLSurf mesh")
# create a BLSurf algorithm for faces
-ghs3dMesh.Triangle(algo=smeshBuilder.BLSURF)
+hybridMesh.Triangle(algo=smeshBuilder.BLSURF)
# compute the mesh
-ghs3dMesh.Compute()
+hybridMesh.Compute()
# Make a copy of the 2D mesh
-ghs3dMesh_wo_geometry = smesh.CopyMesh( ghs3dMesh, 'Ghs3D wo geometry', 0, 0)
+hybridMesh_wo_geometry = smesh.CopyMesh( hybridMesh, 'Ghs3D wo geometry', 0, 0)
# create a Ghs3D algorithm and hypothesis and assign them to the mesh
-GHS3D = smesh.CreateHypothesis('GHS3D_3D', 'GHS3DEngine')
-GHS3D_Parameters = smesh.CreateHypothesis('GHS3D_Parameters', 'GHS3DEngine')
-ghs3dMesh.AddHypothesis( GHS3D )
-ghs3dMesh.AddHypothesis( GHS3D_Parameters )
+HYBRID = smesh.CreateHypothesis('HYBRID_3D', 'HYBRIDEngine')
+HYBRID_Parameters = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
+hybridMesh.AddHypothesis( HYBRID )
+hybridMesh.AddHypothesis( HYBRID_Parameters )
# Create the enforced vertex
-GHS3D_Parameters.SetEnforcedVertex( 50, 50, 100, 2) # no group
+HYBRID_Parameters.SetEnforcedVertex( 50, 50, 100, 2) # no group
# Compute the mesh
-ghs3dMesh.Compute()
+hybridMesh.Compute()
# Ex2: Add one vertex enforced by a GEOM vertex at (50,50,100)
# with physical size 5 and add it to a group called "My special nodes"
-# Create another GHS3D hypothesis and assign it to the mesh without geometry
-GHS3D_Parameters_wo_geometry = smesh.CreateHypothesis('GHS3D_Parameters', 'GHS3DEngine')
-ghs3dMesh_wo_geometry.AddHypothesis( GHS3D )
-ghs3dMesh_wo_geometry.AddHypothesis( GHS3D_Parameters_wo_geometry )
+# Create another HYBRID hypothesis and assign it to the mesh without geometry
+HYBRID_Parameters_wo_geometry = smesh.CreateHypothesis('HYBRID_Parameters', 'HYBRIDEngine')
+hybridMesh_wo_geometry.AddHypothesis( HYBRID )
+hybridMesh_wo_geometry.AddHypothesis( HYBRID_Parameters_wo_geometry )
# Create the enforced vertex
p1 = geompy.MakeVertex(150, 150, 100)
geompy.addToStudy(p1, "p1")
-GHS3D_Parameters_wo_geometry.SetEnforcedVertexGeomWithGroup( p1, 5 , "My special nodes")
-#GHS3D_Parameters.SetEnforcedVertexGeom( p1, 5 ) # no group
+HYBRID_Parameters_wo_geometry.SetEnforcedVertexGeomWithGroup( p1, 5 , "My special nodes")
+#HYBRID_Parameters.SetEnforcedVertexGeom( p1, 5 ) # no group
# compute the mesh
-ghs3dMesh_wo_geometry.Compute()
+hybridMesh_wo_geometry.Compute()
# Erase all enforced vertices
-GHS3D_Parameters.ClearEnforcedVertices()
+HYBRID_Parameters.ClearEnforcedVertices()
# End of script
geompy.addToStudy(box, "box")
# create a mesh on the box
-ghs3dMesh = smesh.Mesh(box,"box: Ghs3D and BLSurf mesh")
+hybridMesh = smesh.Mesh(box,"box: Ghs3D and BLSurf mesh")
# create a BLSurf algorithm for faces
-BLSURF = ghs3dMesh.Triangle(algo=smeshBuilder.BLSURF)
-GHS3D = ghs3dMesh.Tetrahedron(algo=smeshBuilder.GHS3D)
+BLSURF = hybridMesh.Triangle(algo=smeshBuilder.BLSURF)
+HYBRID = hybridMesh.Tetrahedron(algo=smeshBuilder.HYBRID)
# compute the mesh
-ghs3dMesh.Compute()
+hybridMesh.Compute()
# End of script
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-ADD_SUBDIRECTORY(GHS3DPLUGIN)
+ADD_SUBDIRECTORY(HYBRIDPLUGIN)
SALOME_CONFIGURE_FILE(static/header.html.in ${CMAKE_CURRENT_BINARY_DIR}/static/header.html)
SALOME_CONFIGURE_FILE(static/header_py.html.in ${CMAKE_CURRENT_BINARY_DIR}/static/header_py.html)
-SET(DOC_SMESH_MeshersList GHS3DPlugin)
+SET(DOC_SMESH_MeshersList HYBRIDPlugin)
SET(smesh_file "$(SMESH_ROOT_DIR)/bin/salome/collect_mesh_methods.py")
SET(kernel_file "$ENV{KERNEL_ROOT_DIR}/bin/salome/prepare_generating_doc.py")
SALOME_ACCUMULATE_ENVIRONMENT(SMESH_MeshersList NOCHECK ${DOC_SMESH_MeshersList})
-SET(_cmd_options ${smesh_file} -d -o tmp/smeshBuilder.py GHS3DPlugin)
+SET(_cmd_options ${smesh_file} -d -o tmp/smeshBuilder.py HYBRIDPlugin)
SALOME_GENERATE_ENVIRONMENT_SCRIPT(_cmd env_script "${PYTHON_EXECUTABLE}" "${_cmd_options}")
ADD_CUSTOM_TARGET(usr_docs ${CMAKE_COMMAND} -E make_directory tmp
- COMMAND ${PYTHON_EXECUTABLE} ${kernel_file} -o tmp/GHS3DPluginBuilder.py ${CMAKE_SOURCE_DIR}/src/GHS3DPlugin/GHS3DPluginBuilder.py
+ COMMAND ${PYTHON_EXECUTABLE} ${kernel_file} -o tmp/HYBRIDPluginBuilder.py ${CMAKE_SOURCE_DIR}/src/HYBRIDPlugin/HYBRIDPluginBuilder.py
COMMAND ${PYTHON_EXECUTABLE} ${kernel_file} -o tmp/smesh_algorithm.py ${SMESH_ROOT_DIR}/${SALOME_INSTALL_PYTHON}/salome/smesh/smesh_algorithm.py
COMMAND ${_cmd}
COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
)
INSTALL(CODE "EXECUTE_PROCESS(COMMAND \"${CMAKE_COMMAND}\" --build ${PROJECT_BINARY_DIR} --target usr_docs)")
-INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/GHS3DPLUGIN DESTINATION ${SALOME_INSTALL_DOC}/gui/)
-INSTALL(FILES images/head.png DESTINATION ${SALOME_INSTALL_DOC}/gui/GHS3DPLUGIN)
-INSTALL(FILES images/head.png DESTINATION ${SALOME_INSTALL_DOC}/gui/GHS3DPLUGIN/ghs3dpluginpy_doc)
+INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/HYBRIDPLUGIN DESTINATION ${SALOME_INSTALL_DOC}/gui/)
+INSTALL(FILES images/head.png DESTINATION ${SALOME_INSTALL_DOC}/gui/HYBRIDPLUGIN)
+INSTALL(FILES images/head.png DESTINATION ${SALOME_INSTALL_DOC}/gui/HYBRIDPLUGIN/hybridpluginpy_doc)
-SET(make_clean_files GHS3DPLUGIN ghs3dpluginpy_doc.tag)
+SET(make_clean_files HYBRIDPLUGIN hybridpluginpy_doc.tag)
SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${make_clean_files}")
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
-PROJECT_NAME = "SALOME GHS3DPLUGIN User's Guide"
-OUTPUT_DIRECTORY = GHS3DPLUGIN
+PROJECT_NAME = "SALOME HYBRIDPLUGIN User's Guide"
+OUTPUT_DIRECTORY = HYBRIDPLUGIN
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
TAB_SIZE = 5
#rnv: 07.04.2011 Workaround for the doxygen 1.7.3:
#because it wrongly defines location of the html files for search.
-TAGFILES = ghs3dpluginpy_doc.tag=../GHS3DPLUGIN/ghs3dpluginpy_doc
+TAGFILES = hybridpluginpy_doc.tag=../HYBRIDPLUGIN/hybridpluginpy_doc
SEARCHENGINE = YES
#---------------------------------------------------------------------------
#Custom commands
#---------------------------------------------------------------------------
-ALIASES += tui_script{1}="\include \1 <a href=\"../../examples/GHS3DPLUGIN/\1\">Download this script</a>"
+ALIASES += tui_script{1}="\include \1 <a href=\"../../examples/HYBRIDPLUGIN/\1\">Download this script</a>"
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
-PROJECT_NAME = "SALOME GHS3DPLUGIN User's Guide"
-OUTPUT_DIRECTORY = GHS3DPLUGIN
+PROJECT_NAME = "SALOME HYBRIDPLUGIN User's Guide"
+OUTPUT_DIRECTORY = HYBRIDPLUGIN
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
USE_WINDOWS_ENCODING = NO
#---------------------------------------------------------------------------
#Input related options
#---------------------------------------------------------------------------
-INPUT = tmp/GHS3DPluginBuilder.py \
+INPUT = tmp/HYBRIDPluginBuilder.py \
tmp/smeshBuilder.py \
tmp/smesh_algorithm.py
FILE_PATTERNS =
#HTML related options
#---------------------------------------------------------------------------
GENERATE_HTML = YES
-HTML_OUTPUT = ghs3dpluginpy_doc
+HTML_OUTPUT = hybridpluginpy_doc
HTML_HEADER = @CMAKE_CURRENT_BINARY_DIR@/static/header_py.html
HTML_FOOTER = @CMAKE_CURRENT_SOURCE_DIR@/static/footer.html
HTML_EXTRA_STYLESHEET = @CMAKE_CURRENT_SOURCE_DIR@/static/salome_extra.css
#---------------------------------------------------------------------------
#External reference options
#---------------------------------------------------------------------------
-GENERATE_TAGFILE = ghs3dpluginpy_doc.tag
+GENERATE_TAGFILE = hybridpluginpy_doc.tag
SEARCHENGINE = YES
\n <b>Additional Hypotheses</b> can be applied as a supplement to the
main hypotheses, introducing additional concepts to mesh creation.
-One additional hypotheses can be used together with GHS3D algoritm:
+One additional hypotheses can be used together with HYBRID algoritm:
<ul>
-<li><b>Viscous Layers</b> additional hypothesis can be used together with GHS3D.
+<li><b>Viscous Layers</b> additional hypothesis can be used together with HYBRID.
This hypothesis allows creation of layers of highly stretched prisms near
mesh boundary, which is beneficial for high quality viscous
computations. The prisms constructed on the quadrangular mesh faces are
/*!
-\page ghs3d_hypo_page GHS3D Parameters hypothesis
+\page hybrid_hypo_page HYBRID Parameters hypothesis
-\anchor ghs3d_top
-GHS3D Parameters hypothesis works only with <b>Tetrahedron (GHS3D)</b>
+\anchor hybrid_top
+HYBRID Parameters hypothesis works only with <b>Tetrahedron (HYBRID)</b>
algorithm. This algorithm is a commercial software.
To get a licence, visit http://www.distene.com/en/corp/eval-distene.html
\tableofcontents
-\section ghs3d_general_parameters General parameters
+\section hybrid_general_parameters General parameters
-\image html ghs3d_parameters_basic.png
+\image html hybrid_parameters_basic.png
-- <b>Name</b> - allows to define the name of the hypothesis (GHS3D
+- <b>Name</b> - allows to define the name of the hypothesis (HYBRID
Parameters by default).
- <b>Mesh holes</b> - if checked, the algorithm will
- strong
-\ref ghs3d_top "Back to top"
+\ref hybrid_top "Back to top"
-\section ghs3d_advanced_parameters Advanced parameters
+\section hybrid_advanced_parameters Advanced parameters
-\image html ghs3d_parameters_advanced.png
+\image html hybrid_parameters_advanced.png
\subsection memory_settings Memory settings
-- <b>Maximum memory size</b> - launches ghs3d software with
+- <b>Maximum memory size</b> - launches hybrid software with
work space limited to the specified amount of RAM, in Mbytes. If this option is
checked off, the software will be launched with 7O% of the total RAM space.
-- <b>Initial memory size</b> - starts ghs3d software with
+- <b>Initial memory size</b> - starts hybrid software with
the specified amount of work space, in Mbytes. If this option is checked off, the
software will be started with 100 Megabytes of working space.
\subsection log Logs and debug
- <b>Working directory</b> - allows defining the folder for input and output
-files of ghs3d software, which are the files starting with "GHS3D_" prefix.
+files of hybrid software, which are the files starting with "HYBRID_" prefix.
- <b>Verbose level</b> - to choose verbosity level in the range from
0 to 10.
(in this case the log file is always kept).
- <b>Keep all working files</b> - allows checking input and output files
-of ghs3d software, while usually these files are removed after the
+of hybrid software, while usually these files are removed after the
launch of the mesher. The log file (if any) is also kept if this option is checked.
\subsection advanced_meshing_options Advanced meshing options
-- <b>Create new nodes</b> - if this option is checked off, ghs3d
+- <b>Create new nodes</b> - if this option is checked off, hybrid
tries to create tetrahedrons using only the nodes of the 2D mesh.
-- <b>Remove the initial central point</b> TetMesh-GHS3D adds an internal point
+- <b>Remove the initial central point</b> TetMesh-HYBRID adds an internal point
at the gravity centre of the bounding box to speed up and to simplify
the meshing process. However, it is possible to refrain from creating
this point by using the command line option -no initial central point. This can be
replacing overconstrained elements where it is possible. At first the process
slices the overconstrained edges and at second the overconstrained
facets. This ensures that there are no edges with two boundary
-vertices and that there are no facets with three boundary vertices. TetMesh-GHS3D gives the initial
+vertices and that there are no facets with three boundary vertices. TetMesh-HYBRID gives the initial
and final overconstrained edges and facets. It also gives the facets
which have three edges on the boundary.
Note: when using this option, the speed of the meshing process may
WARNING: Changing the default value of this parameter may dramatically decrease the quality of the resulting mesh.
- <b>Option as text</b> - allows to input in the command line any text
-for ghs3d, for example, advanced options.
+for hybrid, for example, advanced options.
-\ref ghs3d_top "Back to top"
+\ref hybrid_top "Back to top"
-\section ghs3d_enforced_vertices Enforced vertices
+\section hybrid_enforced_vertices Enforced vertices
-\image html ghs3d_enforced_vertices.png
+\image html hybrid_enforced_vertices.png
-GHS3D algorithm can locally make the mesh finer. It is possible to
+HYBRID algorithm can locally make the mesh finer. It is possible to
define enforced vertices in the volume where the mesh will be detailed.
A node will be created at the enforced vertex coordinates.
- If a group name is given, the created node will be added to the
group. If the group does not exist, it is created.
-\ref ghs3d_top "Back to top"
+\ref hybrid_top "Back to top"
-\section ghs3d_enforced_meshes Enforced Meshes
+\section hybrid_enforced_meshes Enforced Meshes
-\image html ghs3d_enforced_meshes.png
+\image html hybrid_enforced_meshes.png
-GHS3D algorithm can be forced by other meshes, sub-meshes or
+HYBRID algorithm can be forced by other meshes, sub-meshes or
groups. The constraint elements should be contained
entirely into the solid mesh.
- The constraint element types are:
- If a group name is given, the enforced elements will be added to
the group. If the group does not exist, it is created.
-<br><b>See Also</b> a sample TUI Script of the \ref tui_ghs3d "creation of a Ghs3D hypothesis", including enforced vertices and meshes.
+<br><b>See Also</b> a sample TUI Script of the \ref tui_hybrid "creation of a Ghs3D hypothesis", including enforced vertices and meshes.
-\ref ghs3d_top "Back to top"
+\ref hybrid_top "Back to top"
*/
/*!
-\page ghs3dplugin_python_interface_page Python Interface
+\page hybridplugin_python_interface_page Python Interface
-Python package GHS3DPluginBuilder defines several classes, destined for creation of the 3D meshes.
+Python package HYBRIDPluginBuilder defines several classes, destined for creation of the 3D meshes.
-GHS3D meshing plugin dynamically adds several methods to the smeshBuilder.Mesh class to create meshing algorithms.
+HYBRID meshing plugin dynamically adds several methods to the smeshBuilder.Mesh class to create meshing algorithms.
-Below you can see an example of usage of the GHS3DPluginBuilder Python API for mesh generation:
+Below you can see an example of usage of the HYBRIDPluginBuilder Python API for mesh generation:
-\anchor tui_ghs3d
+\anchor tui_hybrid
--# \ref tui_ghs3d_basic
--# \ref tui_ghs3d_enforced_vertices
--# \ref tui_ghs3d_enforced_meshes
+-# \ref tui_hybrid_basic
+-# \ref tui_hybrid_enforced_vertices
+-# \ref tui_hybrid_enforced_meshes
-\section tui_ghs3d_basic Construction of Mesh using Ghs3D algorithm
+\section tui_hybrid_basic Construction of Mesh using Ghs3D algorithm
\anchor example_BLSURFPlugin
-<h2>Example of mesh generation with GHS3D algorithm:</h2>
-\tui_script{ghs3ddemo.py}
+<h2>Example of mesh generation with HYBRID algorithm:</h2>
+\tui_script{hybriddemo.py}
-\image html ghs3d_screenshot.png Ghs3d mesh without hypothesis
+\image html hybrid_screenshot.png Hybrid mesh without hypothesis
-\ref tui_ghs3d "Back to top"
+\ref tui_hybrid "Back to top"
-\section tui_ghs3d_enforced_vertices Adding enforced vertices
+\section tui_hybrid_enforced_vertices Adding enforced vertices
-<h2>Example of enforced vertices with GHS3D algorithm:</h2>
-\tui_script{ghs3d_enfvert.py}
+<h2>Example of enforced vertices with HYBRID algorithm:</h2>
+\tui_script{hybrid_enfvert.py}
-\image html ghs3d_screenshot_enf1.png Ghs3d mesh with enforced vertex
-\image html ghs3d_screenshot_enf2.png Ghs3d mesh with enforced vertex from GEOM vertex
+\image html hybrid_screenshot_enf1.png Hybrid mesh with enforced vertex
+\image html hybrid_screenshot_enf2.png Hybrid mesh with enforced vertex from GEOM vertex
-\ref tui_ghs3d "Back to top"
+\ref tui_hybrid "Back to top"
-\section tui_ghs3d_enforced_meshes Adding enforced mesh
+\section tui_hybrid_enforced_meshes Adding enforced mesh
-<h2>Example of enforced meshes with GHS3D algorithm:</h2>
-\tui_script{ghs3d_enfmesh.py}
+<h2>Example of enforced meshes with HYBRID algorithm:</h2>
+\tui_script{hybrid_enfmesh.py}
-\image html ghs3d_screenshot_enf3.png
-\image html ghs3d_screenshot_enf4.png
-\image html ghs3d_screenshot_enf5.png
-\image html ghs3d_screenshot_enf6.png
+\image html hybrid_screenshot_enf3.png
+\image html hybrid_screenshot_enf4.png
+\image html hybrid_screenshot_enf5.png
+\image html hybrid_screenshot_enf6.png
-\ref tui_ghs3d "Back to top"
+\ref tui_hybrid "Back to top"
*/
/*!
-\mainpage Introduction to GHS3DPLUGIN
+\mainpage Introduction to HYBRIDPLUGIN
-\b GHS3DPLUGIN plugin is destined for:
+\b HYBRIDPLUGIN plugin is destined for:
- Meshing 3D geometric entities: volumes are split into tetrahedral (pyramidal) elements.
- Generating 3D meshes from 2D meshes (triangles and quadrangles), working without geometrical objects.
-\note GHS3DPLUGIN plugin used GHS3D commercial mesher and require a
+\note HYBRIDPLUGIN plugin used HYBRID commercial mesher and require a
license to be used within the Mesh module.
-To manage parameters of the GHS3DPLUGIN use \subpage ghs3d_hypo_page and \subpage additional_hypo_page
+To manage parameters of the HYBRIDPLUGIN use \subpage hybrid_hypo_page and \subpage additional_hypo_page
-Also all GHS3DPLUGIN functionalities are accessible via
-\subpage ghs3dplugin_python_interface_page "GHS3DPLUGIN Python interface".
+Also all HYBRIDPLUGIN functionalities are accessible via
+\subpage hybridplugin_python_interface_page "HYBRIDPLUGIN Python interface".
\image html image2.gif "Example of a tetrahedral 3D mesh"
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea"><div align="right"><div class="version">Version: @SALOMEGHS3DPLUGIN_VERSION@</div></div></div>
+<div id="titlearea"><div align="right"><div class="version">Version: @SALOMEHYBRIDPLUGIN_VERSION@</div></div></div>
<!-- end header part -->
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea"><div align="right"><div class="version">Version: @SALOMEGHS3DPLUGIN_VERSION@</div></div></div>
+<div id="titlearea"><div align="right"><div class="version">Version: @SALOMEHYBRIDPLUGIN_VERSION@</div></div></div>
<div align="bottom-left"><a href=../index.html>Home</a></div>
<!-- end header part -->
${PROJECT_BINARY_DIR}/idl
)
-SET(SalomeIDLGHS3DPLUGIN_IDLSOURCES
- GHS3DPlugin_Algorithm.idl
+SET(SalomeIDLHYBRIDPLUGIN_IDLSOURCES
+ HYBRIDPlugin_Algorithm.idl
)
SET(_idl_include_dirs
${SMESH_SalomeIDLSMESH}
)
-OMNIORB_ADD_MODULE(SalomeIDLGHS3DPLUGIN "${SalomeIDLGHS3DPLUGIN_IDLSOURCES}" "${_idl_include_dirs}" "${_idl_link_flags}")
-INSTALL(TARGETS SalomeIDLGHS3DPLUGIN EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
+OMNIORB_ADD_MODULE(SalomeIDLHYBRIDPLUGIN "${SalomeIDLHYBRIDPLUGIN_IDLSOURCES}" "${_idl_include_dirs}" "${_idl_link_flags}")
+INSTALL(TARGETS SalomeIDLHYBRIDPLUGIN EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// File : GHS3D_Algorithm.idl
+// File : HYBRID_Algorithm.idl
// Author : Julia DOROVSKIKH
//
-#ifndef _GHS3D_Algorithm_IDL_
-#define _GHS3D_Algorithm_IDL_
+#ifndef _HYBRID_Algorithm_IDL_
+#define _HYBRID_Algorithm_IDL_
#include "SALOME_Exception.idl"
#include "SMESH_Hypothesis.idl"
#include "SMESH_Mesh.idl"
/*!
- * GHS3DPlugin: interfaces to GHS3D related hypotheses and algorithms
+ * HYBRIDPlugin: interfaces to HYBRID related hypotheses and algorithms
*/
-module GHS3DPlugin
+module HYBRIDPlugin
{
typedef sequence<double,3> TCoords;
- struct GHS3DEnforcedVertex {
+ struct HYBRIDEnforcedVertex {
string name;
string geomEntry;
boolean isCompound;
double size;
};
- typedef sequence<GHS3DEnforcedVertex> GHS3DEnforcedVertexList;
+ typedef sequence<HYBRIDEnforcedVertex> HYBRIDEnforcedVertexList;
- struct GHS3DEnforcedMesh {
+ struct HYBRIDEnforcedMesh {
string name;
string entry;
SMESH::ElementType elementType;
string groupName;
};
- typedef sequence<GHS3DEnforcedMesh> GHS3DEnforcedMeshList;
+ typedef sequence<HYBRIDEnforcedMesh> HYBRIDEnforcedMeshList;
/*!
- * GHS3DPlugin_GHS3D: interface of "Tetrahedron (GHS3D)" algorithm
+ * HYBRIDPlugin_HYBRID: interface of "Tetrahedron (HYBRID)" algorithm
*/
- interface GHS3DPlugin_GHS3D : SMESH::SMESH_3D_Algo
+ interface HYBRIDPlugin_HYBRID : SMESH::SMESH_3D_Algo
{
SMESH::SMESH_Mesh importGMFMesh(in string aGMFFileName);
};
/*!
- * Parameters of "Tetrahedron (GHS3D)" algorithm
+ * Parameters of "Tetrahedron (HYBRID)" algorithm
*/
- interface GHS3DPlugin_Hypothesis : SMESH::SMESH_Hypothesis
+ interface HYBRIDPlugin_Hypothesis : SMESH::SMESH_Hypothesis
{
/*!
* To mesh "holes" in a solid or not. Default is to mesh.
double GetEnforcedVertexGeom(in GEOM::GEOM_Object theVertex) raises (SALOME::SALOME_Exception);
boolean RemoveEnforcedVertex(in double x, in double y, in double z) raises (SALOME::SALOME_Exception);
boolean RemoveEnforcedVertexGeom(in GEOM::GEOM_Object theVertex) raises (SALOME::SALOME_Exception);
- GHS3DEnforcedVertexList GetEnforcedVertices();
+ HYBRIDEnforcedVertexList GetEnforcedVertices();
void ClearEnforcedVertices();
/*!
* Set/get/unset an enforced vertex (private method for GUI)
boolean SetEnforcedMeshSizeWithGroup(in SMESH::SMESH_IDSource theSource, in SMESH::ElementType elementType, in double size, in string groupName) raises (SALOME::SALOME_Exception);
/* OBSOLETE FUNCTIONS */
- GHS3DEnforcedMeshList GetEnforcedMeshes();
+ HYBRIDEnforcedMeshList GetEnforcedMeshes();
void ClearEnforcedMeshes();
/*!
#
IF(SALOME_BUILD_GUI)
- SET(GHS3DPLUGIN_RESOURCES_FILES_WITH_GUI
- mesh_hypo_ghs3d.png
- mesh_tree_hypo_ghs3d.png
+ SET(HYBRIDPLUGIN_RESOURCES_FILES_WITH_GUI
+ mesh_hypo_hybrid.png
+ mesh_tree_hypo_hybrid.png
)
ENDIF(SALOME_BUILD_GUI)
-SET(GHS3DPLUGIN_RESOURCES_FILES
- GHS3DPlugin.xml
+SET(HYBRIDPLUGIN_RESOURCES_FILES
+ HYBRIDPlugin.xml
SalomeApp.xml
- ${GHS3DPLUGIN_RESOURCES_FILES_WITH_GUI}
+ ${HYBRIDPLUGIN_RESOURCES_FILES_WITH_GUI}
)
-INSTALL(FILES ${GHS3DPLUGIN_RESOURCES_FILES} DESTINATION ${SALOME_GHS3DPLUGIN_INSTALL_RES_DATA})
+INSTALL(FILES ${HYBRIDPLUGIN_RESOURCES_FILES} DESTINATION ${SALOME_HYBRIDPLUGIN_INSTALL_RES_DATA})
<meshers>
-<meshers-group name="GHS3D"
- resources="GHS3DPlugin"
- idl-module="GHS3DPlugin"
- server-lib="GHS3DEngine"
- gui-lib="GHS3DPluginGUI">
+<meshers-group name="HYBRID"
+ resources="HYBRIDPlugin"
+ idl-module="HYBRIDPlugin"
+ server-lib="HYBRIDEngine"
+ gui-lib="HYBRIDPluginGUI">
<hypotheses>
- <hypothesis type="GHS3D_Parameters"
- label-id="GHS3D Parameters"
- icon-id="mesh_hypo_ghs3d.png"
+ <hypothesis type="HYBRID_Parameters"
+ label-id="HYBRID Parameters"
+ icon-id="mesh_hypo_hybrid.png"
dim="3">
<python-wrap>
<accumulative-methods>
</hypotheses>
<algorithms>
- <algorithm type="GHS3D_3D"
- label-id="Tetrahedron (GHS3D)"
- icon-id="mesh_tree_hypo_ghs3d.png"
+ <algorithm type="HYBRID_3D"
+ label-id="Tetrahedron (HYBRID)"
+ icon-id="mesh_tree_hypo_hybrid.png"
input="TRIA,QUAD"
need-geom="false"
- opt-hypos="GHS3D_Parameters, ViscousLayers"
+ opt-hypos="HYBRID_Parameters, ViscousLayers"
dim="3">
<python-wrap>
- <algo>GHS3D_3D=Tetrahedron(algo=smeshBuilder.GHS3D)</algo>
- <hypo>GHS3D_Parameters=Parameters()</hypo>
+ <algo>HYBRID_3D=Tetrahedron(algo=smeshBuilder.HYBRID)</algo>
+ <hypo>HYBRID_Parameters=Parameters()</hypo>
<hypo>ViscousLayers=ViscousLayers(SetTotalThickness(),SetNumberLayers(),SetStretchFactor(),SetIgnoreFaces())</hypo>
</python-wrap>
</algorithm>
-->
<document>
<section name="resources">
- <parameter name="GHS3DPlugin" value="${GHS3DPLUGIN_ROOT_DIR}/share/salome/resources/ghs3dplugin"/>
+ <parameter name="HYBRIDPlugin" value="${HYBRIDPLUGIN_ROOT_DIR}/share/salome/resources/hybridplugin"/>
</section>
<section name="SMESH">
<!-- Default SMESH module plugins -->
- <parameter name="plugins" value="NETGENPlugin,GHS3DPlugin"/>
+ <parameter name="plugins" value="NETGENPlugin,HYBRIDPlugin"/>
</section>
<section name="smesh_help" >
- <parameter name="Plug-ins/GHS3D plugin User's Guide" value="${GHS3DPLUGIN_ROOT_DIR}/share/doc/salome/gui/GHS3DPLUGIN/index.html"/>
+ <parameter name="Plug-ins/HYBRID plugin User's Guide" value="${HYBRIDPLUGIN_ROOT_DIR}/share/doc/salome/gui/HYBRIDPLUGIN/index.html"/>
</section>
</document>
# Common packages
##
SET(SUBDIRS_COMMON
- GHS3DPlugin
+ HYBRIDPlugin
)
IF(SALOME_BUILD_GUI)
${OMNIORB_INCLUDE_DIR}
${CMAKE_CURRENT_BINARY_DIR}
${PROJECT_BINARY_DIR}/idl
- ${PROJECT_SOURCE_DIR}/src/GHS3DPlugin
+ ${PROJECT_SOURCE_DIR}/src/HYBRIDPlugin
)
# additional preprocessor / compiler flags
${GUI_qtx}
${GUI_SalomeApp}
${CAS_KERNEL}
- SalomeIDLGHS3DPLUGIN
+ SalomeIDLHYBRIDPLUGIN
)
# --- headers ---
# header files / to be processed by moc
SET(_moc_HEADERS
- GHS3DPluginGUI_HypothesisCreator.h
- GHS3DPluginGUI_Dlg.h
+ HYBRIDPluginGUI_HypothesisCreator.h
+ HYBRIDPluginGUI_Dlg.h
)
# header files / no moc processed
SET(_other_HEADERS
- GHS3DPluginGUI_Enums.h
+ HYBRIDPluginGUI_Enums.h
)
-SET(GHS3DPluginGUI_HEADERS ${_moc_HEADERS} ${_other_HEADERS})
+SET(HYBRIDPluginGUI_HEADERS ${_moc_HEADERS} ${_other_HEADERS})
# --- sources ---
# sources / static
SET(_other_SOURCES
- GHS3DPluginGUI.cxx
- GHS3DPluginGUI_HypothesisCreator.cxx
- GHS3DPluginGUI_AdvWidget.cxx
+ HYBRIDPluginGUI.cxx
+ HYBRIDPluginGUI_HypothesisCreator.cxx
+ HYBRIDPluginGUI_AdvWidget.cxx
)
# --- resources ---
# resource files / to be processed by lrelease
SET(_ts_RESOURCES
- GHS3DPlugin_images.ts
- GHS3DPlugin_msg_en.ts
- GHS3DPlugin_msg_fr.ts
- GHS3DPlugin_msg_ja.ts
+ HYBRIDPlugin_images.ts
+ HYBRIDPlugin_msg_en.ts
+ HYBRIDPlugin_msg_fr.ts
+ HYBRIDPlugin_msg_ja.ts
)
# resource files / to be processed by uic
SET(_uic_files
- GHS3DPluginGUI_AdvWidget_QTD.ui
+ HYBRIDPluginGUI_AdvWidget_QTD.ui
)
# header files / uic wrappings
QT4_WRAP_UI(_uic_HEADERS ${_uic_files})
# sources / to compile
-SET(GHS3DPluginGUI_SOURCES ${_other_SOURCES} ${_moc_SOURCES} ${_uic_HEADERS})
+SET(HYBRIDPluginGUI_SOURCES ${_other_SOURCES} ${_moc_SOURCES} ${_uic_HEADERS})
# --- rules ---
-ADD_LIBRARY(GHS3DPluginGUI ${GHS3DPluginGUI_SOURCES})
-TARGET_LINK_LIBRARIES(GHS3DPluginGUI ${_link_LIBRARIES} )
-INSTALL(TARGETS GHS3DPluginGUI EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
+ADD_LIBRARY(HYBRIDPluginGUI ${HYBRIDPluginGUI_SOURCES})
+TARGET_LINK_LIBRARIES(HYBRIDPluginGUI ${_link_LIBRARIES} )
+INSTALL(TARGETS HYBRIDPluginGUI EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
-INSTALL(FILES ${GHS3DPluginGUI_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
-QT4_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_GHS3DPLUGIN_INSTALL_RES_DATA}")
+INSTALL(FILES ${HYBRIDPluginGUI_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
+QT4_INSTALL_TS_RESOURCES("${_ts_RESOURCES}" "${SALOME_HYBRIDPLUGIN_INSTALL_RES_DATA}")
//
// ---
-// File : GHS3DPluginGUI.cxx
+// File : HYBRIDPluginGUI.cxx
// Authors : Gilles DAVID (Euriware)
// ---
//
-#include "GHS3DPluginGUI_HypothesisCreator.h"
+#include "HYBRIDPluginGUI_HypothesisCreator.h"
//=============================================================================
/*! GetHypothesisCreator
//=============================================================================
extern "C"
{
- GHS3DPLUGINGUI_EXPORT
+ HYBRIDPLUGINGUI_EXPORT
SMESHGUI_GenericHypothesisCreator* GetHypothesisCreator( const QString& aHypType )
{
SMESHGUI_GenericHypothesisCreator* aCreator = NULL;
- if ( aHypType == "GHS3D_Parameters" )
- aCreator = new GHS3DPluginGUI_HypothesisCreator( aHypType );
+ if ( aHypType == "HYBRID_Parameters" )
+ aCreator = new HYBRIDPluginGUI_HypothesisCreator( aHypType );
return aCreator;
}
}
//
// ---
-// File : GHS3DPluginGUI_Dlg.cxx
+// File : HYBRIDPluginGUI_Dlg.cxx
// Authors : Renaud NEDELEC (OCC)
// ---
//
-#include "GHS3DPluginGUI_Dlg.h"
+#include "HYBRIDPluginGUI_Dlg.h"
#include <QFileDialog>
//////////////////////////////////////////
-// GHS3DPluginGUI_AdvWidget
+// HYBRIDPluginGUI_AdvWidget
//////////////////////////////////////////
-GHS3DPluginGUI_AdvWidget::GHS3DPluginGUI_AdvWidget( QWidget* parent, Qt::WindowFlags f )
+HYBRIDPluginGUI_AdvWidget::HYBRIDPluginGUI_AdvWidget( QWidget* parent, Qt::WindowFlags f )
: QWidget( parent, f )
{
setupUi( this );
}
-GHS3DPluginGUI_AdvWidget::~GHS3DPluginGUI_AdvWidget()
+HYBRIDPluginGUI_AdvWidget::~HYBRIDPluginGUI_AdvWidget()
{
}
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
- <class>GHS3DPluginGUI_AdvWidget_QTD</class>
- <widget class="QWidget" name="GHS3DPluginGUI_AdvWidget_QTD">
+ <class>HYBRIDPluginGUI_AdvWidget_QTD</class>
+ <widget class="QWidget" name="HYBRIDPluginGUI_AdvWidget_QTD">
<property name="geometry">
<rect>
<x>0</x>
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// File : GHS3DPluginGUI_Dlg.h
+// File : HYBRIDPluginGUI_Dlg.h
// Author : Renaud NEDELEC (OpenCascade)
-#ifndef GHS3DPLUGINGUI_H
-#define GHS3DPLUGINGUI_H
+#ifndef HYBRIDPLUGINGUI_H
+#define HYBRIDPLUGINGUI_H
//////////////////////////////////////////
-// GHS3DPluginGUI_AdvWidget
+// HYBRIDPluginGUI_AdvWidget
//////////////////////////////////////////
-#include "ui_GHS3DPluginGUI_AdvWidget_QTD.h"
-#include "GHS3DPluginGUI_HypothesisCreator.h"
+#include "ui_HYBRIDPluginGUI_AdvWidget_QTD.h"
+#include "HYBRIDPluginGUI_HypothesisCreator.h"
-class GHS3DPLUGINGUI_EXPORT GHS3DPluginGUI_AdvWidget : public QWidget,
- public Ui::GHS3DPluginGUI_AdvWidget_QTD
+class HYBRIDPLUGINGUI_EXPORT HYBRIDPluginGUI_AdvWidget : public QWidget,
+ public Ui::HYBRIDPluginGUI_AdvWidget_QTD
{
Q_OBJECT
public:
- GHS3DPluginGUI_AdvWidget( QWidget* = 0, Qt::WindowFlags = 0 );
- ~GHS3DPluginGUI_AdvWidget();
+ HYBRIDPluginGUI_AdvWidget( QWidget* = 0, Qt::WindowFlags = 0 );
+ ~HYBRIDPluginGUI_AdvWidget();
};
#endif
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// GHS3DPlugin GUI: GUI for plugged-in mesher GHS3DPlugin
-// File : GHS3DPluginGUI_Enums.h
+// HYBRIDPlugin GUI: GUI for plugged-in mesher HYBRIDPlugin
+// File : HYBRIDPluginGUI_Enums.h
// Author : Gilles DAVID (Euriware)
-// Module : GHS3DPlugin
+// Module : HYBRIDPlugin
//
-#ifndef GHS3DPLUGINGUI_Enums_HeaderFile
-#define GHS3DPLUGINGUI_Enums_HeaderFile
+#ifndef HYBRIDPLUGINGUI_Enums_HeaderFile
+#define HYBRIDPLUGINGUI_Enums_HeaderFile
// tabs
enum {
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// GHS3DPlugin GUI: GUI for plugged-in mesher GHS3DPlugin
-// File : GHS3DPluginGUI_HypothesisCreator.cxx
+// HYBRIDPlugin GUI: GUI for plugged-in mesher HYBRIDPlugin
+// File : HYBRIDPluginGUI_HypothesisCreator.cxx
// Author : Michael Zorin
-// Module : GHS3DPlugin
+// Module : HYBRIDPlugin
//
-#include "GHS3DPluginGUI_HypothesisCreator.h"
-#include "GHS3DPluginGUI_Enums.h"
-#include "GHS3DPluginGUI_Dlg.h"
+#include "HYBRIDPluginGUI_HypothesisCreator.h"
+#include "HYBRIDPluginGUI_Enums.h"
+#include "HYBRIDPluginGUI_Dlg.h"
#include <GeometryGUI.h>
//
-GHS3DPluginGUI_HypothesisCreator::GHS3DPluginGUI_HypothesisCreator( const QString& theHypType )
+HYBRIDPluginGUI_HypothesisCreator::HYBRIDPluginGUI_HypothesisCreator( const QString& theHypType )
: SMESHGUI_GenericHypothesisCreator( theHypType )
{
GeomToolSelected = NULL;
iconVertex = QPixmap(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_OBJBROWSER_VERTEX")));
iconCompound = QPixmap(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_OBJBROWSER_COMPOUND")));
// mySelectionMgr = SMESH::GetSelectionMgr(SMESHGUI::GetSMESHGUI());
- myEnfMeshConstraintLabels << tr( "GHS3D_ENF_MESH_CONSTRAINT_NODE" ) << tr( "GHS3D_ENF_MESH_CONSTRAINT_EDGE" ) << tr("GHS3D_ENF_MESH_CONSTRAINT_FACE");
+ myEnfMeshConstraintLabels << tr( "HYBRID_ENF_MESH_CONSTRAINT_NODE" ) << tr( "HYBRID_ENF_MESH_CONSTRAINT_EDGE" ) << tr("HYBRID_ENF_MESH_CONSTRAINT_FACE");
}
-GHS3DPluginGUI_HypothesisCreator::~GHS3DPluginGUI_HypothesisCreator()
+HYBRIDPluginGUI_HypothesisCreator::~HYBRIDPluginGUI_HypothesisCreator()
{
- GHS3DPluginGUI_HypothesisCreator* that = (GHS3DPluginGUI_HypothesisCreator*)this;
+ HYBRIDPluginGUI_HypothesisCreator* that = (HYBRIDPluginGUI_HypothesisCreator*)this;
that->getGeomSelectionTool()->selectionMgr()->clearFilters();
myEnfMeshWdg->deactivateSelection();
}
/**
* \brief {Get or create the geom selection tool for active study}
* */
-GeomSelectionTools* GHS3DPluginGUI_HypothesisCreator::getGeomSelectionTool()
+GeomSelectionTools* HYBRIDPluginGUI_HypothesisCreator::getGeomSelectionTool()
{
- GHS3DPluginGUI_HypothesisCreator* that = (GHS3DPluginGUI_HypothesisCreator*)this;
+ HYBRIDPluginGUI_HypothesisCreator* that = (HYBRIDPluginGUI_HypothesisCreator*)this;
_PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
if (that->GeomToolSelected == NULL || that->GeomToolSelected->getMyStudy() != aStudy) {
that->GeomToolSelected = new GeomSelectionTools(aStudy);
return that->GeomToolSelected;
}
-GEOM::GEOM_Gen_var GHS3DPluginGUI_HypothesisCreator::getGeomEngine()
+GEOM::GEOM_Gen_var HYBRIDPluginGUI_HypothesisCreator::getGeomEngine()
{
return GeometryGUI::GetGeomGen();
}
-QFrame* GHS3DPluginGUI_HypothesisCreator::buildFrame()
+QFrame* HYBRIDPluginGUI_HypothesisCreator::buildFrame()
{
QFrame* fr = new QFrame( 0 );
QVBoxLayout* lay = new QVBoxLayout( fr );
aStdLayout->addWidget( myName, row++, 1, 1, 1 );
}
- myToMeshHolesCheck = new QCheckBox( tr( "GHS3D_TO_MESH_HOLES" ), myStdGroup );
+ myToMeshHolesCheck = new QCheckBox( tr( "HYBRID_TO_MESH_HOLES" ), myStdGroup );
aStdLayout->addWidget( myToMeshHolesCheck, row, 0, 1, 1 );
- myToMakeGroupsOfDomains = new QCheckBox( tr( "GHS3D_TO_MAKE_DOMAIN_GROUPS" ), myStdGroup );
+ myToMakeGroupsOfDomains = new QCheckBox( tr( "HYBRID_TO_MAKE_DOMAIN_GROUPS" ), myStdGroup );
aStdLayout->addWidget( myToMakeGroupsOfDomains, row++, 1, 1, 1 );
- aStdLayout->addWidget( new QLabel( tr( "GHS3D_OPTIMIZATIOL_LEVEL" ), myStdGroup ), row, 0, 1, 1 );
+ aStdLayout->addWidget( new QLabel( tr( "HYBRID_OPTIMIZATIOL_LEVEL" ), myStdGroup ), row, 0, 1, 1 );
myOptimizationLevelCombo = new QComboBox( myStdGroup );
aStdLayout->addWidget( myOptimizationLevelCombo, row++, 1, 1, 1 );
QGridLayout* anAdvLayout = new QGridLayout( myAdvGroup );
anAdvLayout->setSpacing( 6 );
anAdvLayout->setMargin( 11 );
- myAdvWidget = new GHS3DPluginGUI_AdvWidget(myAdvGroup);
+ myAdvWidget = new HYBRIDPluginGUI_AdvWidget(myAdvGroup);
anAdvLayout->addWidget( myAdvWidget);
myAdvWidget->maxMemoryCheck->setText(tr( "MAX_MEMORY_SIZE" ));
myAdvWidget->removeInitialCentralPointCheck->setText (tr( "NO_INITIAL_CENTRAL_POINT" ));
myAdvWidget->boundaryRecoveryCheck ->setText (tr( "RECOVERY_VERSION" ));
myAdvWidget->FEMCorrectionCheck ->setText (tr( "FEM_CORRECTION" ));
- myAdvWidget->gradationLabel ->setText (tr( "GHS3D_GRADATION" ));
+ myAdvWidget->gradationLabel ->setText (tr( "HYBRID_GRADATION" ));
myAdvWidget->gradationSpinBox->RangeStepAndValidator(1.05, 5.0, 0.05, "length_precision");
myAdvWidget->textOptionLabel->setText(tr( "TEXT_OPTION" ));
myEnforcedTableWidget->setColumnCount( ENF_VER_NB_COLUMNS );
myEnforcedTableWidget->setSortingEnabled(true);
QStringList enforcedHeaders;
- enforcedHeaders << tr( "GHS3D_ENF_NAME_COLUMN" )
- << tr( "GHS3D_ENF_VER_X_COLUMN" )<< tr( "GHS3D_ENF_VER_Y_COLUMN" ) << tr( "GHS3D_ENF_VER_Z_COLUMN" )
- << tr( "GHS3D_ENF_SIZE_COLUMN" ) << tr("GHS3D_ENF_ENTRY_COLUMN") << tr("GHS3D_ENF_VER_COMPOUND_COLUMN") << tr( "GHS3D_ENF_GROUP_COLUMN" );
+ enforcedHeaders << tr( "HYBRID_ENF_NAME_COLUMN" )
+ << tr( "HYBRID_ENF_VER_X_COLUMN" )<< tr( "HYBRID_ENF_VER_Y_COLUMN" ) << tr( "HYBRID_ENF_VER_Z_COLUMN" )
+ << tr( "HYBRID_ENF_SIZE_COLUMN" ) << tr("HYBRID_ENF_ENTRY_COLUMN") << tr("HYBRID_ENF_VER_COMPOUND_COLUMN") << tr( "HYBRID_ENF_GROUP_COLUMN" );
myEnforcedTableWidget->setHorizontalHeaderLabels(enforcedHeaders);
myEnforcedTableWidget->verticalHeader()->hide();
SMESH_NumberFilter* vertexFilter = new SMESH_NumberFilter("GEOM", TopAbs_SHAPE, 1, shapeTypes);
myEnfVertexWdg = new StdMeshersGUI_ObjectReferenceParamWdg( vertexFilter, 0, /*multiSel=*/true, /*stretch=*/false);
- myEnfVertexWdg->SetDefaultText(tr("GHS3D_ENF_SELECT_VERTEX"), "QLineEdit { color: grey }");
+ myEnfVertexWdg->SetDefaultText(tr("HYBRID_ENF_SELECT_VERTEX"), "QLineEdit { color: grey }");
- QLabel* myXCoordLabel = new QLabel( tr( "GHS3D_ENF_VER_X_LABEL" ), myEnfGroup );
+ QLabel* myXCoordLabel = new QLabel( tr( "HYBRID_ENF_VER_X_LABEL" ), myEnfGroup );
myXCoord = new SMESHGUI_SpinBox(myEnfGroup);
myXCoord->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
- QLabel* myYCoordLabel = new QLabel( tr( "GHS3D_ENF_VER_Y_LABEL" ), myEnfGroup );
+ QLabel* myYCoordLabel = new QLabel( tr( "HYBRID_ENF_VER_Y_LABEL" ), myEnfGroup );
myYCoord = new SMESHGUI_SpinBox(myEnfGroup);
myYCoord->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
- QLabel* myZCoordLabel = new QLabel( tr( "GHS3D_ENF_VER_Z_LABEL" ), myEnfGroup );
+ QLabel* myZCoordLabel = new QLabel( tr( "HYBRID_ENF_VER_Z_LABEL" ), myEnfGroup );
myZCoord = new SMESHGUI_SpinBox(myEnfGroup);
myZCoord->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
- QLabel* mySizeLabel = new QLabel( tr( "GHS3D_ENF_SIZE_LABEL" ), myEnfGroup );
+ QLabel* mySizeLabel = new QLabel( tr( "HYBRID_ENF_SIZE_LABEL" ), myEnfGroup );
mySizeValue = new SMESHGUI_SpinBox(myEnfGroup);
mySizeValue->RangeStepAndValidator(COORD_MIN, COORD_MAX, 10.0, "length_precision");
- QLabel* myGroupNameLabel = new QLabel( tr( "GHS3D_ENF_GROUP_LABEL" ), myEnfGroup );
+ QLabel* myGroupNameLabel = new QLabel( tr( "HYBRID_ENF_GROUP_LABEL" ), myEnfGroup );
myGroupName = new QLineEdit(myEnfGroup);
- addVertexButton = new QPushButton(tr("GHS3D_ENF_ADD"),myEnfGroup);
+ addVertexButton = new QPushButton(tr("HYBRID_ENF_ADD"),myEnfGroup);
addVertexButton->setEnabled(false);
- removeVertexButton = new QPushButton(tr("GHS3D_ENF_REMOVE"),myEnfGroup);
-// myGlobalGroupName = new QCheckBox(tr("GHS3D_ENF_VER_GROUPS"), myEnfGroup);
+ removeVertexButton = new QPushButton(tr("HYBRID_ENF_REMOVE"),myEnfGroup);
+// myGlobalGroupName = new QCheckBox(tr("HYBRID_ENF_VER_GROUPS"), myEnfGroup);
// myGlobalGroupName->setChecked(false);
// QGroupBox* GroupBox = new QGroupBox( myEnfGroup );
// QLabel* info = new QLabel( GroupBox );
- // info->setText( tr( "GHS3D_ENF_VER_INFO" ) );
+ // info->setText( tr( "HYBRID_ENF_VER_INFO" ) );
// info->setWordWrap( true );
// QVBoxLayout* GroupBoxVLayout = new QVBoxLayout( GroupBox );
// GroupBoxVLayout->setSpacing( 6 );
myEnforcedMeshTableWidget->setSortingEnabled(true);
myEnforcedMeshTableWidget->verticalHeader()->hide();
QStringList enforcedMeshHeaders;
- enforcedMeshHeaders << tr( "GHS3D_ENF_NAME_COLUMN" )
- << tr( "GHS3D_ENF_ENTRY_COLUMN" )
- << tr( "GHS3D_ENF_MESH_CONSTRAINT_COLUMN" )
- << tr( "GHS3D_ENF_GROUP_COLUMN" );
+ enforcedMeshHeaders << tr( "HYBRID_ENF_NAME_COLUMN" )
+ << tr( "HYBRID_ENF_ENTRY_COLUMN" )
+ << tr( "HYBRID_ENF_MESH_CONSTRAINT_COLUMN" )
+ << tr( "HYBRID_ENF_GROUP_COLUMN" );
myEnforcedMeshTableWidget->setHorizontalHeaderLabels(enforcedMeshHeaders);
myEnforcedMeshTableWidget->horizontalHeader()->setStretchLastSection(true);
myEnforcedMeshTableWidget->horizontalHeader()->setResizeMode(QHeaderView::Interactive);
// myEnfMeshArray = new SMESH::mesh_array();
myEnfMeshWdg = new StdMeshersGUI_ObjectReferenceParamWdg( SMESH::IDSOURCE, myEnfMeshGroup, /*multiSel=*/true);
- myEnfMeshWdg->SetDefaultText(tr("GHS3D_ENF_SELECT_MESH"), "QLineEdit { color: grey }");
+ myEnfMeshWdg->SetDefaultText(tr("HYBRID_ENF_SELECT_MESH"), "QLineEdit { color: grey }");
myEnfMeshWdg->AvoidSimultaneousSelection(myEnfVertexWdg);
- QLabel* myMeshConstraintLabel = new QLabel( tr( "GHS3D_ENF_MESH_CONSTRAINT_LABEL" ), myEnfMeshGroup );
+ QLabel* myMeshConstraintLabel = new QLabel( tr( "HYBRID_ENF_MESH_CONSTRAINT_LABEL" ), myEnfMeshGroup );
myEnfMeshConstraint = new QComboBox(myEnfMeshGroup);
myEnfMeshConstraint->insertItems(0,myEnfMeshConstraintLabels);
myEnfMeshConstraint->setEditable(false);
myEnfMeshConstraint->setCurrentIndex(0);
- QLabel* myMeshGroupNameLabel = new QLabel( tr( "GHS3D_ENF_GROUP_LABEL" ), myEnfMeshGroup );
+ QLabel* myMeshGroupNameLabel = new QLabel( tr( "HYBRID_ENF_GROUP_LABEL" ), myEnfMeshGroup );
myMeshGroupName = new QLineEdit(myEnfMeshGroup);
- addEnfMeshButton = new QPushButton(tr("GHS3D_ENF_ADD"),myEnfMeshGroup);
+ addEnfMeshButton = new QPushButton(tr("HYBRID_ENF_ADD"),myEnfMeshGroup);
// addEnfMeshButton->setEnabled(false);
- removeEnfMeshButton = new QPushButton(tr("GHS3D_ENF_REMOVE"),myEnfMeshGroup);
+ removeEnfMeshButton = new QPushButton(tr("HYBRID_ENF_REMOVE"),myEnfMeshGroup);
// QGroupBox* GroupBox2 = new QGroupBox( myEnfMeshGroup );
// QLabel* info2 = new QLabel( GroupBox2 );
- // info2->setText( tr( "GHS3D_ENF_MESH_INFO" ) );
+ // info2->setText( tr( "HYBRID_ENF_MESH_INFO" ) );
// info2->setWordWrap( true );
// QVBoxLayout* GroupBox2VLayout = new QVBoxLayout( GroupBox2 );
// GroupBox2VLayout->setSpacing( 6 );
// add tabs
tab->insertTab( STD_TAB, myStdGroup, tr( "SMESH_ARGUMENTS" ) );
- tab->insertTab( ADV_TAB, myAdvGroup, tr( "GHS3D_ADV_ARGS" ) );
- tab->insertTab( ENF_VER_TAB, myEnfGroup, tr( "GHS3D_ENFORCED_VERTICES" ) );
- tab->insertTab( ENF_MESH_TAB, myEnfMeshGroup, tr( "GHS3D_ENFORCED_MESHES" ) );
+ tab->insertTab( ADV_TAB, myAdvGroup, tr( "HYBRID_ADV_ARGS" ) );
+ tab->insertTab( ENF_VER_TAB, myEnfGroup, tr( "HYBRID_ENFORCED_VERTICES" ) );
+ tab->insertTab( ENF_MESH_TAB, myEnfMeshGroup, tr( "HYBRID_ENFORCED_MESHES" ) );
tab->setCurrentIndex( STD_TAB );
// connections
/**
* This method checks if an enforced vertex is defined;
**/
-void GHS3DPluginGUI_HypothesisCreator::clearEnfVertexSelection()
+void HYBRIDPluginGUI_HypothesisCreator::clearEnfVertexSelection()
{
if (myEnfVertexWdg->NbObjects() != 0) {
disconnect( myEnfVertexWdg, SIGNAL( contentModified()), this, SLOT( onSelectEnforcedVertex() ) );
connect( myEnfVertexWdg, SIGNAL( contentModified()), this, SLOT( onSelectEnforcedVertex() ) );
connect( myEnfVertexWdg, SIGNAL( contentModified()), this, SLOT( checkVertexIsDefined() ) );
}
- GHS3DPluginGUI_HypothesisCreator* that = (GHS3DPluginGUI_HypothesisCreator*)this;
+ HYBRIDPluginGUI_HypothesisCreator* that = (HYBRIDPluginGUI_HypothesisCreator*)this;
that->checkVertexIsDefined();
}
/**
* This method checks if an enforced vertex is defined;
**/
-void GHS3DPluginGUI_HypothesisCreator::checkVertexIsDefined()
+void HYBRIDPluginGUI_HypothesisCreator::checkVertexIsDefined()
{
bool enfVertexIsDefined = false;
enfVertexIsDefined = (!mySizeValue->GetString().isEmpty() &&
/**
* This method checks if an enforced mesh is defined;
**/
-void GHS3DPluginGUI_HypothesisCreator::checkEnfMeshIsDefined()
+void HYBRIDPluginGUI_HypothesisCreator::checkEnfMeshIsDefined()
{
emit enfMeshDefined( myEnfVertexWdg->NbObjects() != 0);
}
/**
* This method resets the content of the X, Y, Z, size and GroupName widgets;
**/
-void GHS3DPluginGUI_HypothesisCreator::clearEnforcedVertexWidgets()
+void HYBRIDPluginGUI_HypothesisCreator::clearEnforcedVertexWidgets()
{
myXCoord->setCleared(true);
myYCoord->setCleared(true);
addVertexButton->setEnabled(false);
}
-/** GHS3DPluginGUI_HypothesisCreator::updateEnforcedVertexValues(item)
+/** HYBRIDPluginGUI_HypothesisCreator::updateEnforcedVertexValues(item)
This method updates the tooltip of a modified item. The QLineEdit widgets content
is synchronized with the coordinates of the enforced vertex clicked in the tree widget.
*/
-void GHS3DPluginGUI_HypothesisCreator::updateEnforcedVertexValues(QTableWidgetItem* item) {
-// MESSAGE("GHS3DPluginGUI_HypothesisCreator::updateEnforcedVertexValues");
+void HYBRIDPluginGUI_HypothesisCreator::updateEnforcedVertexValues(QTableWidgetItem* item) {
+// MESSAGE("HYBRIDPluginGUI_HypothesisCreator::updateEnforcedVertexValues");
int row = myEnforcedTableWidget->row(item);
QVariant vertexName = myEnforcedTableWidget->item(row,ENF_VER_NAME_COLUMN)->data(Qt::EditRole);
}
}
-void GHS3DPluginGUI_HypothesisCreator::onSelectEnforcedVertex() {
+void HYBRIDPluginGUI_HypothesisCreator::onSelectEnforcedVertex() {
int nbSelEnfVertex = myEnfVertexWdg->NbObjects();
clearEnforcedVertexWidgets();
if (nbSelEnfVertex == 1)
if (myEnfVertex == GEOM::GEOM_Object::_nil())
return;
if (myEnfVertex->GetShapeType() == GEOM::VERTEX) {
- GHS3DPluginGUI_HypothesisCreator* that = (GHS3DPluginGUI_HypothesisCreator*)this;
+ HYBRIDPluginGUI_HypothesisCreator* that = (HYBRIDPluginGUI_HypothesisCreator*)this;
GEOM::GEOM_IMeasureOperations_var measureOp = getGeomEngine()->GetIMeasureOperations( that->getGeomSelectionTool()->getMyStudy()->StudyId() );
if (CORBA::is_nil(measureOp))
return;
}
}
-/** GHS3DPluginGUI_HypothesisCreator::synchronizeCoords()
+/** HYBRIDPluginGUI_HypothesisCreator::synchronizeCoords()
This method synchronizes the QLineEdit/SMESHGUI_SpinBox widgets content with the coordinates
of the enforced vertex clicked in the tree widget.
*/
-void GHS3DPluginGUI_HypothesisCreator::synchronizeCoords() {
+void HYBRIDPluginGUI_HypothesisCreator::synchronizeCoords() {
clearEnforcedVertexWidgets();
QList<QTableWidgetItem *> items = myEnforcedTableWidget->selectedItems();
// myEnfVertexWdg->disconnect(SIGNAL(contentModified()));
myEnfVertexWdg->SetObject(GEOM::GEOM_Object::_nil());
}
connect( myEnfVertexWdg, SIGNAL( contentModified()), this, SLOT( onSelectEnforcedVertex() ) );
- GHS3DPluginGUI_HypothesisCreator* that = (GHS3DPluginGUI_HypothesisCreator*)this;
+ HYBRIDPluginGUI_HypothesisCreator* that = (HYBRIDPluginGUI_HypothesisCreator*)this;
that->checkVertexIsDefined();
}
-/** GHS3DPluginGUI_HypothesisCreator::addEnforcedMesh( meshName, geomEntry, elemType, size, groupName)
+/** HYBRIDPluginGUI_HypothesisCreator::addEnforcedMesh( meshName, geomEntry, elemType, size, groupName)
This method adds in the tree widget an enforced mesh from mesh, submesh or group with optionally size and and groupName.
*/
-void GHS3DPluginGUI_HypothesisCreator::addEnforcedMesh(std::string name, std::string entry, int elementType, std::string groupName)
+void HYBRIDPluginGUI_HypothesisCreator::addEnforcedMesh(std::string name, std::string entry, int elementType, std::string groupName)
{
MESSAGE("addEnforcedMesh(\"" << name << ", \"" << entry << "\", " << elementType << ", \"" << groupName << "\")");
bool okToCreate = true;
}
-/** GHS3DPluginGUI_HypothesisCreator::addEnforcedVertex( x, y, z, size, vertexName, geomEntry, groupName)
+/** HYBRIDPluginGUI_HypothesisCreator::addEnforcedVertex( x, y, z, size, vertexName, geomEntry, groupName)
This method adds in the tree widget an enforced vertex with given size and coords (x,y,z) or GEOM vertex or compound and with optionally groupName.
*/
-void GHS3DPluginGUI_HypothesisCreator::addEnforcedVertex(double x, double y, double z, double size, std::string vertexName, std::string geomEntry, std::string groupName, bool isCompound)
+void HYBRIDPluginGUI_HypothesisCreator::addEnforcedVertex(double x, double y, double z, double size, std::string vertexName, std::string geomEntry, std::string groupName, bool isCompound)
{
MESSAGE("addEnforcedVertex(" << x << ", " << y << ", " << z << ", " << size << ", \"" << vertexName << ", \"" << geomEntry << "\", \"" << groupName << "\", " << isCompound << ")");
myEnforcedTableWidget->disconnect(SIGNAL( itemChanged(QTableWidgetItem *)));
updateEnforcedVertexValues(myEnforcedTableWidget->item(rowCount,ENF_VER_NAME_COLUMN));
}
-/** GHS3DPluginGUI_HypothesisCreator::onAddEnforcedMesh()
+/** HYBRIDPluginGUI_HypothesisCreator::onAddEnforcedMesh()
This method is called when a item is added into the enforced meshes tree widget
*/
-void GHS3DPluginGUI_HypothesisCreator::onAddEnforcedMesh()
+void HYBRIDPluginGUI_HypothesisCreator::onAddEnforcedMesh()
{
- MESSAGE("GHS3DPluginGUI_HypothesisCreator::onAddEnforcedMesh()");
+ MESSAGE("HYBRIDPluginGUI_HypothesisCreator::onAddEnforcedMesh()");
- GHS3DPluginGUI_HypothesisCreator* that = (GHS3DPluginGUI_HypothesisCreator*)this;
+ HYBRIDPluginGUI_HypothesisCreator* that = (HYBRIDPluginGUI_HypothesisCreator*)this;
that->getGeomSelectionTool()->selectionMgr()->clearFilters();
myEnfMeshWdg->deactivateSelection();
}
-/** GHS3DPluginGUI_HypothesisCreator::onAddEnforcedVertex()
+/** HYBRIDPluginGUI_HypothesisCreator::onAddEnforcedVertex()
This method is called when a item is added into the enforced vertices tree widget
*/
-void GHS3DPluginGUI_HypothesisCreator::onAddEnforcedVertex()
+void HYBRIDPluginGUI_HypothesisCreator::onAddEnforcedVertex()
{
- MESSAGE("GHS3DPluginGUI_HypothesisCreator::onAddEnforcedVertex()");
+ MESSAGE("HYBRIDPluginGUI_HypothesisCreator::onAddEnforcedVertex()");
- GHS3DPluginGUI_HypothesisCreator* that = (GHS3DPluginGUI_HypothesisCreator*)this;
+ HYBRIDPluginGUI_HypothesisCreator* that = (HYBRIDPluginGUI_HypothesisCreator*)this;
that->getGeomSelectionTool()->selectionMgr()->clearFilters();
myEnfVertexWdg->deactivateSelection();
myEnforcedTableWidget->resizeColumnToContents(column);
}
-/** GHS3DPluginGUI_HypothesisCreator::onRemoveEnforcedMesh()
+/** HYBRIDPluginGUI_HypothesisCreator::onRemoveEnforcedMesh()
This method is called when a item is removed from the enforced meshes tree widget
*/
-void GHS3DPluginGUI_HypothesisCreator::onRemoveEnforcedMesh()
+void HYBRIDPluginGUI_HypothesisCreator::onRemoveEnforcedMesh()
{
QList<int> selectedRows;
QList<QTableWidgetItem *> selectedItems = myEnforcedMeshTableWidget->selectedItems();
myEnforcedMeshTableWidget->selectionModel()->clearSelection();
}
-/** GHS3DPluginGUI_HypothesisCreator::onRemoveEnforcedVertex()
+/** HYBRIDPluginGUI_HypothesisCreator::onRemoveEnforcedVertex()
This method is called when a item is removed from the enforced vertices tree widget
*/
-void GHS3DPluginGUI_HypothesisCreator::onRemoveEnforcedVertex()
+void HYBRIDPluginGUI_HypothesisCreator::onRemoveEnforcedVertex()
{
QList<int> selectedRows;
QList<QTableWidgetItem *> selectedItems = myEnforcedTableWidget->selectedItems();
myEnforcedTableWidget->selectionModel()->clearSelection();
}
-void GHS3DPluginGUI_HypothesisCreator::onToMeshHoles(bool isOn)
+void HYBRIDPluginGUI_HypothesisCreator::onToMeshHoles(bool isOn)
{
// myToMakeGroupsOfDomains->setEnabled( isOn );
// if ( !isOn )
// myToMakeGroupsOfDomains->setChecked( false );
}
-void GHS3DPluginGUI_HypothesisCreator::onDirBtnClicked()
+void HYBRIDPluginGUI_HypothesisCreator::onDirBtnClicked()
{
QString dir = SUIT_FileDlg::getExistingDirectory( dlg(), myAdvWidget->workingDirectoryLineEdit->text(), QString() );
if ( !dir.isEmpty() )
myAdvWidget->workingDirectoryLineEdit->setText( dir );
}
-void GHS3DPluginGUI_HypothesisCreator::updateWidgets()
+void HYBRIDPluginGUI_HypothesisCreator::updateWidgets()
{
//myToMakeGroupsOfDomains->setEnabled( myToMeshHolesCheck->isChecked() );
myAdvWidget->maxMemorySpin->setEnabled( myAdvWidget->maxMemoryCheck->isChecked() );
}
}
-bool GHS3DPluginGUI_HypothesisCreator::checkParams(QString& msg) const
+bool HYBRIDPluginGUI_HypothesisCreator::checkParams(QString& msg) const
{
- MESSAGE("GHS3DPluginGUI_HypothesisCreator::checkParams");
+ MESSAGE("HYBRIDPluginGUI_HypothesisCreator::checkParams");
if ( !QFileInfo( myAdvWidget->workingDirectoryLineEdit->text().trimmed() ).isWritable() ) {
SUIT_MessageBox::warning( dlg(),
tr( "SMESH_WRN_WARNING" ),
- tr( "GHS3D_PERMISSION_DENIED" ) );
+ tr( "HYBRID_PERMISSION_DENIED" ) );
return false;
}
return true;
}
-void GHS3DPluginGUI_HypothesisCreator::retrieveParams() const
+void HYBRIDPluginGUI_HypothesisCreator::retrieveParams() const
{
- MESSAGE("GHS3DPluginGUI_HypothesisCreator::retrieveParams");
- GHS3DPluginGUI_HypothesisCreator* that = (GHS3DPluginGUI_HypothesisCreator*)this;
- GHS3DHypothesisData data;
+ MESSAGE("HYBRIDPluginGUI_HypothesisCreator::retrieveParams");
+ HYBRIDPluginGUI_HypothesisCreator* that = (HYBRIDPluginGUI_HypothesisCreator*)this;
+ HYBRIDHypothesisData data;
readParamsFromHypo( data );
if ( myName )
that->checkVertexIsDefined();
}
-QString GHS3DPluginGUI_HypothesisCreator::storeParams() const
+QString HYBRIDPluginGUI_HypothesisCreator::storeParams() const
{
- MESSAGE("GHS3DPluginGUI_HypothesisCreator::storeParams");
- GHS3DHypothesisData data;
+ MESSAGE("HYBRIDPluginGUI_HypothesisCreator::storeParams");
+ HYBRIDHypothesisData data;
readParamsFromWidgets( data );
storeParamsToHypo( data );
return valStr;
}
-bool GHS3DPluginGUI_HypothesisCreator::readParamsFromHypo( GHS3DHypothesisData& h_data ) const
+bool HYBRIDPluginGUI_HypothesisCreator::readParamsFromHypo( HYBRIDHypothesisData& h_data ) const
{
- MESSAGE("GHS3DPluginGUI_HypothesisCreator::readParamsFromHypo");
- GHS3DPlugin::GHS3DPlugin_Hypothesis_var h =
- GHS3DPlugin::GHS3DPlugin_Hypothesis::_narrow( initParamsHypothesis() );
+ MESSAGE("HYBRIDPluginGUI_HypothesisCreator::readParamsFromHypo");
+ HYBRIDPlugin::HYBRIDPlugin_Hypothesis_var h =
+ HYBRIDPlugin::HYBRIDPlugin_Hypothesis::_narrow( initParamsHypothesis() );
HypothesisData* data = SMESH::GetHypothesisData( hypType() );
h_data.myName = isCreation() && data ? hypName() : "";
h_data.myLogInStandardOutput = h->GetStandardOutputLog();
h_data.myRemoveLogOnSuccess = h->GetRemoveLogOnSuccess();
- GHS3DPlugin::GHS3DEnforcedVertexList_var vertices = h->GetEnforcedVertices();
+ HYBRIDPlugin::HYBRIDEnforcedVertexList_var vertices = h->GetEnforcedVertices();
MESSAGE("vertices->length(): " << vertices->length());
h_data.myEnforcedVertices.clear();
for (int i=0 ; i<vertices->length() ; i++) {
h_data.myEnforcedVertices.insert(myVertex);
}
- GHS3DPlugin::GHS3DEnforcedMeshList_var enfMeshes = h->GetEnforcedMeshes();
+ HYBRIDPlugin::HYBRIDEnforcedMeshList_var enfMeshes = h->GetEnforcedMeshes();
MESSAGE("enfMeshes->length(): " << enfMeshes->length());
h_data.myEnforcedMeshes.clear();
for (int i=0 ; i<enfMeshes->length() ; i++) {
return true;
}
-bool GHS3DPluginGUI_HypothesisCreator::storeParamsToHypo( const GHS3DHypothesisData& h_data ) const
+bool HYBRIDPluginGUI_HypothesisCreator::storeParamsToHypo( const HYBRIDHypothesisData& h_data ) const
{
- MESSAGE("GHS3DPluginGUI_HypothesisCreator::storeParamsToHypo");
- GHS3DPlugin::GHS3DPlugin_Hypothesis_var h =
- GHS3DPlugin::GHS3DPlugin_Hypothesis::_narrow( hypothesis() );
+ MESSAGE("HYBRIDPluginGUI_HypothesisCreator::storeParamsToHypo");
+ HYBRIDPlugin::HYBRIDPlugin_Hypothesis_var h =
+ HYBRIDPlugin::HYBRIDPlugin_Hypothesis::_narrow( hypothesis() );
bool ok = true;
try
// Enforced vertices
int nbVertex = (int) h_data.myEnforcedVertices.size();
- GHS3DPlugin::GHS3DEnforcedVertexList_var vertexHyp = h->GetEnforcedVertices();
+ HYBRIDPlugin::HYBRIDEnforcedVertexList_var vertexHyp = h->GetEnforcedVertices();
int nbVertexHyp = vertexHyp->length();
MESSAGE("Store params for size maps: " << nbVertex << " enforced vertices");
// Enforced Meshes
int nbEnfMeshes = (int) h_data.myEnforcedMeshes.size();
- GHS3DPlugin::GHS3DEnforcedMeshList_var enfMeshListHyp = h->GetEnforcedMeshes();
+ HYBRIDPlugin::HYBRIDEnforcedMeshList_var enfMeshListHyp = h->GetEnforcedMeshes();
int nbEnfMeshListHyp = enfMeshListHyp->length();
MESSAGE("Store params for size maps: " << nbEnfMeshes << " enforced meshes");
return ok;
}
-bool GHS3DPluginGUI_HypothesisCreator::readParamsFromWidgets( GHS3DHypothesisData& h_data ) const
+bool HYBRIDPluginGUI_HypothesisCreator::readParamsFromWidgets( HYBRIDHypothesisData& h_data ) const
{
- MESSAGE("GHS3DPluginGUI_HypothesisCreator::readParamsFromWidgets");
+ MESSAGE("HYBRIDPluginGUI_HypothesisCreator::readParamsFromWidgets");
h_data.myName = myName ? myName->text() : "";
h_data.myToMeshHoles = myToMeshHolesCheck->isChecked();
h_data.myToMakeGroupsOfDomains = myToMakeGroupsOfDomains->isChecked();
return true;
}
-QString GHS3DPluginGUI_HypothesisCreator::caption() const
+QString HYBRIDPluginGUI_HypothesisCreator::caption() const
{
- return tr( "GHS3D_TITLE" );
+ return tr( "HYBRID_TITLE" );
}
-QPixmap GHS3DPluginGUI_HypothesisCreator::icon() const
+QPixmap HYBRIDPluginGUI_HypothesisCreator::icon() const
{
- return SUIT_Session::session()->resourceMgr()->loadPixmap( "GHS3DPlugin", tr( "ICON_DLG_GHS3D_PARAMETERS" ) );
+ return SUIT_Session::session()->resourceMgr()->loadPixmap( "HYBRIDPlugin", tr( "ICON_DLG_HYBRID_PARAMETERS" ) );
}
-QString GHS3DPluginGUI_HypothesisCreator::type() const
+QString HYBRIDPluginGUI_HypothesisCreator::type() const
{
- return tr( "GHS3D_HYPOTHESIS" );
+ return tr( "HYBRID_HYPOTHESIS" );
}
-QString GHS3DPluginGUI_HypothesisCreator::helpPage() const
+QString HYBRIDPluginGUI_HypothesisCreator::helpPage() const
{
- return "ghs3d_hypo_page.html";
+ return "hybrid_hypo_page.html";
}
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// GHS3DPlugin GUI: GUI for plugged-in mesher GHS3DPlugin
-// File : GHS3DPluginGUI_HypothesisCreator.h
+// HYBRIDPlugin GUI: GUI for plugged-in mesher HYBRIDPlugin
+// File : HYBRIDPluginGUI_HypothesisCreator.h
// Author : Michael Zorin
-// Module : GHS3DPlugin
+// Module : HYBRIDPlugin
//
-#ifndef GHS3DPLUGINGUI_HypothesisCreator_HeaderFile
-#define GHS3DPLUGINGUI_HypothesisCreator_HeaderFile
+#ifndef HYBRIDPLUGINGUI_HypothesisCreator_HeaderFile
+#define HYBRIDPLUGINGUI_HypothesisCreator_HeaderFile
#ifdef WIN32
- #if defined GHS3DPluginGUI_EXPORTS
- #define GHS3DPLUGINGUI_EXPORT __declspec( dllexport )
+ #if defined HYBRIDPluginGUI_EXPORTS
+ #define HYBRIDPLUGINGUI_EXPORT __declspec( dllexport )
#else
- #define GHS3DPLUGINGUI_EXPORT __declspec( dllimport )
+ #define HYBRIDPLUGINGUI_EXPORT __declspec( dllimport )
#endif
#else
- #define GHS3DPLUGINGUI_EXPORT
+ #define HYBRIDPLUGINGUI_EXPORT
#endif
#include <SMESHGUI_Hypotheses.h>
#include <vector>
#include <set>
#include <GEOM_Client.hxx>
-#include CORBA_SERVER_HEADER(GHS3DPlugin_Algorithm)
+#include CORBA_SERVER_HEADER(HYBRIDPlugin_Algorithm)
#include CORBA_SERVER_HEADER(SMESH_Gen)
#include CORBA_SERVER_HEADER(SMESH_Mesh)
class StdMeshersGUI_ObjectReferenceParamWdg;
class LightApp_SelectionMgr;
class SUIT_SelectionFilter;
-class GHS3DPluginGUI_AdvWidget;
+class HYBRIDPluginGUI_AdvWidget;
class QTEnfVertex
{
short myVerboseLevel;
TEnfVertexList myEnforcedVertices;
TEnfMeshList myEnforcedMeshes;
-} GHS3DHypothesisData;
+} HYBRIDHypothesisData;
/*!
- \brief Class for creation of GHS3D2D and GHS3D3D hypotheses
+ \brief Class for creation of HYBRID2D and HYBRID3D hypotheses
*/
-class GHS3DPLUGINGUI_EXPORT GHS3DPluginGUI_HypothesisCreator : public SMESHGUI_GenericHypothesisCreator
+class HYBRIDPLUGINGUI_EXPORT HYBRIDPluginGUI_HypothesisCreator : public SMESHGUI_GenericHypothesisCreator
{
Q_OBJECT
public:
- GHS3DPluginGUI_HypothesisCreator( const QString& );
- virtual ~GHS3DPluginGUI_HypothesisCreator();
+ HYBRIDPluginGUI_HypothesisCreator( const QString& );
+ virtual ~HYBRIDPluginGUI_HypothesisCreator();
virtual bool checkParams(QString& msg) const;
virtual QString helpPage() const;
void enfMeshDefined(bool);
private:
- bool readParamsFromHypo( GHS3DHypothesisData& ) const;
- bool readParamsFromWidgets( GHS3DHypothesisData& ) const;
- bool storeParamsToHypo( const GHS3DHypothesisData& ) const;
+ bool readParamsFromHypo( HYBRIDHypothesisData& ) const;
+ bool readParamsFromWidgets( HYBRIDHypothesisData& ) const;
+ bool storeParamsToHypo( const HYBRIDHypothesisData& ) const;
GeomSelectionTools* getGeomSelectionTool();
GEOM::GEOM_Gen_var getGeomEngine();
QComboBox* myOptimizationLevelCombo;
QWidget* myAdvGroup;
- GHS3DPluginGUI_AdvWidget* myAdvWidget;
+ HYBRIDPluginGUI_AdvWidget* myAdvWidget;
QWidget* myEnfGroup;
QPixmap iconVertex, iconCompound;
<context>
<name>@default</name>
<message>
- <source>ICON_DLG_GHS3D_PARAMETERS</source>
- <translation>mesh_hypo_ghs3d.png</translation>
+ <source>ICON_DLG_HYBRID_PARAMETERS</source>
+ <translation>mesh_hypo_hybrid.png</translation>
</message>
<message>
- <source>ICON_SMESH_TREE_ALGO_GHS3D_3D</source>
- <translation>mesh_tree_hypo_ghs3d.png</translation>
+ <source>ICON_SMESH_TREE_ALGO_HYBRID_3D</source>
+ <translation>mesh_tree_hypo_hybrid.png</translation>
</message>
<message>
- <source>ICON_SMESH_TREE_HYPO_GHS3D_Parameters</source>
- <translation>mesh_tree_hypo_ghs3d.png</translation>
+ <source>ICON_SMESH_TREE_HYPO_HYBRID_Parameters</source>
+ <translation>mesh_tree_hypo_hybrid.png</translation>
</message>
</context>
</TS>
<context>
<name>@default</name>
<message>
- <source>GHS3D_ADV_ARGS</source>
+ <source>HYBRID_ADV_ARGS</source>
<translation>Advanced</translation>
</message>
<message>
- <source>GHS3D_HYPOTHESIS</source>
- <translation>GHS3D</translation>
+ <source>HYBRID_HYPOTHESIS</source>
+ <translation>HYBRID</translation>
</message>
<message>
- <source>GHS3D_OPTIMIZATIOL_LEVEL</source>
+ <source>HYBRID_OPTIMIZATIOL_LEVEL</source>
<translation>Optimization level</translation>
</message>
<message>
- <source>GHS3D_PERMISSION_DENIED</source>
+ <source>HYBRID_PERMISSION_DENIED</source>
<translation>Working directory is not writable</translation>
</message>
<message>
- <source>GHS3D_STD_ARGS</source>
+ <source>HYBRID_STD_ARGS</source>
<translation>Parameters</translation>
</message>
<message>
- <source>GHS3D_TITLE</source>
+ <source>HYBRID_TITLE</source>
<translation>Hypothesis Construction</translation>
</message>
<message>
- <source>GHS3D_TO_MESH_HOLES</source>
+ <source>HYBRID_TO_MESH_HOLES</source>
<translation>Mesh holes</translation>
</message>
<message>
- <source>GHS3D_TO_MAKE_DOMAIN_GROUPS</source>
+ <source>HYBRID_TO_MAKE_DOMAIN_GROUPS</source>
<translation>Make groups of domains</translation>
</message>
<message>
<translation>Use FEM correction</translation>
</message>
<message>
- <source>GHS3D_GRADATION</source>
+ <source>HYBRID_GRADATION</source>
<translation>Volumic gradation</translation>
</message>
<message>
<translation>Working directory</translation>
</message>
<message>
- <source>GHS3D_ENFORCED_VERTICES</source>
+ <source>HYBRID_ENFORCED_VERTICES</source>
<translation>Enforced vertices</translation>
</message>
<message>
- <source>GHS3D_ENFORCED_MESHES</source>
+ <source>HYBRID_ENFORCED_MESHES</source>
<translation>Enforced meshes</translation>
</message>
<message>
- <source>GHS3D_ENF_NAME_COLUMN</source>
+ <source>HYBRID_ENF_NAME_COLUMN</source>
<translation>Name</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_X_COLUMN</source>
+ <source>HYBRID_ENF_VER_X_COLUMN</source>
<translation>X</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Y_COLUMN</source>
+ <source>HYBRID_ENF_VER_Y_COLUMN</source>
<translation>Y</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Z_COLUMN</source>
+ <source>HYBRID_ENF_VER_Z_COLUMN</source>
<translation>Z</translation>
</message>
<message>
- <source>GHS3D_ENF_SIZE_COLUMN</source>
+ <source>HYBRID_ENF_SIZE_COLUMN</source>
<translation>Size</translation>
</message>
<message>
- <source>GHS3D_ENF_ENTRY_COLUMN</source>
+ <source>HYBRID_ENF_ENTRY_COLUMN</source>
<translation>Vertex Entry</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_COLUMN</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_COLUMN</source>
<translation>Constraint</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_COMPOUND_COLUMN</source>
+ <source>HYBRID_ENF_VER_COMPOUND_COLUMN</source>
<translation>Compound</translation>
</message>
<message>
- <source>GHS3D_ENF_GROUP_COLUMN</source>
+ <source>HYBRID_ENF_GROUP_COLUMN</source>
<translation>Group</translation>
</message>
<message>
- <source>GHS3D_ENF_SELECT_VERTEX</source>
+ <source>HYBRID_ENF_SELECT_VERTEX</source>
<translation>Select a vertex</translation>
</message>
<message>
- <source>GHS3D_ENF_SELECT_MESH</source>
+ <source>HYBRID_ENF_SELECT_MESH</source>
<translation>Select a mesh</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_X_LABEL</source>
+ <source>HYBRID_ENF_VER_X_LABEL</source>
<translation>X:</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Y_LABEL</source>
+ <source>HYBRID_ENF_VER_Y_LABEL</source>
<translation>Y:</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Z_LABEL</source>
+ <source>HYBRID_ENF_VER_Z_LABEL</source>
<translation>Z:</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_LABEL</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_LABEL</source>
<translation>Constraint:</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_NODE</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_NODE</source>
<translation>Nodes</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_EDGE</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_EDGE</source>
<translation>Edges</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_FACE</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_FACE</source>
<translation>Faces</translation>
</message>
<message>
- <source>GHS3D_ENF_SIZE_LABEL</source>
+ <source>HYBRID_ENF_SIZE_LABEL</source>
<translation>Size:</translation>
</message>
<message>
- <source>GHS3D_ENF_GROUP_LABEL</source>
+ <source>HYBRID_ENF_GROUP_LABEL</source>
<translation>Group:</translation>
</message>
<message>
- <source>GHS3D_ENF_ADD</source>
+ <source>HYBRID_ENF_ADD</source>
<translation>Add</translation>
</message>
<message>
- <source>GHS3D_ENF_REMOVE</source>
+ <source>HYBRID_ENF_REMOVE</source>
<translation>Remove</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_INFO</source>
+ <source>HYBRID_ENF_VER_INFO</source>
<translation><b>Warning</b>: Enforced vertices are currently only taken into account for meshes w/o associated geometry.</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_INFO</source>
+ <source>HYBRID_ENF_MESH_INFO</source>
<translation><b>Warning</b>: Enforced meshes are currently only taken into account for meshes w/o associated geometry.</translation>
</message>
</context>
<context>
<name>@default</name>
<message>
- <source>GHS3D_TO_MAKE_DOMAIN_GROUPS</source>
+ <source>HYBRID_TO_MAKE_DOMAIN_GROUPS</source>
<translation>Pour créer des groupes de domaines</translation>
</message>
<message>
- <source>GHS3D_ADV_ARGS</source>
+ <source>HYBRID_ADV_ARGS</source>
<translation>Avancé</translation>
</message>
<message>
- <source>GHS3D_HYPOTHESIS</source>
- <translation>GHS3D</translation>
+ <source>HYBRID_HYPOTHESIS</source>
+ <translation>HYBRID</translation>
</message>
<message>
- <source>GHS3D_OPTIMIZATIOL_LEVEL</source>
+ <source>HYBRID_OPTIMIZATIOL_LEVEL</source>
<translation>Niveau d'optimisation</translation>
</message>
<message>
- <source>GHS3D_PERMISSION_DENIED</source>
+ <source>HYBRID_PERMISSION_DENIED</source>
<translation>Il n'est pas possible d'écrire dans le répertoire</translation>
</message>
<message>
- <source>GHS3D_STD_ARGS</source>
+ <source>HYBRID_STD_ARGS</source>
<translation>Paramètres</translation>
</message>
<message>
- <source>GHS3D_TITLE</source>
+ <source>HYBRID_TITLE</source>
<translation>Construction de l'hypothèse </translation>
</message>
<message>
- <source>GHS3D_TO_MESH_HOLES</source>
+ <source>HYBRID_TO_MESH_HOLES</source>
<translation>Mailler les trous</translation>
</message>
<message>
<translation>Utiliser la correction FEM</translation>
</message>
<message>
- <source>GHS3D_GRADATION</source>
+ <source>HYBRID_GRADATION</source>
<translation>Gradation volumique</translation>
</message>
<message>
<translation>Répertoire de travail</translation>
</message>
<message>
- <source>GHS3D_ENFORCED_VERTICES</source>
+ <source>HYBRID_ENFORCED_VERTICES</source>
<translation>Points de passage</translation>
</message>
<message>
- <source>GHS3D_ENFORCED_MESHES</source>
+ <source>HYBRID_ENFORCED_MESHES</source>
<translation>Maillages de contrainte</translation>
</message>
<message>
- <source>GHS3D_ENF_NAME_COLUMN</source>
+ <source>HYBRID_ENF_NAME_COLUMN</source>
<translation>Nom</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_X_COLUMN</source>
+ <source>HYBRID_ENF_VER_X_COLUMN</source>
<translation>X</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Y_COLUMN</source>
+ <source>HYBRID_ENF_VER_Y_COLUMN</source>
<translation>Y</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Z_COLUMN</source>
+ <source>HYBRID_ENF_VER_Z_COLUMN</source>
<translation>Z</translation>
</message>
<message>
- <source>GHS3D_ENF_SIZE_COLUMN</source>
+ <source>HYBRID_ENF_SIZE_COLUMN</source>
<translation>Taille</translation>
</message>
<message>
- <source>GHS3D_ENF_ENTRY_COLUMN</source>
+ <source>HYBRID_ENF_ENTRY_COLUMN</source>
<translation>ID de point</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_COLUMN</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_COLUMN</source>
<translation>Contrainte</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_COMPOUND_COLUMN</source>
+ <source>HYBRID_ENF_VER_COMPOUND_COLUMN</source>
<translation>Compound</translation>
</message>
<message>
- <source>GHS3D_ENF_GROUP_COLUMN</source>
+ <source>HYBRID_ENF_GROUP_COLUMN</source>
<translation>Groupe</translation>
</message>
<message>
- <source>GHS3D_ENF_SELECT_VERTEX</source>
+ <source>HYBRID_ENF_SELECT_VERTEX</source>
<translation>Sélectionnez une/des point(s)</translation>
</message>
<message>
- <source>GHS3D_ENF_SELECT_MESH</source>
+ <source>HYBRID_ENF_SELECT_MESH</source>
<translation>Sélectionnez une/des maillage(s)</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_X_LABEL</source>
+ <source>HYBRID_ENF_VER_X_LABEL</source>
<translation>X:</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Y_LABEL</source>
+ <source>HYBRID_ENF_VER_Y_LABEL</source>
<translation>Y:</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Z_LABEL</source>
+ <source>HYBRID_ENF_VER_Z_LABEL</source>
<translation>Z:</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_LABEL</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_LABEL</source>
<translation>Contrainte:</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_NODE</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_NODE</source>
<translation>Noeuds</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_EDGE</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_EDGE</source>
<translation>Segments</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_FACE</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_FACE</source>
<translation>Faces</translation>
</message>
<message>
- <source>GHS3D_ENF_SIZE_LABEL</source>
+ <source>HYBRID_ENF_SIZE_LABEL</source>
<translation>Taille:</translation>
</message>
<message>
- <source>GHS3D_ENF_GROUP_LABEL</source>
+ <source>HYBRID_ENF_GROUP_LABEL</source>
<translation>Groupe:</translation>
</message>
<message>
- <source>GHS3D_ENF_ADD</source>
+ <source>HYBRID_ENF_ADD</source>
<translation>Ajouter</translation>
</message>
<message>
- <source>GHS3D_ENF_REMOVE</source>
+ <source>HYBRID_ENF_REMOVE</source>
<translation>Supprimer</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_INFO</source>
+ <source>HYBRID_ENF_VER_INFO</source>
<translation><b>Attention</b>: Les points de passage ne sont pris en compte que pour des maillage sans géométrie associée.</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_INFO</source>
+ <source>HYBRID_ENF_MESH_INFO</source>
<translation><b>Attention</b>: Les éléments de contraintes ne sont pris en compte que pour des maillage sans géométrie associée.</translation>
</message>
</context>
<context>
<name>@default</name>
<message>
- <source>GHS3D_ADV_ARGS</source>
+ <source>HYBRID_ADV_ARGS</source>
<translation>高度な</translation>
</message>
<message>
- <source>GHS3D_HYPOTHESIS</source>
- <translation>GHS3D</translation>
+ <source>HYBRID_HYPOTHESIS</source>
+ <translation>HYBRID</translation>
</message>
<message>
- <source>GHS3D_OPTIMIZATIOL_LEVEL</source>
+ <source>HYBRID_OPTIMIZATIOL_LEVEL</source>
<translation>最適化のレベル</translation>
</message>
<message>
- <source>GHS3D_PERMISSION_DENIED</source>
+ <source>HYBRID_PERMISSION_DENIED</source>
<translation>ディレクトリを作成することはできません。</translation>
</message>
<message>
- <source>GHS3D_STD_ARGS</source>
+ <source>HYBRID_STD_ARGS</source>
<translation>パラメーター</translation>
</message>
<message>
- <source>GHS3D_TITLE</source>
+ <source>HYBRID_TITLE</source>
<translation>仮説の構築</translation>
</message>
<message>
- <source>GHS3D_TO_MESH_HOLES</source>
+ <source>HYBRID_TO_MESH_HOLES</source>
<translation>メッシュの穴</translation>
</message>
<message>
- <source>GHS3D_TO_MAKE_DOMAIN_GROUPS</source>
+ <source>HYBRID_TO_MAKE_DOMAIN_GROUPS</source>
<translation>ドメインのグループを確認するには</translation>
</message>
<message>
<translation>GEF 補正を使用してください。</translation>
</message>
<message>
- <source>GHS3D_GRADATION</source>
+ <source>HYBRID_GRADATION</source>
<translation>ボリュームのグラデーション</translation>
</message>
<message>
<translation>作業ディレクトリ</translation>
</message>
<message>
- <source>GHS3D_ENFORCED_VERTICES</source>
+ <source>HYBRID_ENFORCED_VERTICES</source>
<translation>交差点</translation>
</message>
<message>
- <source>GHS3D_ENFORCED_MESHES</source>
+ <source>HYBRID_ENFORCED_MESHES</source>
<translation>制約メッシュ</translation>
</message>
<message>
- <source>GHS3D_ENF_NAME_COLUMN</source>
+ <source>HYBRID_ENF_NAME_COLUMN</source>
<translation>名前</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_X_COLUMN</source>
+ <source>HYBRID_ENF_VER_X_COLUMN</source>
<translation>X</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Y_COLUMN</source>
+ <source>HYBRID_ENF_VER_Y_COLUMN</source>
<translation>そこ</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Z_COLUMN</source>
+ <source>HYBRID_ENF_VER_Z_COLUMN</source>
<translation>Z</translation>
</message>
<message>
- <source>GHS3D_ENF_SIZE_COLUMN</source>
+ <source>HYBRID_ENF_SIZE_COLUMN</source>
<translation>サイズ</translation>
</message>
<message>
- <source>GHS3D_ENF_ENTRY_COLUMN</source>
+ <source>HYBRID_ENF_ENTRY_COLUMN</source>
<translation>ポイント ID</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_COLUMN</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_COLUMN</source>
<translation>制約</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_COMPOUND_COLUMN</source>
+ <source>HYBRID_ENF_VER_COMPOUND_COLUMN</source>
<translation>複合</translation>
</message>
<message>
- <source>GHS3D_ENF_GROUP_COLUMN</source>
+ <source>HYBRID_ENF_GROUP_COLUMN</source>
<translation>グループ</translation>
</message>
<message>
- <source>GHS3D_ENF_SELECT_VERTEX</source>
+ <source>HYBRID_ENF_SELECT_VERTEX</source>
<translation>・ ポイント (s) の選択</translation>
</message>
<message>
- <source>GHS3D_ENF_SELECT_MESH</source>
+ <source>HYBRID_ENF_SELECT_MESH</source>
<translation>1 つを選択/メッシュ (s)</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_X_LABEL</source>
+ <source>HYBRID_ENF_VER_X_LABEL</source>
<translation>X:</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Y_LABEL</source>
+ <source>HYBRID_ENF_VER_Y_LABEL</source>
<translation>Y:</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_Z_LABEL</source>
+ <source>HYBRID_ENF_VER_Z_LABEL</source>
<translation>Z:</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_LABEL</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_LABEL</source>
<translation>制約:</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_NODE</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_NODE</source>
<translation>節点</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_EDGE</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_EDGE</source>
<translation>セグメント</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_CONSTRAINT_FACE</source>
+ <source>HYBRID_ENF_MESH_CONSTRAINT_FACE</source>
<translation>Faces</translation>
</message>
<message>
- <source>GHS3D_ENF_SIZE_LABEL</source>
+ <source>HYBRID_ENF_SIZE_LABEL</source>
<translation>サイズ:</translation>
</message>
<message>
- <source>GHS3D_ENF_GROUP_LABEL</source>
+ <source>HYBRID_ENF_GROUP_LABEL</source>
<translation>グループ:</translation>
</message>
<message>
- <source>GHS3D_ENF_ADD</source>
+ <source>HYBRID_ENF_ADD</source>
<translation>追加</translation>
</message>
<message>
- <source>GHS3D_ENF_REMOVE</source>
+ <source>HYBRID_ENF_REMOVE</source>
<translation>削除</translation>
</message>
<message>
- <source>GHS3D_ENF_VER_INFO</source>
+ <source>HYBRID_ENF_VER_INFO</source>
<translation><b>注意</b>: 交差ポイント関連ジオメトリなしメッシュが考慮されます。</translation>
</message>
<message>
- <source>GHS3D_ENF_MESH_INFO</source>
+ <source>HYBRID_ENF_MESH_INFO</source>
<translation><b>注意</b>: 要素制約の関連付けられたジオメトリなしメッシュ考慮されます。</translation>
</message>
</context>
${KERNEL_SALOMEBasics}
${KERNEL_SalomeNS}
${KERNEL_OpUtil}
- SalomeIDLGHS3DPLUGIN
+ SalomeIDLHYBRIDPLUGIN
)
# --- headers ---
# header files
-SET(GHS3DEngine_HEADERS
- GHS3DPlugin_Defs.hxx
- GHS3DPlugin_GHS3D.hxx
- GHS3DPlugin_GHS3D_i.hxx
- GHS3DPlugin_Hypothesis.hxx
- GHS3DPlugin_Hypothesis_i.hxx
+SET(HYBRIDEngine_HEADERS
+ HYBRIDPlugin_Defs.hxx
+ HYBRIDPlugin_HYBRID.hxx
+ HYBRIDPlugin_HYBRID_i.hxx
+ HYBRIDPlugin_Hypothesis.hxx
+ HYBRIDPlugin_Hypothesis_i.hxx
)
# --- sources ---
# sources / static
-SET(GHS3DEngine_SOURCES
- GHS3DPlugin_GHS3D.cxx
- GHS3DPlugin_GHS3D_i.cxx
- GHS3DPlugin_i.cxx
- GHS3DPlugin_Hypothesis.cxx
- GHS3DPlugin_Hypothesis_i.cxx
+SET(HYBRIDEngine_SOURCES
+ HYBRIDPlugin_HYBRID.cxx
+ HYBRIDPlugin_HYBRID_i.cxx
+ HYBRIDPlugin_i.cxx
+ HYBRIDPlugin_Hypothesis.cxx
+ HYBRIDPlugin_Hypothesis_i.cxx
)
# --- scripts ---
# scripts / static
SET(_bin_SCRIPTS
__init__.py
- GHS3DPluginBuilder.py
+ HYBRIDPluginBuilder.py
)
# --- rules ---
-ADD_LIBRARY(GHS3DEngine ${GHS3DEngine_SOURCES})
-TARGET_LINK_LIBRARIES(GHS3DEngine ${_link_LIBRARIES} )
-INSTALL(TARGETS GHS3DEngine EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
+ADD_LIBRARY(HYBRIDEngine ${HYBRIDEngine_SOURCES})
+TARGET_LINK_LIBRARIES(HYBRIDEngine ${_link_LIBRARIES} )
+INSTALL(TARGETS HYBRIDEngine EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${SALOME_INSTALL_LIBS})
-INSTALL(FILES ${GHS3DEngine_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
+INSTALL(FILES ${HYBRIDEngine_HEADERS} DESTINATION ${SALOME_INSTALL_HEADERS})
-SALOME_INSTALL_SCRIPTS("${_bin_SCRIPTS}" ${SALOME_INSTALL_PYTHON}/salome/GHS3DPlugin)
+SALOME_INSTALL_SCRIPTS("${_bin_SCRIPTS}" ${SALOME_INSTALL_PYTHON}/salome/HYBRIDPlugin)
#
##
-# @package GHS3DPluginBuilder
-# Python API for the GHS3D meshing plug-in module.
+# @package HYBRIDPluginBuilder
+# Python API for the HYBRID meshing plug-in module.
from salome.smesh.smesh_algorithm import Mesh_Algorithm
from salome.smesh.smeshBuilder import AssureGeomPublished
-# import GHS3DPlugin module if possible
-noGHS3DPlugin = 0
+# import HYBRIDPlugin module if possible
+noHYBRIDPlugin = 0
try:
- import GHS3DPlugin
+ import HYBRIDPlugin
except ImportError:
- noGHS3DPlugin = 1
+ noHYBRIDPlugin = 1
pass
-# Optimization level of GHS3D
+# Optimization level of HYBRID
# V3.1
None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization = 0,1,2,3
# V4.1 (partialy redefines V3.1). Issue 0020574
# Mesh algo type identifiers
#----------------------------
-## Algorithm type: GHS3D tetrahedron 3D algorithm, see GHS3D_Algorithm
-GHS3D = "GHS3D_3D"
+## Algorithm type: HYBRID tetrahedron 3D algorithm, see HYBRID_Algorithm
+HYBRID = "HYBRID_3D"
-## Tetrahedron GHS3D 3D algorithm
+## Tetrahedron HYBRID 3D algorithm
#
-# It can be created by calling smeshBuilder.Mesh.Tetrahedron( smeshBuilder.GHS3D, geom=0 )
-class GHS3D_Algorithm(Mesh_Algorithm):
+# It can be created by calling smeshBuilder.Mesh.Tetrahedron( smeshBuilder.HYBRID, geom=0 )
+class HYBRID_Algorithm(Mesh_Algorithm):
## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Tetrahedron"
## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
- algoType = GHS3D
+ algoType = HYBRID
## doc string of the method in smeshBuilder.Mesh class
# @internal
docHelper = "Creates tetrahedron 3D algorithm for volumes"
# if it is @c 0 (default), the algorithm is assigned to the main shape
def __init__(self, mesh, geom=0):
Mesh_Algorithm.__init__(self)
- if noGHS3DPlugin: print "Warning: GHS3DPlugin module unavailable"
- self.Create(mesh, geom, self.algoType, "libGHS3DEngine.so")
+ if noHYBRIDPlugin: print "Warning: HYBRIDPlugin module unavailable"
+ self.Create(mesh, geom, self.algoType, "libHYBRIDEngine.so")
self.params = None
pass
# @return hypothesis object
def Parameters(self):
if not self.params:
- self.params = self.Hypothesis("GHS3D_Parameters", [],
- "libGHS3DEngine.so", UseExisting=0)
+ self.params = self.Hypothesis("HYBRID_Parameters", [],
+ "libHYBRIDEngine.so", UseExisting=0)
pass
return self.params
self.Parameters().SetTextOption(option)
pass
- pass # end of GHS3D_Algorithm class
+ pass # end of HYBRID_Algorithm class
//
//=============================================================================
-// File : GHS3DPlugin_Defs.hxx
+// File : HYBRIDPlugin_Defs.hxx
// Author : Alexander A. BORODIN
//
-#ifndef _GHS3DPlugin_DEFS_HXX_
-#define _GHS3DPlugin_DEFS_HXX_
+#ifndef _HYBRIDPlugin_DEFS_HXX_
+#define _HYBRIDPlugin_DEFS_HXX_
#ifdef WIN32
- #if defined GHS3DPLUGIN_EXPORTS || defined GHS3DEngine_EXPORTS
- #define GHS3DPLUGIN_EXPORT __declspec( dllexport )
+ #if defined HYBRIDPLUGIN_EXPORTS || defined HYBRIDEngine_EXPORTS
+ #define HYBRIDPLUGIN_EXPORT __declspec( dllexport )
#else
- #define GHS3DPLUGIN_EXPORT __declspec( dllimport )
+ #define HYBRIDPLUGIN_EXPORT __declspec( dllimport )
#endif
#else
- #define GHS3DPLUGIN_EXPORT
+ #define HYBRIDPLUGIN_EXPORT
#endif
#endif
//
//=============================================================================
-// File : GHS3DPlugin_GHS3D.cxx
+// File : HYBRIDPlugin_HYBRID.cxx
// Created :
// Author : Edward AGAPOV, modified by Lioka RAZAFINDRAZAKA (CEA) 09/02/2007
// Project : SALOME
//=============================================================================
//
-#include "GHS3DPlugin_GHS3D.hxx"
-#include "GHS3DPlugin_Hypothesis.hxx"
+#include "HYBRIDPlugin_HYBRID.hxx"
+#include "HYBRIDPlugin_Hypothesis.hxx"
#include <SMDS_FaceOfNodes.hxx>
#include <SMDS_MeshElement.hxx>
*/
//=============================================================================
-GHS3DPlugin_GHS3D::GHS3DPlugin_GHS3D(int hypId, int studyId, SMESH_Gen* gen)
+HYBRIDPlugin_HYBRID::HYBRIDPlugin_HYBRID(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_3D_Algo(hypId, studyId, gen)
{
- MESSAGE("GHS3DPlugin_GHS3D::GHS3DPlugin_GHS3D");
+ MESSAGE("HYBRIDPlugin_HYBRID::HYBRIDPlugin_HYBRID");
_name = Name();
_shapeType = (1 << TopAbs_SHELL) | (1 << TopAbs_SOLID);// 1 bit /shape type
_onlyUnaryInput = false; // Compute() will be called on a compound of solids
_iShape=0;
_nbShape=0;
- _compatibleHypothesis.push_back( GHS3DPlugin_Hypothesis::GetHypType());
+ _compatibleHypothesis.push_back( HYBRIDPlugin_Hypothesis::GetHypType());
_compatibleHypothesis.push_back( StdMeshers_ViscousLayers::GetHypType() );
_requireShape = false; // can work without shape_studyId
*/
//=============================================================================
-GHS3DPlugin_GHS3D::~GHS3DPlugin_GHS3D()
+HYBRIDPlugin_HYBRID::~HYBRIDPlugin_HYBRID()
{
- MESSAGE("GHS3DPlugin_GHS3D::~GHS3DPlugin_GHS3D");
+ MESSAGE("HYBRIDPlugin_HYBRID::~HYBRIDPlugin_HYBRID");
}
//=============================================================================
*/
//=============================================================================
-bool GHS3DPlugin_GHS3D::CheckHypothesis ( SMESH_Mesh& aMesh,
+bool HYBRIDPlugin_HYBRID::CheckHypothesis ( SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
Hypothesis_Status& aStatus )
{
for ( ; h != hyps.end(); ++h )
{
if ( !_hyp )
- _hyp = dynamic_cast< const GHS3DPlugin_Hypothesis*> ( *h );
+ _hyp = dynamic_cast< const HYBRIDPlugin_Hypothesis*> ( *h );
if ( !_viscousLayersHyp )
_viscousLayersHyp = dynamic_cast< const StdMeshers_ViscousLayers*> ( *h );
}
//purpose :
//=======================================================================
-TopoDS_Shape GHS3DPlugin_GHS3D::entryToShape(std::string entry)
+TopoDS_Shape HYBRIDPlugin_HYBRID::entryToShape(std::string entry)
{
- MESSAGE("GHS3DPlugin_GHS3D::entryToShape "<<entry );
+ MESSAGE("HYBRIDPlugin_HYBRID::entryToShape "<<entry );
GEOM::GEOM_Object_var aGeomObj;
TopoDS_Shape S = TopoDS_Shape();
SALOMEDS::SObject_var aSObj = myStudy->FindObjectID( entry.c_str() );
//=======================================================================
//function : findShapeID
-//purpose : find the solid corresponding to GHS3D sub-domain following
-// the technique proposed in GHS3D manual (available within
-// ghs3d installation) in chapter "B.4 Subdomain (sub-region) assignment".
+//purpose : find the solid corresponding to HYBRID sub-domain following
+// the technique proposed in HYBRID manual (available within
+// hybrid installation) in chapter "B.4 Subdomain (sub-region) assignment".
// In brief: normal of the triangle defined by the given nodes
// points out of the domain it is associated to
//=======================================================================
// const int nbShape,
// const TopoDS_Shape* tabShape,
// double** tabBox,
-// map <int,const SMDS_MeshNode*>& theGhs3dIdToNodeMap,
+// map <int,const SMDS_MeshNode*>& theHybridIdToNodeMap,
// bool toMeshHoles,
// int nbEnforcedVertices,
// int nbEnforcedNodes)
// for (int i=0; i < nbTriangle; i++) {
// tabID[i] = 0;
// int nodeId1, nodeId2, nodeId3;
-// // find the solid corresponding to GHS3D sub-domain following
-// // the technique proposed in GHS3D manual in chapter
+// // find the solid corresponding to HYBRID sub-domain following
+// // the technique proposed in HYBRID manual in chapter
// // "B.4 Subdomain (sub-region) assignment"
//
// nodeId1 = strtol(ptr, &ptr, 10);
//
// if ( nbTriangle > 1 ) {
// // get the nodes indices
-// const SMDS_MeshNode* n1 = theGhs3dIdToNodeMap[ nodeId1 ];
-// const SMDS_MeshNode* n2 = theGhs3dIdToNodeMap[ nodeId2 ];
-// const SMDS_MeshNode* n3 = theGhs3dIdToNodeMap[ nodeId3 ];
+// const SMDS_MeshNode* n1 = theHybridIdToNodeMap[ nodeId1 ];
+// const SMDS_MeshNode* n2 = theHybridIdToNodeMap[ nodeId2 ];
+// const SMDS_MeshNode* n3 = theHybridIdToNodeMap[ nodeId3 ];
// try {
// OCC_CATCH_SIGNALS;
// tabID[i] = findShapeID( theMesh, n1, n2, n3, toMeshHoles );
-// // -- 0020330: Pb with ghs3d as a submesh
+// // -- 0020330: Pb with hybrid as a submesh
// // check that found shape is to be meshed
// if ( tabID[i] > 0 ) {
// const TopoDS_Shape& foundShape = theMeshDS->IndexToShape( tabID[i] );
// if ( !isToBeMeshed )
// tabID[i] = HOLE_ID;
// }
-// // END -- 0020330: Pb with ghs3d as a submesh
+// // END -- 0020330: Pb with hybrid as a submesh
// #ifdef _DEBUG_
// std::cout << i+1 << " subdomain: findShapeID() returns " << tabID[i] << std::endl;
// #endif
// continue;
//
// int id[nbElem*tabRef[token]];
-// int ghs3dShapeID[nbElem];
+// int hybridShapeID[nbElem];
//
// if (token == GmfVertices) {
// std::cout << " vertices" << std::endl;
// for ( int iElem = 0; iElem < nbElem; iElem++ ) {
// aGMFID = iElem + 1;
// if (ver == GmfFloat) {
-// GmfGetLin(InpMsh, token, &VerTab_f[nbElem][0], &VerTab_f[nbElem][1], &VerTab_f[nbElem][2], &ghs3dShapeID[iElem]);
+// GmfGetLin(InpMsh, token, &VerTab_f[nbElem][0], &VerTab_f[nbElem][1], &VerTab_f[nbElem][2], &hybridShapeID[iElem]);
// aGMFNode = theMeshDS->AddNode(VerTab_f[nbElem][0], VerTab_f[nbElem][1], VerTab_f[nbElem][2]);
// }
// else {
-// GmfGetLin(InpMsh, token, &VerTab_d[nbElem][0], &VerTab_d[nbElem][1], &VerTab_d[nbElem][2], &ghs3dShapeID[iElem]);
+// GmfGetLin(InpMsh, token, &VerTab_d[nbElem][0], &VerTab_d[nbElem][1], &VerTab_d[nbElem][2], &hybridShapeID[iElem]);
// aGMFNode = theMeshDS->AddNode(VerTab_d[nbElem][0], VerTab_d[nbElem][1], VerTab_d[nbElem][2]);
// }
// GMFNode[ aGMFID ] = aGMFNode;
// else if (token == GmfEdges && nbElem > 0) {
// std::cout << " edges" << std::endl;
// for ( int iElem = 0; iElem < nbElem; iElem++ )
-// GmfGetLin(InpMsh, token, &id[iElem*tabRef[token]], &id[iElem*tabRef[token]+1], &ghs3dShapeID[iElem]);
+// GmfGetLin(InpMsh, token, &id[iElem*tabRef[token]], &id[iElem*tabRef[token]+1], &hybridShapeID[iElem]);
// }
// else if (token == GmfTriangles && nbElem > 0) {
// std::cout << " triangles" << std::endl;
// for ( int iElem = 0; iElem < nbElem; iElem++ )
-// GmfGetLin(InpMsh, token, &id[iElem*tabRef[token]], &id[iElem*tabRef[token]+1], &id[iElem*tabRef[token]+2], &ghs3dShapeID[iElem]);
+// GmfGetLin(InpMsh, token, &id[iElem*tabRef[token]], &id[iElem*tabRef[token]+1], &id[iElem*tabRef[token]+2], &hybridShapeID[iElem]);
// }
// // else if (token == GmfQuadrilaterals && nbElem > 0) {
// // std::cout << " Quadrilaterals" << std::endl;
// // for ( int iElem = 0; iElem < nbElem; iElem++ )
-// // GmfGetLin(InpMsh, token, &id[iElem*tabRef[token]], &id[iElem*tabRef[token]+1], &id[iElem*tabRef[token]+2], &id[iElem*tabRef[token]+3], &ghs3dShapeID[iElem]);
+// // GmfGetLin(InpMsh, token, &id[iElem*tabRef[token]], &id[iElem*tabRef[token]+1], &id[iElem*tabRef[token]+2], &id[iElem*tabRef[token]+3], &hybridShapeID[iElem]);
// // }
// else if (token == GmfTetrahedra && nbElem > 0) {
// std::cout << " Tetrahedra" << std::endl;
// &id[iElem*tabRef[token]+1],
// &id[iElem*tabRef[token]+2],
// &id[iElem*tabRef[token]+3],
-// &ghs3dShapeID[iElem]);
+// &hybridShapeID[iElem]);
// }
// // else if (token == GmfHexahedra && nbElem > 0) {
// // std::cout << " Hexahedra" << std::endl;
// // for ( int iElem = 0; iElem < nbElem; iElem++ )
// // GmfGetLin(InpMsh, token, &id[iElem*tabRef[token]], &id[iElem*tabRef[token]+1], &id[iElem*tabRef[token]+2], &id[iElem*tabRef[token]+3],
-// // &id[iElem*tabRef[token]+4], &id[iElem*tabRef[token]+5], &id[iElem*tabRef[token]+6], &id[iElem*tabRef[token]+7], &ghs3dShapeID[iElem]);
+// // &id[iElem*tabRef[token]+4], &id[iElem*tabRef[token]+5], &id[iElem*tabRef[token]+6], &id[iElem*tabRef[token]+7], &hybridShapeID[iElem]);
// // }
//
// switch (token) {
//
// // IN WORK
// TopoDS_Shape aSolid;
-// // We always run GHS3D with "to mesh holes"==TRUE but we must not create
+// // We always run HYBRID with "to mesh holes"==TRUE but we must not create
// // tetras within holes depending on hypo option,
// // so we first check if aTet is inside a hole and then create it
// if ( nbTriangle > 1 ) {
// tetraShapeID = HOLE_ID; // negative tetraShapeID means not to create tetras if !toMeshHoles
-// int aGhs3dShapeID = ghs3dShapeID[iElem] - IdShapeRef;
-// if ( tabID[ aGhs3dShapeID ] == 0 ) {
+// int aHybridShapeID = hybridShapeID[iElem] - IdShapeRef;
+// if ( tabID[ aHybridShapeID ] == 0 ) {
// TopAbs_State state;
// aSolid = findShape(node, aSolid, tabShape, tabBox, nbShape, &state);
// if ( toMeshHoles || state == TopAbs_IN )
// tetraShapeID = theMeshDS->ShapeToIndex( aSolid );
-// tabID[ aGhs3dShapeID ] = tetraShapeID;
+// tabID[ aHybridShapeID ] = tetraShapeID;
// }
// else
-// tetraShapeID = tabID[ aGhs3dShapeID ];
+// tetraShapeID = tabID[ aHybridShapeID ];
// }
// else if ( nbShape > 1 ) {
// // Case where nbTriangle == 1 while nbShape == 2 encountered
// } // for
//
// if ( !toMeshHoles ) {
-// map <int,const SMDS_MeshNode*>::iterator itOnNode = theGhs3dIdToNodeMap.find( nbVertices-(nbEnforcedVertices+nbEnforcedNodes) );
-// for ( ; itOnNode != theGhs3dIdToNodeMap.end(); ++itOnNode) {
+// map <int,const SMDS_MeshNode*>::iterator itOnNode = theHybridIdToNodeMap.find( nbVertices-(nbEnforcedVertices+nbEnforcedNodes) );
+// for ( ; itOnNode != theHybridIdToNodeMap.end(); ++itOnNode) {
// if ( nodeAssigne[ itOnNode->first ] == HOLE_ID )
// theMeshDS->RemoveFreeNode( itOnNode->second, 0 );
// }
//=======================================================================
static bool readGMFFile(const char* theFile,
- GHS3DPlugin_GHS3D* theAlgo,
+ HYBRIDPlugin_HYBRID* theAlgo,
SMESH_MesherHelper* theHelper,
- std::vector <const SMDS_MeshNode*> & theNodeByGhs3dId,
- std::vector <const SMDS_MeshElement*> & theFaceByGhs3dId,
- map<const SMDS_MeshNode*,int> & theNodeToGhs3dIdMap,
- std::vector<std::string> & aNodeGroupByGhs3dId,
- std::vector<std::string> & anEdgeGroupByGhs3dId,
- std::vector<std::string> & aFaceGroupByGhs3dId,
+ std::vector <const SMDS_MeshNode*> & theNodeByHybridId,
+ std::vector <const SMDS_MeshElement*> & theFaceByHybridId,
+ map<const SMDS_MeshNode*,int> & theNodeToHybridIdMap,
+ std::vector<std::string> & aNodeGroupByHybridId,
+ std::vector<std::string> & anEdgeGroupByHybridId,
+ std::vector<std::string> & aFaceGroupByHybridId,
std::set<std::string> & groupsToRemove,
bool toMakeGroupsOfDomains=false,
bool toMeshHoles=true)
SMESHDS_Mesh* theMeshDS = theHelper->GetMeshDS();
const bool hasGeom = ( theHelper->GetMesh()->HasShapeToMesh() );
- int nbInitialNodes = theNodeByGhs3dId.size();
+ int nbInitialNodes = theNodeByHybridId.size();
int nbMeshNodes = theMeshDS->NbNodes();
const bool isQuadMesh =
theHelper->GetMesh()->NbVolumes( ORDER_QUADRATIC );
#ifdef _DEBUG_
- std::cout << "theNodeByGhs3dId.size(): " << nbInitialNodes << std::endl;
+ std::cout << "theNodeByHybridId.size(): " << nbInitialNodes << std::endl;
std::cout << "theHelper->GetMesh()->NbNodes(): " << nbMeshNodes << std::endl;
std::cout << "isQuadMesh: " << isQuadMesh << std::endl;
#endif
GmfGetLin( InpMsh, GmfSubDomainFromGeom,
&faceNbNodes, &faceIndex, &orientation, &domainNb);
solidIDByDomain[ domainNb ] = 1;
- if ( 0 < faceIndex && faceIndex-1 < theFaceByGhs3dId.size() )
+ if ( 0 < faceIndex && faceIndex-1 < theFaceByHybridId.size() )
{
- const SMDS_MeshElement* face = theFaceByGhs3dId[ faceIndex-1 ];
+ const SMDS_MeshElement* face = theFaceByHybridId[ faceIndex-1 ];
const SMDS_MeshNode* nn[3] = { face->GetNode(0),
face->GetNode(1),
face->GetNode(2) };
// while ( nodeIt->more() )
// {
// node = nodeIt->next();
-// if (theNodeToGhs3dIdMap.find(node) != theNodeToGhs3dIdMap.end())
+// if (theNodeToHybridIdMap.find(node) != theNodeToHybridIdMap.end())
// theMeshDS->RemoveNode(node);
// }
// }
aGMFID = iElem -nbInitialNodes +1;
GMFNode[ aGMFID ] = aGMFNode;
- if (aGMFID-1 < aNodeGroupByGhs3dId.size() && !aNodeGroupByGhs3dId.at(aGMFID-1).empty())
- addElemInMeshGroup(theHelper->GetMesh(), aGMFNode, aNodeGroupByGhs3dId.at(aGMFID-1), groupsToRemove);
+ if (aGMFID-1 < aNodeGroupByHybridId.size() && !aNodeGroupByHybridId.at(aGMFID-1).empty())
+ addElemInMeshGroup(theHelper->GetMesh(), aGMFNode, aNodeGroupByHybridId.at(aGMFID-1), groupsToRemove);
}
}
}
if (aGMFNodeID <= nbInitialNodes) // input nodes
{
aGMFNodeID--;
- node[ iRef ] = theNodeByGhs3dId[aGMFNodeID];
+ node[ iRef ] = theNodeByHybridId[aGMFNodeID];
}
else
{
case GmfEdges:
if (fullyCreatedElement) {
aCreatedElem = theHelper->AddEdge( node[0], node[1], noID, force3d );
- if (anEdgeGroupByGhs3dId.size() && !anEdgeGroupByGhs3dId[iElem].empty())
- addElemInMeshGroup(theHelper->GetMesh(), aCreatedElem, anEdgeGroupByGhs3dId[iElem], groupsToRemove);
+ if (anEdgeGroupByHybridId.size() && !anEdgeGroupByHybridId[iElem].empty())
+ addElemInMeshGroup(theHelper->GetMesh(), aCreatedElem, anEdgeGroupByHybridId[iElem], groupsToRemove);
}
break;
case GmfTriangles:
if (fullyCreatedElement) {
aCreatedElem = theHelper->AddFace( node[0], node[1], node[2], noID, force3d );
- if (aFaceGroupByGhs3dId.size() && !aFaceGroupByGhs3dId[iElem].empty())
- addElemInMeshGroup(theHelper->GetMesh(), aCreatedElem, aFaceGroupByGhs3dId[iElem], groupsToRemove);
+ if (aFaceGroupByHybridId.size() && !aFaceGroupByHybridId[iElem].empty())
+ addElemInMeshGroup(theHelper->GetMesh(), aCreatedElem, aFaceGroupByHybridId[iElem], groupsToRemove);
}
break;
case GmfQuadrilaterals:
const char* theSolFileName,
const SMESH_ProxyMesh& theProxyMesh,
SMESH_MesherHelper& theHelper,
- std::vector <const SMDS_MeshNode*> & theNodeByGhs3dId,
- std::vector <const SMDS_MeshElement*> & theFaceByGhs3dId,
- std::map<const SMDS_MeshNode*,int> & aNodeToGhs3dIdMap,
- std::vector<std::string> & aNodeGroupByGhs3dId,
- std::vector<std::string> & anEdgeGroupByGhs3dId,
- std::vector<std::string> & aFaceGroupByGhs3dId,
- GHS3DPlugin_Hypothesis::TIDSortedNodeGroupMap & theEnforcedNodes,
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedEdges,
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedTriangles,
+ std::vector <const SMDS_MeshNode*> & theNodeByHybridId,
+ std::vector <const SMDS_MeshElement*> & theFaceByHybridId,
+ std::map<const SMDS_MeshNode*,int> & aNodeToHybridIdMap,
+ std::vector<std::string> & aNodeGroupByHybridId,
+ std::vector<std::string> & anEdgeGroupByHybridId,
+ std::vector<std::string> & aFaceGroupByHybridId,
+ HYBRIDPlugin_Hypothesis::TIDSortedNodeGroupMap & theEnforcedNodes,
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedEdges,
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedTriangles,
std::map<std::vector<double>, std::string> & enfVerticesWithGroup,
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexCoordsValues & theEnforcedVertices)
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexCoordsValues & theEnforcedVertices)
{
MESSAGE("writeGMFFile w/o geometry");
std::string tmpStr;
int idx, idxRequired = 0, idxSol = 0;
const int dummyint = 0;
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexCoordsValues::const_iterator vertexIt;
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexCoordsValues::const_iterator vertexIt;
std::vector<double> enfVertexSizes;
const SMDS_MeshElement* elem;
TIDSortedElemSet anElemSet, theKeptEnforcedEdges, theKeptEnforcedTriangles;
SMDS_ElemIteratorPtr nodeIt;
- std::vector <const SMDS_MeshNode*> theEnforcedNodeByGhs3dId;
- map<const SMDS_MeshNode*,int> anEnforcedNodeToGhs3dIdMap, anExistingEnforcedNodeToGhs3dIdMap;
+ std::vector <const SMDS_MeshNode*> theEnforcedNodeByHybridId;
+ map<const SMDS_MeshNode*,int> anEnforcedNodeToHybridIdMap, anExistingEnforcedNodeToHybridIdMap;
std::vector< const SMDS_MeshElement* > foundElems;
map<const SMDS_MeshNode*,TopAbs_State> aNodeToTopAbs_StateMap;
int nbFoundElems;
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap::iterator elemIt;
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap::iterator elemIt;
TIDSortedElemSet::iterator elemSetIt;
bool isOK;
SMESH_Mesh* theMesh = theHelper.GetMesh();
// count faces
int nbFaces = theProxyMesh.NbFaces();
int nbNodes;
- theFaceByGhs3dId.reserve( nbFaces );
+ theFaceByHybridId.reserve( nbFaces );
// groups management
int usedEnforcedNodes = 0;
nbNodes = elem->NbCornerNodes();
while ( nodeIt->more() && nbNodes--)
{
- // find GHS3D ID
+ // find HYBRID ID
const SMDS_MeshNode* node = castToNode( nodeIt->next() );
- int newId = aNodeToGhs3dIdMap.size() + 1; // ghs3d ids count from 1
- aNodeToGhs3dIdMap.insert( make_pair( node, newId ));
+ int newId = aNodeToHybridIdMap.size() + 1; // hybrid ids count from 1
+ aNodeToHybridIdMap.insert( make_pair( node, newId ));
}
}
nodeIt = elem->nodesIterator();
nbNodes = 2;
while ( nodeIt->more() && nbNodes-- ) {
- // find GHS3D ID
+ // find HYBRID ID
const SMDS_MeshNode* node = castToNode( nodeIt->next() );
// Test if point is inside shape to mesh
gp_Pnt myPoint(node->X(),node->Y(),node->Z());
nbNodes = 2;
int newId = -1;
while ( nodeIt->more() && nbNodes-- ) {
- // find GHS3D ID
+ // find HYBRID ID
const SMDS_MeshNode* node = castToNode( nodeIt->next() );
gp_Pnt myPoint(node->X(),node->Y(),node->Z());
nbFoundElems = pntCls->FindElementsByPoint(myPoint, SMDSAbs_Node, foundElems);
#endif
if (nbFoundElems ==0) {
if ((*aNodeToTopAbs_StateMap.find(node)).second == TopAbs_IN) {
- newId = aNodeToGhs3dIdMap.size() + anEnforcedNodeToGhs3dIdMap.size() + 1; // ghs3d ids count from 1
- anEnforcedNodeToGhs3dIdMap.insert( make_pair( node, newId ));
+ newId = aNodeToHybridIdMap.size() + anEnforcedNodeToHybridIdMap.size() + 1; // hybrid ids count from 1
+ anEnforcedNodeToHybridIdMap.insert( make_pair( node, newId ));
}
}
else if (nbFoundElems ==1) {
const SMDS_MeshNode* existingNode = (SMDS_MeshNode*) foundElems.at(0);
- newId = (*aNodeToGhs3dIdMap.find(existingNode)).second;
- anExistingEnforcedNodeToGhs3dIdMap.insert( make_pair( node, newId ));
+ newId = (*aNodeToHybridIdMap.find(existingNode)).second;
+ anExistingEnforcedNodeToHybridIdMap.insert( make_pair( node, newId ));
}
else
isOK = false;
#ifdef _DEBUG_
- std::cout << "GHS3D node ID: "<<newId<<std::endl;
+ std::cout << "HYBRID node ID: "<<newId<<std::endl;
#endif
}
if (isOK)
nodeIt = elem->nodesIterator();
nbNodes = 3;
while ( nodeIt->more() && nbNodes--) {
- // find GHS3D ID
+ // find HYBRID ID
const SMDS_MeshNode* node = castToNode( nodeIt->next() );
// Test if point is inside shape to mesh
gp_Pnt myPoint(node->X(),node->Y(),node->Z());
nbNodes = 3;
int newId = -1;
while ( nodeIt->more() && nbNodes--) {
- // find GHS3D ID
+ // find HYBRID ID
const SMDS_MeshNode* node = castToNode( nodeIt->next() );
gp_Pnt myPoint(node->X(),node->Y(),node->Z());
nbFoundElems = pntCls->FindElementsByPoint(myPoint, SMDSAbs_Node, foundElems);
#endif
if (nbFoundElems ==0) {
if ((*aNodeToTopAbs_StateMap.find(node)).second == TopAbs_IN) {
- newId = aNodeToGhs3dIdMap.size() + anEnforcedNodeToGhs3dIdMap.size() + 1; // ghs3d ids count from 1
- anEnforcedNodeToGhs3dIdMap.insert( make_pair( node, newId ));
+ newId = aNodeToHybridIdMap.size() + anEnforcedNodeToHybridIdMap.size() + 1; // hybrid ids count from 1
+ anEnforcedNodeToHybridIdMap.insert( make_pair( node, newId ));
}
}
else if (nbFoundElems ==1) {
const SMDS_MeshNode* existingNode = (SMDS_MeshNode*) foundElems.at(0);
- newId = (*aNodeToGhs3dIdMap.find(existingNode)).second;
- anExistingEnforcedNodeToGhs3dIdMap.insert( make_pair( node, newId ));
+ newId = (*aNodeToHybridIdMap.find(existingNode)).second;
+ anExistingEnforcedNodeToHybridIdMap.insert( make_pair( node, newId ));
}
else
isOK = false;
#ifdef _DEBUG_
- std::cout << "GHS3D node ID: "<<newId<<std::endl;
+ std::cout << "HYBRID node ID: "<<newId<<std::endl;
#endif
}
if (isOK)
}
}
- // put nodes to theNodeByGhs3dId vector
+ // put nodes to theNodeByHybridId vector
#ifdef _DEBUG_
- std::cout << "aNodeToGhs3dIdMap.size(): "<<aNodeToGhs3dIdMap.size()<<std::endl;
+ std::cout << "aNodeToHybridIdMap.size(): "<<aNodeToHybridIdMap.size()<<std::endl;
#endif
- theNodeByGhs3dId.resize( aNodeToGhs3dIdMap.size() );
- map<const SMDS_MeshNode*,int>::const_iterator n2id = aNodeToGhs3dIdMap.begin();
- for ( ; n2id != aNodeToGhs3dIdMap.end(); ++ n2id)
+ theNodeByHybridId.resize( aNodeToHybridIdMap.size() );
+ map<const SMDS_MeshNode*,int>::const_iterator n2id = aNodeToHybridIdMap.begin();
+ for ( ; n2id != aNodeToHybridIdMap.end(); ++ n2id)
{
// std::cout << "n2id->first: "<<n2id->first<<std::endl;
- theNodeByGhs3dId[ n2id->second - 1 ] = n2id->first; // ghs3d ids count from 1
+ theNodeByHybridId[ n2id->second - 1 ] = n2id->first; // hybrid ids count from 1
}
- // put nodes to anEnforcedNodeToGhs3dIdMap vector
+ // put nodes to anEnforcedNodeToHybridIdMap vector
#ifdef _DEBUG_
- std::cout << "anEnforcedNodeToGhs3dIdMap.size(): "<<anEnforcedNodeToGhs3dIdMap.size()<<std::endl;
+ std::cout << "anEnforcedNodeToHybridIdMap.size(): "<<anEnforcedNodeToHybridIdMap.size()<<std::endl;
#endif
- theEnforcedNodeByGhs3dId.resize( anEnforcedNodeToGhs3dIdMap.size());
- n2id = anEnforcedNodeToGhs3dIdMap.begin();
- for ( ; n2id != anEnforcedNodeToGhs3dIdMap.end(); ++ n2id)
+ theEnforcedNodeByHybridId.resize( anEnforcedNodeToHybridIdMap.size());
+ n2id = anEnforcedNodeToHybridIdMap.begin();
+ for ( ; n2id != anEnforcedNodeToHybridIdMap.end(); ++ n2id)
{
- if (n2id->second > aNodeToGhs3dIdMap.size()) {
- theEnforcedNodeByGhs3dId[ n2id->second - aNodeToGhs3dIdMap.size() - 1 ] = n2id->first; // ghs3d ids count from 1
+ if (n2id->second > aNodeToHybridIdMap.size()) {
+ theEnforcedNodeByHybridId[ n2id->second - aNodeToHybridIdMap.size() - 1 ] = n2id->first; // hybrid ids count from 1
}
}
/* ========================== NODES ========================== */
vector<const SMDS_MeshNode*> theOrderedNodes, theRequiredNodes;
std::set< std::vector<double> > nodesCoords;
- vector<const SMDS_MeshNode*>::const_iterator ghs3dNodeIt = theNodeByGhs3dId.begin();
- vector<const SMDS_MeshNode*>::const_iterator after = theNodeByGhs3dId.end();
+ vector<const SMDS_MeshNode*>::const_iterator hybridNodeIt = theNodeByHybridId.begin();
+ vector<const SMDS_MeshNode*>::const_iterator after = theNodeByHybridId.end();
- (theNodeByGhs3dId.size() <= 1) ? tmpStr = " node" : " nodes";
- std::cout << theNodeByGhs3dId.size() << tmpStr << " from mesh ..." << std::endl;
- for ( ; ghs3dNodeIt != after; ++ghs3dNodeIt )
+ (theNodeByHybridId.size() <= 1) ? tmpStr = " node" : " nodes";
+ std::cout << theNodeByHybridId.size() << tmpStr << " from mesh ..." << std::endl;
+ for ( ; hybridNodeIt != after; ++hybridNodeIt )
{
- const SMDS_MeshNode* node = *ghs3dNodeIt;
+ const SMDS_MeshNode* node = *hybridNodeIt;
std::vector<double> coords;
coords.push_back(node->X());
coords.push_back(node->Y());
}
// Iterate over the enforced nodes given by enforced elements
- ghs3dNodeIt = theEnforcedNodeByGhs3dId.begin();
- after = theEnforcedNodeByGhs3dId.end();
- (theEnforcedNodeByGhs3dId.size() <= 1) ? tmpStr = " node" : " nodes";
- std::cout << theEnforcedNodeByGhs3dId.size() << tmpStr << " from enforced elements ..." << std::endl;
- for ( ; ghs3dNodeIt != after; ++ghs3dNodeIt )
+ hybridNodeIt = theEnforcedNodeByHybridId.begin();
+ after = theEnforcedNodeByHybridId.end();
+ (theEnforcedNodeByHybridId.size() <= 1) ? tmpStr = " node" : " nodes";
+ std::cout << theEnforcedNodeByHybridId.size() << tmpStr << " from enforced elements ..." << std::endl;
+ for ( ; hybridNodeIt != after; ++hybridNodeIt )
{
- const SMDS_MeshNode* node = *ghs3dNodeIt;
+ const SMDS_MeshNode* node = *hybridNodeIt;
std::vector<double> coords;
coords.push_back(node->X());
coords.push_back(node->Y());
// Iterate over the enforced nodes
- GHS3DPlugin_Hypothesis::TIDSortedNodeGroupMap::const_iterator enfNodeIt;
+ HYBRIDPlugin_Hypothesis::TIDSortedNodeGroupMap::const_iterator enfNodeIt;
(theEnforcedNodes.size() <= 1) ? tmpStr = " node" : " nodes";
std::cout << theEnforcedNodes.size() << tmpStr << " from enforced nodes ..." << std::endl;
for(enfNodeIt = theEnforcedNodes.begin() ; enfNodeIt != theEnforcedNodes.end() ; ++enfNodeIt)
std::cout << "Begin writting required nodes in GmfVertices" << std::endl;
std::cout << "Nb vertices: " << theOrderedNodes.size() << std::endl;
GmfSetKwd(idx, GmfVertices, theOrderedNodes.size()/*+solSize*/);
- for (ghs3dNodeIt = theOrderedNodes.begin();ghs3dNodeIt != theOrderedNodes.end();++ghs3dNodeIt) {
- GmfSetLin(idx, GmfVertices, (*ghs3dNodeIt)->X(), (*ghs3dNodeIt)->Y(), (*ghs3dNodeIt)->Z(), dummyint);
+ for (hybridNodeIt = theOrderedNodes.begin();hybridNodeIt != theOrderedNodes.end();++hybridNodeIt) {
+ GmfSetLin(idx, GmfVertices, (*hybridNodeIt)->X(), (*hybridNodeIt)->Y(), (*hybridNodeIt)->Z(), dummyint);
}
std::cout << "End writting required nodes in GmfVertices" << std::endl;
if (requiredNodes + solSize) {
std::cout << "Begin writting in req and sol file" << std::endl;
- aNodeGroupByGhs3dId.resize( requiredNodes + solSize );
+ aNodeGroupByHybridId.resize( requiredNodes + solSize );
idxRequired = GmfOpenMesh(theRequiredFileName, GmfWrite, GMFVERSION, GMFDIMENSION);
if (!idxRequired) {
GmfCloseMesh(idx);
GmfSetKwd(idxSol, GmfSolAtVertices, requiredNodes + solSize, 1, TypTab);
// int usedEnforcedNodes = 0;
// std::string gn = "";
- for (ghs3dNodeIt = theRequiredNodes.begin();ghs3dNodeIt != theRequiredNodes.end();++ghs3dNodeIt) {
- GmfSetLin(idxRequired, GmfVertices, (*ghs3dNodeIt)->X(), (*ghs3dNodeIt)->Y(), (*ghs3dNodeIt)->Z(), dummyint);
+ for (hybridNodeIt = theRequiredNodes.begin();hybridNodeIt != theRequiredNodes.end();++hybridNodeIt) {
+ GmfSetLin(idxRequired, GmfVertices, (*hybridNodeIt)->X(), (*hybridNodeIt)->Y(), (*hybridNodeIt)->Z(), dummyint);
GmfSetLin(idxSol, GmfSolAtVertices, ValTab);
- if (theEnforcedNodes.find((*ghs3dNodeIt)) != theEnforcedNodes.end())
- gn = theEnforcedNodes.find((*ghs3dNodeIt))->second;
- aNodeGroupByGhs3dId[usedEnforcedNodes] = gn;
+ if (theEnforcedNodes.find((*hybridNodeIt)) != theEnforcedNodes.end())
+ gn = theEnforcedNodes.find((*hybridNodeIt))->second;
+ aNodeGroupByHybridId[usedEnforcedNodes] = gn;
usedEnforcedNodes++;
}
double solTab[] = {enfVertexSizes.at(i)};
GmfSetLin(idxRequired, GmfVertices, ReqVerTab[i][0], ReqVerTab[i][1], ReqVerTab[i][2], dummyint);
GmfSetLin(idxSol, GmfSolAtVertices, solTab);
- aNodeGroupByGhs3dId[usedEnforcedNodes] = enfVerticesWithGroup.find(ReqVerTab[i])->second;
+ aNodeGroupByHybridId[usedEnforcedNodes] = enfVerticesWithGroup.find(ReqVerTab[i])->second;
#ifdef _DEBUG_
- std::cout << "aNodeGroupByGhs3dId["<<usedEnforcedNodes<<"] = \""<<aNodeGroupByGhs3dId[usedEnforcedNodes]<<"\""<<std::endl;
+ std::cout << "aNodeGroupByHybridId["<<usedEnforcedNodes<<"] = \""<<aNodeGroupByHybridId[usedEnforcedNodes]<<"\""<<std::endl;
#endif
usedEnforcedNodes++;
}
// GmfEdges
int usedEnforcedEdges = 0;
if (theKeptEnforcedEdges.size()) {
- anEdgeGroupByGhs3dId.resize( theKeptEnforcedEdges.size() );
+ anEdgeGroupByHybridId.resize( theKeptEnforcedEdges.size() );
// idxRequired = GmfOpenMesh(theRequiredFileName, GmfWrite, GMFVERSION, GMFDIMENSION);
// if (!idxRequired)
// return false;
nodeIt = elem->nodesIterator();
int index=0;
while ( nodeIt->more() ) {
- // find GHS3D ID
+ // find HYBRID ID
const SMDS_MeshNode* node = castToNode( nodeIt->next() );
- map< const SMDS_MeshNode*,int >::iterator it = anEnforcedNodeToGhs3dIdMap.find(node);
- if (it == anEnforcedNodeToGhs3dIdMap.end()) {
- it = anExistingEnforcedNodeToGhs3dIdMap.find(node);
- if (it == anEnforcedNodeToGhs3dIdMap.end())
+ map< const SMDS_MeshNode*,int >::iterator it = anEnforcedNodeToHybridIdMap.find(node);
+ if (it == anEnforcedNodeToHybridIdMap.end()) {
+ it = anExistingEnforcedNodeToHybridIdMap.find(node);
+ if (it == anEnforcedNodeToHybridIdMap.end())
throw "Node not found";
}
nedge[index] = it->second;
index++;
}
GmfSetLin(idx, GmfEdges, nedge[0], nedge[1], dummyint);
- anEdgeGroupByGhs3dId[usedEnforcedEdges] = theEnforcedEdges.find(elem)->second;
+ anEdgeGroupByHybridId[usedEnforcedEdges] = theEnforcedEdges.find(elem)->second;
// GmfSetLin(idxRequired, GmfEdges, nedge[0], nedge[1], dummyint);
usedEnforcedEdges++;
}
// GmfTriangles
int usedEnforcedTriangles = 0;
if (anElemSet.size()+theKeptEnforcedTriangles.size()) {
- aFaceGroupByGhs3dId.resize( anElemSet.size()+theKeptEnforcedTriangles.size() );
+ aFaceGroupByHybridId.resize( anElemSet.size()+theKeptEnforcedTriangles.size() );
GmfSetKwd(idx, GmfTriangles, anElemSet.size()+theKeptEnforcedTriangles.size());
int k=0;
for(elemSetIt = anElemSet.begin() ; elemSetIt != anElemSet.end() ; ++elemSetIt,++k) {
elem = (*elemSetIt);
- theFaceByGhs3dId.push_back( elem );
+ theFaceByHybridId.push_back( elem );
nodeIt = elem->nodesIterator();
int index=0;
for ( int j = 0; j < 3; ++j ) {
- // find GHS3D ID
+ // find HYBRID ID
const SMDS_MeshNode* node = castToNode( nodeIt->next() );
- map< const SMDS_MeshNode*,int >::iterator it = aNodeToGhs3dIdMap.find(node);
- if (it == aNodeToGhs3dIdMap.end())
+ map< const SMDS_MeshNode*,int >::iterator it = aNodeToHybridIdMap.find(node);
+ if (it == aNodeToHybridIdMap.end())
throw "Node not found";
ntri[index] = it->second;
index++;
}
GmfSetLin(idx, GmfTriangles, ntri[0], ntri[1], ntri[2], dummyint);
- aFaceGroupByGhs3dId[k] = "";
+ aFaceGroupByHybridId[k] = "";
}
if ( !theHelper.GetMesh()->HasShapeToMesh() )
- SMESHUtils::FreeVector( theFaceByGhs3dId );
+ SMESHUtils::FreeVector( theFaceByHybridId );
if (theKeptEnforcedTriangles.size()) {
for(elemSetIt = theKeptEnforcedTriangles.begin() ; elemSetIt != theKeptEnforcedTriangles.end() ; ++elemSetIt,++k) {
elem = (*elemSetIt);
nodeIt = elem->nodesIterator();
int index=0;
for ( int j = 0; j < 3; ++j ) {
- // find GHS3D ID
+ // find HYBRID ID
const SMDS_MeshNode* node = castToNode( nodeIt->next() );
- map< const SMDS_MeshNode*,int >::iterator it = anEnforcedNodeToGhs3dIdMap.find(node);
- if (it == anEnforcedNodeToGhs3dIdMap.end()) {
- it = anExistingEnforcedNodeToGhs3dIdMap.find(node);
- if (it == anEnforcedNodeToGhs3dIdMap.end())
+ map< const SMDS_MeshNode*,int >::iterator it = anEnforcedNodeToHybridIdMap.find(node);
+ if (it == anEnforcedNodeToHybridIdMap.end()) {
+ it = anExistingEnforcedNodeToHybridIdMap.find(node);
+ if (it == anEnforcedNodeToHybridIdMap.end())
throw "Node not found";
}
ntri[index] = it->second;
index++;
}
GmfSetLin(idx, GmfTriangles, ntri[0], ntri[1], ntri[2], dummyint);
- aFaceGroupByGhs3dId[k] = theEnforcedTriangles.find(elem)->second;
+ aFaceGroupByHybridId[k] = theEnforcedTriangles.find(elem)->second;
usedEnforcedTriangles++;
}
}
// SMESH_MesherHelper& theHelper,
// const SMESH_ProxyMesh& theProxyMesh,
// std::map <int,int> & theNodeId2NodeIndexMap,
-// std::map <int,int> & theSmdsToGhs3dIdMap,
-// std::map <int,const SMDS_MeshNode*> & theGhs3dIdToNodeMap,
+// std::map <int,int> & theSmdsToHybridIdMap,
+// std::map <int,const SMDS_MeshNode*> & theHybridIdToNodeMap,
// TIDSortedNodeSet & theEnforcedNodes,
// TIDSortedElemSet & theEnforcedEdges,
// TIDSortedElemSet & theEnforcedTriangles,
// // TIDSortedElemSet & theEnforcedQuadrangles,
-// GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexCoordsValues & theEnforcedVertices)
+// HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexCoordsValues & theEnforcedVertices)
// {
// MESSAGE("writeGMFFile with geometry");
// int idx, idxRequired, idxSol;
-// int nbv, nbev, nben, aGhs3dID = 0;
+// int nbv, nbev, nben, aHybridID = 0;
// const int dummyint = 0;
-// GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexCoordsValues::const_iterator vertexIt;
+// HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexCoordsValues::const_iterator vertexIt;
// std::vector<double> enfVertexSizes;
// TIDSortedNodeSet::const_iterator enfNodeIt;
// const SMDS_MeshNode* node;
// nbev = theEnforcedVertices.size();
// nben = theEnforcedNodes.size();
//
-// // Issue 020674: EDF 870 SMESH: Mesh generated by Netgen not usable by GHS3D
+// // Issue 020674: EDF 870 SMESH: Mesh generated by Netgen not usable by HYBRID
// // The problem is in nodes on degenerated edges, we need to skip nodes which are free
// // and replace not-free nodes on edges by the node on vertex
// TNodeNodeMap n2nDegen; // map a node on degenerated edge to a node on vertex
// coords.push_back(node->Y());
// coords.push_back(node->Z());
// if (VerMap.find(coords) != VerMap.end()) {
-// aGhs3dID = theSmdsToGhs3dIdMap[node->GetID()];
-// theGhs3dIdToNodeMap[theSmdsToGhs3dIdMap[node->GetID()]] = node;
+// aHybridID = theSmdsToHybridIdMap[node->GetID()];
+// theHybridIdToNodeMap[theSmdsToHybridIdMap[node->GetID()]] = node;
// continue;
// }
// VerTab.push_back(coords);
// VerMap.insert(coords);
-// aGhs3dID++;
-// theSmdsToGhs3dIdMap.insert( make_pair( node->GetID(), aGhs3dID ));
-// theGhs3dIdToNodeMap.insert( make_pair( aGhs3dID, node ));
+// aHybridID++;
+// theSmdsToHybridIdMap.insert( make_pair( node->GetID(), aHybridID ));
+// theHybridIdToNodeMap.insert( make_pair( aHybridID, node ));
// }
//
//
// continue;
// VerTab.push_back(coords);
// VerMap.insert(coords);
-// aGhs3dID++;
-// theNodeId2NodeIndexMap.insert( make_pair( (*enfNodeIt)->GetID(), aGhs3dID ));
+// aHybridID++;
+// theNodeId2NodeIndexMap.insert( make_pair( (*enfNodeIt)->GetID(), aHybridID ));
// }
// }
//
// itOnSubFace = aFace->nodesIterator();
// att.clear();
// for ( int j = 0; j < 3; ++j ) {
-// // find GHS3D ID
+// // find HYBRID ID
// node = castToNode( itOnSubFace->next() );
// if (( n2nDegenIt = n2nDegen.find( node )) != n2nDegen.end() )
// node = n2nDegenIt->second;
// aSmdsID = node->GetID();
-// itOnMap = theSmdsToGhs3dIdMap.find( aSmdsID );
-// ASSERT( itOnMap != theSmdsToGhs3dIdMap.end() );
+// itOnMap = theSmdsToHybridIdMap.find( aSmdsID );
+// ASSERT( itOnMap != theSmdsToHybridIdMap.end() );
// att.push_back((*itOnMap).second);
// }
// tt.push_back(att);
// }
// VerTab.push_back(coords);
// VerMap.insert(coords);
-// aGhs3dID++;
-// theNodeId2NodeIndexMap.insert( make_pair( node->GetID(), aGhs3dID ));
-// att.push_back(aGhs3dID);
+// aHybridID++;
+// theNodeId2NodeIndexMap.insert( make_pair( node->GetID(), aHybridID ));
+// att.push_back(aHybridID);
// }
// if (isOK)
// tt.push_back(att);
// VerTab.push_back(coords);
// VerMap.insert(coords);
//
-// aGhs3dID++;
-// theNodeId2NodeIndexMap.insert( make_pair( node->GetID(), aGhs3dID ));
-// aet.push_back(aGhs3dID);
+// aHybridID++;
+// theNodeId2NodeIndexMap.insert( make_pair( node->GetID(), aHybridID ));
+// aet.push_back(aHybridID);
// }
// if (isOK)
// et.push_back(aet);
//
//
// /* Write vertices number */
-// MESSAGE("Number of vertices: "<<aGhs3dID);
+// MESSAGE("Number of vertices: "<<aHybridID);
// MESSAGE("Size of vector: "<<VerTab.size());
-// GmfSetKwd(idx, GmfVertices, aGhs3dID/*+solSize*/);
-// for (int i=0;i<aGhs3dID;i++)
+// GmfSetKwd(idx, GmfVertices, aHybridID/*+solSize*/);
+// for (int i=0;i<aHybridID;i++)
// GmfSetLin(idx, GmfVertices, VerTab[i][0], VerTab[i][1], VerTab[i][2], dummyint);
// // for (int i=0;i<solSize;i++) {
// // std::cout << ReqVerTab[i][0] <<" "<< ReqVerTab[i][1] << " "<< ReqVerTab[i][2] << std::endl;
// // itOnSubFace = aFace->nodesIterator();
// // aqt.clear();
// // while ( itOnSubFace->more() ) {
-// // // find GHS3D ID
+// // // find HYBRID ID
// // aSmdsID = itOnSubFace->next()->GetID();
-// // itOnMap = theSmdsToGhs3dIdMap.find( aSmdsID );
-// // ASSERT( itOnMap != theSmdsToGhs3dIdMap.end() );
+// // itOnMap = theSmdsToHybridIdMap.find( aSmdsID );
+// // ASSERT( itOnMap != theSmdsToHybridIdMap.end() );
// // aqt.push_back((*itOnMap).second);
// // }
// // qt.push_back(aqt);
static bool writeFaces (ofstream & theFile,
const SMESH_ProxyMesh& theMesh,
const TopoDS_Shape& theShape,
- const map <int,int> & theSmdsToGhs3dIdMap,
- const map <int,int> & theEnforcedNodeIdToGhs3dIdMap,
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedEdges,
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedTriangles)
+ const map <int,int> & theSmdsToHybridIdMap,
+ const map <int,int> & theEnforcedNodeIdToHybridIdMap,
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedEdges,
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedTriangles)
{
// record structure:
//
itOnSubFace = aFace->nodesIterator();
for ( int j = 0; j < 3; ++j ) {
- // find GHS3D ID
+ // find HYBRID ID
aSmdsID = itOnSubFace->next()->GetID();
- itOnMap = theSmdsToGhs3dIdMap.find( aSmdsID );
- // if ( itOnMap == theSmdsToGhs3dIdMap.end() ) {
+ itOnMap = theSmdsToHybridIdMap.find( aSmdsID );
+ // if ( itOnMap == theSmdsToHybridIdMap.end() ) {
// cout << "not found node: " << aSmdsID << endl;
// return false;
// }
- ASSERT( itOnMap != theSmdsToGhs3dIdMap.end() );
+ ASSERT( itOnMap != theSmdsToHybridIdMap.end() );
localStream << (*itOnMap).second << space ;
}
// aStream << "2" << space ;
// for ( int j = 0; j < 2; ++j ) {
// aSmdsID = itOnSubFace->next()->GetID();
-// itOnMap = theEnforcedNodeIdToGhs3dIdMap.find(aSmdsID);
-// if (itOnMap != theEnforcedNodeIdToGhs3dIdMap.end())
+// itOnMap = theEnforcedNodeIdToHybridIdMap.find(aSmdsID);
+// if (itOnMap != theEnforcedNodeIdToHybridIdMap.end())
// aStream << (*itOnMap).second << space;
// else {
// isOK = false;
// aStream << nbNodes << space ;
// for ( int j = 0; j < 3; ++j ) {
// aSmdsID = itOnSubFace->next()->GetID();
-// itOnMap = theEnforcedNodeIdToGhs3dIdMap.find(aSmdsID);
-// if (itOnMap != theEnforcedNodeIdToGhs3dIdMap.end())
+// itOnMap = theEnforcedNodeIdToHybridIdMap.find(aSmdsID);
+// if (itOnMap != theEnforcedNodeIdToHybridIdMap.end())
// aStream << (*itOnMap).second << space;
// else {
// isOK = false;
static bool writePoints (ofstream & theFile,
SMESH_MesherHelper& theHelper,
- map <int,int> & theSmdsToGhs3dIdMap,
- map <int,int> & theEnforcedNodeIdToGhs3dIdMap,
- map <int,const SMDS_MeshNode*> & theGhs3dIdToNodeMap,
- GHS3DPlugin_Hypothesis::TID2SizeMap & theNodeIDToSizeMap,
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexCoordsValues & theEnforcedVertices,
- GHS3DPlugin_Hypothesis::TIDSortedNodeGroupMap & theEnforcedNodes,
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedEdges,
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedTriangles)
+ map <int,int> & theSmdsToHybridIdMap,
+ map <int,int> & theEnforcedNodeIdToHybridIdMap,
+ map <int,const SMDS_MeshNode*> & theHybridIdToNodeMap,
+ HYBRIDPlugin_Hypothesis::TID2SizeMap & theNodeIDToSizeMap,
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexCoordsValues & theEnforcedVertices,
+ HYBRIDPlugin_Hypothesis::TIDSortedNodeGroupMap & theEnforcedNodes,
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedEdges,
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedTriangles)
{
// record structure:
//
const TopoDS_Shape shapeToMesh = theMeshDS->ShapeToMesh();
- int aGhs3dID = 1;
+ int aHybridID = 1;
SMDS_NodeIteratorPtr nodeIt = theMeshDS->nodesIterator();
const SMDS_MeshNode* node;
- // Issue 020674: EDF 870 SMESH: Mesh generated by Netgen not usable by GHS3D
+ // Issue 020674: EDF 870 SMESH: Mesh generated by Netgen not usable by HYBRID
// The problem is in nodes on degenerated edges, we need to skip nodes which are free
// and replace not-free nodes on degenerated edges by the node on vertex
TNodeNodeMap n2nDegen; // map a node on degenerated edge to a node on vertex
if ( n2nDegen.count( node ) ) // Issue 0020674
continue;
- theSmdsToGhs3dIdMap.insert( make_pair( node->GetID(), aGhs3dID ));
- theGhs3dIdToNodeMap.insert( make_pair( aGhs3dID, node ));
- aGhs3dID++;
+ theSmdsToHybridIdMap.insert( make_pair( node->GetID(), aHybridID ));
+ theHybridIdToNodeMap.insert( make_pair( aHybridID, node ));
+ aHybridID++;
// X Y Z DUMMY_INT
theFile
// Iterate over the enforced nodes
std::map<int,double> enfVertexIndexSizeMap;
if (nbEnforcedNodes) {
- GHS3DPlugin_Hypothesis::TIDSortedNodeGroupMap::const_iterator nodeIt = theEnforcedNodes.begin();
+ HYBRIDPlugin_Hypothesis::TIDSortedNodeGroupMap::const_iterator nodeIt = theEnforcedNodes.begin();
for( ; nodeIt != theEnforcedNodes.end() ; ++nodeIt) {
double x = nodeIt->first->X();
double y = nodeIt->first->Y();
continue;
// double size = theNodeIDToSizeMap.find(nodeIt->first->GetID())->second;
- // theGhs3dIdToNodeMap.insert( make_pair( nbNodes + i, (*nodeIt) ));
+ // theHybridIdToNodeMap.insert( make_pair( nbNodes + i, (*nodeIt) ));
// MESSAGE("Adding enforced node (" << x << "," << y <<"," << z << ")");
// X Y Z PHY_SIZE DUMMY_INT
theFile
<< -1 << space
<< dummyint << space;
theFile << std::endl;
- theEnforcedNodeIdToGhs3dIdMap.insert( make_pair( nodeIt->first->GetID(), aGhs3dID ));
- enfVertexIndexSizeMap[aGhs3dID] = -1;
- aGhs3dID++;
+ theEnforcedNodeIdToHybridIdMap.insert( make_pair( nodeIt->first->GetID(), aHybridID ));
+ enfVertexIndexSizeMap[aHybridID] = -1;
+ aHybridID++;
// else
// MESSAGE("Enforced vertex (" << x << "," << y <<"," << z << ") is not inside the geometry: it was not added ");
}
if (nbEnforcedVertices) {
// Iterate over the enforced vertices
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexCoordsValues::const_iterator vertexIt = theEnforcedVertices.begin();
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexCoordsValues::const_iterator vertexIt = theEnforcedVertices.begin();
for( ; vertexIt != theEnforcedVertices.end() ; ++vertexIt) {
double x = vertexIt->first[0];
double y = vertexIt->first[1];
<< vertexIt->second << space
<< dummyint << space;
theFile << std::endl;
- enfVertexIndexSizeMap[aGhs3dID] = vertexIt->second;
- aGhs3dID++;
+ enfVertexIndexSizeMap[aHybridID] = vertexIt->second;
+ aHybridID++;
}
}
#ifdef WIN32
const char* fileName,
#endif
- GHS3DPlugin_GHS3D* theAlgo,
+ HYBRIDPlugin_HYBRID* theAlgo,
SMESH_MesherHelper& theHelper,
TopoDS_Shape tabShape[],
double** tabBox,
const int nbShape,
- map <int,const SMDS_MeshNode*>& theGhs3dIdToNodeMap,
+ map <int,const SMDS_MeshNode*>& theHybridIdToNodeMap,
std::map <int,int> & theNodeId2NodeIndexMap,
bool toMeshHoles,
int nbEnforcedVertices,
int nbEnforcedNodes,
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedEdges,
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedTriangles,
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedEdges,
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap & theEnforcedTriangles,
bool toMakeGroupsOfDomains)
{
- MESSAGE("GHS3DPlugin_GHS3D::readResultFile()");
+ MESSAGE("HYBRIDPlugin_HYBRID::readResultFile()");
Kernel_Utils::Localizer loc;
struct stat status;
size_t length;
int nbElems, nbNodes, nbInputNodes;
int nbTriangle;
- int ID, shapeID, ghs3dShapeID;
+ int ID, shapeID, hybridShapeID;
int IdShapeRef = 1;
int compoundID =
nbShape ? theMeshDS->ShapeToIndex( tabShape[0] ) : theMeshDS->ShapeToIndex( theMeshDS->ShapeToMesh() );
// Creating SMESH nodes
// - for enforced vertices
// - for vertices of forced edges
- // - for ghs3d nodes
+ // - for hybrid nodes
nodeAssigne[ iNode ] = 0;
aNewNode = theMeshDS->AddNode( coord[0],coord[1],coord[2] );
- theGhs3dIdToNodeMap.insert(theGhs3dIdToNodeMap.end(), make_pair( iNode, aNewNode ));
+ theHybridIdToNodeMap.insert(theHybridIdToNodeMap.end(), make_pair( iNode, aNewNode ));
}
}
if(theAlgo->computeCanceled())
return false;
tabID[i] = 0;
- // find the solid corresponding to GHS3D sub-domain following
- // the technique proposed in GHS3D manual in chapter
+ // find the solid corresponding to HYBRID sub-domain following
+ // the technique proposed in HYBRID manual in chapter
// "B.4 Subdomain (sub-region) assignment"
int nodeId1 = strtol(ptr, &ptr, 10);
int nodeId2 = strtol(ptr, &ptr, 10);
int nodeId3 = strtol(ptr, &ptr, 10);
if ( nbTriangle > 1 ) {
- const SMDS_MeshNode* n1 = theGhs3dIdToNodeMap[ nodeId1 ];
- const SMDS_MeshNode* n2 = theGhs3dIdToNodeMap[ nodeId2 ];
- const SMDS_MeshNode* n3 = theGhs3dIdToNodeMap[ nodeId3 ];
+ const SMDS_MeshNode* n1 = theHybridIdToNodeMap[ nodeId1 ];
+ const SMDS_MeshNode* n2 = theHybridIdToNodeMap[ nodeId2 ];
+ const SMDS_MeshNode* n3 = theHybridIdToNodeMap[ nodeId3 ];
if (!n1 || !n2 || !n3) {
tabID[i] = HOLE_ID;
continue;
OCC_CATCH_SIGNALS;
// tabID[i] = findShapeID( theHelper, n1, n2, n3, toMeshHoles );
tabID[i] = findShapeID( *theHelper.GetMesh(), n1, n2, n3, toMeshHoles );
- // -- 0020330: Pb with ghs3d as a submesh
+ // -- 0020330: Pb with hybrid as a submesh
// check that found shape is to be meshed
if ( tabID[i] > 0 ) {
const TopoDS_Shape& foundShape = theMeshDS->IndexToShape( tabID[i] );
if ( !isToBeMeshed )
tabID[i] = HOLE_ID;
}
- // END -- 0020330: Pb with ghs3d as a submesh
+ // END -- 0020330: Pb with hybrid as a submesh
#ifdef _DEBUG_
std::cout << i+1 << " subdomain: findShapeID() returns " << tabID[i] << std::endl;
#endif
return false;
for (int iNode = 0; iNode < 4; iNode++) {
ID = strtol(tetraPtr, &tetraPtr, 10);
- itOnNode = theGhs3dIdToNodeMap.find(ID);
+ itOnNode = theHybridIdToNodeMap.find(ID);
node[ iNode ] = itOnNode->second;
nodeID[ iNode ] = ID;
}
- // We always run GHS3D with "to mesh holes"==TRUE but we must not create
+ // We always run HYBRID with "to mesh holes"==TRUE but we must not create
// tetras within holes depending on hypo option,
// so we first check if aTet is inside a hole and then create it
//aTet = theMeshDS->AddVolume( node[1], node[0], node[2], node[3] );
- ghs3dShapeID = 0; // domain ID
+ hybridShapeID = 0; // domain ID
if ( nbTriangle > 1 ) {
shapeID = HOLE_ID; // negative shapeID means not to create tetras if !toMeshHoles
- ghs3dShapeID = strtol(shapePtr, &shapePtr, 10) - IdShapeRef;
- if ( tabID[ ghs3dShapeID ] == 0 ) {
+ hybridShapeID = strtol(shapePtr, &shapePtr, 10) - IdShapeRef;
+ if ( tabID[ hybridShapeID ] == 0 ) {
TopAbs_State state;
aSolid = findShape(node, aSolid, tabShape, tabBox, nbShape, &state);
if ( toMeshHoles || state == TopAbs_IN )
shapeID = theMeshDS->ShapeToIndex( aSolid );
- tabID[ ghs3dShapeID ] = shapeID;
+ tabID[ hybridShapeID ] = shapeID;
}
else
- shapeID = tabID[ ghs3dShapeID ];
+ shapeID = tabID[ hybridShapeID ];
}
else if ( nbShape > 1 ) {
// Case where nbTriangle == 1 while nbShape == 2 encountered
theMeshDS->SetMeshElementOnShape( aTet, shapeID );
if ( toMakeGroupsOfDomains )
{
- if ( int( elemsOfDomain.size() ) < ghs3dShapeID+1 )
- elemsOfDomain.resize( ghs3dShapeID+1 );
- elemsOfDomain[ ghs3dShapeID ].push_back( aTet );
+ if ( int( elemsOfDomain.size() ) < hybridShapeID+1 )
+ elemsOfDomain.resize( hybridShapeID+1 );
+ elemsOfDomain[ hybridShapeID ].push_back( aTet );
}
}
#ifdef _DEBUG_
makeDomainGroups( elemsOfDomain, &theHelper );
// Add enforced elements
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap::const_iterator elemIt;
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap::const_iterator elemIt;
const SMDS_MeshElement* anElem;
SMDS_ElemIteratorPtr itOnEnfElem;
map<int,int>::const_iterator itOnMap;
int aNodeID = itOnEnfElem->next()->GetID();
itOnMap = theNodeId2NodeIndexMap.find(aNodeID);
if (itOnMap != theNodeId2NodeIndexMap.end()) {
- itOnNode = theGhs3dIdToNodeMap.find((*itOnMap).second);
- if (itOnNode != theGhs3dIdToNodeMap.end()) {
+ itOnNode = theHybridIdToNodeMap.find((*itOnMap).second);
+ if (itOnNode != theHybridIdToNodeMap.end()) {
node.push_back((*itOnNode).second);
// shapeID =(*itOnNode).second->getshapeId();
}
int aNodeID = itOnEnfElem->next()->GetID();
itOnMap = theNodeId2NodeIndexMap.find(aNodeID);
if (itOnMap != theNodeId2NodeIndexMap.end()) {
- itOnNode = theGhs3dIdToNodeMap.find((*itOnMap).second);
- if (itOnNode != theGhs3dIdToNodeMap.end()) {
+ itOnNode = theHybridIdToNodeMap.find((*itOnMap).second);
+ if (itOnNode != theHybridIdToNodeMap.end()) {
node.push_back((*itOnNode).second);
// shapeID =(*itOnNode).second->getshapeId();
}
// Remove nodes of tetras inside holes if !toMeshHoles
if ( !toMeshHoles ) {
- itOnNode = theGhs3dIdToNodeMap.find( nbInputNodes );
- for ( ; itOnNode != theGhs3dIdToNodeMap.end(); ++itOnNode) {
+ itOnNode = theHybridIdToNodeMap.find( nbInputNodes );
+ for ( ; itOnNode != theHybridIdToNodeMap.end(); ++itOnNode) {
ID = itOnNode->first;
if ( nodeAssigne[ ID ] == HOLE_ID )
theMeshDS->RemoveFreeNode( itOnNode->second, 0 );
//=============================================================================
/*!
- *Here we are going to use the GHS3D mesher with geometry
+ *Here we are going to use the HYBRID mesher with geometry
*/
//=============================================================================
-bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh& theMesh,
+bool HYBRIDPlugin_HYBRID::Compute(SMESH_Mesh& theMesh,
const TopoDS_Shape& theShape)
{
bool Ok(false);
//SMESHDS_Mesh* meshDS = theMesh.GetMeshDS();
// we count the number of shapes
- // _nbShape = countShape( meshDS, TopAbs_SOLID ); -- 0020330: Pb with ghs3d as a submesh
+ // _nbShape = countShape( meshDS, TopAbs_SOLID ); -- 0020330: Pb with hybrid as a submesh
// _nbShape = 0;
TopExp_Explorer expBox ( theShape, TopAbs_SOLID );
// for ( ; expBox.More(); expBox.Next() )
// a unique working file name
// to avoid access to the same files by eg different users
- _genericName = GHS3DPlugin_Hypothesis::GetFileName(_hyp);
+ _genericName = HYBRIDPlugin_Hypothesis::GetFileName(_hyp);
TCollection_AsciiString aGenericName((char*) _genericName.c_str() );
TCollection_AsciiString aGenericNameRequired = aGenericName + "_required";
// aSolFileName = aGenericNameRequired + ".solb"; // GMF solution file
//#endif
- std::map <int,int> aNodeId2NodeIndexMap, aSmdsToGhs3dIdMap, anEnforcedNodeIdToGhs3dIdMap;
- //std::map <int,const SMDS_MeshNode*> aGhs3dIdToNodeMap;
+ std::map <int,int> aNodeId2NodeIndexMap, aSmdsToHybridIdMap, anEnforcedNodeIdToHybridIdMap;
+ //std::map <int,const SMDS_MeshNode*> aHybridIdToNodeMap;
std::map <int, int> nodeID2nodeIndexMap;
std::map<std::vector<double>, std::string> enfVerticesWithGroup;
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexCoordsValues coordsSizeMap = GHS3DPlugin_Hypothesis::GetEnforcedVerticesCoordsSize(_hyp);
- GHS3DPlugin_Hypothesis::TIDSortedNodeGroupMap enforcedNodes = GHS3DPlugin_Hypothesis::GetEnforcedNodes(_hyp);
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap enforcedEdges = GHS3DPlugin_Hypothesis::GetEnforcedEdges(_hyp);
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap enforcedTriangles = GHS3DPlugin_Hypothesis::GetEnforcedTriangles(_hyp);
-// TIDSortedElemSet enforcedQuadrangles = GHS3DPlugin_Hypothesis::GetEnforcedQuadrangles(_hyp);
- GHS3DPlugin_Hypothesis::TID2SizeMap nodeIDToSizeMap = GHS3DPlugin_Hypothesis::GetNodeIDToSizeMap(_hyp);
-
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList enfVertices = GHS3DPlugin_Hypothesis::GetEnforcedVertices(_hyp);
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList::const_iterator enfVerIt = enfVertices.begin();
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexCoordsValues coordsSizeMap = HYBRIDPlugin_Hypothesis::GetEnforcedVerticesCoordsSize(_hyp);
+ HYBRIDPlugin_Hypothesis::TIDSortedNodeGroupMap enforcedNodes = HYBRIDPlugin_Hypothesis::GetEnforcedNodes(_hyp);
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap enforcedEdges = HYBRIDPlugin_Hypothesis::GetEnforcedEdges(_hyp);
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap enforcedTriangles = HYBRIDPlugin_Hypothesis::GetEnforcedTriangles(_hyp);
+// TIDSortedElemSet enforcedQuadrangles = HYBRIDPlugin_Hypothesis::GetEnforcedQuadrangles(_hyp);
+ HYBRIDPlugin_Hypothesis::TID2SizeMap nodeIDToSizeMap = HYBRIDPlugin_Hypothesis::GetNodeIDToSizeMap(_hyp);
+
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexList enfVertices = HYBRIDPlugin_Hypothesis::GetEnforcedVertices(_hyp);
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexList::const_iterator enfVerIt = enfVertices.begin();
std::vector<double> coords;
for ( ; enfVerIt != enfVertices.end() ; ++enfVerIt)
{
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex* enfVertex = (*enfVerIt);
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* enfVertex = (*enfVerIt);
// if (enfVertex->geomEntry.empty() && enfVertex->coords.size()) {
if (enfVertex->coords.size()) {
coordsSizeMap.insert(make_pair(enfVertex->coords,enfVertex->size));
SMESH_MesherHelper helper( theMesh );
helper.SetSubShape( theShape );
- std::vector <const SMDS_MeshNode*> aNodeByGhs3dId, anEnforcedNodeByGhs3dId;
- std::vector <const SMDS_MeshElement*> aFaceByGhs3dId;
- std::map<const SMDS_MeshNode*,int> aNodeToGhs3dIdMap;
- std::vector<std::string> aNodeGroupByGhs3dId, anEdgeGroupByGhs3dId, aFaceGroupByGhs3dId;
+ std::vector <const SMDS_MeshNode*> aNodeByHybridId, anEnforcedNodeByHybridId;
+ std::vector <const SMDS_MeshElement*> aFaceByHybridId;
+ std::map<const SMDS_MeshNode*,int> aNodeToHybridIdMap;
+ std::vector<std::string> aNodeGroupByHybridId, anEdgeGroupByHybridId, aFaceGroupByHybridId;
{
SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( theMesh ));
}
// Ok = (writePoints( aPointsFile, helper,
- // aSmdsToGhs3dIdMap, anEnforcedNodeIdToGhs3dIdMap, aGhs3dIdToNodeMap,
+ // aSmdsToHybridIdMap, anEnforcedNodeIdToHybridIdMap, aHybridIdToNodeMap,
// nodeIDToSizeMap,
// coordsSizeMap, enforcedNodes, enforcedEdges, enforcedTriangles)
// &&
// writeFaces ( aFacesFile, *proxyMesh, theShape,
- // aSmdsToGhs3dIdMap, anEnforcedNodeIdToGhs3dIdMap,
+ // aSmdsToHybridIdMap, anEnforcedNodeIdToHybridIdMap,
// enforcedEdges, enforcedTriangles ));
Ok = writeGMFFile(aGMFFileName.ToCString(), aRequiredVerticesFileName.ToCString(), aSolFileName.ToCString(),
*proxyMesh, helper,
- aNodeByGhs3dId, aFaceByGhs3dId, aNodeToGhs3dIdMap,
- aNodeGroupByGhs3dId, anEdgeGroupByGhs3dId, aFaceGroupByGhs3dId,
+ aNodeByHybridId, aFaceByHybridId, aNodeToHybridIdMap,
+ aNodeGroupByHybridId, anEdgeGroupByHybridId, aFaceGroupByHybridId,
enforcedNodes, enforcedEdges, enforcedTriangles, /*enforcedQuadrangles,*/
enfVerticesWithGroup, coordsSizeMap);
}
- // Write aSmdsToGhs3dIdMap to temp file
- TCollection_AsciiString aSmdsToGhs3dIdMapFileName;
- aSmdsToGhs3dIdMapFileName = aGenericName + ".ids"; // ids relation
- ofstream aIdsFile ( aSmdsToGhs3dIdMapFileName.ToCString() , ios::out);
+ // Write aSmdsToHybridIdMap to temp file
+ TCollection_AsciiString aSmdsToHybridIdMapFileName;
+ aSmdsToHybridIdMapFileName = aGenericName + ".ids"; // ids relation
+ ofstream aIdsFile ( aSmdsToHybridIdMapFileName.ToCString() , ios::out);
Ok = aIdsFile.rdbuf()->is_open();
if (!Ok) {
- INFOS( "Can't write into " << aSmdsToGhs3dIdMapFileName);
- return error(SMESH_Comment("Can't write into ") << aSmdsToGhs3dIdMapFileName);
+ INFOS( "Can't write into " << aSmdsToHybridIdMapFileName);
+ return error(SMESH_Comment("Can't write into ") << aSmdsToHybridIdMapFileName);
}
- INFOS( "Writing ids relation into " << aSmdsToGhs3dIdMapFileName);
- aIdsFile << "Smds Ghs3d" << std::endl;
+ INFOS( "Writing ids relation into " << aSmdsToHybridIdMapFileName);
+ aIdsFile << "Smds Hybrid" << std::endl;
map <int,int>::const_iterator myit;
- for (myit=aSmdsToGhs3dIdMap.begin() ; myit != aSmdsToGhs3dIdMap.end() ; ++myit) {
+ for (myit=aSmdsToHybridIdMap.begin() ; myit != aSmdsToHybridIdMap.end() ; ++myit) {
aIdsFile << myit->first << " " << myit->second << std::endl;
}
removeFile( aGMFFileName );
removeFile( aRequiredVerticesFileName );
removeFile( aSolFileName );
- removeFile( aSmdsToGhs3dIdMapFileName );
+ removeFile( aSmdsToHybridIdMapFileName );
}
return error(COMPERR_BAD_INPUT_MESH);
}
removeFile( aResultFileName ); // needed for boundary recovery module usage
// -----------------
- // run ghs3d mesher
+ // run hybrid mesher
// -----------------
- TCollection_AsciiString cmd( (char*)GHS3DPlugin_Hypothesis::CommandToRun( _hyp ).c_str() );
+ TCollection_AsciiString cmd( (char*)HYBRIDPlugin_Hypothesis::CommandToRun( _hyp ).c_str() );
cmd += TCollection_AsciiString(" --in ") + aGMFFileName;
if ( nbEnforcedVertices + nbEnforcedNodes)
cmd += TCollection_AsciiString(" 1>" ) + aLogFileName; // dump into file
std::cout << std::endl;
- std::cout << "Ghs3d execution..." << std::endl;
+ std::cout << "Hybrid execution..." << std::endl;
std::cout << cmd << std::endl;
_compute_canceled = false;
system( cmd.ToCString() ); // run
std::cout << std::endl;
- std::cout << "End of Ghs3d execution !" << std::endl;
+ std::cout << "End of Hybrid execution !" << std::endl;
// --------------
// read a result
// fileOpen = open( aResultFileName.ToCString(), O_RDONLY);
// if ( fileOpen < 0 ) {
// std::cout << std::endl;
- // std::cout << "Can't open the " << aResultFileName.ToCString() << " GHS3D output file" << std::endl;
+ // std::cout << "Can't open the " << aResultFileName.ToCString() << " HYBRID output file" << std::endl;
// std::cout << "Log: " << aLogFileName << std::endl;
// Ok = false;
// }
// else {
- GHS3DPlugin_Hypothesis::TSetStrings groupsToRemove = GHS3DPlugin_Hypothesis::GetGroupsToRemove(_hyp);
+ HYBRIDPlugin_Hypothesis::TSetStrings groupsToRemove = HYBRIDPlugin_Hypothesis::GetGroupsToRemove(_hyp);
bool toMeshHoles =
- _hyp ? _hyp->GetToMeshHoles(true) : GHS3DPlugin_Hypothesis::DefaultMeshHoles();
- const bool toMakeGroupsOfDomains = GHS3DPlugin_Hypothesis::GetToMakeGroupsOfDomains( _hyp );
+ _hyp ? _hyp->GetToMeshHoles(true) : HYBRIDPlugin_Hypothesis::DefaultMeshHoles();
+ const bool toMakeGroupsOfDomains = HYBRIDPlugin_Hypothesis::GetToMakeGroupsOfDomains( _hyp );
helper.IsQuadraticSubMesh( theShape );
helper.SetElementsOnShape( false );
// #endif
// this,
// /*theMesh, */helper, tabShape, tabBox, _nbShape,
-// aGhs3dIdToNodeMap, aNodeId2NodeIndexMap,
+// aHybridIdToNodeMap, aNodeId2NodeIndexMap,
// toMeshHoles,
// nbEnforcedVertices, nbEnforcedNodes,
// enforcedEdges, enforcedTriangles,
Ok = readGMFFile(aResultFileName.ToCString(),
this,
- &helper, aNodeByGhs3dId, aFaceByGhs3dId, aNodeToGhs3dIdMap,
- aNodeGroupByGhs3dId, anEdgeGroupByGhs3dId, aFaceGroupByGhs3dId,
+ &helper, aNodeByHybridId, aFaceByHybridId, aNodeToHybridIdMap,
+ aNodeGroupByHybridId, anEdgeGroupByHybridId, aFaceGroupByHybridId,
groupsToRemove, toMakeGroupsOfDomains, toMeshHoles);
removeEmptyGroupsOfDomains( helper.GetMesh(), /*notEmptyAsWell =*/ !toMakeGroupsOfDomains );
else if ( OSD_File( aLogFileName ).Size() > 0 )
{
// get problem description from the log file
- _Ghs2smdsConvertor conv( aNodeByGhs3dId );
+ _Ghs2smdsConvertor conv( aNodeByHybridId );
storeErrorDescription( aLogFileName, conv );
}
else
{
// the log file is empty
removeFile( aLogFileName );
- INFOS( "GHS3D Error, command '" << cmd.ToCString() << "' failed" );
- error(COMPERR_ALGO_FAILED, "ghs3d: command not found" );
+ INFOS( "HYBRID Error, command '" << cmd.ToCString() << "' failed" );
+ error(COMPERR_ALGO_FAILED, "hybrid: command not found" );
}
if ( !_keepFiles ) {
removeFile( aSolFileName );
removeFile( aResSolFileName );
removeFile( aResultFileName );
- removeFile( aSmdsToGhs3dIdMapFileName );
+ removeFile( aSmdsToHybridIdMapFileName );
}
- std::cout << "<" << aResultFileName.ToCString() << "> GHS3D output file ";
+ std::cout << "<" << aResultFileName.ToCString() << "> HYBRID output file ";
if ( !Ok )
std::cout << "not ";
std::cout << "treated !" << std::endl;
//=============================================================================
/*!
- *Here we are going to use the GHS3D mesher w/o geometry
+ *Here we are going to use the HYBRID mesher w/o geometry
*/
//=============================================================================
-bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh& theMesh,
+bool HYBRIDPlugin_HYBRID::Compute(SMESH_Mesh& theMesh,
SMESH_MesherHelper* theHelper)
{
- MESSAGE("GHS3DPlugin_GHS3D::Compute()");
+ MESSAGE("HYBRIDPlugin_HYBRID::Compute()");
theHelper->IsQuadraticSubMesh( theHelper->GetSubShape() );
// a unique working file name
// to avoid access to the same files by eg different users
- _genericName = GHS3DPlugin_Hypothesis::GetFileName(_hyp);
+ _genericName = HYBRIDPlugin_Hypothesis::GetFileName(_hyp);
TCollection_AsciiString aGenericName((char*) _genericName.c_str() );
TCollection_AsciiString aGenericNameRequired = aGenericName + "_required";
std::map <int, int> nodeID2nodeIndexMap;
std::map<std::vector<double>, std::string> enfVerticesWithGroup;
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexCoordsValues coordsSizeMap;
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexCoordsValues coordsSizeMap;
TopoDS_Shape GeomShape;
// TopAbs_ShapeEnum GeomType;
std::vector<double> coords;
gp_Pnt aPnt;
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex* enfVertex;
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* enfVertex;
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList enfVertices = GHS3DPlugin_Hypothesis::GetEnforcedVertices(_hyp);
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList::const_iterator enfVerIt = enfVertices.begin();
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexList enfVertices = HYBRIDPlugin_Hypothesis::GetEnforcedVertices(_hyp);
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexList::const_iterator enfVerIt = enfVertices.begin();
for ( ; enfVerIt != enfVertices.end() ; ++enfVerIt)
{
}
// const SMDS_MeshNode* enfNode;
- GHS3DPlugin_Hypothesis::TIDSortedNodeGroupMap enforcedNodes = GHS3DPlugin_Hypothesis::GetEnforcedNodes(_hyp);
-// GHS3DPlugin_Hypothesis::TIDSortedNodeGroupMap::const_iterator enfNodeIt = enforcedNodes.begin();
+ HYBRIDPlugin_Hypothesis::TIDSortedNodeGroupMap enforcedNodes = HYBRIDPlugin_Hypothesis::GetEnforcedNodes(_hyp);
+// HYBRIDPlugin_Hypothesis::TIDSortedNodeGroupMap::const_iterator enfNodeIt = enforcedNodes.begin();
// for ( ; enfNodeIt != enforcedNodes.end() ; ++enfNodeIt)
// {
// enfNode = enfNodeIt->first;
// }
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap enforcedEdges = GHS3DPlugin_Hypothesis::GetEnforcedEdges(_hyp);
- GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap enforcedTriangles = GHS3DPlugin_Hypothesis::GetEnforcedTriangles(_hyp);
-// TIDSortedElemSet enforcedQuadrangles = GHS3DPlugin_Hypothesis::GetEnforcedQuadrangles(_hyp);
- GHS3DPlugin_Hypothesis::TID2SizeMap nodeIDToSizeMap = GHS3DPlugin_Hypothesis::GetNodeIDToSizeMap(_hyp);
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap enforcedEdges = HYBRIDPlugin_Hypothesis::GetEnforcedEdges(_hyp);
+ HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap enforcedTriangles = HYBRIDPlugin_Hypothesis::GetEnforcedTriangles(_hyp);
+// TIDSortedElemSet enforcedQuadrangles = HYBRIDPlugin_Hypothesis::GetEnforcedQuadrangles(_hyp);
+ HYBRIDPlugin_Hypothesis::TID2SizeMap nodeIDToSizeMap = HYBRIDPlugin_Hypothesis::GetNodeIDToSizeMap(_hyp);
std::string tmpStr;
(nbEnforcedVertices <= 1) ? tmpStr = "vertex" : tmpStr = "vertices";
std::cout << nbEnforcedVertices << " enforced " << tmpStr << " from hypo" << std::endl;
- std::vector <const SMDS_MeshNode*> aNodeByGhs3dId, anEnforcedNodeByGhs3dId;
- std::vector <const SMDS_MeshElement*> aFaceByGhs3dId;
- std::map<const SMDS_MeshNode*,int> aNodeToGhs3dIdMap;
- std::vector<std::string> aNodeGroupByGhs3dId, anEdgeGroupByGhs3dId, aFaceGroupByGhs3dId;
+ std::vector <const SMDS_MeshNode*> aNodeByHybridId, anEnforcedNodeByHybridId;
+ std::vector <const SMDS_MeshElement*> aFaceByHybridId;
+ std::map<const SMDS_MeshNode*,int> aNodeToHybridIdMap;
+ std::vector<std::string> aNodeGroupByHybridId, anEdgeGroupByHybridId, aFaceGroupByHybridId;
{
SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( theMesh ));
if ( theMesh.NbQuadrangles() > 0 )
Ok = writeGMFFile(aGMFFileName.ToCString(), aRequiredVerticesFileName.ToCString(), aSolFileName.ToCString(),
*proxyMesh, *theHelper,
- aNodeByGhs3dId, aFaceByGhs3dId, aNodeToGhs3dIdMap,
- aNodeGroupByGhs3dId, anEdgeGroupByGhs3dId, aFaceGroupByGhs3dId,
+ aNodeByHybridId, aFaceByHybridId, aNodeToHybridIdMap,
+ aNodeGroupByHybridId, anEdgeGroupByHybridId, aFaceGroupByHybridId,
enforcedNodes, enforcedEdges, enforcedTriangles,
enfVerticesWithGroup, coordsSizeMap);
}
// -----------------
- // run ghs3d mesher
+ // run hybrid mesher
// -----------------
- TCollection_AsciiString cmd = TCollection_AsciiString((char*)GHS3DPlugin_Hypothesis::CommandToRun( _hyp, false ).c_str());
+ TCollection_AsciiString cmd = TCollection_AsciiString((char*)HYBRIDPlugin_Hypothesis::CommandToRun( _hyp, false ).c_str());
cmd += TCollection_AsciiString(" --in ") + aGMFFileName;
if ( nbEnforcedVertices + nbEnforcedNodes)
cmd += TCollection_AsciiString(" 1>" ) + aLogFileName; // dump into file
std::cout << std::endl;
- std::cout << "Ghs3d execution..." << std::endl;
+ std::cout << "Hybrid execution..." << std::endl;
std::cout << cmd << std::endl;
_compute_canceled = false;
system( cmd.ToCString() ); // run
std::cout << std::endl;
- std::cout << "End of Ghs3d execution !" << std::endl;
+ std::cout << "End of Hybrid execution !" << std::endl;
// --------------
// read a result
// --------------
- GHS3DPlugin_Hypothesis::TSetStrings groupsToRemove = GHS3DPlugin_Hypothesis::GetGroupsToRemove(_hyp);
- const bool toMakeGroupsOfDomains = GHS3DPlugin_Hypothesis::GetToMakeGroupsOfDomains( _hyp );
+ HYBRIDPlugin_Hypothesis::TSetStrings groupsToRemove = HYBRIDPlugin_Hypothesis::GetGroupsToRemove(_hyp);
+ const bool toMakeGroupsOfDomains = HYBRIDPlugin_Hypothesis::GetToMakeGroupsOfDomains( _hyp );
Ok = readGMFFile(aResultFileName.ToCString(),
this,
- theHelper, aNodeByGhs3dId, aFaceByGhs3dId, aNodeToGhs3dIdMap,
- aNodeGroupByGhs3dId, anEdgeGroupByGhs3dId, aFaceGroupByGhs3dId,
+ theHelper, aNodeByHybridId, aFaceByHybridId, aNodeToHybridIdMap,
+ aNodeGroupByHybridId, anEdgeGroupByHybridId, aFaceGroupByHybridId,
groupsToRemove, toMakeGroupsOfDomains);
updateMeshGroups(theHelper->GetMesh(), groupsToRemove);
removeEmptyGroupsOfDomains( theHelper->GetMesh(), /*notEmptyAsWell =*/ !toMakeGroupsOfDomains );
if ( Ok ) {
- GHS3DPlugin_Hypothesis* that = (GHS3DPlugin_Hypothesis*)this->_hyp;
+ HYBRIDPlugin_Hypothesis* that = (HYBRIDPlugin_Hypothesis*)this->_hyp;
if (that)
that->ClearGroupsToRemove();
}
else if ( OSD_File( aLogFileName ).Size() > 0 )
{
// get problem description from the log file
- _Ghs2smdsConvertor conv( aNodeByGhs3dId );
+ _Ghs2smdsConvertor conv( aNodeByHybridId );
storeErrorDescription( aLogFileName, conv );
}
else {
// the log file is empty
removeFile( aLogFileName );
- INFOS( "GHS3D Error, command '" << cmd.ToCString() << "' failed" );
- error(COMPERR_ALGO_FAILED, "ghs3d: command not found" );
+ INFOS( "HYBRID Error, command '" << cmd.ToCString() << "' failed" );
+ error(COMPERR_ALGO_FAILED, "hybrid: command not found" );
}
if ( !_keepFiles )
return Ok;
}
-void GHS3DPlugin_GHS3D::CancelCompute()
+void HYBRIDPlugin_HYBRID::CancelCompute()
{
_compute_canceled = true;
#ifdef WIN32
#else
std::string cmd = "ps xo pid,args | grep " + _genericName;
- //cmd += " | grep -e \"^ *[0-9]\\+ \\+" + GHS3DPlugin_Hypothesis::GetExeName() + "\"";
+ //cmd += " | grep -e \"^ *[0-9]\\+ \\+" + HYBRIDPlugin_Hypothesis::GetExeName() + "\"";
cmd += " | awk '{print $1}' | xargs kill -9 > /dev/null 2>&1";
system( cmd.c_str() );
#endif
//================================================================================
/*!
- * \brief Provide human readable text by error code reported by ghs3d
+ * \brief Provide human readable text by error code reported by hybrid
*/
//================================================================================
*/
//================================================================================
-bool GHS3DPlugin_GHS3D::storeErrorDescription(const TCollection_AsciiString& logFile,
+bool HYBRIDPlugin_HYBRID::storeErrorDescription(const TCollection_AsciiString& logFile,
const _Ghs2smdsConvertor & toSmdsConvertor )
{
if(_compute_canceled)
{
char msg2[] = "SEGMENTATION FAULT";
if ( search( &buf[0], bufEnd, msg2, msg2 + strlen(msg2)) != bufEnd )
- errDescription << "ghs3d: SEGMENTATION FAULT. ";
+ errDescription << "hybrid: SEGMENTATION FAULT. ";
}
}
//================================================================================
/*!
- * \brief Return SMDS element by ids of GHS3D nodes
+ * \brief Return SMDS element by ids of HYBRID nodes
*/
//================================================================================
*
*/
//=============================================================================
-bool GHS3DPlugin_GHS3D::Evaluate(SMESH_Mesh& aMesh,
+bool HYBRIDPlugin_HYBRID::Evaluate(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
MapShapeNbElems& aResMap)
{
return true;
}
-bool GHS3DPlugin_GHS3D::importGMFMesh(const char* theGMFFileName, SMESH_Mesh& theMesh)
+bool HYBRIDPlugin_HYBRID::importGMFMesh(const char* theGMFFileName, SMESH_Mesh& theMesh)
{
SMESH_MesherHelper* helper = new SMESH_MesherHelper(theMesh );
std::vector <const SMDS_MeshNode*> dummyNodeVector;
- std::vector <const SMDS_MeshElement*> aFaceByGhs3dId;
+ std::vector <const SMDS_MeshElement*> aFaceByHybridId;
std::map<const SMDS_MeshNode*,int> dummyNodeMap;
std::map<std::vector<double>, std::string> dummyEnfVertGroup;
std::vector<std::string> dummyElemGroup;
bool ok = readGMFFile(theGMFFileName,
this,
- helper, dummyNodeVector, aFaceByGhs3dId, dummyNodeMap, dummyElemGroup, dummyElemGroup, dummyElemGroup, dummyGroupsToRemove);
+ helper, dummyNodeVector, aFaceByHybridId, dummyNodeMap, dummyElemGroup, dummyElemGroup, dummyElemGroup, dummyGroupsToRemove);
theMesh.GetMeshDS()->Modified();
return ok;
}
/*!
* \brief Returns an ID of listener
*/
- static const char* Name() { return "GHS3DPlugin_GHS3D::_EnforcedMeshRestorer"; }
+ static const char* Name() { return "HYBRIDPlugin_HYBRID::_EnforcedMeshRestorer"; }
//================================================================================
/*!
!data->mySubMeshes.empty() )
{
// An enforced mesh (subMesh->_father) has been loaded from hdf file
- if ( GHS3DPlugin_Hypothesis* hyp = GetGHSHypothesis( data->mySubMeshes.front() ))
+ if ( HYBRIDPlugin_Hypothesis* hyp = GetGHSHypothesis( data->mySubMeshes.front() ))
hyp->RestoreEnfElemsByMeshes();
}
}
//================================================================================
/*!
- * \brief Returns GHS3DPlugin_Hypothesis used to compute a subMesh
+ * \brief Returns HYBRIDPlugin_Hypothesis used to compute a subMesh
*/
- static GHS3DPlugin_Hypothesis* GetGHSHypothesis( SMESH_subMesh* subMesh )
+ static HYBRIDPlugin_Hypothesis* GetGHSHypothesis( SMESH_subMesh* subMesh )
{
- SMESH_HypoFilter ghsHypFilter( SMESH_HypoFilter::HasName( "GHS3D_Parameters" ));
- return (GHS3DPlugin_Hypothesis* )
+ SMESH_HypoFilter ghsHypFilter( SMESH_HypoFilter::HasName( "HYBRID_Parameters" ));
+ return (HYBRIDPlugin_Hypothesis* )
subMesh->GetFather()->GetHypothesis( subMesh->GetSubShape(),
ghsHypFilter,
/*visitAncestors=*/true);
{
_GroupsOfDomainsRemover():
SMESH_subMeshEventListener( /*isDeletable = */true,
- "GHS3DPlugin_GHS3D::_GroupsOfDomainsRemover" ) {}
+ "HYBRIDPlugin_HYBRID::_GroupsOfDomainsRemover" ) {}
/*!
* \brief Treat events of the subMesh
*/
*/
//================================================================================
-void GHS3DPlugin_GHS3D::SubmeshRestored(SMESH_subMesh* subMesh)
+void HYBRIDPlugin_HYBRID::SubmeshRestored(SMESH_subMesh* subMesh)
{
- if ( GHS3DPlugin_Hypothesis* hyp = _EnforcedMeshRestorer::GetGHSHypothesis( subMesh ))
+ if ( HYBRIDPlugin_Hypothesis* hyp = _EnforcedMeshRestorer::GetGHSHypothesis( subMesh ))
{
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedMeshList enfMeshes = hyp->_GetEnforcedMeshes();
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedMeshList::iterator it = enfMeshes.begin();
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedMeshList enfMeshes = hyp->_GetEnforcedMeshes();
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedMeshList::iterator it = enfMeshes.begin();
for(;it != enfMeshes.end();++it) {
- GHS3DPlugin_Hypothesis::TGHS3DEnforcedMesh* enfMesh = *it;
+ HYBRIDPlugin_Hypothesis::THYBRIDEnforcedMesh* enfMesh = *it;
if ( SMESH_Mesh* mesh = GetMeshByPersistentID( enfMesh->persistID ))
{
SMESH_subMesh* smToListen = mesh->GetSubMesh( mesh->GetShapeToMesh() );
*/
//================================================================================
-void GHS3DPlugin_GHS3D::SetEventListener(SMESH_subMesh* subMesh)
+void HYBRIDPlugin_HYBRID::SetEventListener(SMESH_subMesh* subMesh)
{
subMesh->SetEventListener( new _GroupsOfDomainsRemover(), 0, subMesh );
}
//
//=============================================================================
-// File : GHS3DPlugin_GHS3D.hxx
+// File : HYBRIDPlugin_HYBRID.hxx
// Author : Edward AGAPOV, modified by Lioka RAZAFINDRAZAKA (CEA) 09/02/2007
// Project : SALOME
//=============================================================================
//
-#ifndef _GHS3DPlugin_GHS3D_HXX_
-#define _GHS3DPlugin_GHS3D_HXX_
+#ifndef _HYBRIDPlugin_HYBRID_HXX_
+#define _HYBRIDPlugin_HYBRID_HXX_
#include "SMESH_Algo.hxx"
#include "SMESH_Gen.hxx"
#endif
#define GMFDIMENSION 3
-class GHS3DPlugin_Hypothesis;
+class HYBRIDPlugin_Hypothesis;
class SMDS_MeshNode;
class SMESH_Mesh;
class StdMeshers_ViscousLayers;
class _Ghs2smdsConvertor;
class TopoDS_Shape;
-class GHS3DPlugin_GHS3D: public SMESH_3D_Algo
+class HYBRIDPlugin_HYBRID: public SMESH_3D_Algo
{
public:
- GHS3DPlugin_GHS3D(int hypId, int studyId, SMESH_Gen* gen);
- virtual ~GHS3DPlugin_GHS3D();
+ HYBRIDPlugin_HYBRID(int hypId, int studyId, SMESH_Gen* gen);
+ virtual ~HYBRIDPlugin_HYBRID();
virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
bool importGMFMesh(const char* aGMFFileName, SMESH_Mesh& aMesh);
- static const char* Name() { return "GHS3D_3D"; }
+ static const char* Name() { return "HYBRID_3D"; }
protected:
- const GHS3DPlugin_Hypothesis* _hyp;
+ const HYBRIDPlugin_Hypothesis* _hyp;
const StdMeshers_ViscousLayers* _viscousLayersHyp;
std::string _genericName;
};
/*!
- * \brief Convertor of GHS3D elements to SMDS ones
+ * \brief Convertor of HYBRID elements to SMDS ones
*/
class _Ghs2smdsConvertor
{
//
// SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
-// File : GHS3DPlugin_GHS3D_i.cxx
+// File : HYBRIDPlugin_HYBRID_i.cxx
// Author : Edward AGAPOV
-// Module : GHS3DPlugin
+// Module : HYBRIDPlugin
// $Header$
//
-#include "GHS3DPlugin_GHS3D_i.hxx"
+#include "HYBRIDPlugin_HYBRID_i.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Mesh_i.hxx"
#include "SMESH_Gen_i.hxx"
-#include "GHS3DPlugin_GHS3D.hxx"
+#include "HYBRIDPlugin_HYBRID.hxx"
#include "SMESH_PythonDump.hxx"
#include "utilities.h"
//=============================================================================
/*!
- * GHS3DPlugin_GHS3D_i::GHS3DPlugin_GHS3D_i
+ * HYBRIDPlugin_HYBRID_i::HYBRIDPlugin_HYBRID_i
*
* Constructor
*/
//=============================================================================
-GHS3DPlugin_GHS3D_i::GHS3DPlugin_GHS3D_i (PortableServer::POA_ptr thePOA,
+HYBRIDPlugin_HYBRID_i::HYBRIDPlugin_HYBRID_i (PortableServer::POA_ptr thePOA,
int theStudyId,
::SMESH_Gen* theGenImpl )
: SALOME::GenericObj_i( thePOA ),
SMESH_Algo_i( thePOA ),
SMESH_3D_Algo_i( thePOA )
{
- MESSAGE( "GHS3DPlugin_GHS3D_i::GHS3DPlugin_GHS3D_i" );
- myBaseImpl = new ::GHS3DPlugin_GHS3D (theGenImpl->GetANewId(),
+ MESSAGE( "HYBRIDPlugin_HYBRID_i::HYBRIDPlugin_HYBRID_i" );
+ myBaseImpl = new ::HYBRIDPlugin_HYBRID (theGenImpl->GetANewId(),
theStudyId,
theGenImpl );
}
//=============================================================================
/*!
- * GHS3DPlugin_GHS3D_i::~GHS3DPlugin_GHS3D_i
+ * HYBRIDPlugin_HYBRID_i::~HYBRIDPlugin_HYBRID_i
*
* Destructor
*/
//=============================================================================
-GHS3DPlugin_GHS3D_i::~GHS3DPlugin_GHS3D_i()
+HYBRIDPlugin_HYBRID_i::~HYBRIDPlugin_HYBRID_i()
{
- MESSAGE( "GHS3DPlugin_GHS3D_i::~GHS3DPlugin_GHS3D_i" );
+ MESSAGE( "HYBRIDPlugin_HYBRID_i::~HYBRIDPlugin_HYBRID_i" );
}
//=============================================================================
/*!
- * GHS3DPlugin_GHS3D_i::GetImpl
+ * HYBRIDPlugin_HYBRID_i::GetImpl
*
* Get implementation
*/
//=============================================================================
-::GHS3DPlugin_GHS3D* GHS3DPlugin_GHS3D_i::GetImpl()
+::HYBRIDPlugin_HYBRID* HYBRIDPlugin_HYBRID_i::GetImpl()
{
- MESSAGE( "GHS3DPlugin_GHS3D_i::GetImpl" );
- return ( ::GHS3DPlugin_GHS3D* )myBaseImpl;
+ MESSAGE( "HYBRIDPlugin_HYBRID_i::GetImpl" );
+ return ( ::HYBRIDPlugin_HYBRID* )myBaseImpl;
}
//=============================================================================
/*!
- * GHS3DPlugin_GHS3D_i::~GHS3DPlugin_GHS3D_i
+ * HYBRIDPlugin_HYBRID_i::~HYBRIDPlugin_HYBRID_i
*
* Destructor
*/
//=============================================================================
-SMESH::SMESH_Mesh_ptr GHS3DPlugin_GHS3D_i::importGMFMesh(const char* theGMFFileName)
+SMESH::SMESH_Mesh_ptr HYBRIDPlugin_HYBRID_i::importGMFMesh(const char* theGMFFileName)
{
- MESSAGE( "GHS3DPlugin_GHS3D_i::importGMFMesh" );
+ MESSAGE( "HYBRIDPlugin_HYBRID_i::importGMFMesh" );
SMESH_Gen_i* smeshGen = SMESH_Gen_i::GetSMESHGen();
SMESH::SMESH_Mesh_ptr theMesh = smeshGen->CreateEmptyMesh();
smeshGen->RemoveLastFromPythonScript(smeshGen->GetCurrentStudy()->StudyId());
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// File : GHS3DPlugin_GHS3D_i.hxx
+// File : HYBRIDPlugin_HYBRID_i.hxx
// Author : Edward AGAPOV
-// Module : GHS3DPlugin
+// Module : HYBRIDPlugin
// $Header$
//
-#ifndef _GHS3DPlugin_GHS3D_I_HXX_
-#define _GHS3DPlugin_GHS3D_I_HXX_
+#ifndef _HYBRIDPlugin_HYBRID_I_HXX_
+#define _HYBRIDPlugin_HYBRID_I_HXX_
#include <SALOMEconfig.h>
-#include CORBA_SERVER_HEADER(GHS3DPlugin_Algorithm)
+#include CORBA_SERVER_HEADER(HYBRIDPlugin_Algorithm)
#include CORBA_SERVER_HEADER(SALOME_Exception)
#include "SMESH_3D_Algo_i.hxx"
-#include "GHS3DPlugin_GHS3D.hxx"
+#include "HYBRIDPlugin_HYBRID.hxx"
// ======================================================
-// GHS3D 3d algorithm
+// HYBRID 3d algorithm
// ======================================================
-class GHS3DPlugin_GHS3D_i:
- public virtual POA_GHS3DPlugin::GHS3DPlugin_GHS3D,
+class HYBRIDPlugin_HYBRID_i:
+ public virtual POA_HYBRIDPlugin::HYBRIDPlugin_HYBRID,
public virtual SMESH_3D_Algo_i
{
public:
// Constructor
- GHS3DPlugin_GHS3D_i (PortableServer::POA_ptr thePOA,
+ HYBRIDPlugin_HYBRID_i (PortableServer::POA_ptr thePOA,
int theStudyId,
::SMESH_Gen* theGenImpl );
// Destructor
- virtual ~GHS3DPlugin_GHS3D_i();
+ virtual ~HYBRIDPlugin_HYBRID_i();
// Get implementation
- ::GHS3DPlugin_GHS3D* GetImpl();
+ ::HYBRIDPlugin_HYBRID* GetImpl();
virtual SMESH::SMESH_Mesh_ptr importGMFMesh(const char* theGMFFileName);
};
//
//=============================================================================
-// File : GHS3DPlugin_Hypothesis.cxx
+// File : HYBRIDPlugin_Hypothesis.cxx
// Created : Wed Apr 2 12:36:29 2008
// Author : Edward AGAPOV (eap)
//=============================================================================
//
-#include "GHS3DPlugin_Hypothesis.hxx"
+#include "HYBRIDPlugin_Hypothesis.hxx"
#include <SMESH_ProxyMesh.hxx>
#include <SMESH_Group.hxx>
#include <StdMeshers_QuadToTriaAdaptor.hxx>
#endif
//=======================================================================
-//function : GHS3DPlugin_Hypothesis
+//function : HYBRIDPlugin_Hypothesis
//=======================================================================
-GHS3DPlugin_Hypothesis::GHS3DPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen)
+HYBRIDPlugin_Hypothesis::HYBRIDPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen)
: SMESH_Hypothesis(hypId, studyId, gen),
myToMeshHoles(DefaultMeshHoles()),
myToMakeGroupsOfDomains(DefaultToMakeGroupsOfDomains()),
myToRemoveCentralPoint(DefaultToRemoveCentralPoint()),
myGradation(DefaultGradation()),
myLogInStandardOutput(DefaultStandardOutputLog()),
- _enfVertexList(DefaultGHS3DEnforcedVertexList()),
- _enfVertexCoordsSizeList(DefaultGHS3DEnforcedVertexCoordsValues()),
- _enfVertexEntrySizeList(DefaultGHS3DEnforcedVertexEntryValues()),
- _coordsEnfVertexMap(DefaultCoordsGHS3DEnforcedVertexMap()),
- _geomEntryEnfVertexMap(DefaultGeomEntryGHS3DEnforcedVertexMap()),
- _enfMeshList(DefaultGHS3DEnforcedMeshList()),
- _entryEnfMeshMap(DefaultEntryGHS3DEnforcedMeshListMap()),
+ _enfVertexList(DefaultHYBRIDEnforcedVertexList()),
+ _enfVertexCoordsSizeList(DefaultHYBRIDEnforcedVertexCoordsValues()),
+ _enfVertexEntrySizeList(DefaultHYBRIDEnforcedVertexEntryValues()),
+ _coordsEnfVertexMap(DefaultCoordsHYBRIDEnforcedVertexMap()),
+ _geomEntryEnfVertexMap(DefaultGeomEntryHYBRIDEnforcedVertexMap()),
+ _enfMeshList(DefaultHYBRIDEnforcedMeshList()),
+ _entryEnfMeshMap(DefaultEntryHYBRIDEnforcedMeshListMap()),
_enfNodes(TIDSortedNodeGroupMap()),
_enfEdges(TIDSortedElemGroupMap()),
_enfTriangles(TIDSortedElemGroupMap()),
_nodeIDToSizeMap(DefaultID2SizeMap()),
_groupsToRemove(DefaultGroupsToRemove())
{
- _name = "GHS3D_Parameters";
+ _name = "HYBRID_Parameters";
_param_algo_dim = 3;
}
//function : SetToMeshHoles
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetToMeshHoles(bool toMesh)
+void HYBRIDPlugin_Hypothesis::SetToMeshHoles(bool toMesh)
{
if ( myToMeshHoles != toMesh ) {
myToMeshHoles = toMesh;
//function : GetToMeshHoles
//=======================================================================
-bool GHS3DPlugin_Hypothesis::GetToMeshHoles(bool checkFreeOption) const
+bool HYBRIDPlugin_Hypothesis::GetToMeshHoles(bool checkFreeOption) const
{
if (checkFreeOption && !myTextOption.empty()) {
if ( myTextOption.find("-c 0"))
//function : SetToMakeGroupsOfDomains
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetToMakeGroupsOfDomains(bool toMakeGroups)
+void HYBRIDPlugin_Hypothesis::SetToMakeGroupsOfDomains(bool toMakeGroups)
{
if ( myToMakeGroupsOfDomains != toMakeGroups ) {
myToMakeGroupsOfDomains = toMakeGroups;
//function : GetToMakeGroupsOfDomains
//=======================================================================
-bool GHS3DPlugin_Hypothesis::GetToMakeGroupsOfDomains() const
+bool HYBRIDPlugin_Hypothesis::GetToMakeGroupsOfDomains() const
{
return myToMakeGroupsOfDomains;
}
//function : GetToMakeGroupsOfDomains
//=======================================================================
-bool GHS3DPlugin_Hypothesis::GetToMakeGroupsOfDomains(const GHS3DPlugin_Hypothesis* hyp)
+bool HYBRIDPlugin_Hypothesis::GetToMakeGroupsOfDomains(const HYBRIDPlugin_Hypothesis* hyp)
{
bool res;
if ( hyp ) res = /*hyp->GetToMeshHoles(true) &&*/ hyp->GetToMakeGroupsOfDomains();
//function : SetMaximumMemory
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetMaximumMemory(double MB)
+void HYBRIDPlugin_Hypothesis::SetMaximumMemory(double MB)
{
if ( myMaximumMemory != MB ) {
myMaximumMemory = MB;
// * automatic memory adjustment mode. Default is zero
//=======================================================================
-double GHS3DPlugin_Hypothesis::GetMaximumMemory() const
+double HYBRIDPlugin_Hypothesis::GetMaximumMemory() const
{
return myMaximumMemory;
}
//function : SetInitialMemory
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetInitialMemory(double MB)
+void HYBRIDPlugin_Hypothesis::SetInitialMemory(double MB)
{
if ( myInitialMemory != MB ) {
myInitialMemory = MB;
//function : GetInitialMemory
//=======================================================================
-double GHS3DPlugin_Hypothesis::GetInitialMemory() const
+double HYBRIDPlugin_Hypothesis::GetInitialMemory() const
{
return myInitialMemory;
}
//function : SetOptimizationLevel
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetOptimizationLevel(OptimizationLevel level)
+void HYBRIDPlugin_Hypothesis::SetOptimizationLevel(OptimizationLevel level)
{
if ( myOptimizationLevel != level ) {
myOptimizationLevel = level;
//function : GetOptimizationLevel
//=======================================================================
-GHS3DPlugin_Hypothesis::OptimizationLevel GHS3DPlugin_Hypothesis::GetOptimizationLevel() const
+HYBRIDPlugin_Hypothesis::OptimizationLevel HYBRIDPlugin_Hypothesis::GetOptimizationLevel() const
{
return (OptimizationLevel) myOptimizationLevel;
}
//function : SetWorkingDirectory
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetWorkingDirectory(const std::string& path)
+void HYBRIDPlugin_Hypothesis::SetWorkingDirectory(const std::string& path)
{
if ( myWorkingDirectory != path ) {
myWorkingDirectory = path;
//function : GetWorkingDirectory
//=======================================================================
-std::string GHS3DPlugin_Hypothesis::GetWorkingDirectory() const
+std::string HYBRIDPlugin_Hypothesis::GetWorkingDirectory() const
{
return myWorkingDirectory;
}
//function : SetKeepFiles
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetKeepFiles(bool toKeep)
+void HYBRIDPlugin_Hypothesis::SetKeepFiles(bool toKeep)
{
if ( myKeepFiles != toKeep ) {
myKeepFiles = toKeep;
//function : GetKeepFiles
//=======================================================================
-bool GHS3DPlugin_Hypothesis::GetKeepFiles() const
+bool HYBRIDPlugin_Hypothesis::GetKeepFiles() const
{
return myKeepFiles;
}
//function : SetVerboseLevel
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetVerboseLevel(short level)
+void HYBRIDPlugin_Hypothesis::SetVerboseLevel(short level)
{
if ( myVerboseLevel != level ) {
myVerboseLevel = level;
//function : GetVerboseLevel
//=======================================================================
-short GHS3DPlugin_Hypothesis::GetVerboseLevel() const
+short HYBRIDPlugin_Hypothesis::GetVerboseLevel() const
{
return myVerboseLevel;
}
//function : SetToCreateNewNodes
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetToCreateNewNodes(bool toCreate)
+void HYBRIDPlugin_Hypothesis::SetToCreateNewNodes(bool toCreate)
{
if ( myToCreateNewNodes != toCreate ) {
myToCreateNewNodes = toCreate;
//function : GetToCreateNewNodes
//=======================================================================
-bool GHS3DPlugin_Hypothesis::GetToCreateNewNodes() const
+bool HYBRIDPlugin_Hypothesis::GetToCreateNewNodes() const
{
return myToCreateNewNodes;
}
//function : SetToUseBoundaryRecoveryVersion
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetToUseBoundaryRecoveryVersion(bool toUse)
+void HYBRIDPlugin_Hypothesis::SetToUseBoundaryRecoveryVersion(bool toUse)
{
if ( myToUseBoundaryRecoveryVersion != toUse ) {
myToUseBoundaryRecoveryVersion = toUse;
//function : GetToUseBoundaryRecoveryVersion
//=======================================================================
-bool GHS3DPlugin_Hypothesis::GetToUseBoundaryRecoveryVersion() const
+bool HYBRIDPlugin_Hypothesis::GetToUseBoundaryRecoveryVersion() const
{
return myToUseBoundaryRecoveryVersion;
}
//function : SetFEMCorrection
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetFEMCorrection(bool toUseFem)
+void HYBRIDPlugin_Hypothesis::SetFEMCorrection(bool toUseFem)
{
if ( myToUseFemCorrection != toUseFem ) {
myToUseFemCorrection = toUseFem;
//function : GetFEMCorrection
//=======================================================================
-bool GHS3DPlugin_Hypothesis::GetFEMCorrection() const
+bool HYBRIDPlugin_Hypothesis::GetFEMCorrection() const
{
return myToUseFemCorrection;
}
//function : SetToRemoveCentralPoint
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetToRemoveCentralPoint(bool toRemove)
+void HYBRIDPlugin_Hypothesis::SetToRemoveCentralPoint(bool toRemove)
{
if ( myToRemoveCentralPoint != toRemove ) {
myToRemoveCentralPoint = toRemove;
//function : GetToRemoveCentralPoint
//=======================================================================
-bool GHS3DPlugin_Hypothesis::GetToRemoveCentralPoint() const
+bool HYBRIDPlugin_Hypothesis::GetToRemoveCentralPoint() const
{
return myToRemoveCentralPoint;
}
//function : SetTextOption
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetTextOption(const std::string& option)
+void HYBRIDPlugin_Hypothesis::SetTextOption(const std::string& option)
{
if ( myTextOption != option ) {
myTextOption = option;
//function : GetTextOption
//=======================================================================
-std::string GHS3DPlugin_Hypothesis::GetTextOption() const
+std::string HYBRIDPlugin_Hypothesis::GetTextOption() const
{
return myTextOption;
}
//function : SetGradation
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetGradation(double gradation)
+void HYBRIDPlugin_Hypothesis::SetGradation(double gradation)
{
if ( myGradation != gradation ) {
myGradation = gradation;
//function : GetGradation
//=======================================================================
-double GHS3DPlugin_Hypothesis::GetGradation() const
+double HYBRIDPlugin_Hypothesis::GetGradation() const
{
return myGradation;
}
//function : SetStandardOutputLog
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetStandardOutputLog(bool logInStandardOutput)
+void HYBRIDPlugin_Hypothesis::SetStandardOutputLog(bool logInStandardOutput)
{
if ( myLogInStandardOutput != logInStandardOutput ) {
myLogInStandardOutput = logInStandardOutput;
//function : GetStandardOutputLog
//=======================================================================
-bool GHS3DPlugin_Hypothesis::GetStandardOutputLog() const
+bool HYBRIDPlugin_Hypothesis::GetStandardOutputLog() const
{
return myLogInStandardOutput;
}
//function : SetRemoveLogOnSuccess
//=======================================================================
-void GHS3DPlugin_Hypothesis::SetRemoveLogOnSuccess(bool removeLogOnSuccess)
+void HYBRIDPlugin_Hypothesis::SetRemoveLogOnSuccess(bool removeLogOnSuccess)
{
if ( myRemoveLogOnSuccess != removeLogOnSuccess ) {
myRemoveLogOnSuccess = removeLogOnSuccess;
//function : GetRemoveLogOnSuccess
//=======================================================================
-bool GHS3DPlugin_Hypothesis::GetRemoveLogOnSuccess() const
+bool HYBRIDPlugin_Hypothesis::GetRemoveLogOnSuccess() const
{
return myRemoveLogOnSuccess;
}
//function : SetEnforcedVertex
//=======================================================================
-bool GHS3DPlugin_Hypothesis::SetEnforcedVertex(std::string theName, std::string theEntry, std::string theGroupName,
+bool HYBRIDPlugin_Hypothesis::SetEnforcedVertex(std::string theName, std::string theEntry, std::string theGroupName,
double size, double x, double y, double z, bool isCompound)
{
- MESSAGE("GHS3DPlugin_Hypothesis::SetEnforcedVertex(\""<< theName << "\", \""<< theEntry << "\", \"" << theGroupName << "\", "
+ MESSAGE("HYBRIDPlugin_Hypothesis::SetEnforcedVertex(\""<< theName << "\", \""<< theEntry << "\", \"" << theGroupName << "\", "
<< size << ", " << x << ", " << y << ", " << z << ", "<< isCompound << ")");
bool toNotify = false;
bool toCreate = true;
- TGHS3DEnforcedVertex *oldEnVertex;
- TGHS3DEnforcedVertex *newEnfVertex = new TGHS3DEnforcedVertex();
+ THYBRIDEnforcedVertex *oldEnVertex;
+ THYBRIDEnforcedVertex *newEnfVertex = new THYBRIDEnforcedVertex();
newEnfVertex->name = theName;
newEnfVertex->geomEntry = theEntry;
newEnfVertex->coords.clear();
// update _enfVertexList
- TGHS3DEnforcedVertexList::iterator it = _enfVertexList.find(newEnfVertex);
+ THYBRIDEnforcedVertexList::iterator it = _enfVertexList.find(newEnfVertex);
if (it != _enfVertexList.end()) {
toCreate = false;
oldEnVertex = (*it);
if (toNotify)
NotifySubMeshesHypothesisModification();
- MESSAGE("GHS3DPlugin_Hypothesis::SetEnforcedVertex END");
+ MESSAGE("HYBRIDPlugin_Hypothesis::SetEnforcedVertex END");
return toNotify;
}
//=======================================================================
//function : SetEnforcedMesh
//=======================================================================
-bool GHS3DPlugin_Hypothesis::SetEnforcedMesh(SMESH_Mesh& theMesh, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName)
+bool HYBRIDPlugin_Hypothesis::SetEnforcedMesh(SMESH_Mesh& theMesh, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName)
{
TIDSortedElemSet theElemSet;
SMDS_ElemIteratorPtr eIt = theMesh.GetMeshDS()->elementsIterator(SMDSAbs_ElementType(elementType));
MESSAGE("Add "<<theElemSet.size()<<" types["<<elementType<<"] from source mesh");
bool added = SetEnforcedElements( theElemSet, elementType, groupName);
if (added) {
- TGHS3DEnforcedMesh* newEnfMesh = new TGHS3DEnforcedMesh();
+ THYBRIDEnforcedMesh* newEnfMesh = new THYBRIDEnforcedMesh();
newEnfMesh->persistID = theMesh.GetMeshDS()->GetPersistentId();
newEnfMesh->name = name;
newEnfMesh->entry = entry;
newEnfMesh->elementType = elementType;
newEnfMesh->groupName = groupName;
- TGHS3DEnforcedMeshList::iterator it = _enfMeshList.find(newEnfMesh);
+ THYBRIDEnforcedMeshList::iterator it = _enfMeshList.find(newEnfMesh);
if (it == _enfMeshList.end()) {
_entryEnfMeshMap[entry].insert(newEnfMesh);
_enfMeshList.insert(newEnfMesh);
//=======================================================================
//function : SetEnforcedGroup
//=======================================================================
-bool GHS3DPlugin_Hypothesis::SetEnforcedGroup(const SMESHDS_Mesh* theMeshDS, SMESH::long_array_var theIDs, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName)
+bool HYBRIDPlugin_Hypothesis::SetEnforcedGroup(const SMESHDS_Mesh* theMeshDS, SMESH::long_array_var theIDs, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName)
{
- MESSAGE("GHS3DPlugin_Hypothesis::SetEnforcedGroup");
+ MESSAGE("HYBRIDPlugin_Hypothesis::SetEnforcedGroup");
TIDSortedElemSet theElemSet;
if ( theIDs->length() == 0 ){MESSAGE("The source group is empty");}
for (int i=0; i < theIDs->length(); i++) {
MESSAGE("Add "<<theElemSet.size()<<" types["<<elementType<<"] from source group ");
bool added = SetEnforcedElements( theElemSet, elementType, groupName);
if (added) {
- TGHS3DEnforcedMesh* newEnfMesh = new TGHS3DEnforcedMesh();
+ THYBRIDEnforcedMesh* newEnfMesh = new THYBRIDEnforcedMesh();
newEnfMesh->name = name;
newEnfMesh->entry = entry;
newEnfMesh->elementType = elementType;
newEnfMesh->groupName = groupName;
- TGHS3DEnforcedMeshList::iterator it = _enfMeshList.find(newEnfMesh);
+ THYBRIDEnforcedMeshList::iterator it = _enfMeshList.find(newEnfMesh);
if (it == _enfMeshList.end()) {
_entryEnfMeshMap[entry].insert(newEnfMesh);
_enfMeshList.insert(newEnfMesh);
//=======================================================================
//function : SetEnforcedElements
//=======================================================================
-bool GHS3DPlugin_Hypothesis::SetEnforcedElements(TIDSortedElemSet theElemSet, SMESH::ElementType elementType, std::string groupName)
+bool HYBRIDPlugin_Hypothesis::SetEnforcedElements(TIDSortedElemSet theElemSet, SMESH::ElementType elementType, std::string groupName)
{
- MESSAGE("GHS3DPlugin_Hypothesis::SetEnforcedElements");
+ MESSAGE("HYBRIDPlugin_Hypothesis::SetEnforcedElements");
TIDSortedElemSet::const_iterator it = theElemSet.begin();
const SMDS_MeshElement* elem;
const SMDS_MeshNode* node;
//function : GetEnforcedVertex
//=======================================================================
-GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex* GHS3DPlugin_Hypothesis::GetEnforcedVertex(double x, double y, double z)
+HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* HYBRIDPlugin_Hypothesis::GetEnforcedVertex(double x, double y, double z)
throw (std::invalid_argument)
{
std::vector<double> coord(3);
throw std::invalid_argument(msg.str());
}
-GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex* GHS3DPlugin_Hypothesis::GetEnforcedVertex(const std::string theEntry)
+HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* HYBRIDPlugin_Hypothesis::GetEnforcedVertex(const std::string theEntry)
throw (std::invalid_argument)
{
if (_geomEntryEnfVertexMap.count(theEntry)>0)
//function : RemoveEnforcedVertex
//=======================================================================
-bool GHS3DPlugin_Hypothesis::RemoveEnforcedVertex(double x, double y, double z, const std::string theEntry)
+bool HYBRIDPlugin_Hypothesis::RemoveEnforcedVertex(double x, double y, double z, const std::string theEntry)
throw (std::invalid_argument)
{
bool toNotify = false;
std::ostringstream msg;
- TGHS3DEnforcedVertex *oldEnfVertex;
+ THYBRIDEnforcedVertex *oldEnfVertex;
std::vector<double> coords(3);
coords[0] = x;
coords[1] = y;
coords[2] = z;
// check that enf vertex with given enf vertex entry exists
- TGeomEntryGHS3DEnforcedVertexMap::iterator it_enfVertexEntry = _geomEntryEnfVertexMap.find(theEntry);
+ TGeomEntryHYBRIDEnforcedVertexMap::iterator it_enfVertexEntry = _geomEntryEnfVertexMap.find(theEntry);
if (it_enfVertexEntry != _geomEntryEnfVertexMap.end()) {
// Success
MESSAGE("Found enforced vertex with geom entry " << theEntry);
// Fail
MESSAGE("Enforced vertex with geom entry " << theEntry << " not found");
// check that enf vertex with given coords exists
- TCoordsGHS3DEnforcedVertexMap::iterator it_coords_enf = _coordsEnfVertexMap.find(coords);
+ TCoordsHYBRIDEnforcedVertexMap::iterator it_coords_enf = _coordsEnfVertexMap.find(coords);
if (it_coords_enf != _coordsEnfVertexMap.end()) {
// Success
MESSAGE("Found enforced vertex with coords " << x << ", " << y << ", " << z);
MESSAGE("Remove enf vertex from _enfVertexList");
// update _enfVertexList
- TGHS3DEnforcedVertexList::iterator it = _enfVertexList.find(oldEnfVertex);
+ THYBRIDEnforcedVertexList::iterator it = _enfVertexList.find(oldEnfVertex);
if (it != _enfVertexList.end()) {
if ((*it)->groupName != "")
_groupsToRemove.insert((*it)->groupName);
//=======================================================================
//function : ClearEnforcedVertices
//=======================================================================
-void GHS3DPlugin_Hypothesis::ClearEnforcedVertices()
+void HYBRIDPlugin_Hypothesis::ClearEnforcedVertices()
{
- TGHS3DEnforcedVertexList::const_iterator it = _enfVertexList.begin();
+ THYBRIDEnforcedVertexList::const_iterator it = _enfVertexList.begin();
for(;it != _enfVertexList.end();++it) {
if ((*it)->groupName != "")
_groupsToRemove.insert((*it)->groupName);
//=======================================================================
//function : ClearEnforcedMeshes
//=======================================================================
-void GHS3DPlugin_Hypothesis::ClearEnforcedMeshes()
+void HYBRIDPlugin_Hypothesis::ClearEnforcedMeshes()
{
- TGHS3DEnforcedMeshList::const_iterator it = _enfMeshList.begin();
+ THYBRIDEnforcedMeshList::const_iterator it = _enfMeshList.begin();
for(;it != _enfMeshList.end();++it) {
if ((*it)->groupName != "")
_groupsToRemove.insert((*it)->groupName);
*/
//================================================================================
-void GHS3DPlugin_Hypothesis::RestoreEnfElemsByMeshes()
+void HYBRIDPlugin_Hypothesis::RestoreEnfElemsByMeshes()
{
- TGHS3DEnforcedMeshList::const_iterator it = _enfMeshList.begin();
+ THYBRIDEnforcedMeshList::const_iterator it = _enfMeshList.begin();
for(;it != _enfMeshList.end();++it) {
- TGHS3DEnforcedMesh* enfMesh = *it;
+ THYBRIDEnforcedMesh* enfMesh = *it;
if ( SMESH_Mesh* mesh = GetMeshByPersistentID( enfMesh->persistID ))
SetEnforcedMesh( *mesh,
enfMesh->elementType,
//function : SetGroupsToRemove
//=======================================================================
-void GHS3DPlugin_Hypothesis::ClearGroupsToRemove()
+void HYBRIDPlugin_Hypothesis::ClearGroupsToRemove()
{
_groupsToRemove.clear();
}
//function : DefaultMeshHoles
//=======================================================================
-bool GHS3DPlugin_Hypothesis::DefaultMeshHoles()
+bool HYBRIDPlugin_Hypothesis::DefaultMeshHoles()
{
return false; // PAL19680
}
//function : DefaultToMakeGroupsOfDomains
//=======================================================================
-bool GHS3DPlugin_Hypothesis::DefaultToMakeGroupsOfDomains()
+bool HYBRIDPlugin_Hypothesis::DefaultToMakeGroupsOfDomains()
{
return false; // issue 0022172
}
#include <windows.h>
#endif
-double GHS3DPlugin_Hypothesis::DefaultMaximumMemory()
+double HYBRIDPlugin_Hypothesis::DefaultMaximumMemory()
{
#ifndef WIN32
struct sysinfo si;
//function : DefaultInitialMemory
//=======================================================================
-double GHS3DPlugin_Hypothesis::DefaultInitialMemory()
+double HYBRIDPlugin_Hypothesis::DefaultInitialMemory()
{
return DefaultMaximumMemory();
}
//function : DefaultOptimizationLevel
//=======================================================================
-short GHS3DPlugin_Hypothesis::DefaultOptimizationLevel()
+short HYBRIDPlugin_Hypothesis::DefaultOptimizationLevel()
{
return Medium;
}
//function : DefaultWorkingDirectory
//=======================================================================
-std::string GHS3DPlugin_Hypothesis::DefaultWorkingDirectory()
+std::string HYBRIDPlugin_Hypothesis::DefaultWorkingDirectory()
{
TCollection_AsciiString aTmpDir;
//function : DefaultKeepFiles
//=======================================================================
-bool GHS3DPlugin_Hypothesis::DefaultKeepFiles()
+bool HYBRIDPlugin_Hypothesis::DefaultKeepFiles()
{
return false;
}
//function : DefaultRemoveLogOnSuccess
//=======================================================================
-bool GHS3DPlugin_Hypothesis::DefaultRemoveLogOnSuccess()
+bool HYBRIDPlugin_Hypothesis::DefaultRemoveLogOnSuccess()
{
return false;
}
//function : DefaultVerboseLevel
//=======================================================================
-short GHS3DPlugin_Hypothesis::DefaultVerboseLevel()
+short HYBRIDPlugin_Hypothesis::DefaultVerboseLevel()
{
return 10;
}
//function : DefaultToCreateNewNodes
//=======================================================================
-bool GHS3DPlugin_Hypothesis::DefaultToCreateNewNodes()
+bool HYBRIDPlugin_Hypothesis::DefaultToCreateNewNodes()
{
return true;
}
//function : DefaultToUseBoundaryRecoveryVersion
//=======================================================================
-bool GHS3DPlugin_Hypothesis::DefaultToUseBoundaryRecoveryVersion()
+bool HYBRIDPlugin_Hypothesis::DefaultToUseBoundaryRecoveryVersion()
{
return false;
}
//function : DefaultToUseFEMCorrection
//=======================================================================
-bool GHS3DPlugin_Hypothesis::DefaultToUseFEMCorrection()
+bool HYBRIDPlugin_Hypothesis::DefaultToUseFEMCorrection()
{
return false;
}
//function : DefaultToRemoveCentralPoint
//=======================================================================
-bool GHS3DPlugin_Hypothesis::DefaultToRemoveCentralPoint()
+bool HYBRIDPlugin_Hypothesis::DefaultToRemoveCentralPoint()
{
return false;
}
//function : DefaultGradation
//=======================================================================
-double GHS3DPlugin_Hypothesis::DefaultGradation()
+double HYBRIDPlugin_Hypothesis::DefaultGradation()
{
return 1.05;
}
//function : DefaultStandardOutputLog
//=======================================================================
-bool GHS3DPlugin_Hypothesis::DefaultStandardOutputLog()
+bool HYBRIDPlugin_Hypothesis::DefaultStandardOutputLog()
{
return false;
}
// //function : DefaultID2SizeMap
// //=======================================================================
//
-// GHS3DPlugin_Hypothesis::TID2SizeMap GHS3DPlugin_Hypothesis::DefaultID2SizeMap()
+// HYBRIDPlugin_Hypothesis::TID2SizeMap HYBRIDPlugin_Hypothesis::DefaultID2SizeMap()
// {
-// return GHS3DPlugin_Hypothesis::TID2SizeMap();
+// return HYBRIDPlugin_Hypothesis::TID2SizeMap();
// }
//function : SaveTo
//=======================================================================
-std::ostream & GHS3DPlugin_Hypothesis::SaveTo(std::ostream & save)
+std::ostream & HYBRIDPlugin_Hypothesis::SaveTo(std::ostream & save)
{
save << (int) myToMeshHoles << " ";
save << myMaximumMemory << " ";
}
- TGHS3DEnforcedVertexList::iterator it = _enfVertexList.begin();
+ THYBRIDEnforcedVertexList::iterator it = _enfVertexList.begin();
if (it != _enfVertexList.end()) {
save << " " << "__ENFORCED_VERTICES_BEGIN__ ";
for ( ; it != _enfVertexList.end(); ++it ) {
- TGHS3DEnforcedVertex *enfVertex = (*it);
+ THYBRIDEnforcedVertex *enfVertex = (*it);
save << " " << "__BEGIN_VERTEX__";
if (!enfVertex->name.empty()) {
save << " " << "__BEGIN_NAME__";
save << " " << "__ENFORCED_VERTICES_END__ ";
}
- TGHS3DEnforcedMeshList::iterator it_mesh = _enfMeshList.begin();
+ THYBRIDEnforcedMeshList::iterator it_mesh = _enfMeshList.begin();
if (it_mesh != _enfMeshList.end()) {
save << " " << "__ENFORCED_MESHES_BEGIN__ ";
for ( ; it_mesh != _enfMeshList.end(); ++it_mesh ) {
- TGHS3DEnforcedMesh *enfMesh = (*it_mesh);
+ THYBRIDEnforcedMesh *enfMesh = (*it_mesh);
save << " " << "__BEGIN_ENF_MESH__";
save << " " << "__BEGIN_NAME__";
//function : LoadFrom
//=======================================================================
-std::istream & GHS3DPlugin_Hypothesis::LoadFrom(std::istream & load)
+std::istream & HYBRIDPlugin_Hypothesis::LoadFrom(std::istream & load)
{
bool isOK = true;
int i;
if (txt == "__ENFORCED_VERTICES_END__")
isOK = false;
- TGHS3DEnforcedVertex *enfVertex = new TGHS3DEnforcedVertex();
+ THYBRIDEnforcedVertex *enfVertex = new THYBRIDEnforcedVertex();
while (isOK) {
isOK = (load >> txt);
if (txt == "__END_VERTEX__") {
if (txt == "__ENFORCED_MESHES_END__")
isOK = false;
- TGHS3DEnforcedMesh *enfMesh = new TGHS3DEnforcedMesh();
+ THYBRIDEnforcedMesh *enfMesh = new THYBRIDEnforcedMesh();
while (isOK) {
isOK = (load >> txt);
if (txt == "__END_ENF_MESH__") {
//function : SetParametersByMesh
//=======================================================================
-bool GHS3DPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh* ,const TopoDS_Shape&)
+bool HYBRIDPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh* ,const TopoDS_Shape&)
{
return false;
}
*/
//================================================================================
-bool GHS3DPlugin_Hypothesis::SetParametersByDefaults(const TDefaults& dflts,
+bool HYBRIDPlugin_Hypothesis::SetParametersByDefaults(const TDefaults& dflts,
const SMESH_Mesh* /*theMesh*/)
{
myToMakeGroupsOfDomains = ( !dflts._shape || dflts._shape->IsNull() );
//================================================================================
/*!
- * \brief Return command to run ghs3d mesher excluding file prefix (-f)
+ * \brief Return command to run hybrid mesher excluding file prefix (-f)
*/
//================================================================================
-std::string GHS3DPlugin_Hypothesis::CommandToRun(const GHS3DPlugin_Hypothesis* hyp,
+std::string HYBRIDPlugin_Hypothesis::CommandToRun(const HYBRIDPlugin_Hypothesis* hyp,
const bool hasShapeToMesh)
{
TCollection_AsciiString cmd = GetExeName().c_str();
if ( !useBndRecovery && hyp )
useBndRecovery = hyp->myToUseBoundaryRecoveryVersion;
- // ghs3d needs to know amount of memory it may use (MB).
- // Default memory is defined at ghs3d installation but it may be not enough,
+ // hybrid needs to know amount of memory it may use (MB).
+ // Default memory is defined at hybrid installation but it may be not enough,
// so allow to use about all available memory
if ( m ) {
double aMaximumMemory = hyp ? hyp->myMaximumMemory : -1;
// 0 , all components to be meshed
// 1 , only the main ( outermost ) component to be meshed
if ( c && !useBndRecovery ) {
- // We always run GHS3D with "to mesh holes'==TRUE (see PAL19680)
+ // We always run HYBRID with "to mesh holes'==TRUE (see PAL19680)
if ( hasShapeToMesh )
cmd += " -c 0";
else {
*/
//================================================================================
-std::string GHS3DPlugin_Hypothesis::GetFileName(const GHS3DPlugin_Hypothesis* hyp)
+std::string HYBRIDPlugin_Hypothesis::GetFileName(const HYBRIDPlugin_Hypothesis* hyp)
{
std::string aTmpDir = hyp ? hyp->GetWorkingDirectory() : DefaultWorkingDirectory();
const char lastChar = *aTmpDir.rbegin();
#endif
TCollection_AsciiString aGenericName = (char*)aTmpDir.c_str();
- aGenericName += "GHS3D_";
+ aGenericName += "HYBRID_";
aGenericName += getpid();
aGenericName += "_";
aGenericName += Abs((Standard_Integer)(long) aGenericName.ToCString());
*/
//================================================================================
-std::string GHS3DPlugin_Hypothesis::GetExeName()
+std::string HYBRIDPlugin_Hypothesis::GetExeName()
{
return "mg-tetra.exe";
}
*/
//================================================================================
-GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList GHS3DPlugin_Hypothesis::GetEnforcedVertices(const GHS3DPlugin_Hypothesis* hyp)
+HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexList HYBRIDPlugin_Hypothesis::GetEnforcedVertices(const HYBRIDPlugin_Hypothesis* hyp)
{
- return hyp ? hyp->_GetEnforcedVertices():DefaultGHS3DEnforcedVertexList();
+ return hyp ? hyp->_GetEnforcedVertices():DefaultHYBRIDEnforcedVertexList();
}
-GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexCoordsValues GHS3DPlugin_Hypothesis::GetEnforcedVerticesCoordsSize (const GHS3DPlugin_Hypothesis* hyp)
+HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexCoordsValues HYBRIDPlugin_Hypothesis::GetEnforcedVerticesCoordsSize (const HYBRIDPlugin_Hypothesis* hyp)
{
- return hyp ? hyp->_GetEnforcedVerticesCoordsSize(): DefaultGHS3DEnforcedVertexCoordsValues();
+ return hyp ? hyp->_GetEnforcedVerticesCoordsSize(): DefaultHYBRIDEnforcedVertexCoordsValues();
}
-GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexEntryValues GHS3DPlugin_Hypothesis::GetEnforcedVerticesEntrySize (const GHS3DPlugin_Hypothesis* hyp)
+HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexEntryValues HYBRIDPlugin_Hypothesis::GetEnforcedVerticesEntrySize (const HYBRIDPlugin_Hypothesis* hyp)
{
- return hyp ? hyp->_GetEnforcedVerticesEntrySize(): DefaultGHS3DEnforcedVertexEntryValues();
+ return hyp ? hyp->_GetEnforcedVerticesEntrySize(): DefaultHYBRIDEnforcedVertexEntryValues();
}
-GHS3DPlugin_Hypothesis::TCoordsGHS3DEnforcedVertexMap GHS3DPlugin_Hypothesis::GetEnforcedVerticesByCoords (const GHS3DPlugin_Hypothesis* hyp)
+HYBRIDPlugin_Hypothesis::TCoordsHYBRIDEnforcedVertexMap HYBRIDPlugin_Hypothesis::GetEnforcedVerticesByCoords (const HYBRIDPlugin_Hypothesis* hyp)
{
- return hyp ? hyp->_GetEnforcedVerticesByCoords(): DefaultCoordsGHS3DEnforcedVertexMap();
+ return hyp ? hyp->_GetEnforcedVerticesByCoords(): DefaultCoordsHYBRIDEnforcedVertexMap();
}
-GHS3DPlugin_Hypothesis::TGeomEntryGHS3DEnforcedVertexMap GHS3DPlugin_Hypothesis::GetEnforcedVerticesByEntry (const GHS3DPlugin_Hypothesis* hyp)
+HYBRIDPlugin_Hypothesis::TGeomEntryHYBRIDEnforcedVertexMap HYBRIDPlugin_Hypothesis::GetEnforcedVerticesByEntry (const HYBRIDPlugin_Hypothesis* hyp)
{
- return hyp ? hyp->_GetEnforcedVerticesByEntry(): DefaultGeomEntryGHS3DEnforcedVertexMap();
+ return hyp ? hyp->_GetEnforcedVerticesByEntry(): DefaultGeomEntryHYBRIDEnforcedVertexMap();
}
-GHS3DPlugin_Hypothesis::TIDSortedNodeGroupMap GHS3DPlugin_Hypothesis::GetEnforcedNodes(const GHS3DPlugin_Hypothesis* hyp)
+HYBRIDPlugin_Hypothesis::TIDSortedNodeGroupMap HYBRIDPlugin_Hypothesis::GetEnforcedNodes(const HYBRIDPlugin_Hypothesis* hyp)
{
return hyp ? hyp->_GetEnforcedNodes():DefaultIDSortedNodeGroupMap();
}
-GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap GHS3DPlugin_Hypothesis::GetEnforcedEdges(const GHS3DPlugin_Hypothesis* hyp)
+HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap HYBRIDPlugin_Hypothesis::GetEnforcedEdges(const HYBRIDPlugin_Hypothesis* hyp)
{
return hyp ? hyp->_GetEnforcedEdges():DefaultIDSortedElemGroupMap();
}
-GHS3DPlugin_Hypothesis::TIDSortedElemGroupMap GHS3DPlugin_Hypothesis::GetEnforcedTriangles(const GHS3DPlugin_Hypothesis* hyp)
+HYBRIDPlugin_Hypothesis::TIDSortedElemGroupMap HYBRIDPlugin_Hypothesis::GetEnforcedTriangles(const HYBRIDPlugin_Hypothesis* hyp)
{
return hyp ? hyp->_GetEnforcedTriangles():DefaultIDSortedElemGroupMap();
}
-GHS3DPlugin_Hypothesis::TID2SizeMap GHS3DPlugin_Hypothesis::GetNodeIDToSizeMap(const GHS3DPlugin_Hypothesis* hyp)
+HYBRIDPlugin_Hypothesis::TID2SizeMap HYBRIDPlugin_Hypothesis::GetNodeIDToSizeMap(const HYBRIDPlugin_Hypothesis* hyp)
{
return hyp ? hyp->_GetNodeIDToSizeMap(): DefaultID2SizeMap();
}
-GHS3DPlugin_Hypothesis::TSetStrings GHS3DPlugin_Hypothesis::GetGroupsToRemove(const GHS3DPlugin_Hypothesis* hyp)
+HYBRIDPlugin_Hypothesis::TSetStrings HYBRIDPlugin_Hypothesis::GetGroupsToRemove(const HYBRIDPlugin_Hypothesis* hyp)
{
return hyp ? hyp->_GetGroupsToRemove(): DefaultGroupsToRemove();
}
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// GHS3DPlugin : C++ implementation
-// File : GHS3DPlugin_Hypothesis.hxx
+// HYBRIDPlugin : C++ implementation
+// File : HYBRIDPlugin_Hypothesis.hxx
// Created : Wed Apr 2 12:21:17 2008
// Author : Edward AGAPOV (eap)
//
-#ifndef GHS3DPlugin_Hypothesis_HeaderFile
-#define GHS3DPlugin_Hypothesis_HeaderFile
+#ifndef HYBRIDPlugin_Hypothesis_HeaderFile
+#define HYBRIDPlugin_Hypothesis_HeaderFile
-#include "GHS3DPlugin_Defs.hxx"
+#include "HYBRIDPlugin_Defs.hxx"
#include <SMDS_MeshNode.hxx>
#include <vector>
#include <cstdio>
-class GHS3DPLUGIN_EXPORT GHS3DPlugin_Hypothesis: public SMESH_Hypothesis
+class HYBRIDPLUGIN_EXPORT HYBRIDPlugin_Hypothesis: public SMESH_Hypothesis
{
public:
- GHS3DPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen);
+ HYBRIDPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen * gen);
- typedef std::map<std::vector<double>,double> TGHS3DEnforcedVertexCoordsValues;
- typedef std::map<std::string,double> TGHS3DEnforcedVertexEntryValues;
+ typedef std::map<std::vector<double>,double> THYBRIDEnforcedVertexCoordsValues;
+ typedef std::map<std::string,double> THYBRIDEnforcedVertexEntryValues;
- struct TGHS3DEnforcedVertex {
+ struct THYBRIDEnforcedVertex {
std::string name;
std::string geomEntry;
bool isCompound;
double size;
};
- struct CompareGHS3DEnforcedVertex {
- bool operator () (const TGHS3DEnforcedVertex* e1, const TGHS3DEnforcedVertex* e2) const {
+ struct CompareHYBRIDEnforcedVertex {
+ bool operator () (const THYBRIDEnforcedVertex* e1, const THYBRIDEnforcedVertex* e2) const {
if (e1 && e2) {
if (e1->coords.size() && e2->coords.size())
return (e1->coords < e2->coords);
return false;
}
};
- typedef std::set< TGHS3DEnforcedVertex*, CompareGHS3DEnforcedVertex > TGHS3DEnforcedVertexList;
+ typedef std::set< THYBRIDEnforcedVertex*, CompareHYBRIDEnforcedVertex > THYBRIDEnforcedVertexList;
// Map Coords / Enforced node
- typedef std::map< std::vector<double>, TGHS3DEnforcedVertex* > TCoordsGHS3DEnforcedVertexMap;
+ typedef std::map< std::vector<double>, THYBRIDEnforcedVertex* > TCoordsHYBRIDEnforcedVertexMap;
// Map geom entry / Enforced node
- typedef std::map< std::string, TGHS3DEnforcedVertex* > TGeomEntryGHS3DEnforcedVertexMap;
+ typedef std::map< std::string, THYBRIDEnforcedVertex* > TGeomEntryHYBRIDEnforcedVertexMap;
// Map groupName / Enforced node
- typedef std::map< std::string, TGHS3DEnforcedVertexList > TGroupNameGHS3DEnforcedVertexMap;
+ typedef std::map< std::string, THYBRIDEnforcedVertexList > TGroupNameHYBRIDEnforcedVertexMap;
////////////////////
// Enforced meshes
////////////////////
- struct TGHS3DEnforcedMesh {
+ struct THYBRIDEnforcedMesh {
int persistID;
std::string name;
std::string entry;
SMESH::ElementType elementType;
};
- struct CompareGHS3DEnforcedMesh {
- bool operator () (const TGHS3DEnforcedMesh* e1, const TGHS3DEnforcedMesh* e2) const {
+ struct CompareHYBRIDEnforcedMesh {
+ bool operator () (const THYBRIDEnforcedMesh* e1, const THYBRIDEnforcedMesh* e2) const {
if (e1 && e2) {
if (e1->entry == e2->entry)
return (e1->elementType < e2->elementType);
return false;
}
};
- typedef std::set< TGHS3DEnforcedMesh*, CompareGHS3DEnforcedMesh > TGHS3DEnforcedMeshList;
+ typedef std::set< THYBRIDEnforcedMesh*, CompareHYBRIDEnforcedMesh > THYBRIDEnforcedMeshList;
// Map mesh entry / Enforced mesh list
// ex: 0:1:2:1 -> [ ("Mesh_1", "0:1:2:1", TopAbs_NODE, ""),
// ("Mesh_1", "0:1:2:1", TopAbs_EDGE, "edge group")]
- typedef std::map< std::string, TGHS3DEnforcedMeshList > TEntryGHS3DEnforcedMeshListMap;
+ typedef std::map< std::string, THYBRIDEnforcedMeshList > TEntryHYBRIDEnforcedMeshListMap;
typedef std::map<int,double> TID2SizeMap;
typedef std::map<const SMDS_MeshNode*, std::string, TIDMeshIDCompare > TIDSortedNodeGroupMap;
typedef std::set<std::string> TSetStrings;
- static const char* GetHypType() { return "GHS3D_Parameters"; }
+ static const char* GetHypType() { return "HYBRID_Parameters"; }
/*!
* To mesh "holes" in a solid or not. Default is to mesh.
*/
/*!
- * \brief Return command to run ghs3d mesher excluding file prefix (-f)
+ * \brief Return command to run hybrid mesher excluding file prefix (-f)
*/
- static std::string CommandToRun(const GHS3DPlugin_Hypothesis* hyp,
+ static std::string CommandToRun(const HYBRIDPlugin_Hypothesis* hyp,
const bool hasShapeToMesh=true);
/*!
* \brief Return a unique file name
*/
- static std::string GetFileName(const GHS3DPlugin_Hypothesis* hyp);
+ static std::string GetFileName(const HYBRIDPlugin_Hypothesis* hyp);
/*!
* \brief Return the name of executable
*/
*/
bool SetEnforcedVertex(std::string aName, std::string anEntry, std::string aGroupName,
double size, double x=0.0, double y=0.0, double z=0.0, bool isCompound = false);
- TGHS3DEnforcedVertex* GetEnforcedVertex(double x, double y, double z) throw (std::invalid_argument);
- TGHS3DEnforcedVertex* GetEnforcedVertex(const std::string anEntry) throw (std::invalid_argument);
+ THYBRIDEnforcedVertex* GetEnforcedVertex(double x, double y, double z) throw (std::invalid_argument);
+ THYBRIDEnforcedVertex* GetEnforcedVertex(const std::string anEntry) throw (std::invalid_argument);
bool RemoveEnforcedVertex(double x=0.0, double y=0.0, double z=0.0, const std::string anEntry="" ) throw (std::invalid_argument);
- const TGHS3DEnforcedVertexCoordsValues _GetEnforcedVerticesCoordsSize() const {return _enfVertexCoordsSizeList; }
- const TGHS3DEnforcedVertexEntryValues _GetEnforcedVerticesEntrySize() const {return _enfVertexEntrySizeList; }
- const TGHS3DEnforcedVertexList _GetEnforcedVertices() const { return _enfVertexList; }
- const TCoordsGHS3DEnforcedVertexMap _GetEnforcedVerticesByCoords() const { return _coordsEnfVertexMap; }
- const TGeomEntryGHS3DEnforcedVertexMap _GetEnforcedVerticesByEntry() const { return _geomEntryEnfVertexMap; }
+ const THYBRIDEnforcedVertexCoordsValues _GetEnforcedVerticesCoordsSize() const {return _enfVertexCoordsSizeList; }
+ const THYBRIDEnforcedVertexEntryValues _GetEnforcedVerticesEntrySize() const {return _enfVertexEntrySizeList; }
+ const THYBRIDEnforcedVertexList _GetEnforcedVertices() const { return _enfVertexList; }
+ const TCoordsHYBRIDEnforcedVertexMap _GetEnforcedVerticesByCoords() const { return _coordsEnfVertexMap; }
+ const TGeomEntryHYBRIDEnforcedVertexMap _GetEnforcedVerticesByEntry() const { return _geomEntryEnfVertexMap; }
void ClearEnforcedVertices();
/*!
bool SetEnforcedMesh(SMESH_Mesh& theMesh, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName = "");
bool SetEnforcedGroup(const SMESHDS_Mesh* theMeshDS, SMESH::long_array_var theIDs, SMESH::ElementType elementType, std::string name, std::string entry, std::string groupName = "");
bool SetEnforcedElements(TIDSortedElemSet theElemSet, SMESH::ElementType elementType, std::string groupName = "");
- const TGHS3DEnforcedMeshList _GetEnforcedMeshes() const { return _enfMeshList; }
- const TEntryGHS3DEnforcedMeshListMap _GetEnforcedMeshesByEntry() const { return _entryEnfMeshMap; }
+ const THYBRIDEnforcedMeshList _GetEnforcedMeshes() const { return _enfMeshList; }
+ const TEntryHYBRIDEnforcedMeshListMap _GetEnforcedMeshesByEntry() const { return _entryEnfMeshMap; }
void ClearEnforcedMeshes();
const TIDSortedNodeGroupMap _GetEnforcedNodes() const { return _enfNodes; }
const TIDSortedElemGroupMap _GetEnforcedEdges() const { return _enfEdges; }
/*!
* \brief Return the enforced vertices
*/
- static TGHS3DEnforcedVertexList GetEnforcedVertices(const GHS3DPlugin_Hypothesis* hyp);
- static TGHS3DEnforcedVertexCoordsValues GetEnforcedVerticesCoordsSize(const GHS3DPlugin_Hypothesis* hyp);
- static TGHS3DEnforcedVertexEntryValues GetEnforcedVerticesEntrySize(const GHS3DPlugin_Hypothesis* hyp);
- static TCoordsGHS3DEnforcedVertexMap GetEnforcedVerticesByCoords(const GHS3DPlugin_Hypothesis* hyp);
- static TGeomEntryGHS3DEnforcedVertexMap GetEnforcedVerticesByEntry(const GHS3DPlugin_Hypothesis* hyp);
+ static THYBRIDEnforcedVertexList GetEnforcedVertices(const HYBRIDPlugin_Hypothesis* hyp);
+ static THYBRIDEnforcedVertexCoordsValues GetEnforcedVerticesCoordsSize(const HYBRIDPlugin_Hypothesis* hyp);
+ static THYBRIDEnforcedVertexEntryValues GetEnforcedVerticesEntrySize(const HYBRIDPlugin_Hypothesis* hyp);
+ static TCoordsHYBRIDEnforcedVertexMap GetEnforcedVerticesByCoords(const HYBRIDPlugin_Hypothesis* hyp);
+ static TGeomEntryHYBRIDEnforcedVertexMap GetEnforcedVerticesByEntry(const HYBRIDPlugin_Hypothesis* hyp);
- static TGHS3DEnforcedMeshList GetEnforcedMeshes(const GHS3DPlugin_Hypothesis* hyp);
- static TEntryGHS3DEnforcedMeshListMap GetEnforcedMeshesByEntry(const GHS3DPlugin_Hypothesis* hyp);
- static TIDSortedNodeGroupMap GetEnforcedNodes(const GHS3DPlugin_Hypothesis* hyp);
- static TIDSortedElemGroupMap GetEnforcedEdges(const GHS3DPlugin_Hypothesis* hyp);
- static TIDSortedElemGroupMap GetEnforcedTriangles(const GHS3DPlugin_Hypothesis* hyp);
- static TID2SizeMap GetNodeIDToSizeMap(const GHS3DPlugin_Hypothesis* hyp);
- static TSetStrings GetGroupsToRemove(const GHS3DPlugin_Hypothesis* hyp);
- static bool GetToMakeGroupsOfDomains(const GHS3DPlugin_Hypothesis* hyp);
+ static THYBRIDEnforcedMeshList GetEnforcedMeshes(const HYBRIDPlugin_Hypothesis* hyp);
+ static TEntryHYBRIDEnforcedMeshListMap GetEnforcedMeshesByEntry(const HYBRIDPlugin_Hypothesis* hyp);
+ static TIDSortedNodeGroupMap GetEnforcedNodes(const HYBRIDPlugin_Hypothesis* hyp);
+ static TIDSortedElemGroupMap GetEnforcedEdges(const HYBRIDPlugin_Hypothesis* hyp);
+ static TIDSortedElemGroupMap GetEnforcedTriangles(const HYBRIDPlugin_Hypothesis* hyp);
+ static TID2SizeMap GetNodeIDToSizeMap(const HYBRIDPlugin_Hypothesis* hyp);
+ static TSetStrings GetGroupsToRemove(const HYBRIDPlugin_Hypothesis* hyp);
+ static bool GetToMakeGroupsOfDomains(const HYBRIDPlugin_Hypothesis* hyp);
void ClearGroupsToRemove();
static bool DefaultMeshHoles();
static bool DefaultRemoveLogOnSuccess();
static double DefaultGradation();
- static TGHS3DEnforcedVertex DefaultGHS3DEnforcedVertex() {return TGHS3DEnforcedVertex();}
- static TGHS3DEnforcedVertexList DefaultGHS3DEnforcedVertexList() {return TGHS3DEnforcedVertexList();}
- static TGHS3DEnforcedVertexCoordsValues DefaultGHS3DEnforcedVertexCoordsValues() {return TGHS3DEnforcedVertexCoordsValues();}
- static TGHS3DEnforcedVertexEntryValues DefaultGHS3DEnforcedVertexEntryValues() {return TGHS3DEnforcedVertexEntryValues();}
- static TCoordsGHS3DEnforcedVertexMap DefaultCoordsGHS3DEnforcedVertexMap() {return TCoordsGHS3DEnforcedVertexMap();}
- static TGeomEntryGHS3DEnforcedVertexMap DefaultGeomEntryGHS3DEnforcedVertexMap() {return TGeomEntryGHS3DEnforcedVertexMap();}
- static TGroupNameGHS3DEnforcedVertexMap DefaultGroupNameGHS3DEnforcedVertexMap() {return TGroupNameGHS3DEnforcedVertexMap();}
+ static THYBRIDEnforcedVertex DefaultHYBRIDEnforcedVertex() {return THYBRIDEnforcedVertex();}
+ static THYBRIDEnforcedVertexList DefaultHYBRIDEnforcedVertexList() {return THYBRIDEnforcedVertexList();}
+ static THYBRIDEnforcedVertexCoordsValues DefaultHYBRIDEnforcedVertexCoordsValues() {return THYBRIDEnforcedVertexCoordsValues();}
+ static THYBRIDEnforcedVertexEntryValues DefaultHYBRIDEnforcedVertexEntryValues() {return THYBRIDEnforcedVertexEntryValues();}
+ static TCoordsHYBRIDEnforcedVertexMap DefaultCoordsHYBRIDEnforcedVertexMap() {return TCoordsHYBRIDEnforcedVertexMap();}
+ static TGeomEntryHYBRIDEnforcedVertexMap DefaultGeomEntryHYBRIDEnforcedVertexMap() {return TGeomEntryHYBRIDEnforcedVertexMap();}
+ static TGroupNameHYBRIDEnforcedVertexMap DefaultGroupNameHYBRIDEnforcedVertexMap() {return TGroupNameHYBRIDEnforcedVertexMap();}
- static TGHS3DEnforcedMesh DefaultGHS3DEnforcedMesh() {return TGHS3DEnforcedMesh();}
- static TGHS3DEnforcedMeshList DefaultGHS3DEnforcedMeshList() {return TGHS3DEnforcedMeshList();}
- static TEntryGHS3DEnforcedMeshListMap DefaultEntryGHS3DEnforcedMeshListMap() {return TEntryGHS3DEnforcedMeshListMap();}
+ static THYBRIDEnforcedMesh DefaultHYBRIDEnforcedMesh() {return THYBRIDEnforcedMesh();}
+ static THYBRIDEnforcedMeshList DefaultHYBRIDEnforcedMeshList() {return THYBRIDEnforcedMeshList();}
+ static TEntryHYBRIDEnforcedMeshListMap DefaultEntryHYBRIDEnforcedMeshListMap() {return TEntryHYBRIDEnforcedMeshListMap();}
static TIDSortedNodeGroupMap DefaultIDSortedNodeGroupMap() {return TIDSortedNodeGroupMap();}
static TIDSortedElemGroupMap DefaultIDSortedElemGroupMap() {return TIDSortedElemGroupMap();}
static TID2SizeMap DefaultID2SizeMap() {return TID2SizeMap();}
// Persistence
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
- friend GHS3DPLUGIN_EXPORT std::ostream & operator <<(std::ostream & save, GHS3DPlugin_Hypothesis & hyp);
- friend GHS3DPLUGIN_EXPORT std::istream & operator >>(std::istream & load, GHS3DPlugin_Hypothesis & hyp);
+ friend HYBRIDPLUGIN_EXPORT std::ostream & operator <<(std::ostream & save, HYBRIDPlugin_Hypothesis & hyp);
+ friend HYBRIDPLUGIN_EXPORT std::istream & operator >>(std::istream & load, HYBRIDPlugin_Hypothesis & hyp);
/*!
* \brief Does nothing
std::string myTextOption;
double myGradation;
- TGHS3DEnforcedVertexList _enfVertexList;
- TGHS3DEnforcedVertexCoordsValues _enfVertexCoordsSizeList;
- TGHS3DEnforcedVertexEntryValues _enfVertexEntrySizeList;
+ THYBRIDEnforcedVertexList _enfVertexList;
+ THYBRIDEnforcedVertexCoordsValues _enfVertexCoordsSizeList;
+ THYBRIDEnforcedVertexEntryValues _enfVertexEntrySizeList;
// map to get "manual" enf vertex (through the coordinates)
- TCoordsGHS3DEnforcedVertexMap _coordsEnfVertexMap;
+ TCoordsHYBRIDEnforcedVertexMap _coordsEnfVertexMap;
// map to get "geom" enf vertex (through the geom entries)
- TGeomEntryGHS3DEnforcedVertexMap _geomEntryEnfVertexMap;
+ TGeomEntryHYBRIDEnforcedVertexMap _geomEntryEnfVertexMap;
- TGHS3DEnforcedMeshList _enfMeshList;
+ THYBRIDEnforcedMeshList _enfMeshList;
// map to get enf meshes through the entries
- TEntryGHS3DEnforcedMeshListMap _entryEnfMeshMap;
+ TEntryHYBRIDEnforcedMeshListMap _entryEnfMeshMap;
TIDSortedNodeGroupMap _enfNodes;
TIDSortedElemGroupMap _enfEdges;
TIDSortedElemGroupMap _enfTriangles;
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// File : GHS3DPlugin_Hypothesis_i.cxx
+// File : HYBRIDPlugin_Hypothesis_i.cxx
// Created : Wed Apr 2 13:53:01 2008
// Author : Edward AGAPOV (eap)
//
-#include "GHS3DPlugin_Hypothesis_i.hxx"
+#include "HYBRIDPlugin_Hypothesis_i.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_PythonDump.hxx"
// #include CORBA_SERVER_HEADER(SALOMEDS)
//=======================================================================
-//function : GHS3DPlugin_Hypothesis_i
+//function : HYBRIDPlugin_Hypothesis_i
//=======================================================================
-GHS3DPlugin_Hypothesis_i::GHS3DPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
+HYBRIDPlugin_Hypothesis_i::HYBRIDPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
int theStudyId,
::SMESH_Gen* theGenImpl)
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA )
{
- MESSAGE( "GHS3DPlugin_Hypothesis_i::GHS3DPlugin_Hypothesis_i" );
- myBaseImpl = new ::GHS3DPlugin_Hypothesis (theGenImpl->GetANewId(),
+ MESSAGE( "HYBRIDPlugin_Hypothesis_i::HYBRIDPlugin_Hypothesis_i" );
+ myBaseImpl = new ::HYBRIDPlugin_Hypothesis (theGenImpl->GetANewId(),
theStudyId,
theGenImpl);
}
//=======================================================================
-//function : ~GHS3DPlugin_Hypothesis_i
+//function : ~HYBRIDPlugin_Hypothesis_i
//=======================================================================
-GHS3DPlugin_Hypothesis_i::~GHS3DPlugin_Hypothesis_i()
+HYBRIDPlugin_Hypothesis_i::~HYBRIDPlugin_Hypothesis_i()
{
- MESSAGE( "GHS3DPlugin_Hypothesis_i::~GHS3DPlugin_Hypothesis_i" );
+ MESSAGE( "HYBRIDPlugin_Hypothesis_i::~HYBRIDPlugin_Hypothesis_i" );
}
//=======================================================================
//function : SetToMeshHoles
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetToMeshHoles(CORBA::Boolean toMesh)
+void HYBRIDPlugin_Hypothesis_i::SetToMeshHoles(CORBA::Boolean toMesh)
{
ASSERT(myBaseImpl);
this->GetImpl()->SetToMeshHoles(toMesh);
//function : GetToMeshHoles
//=======================================================================
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToMeshHoles()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToMeshHoles()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetToMeshHoles();
//function : SetToMakeGroupsOfDomains
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetToMakeGroupsOfDomains(CORBA::Boolean toMakeGroups)
+void HYBRIDPlugin_Hypothesis_i::SetToMakeGroupsOfDomains(CORBA::Boolean toMakeGroups)
{
ASSERT(myBaseImpl);
this->GetImpl()->SetToMakeGroupsOfDomains(toMakeGroups);
//function : GetToMakeGroupsOfDomains
//=======================================================================
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToMakeGroupsOfDomains()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToMakeGroupsOfDomains()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetToMakeGroupsOfDomains();
//function : SetMaximumMemory
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetMaximumMemory(CORBA::Double MB)
+void HYBRIDPlugin_Hypothesis_i::SetMaximumMemory(CORBA::Double MB)
throw ( SALOME::SALOME_Exception )
{
if ( MB == 0 )
//function : GetMaximumMemory
//=======================================================================
-CORBA::Double GHS3DPlugin_Hypothesis_i::GetMaximumMemory()
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetMaximumMemory()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetMaximumMemory();
//function : SetInitialMemory
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetInitialMemory(CORBA::Double MB)
+void HYBRIDPlugin_Hypothesis_i::SetInitialMemory(CORBA::Double MB)
throw ( SALOME::SALOME_Exception )
{
if ( MB == 0 )
//function : GetInitialMemory
//=======================================================================
-CORBA::Double GHS3DPlugin_Hypothesis_i::GetInitialMemory()
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetInitialMemory()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetInitialMemory();
//function : SetOptimizationLevel
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetOptimizationLevel(CORBA::Short level)
+void HYBRIDPlugin_Hypothesis_i::SetOptimizationLevel(CORBA::Short level)
throw ( SALOME::SALOME_Exception )
{
- ::GHS3DPlugin_Hypothesis::OptimizationLevel l =
- (::GHS3DPlugin_Hypothesis::OptimizationLevel) level;
- if ( l < ::GHS3DPlugin_Hypothesis::None ||
- l > ::GHS3DPlugin_Hypothesis::Strong )
+ ::HYBRIDPlugin_Hypothesis::OptimizationLevel l =
+ (::HYBRIDPlugin_Hypothesis::OptimizationLevel) level;
+ if ( l < ::HYBRIDPlugin_Hypothesis::None ||
+ l > ::HYBRIDPlugin_Hypothesis::Strong )
THROW_SALOME_CORBA_EXCEPTION( "Invalid optimization level",SALOME::BAD_PARAM );
ASSERT(myBaseImpl);
//function : GetOptimizationLevel
//=======================================================================
-CORBA::Short GHS3DPlugin_Hypothesis_i::GetOptimizationLevel()
+CORBA::Short HYBRIDPlugin_Hypothesis_i::GetOptimizationLevel()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetOptimizationLevel();
//function : SetWorkingDirectory
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetWorkingDirectory(const char* path) throw ( SALOME::SALOME_Exception )
+void HYBRIDPlugin_Hypothesis_i::SetWorkingDirectory(const char* path) throw ( SALOME::SALOME_Exception )
{
if (!path )
THROW_SALOME_CORBA_EXCEPTION( "Null working directory",SALOME::BAD_PARAM );
#else
if ( lastChar != '/' ) file += '/';
#endif
- file += "GHS3D.log";
+ file += "HYBRID.log";
SMESH_Mesh_i::PrepareForWriting (file.c_str());
ASSERT(myBaseImpl);
//function : GetWorkingDirectory
//=======================================================================
-char* GHS3DPlugin_Hypothesis_i::GetWorkingDirectory()
+char* HYBRIDPlugin_Hypothesis_i::GetWorkingDirectory()
{
ASSERT(myBaseImpl);
return CORBA::string_dup( this->GetImpl()->GetWorkingDirectory().c_str() );
//function : SetKeepFiles
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetKeepFiles(CORBA::Boolean toKeep)
+void HYBRIDPlugin_Hypothesis_i::SetKeepFiles(CORBA::Boolean toKeep)
{
ASSERT(myBaseImpl);
this->GetImpl()->SetKeepFiles(toKeep);
//function : GetKeepFiles
//=======================================================================
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetKeepFiles()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetKeepFiles()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetKeepFiles();
//function : SetVerboseLevel
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetVerboseLevel(CORBA::Short level)
+void HYBRIDPlugin_Hypothesis_i::SetVerboseLevel(CORBA::Short level)
throw ( SALOME::SALOME_Exception )
{
if (level < 0 || level > 10 )
//function : GetVerboseLevel
//=======================================================================
-CORBA::Short GHS3DPlugin_Hypothesis_i::GetVerboseLevel()
+CORBA::Short HYBRIDPlugin_Hypothesis_i::GetVerboseLevel()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetVerboseLevel();
//function : SetToCreateNewNodes
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetToCreateNewNodes(CORBA::Boolean toCreate)
+void HYBRIDPlugin_Hypothesis_i::SetToCreateNewNodes(CORBA::Boolean toCreate)
{
ASSERT(myBaseImpl);
this->GetImpl()->SetToCreateNewNodes(toCreate);
//function : GetToCreateNewNodes
//=======================================================================
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToCreateNewNodes()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToCreateNewNodes()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetToCreateNewNodes();
//function : SetToUseBoundaryRecoveryVersion
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetToUseBoundaryRecoveryVersion(CORBA::Boolean toUse)
+void HYBRIDPlugin_Hypothesis_i::SetToUseBoundaryRecoveryVersion(CORBA::Boolean toUse)
{
ASSERT(myBaseImpl);
this->GetImpl()->SetToUseBoundaryRecoveryVersion(toUse);
//function : GetToUseBoundaryRecoveryVersion
//=======================================================================
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToUseBoundaryRecoveryVersion()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToUseBoundaryRecoveryVersion()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetToUseBoundaryRecoveryVersion();
//function : SetFEMCorrection
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetFEMCorrection(CORBA::Boolean toUseFem)
+void HYBRIDPlugin_Hypothesis_i::SetFEMCorrection(CORBA::Boolean toUseFem)
{
ASSERT(myBaseImpl);
this->GetImpl()->SetFEMCorrection(toUseFem);
//function : GetFEMCorrection
//=======================================================================
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetFEMCorrection()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetFEMCorrection()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetFEMCorrection();
//function : SetToRemoveCentralPoint
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetToRemoveCentralPoint(CORBA::Boolean toRemove)
+void HYBRIDPlugin_Hypothesis_i::SetToRemoveCentralPoint(CORBA::Boolean toRemove)
{
ASSERT(myBaseImpl);
this->GetImpl()->SetToRemoveCentralPoint(toRemove);
//function : GetToRemoveCentralPoint
//=======================================================================
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToRemoveCentralPoint()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToRemoveCentralPoint()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetToRemoveCentralPoint();
//function : SetTextOption
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetTextOption(const char* option)
+void HYBRIDPlugin_Hypothesis_i::SetTextOption(const char* option)
{
ASSERT(myBaseImpl);
this->GetImpl()->SetTextOption(option);
//function : GetTextOption
//=======================================================================
-char* GHS3DPlugin_Hypothesis_i::GetTextOption()
+char* HYBRIDPlugin_Hypothesis_i::GetTextOption()
{
ASSERT(myBaseImpl);
return CORBA::string_dup( this->GetImpl()->GetTextOption().c_str() );
//function : SetToRemoveCentralPoint
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetGradation(CORBA::Double gradation)
+void HYBRIDPlugin_Hypothesis_i::SetGradation(CORBA::Double gradation)
{
if (gradation <= 1)
THROW_SALOME_CORBA_EXCEPTION( "The volumic gradation must be > 1",SALOME::BAD_PARAM );
//function : GetToRemoveCentralPoint
//=======================================================================
-CORBA::Double GHS3DPlugin_Hypothesis_i::GetGradation()
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetGradation()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetGradation();
//function : SetStandardOutputLog
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetStandardOutputLog(CORBA::Boolean logInStandardOutput)
+void HYBRIDPlugin_Hypothesis_i::SetStandardOutputLog(CORBA::Boolean logInStandardOutput)
{
ASSERT(myBaseImpl);
this->GetImpl()->SetStandardOutputLog(logInStandardOutput);
//function : GetStandardOutputLog
//=======================================================================
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetStandardOutputLog()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetStandardOutputLog()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetStandardOutputLog();
//function : SetRemoveLogOnSuccess
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::SetRemoveLogOnSuccess(CORBA::Boolean removeLogOnSuccess)
+void HYBRIDPlugin_Hypothesis_i::SetRemoveLogOnSuccess(CORBA::Boolean removeLogOnSuccess)
{
ASSERT(myBaseImpl);
this->GetImpl()->SetRemoveLogOnSuccess(removeLogOnSuccess);
//function : GetRemoveLogOnSuccess
//=======================================================================
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetRemoveLogOnSuccess()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetRemoveLogOnSuccess()
{
ASSERT(myBaseImpl);
return this->GetImpl()->GetRemoveLogOnSuccess();
//function : SetEnforcedVertex
//=======================================================================
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size)
throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
MESSAGE("IDL : SetEnforcedVertex( "<< x << ", " << y << ", " << z << ", " << size << ")");
return p_SetEnforcedVertex(size, x, y, z);
}
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedVertexNamed(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName)
throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
MESSAGE("IDL : SetEnforcedVertexNamed( "<< x << ", " << y << ", " << z << ", " << size << ", " << theVertexName << ")");
return p_SetEnforcedVertex(size, x, y, z, theVertexName, "", "");
}
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theGroupName)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedVertexWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theGroupName)
throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
MESSAGE("IDL : SetEnforcedVertexWithGroup( "<< x << ", " << y << ", " << z << ", " << size << ", " << theGroupName << ")");
return p_SetEnforcedVertex(size, x, y, z, "", "", theGroupName);
}
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName, const char* theGroupName)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedVertexNamedWithGroup(CORBA::Double x, CORBA::Double y, CORBA::Double z, CORBA::Double size, const char* theVertexName, const char* theGroupName)
throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
MESSAGE("IDL : SetEnforcedVertexNamedWithGroup( "<< x << ", " << y << ", " << z << ", " << size << ", " << theVertexName << ", " << theGroupName << ")");
return p_SetEnforcedVertex(size, x, y, z, theVertexName, "", theGroupName);
}
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size)
throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
return p_SetEnforcedVertex(size, x, y, z, theVertexName.c_str(), theVertexEntry.c_str(), "", isCompound);
}
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size, const char* theGroupName)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_ptr theVertex, CORBA::Double size, const char* theGroupName)
throw (SALOME::SALOME_Exception) {
ASSERT(myBaseImpl);
return p_SetEnforcedVertex(size, x, y, z, theVertexName.c_str(), theVertexEntry.c_str(), theGroupName, isCompound);
}
-bool GHS3DPlugin_Hypothesis_i:: p_SetEnforcedVertex(CORBA::Double size, CORBA::Double x, CORBA::Double y, CORBA::Double z,
+bool HYBRIDPlugin_Hypothesis_i:: p_SetEnforcedVertex(CORBA::Double size, CORBA::Double x, CORBA::Double y, CORBA::Double z,
const char* theVertexName, const char* theVertexEntry, const char* theGroupName,
CORBA::Boolean isCompound)
throw (SALOME::SALOME_Exception) {
MESSAGE("IDL : p_SetEnforcedVertex(" << size << ", " << x << ", " << y << ", " << z << ", \"" << theVertexName << "\", \"" << theVertexEntry << "\", \"" << theGroupName << "\", " << isCompound<< ")");
bool newValue = false;
- ::GHS3DPlugin_Hypothesis::TCoordsGHS3DEnforcedVertexMap coordsList;
- ::GHS3DPlugin_Hypothesis::TGeomEntryGHS3DEnforcedVertexMap enfVertexEntryList;
+ ::HYBRIDPlugin_Hypothesis::TCoordsHYBRIDEnforcedVertexMap coordsList;
+ ::HYBRIDPlugin_Hypothesis::TGeomEntryHYBRIDEnforcedVertexMap enfVertexEntryList;
if (string(theVertexEntry).empty()) {
coordsList = this->GetImpl()->_GetEnforcedVerticesByCoords();
std::vector<double> coords;
}
else {
MESSAGE("Coords already found, compare names");
- ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex *enfVertex = this->GetImpl()->GetEnforcedVertex(x, y, z);
+ ::HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex *enfVertex = this->GetImpl()->GetEnforcedVertex(x, y, z);
if ((enfVertex->name != theVertexName) || (enfVertex->groupName != theGroupName) || (enfVertex->size != size)) {
MESSAGE("The names or size are different: update");
// this->GetImpl()->ClearEnforcedVertex(theFaceEntry, x, y, z);
else {
// if (isCompound || (!isCompound && !string(theVertexEntry).empty())) {
enfVertexEntryList = this->GetImpl()->_GetEnforcedVerticesByEntry();
-// ::BLSURFPlugin_Hypothesis::TGeomEntryGHS3DEnforcedVertexMap::const_iterator it = enfVertexEntryList.find(theVertexEntry);
+// ::BLSURFPlugin_Hypothesis::TGeomEntryHYBRIDEnforcedVertexMap::const_iterator it = enfVertexEntryList.find(theVertexEntry);
if ( enfVertexEntryList.find(theVertexEntry) == enfVertexEntryList.end()) {
MESSAGE("Geom entry not found: add it in enfVertexEntryList");
newValue = true;
}
else {
MESSAGE("Geom entry already found, compare names");
- ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex *enfVertex = this->GetImpl()->GetEnforcedVertex(theVertexEntry);
+ ::HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex *enfVertex = this->GetImpl()->GetEnforcedVertex(theVertexEntry);
if ((enfVertex->name != theVertexName) || (enfVertex->groupName != theGroupName) || (enfVertex->size != size)) {
MESSAGE("The names or size are different: update");
// this->GetImpl()->ClearEnforcedVertex(theFaceEntry, x, y, z);
//function : GetEnforcedVertex
//=======================================================================
-CORBA::Double GHS3DPlugin_Hypothesis_i::GetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+ ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
ExDescription.lineNumber = 513;
throw SALOME::SALOME_Exception(ExDescription);
}
//function : GetEnforcedVertex
//=======================================================================
-CORBA::Double GHS3DPlugin_Hypothesis_i::GetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+ ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
ExDescription.lineNumber = 538;
throw SALOME::SALOME_Exception(ExDescription);
}
//function : GetEnforcedVertices
//=======================================================================
-GHS3DPlugin::GHS3DEnforcedVertexList* GHS3DPlugin_Hypothesis_i::GetEnforcedVertices()
+HYBRIDPlugin::HYBRIDEnforcedVertexList* HYBRIDPlugin_Hypothesis_i::GetEnforcedVertices()
{
ASSERT(myBaseImpl);
- GHS3DPlugin::GHS3DEnforcedVertexList_var result = new GHS3DPlugin::GHS3DEnforcedVertexList();
+ HYBRIDPlugin::HYBRIDEnforcedVertexList_var result = new HYBRIDPlugin::HYBRIDEnforcedVertexList();
- const ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList enfVertexList = this->GetImpl()->_GetEnforcedVertices();
+ const ::HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexList enfVertexList = this->GetImpl()->_GetEnforcedVertices();
result->length( enfVertexList.size() );
- ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertexList::const_iterator it = enfVertexList.begin();
+ ::HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertexList::const_iterator it = enfVertexList.begin();
for (int i = 0 ; it != enfVertexList.end(); ++it, ++i ) {
- ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex* currentVertex = (*it);
- GHS3DPlugin::GHS3DEnforcedVertex_var enfVertex = new GHS3DPlugin::GHS3DEnforcedVertex();
+ ::HYBRIDPlugin_Hypothesis::THYBRIDEnforcedVertex* currentVertex = (*it);
+ HYBRIDPlugin::HYBRIDEnforcedVertex_var enfVertex = new HYBRIDPlugin::HYBRIDEnforcedVertex();
// Name
enfVertex->name = CORBA::string_dup(currentVertex->name.c_str());
// Geom Vertex Entry
enfVertex->geomEntry = CORBA::string_dup(currentVertex->geomEntry.c_str());
// Coords
- GHS3DPlugin::TCoords_var coords = new GHS3DPlugin::TCoords();
+ HYBRIDPlugin::TCoords_var coords = new HYBRIDPlugin::TCoords();
coords->length(currentVertex->coords.size());
for (int ind = 0; ind < currentVertex->coords.size(); ind++)
coords[ind] = currentVertex->coords[ind];
//function : RemoveEnforcedVertex
//=======================================================================
-bool GHS3DPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
+bool HYBRIDPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z)
throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+ ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
ExDescription.lineNumber = 625;
throw SALOME::SALOME_Exception(ExDescription);
}
}
}
-bool GHS3DPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
+bool HYBRIDPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex)
throw (SALOME::SALOME_Exception)
{
ASSERT(myBaseImpl);
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+ ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
ExDescription.lineNumber = 648;
throw SALOME::SALOME_Exception(ExDescription);
}
//function : ClearEnforcedVertices
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::ClearEnforcedVertices()
+void HYBRIDPlugin_Hypothesis_i::ClearEnforcedVertices()
{
ASSERT(myBaseImpl);
this->GetImpl()->ClearEnforcedVertices();
//function : ClearEnforcedMeshes
//=======================================================================
-void GHS3DPlugin_Hypothesis_i::ClearEnforcedMeshes()
+void HYBRIDPlugin_Hypothesis_i::ClearEnforcedMeshes()
{
ASSERT(myBaseImpl);
this->GetImpl()->ClearEnforcedMeshes();
//function : GetEnforcedMeshes
//=======================================================================
-GHS3DPlugin::GHS3DEnforcedMeshList* GHS3DPlugin_Hypothesis_i::GetEnforcedMeshes()
+HYBRIDPlugin::HYBRIDEnforcedMeshList* HYBRIDPlugin_Hypothesis_i::GetEnforcedMeshes()
{
ASSERT(myBaseImpl);
- GHS3DPlugin::GHS3DEnforcedMeshList_var result = new GHS3DPlugin::GHS3DEnforcedMeshList();
+ HYBRIDPlugin::HYBRIDEnforcedMeshList_var result = new HYBRIDPlugin::HYBRIDEnforcedMeshList();
- const ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedMeshList enfMeshList = this->GetImpl()->_GetEnforcedMeshes();
+ const ::HYBRIDPlugin_Hypothesis::THYBRIDEnforcedMeshList enfMeshList = this->GetImpl()->_GetEnforcedMeshes();
result->length( enfMeshList.size() );
- ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedMeshList::const_iterator it = enfMeshList.begin();
+ ::HYBRIDPlugin_Hypothesis::THYBRIDEnforcedMeshList::const_iterator it = enfMeshList.begin();
for (int i = 0 ; it != enfMeshList.end(); ++it, ++i ) {
- ::GHS3DPlugin_Hypothesis::TGHS3DEnforcedMesh* currentMesh = (*it);
- GHS3DPlugin::GHS3DEnforcedMesh_var enfMesh = new GHS3DPlugin::GHS3DEnforcedMesh();
+ ::HYBRIDPlugin_Hypothesis::THYBRIDEnforcedMesh* currentMesh = (*it);
+ HYBRIDPlugin::HYBRIDEnforcedMesh_var enfMesh = new HYBRIDPlugin::HYBRIDEnforcedMesh();
// Name
enfMesh->name = CORBA::string_dup(currentMesh->name.c_str());
// Mesh Entry
/*!
* \brief Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource. The elements will be grouped in theGroupName.
*/
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, const char* theGroupName)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, const char* theGroupName)
throw (SALOME::SALOME_Exception)
{
-// #if GHS3D_VERSION >= 42
+// #if HYBRID_VERSION >= 42
return p_SetEnforcedMesh(theSource, theType, "", theGroupName);
// #else
// SALOME::ExceptionStruct ExDescription;
-// ExDescription.text = "Bad version of GHS3D. It must >= 4.2.";
+// ExDescription.text = "Bad version of HYBRID. It must >= 4.2.";
// ExDescription.type = SALOME::BAD_PARAM;
-// ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+// ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
// ExDescription.lineNumber = 719;
// throw SALOME::SALOME_Exception(ExDescription);
// #endif
/*!
* \brief Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource.
*/
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType)
throw (SALOME::SALOME_Exception)
{
-// MESSAGE("GHS3DPlugin_Hypothesis_i::SetEnforcedMesh");
-// #if GHS3D_VERSION >= 42
+// MESSAGE("HYBRIDPlugin_Hypothesis_i::SetEnforcedMesh");
+// #if HYBRID_VERSION >= 42
return p_SetEnforcedMesh(theSource, theType);
// #else
// SALOME::ExceptionStruct ExDescription;
-// ExDescription.text = "Bad version of GHS3D. It must >= 4.2.";
+// ExDescription.text = "Bad version of HYBRID. It must >= 4.2.";
// ExDescription.type = SALOME::BAD_PARAM;
-// ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+// ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
// ExDescription.lineNumber = 750;
// throw SALOME::SALOME_Exception(ExDescription);
// #endif
/*!
* \brief OBSOLETE FUNCTION - Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource and a size. The elements will be grouped in theGroupName.
*/
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double theSize, const char* theGroupName)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double theSize, const char* theGroupName)
throw (SALOME::SALOME_Exception)
{
-// #if GHS3D_VERSION >= 42
+// #if HYBRID_VERSION >= 42
return p_SetEnforcedMesh(theSource, theType, "", theGroupName);
// #else
// SALOME::ExceptionStruct ExDescription;
-// ExDescription.text = "Bad version of GHS3D. It must >= 4.2.";
+// ExDescription.text = "Bad version of HYBRID. It must >= 4.2.";
// ExDescription.type = SALOME::BAD_PARAM;
-// ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+// ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
// ExDescription.lineNumber = 750;
// throw SALOME::SALOME_Exception(ExDescription);
// #endif
/*!
* \brief OBSOLETE FUNCTION - Adds enforced elements of type elementType using another mesh/sub-mesh/mesh group theSource and a size.
*/
-bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshSize(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double theSize)
+bool HYBRIDPlugin_Hypothesis_i::SetEnforcedMeshSize(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, double theSize)
throw (SALOME::SALOME_Exception)
{
-// #if GHS3D_VERSION >= 42
+// #if HYBRID_VERSION >= 42
return p_SetEnforcedMesh(theSource, theType);
// #else
// SALOME::ExceptionStruct ExDescription;
-// ExDescription.text = "Bad version of GHS3D. It must >= 4.2.";
+// ExDescription.text = "Bad version of HYBRID. It must >= 4.2.";
// ExDescription.type = SALOME::BAD_PARAM;
-// ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+// ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
// ExDescription.lineNumber = 750;
// throw SALOME::SALOME_Exception(ExDescription);
// #endif
}
-bool GHS3DPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, const char* theName, const char* theGroupName)
+bool HYBRIDPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType theType, const char* theName, const char* theGroupName)
throw (SALOME::SALOME_Exception)
{
- MESSAGE("GHS3DPlugin_Hypothesis_i::p_SetEnforcedMesh");
+ MESSAGE("HYBRIDPlugin_Hypothesis_i::p_SetEnforcedMesh");
ASSERT(myBaseImpl);
if (CORBA::is_nil( theSource ))
SALOME::ExceptionStruct ExDescription;
ExDescription.text = "The source mesh CORBA object is NULL";
ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+ ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
ExDescription.lineNumber = 840;
throw SALOME::SALOME_Exception(ExDescription);
}
// SALOME::ExceptionStruct ExDescription;
// ExDescription.text = "The source mesh has bad type";
// ExDescription.type = SALOME::BAD_PARAM;
-// ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+// ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
// ExDescription.lineNumber = 840;
// throw SALOME::SALOME_Exception(ExDescription);
}
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+ ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
ExDescription.lineNumber = 840;
throw SALOME::SALOME_Exception(ExDescription);
}
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+ ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
ExDescription.lineNumber = 840;
throw SALOME::SALOME_Exception(ExDescription);
}
SALOME::ExceptionStruct ExDescription;
ExDescription.text = ex.what();
ExDescription.type = SALOME::BAD_PARAM;
- ExDescription.sourceFile = "GHS3DPlugin_Hypothesis_i.cxx";
+ ExDescription.sourceFile = "HYBRIDPlugin_Hypothesis_i.cxx";
ExDescription.lineNumber = 840;
throw SALOME::SALOME_Exception(ExDescription);
}
*/
//=============================================================================
-::GHS3DPlugin_Hypothesis* GHS3DPlugin_Hypothesis_i::GetImpl()
+::HYBRIDPlugin_Hypothesis* HYBRIDPlugin_Hypothesis_i::GetImpl()
{
- return (::GHS3DPlugin_Hypothesis*)myBaseImpl;
+ return (::HYBRIDPlugin_Hypothesis*)myBaseImpl;
}
//================================================================================
*/
//================================================================================
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::IsDimSupported( SMESH::Dimension type )
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::IsDimSupported( SMESH::Dimension type )
{
return type == SMESH::DIM_3D;
}
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// GHS3DPlugin : C++ implementation
-// File : GHS3DPlugin_Hypothesis_i.hxx
+// HYBRIDPlugin : C++ implementation
+// File : HYBRIDPlugin_Hypothesis_i.hxx
// Date : 03/04/2006
// Project : SALOME
//
-#ifndef _GHS3DPlugin_Hypothesis_i_HXX_
-#define _GHS3DPlugin_Hypothesis_i_HXX_
+#ifndef _HYBRIDPlugin_Hypothesis_i_HXX_
+#define _HYBRIDPlugin_Hypothesis_i_HXX_
-#include "GHS3DPlugin_Defs.hxx"
+#include "HYBRIDPlugin_Defs.hxx"
#include <SALOMEconfig.h>
-#include CORBA_SERVER_HEADER(GHS3DPlugin_Algorithm)
+#include CORBA_SERVER_HEADER(HYBRIDPlugin_Algorithm)
#include "SMESH_Hypothesis_i.hxx"
#include "SMESH_Mesh_i.hxx"
-#include "GHS3DPlugin_Hypothesis.hxx"
+#include "HYBRIDPlugin_Hypothesis.hxx"
class SMESH_Gen;
-// GHS3DPlugin parameters hypothesis
+// HYBRIDPlugin parameters hypothesis
-class GHS3DPLUGIN_EXPORT GHS3DPlugin_Hypothesis_i:
- public virtual POA_GHS3DPlugin::GHS3DPlugin_Hypothesis,
+class HYBRIDPLUGIN_EXPORT HYBRIDPlugin_Hypothesis_i:
+ public virtual POA_HYBRIDPlugin::HYBRIDPlugin_Hypothesis,
public virtual SMESH_Hypothesis_i
{
public:
// Constructor
- GHS3DPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
+ HYBRIDPlugin_Hypothesis_i (PortableServer::POA_ptr thePOA,
int theStudyId,
::SMESH_Gen* theGenImpl);
// Destructor
- virtual ~GHS3DPlugin_Hypothesis_i();
+ virtual ~HYBRIDPlugin_Hypothesis_i();
/*!
* To mesh "holes" in a solid or not. Default is to mesh.
CORBA::Double GetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex) throw (SALOME::SALOME_Exception);
bool RemoveEnforcedVertex(CORBA::Double x, CORBA::Double y, CORBA::Double z) throw (SALOME::SALOME_Exception);
bool RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVertex) throw (SALOME::SALOME_Exception);
- GHS3DPlugin::GHS3DEnforcedVertexList* GetEnforcedVertices();
+ HYBRIDPlugin::HYBRIDEnforcedVertexList* GetEnforcedVertices();
void ClearEnforcedVertices();
/*!
* To set an enforced mesh
bool SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSource_ptr theSource, SMESH::ElementType elementType, double size, const char* theGroupName) throw (SALOME::SALOME_Exception);
/* OBSOLETE FUNCTIONS */
- GHS3DPlugin::GHS3DEnforcedMeshList* GetEnforcedMeshes();
+ HYBRIDPlugin::HYBRIDEnforcedMeshList* GetEnforcedMeshes();
void ClearEnforcedMeshes();
// Get implementation
- ::GHS3DPlugin_Hypothesis* GetImpl();
+ ::HYBRIDPlugin_Hypothesis* GetImpl();
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH GHS3DPlugin : implementaion of SMESH idl descriptions
-// File : GHS3DPlugin.cxx
+// SMESH HYBRIDPlugin : implementaion of SMESH idl descriptions
+// File : HYBRIDPlugin.cxx
// Author : Julia DOROVSKIKH
// Module : SMESH
// $Header$
#include "utilities.h"
-#include "GHS3DPlugin_GHS3D_i.hxx"
-#include "GHS3DPlugin_Hypothesis_i.hxx"
+#include "HYBRIDPlugin_HYBRID_i.hxx"
+#include "HYBRIDPlugin_Hypothesis_i.hxx"
-template <class T> class GHS3DPlugin_Creator_i:public HypothesisCreator_i<T>
+template <class T> class HYBRIDPlugin_Creator_i:public HypothesisCreator_i<T>
{
- // as we have 'module GHS3DPlugin' in GHS3DPlugin_Algorithm.idl
- virtual std::string GetModuleName() { return "GHS3DPlugin"; }
+ // as we have 'module HYBRIDPlugin' in HYBRIDPlugin_Algorithm.idl
+ virtual std::string GetModuleName() { return "HYBRIDPlugin"; }
};
//=============================================================================
extern "C"
{
- GHS3DPLUGIN_EXPORT GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName);
+ HYBRIDPLUGIN_EXPORT GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName);
- GHS3DPLUGIN_EXPORT
+ HYBRIDPLUGIN_EXPORT
GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName)
{
MESSAGE("GetHypothesisCreator " << aHypName);
// Hypotheses
// Algorithm
- if (strcmp(aHypName, "GHS3D_3D") == 0)
- aCreator = new GHS3DPlugin_Creator_i<GHS3DPlugin_GHS3D_i>;
+ if (strcmp(aHypName, "HYBRID_3D") == 0)
+ aCreator = new HYBRIDPlugin_Creator_i<HYBRIDPlugin_HYBRID_i>;
// Hypothesis
- else if (strcmp(aHypName, "GHS3D_Parameters") == 0)
- aCreator = new GHS3DPlugin_Creator_i<GHS3DPlugin_Hypothesis_i>;
+ else if (strcmp(aHypName, "HYBRID_Parameters") == 0)
+ aCreator = new HYBRIDPlugin_Creator_i<HYBRIDPlugin_Hypothesis_i>;
else ;
return aCreator;
#
##
-# @package GHS3DPluginBuilder
-# Python API for the GHS3D meshing plug-in module.
+# @package HYBRIDPluginBuilder
+# Python API for the HYBRID meshing plug-in module.
