]> SALOME platform Git repositories - plugins/hybridplugin.git/commitdiff
Salome HOME
20140612_1537 clone to HYBRIDPLUGIN Modify files contents [('GHS3DPLUGIN', 'HYBRIDPLU... hybrid hybridV0
authorChristian Van Wambeke <christian.van-wambeke@cea.fr>
Thu, 12 Jun 2014 13:37:23 +0000 (15:37 +0200)
committerChristian Van Wambeke <christian.van-wambeke@cea.fr>
Thu, 12 Jun 2014 13:37:23 +0000 (15:37 +0200)
55 files changed:
CMakeLists.txt
HYBRIDPLUGIN_version.h.in
INSTALL
SalomeHYBRIDPLUGINConfig.cmake.in
adm_local/cmake_files/CMakeLists.txt
adm_local/cmake_files/FindSalomeHYBRIDPLUGIN.cmake
adm_local/unix/config_files/CMakeLists.txt
adm_local/unix/config_files/check_HYBRID.m4
adm_local/unix/config_files/check_HYBRIDPLUGIN.m4
bin/VERSION.in
doc/salome/examples/CMakeLists.txt
doc/salome/examples/hybrid_enfmesh.py
doc/salome/examples/hybrid_enfvert.py
doc/salome/examples/hybriddemo.py
doc/salome/gui/CMakeLists.txt
doc/salome/gui/HYBRIDPLUGIN/CMakeLists.txt
doc/salome/gui/HYBRIDPLUGIN/doxyfile.in
doc/salome/gui/HYBRIDPLUGIN/doxyfile_py.in
doc/salome/gui/HYBRIDPLUGIN/input/additional_hypo.doc
doc/salome/gui/HYBRIDPLUGIN/input/hybrid_hypo.doc
doc/salome/gui/HYBRIDPLUGIN/input/hybridplugin_python_interface.doc
doc/salome/gui/HYBRIDPLUGIN/input/index.doc
doc/salome/gui/HYBRIDPLUGIN/static/header.html.in
doc/salome/gui/HYBRIDPLUGIN/static/header_py.html.in
idl/CMakeLists.txt
idl/HYBRIDPlugin_Algorithm.idl
resources/CMakeLists.txt
resources/HYBRIDPlugin.xml
resources/SalomeApp.xml
src/CMakeLists.txt
src/GUI/CMakeLists.txt
src/GUI/HYBRIDPluginGUI.cxx
src/GUI/HYBRIDPluginGUI_AdvWidget.cxx
src/GUI/HYBRIDPluginGUI_AdvWidget_QTD.ui
src/GUI/HYBRIDPluginGUI_Dlg.h
src/GUI/HYBRIDPluginGUI_Enums.h
src/GUI/HYBRIDPluginGUI_HypothesisCreator.cxx
src/GUI/HYBRIDPluginGUI_HypothesisCreator.h
src/GUI/HYBRIDPlugin_images.ts
src/GUI/HYBRIDPlugin_msg_en.ts
src/GUI/HYBRIDPlugin_msg_fr.ts
src/GUI/HYBRIDPlugin_msg_ja.ts
src/HYBRIDPlugin/CMakeLists.txt
src/HYBRIDPlugin/HYBRIDPluginBuilder.py
src/HYBRIDPlugin/HYBRIDPlugin_Defs.hxx
src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.cxx
src/HYBRIDPlugin/HYBRIDPlugin_HYBRID.hxx
src/HYBRIDPlugin/HYBRIDPlugin_HYBRID_i.cxx
src/HYBRIDPlugin/HYBRIDPlugin_HYBRID_i.hxx
src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.cxx
src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis.hxx
src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.cxx
src/HYBRIDPlugin/HYBRIDPlugin_Hypothesis_i.hxx
src/HYBRIDPlugin/HYBRIDPlugin_i.cxx
src/HYBRIDPlugin/__init__.py

index d94b36184b0ad05a94b0bab70cb0973eb723b266..45e3786d5784800c045c66b4ca7716c77db1cd2f 100755 (executable)
@@ -17,7 +17,7 @@
 # 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)
@@ -46,7 +46,7 @@ ELSE(EXISTS ${KERNEL_ROOT_DIR})
 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
@@ -60,7 +60,7 @@ LIST(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/adm_local/cmake_files")
 # 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()
@@ -143,8 +143,8 @@ IF(EXISTS ${SMESH_ROOT_DIR})
   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})
@@ -181,18 +181,18 @@ SET(SALOME_INSTALL_AMCONFIG_LOCAL "${SALOME_INSTALL_AMCONFIG_LOCAL}" CACHE PATH
 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})
@@ -211,7 +211,7 @@ ENDIF(SALOME_BUILD_DOC)
 # 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)
@@ -221,12 +221,12 @@ INCLUDE(CMakePackageConfigHelpers)
 # 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)
 
index b36b651d2c05beba898870a53455806a2d8f70b5..7ca46bf5dfdf252fcd488341a6ab3dbb35eb0f8b 100644 (file)
 // 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__
diff --git a/INSTALL b/INSTALL
index 937a961091acf92d260b109e83f3b8992ce7dc3f..837878e08ce7972f6c6ce35a466b998984008702 100644 (file)
--- a/INSTALL
+++ b/INSTALL
@@ -1 +1 @@
-SALOME2 : GHS3DPLUGIN module (SMESH plugin)
+SALOME2 : HYBRIDPLUGIN module (SMESH plugin)
index ffe829110ac99fd20bd6c537c010d12a27bf791e..8fdd4dca6ab99b97ce3d7c10707679ce0ba555a9 100644 (file)
 # 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@")
@@ -113,7 +113,7 @@ IF(NOT (TARGET SMESHEngine))
   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
index f2c96fbe04ef55bdfaf5281294ba419378f761c1..6d726fd33b459461b38a96513d483307538ca3de 100755 (executable)
@@ -23,6 +23,6 @@
 
 # These files are data, module or lib files
 SET(_adm_data
-  FindSalomeGHS3DPLUGIN.cmake
+  FindSalomeHYBRIDPLUGIN.cmake
 )
 INSTALL(FILES ${_adm_data} DESTINATION ${SALOME_INSTALL_CMAKE_LOCAL})
index 1a3bd9f651ca4143b8795727554efad0bd414da4..cde4e8c940664427b7d9d9445efdc7841433bd61 100644 (file)
 #
 #
 
-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
index 7bcc8c8e37e46b7035e13d3ff5fe300462455bcd..2e06ad08bd207c4c3599dedf3a1b80ef1c99b22b 100755 (executable)
@@ -21,8 +21,8 @@
 #
 
 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)
index 9224772988bde1715dbd9c0f4b205357b8d30c8c..aa2159a16457136d9aa1a92efa281ac51d834eba 100644 (file)
@@ -17,19 +17,19 @@ dnl
 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
index dbee3524de5e8f36ac537f1beaf66e16605a0b03..05a05723741a774327747a1ff12a1a774186b231 100755 (executable)
@@ -17,62 +17,62 @@ 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
  
index 0cc3deba8bba06931480dc6c93b0d63918e60bf6..4fe439aaf7a1305f02cbbc0137c1850948273113 100755 (executable)
@@ -1,3 +1,3 @@
-[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
index 500aed4703218e4c6800f651ea629763e73839f7..0fadb32a7dfa8fb7f437361aac6d7a6637f43620 100644 (file)
@@ -18,4 +18,4 @@
 #
 
 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)
index 4da517ebf5247020664c34b498242b9be7721b2b..80bf527ae89516a9300b9ac14560c15e67c61441 100644 (file)
@@ -1,5 +1,5 @@
 
-# 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.
@@ -44,15 +44,15 @@ BLSURF_Parameters2 = smesh.CreateHypothesis('BLSURF_Parameters', 'BLSURFEngine')
 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)
@@ -77,26 +77,26 @@ Mesh_box_tri.Compute()
 # 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()
index 319ca32dd77f8ba87e1f8e1d10e925d302be1cf0..0c0424828283924e290a7ba1cf75fe5203f267cd 100644 (file)
@@ -25,44 +25,44 @@ smesh =  smeshBuilder.New(salome.myStudy)
 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
index 2e43838a5fc2d6ad481be94521765b047ce589b7..d4b89f7a172c4fb855443137e76252ce13b79238 100644 (file)
@@ -14,14 +14,14 @@ 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
-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
 
index d9493ff0353cd92dc0d2679a073dd2a673fe3ea6..d1667cde3097beb59bdbf3271a82a57197242eca 100755 (executable)
@@ -20,4 +20,4 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
-ADD_SUBDIRECTORY(GHS3DPLUGIN)
+ADD_SUBDIRECTORY(HYBRIDPLUGIN)
index b30912c637763bd96d9cf3e235b8a178e61119f4..dbff9d4c0c7842d72318cca613ba13d504574a72 100755 (executable)
@@ -22,17 +22,17 @@ SALOME_CONFIGURE_FILE(doxyfile_py.in doxyfile_py)
 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
@@ -43,9 +43,9 @@ ADD_CUSTOM_TARGET(usr_docs ${CMAKE_COMMAND} -E make_directory tmp
 )
 
 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}")
index 0eaea0293dcdef1add81ef3ca8ba6e045c5cbfc6..0eda78c8ae9fd01e3bc39f1df27f356676047254 100755 (executable)
@@ -20,8 +20,8 @@
 #---------------------------------------------------------------------------
 # 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
@@ -77,10 +77,10 @@ GENERATE_RTF      = NO
 
 #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>"
index 54aafbdd97c71cb1b3f6a732cbdd4b6c1ce05378..8a9684741e12e55edb12cc151ec9c6d243a7439f 100755 (executable)
@@ -20,8 +20,8 @@
 #---------------------------------------------------------------------------
 # 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
@@ -96,7 +96,7 @@ EXAMPLE_RECURSIVE      = NO
 #---------------------------------------------------------------------------
 #Input related options
 #---------------------------------------------------------------------------
-INPUT             = tmp/GHS3DPluginBuilder.py \
+INPUT             = tmp/HYBRIDPluginBuilder.py \
                     tmp/smeshBuilder.py \
                     tmp/smesh_algorithm.py
 FILE_PATTERNS     = 
@@ -108,7 +108,7 @@ EXAMPLE_PATH      =
 #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
@@ -158,5 +158,5 @@ DOT_CLEANUP            = YES
 #---------------------------------------------------------------------------
 #External reference options
 #---------------------------------------------------------------------------
-GENERATE_TAGFILE  = ghs3dpluginpy_doc.tag
+GENERATE_TAGFILE  = hybridpluginpy_doc.tag
 SEARCHENGINE           = YES
index 90873f2075ea662a43118e1fa4778d8b9087056d..65003923cada319d9fd28b5a4c9274b3080949a0 100644 (file)
@@ -5,9 +5,9 @@
 \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
index 27198b23e63816fba3b2a7957b0e15933f71d4e4..8124192fd7acf92ae8c3be5673b4d433e0e5b35a 100644 (file)
@@ -1,20 +1,20 @@
 /*!
 
-\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 (GHS3
+- <b>Name</b> - allows to define the name of the hypothesis (HYBRI
 Parameters by default).
 
 - <b>Mesh holes</b> - if checked, the algorithm will 
@@ -40,26 +40,26 @@ but can be time-consuming):
 
   - 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.
@@ -83,15 +83,15 @@ is enabled (there must be a log file to delete it) and <b>Keep all working files
 (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
@@ -118,7 +118,7 @@ positive volume).
 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 
@@ -129,15 +129,15 @@ By default, the FEM correction is not used.
 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.
 
@@ -150,13 +150,13 @@ An enforced vertex is defined by:
 - 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:
@@ -166,8 +166,8 @@ entirely into the solid mesh.
 - 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"
 
 */
index 696612161833a980ad5ccbdde402e83655ca62da..5360f15d6e632399012398e78ff421b2406d9493 100644 (file)
@@ -1,51 +1,51 @@
 /*!
 
-\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"
 
 */
index 354df119369c75e9a9882556db70f721f2870a47..9ec6a1af5065bd89b1b635ea944a1bc5d2f140a3 100644 (file)
@@ -1,18 +1,18 @@
 /*!
 
-\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"
index fdbae6675e0ff021cd7daefc63b8f3ffa79598c9..97e983a97bcef7eb093e12d2b920b1592afc1c0f 100755 (executable)
@@ -19,5 +19,5 @@ $extrastylesheet
 <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 -->
index d8f387b2e618a22c96bedefc963983f8308d3b07..26c3fc64a8aefe5d8d2df201128ae6b9671e7917 100644 (file)
@@ -19,6 +19,6 @@ $extrastylesheet
 <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 -->
index 7c175b7d6d61d945904d034586855e5e4e55fbf9..8304ec15fedf8026d8c701829b03c4868eb2d69a 100755 (executable)
@@ -27,8 +27,8 @@ INCLUDE_DIRECTORIES(
   ${PROJECT_BINARY_DIR}/idl
 )
 
-SET(SalomeIDLGHS3DPLUGIN_IDLSOURCES
-  GHS3DPlugin_Algorithm.idl
+SET(SalomeIDLHYBRIDPLUGIN_IDLSOURCES
+  HYBRIDPlugin_Algorithm.idl
 )
 
 SET(_idl_include_dirs
@@ -43,5 +43,5 @@ SET(_idl_link_flags
   ${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})
index e369a41e1ffa7801c01a40e08f851640988309d4..407a44026b928c2e20244e29c447a659ac537feb 100644 (file)
 // 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;
@@ -42,29 +42,29 @@ module GHS3DPlugin
     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.
@@ -175,7 +175,7 @@ module GHS3DPlugin
     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)
@@ -192,7 +192,7 @@ module GHS3DPlugin
     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();
 
    /*!
index 76b4b0ca6408f64fe9b27e1c560e5befbe1bd742..2bbea7a95bce47ac98ffdc240f1a20a0c82b8ad5 100755 (executable)
 #
 
 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})
index 8d0ac365ac39ffb1fa38ece3952827d2f46f953e..294ccc7ed597b3b230cdc8c5639ca785e1b9d8eb 100644 (file)
 
 <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>
index 67c4022df1f10eca9667288606094bf02a64a8f3..e2378e0c0efff0357db2db43c972a91bc46cbeaa 100644 (file)
 -->
 <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>
index 62da8a1ba5aedb24a089570a48aa362cd55b2ef2..418dde2f79f3ef61956154da7b09a2748873fe39 100755 (executable)
@@ -21,7 +21,7 @@
 # Common packages
 ##
 SET(SUBDIRS_COMMON
-  GHS3DPlugin
+  HYBRIDPlugin
 )
 
 IF(SALOME_BUILD_GUI)
index 42aee0842cb11abe6ebc68ed73f92d41eac22de8..202d2ce672544e5763df59c832554f5443a70b31 100644 (file)
@@ -32,7 +32,7 @@ INCLUDE_DIRECTORIES(
   ${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
@@ -56,23 +56,23 @@ SET(_link_LIBRARIES
   ${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 ---
 
@@ -81,37 +81,37 @@ QT4_WRAP_CPP(_moc_SOURCES ${_moc_HEADERS})
 
 # 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}")
index b24765fc7b5e2543e1dd376789c15148d280ee04..cf3e669828189ca4115f41dc3fa0535adb608f9e 100644 (file)
 //
 
 // ---
-// 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;
   }
 }
index 52cf2727e2919eebaac5df65aecfff74e9f1def9..ca0de62c4b2323317038d38e55b9d61f6aa019a9 100644 (file)
 //
 
 // ---
-// 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()
 {
 }
index 1913752d3548fbc90924e24280dd6ecc8bcc177f..056e712fee1e5ad0a65500f38ab8b8fe9ff51c0a 100644 (file)
@@ -1,7 +1,7 @@
 <?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>
index 506f33fff90df4cdf2050d33ec6222741e82e43c..3758383d555361f98d152b3816792c0c7ebaa145 100644 (file)
 // 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
index 95939ae39a0594c6a50440a98d4aeebf4b64036b..b191929779d7f82cb284aef11089347e32eaf3f6 100644 (file)
 // 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 {
index 24292981bed7fd0c66401a5e3b3ac6e4e2d030e7..f089c197a0c5cc9b5277d77d8f0d4a9dd3a6cb85 100644 (file)
 // 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>
 
@@ -325,7 +325,7 @@ void EnforcedMeshTableWidgetDelegate::updateEditorGeometry(QWidget *editor,
 //
 
 
-GHS3DPluginGUI_HypothesisCreator::GHS3DPluginGUI_HypothesisCreator( const QString& theHypType )
+HYBRIDPluginGUI_HypothesisCreator::HYBRIDPluginGUI_HypothesisCreator( const QString& theHypType )
 : SMESHGUI_GenericHypothesisCreator( theHypType )
 {
   GeomToolSelected = NULL;
@@ -334,12 +334,12 @@ GHS3DPluginGUI_HypothesisCreator::GHS3DPluginGUI_HypothesisCreator( const QStrin
   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();
 }
@@ -347,9 +347,9 @@ GHS3DPluginGUI_HypothesisCreator::~GHS3DPluginGUI_HypothesisCreator()
 /**
  * \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);
@@ -357,12 +357,12 @@ GeomSelectionTools* GHS3DPluginGUI_HypothesisCreator::getGeomSelectionTool()
   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 );
@@ -390,12 +390,12 @@ QFrame* GHS3DPluginGUI_HypothesisCreator::buildFrame()
     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 );
 
@@ -410,7 +410,7 @@ QFrame* GHS3DPluginGUI_HypothesisCreator::buildFrame()
   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" ));
@@ -440,7 +440,7 @@ QFrame* GHS3DPluginGUI_HypothesisCreator::buildFrame()
   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" ));
 
@@ -454,9 +454,9 @@ QFrame* GHS3DPluginGUI_HypothesisCreator::buildFrame()
   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();
@@ -478,33 +478,33 @@ QFrame* GHS3DPluginGUI_HypothesisCreator::buildFrame()
 
   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 );
@@ -545,10 +545,10 @@ QFrame* GHS3DPluginGUI_HypothesisCreator::buildFrame()
   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);
@@ -564,26 +564,26 @@ QFrame* GHS3DPluginGUI_HypothesisCreator::buildFrame()
 //   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 );
@@ -608,9 +608,9 @@ QFrame* GHS3DPluginGUI_HypothesisCreator::buildFrame()
   
   // 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
@@ -651,7 +651,7 @@ QFrame* GHS3DPluginGUI_HypothesisCreator::buildFrame()
 /** 
  * 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() ) );
@@ -660,14 +660,14 @@ void GHS3DPluginGUI_HypothesisCreator::clearEnfVertexSelection()
     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() &&
@@ -681,7 +681,7 @@ void GHS3DPluginGUI_HypothesisCreator::checkVertexIsDefined()
 /** 
  * This method checks if an enforced mesh is defined;
 **/
-void GHS3DPluginGUI_HypothesisCreator::checkEnfMeshIsDefined()
+void HYBRIDPluginGUI_HypothesisCreator::checkEnfMeshIsDefined()
 {
   emit enfMeshDefined( myEnfVertexWdg->NbObjects() != 0);
 }
@@ -689,7 +689,7 @@ void GHS3DPluginGUI_HypothesisCreator::checkEnfMeshIsDefined()
 /** 
  * 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);
@@ -703,12 +703,12 @@ void GHS3DPluginGUI_HypothesisCreator::clearEnforcedVertexWidgets()
   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);
@@ -762,7 +762,7 @@ void GHS3DPluginGUI_HypothesisCreator::updateEnforcedVertexValues(QTableWidgetIt
   }
 }
 
-void GHS3DPluginGUI_HypothesisCreator::onSelectEnforcedVertex() {
+void HYBRIDPluginGUI_HypothesisCreator::onSelectEnforcedVertex() {
   int nbSelEnfVertex = myEnfVertexWdg->NbObjects();
   clearEnforcedVertexWidgets();
   if (nbSelEnfVertex == 1)
@@ -774,7 +774,7 @@ void GHS3DPluginGUI_HypothesisCreator::onSelectEnforcedVertex() {
     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;
@@ -797,11 +797,11 @@ void GHS3DPluginGUI_HypothesisCreator::onSelectEnforcedVertex() {
   }
 }
 
-/** 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()));
@@ -871,14 +871,14 @@ void GHS3DPluginGUI_HypothesisCreator::synchronizeCoords() {
     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;
@@ -982,10 +982,10 @@ void GHS3DPluginGUI_HypothesisCreator::addEnforcedMesh(std::string name, std::st
     
 }
 
-/** 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 *)));
@@ -1149,14 +1149,14 @@ void GHS3DPluginGUI_HypothesisCreator::addEnforcedVertex(double x, double y, dou
   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();
@@ -1219,14 +1219,14 @@ void GHS3DPluginGUI_HypothesisCreator::onAddEnforcedMesh()
 }
 
 
-/** 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();
@@ -1303,10 +1303,10 @@ void GHS3DPluginGUI_HypothesisCreator::onAddEnforcedVertex()
     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();
@@ -1330,10 +1330,10 @@ void GHS3DPluginGUI_HypothesisCreator::onRemoveEnforcedMesh()
   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();
@@ -1357,21 +1357,21 @@ void GHS3DPluginGUI_HypothesisCreator::onRemoveEnforcedVertex()
   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() );
@@ -1388,25 +1388,25 @@ void GHS3DPluginGUI_HypothesisCreator::updateWidgets()
   }
 }
 
-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 )
@@ -1579,10 +1579,10 @@ void GHS3DPluginGUI_HypothesisCreator::retrieveParams() const
   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 );
     
@@ -1650,11 +1650,11 @@ QString GHS3DPluginGUI_HypothesisCreator::storeParams() const
   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() : "";
@@ -1677,7 +1677,7 @@ bool GHS3DPluginGUI_HypothesisCreator::readParamsFromHypo( GHS3DHypothesisData&
   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++) {
@@ -1695,7 +1695,7 @@ bool GHS3DPluginGUI_HypothesisCreator::readParamsFromHypo( GHS3DHypothesisData&
     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++) {
@@ -1722,11 +1722,11 @@ bool GHS3DPluginGUI_HypothesisCreator::readParamsFromHypo( GHS3DHypothesisData&
   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
@@ -1771,7 +1771,7 @@ bool GHS3DPluginGUI_HypothesisCreator::storeParamsToHypo( const GHS3DHypothesisD
     
     // 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");
@@ -1797,7 +1797,7 @@ bool GHS3DPluginGUI_HypothesisCreator::storeParamsToHypo( const GHS3DHypothesisD
     
     // 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");
@@ -1850,9 +1850,9 @@ bool GHS3DPluginGUI_HypothesisCreator::storeParamsToHypo( const GHS3DHypothesisD
   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();
@@ -1925,22 +1925,22 @@ bool GHS3DPluginGUI_HypothesisCreator::readParamsFromWidgets( GHS3DHypothesisDat
   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";
 }
index 64a34429bd14e2c57ad56cf7c70778501a4fdd7b..0ac08d0362d3383a10ff077e782ff94ab099b467 100644 (file)
 // 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>
@@ -44,7 +44,7 @@
 #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)
 
@@ -61,7 +61,7 @@ class SMESHGUI_SpinBox;
 class StdMeshersGUI_ObjectReferenceParamWdg;
 class LightApp_SelectionMgr;
 class SUIT_SelectionFilter;
-class GHS3DPluginGUI_AdvWidget;
+class HYBRIDPluginGUI_AdvWidget;
 
 class QTEnfVertex
 {
@@ -150,18 +150,18 @@ typedef struct
   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;
@@ -203,9 +203,9 @@ signals:
   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();
 
@@ -217,7 +217,7 @@ private:
   QComboBox*          myOptimizationLevelCombo;
 
   QWidget*                  myAdvGroup;
-  GHS3DPluginGUI_AdvWidget* myAdvWidget;
+  HYBRIDPluginGUI_AdvWidget* myAdvWidget;
   
   QWidget*            myEnfGroup;
   QPixmap             iconVertex, iconCompound;
index 7f59dfee8759ad323e538c652fa486f0da71e036..71773ff314196a596d4d26e0b434a97aa0da13ab 100644 (file)
@@ -4,16 +4,16 @@
     <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>
index a7e3aca0ac9e4b5dea090f655190c10ed84d0ab7..77fd9252591dd1fb64a2c224bfebdb72c4fb1c31 100644 (file)
@@ -4,35 +4,35 @@
 <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>&lt;b&gt;Warning&lt;/b&gt;: 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>&lt;b&gt;Warning&lt;/b&gt;: Enforced meshes are currently only taken into account for meshes w/o associated geometry.</translation>
     </message>
 </context>
index 94a04c5cf291d725d97be7f378534b82b4449989..a529cf274c7522fe7654fe66746d3070982969f8 100755 (executable)
@@ -4,35 +4,35 @@
 <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&apos;optimisation</translation>
     </message>
     <message>
-        <source>GHS3D_PERMISSION_DENIED</source>
+        <source>HYBRID_PERMISSION_DENIED</source>
         <translation>Il n&apos;est pas possible d&apos;é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&apos;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>&lt;b&gt;Attention&lt;/b&gt;: 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>&lt;b&gt;Attention&lt;/b&gt;: Les éléments de contraintes ne sont pris en compte que pour des maillage sans géométrie associée.</translation>
     </message>
 </context>
index eac4660d458fbd802bc879a2fdb53797f42213ce..d1524aa474af5f4ad5b9f75756b71e3da840d80f 100644 (file)
@@ -4,35 +4,35 @@
   <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>&lt;b&gt;注意&lt;/b&gt;: 交差ポイント関連ジオメトリなしメッシュが考慮されます。</translation>
     </message>
     <message>
-      <source>GHS3D_ENF_MESH_INFO</source>
+      <source>HYBRID_ENF_MESH_INFO</source>
       <translation>&lt;b&gt;注意&lt;/b&gt;: 要素制約の関連付けられたジオメトリなしメッシュ考慮されます。</translation>
     </message>
   </context>
index f10a1f498407b4f23020e6233410e9f9f176525b..4e8ad072d05bd0b36e6a9f909d11b9e066f1f9f3 100644 (file)
@@ -57,29 +57,29 @@ SET(_link_LIBRARIES
   ${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 ---
@@ -87,15 +87,15 @@ SET(GHS3DEngine_SOURCES
 # 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)
index ec39a467247fdd6e89a147eb93b5761997ae9e8c..4c4b9b7d8c94057a411e21865148a621a55eceaa 100644 (file)
 #
 
 ##
-# @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
@@ -42,20 +42,20 @@ None_Optimization, Light_Optimization, Standard_Optimization, StandardPlus_Optim
 # 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"
@@ -66,8 +66,8 @@ class GHS3D_Algorithm(Mesh_Algorithm):
     #              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
 
@@ -75,8 +75,8 @@ class GHS3D_Algorithm(Mesh_Algorithm):
     #  @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
 
@@ -262,4 +262,4 @@ class GHS3D_Algorithm(Mesh_Algorithm):
         self.Parameters().SetTextOption(option)
         pass
     
-    pass # end of GHS3D_Algorithm class
+    pass # end of HYBRID_Algorithm class
index 0006d709441f27455e190a5fd4fe10ddfa2e24bb..07e2f214e3ab9729fd2a0f3b8534d342f076f48b 100644 (file)
 //
 
 //=============================================================================
-// 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
index e5c72f29a8bc03ff64fcd7adbca7eab5f27174a2..9c646d688670f395e1709f7487bd60b5d8f28823 100644 (file)
 //
 
 //=============================================================================
-// 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>
@@ -114,16 +114,16 @@ static void removeFile( const TCollection_AsciiString& fileName )
  */
 //=============================================================================
 
-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
 
@@ -147,9 +147,9 @@ GHS3DPlugin_GHS3D::GHS3DPlugin_GHS3D(int hypId, int studyId, SMESH_Gen* gen)
  */
 //=============================================================================
 
-GHS3DPlugin_GHS3D::~GHS3DPlugin_GHS3D()
+HYBRIDPlugin_HYBRID::~HYBRIDPlugin_HYBRID()
 {
-  MESSAGE("GHS3DPlugin_GHS3D::~GHS3DPlugin_GHS3D");
+  MESSAGE("HYBRIDPlugin_HYBRID::~HYBRIDPlugin_HYBRID");
 }
 
 //=============================================================================
@@ -158,7 +158,7 @@ GHS3DPlugin_GHS3D::~GHS3DPlugin_GHS3D()
  */
 //=============================================================================
 
-bool GHS3DPlugin_GHS3D::CheckHypothesis ( SMESH_Mesh&         aMesh,
+bool HYBRIDPlugin_HYBRID::CheckHypothesis ( SMESH_Mesh&         aMesh,
                                           const TopoDS_Shape& aShape,
                                           Hypothesis_Status&  aStatus )
 {
@@ -176,7 +176,7 @@ bool GHS3DPlugin_GHS3D::CheckHypothesis ( SMESH_Mesh&         aMesh,
   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 );
   }
@@ -196,9 +196,9 @@ bool GHS3DPlugin_GHS3D::CheckHypothesis ( SMESH_Mesh&         aMesh,
 //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() );
@@ -313,9 +313,9 @@ static bool isTmpFace(const SMDS_MeshNode* node1,
 
 //=======================================================================
 //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
 //=======================================================================
@@ -551,7 +551,7 @@ static int findShapeID(SMESH_Mesh&          mesh,
 //                         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)
@@ -636,8 +636,8 @@ static int findShapeID(SMESH_Mesh&          mesh,
 //   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);
@@ -652,13 +652,13 @@ static int findShapeID(SMESH_Mesh&          mesh,
 // 
 //     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] );
@@ -668,7 +668,7 @@ static int findShapeID(SMESH_Mesh&          mesh,
 //           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
@@ -735,7 +735,7 @@ static int findShapeID(SMESH_Mesh&          mesh,
 //       continue;
 // 
 //     int id[nbElem*tabRef[token]];
-//     int ghs3dShapeID[nbElem];
+//     int hybridShapeID[nbElem];
 // 
 //     if (token == GmfVertices) {
 //       std::cout << " vertices" << std::endl;
@@ -748,11 +748,11 @@ static int findShapeID(SMESH_Mesh&          mesh,
 //       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;
@@ -773,17 +773,17 @@ static int findShapeID(SMESH_Mesh&          mesh,
 //     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;
@@ -793,13 +793,13 @@ static int findShapeID(SMESH_Mesh&          mesh,
 //                   &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) {
@@ -868,21 +868,21 @@ static int findShapeID(SMESH_Mesh&          mesh,
 //           
 //           // 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
@@ -945,8 +945,8 @@ static int findShapeID(SMESH_Mesh&          mesh,
 //       } // 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 );
 //         }
@@ -1132,14 +1132,14 @@ static void makeDomainGroups( std::vector< std::vector< const SMDS_MeshElement*
 //=======================================================================
 
 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)
@@ -1148,7 +1148,7 @@ static bool readGMFFile(const char*                     theFile,
   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 = 
@@ -1157,7 +1157,7 @@ static bool readGMFFile(const char*                     theFile,
     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
@@ -1215,9 +1215,9 @@ static bool readGMFFile(const char*                     theFile,
         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) };
@@ -1286,7 +1286,7 @@ static bool readGMFFile(const char*                     theFile,
 //         while ( nodeIt->more() )
 //         {
 //           node = nodeIt->next();
-//           if (theNodeToGhs3dIdMap.find(node) != theNodeToGhs3dIdMap.end())
+//           if (theNodeToHybridIdMap.find(node) != theNodeToHybridIdMap.end())
 //             theMeshDS->RemoveNode(node);
 //         }
 //       }
@@ -1322,8 +1322,8 @@ static bool readGMFFile(const char*                     theFile,
           
           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);
         }
       }
     }
@@ -1400,7 +1400,7 @@ static bool readGMFFile(const char*                     theFile,
           if (aGMFNodeID <= nbInitialNodes) // input nodes
           {
             aGMFNodeID--;
-            node[ iRef ] = theNodeByGhs3dId[aGMFNodeID];
+            node[ iRef ] = theNodeByHybridId[aGMFNodeID];
           }
           else
           {
@@ -1416,15 +1416,15 @@ static bool readGMFFile(const char*                     theFile,
         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:
@@ -1563,33 +1563,33 @@ static bool writeGMFFile(const char*                                     theMesh
                          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();
@@ -1602,7 +1602,7 @@ static bool writeGMFFile(const char*                                     theMesh
   // count faces
   int nbFaces = theProxyMesh.NbFaces();
   int nbNodes;
-  theFaceByGhs3dId.reserve( nbFaces );
+  theFaceByHybridId.reserve( nbFaces );
   
   // groups management
   int usedEnforcedNodes = 0;
@@ -1627,10 +1627,10 @@ static bool writeGMFFile(const char*                                     theMesh
     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 ));
     }
   }
   
@@ -1643,7 +1643,7 @@ static bool writeGMFFile(const char*                                     theMesh
     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());
@@ -1659,7 +1659,7 @@ static bool writeGMFFile(const char*                                     theMesh
       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);
@@ -1669,19 +1669,19 @@ static bool writeGMFFile(const char*                                     theMesh
 #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)
@@ -1698,7 +1698,7 @@ static bool writeGMFFile(const char*                                     theMesh
     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());
@@ -1714,7 +1714,7 @@ static bool writeGMFFile(const char*                                     theMesh
       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);
@@ -1723,19 +1723,19 @@ static bool writeGMFFile(const char*                                     theMesh
 #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)
@@ -1743,28 +1743,28 @@ static bool writeGMFFile(const char*                                     theMesh
     }
   }
   
-  // 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
     }
   }
   
@@ -1772,14 +1772,14 @@ static bool writeGMFFile(const char*                                     theMesh
   /* ========================== 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());
@@ -1789,13 +1789,13 @@ static bool writeGMFFile(const char*                                     theMesh
   }
   
   // 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());
@@ -1847,7 +1847,7 @@ static bool writeGMFFile(const char*                                     theMesh
   
   
   // 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)
@@ -1954,15 +1954,15 @@ static bool writeGMFFile(const char*                                     theMesh
   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);
@@ -1981,12 +1981,12 @@ static bool writeGMFFile(const char*                                     theMesh
     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++;
     }
 
@@ -1998,9 +1998,9 @@ static bool writeGMFFile(const char*                                     theMesh
       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++;
     }
@@ -2012,7 +2012,7 @@ static bool writeGMFFile(const char*                                     theMesh
   // 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;
@@ -2023,19 +2023,19 @@ static bool writeGMFFile(const char*                                     theMesh
       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++;
     }
@@ -2053,47 +2053,47 @@ static bool writeGMFFile(const char*                                     theMesh
   // 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++;
       }
     }
@@ -2122,19 +2122,19 @@ static bool writeGMFFile(const char*                                     theMesh
 //                         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;
@@ -2154,7 +2154,7 @@ static bool writeGMFFile(const char*                                     theMesh
 //   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
@@ -2207,15 +2207,15 @@ static bool writeGMFFile(const char*                                     theMesh
 //     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 ));
 //   }
 //   
 //   
@@ -2243,8 +2243,8 @@ static bool writeGMFFile(const char*                                     theMesh
 //         continue;
 //       VerTab.push_back(coords);
 //       VerMap.insert(coords);
-//       aGhs3dID++;
-//       theNodeId2NodeIndexMap.insert( make_pair( (*enfNodeIt)->GetID(), aGhs3dID ));
+//       aHybridID++;
+//       theNodeId2NodeIndexMap.insert( make_pair( (*enfNodeIt)->GetID(), aHybridID ));
 //     }
 //   }
 //     
@@ -2333,13 +2333,13 @@ static bool writeGMFFile(const char*                                     theMesh
 //         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);
@@ -2384,9 +2384,9 @@ static bool writeGMFFile(const char*                                     theMesh
 //         }
 //         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);
@@ -2432,9 +2432,9 @@ static bool writeGMFFile(const char*                                     theMesh
 //         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);
@@ -2443,10 +2443,10 @@ static bool writeGMFFile(const char*                                     theMesh
 // 
 // 
 //   /* 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;
@@ -2509,10 +2509,10 @@ static bool writeGMFFile(const char*                                     theMesh
 // //         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);
@@ -2564,10 +2564,10 @@ static bool writeGMFFile(const char*                                     theMesh
 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:
   //
@@ -2639,14 +2639,14 @@ static bool writeFaces (ofstream &              theFile,
 
       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 ;
       }
@@ -2681,8 +2681,8 @@ static bool writeFaces (ofstream &              theFile,
 //     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;
@@ -2722,8 +2722,8 @@ static bool writeFaces (ofstream &              theFile,
 //     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;
@@ -2762,14 +2762,14 @@ static bool writeFaces (ofstream &              theFile,
 
 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:
   //
@@ -2787,11 +2787,11 @@ static bool writePoints (ofstream &                       theFile,
   
   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
@@ -2867,9 +2867,9 @@ static bool writePoints (ofstream &                       theFile,
     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
@@ -2885,7 +2885,7 @@ static bool writePoints (ofstream &                       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();
@@ -2905,7 +2905,7 @@ static bool writePoints (ofstream &                       theFile,
         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
@@ -2915,9 +2915,9 @@ static bool writePoints (ofstream &                       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 ");
     }
@@ -2925,7 +2925,7 @@ static bool writePoints (ofstream &                       theFile,
   
   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];
@@ -2946,8 +2946,8 @@ static bool writePoints (ofstream &                       theFile,
       << vertexIt->second << space 
       << dummyint << space;
       theFile << std::endl;
-      enfVertexIndexSizeMap[aGhs3dID] = vertexIt->second;
-      aGhs3dID++;
+      enfVertexIndexSizeMap[aHybridID] = vertexIt->second;
+      aHybridID++;
     }
   }
   
@@ -2967,21 +2967,21 @@ static bool readResultFile(const int                       fileOpen,
 #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;
@@ -2996,7 +2996,7 @@ static bool readResultFile(const int                       fileOpen,
 
   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() );
@@ -3064,10 +3064,10 @@ static bool readResultFile(const int                       fileOpen,
       // 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 ));
     }
   }
 
@@ -3079,16 +3079,16 @@ static bool readResultFile(const int                       fileOpen,
     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;
@@ -3097,7 +3097,7 @@ static bool readResultFile(const int                       fileOpen,
         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] );
@@ -3107,7 +3107,7 @@ static bool readResultFile(const int                       fileOpen,
           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
@@ -3141,27 +3141,27 @@ static bool readResultFile(const int                       fileOpen,
       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
@@ -3196,9 +3196,9 @@ static bool readResultFile(const int                       fileOpen,
       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_
@@ -3209,7 +3209,7 @@ static bool readResultFile(const int                       fileOpen,
     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;
@@ -3228,8 +3228,8 @@ static bool readResultFile(const int                       fileOpen,
         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();
           }
@@ -3259,8 +3259,8 @@ static bool readResultFile(const int                       fileOpen,
         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();
           }
@@ -3279,8 +3279,8 @@ static bool readResultFile(const int                       fileOpen,
 
   // 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 );
@@ -3329,18 +3329,18 @@ static bool readResultFile(const int                       fileOpen,
 
 //=============================================================================
 /*!
- *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() )
@@ -3370,7 +3370,7 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
 
   // 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";
 
@@ -3391,24 +3391,24 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
 //  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));
@@ -3465,10 +3465,10 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
   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 ));
 
@@ -3499,34 +3499,34 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         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;
   }
 
@@ -3537,17 +3537,17 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
       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)
@@ -3557,7 +3557,7 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
     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;
@@ -3565,7 +3565,7 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
   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
@@ -3577,15 +3577,15 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
   // 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 );
@@ -3596,7 +3596,7 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
 // #endif
 //                          this,
 //                          /*theMesh, */helper, tabShape, tabBox, _nbShape, 
-//                          aGhs3dIdToNodeMap, aNodeId2NodeIndexMap,
+//                          aHybridIdToNodeMap, aNodeId2NodeIndexMap,
 //                          toMeshHoles, 
 //                          nbEnforcedVertices, nbEnforcedNodes, 
 //                          enforcedEdges, enforcedTriangles,
@@ -3604,8 +3604,8 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
                          
     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 );
@@ -3629,15 +3629,15 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
   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 ) {
@@ -3648,9 +3648,9 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
     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;
@@ -3665,19 +3665,19 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
 
 //=============================================================================
 /*!
- *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";
 
@@ -3701,15 +3701,15 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
 
   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)
   {
@@ -3760,8 +3760,8 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
   }
 
 //   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;
@@ -3774,10 +3774,10 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
 //   }
 
 
-  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;
 
@@ -3788,10 +3788,10 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
   (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 )
@@ -3803,17 +3803,17 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
 
     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)
@@ -3823,7 +3823,7 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
     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;
@@ -3831,25 +3831,25 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
   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();
   }
@@ -3868,14 +3868,14 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
   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 )
@@ -3891,13 +3891,13 @@ bool GHS3DPlugin_GHS3D::Compute(SMESH_Mesh&         theMesh,
   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
@@ -3905,7 +3905,7 @@ void GHS3DPlugin_GHS3D::CancelCompute()
 
 //================================================================================
 /*!
- * \brief Provide human readable text by error code reported by ghs3d
+ * \brief Provide human readable text by error code reported by hybrid
  */
 //================================================================================
 
@@ -4225,7 +4225,7 @@ static char* getIds( char* ptr, int nbIds, vector<int>& ids )
  */
 //================================================================================
 
-bool GHS3DPlugin_GHS3D::storeErrorDescription(const TCollection_AsciiString& logFile,
+bool HYBRIDPlugin_HYBRID::storeErrorDescription(const TCollection_AsciiString& logFile,
                                               const _Ghs2smdsConvertor &     toSmdsConvertor )
 {
   if(_compute_canceled)
@@ -4483,7 +4483,7 @@ bool GHS3DPlugin_GHS3D::storeErrorDescription(const TCollection_AsciiString& log
     {
       char msg2[] = "SEGMENTATION FAULT";
       if ( search( &buf[0], bufEnd, msg2, msg2 + strlen(msg2)) != bufEnd )
-        errDescription << "ghs3d: SEGMENTATION FAULT. ";
+        errDescription << "hybrid: SEGMENTATION FAULT. ";
     }
   }
 
@@ -4519,7 +4519,7 @@ _Ghs2smdsConvertor::_Ghs2smdsConvertor( const vector <const SMDS_MeshNode*> &  n
 
 //================================================================================
 /*!
- * \brief Return SMDS element by ids of GHS3D nodes
+ * \brief Return SMDS element by ids of HYBRID nodes
  */
 //================================================================================
 
@@ -4568,7 +4568,7 @@ const SMDS_MeshElement* _Ghs2smdsConvertor::getElement(const vector<int>& ghsNod
  *
  */
 //=============================================================================
-bool GHS3DPlugin_GHS3D::Evaluate(SMESH_Mesh& aMesh,
+bool HYBRIDPlugin_HYBRID::Evaluate(SMESH_Mesh& aMesh,
                                  const TopoDS_Shape& aShape,
                                  MapShapeNbElems& aResMap)
 {
@@ -4643,11 +4643,11 @@ bool GHS3DPlugin_GHS3D::Evaluate(SMESH_Mesh& aMesh,
   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;
@@ -4655,7 +4655,7 @@ bool GHS3DPlugin_GHS3D::importGMFMesh(const char* theGMFFileName, SMESH_Mesh& th
 
   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;
 }
@@ -4677,7 +4677,7 @@ namespace
     /*!
      * \brief Returns an ID of listener
      */
-    static const char* Name() { return "GHS3DPlugin_GHS3D::_EnforcedMeshRestorer"; }
+    static const char* Name() { return "HYBRIDPlugin_HYBRID::_EnforcedMeshRestorer"; }
 
     //================================================================================
     /*!
@@ -4695,18 +4695,18 @@ namespace
            !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);
@@ -4722,7 +4722,7 @@ namespace
   {
     _GroupsOfDomainsRemover():
       SMESH_subMeshEventListener( /*isDeletable = */true,
-                                  "GHS3DPlugin_GHS3D::_GroupsOfDomainsRemover" ) {}
+                                  "HYBRIDPlugin_HYBRID::_GroupsOfDomainsRemover" ) {}
     /*!
      * \brief Treat events of the subMesh
      */
@@ -4748,14 +4748,14 @@ namespace
  */
 //================================================================================
 
-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() );
@@ -4779,7 +4779,7 @@ void GHS3DPlugin_GHS3D::SubmeshRestored(SMESH_subMesh* subMesh)
  */
 //================================================================================
 
-void GHS3DPlugin_GHS3D::SetEventListener(SMESH_subMesh* subMesh)
+void HYBRIDPlugin_HYBRID::SetEventListener(SMESH_subMesh* subMesh)
 {
   subMesh->SetEventListener( new _GroupsOfDomainsRemover(), 0, subMesh );
 }
index 0dc458e243583afb39c365bf099fca6935c2b6cb..4efcb08e902594379615a57f30b487f73ab7c665 100644 (file)
 //
 
 //=============================================================================
-// 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"
@@ -43,7 +43,7 @@ extern "C"
 #endif
 #define GMFDIMENSION 3
 
-class GHS3DPlugin_Hypothesis;
+class HYBRIDPlugin_Hypothesis;
 class SMDS_MeshNode;
 class SMESH_Mesh;
 class StdMeshers_ViscousLayers;
@@ -51,11 +51,11 @@ class TCollection_AsciiString;
 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,
@@ -79,10 +79,10 @@ public:
 
   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;
    
@@ -104,7 +104,7 @@ private:
 };
 
 /*!
- * \brief Convertor of GHS3D elements to SMDS ones
+ * \brief Convertor of HYBRID elements to SMDS ones
  */
 class _Ghs2smdsConvertor
 {
index 198f25848981ea7567bb185ceae7e1698c4b9512..94e3f575e85dabdbb508c9bc1e1557cc6106948b 100644 (file)
 //
 
 //  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 ), 
@@ -49,50 +49,50 @@ GHS3DPlugin_GHS3D_i::GHS3DPlugin_GHS3D_i (PortableServer::POA_ptr 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());
index 3f1a8b9a2bcc84ce8244ec578bda5a49fd07ed6f..e3cfb4692873c21d199007d13ea390be33346461 100644 (file)
 // 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);
 };
index 2b8378d8c3ecbcd4634e1117d38b753e7d1a2adf..68971c6f81aa4acafeea6fcce63fac4bf7bb6b1d 100644 (file)
 //
 
 //=============================================================================
-// 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()),
@@ -55,20 +55,20 @@ GHS3DPlugin_Hypothesis::GHS3DPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen
   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;
 }
 
@@ -76,7 +76,7 @@ GHS3DPlugin_Hypothesis::GHS3DPlugin_Hypothesis(int hypId, int studyId, SMESH_Gen
 //function : SetToMeshHoles
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetToMeshHoles(bool toMesh)
+void HYBRIDPlugin_Hypothesis::SetToMeshHoles(bool toMesh)
 {
   if ( myToMeshHoles != toMesh ) {
     myToMeshHoles = toMesh;
@@ -88,7 +88,7 @@ void GHS3DPlugin_Hypothesis::SetToMeshHoles(bool 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"))
@@ -103,7 +103,7 @@ bool GHS3DPlugin_Hypothesis::GetToMeshHoles(bool checkFreeOption) const
 //function : SetToMakeGroupsOfDomains
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetToMakeGroupsOfDomains(bool toMakeGroups)
+void HYBRIDPlugin_Hypothesis::SetToMakeGroupsOfDomains(bool toMakeGroups)
 {
   if ( myToMakeGroupsOfDomains != toMakeGroups ) {
     myToMakeGroupsOfDomains = toMakeGroups;
@@ -115,7 +115,7 @@ void GHS3DPlugin_Hypothesis::SetToMakeGroupsOfDomains(bool toMakeGroups)
 //function : GetToMakeGroupsOfDomains
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::GetToMakeGroupsOfDomains() const
+bool HYBRIDPlugin_Hypothesis::GetToMakeGroupsOfDomains() const
 {
   return myToMakeGroupsOfDomains;
 }
@@ -124,7 +124,7 @@ bool GHS3DPlugin_Hypothesis::GetToMakeGroupsOfDomains() const
 //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();
@@ -136,7 +136,7 @@ bool GHS3DPlugin_Hypothesis::GetToMakeGroupsOfDomains(const GHS3DPlugin_Hypothes
 //function : SetMaximumMemory
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetMaximumMemory(double MB)
+void HYBRIDPlugin_Hypothesis::SetMaximumMemory(double MB)
 {
   if ( myMaximumMemory != MB ) {
     myMaximumMemory = MB;
@@ -149,7 +149,7 @@ void GHS3DPlugin_Hypothesis::SetMaximumMemory(double MB)
 //           * automatic memory adjustment mode. Default is zero
 //=======================================================================
 
-double GHS3DPlugin_Hypothesis::GetMaximumMemory() const
+double HYBRIDPlugin_Hypothesis::GetMaximumMemory() const
 {
   return myMaximumMemory;
 }
@@ -158,7 +158,7 @@ double GHS3DPlugin_Hypothesis::GetMaximumMemory() const
 //function : SetInitialMemory
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetInitialMemory(double MB)
+void HYBRIDPlugin_Hypothesis::SetInitialMemory(double MB)
 {
   if ( myInitialMemory != MB ) {
     myInitialMemory = MB;
@@ -170,7 +170,7 @@ void GHS3DPlugin_Hypothesis::SetInitialMemory(double MB)
 //function : GetInitialMemory
 //=======================================================================
 
-double GHS3DPlugin_Hypothesis::GetInitialMemory() const
+double HYBRIDPlugin_Hypothesis::GetInitialMemory() const
 {
   return myInitialMemory;
 }
@@ -179,7 +179,7 @@ double GHS3DPlugin_Hypothesis::GetInitialMemory() const
 //function : SetOptimizationLevel
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetOptimizationLevel(OptimizationLevel level)
+void HYBRIDPlugin_Hypothesis::SetOptimizationLevel(OptimizationLevel level)
 {
   if ( myOptimizationLevel != level ) {
     myOptimizationLevel = level;
@@ -191,7 +191,7 @@ void GHS3DPlugin_Hypothesis::SetOptimizationLevel(OptimizationLevel level)
 //function : GetOptimizationLevel
 //=======================================================================
 
-GHS3DPlugin_Hypothesis::OptimizationLevel GHS3DPlugin_Hypothesis::GetOptimizationLevel() const
+HYBRIDPlugin_Hypothesis::OptimizationLevel HYBRIDPlugin_Hypothesis::GetOptimizationLevel() const
 {
   return (OptimizationLevel) myOptimizationLevel;
 }
@@ -200,7 +200,7 @@ GHS3DPlugin_Hypothesis::OptimizationLevel GHS3DPlugin_Hypothesis::GetOptimizatio
 //function : SetWorkingDirectory
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetWorkingDirectory(const std::string& path)
+void HYBRIDPlugin_Hypothesis::SetWorkingDirectory(const std::string& path)
 {
   if ( myWorkingDirectory != path ) {
     myWorkingDirectory = path;
@@ -212,7 +212,7 @@ void GHS3DPlugin_Hypothesis::SetWorkingDirectory(const std::string& path)
 //function : GetWorkingDirectory
 //=======================================================================
 
-std::string GHS3DPlugin_Hypothesis::GetWorkingDirectory() const
+std::string HYBRIDPlugin_Hypothesis::GetWorkingDirectory() const
 {
   return myWorkingDirectory;
 }
@@ -221,7 +221,7 @@ std::string GHS3DPlugin_Hypothesis::GetWorkingDirectory() const
 //function : SetKeepFiles
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetKeepFiles(bool toKeep)
+void HYBRIDPlugin_Hypothesis::SetKeepFiles(bool toKeep)
 {
   if ( myKeepFiles != toKeep ) {
     myKeepFiles = toKeep;
@@ -233,7 +233,7 @@ void GHS3DPlugin_Hypothesis::SetKeepFiles(bool toKeep)
 //function : GetKeepFiles
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::GetKeepFiles() const
+bool HYBRIDPlugin_Hypothesis::GetKeepFiles() const
 {
   return myKeepFiles;
 }
@@ -242,7 +242,7 @@ bool GHS3DPlugin_Hypothesis::GetKeepFiles() const
 //function : SetVerboseLevel
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetVerboseLevel(short level)
+void HYBRIDPlugin_Hypothesis::SetVerboseLevel(short level)
 {
   if ( myVerboseLevel != level ) {
     myVerboseLevel = level;
@@ -254,7 +254,7 @@ void GHS3DPlugin_Hypothesis::SetVerboseLevel(short level)
 //function : GetVerboseLevel
 //=======================================================================
 
-short GHS3DPlugin_Hypothesis::GetVerboseLevel() const
+short HYBRIDPlugin_Hypothesis::GetVerboseLevel() const
 {
   return myVerboseLevel;
 }
@@ -263,7 +263,7 @@ short GHS3DPlugin_Hypothesis::GetVerboseLevel() const
 //function : SetToCreateNewNodes
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetToCreateNewNodes(bool toCreate)
+void HYBRIDPlugin_Hypothesis::SetToCreateNewNodes(bool toCreate)
 {
   if ( myToCreateNewNodes != toCreate ) {
     myToCreateNewNodes = toCreate;
@@ -275,7 +275,7 @@ void GHS3DPlugin_Hypothesis::SetToCreateNewNodes(bool toCreate)
 //function : GetToCreateNewNodes
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::GetToCreateNewNodes() const
+bool HYBRIDPlugin_Hypothesis::GetToCreateNewNodes() const
 {
   return myToCreateNewNodes;
 }
@@ -284,7 +284,7 @@ bool GHS3DPlugin_Hypothesis::GetToCreateNewNodes() const
 //function : SetToUseBoundaryRecoveryVersion
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetToUseBoundaryRecoveryVersion(bool toUse)
+void HYBRIDPlugin_Hypothesis::SetToUseBoundaryRecoveryVersion(bool toUse)
 {
   if ( myToUseBoundaryRecoveryVersion != toUse ) {
     myToUseBoundaryRecoveryVersion = toUse;
@@ -296,7 +296,7 @@ void GHS3DPlugin_Hypothesis::SetToUseBoundaryRecoveryVersion(bool toUse)
 //function : GetToUseBoundaryRecoveryVersion
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::GetToUseBoundaryRecoveryVersion() const
+bool HYBRIDPlugin_Hypothesis::GetToUseBoundaryRecoveryVersion() const
 {
   return myToUseBoundaryRecoveryVersion;
 }
@@ -305,7 +305,7 @@ bool GHS3DPlugin_Hypothesis::GetToUseBoundaryRecoveryVersion() const
 //function : SetFEMCorrection
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetFEMCorrection(bool toUseFem)
+void HYBRIDPlugin_Hypothesis::SetFEMCorrection(bool toUseFem)
 {
   if ( myToUseFemCorrection != toUseFem ) {
     myToUseFemCorrection = toUseFem;
@@ -317,7 +317,7 @@ void GHS3DPlugin_Hypothesis::SetFEMCorrection(bool toUseFem)
 //function : GetFEMCorrection
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::GetFEMCorrection() const
+bool HYBRIDPlugin_Hypothesis::GetFEMCorrection() const
 {
   return myToUseFemCorrection;
 }
@@ -326,7 +326,7 @@ bool GHS3DPlugin_Hypothesis::GetFEMCorrection() const
 //function : SetToRemoveCentralPoint
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetToRemoveCentralPoint(bool toRemove)
+void HYBRIDPlugin_Hypothesis::SetToRemoveCentralPoint(bool toRemove)
 {
   if ( myToRemoveCentralPoint != toRemove ) {
     myToRemoveCentralPoint = toRemove;
@@ -338,7 +338,7 @@ void GHS3DPlugin_Hypothesis::SetToRemoveCentralPoint(bool toRemove)
 //function : GetToRemoveCentralPoint
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::GetToRemoveCentralPoint() const
+bool HYBRIDPlugin_Hypothesis::GetToRemoveCentralPoint() const
 {
   return myToRemoveCentralPoint;
 }
@@ -347,7 +347,7 @@ bool GHS3DPlugin_Hypothesis::GetToRemoveCentralPoint() const
 //function : SetTextOption
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetTextOption(const std::string& option)
+void HYBRIDPlugin_Hypothesis::SetTextOption(const std::string& option)
 {
   if ( myTextOption != option ) {
     myTextOption = option;
@@ -359,7 +359,7 @@ void GHS3DPlugin_Hypothesis::SetTextOption(const std::string& option)
 //function : GetTextOption
 //=======================================================================
 
-std::string GHS3DPlugin_Hypothesis::GetTextOption() const
+std::string HYBRIDPlugin_Hypothesis::GetTextOption() const
 {
   return myTextOption;
 }
@@ -368,7 +368,7 @@ std::string GHS3DPlugin_Hypothesis::GetTextOption() const
 //function : SetGradation
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetGradation(double gradation)
+void HYBRIDPlugin_Hypothesis::SetGradation(double gradation)
 {
   if ( myGradation != gradation ) {
     myGradation = gradation;
@@ -380,7 +380,7 @@ void GHS3DPlugin_Hypothesis::SetGradation(double gradation)
 //function : GetGradation
 //=======================================================================
 
-double GHS3DPlugin_Hypothesis::GetGradation() const
+double HYBRIDPlugin_Hypothesis::GetGradation() const
 {
   return myGradation;
 }
@@ -389,7 +389,7 @@ double GHS3DPlugin_Hypothesis::GetGradation() const
 //function : SetStandardOutputLog
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetStandardOutputLog(bool logInStandardOutput)
+void HYBRIDPlugin_Hypothesis::SetStandardOutputLog(bool logInStandardOutput)
 {
   if ( myLogInStandardOutput != logInStandardOutput ) {
     myLogInStandardOutput = logInStandardOutput;
@@ -401,7 +401,7 @@ void GHS3DPlugin_Hypothesis::SetStandardOutputLog(bool logInStandardOutput)
 //function : GetStandardOutputLog
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::GetStandardOutputLog() const
+bool HYBRIDPlugin_Hypothesis::GetStandardOutputLog() const
 {
   return myLogInStandardOutput;
 }
@@ -410,7 +410,7 @@ bool GHS3DPlugin_Hypothesis::GetStandardOutputLog() const
 //function : SetRemoveLogOnSuccess
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::SetRemoveLogOnSuccess(bool removeLogOnSuccess)
+void HYBRIDPlugin_Hypothesis::SetRemoveLogOnSuccess(bool removeLogOnSuccess)
 {
   if ( myRemoveLogOnSuccess != removeLogOnSuccess ) {
     myRemoveLogOnSuccess = removeLogOnSuccess;
@@ -422,7 +422,7 @@ void GHS3DPlugin_Hypothesis::SetRemoveLogOnSuccess(bool removeLogOnSuccess)
 //function : GetRemoveLogOnSuccess
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::GetRemoveLogOnSuccess() const
+bool HYBRIDPlugin_Hypothesis::GetRemoveLogOnSuccess() const
 {
   return myRemoveLogOnSuccess;
 }
@@ -431,17 +431,17 @@ bool GHS3DPlugin_Hypothesis::GetRemoveLogOnSuccess() const
 //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();
@@ -456,7 +456,7 @@ bool GHS3DPlugin_Hypothesis::SetEnforcedVertex(std::string theName, std::string
   
   
   // update _enfVertexList
-  TGHS3DEnforcedVertexList::iterator it = _enfVertexList.find(newEnfVertex);
+  THYBRIDEnforcedVertexList::iterator it = _enfVertexList.find(newEnfVertex);
   if (it != _enfVertexList.end()) {
     toCreate = false;
     oldEnVertex = (*it);
@@ -509,7 +509,7 @@ bool GHS3DPlugin_Hypothesis::SetEnforcedVertex(std::string theName, std::string
   if (toNotify)
     NotifySubMeshesHypothesisModification();
 
-  MESSAGE("GHS3DPlugin_Hypothesis::SetEnforcedVertex END");
+  MESSAGE("HYBRIDPlugin_Hypothesis::SetEnforcedVertex END");
   return toNotify;
 }
 
@@ -517,7 +517,7 @@ bool GHS3DPlugin_Hypothesis::SetEnforcedVertex(std::string theName, std::string
 //=======================================================================
 //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));
@@ -526,14 +526,14 @@ bool GHS3DPlugin_Hypothesis::SetEnforcedMesh(SMESH_Mesh& theMesh, SMESH::Element
   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);
@@ -548,9 +548,9 @@ bool GHS3DPlugin_Hypothesis::SetEnforcedMesh(SMESH_Mesh& theMesh, SMESH::Element
 //=======================================================================
 //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++) {
@@ -576,13 +576,13 @@ bool GHS3DPlugin_Hypothesis::SetEnforcedGroup(const SMESHDS_Mesh* theMeshDS, SME
   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);
@@ -594,9 +594,9 @@ bool GHS3DPlugin_Hypothesis::SetEnforcedGroup(const SMESHDS_Mesh* theMeshDS, SME
 //=======================================================================
 //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;
@@ -673,7 +673,7 @@ bool GHS3DPlugin_Hypothesis::SetEnforcedElements(TIDSortedElemSet theElemSet, SM
 //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);
@@ -687,7 +687,7 @@ GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex* GHS3DPlugin_Hypothesis::GetEnforce
   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)
@@ -702,19 +702,19 @@ GHS3DPlugin_Hypothesis::TGHS3DEnforcedVertex* GHS3DPlugin_Hypothesis::GetEnforce
 //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);
@@ -724,7 +724,7 @@ bool GHS3DPlugin_Hypothesis::RemoveEnforcedVertex(double x, double y, double z,
     // 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);
@@ -741,7 +741,7 @@ bool GHS3DPlugin_Hypothesis::RemoveEnforcedVertex(double x, double y, double 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);
@@ -759,9 +759,9 @@ bool GHS3DPlugin_Hypothesis::RemoveEnforcedVertex(double x, double y, double z,
 //=======================================================================
 //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);
@@ -777,9 +777,9 @@ void GHS3DPlugin_Hypothesis::ClearEnforcedVertices()
 //=======================================================================
 //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);
@@ -799,11 +799,11 @@ void GHS3DPlugin_Hypothesis::ClearEnforcedMeshes()
  */
 //================================================================================
 
-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,
@@ -818,7 +818,7 @@ void GHS3DPlugin_Hypothesis::RestoreEnfElemsByMeshes()
 //function : SetGroupsToRemove
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis::ClearGroupsToRemove()
+void HYBRIDPlugin_Hypothesis::ClearGroupsToRemove()
 {
   _groupsToRemove.clear();
 }
@@ -828,7 +828,7 @@ void GHS3DPlugin_Hypothesis::ClearGroupsToRemove()
 //function : DefaultMeshHoles
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::DefaultMeshHoles()
+bool HYBRIDPlugin_Hypothesis::DefaultMeshHoles()
 {
   return false; // PAL19680
 }
@@ -837,7 +837,7 @@ bool GHS3DPlugin_Hypothesis::DefaultMeshHoles()
 //function : DefaultToMakeGroupsOfDomains
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::DefaultToMakeGroupsOfDomains()
+bool HYBRIDPlugin_Hypothesis::DefaultToMakeGroupsOfDomains()
 {
   return false; // issue 0022172
 }
@@ -852,7 +852,7 @@ bool GHS3DPlugin_Hypothesis::DefaultToMakeGroupsOfDomains()
 #include <windows.h>
 #endif
 
-double  GHS3DPlugin_Hypothesis::DefaultMaximumMemory()
+double  HYBRIDPlugin_Hypothesis::DefaultMaximumMemory()
 {
 #ifndef WIN32
   struct sysinfo si;
@@ -881,7 +881,7 @@ double  GHS3DPlugin_Hypothesis::DefaultMaximumMemory()
 //function : DefaultInitialMemory
 //=======================================================================
 
-double  GHS3DPlugin_Hypothesis::DefaultInitialMemory()
+double  HYBRIDPlugin_Hypothesis::DefaultInitialMemory()
 {
   return DefaultMaximumMemory();
 }
@@ -890,7 +890,7 @@ double  GHS3DPlugin_Hypothesis::DefaultInitialMemory()
 //function : DefaultOptimizationLevel
 //=======================================================================
 
-short  GHS3DPlugin_Hypothesis::DefaultOptimizationLevel()
+short  HYBRIDPlugin_Hypothesis::DefaultOptimizationLevel()
 {
   return Medium;
 }
@@ -899,7 +899,7 @@ short  GHS3DPlugin_Hypothesis::DefaultOptimizationLevel()
 //function : DefaultWorkingDirectory
 //=======================================================================
 
-std::string GHS3DPlugin_Hypothesis::DefaultWorkingDirectory()
+std::string HYBRIDPlugin_Hypothesis::DefaultWorkingDirectory()
 {
   TCollection_AsciiString aTmpDir;
 
@@ -921,7 +921,7 @@ std::string GHS3DPlugin_Hypothesis::DefaultWorkingDirectory()
 //function : DefaultKeepFiles
 //=======================================================================
 
-bool   GHS3DPlugin_Hypothesis::DefaultKeepFiles()
+bool   HYBRIDPlugin_Hypothesis::DefaultKeepFiles()
 {
   return false;
 }
@@ -930,7 +930,7 @@ bool   GHS3DPlugin_Hypothesis::DefaultKeepFiles()
 //function : DefaultRemoveLogOnSuccess
 //=======================================================================
 
-bool   GHS3DPlugin_Hypothesis::DefaultRemoveLogOnSuccess()
+bool   HYBRIDPlugin_Hypothesis::DefaultRemoveLogOnSuccess()
 {
   return false;
 }
@@ -940,7 +940,7 @@ bool   GHS3DPlugin_Hypothesis::DefaultRemoveLogOnSuccess()
 //function : DefaultVerboseLevel
 //=======================================================================
 
-short  GHS3DPlugin_Hypothesis::DefaultVerboseLevel()
+short  HYBRIDPlugin_Hypothesis::DefaultVerboseLevel()
 {
   return 10;
 }
@@ -949,7 +949,7 @@ short  GHS3DPlugin_Hypothesis::DefaultVerboseLevel()
 //function : DefaultToCreateNewNodes
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::DefaultToCreateNewNodes()
+bool HYBRIDPlugin_Hypothesis::DefaultToCreateNewNodes()
 {
   return true;
 }
@@ -958,7 +958,7 @@ bool GHS3DPlugin_Hypothesis::DefaultToCreateNewNodes()
 //function : DefaultToUseBoundaryRecoveryVersion
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::DefaultToUseBoundaryRecoveryVersion()
+bool HYBRIDPlugin_Hypothesis::DefaultToUseBoundaryRecoveryVersion()
 {
   return false;
 }
@@ -967,7 +967,7 @@ bool GHS3DPlugin_Hypothesis::DefaultToUseBoundaryRecoveryVersion()
 //function : DefaultToUseFEMCorrection
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::DefaultToUseFEMCorrection()
+bool HYBRIDPlugin_Hypothesis::DefaultToUseFEMCorrection()
 {
   return false;
 }
@@ -976,7 +976,7 @@ bool GHS3DPlugin_Hypothesis::DefaultToUseFEMCorrection()
 //function : DefaultToRemoveCentralPoint
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::DefaultToRemoveCentralPoint()
+bool HYBRIDPlugin_Hypothesis::DefaultToRemoveCentralPoint()
 {
   return false;
 }
@@ -985,7 +985,7 @@ bool GHS3DPlugin_Hypothesis::DefaultToRemoveCentralPoint()
 //function : DefaultGradation
 //=======================================================================
 
-double GHS3DPlugin_Hypothesis::DefaultGradation()
+double HYBRIDPlugin_Hypothesis::DefaultGradation()
 {
   return 1.05;
 }
@@ -994,7 +994,7 @@ double GHS3DPlugin_Hypothesis::DefaultGradation()
 //function : DefaultStandardOutputLog
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::DefaultStandardOutputLog()
+bool HYBRIDPlugin_Hypothesis::DefaultStandardOutputLog()
 {
   return false;
 }
@@ -1003,9 +1003,9 @@ bool GHS3DPlugin_Hypothesis::DefaultStandardOutputLog()
 // //function : DefaultID2SizeMap
 // //=======================================================================
 // 
-// GHS3DPlugin_Hypothesis::TID2SizeMap GHS3DPlugin_Hypothesis::DefaultID2SizeMap()
+// HYBRIDPlugin_Hypothesis::TID2SizeMap HYBRIDPlugin_Hypothesis::DefaultID2SizeMap()
 // {
-//   return GHS3DPlugin_Hypothesis::TID2SizeMap();
+//   return HYBRIDPlugin_Hypothesis::TID2SizeMap();
 // }
 
 
@@ -1013,7 +1013,7 @@ bool GHS3DPlugin_Hypothesis::DefaultStandardOutputLog()
 //function : SaveTo
 //=======================================================================
 
-std::ostream & GHS3DPlugin_Hypothesis::SaveTo(std::ostream & save)
+std::ostream & HYBRIDPlugin_Hypothesis::SaveTo(std::ostream & save)
 {
   save << (int) myToMeshHoles                 << " ";
   save << myMaximumMemory                     << " ";
@@ -1035,11 +1035,11 @@ std::ostream & GHS3DPlugin_Hypothesis::SaveTo(std::ostream & save)
   }
   
 
-  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__";
@@ -1071,11 +1071,11 @@ std::ostream & GHS3DPlugin_Hypothesis::SaveTo(std::ostream & save)
     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__";
@@ -1109,7 +1109,7 @@ std::ostream & GHS3DPlugin_Hypothesis::SaveTo(std::ostream & save)
 //function : LoadFrom
 //=======================================================================
 
-std::istream & GHS3DPlugin_Hypothesis::LoadFrom(std::istream & load)
+std::istream & HYBRIDPlugin_Hypothesis::LoadFrom(std::istream & load)
 {
   bool isOK = true;
   int i;
@@ -1255,7 +1255,7 @@ std::istream & GHS3DPlugin_Hypothesis::LoadFrom(std::istream & load)
       if (txt == "__ENFORCED_VERTICES_END__")
         isOK = false;
 
-      TGHS3DEnforcedVertex *enfVertex = new TGHS3DEnforcedVertex();
+      THYBRIDEnforcedVertex *enfVertex = new THYBRIDEnforcedVertex();
       while (isOK) {
         isOK = (load >> txt);
         if (txt == "__END_VERTEX__") {
@@ -1351,7 +1351,7 @@ std::istream & GHS3DPlugin_Hypothesis::LoadFrom(std::istream & load)
       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__") {
@@ -1430,7 +1430,7 @@ std::istream & GHS3DPlugin_Hypothesis::LoadFrom(std::istream & load)
 //function : SetParametersByMesh
 //=======================================================================
 
-bool GHS3DPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh* ,const TopoDS_Shape&)
+bool HYBRIDPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh* ,const TopoDS_Shape&)
 {
   return false;
 }
@@ -1442,7 +1442,7 @@ bool GHS3DPlugin_Hypothesis::SetParametersByMesh(const SMESH_Mesh* ,const TopoDS
  */
 //================================================================================
 
-bool GHS3DPlugin_Hypothesis::SetParametersByDefaults(const TDefaults&  dflts,
+bool HYBRIDPlugin_Hypothesis::SetParametersByDefaults(const TDefaults&  dflts,
                                                      const SMESH_Mesh* /*theMesh*/)
 {
   myToMakeGroupsOfDomains = ( !dflts._shape || dflts._shape->IsNull() );
@@ -1451,11 +1451,11 @@ bool GHS3DPlugin_Hypothesis::SetParametersByDefaults(const TDefaults&  dflts,
 
 //================================================================================
 /*!
- * \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();
@@ -1476,8 +1476,8 @@ std::string GHS3DPlugin_Hypothesis::CommandToRun(const GHS3DPlugin_Hypothesis* h
   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;
@@ -1499,7 +1499,7 @@ std::string GHS3DPlugin_Hypothesis::CommandToRun(const GHS3DPlugin_Hypothesis* h
   // 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 {
@@ -1571,7 +1571,7 @@ std::string GHS3DPlugin_Hypothesis::CommandToRun(const GHS3DPlugin_Hypothesis* h
  */
 //================================================================================
 
-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();
@@ -1582,7 +1582,7 @@ std::string GHS3DPlugin_Hypothesis::GetFileName(const GHS3DPlugin_Hypothesis* hy
 #endif      
 
   TCollection_AsciiString aGenericName = (char*)aTmpDir.c_str();
-  aGenericName += "GHS3D_";
+  aGenericName += "HYBRID_";
   aGenericName += getpid();
   aGenericName += "_";
   aGenericName += Abs((Standard_Integer)(long) aGenericName.ToCString());
@@ -1596,7 +1596,7 @@ std::string GHS3DPlugin_Hypothesis::GetFileName(const GHS3DPlugin_Hypothesis* hy
  */
 //================================================================================
 
-std::string GHS3DPlugin_Hypothesis::GetExeName()
+std::string HYBRIDPlugin_Hypothesis::GetExeName()
 {
   return "mg-tetra.exe";
 }
@@ -1607,52 +1607,52 @@ std::string GHS3DPlugin_Hypothesis::GetExeName()
 */
 //================================================================================
 
-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();
 }
index eb0c1f80b89c6013d7d92b2c1261d1ed3d8bf74e..31150ad28c55726fb7dc43fe955aa1b362ea39fd 100644 (file)
 // 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;
@@ -58,8 +58,8 @@ public:
     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);
@@ -69,19 +69,19 @@ public:
       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;
@@ -89,8 +89,8 @@ public:
     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);
@@ -101,11 +101,11 @@ public:
         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;
 
@@ -118,7 +118,7 @@ public:
   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.
    */
@@ -225,14 +225,14 @@ public:
   
 
   /*!
-   * \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
    */
@@ -243,14 +243,14 @@ public:
    */
   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();
 
   /*!
@@ -259,8 +259,8 @@ public:
   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; }
@@ -271,20 +271,20 @@ public:
   /*!
    * \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();
@@ -303,17 +303,17 @@ public:
   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();}
@@ -322,8 +322,8 @@ public:
   // 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
@@ -354,18 +354,18 @@ private:
   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;
index 0e2f6b8fd144a24607d8c4b7ed4e37f5fd40845c..105ccfb23e9a32e612325085da912f328e0838eb 100644 (file)
 // 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);
@@ -84,7 +84,7 @@ void GHS3DPlugin_Hypothesis_i::SetToMeshHoles(CORBA::Boolean toMesh)
 //function : GetToMeshHoles
 //=======================================================================
 
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToMeshHoles()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToMeshHoles()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetToMeshHoles();
@@ -94,7 +94,7 @@ CORBA::Boolean GHS3DPlugin_Hypothesis_i::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);
@@ -105,7 +105,7 @@ void GHS3DPlugin_Hypothesis_i::SetToMakeGroupsOfDomains(CORBA::Boolean toMakeGro
 //function : GetToMakeGroupsOfDomains
 //=======================================================================
 
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToMakeGroupsOfDomains()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToMakeGroupsOfDomains()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetToMakeGroupsOfDomains();
@@ -115,7 +115,7 @@ CORBA::Boolean GHS3DPlugin_Hypothesis_i::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 )
@@ -129,7 +129,7 @@ void GHS3DPlugin_Hypothesis_i::SetMaximumMemory(CORBA::Double MB)
 //function : GetMaximumMemory
 //=======================================================================
 
-CORBA::Double GHS3DPlugin_Hypothesis_i::GetMaximumMemory()
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetMaximumMemory()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetMaximumMemory();
@@ -139,7 +139,7 @@ CORBA::Double GHS3DPlugin_Hypothesis_i::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 )
@@ -153,7 +153,7 @@ void GHS3DPlugin_Hypothesis_i::SetInitialMemory(CORBA::Double MB)
 //function : GetInitialMemory
 //=======================================================================
 
-CORBA::Double GHS3DPlugin_Hypothesis_i::GetInitialMemory()
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetInitialMemory()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetInitialMemory();
@@ -163,13 +163,13 @@ CORBA::Double GHS3DPlugin_Hypothesis_i::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);
@@ -181,7 +181,7 @@ void GHS3DPlugin_Hypothesis_i::SetOptimizationLevel(CORBA::Short level)
 //function : GetOptimizationLevel
 //=======================================================================
 
-CORBA::Short GHS3DPlugin_Hypothesis_i::GetOptimizationLevel()
+CORBA::Short HYBRIDPlugin_Hypothesis_i::GetOptimizationLevel()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetOptimizationLevel();
@@ -191,7 +191,7 @@ CORBA::Short GHS3DPlugin_Hypothesis_i::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 );
@@ -203,7 +203,7 @@ void GHS3DPlugin_Hypothesis_i::SetWorkingDirectory(const char* path) throw ( SAL
 #else
   if ( lastChar != '/' ) file += '/';
 #endif
-  file += "GHS3D.log";
+  file += "HYBRID.log";
   SMESH_Mesh_i::PrepareForWriting (file.c_str());
 
   ASSERT(myBaseImpl);
@@ -215,7 +215,7 @@ void GHS3DPlugin_Hypothesis_i::SetWorkingDirectory(const char* path) throw ( SAL
 //function : GetWorkingDirectory
 //=======================================================================
 
-char* GHS3DPlugin_Hypothesis_i::GetWorkingDirectory()
+char* HYBRIDPlugin_Hypothesis_i::GetWorkingDirectory()
 {
   ASSERT(myBaseImpl);
   return CORBA::string_dup( this->GetImpl()->GetWorkingDirectory().c_str() );
@@ -225,7 +225,7 @@ char* GHS3DPlugin_Hypothesis_i::GetWorkingDirectory()
 //function : SetKeepFiles
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis_i::SetKeepFiles(CORBA::Boolean toKeep)
+void HYBRIDPlugin_Hypothesis_i::SetKeepFiles(CORBA::Boolean toKeep)
 {
   ASSERT(myBaseImpl);
   this->GetImpl()->SetKeepFiles(toKeep);
@@ -236,7 +236,7 @@ void GHS3DPlugin_Hypothesis_i::SetKeepFiles(CORBA::Boolean toKeep)
 //function : GetKeepFiles
 //=======================================================================
 
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetKeepFiles()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetKeepFiles()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetKeepFiles();
@@ -246,7 +246,7 @@ CORBA::Boolean GHS3DPlugin_Hypothesis_i::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 )
@@ -261,7 +261,7 @@ void GHS3DPlugin_Hypothesis_i::SetVerboseLevel(CORBA::Short level)
 //function : GetVerboseLevel
 //=======================================================================
 
-CORBA::Short GHS3DPlugin_Hypothesis_i::GetVerboseLevel()
+CORBA::Short HYBRIDPlugin_Hypothesis_i::GetVerboseLevel()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetVerboseLevel();
@@ -271,7 +271,7 @@ CORBA::Short GHS3DPlugin_Hypothesis_i::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);
@@ -282,7 +282,7 @@ void GHS3DPlugin_Hypothesis_i::SetToCreateNewNodes(CORBA::Boolean toCreate)
 //function : GetToCreateNewNodes
 //=======================================================================
 
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToCreateNewNodes()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToCreateNewNodes()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetToCreateNewNodes();
@@ -292,7 +292,7 @@ CORBA::Boolean GHS3DPlugin_Hypothesis_i::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);
@@ -303,7 +303,7 @@ void GHS3DPlugin_Hypothesis_i::SetToUseBoundaryRecoveryVersion(CORBA::Boolean to
 //function : GetToUseBoundaryRecoveryVersion
 //=======================================================================
 
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToUseBoundaryRecoveryVersion()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToUseBoundaryRecoveryVersion()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetToUseBoundaryRecoveryVersion();
@@ -313,7 +313,7 @@ CORBA::Boolean GHS3DPlugin_Hypothesis_i::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);
@@ -324,7 +324,7 @@ void GHS3DPlugin_Hypothesis_i::SetFEMCorrection(CORBA::Boolean toUseFem)
 //function : GetFEMCorrection
 //=======================================================================
 
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetFEMCorrection()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetFEMCorrection()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetFEMCorrection();
@@ -334,7 +334,7 @@ CORBA::Boolean GHS3DPlugin_Hypothesis_i::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);
@@ -345,7 +345,7 @@ void GHS3DPlugin_Hypothesis_i::SetToRemoveCentralPoint(CORBA::Boolean toRemove)
 //function : GetToRemoveCentralPoint
 //=======================================================================
 
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetToRemoveCentralPoint()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetToRemoveCentralPoint()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetToRemoveCentralPoint();
@@ -355,7 +355,7 @@ CORBA::Boolean GHS3DPlugin_Hypothesis_i::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);
@@ -366,7 +366,7 @@ void GHS3DPlugin_Hypothesis_i::SetTextOption(const char* option)
 //function : GetTextOption
 //=======================================================================
 
-char* GHS3DPlugin_Hypothesis_i::GetTextOption()
+char* HYBRIDPlugin_Hypothesis_i::GetTextOption()
 {
   ASSERT(myBaseImpl);
   return CORBA::string_dup( this->GetImpl()->GetTextOption().c_str() );
@@ -376,7 +376,7 @@ char* GHS3DPlugin_Hypothesis_i::GetTextOption()
 //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 );
@@ -391,7 +391,7 @@ void GHS3DPlugin_Hypothesis_i::SetGradation(CORBA::Double gradation)
 //function : GetToRemoveCentralPoint
 //=======================================================================
 
-CORBA::Double GHS3DPlugin_Hypothesis_i::GetGradation()
+CORBA::Double HYBRIDPlugin_Hypothesis_i::GetGradation()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetGradation();
@@ -401,7 +401,7 @@ CORBA::Double GHS3DPlugin_Hypothesis_i::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);
@@ -412,7 +412,7 @@ void GHS3DPlugin_Hypothesis_i::SetStandardOutputLog(CORBA::Boolean logInStandard
 //function : GetStandardOutputLog
 //=======================================================================
 
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetStandardOutputLog()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetStandardOutputLog()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetStandardOutputLog();
@@ -422,7 +422,7 @@ CORBA::Boolean GHS3DPlugin_Hypothesis_i::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);
@@ -433,7 +433,7 @@ void GHS3DPlugin_Hypothesis_i::SetRemoveLogOnSuccess(CORBA::Boolean removeLogOnS
 //function : GetRemoveLogOnSuccess
 //=======================================================================
 
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::GetRemoveLogOnSuccess()
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::GetRemoveLogOnSuccess()
 {
   ASSERT(myBaseImpl);
   return this->GetImpl()->GetRemoveLogOnSuccess();
@@ -443,35 +443,35 @@ CORBA::Boolean GHS3DPlugin_Hypothesis_i::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);
   
@@ -517,7 +517,7 @@ bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexGeom(GEOM::GEOM_Object_ptr theVe
   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);
   
@@ -563,7 +563,7 @@ bool GHS3DPlugin_Hypothesis_i::SetEnforcedVertexGeomWithGroup(GEOM::GEOM_Object_
   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) {
@@ -571,8 +571,8 @@ bool GHS3DPlugin_Hypothesis_i:: p_SetEnforcedVertex(CORBA::Double size, CORBA::D
   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;
@@ -585,7 +585,7 @@ bool GHS3DPlugin_Hypothesis_i:: p_SetEnforcedVertex(CORBA::Double size, CORBA::D
     }
     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);
@@ -614,14 +614,14 @@ bool GHS3DPlugin_Hypothesis_i:: p_SetEnforcedVertex(CORBA::Double size, CORBA::D
   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);
@@ -651,7 +651,7 @@ bool GHS3DPlugin_Hypothesis_i:: p_SetEnforcedVertex(CORBA::Double size, CORBA::D
 //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);
@@ -664,7 +664,7 @@ CORBA::Double GHS3DPlugin_Hypothesis_i::GetEnforcedVertex(CORBA::Double x, CORBA
     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);
   }
@@ -677,7 +677,7 @@ CORBA::Double GHS3DPlugin_Hypothesis_i::GetEnforcedVertex(CORBA::Double x, CORBA
 //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);
@@ -715,7 +715,7 @@ CORBA::Double GHS3DPlugin_Hypothesis_i::GetEnforcedVertexGeom(GEOM::GEOM_Object_
     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);
   }
@@ -728,25 +728,25 @@ CORBA::Double GHS3DPlugin_Hypothesis_i::GetEnforcedVertexGeom(GEOM::GEOM_Object_
 //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];
@@ -770,7 +770,7 @@ GHS3DPlugin::GHS3DEnforcedVertexList* GHS3DPlugin_Hypothesis_i::GetEnforcedVerti
 //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);
@@ -783,7 +783,7 @@ bool GHS3DPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Doub
     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);
   }
@@ -792,7 +792,7 @@ bool GHS3DPlugin_Hypothesis_i::RemoveEnforcedVertex(CORBA::Double x, CORBA::Doub
   }
 }
 
-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);
@@ -828,7 +828,7 @@ bool GHS3DPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr th
     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);
   }
@@ -841,7 +841,7 @@ bool GHS3DPlugin_Hypothesis_i::RemoveEnforcedVertexGeom(GEOM::GEOM_Object_ptr th
 //function : ClearEnforcedVertices
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis_i::ClearEnforcedVertices()
+void HYBRIDPlugin_Hypothesis_i::ClearEnforcedVertices()
 {
   ASSERT(myBaseImpl);
   this->GetImpl()->ClearEnforcedVertices();
@@ -852,7 +852,7 @@ void GHS3DPlugin_Hypothesis_i::ClearEnforcedVertices()
 //function : ClearEnforcedMeshes
 //=======================================================================
 
-void GHS3DPlugin_Hypothesis_i::ClearEnforcedMeshes()
+void HYBRIDPlugin_Hypothesis_i::ClearEnforcedMeshes()
 {
   ASSERT(myBaseImpl);
   this->GetImpl()->ClearEnforcedMeshes();
@@ -863,19 +863,19 @@ void GHS3DPlugin_Hypothesis_i::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
@@ -896,16 +896,16 @@ GHS3DPlugin::GHS3DEnforcedMeshList* GHS3DPlugin_Hypothesis_i::GetEnforcedMeshes(
 /*!
  * \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
@@ -914,17 +914,17 @@ bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshWithGroup(SMESH::SMESH_IDSource_pt
 /*!
  * \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
@@ -933,16 +933,16 @@ bool GHS3DPlugin_Hypothesis_i::SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSour
 /*!
  * \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
@@ -951,25 +951,25 @@ bool GHS3DPlugin_Hypothesis_i::SetEnforcedMeshSizeWithGroup(SMESH::SMESH_IDSourc
 /*!
  * \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 ))
@@ -977,7 +977,7 @@ bool GHS3DPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSo
     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);
   }
@@ -1007,7 +1007,7 @@ bool GHS3DPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSo
 //     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);
   }
@@ -1043,7 +1043,7 @@ bool GHS3DPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSo
       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);
     }
@@ -1070,7 +1070,7 @@ bool GHS3DPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSo
       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);
     }
@@ -1097,7 +1097,7 @@ bool GHS3DPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSo
       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);
     }
@@ -1113,9 +1113,9 @@ bool GHS3DPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSo
  */
 //=============================================================================
 
-::GHS3DPlugin_Hypothesis* GHS3DPlugin_Hypothesis_i::GetImpl()
+::HYBRIDPlugin_Hypothesis* HYBRIDPlugin_Hypothesis_i::GetImpl()
 {
-  return (::GHS3DPlugin_Hypothesis*)myBaseImpl;
+  return (::HYBRIDPlugin_Hypothesis*)myBaseImpl;
 }
 
 //================================================================================
@@ -1124,7 +1124,7 @@ bool GHS3DPlugin_Hypothesis_i::p_SetEnforcedMesh(SMESH::SMESH_IDSource_ptr theSo
  */
 //================================================================================  
 
-CORBA::Boolean GHS3DPlugin_Hypothesis_i::IsDimSupported( SMESH::Dimension type )
+CORBA::Boolean HYBRIDPlugin_Hypothesis_i::IsDimSupported( SMESH::Dimension type )
 {
   return type == SMESH::DIM_3D;
 }
index a23952ca8bf8e7ec7b42fcc999e25e8c7ebe7889..3dbe108bff69ab35ed881cda41fc63dc84e741bf 100644 (file)
 // 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.
@@ -161,7 +161,7 @@ class GHS3DPLUGIN_EXPORT GHS3DPlugin_Hypothesis_i:
   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
@@ -175,11 +175,11 @@ class GHS3DPLUGIN_EXPORT GHS3DPlugin_Hypothesis_i:
   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 );
index e5164c218f490530b55ad3baeaad0313db79df4d..ceafd9ae4ffa6637a262e9f88a62e2a10b570383 100644 (file)
@@ -17,8 +17,8 @@
 // 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"; }
 };
 
 //=============================================================================
@@ -44,9 +44,9 @@ template <class T> class GHS3DPlugin_Creator_i:public HypothesisCreator_i<T>
 
 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);
@@ -56,11 +56,11 @@ extern "C"
     // 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;
index 72bdea53ebfa34281c28a777e5a2c113bc8d5005..28275922810209318554d8f999853bfab8985326 100644 (file)
@@ -18,6 +18,6 @@
 #
 
 ##
-# @package GHS3DPluginBuilder
-# Python API for the GHS3D meshing plug-in module.
+# @package HYBRIDPluginBuilder
+# Python API for the HYBRID meshing plug-in module.