CMAKE_MINIMUM_REQUIRED(VERSION 2.8.2 FATAL_ERROR)
#INCLUDE(CMakeDependentOption)
-PROJECT(MEDtool C CXX)
+PROJECT(MEDCoupling C CXX)
# Ensure a proper linker behavior:
CMAKE_POLICY(SET CMP0003 NEW)
# Our own set of macros:
LIST(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake_files")
-INCLUDE(MEDtoolMacros)
+INCLUDE(MEDCouplingMacros)
# Platform setup
# ==============
# User options
# ============
INCLUDE(CMakeDependentOption)
-OPTION(MEDTOOL_MED_MICROMED "Build MED without MED file dependancy." OFF)
-OPTION(MEDTOOL_MED_ENABLE_PYTHON "Build PYTHON bindings." ON)
-OPTION(MEDTOOL_MED_ENABLE_PARTITIONER "Build MEDPartitioner." ON)
-OPTION(MEDTOOL_MED_ENABLE_RENUMBER "Build Renumber." ON)
-OPTION(MEDTOOL_MED_WITH_FILE_EXAMPLES "Install examples of files containing meshes and fields of different formats." ON)
-OPTION(MEDTOOL_USE_MPI "(Use MPI containers) - For MED this triggers the build of ParaMEDMEM." OFF)
-OPTION(MEDTOOL_BUILD_TESTS "Build MED tests." ON)
-OPTION(MEDTOOL_BUILD_DOC "Build MED doc." ON)
-CMAKE_DEPENDENT_OPTION(MEDTOOL_MED_PARTITIONER_METIS "Enable metis graph library in MEDPartitioner." ON "MEDTOOL_MED_ENABLE_PARTITIONER" OFF)
-CMAKE_DEPENDENT_OPTION(MEDTOOL_MED_PARTITIONER_SCOTCH "Enable scotch graph library in MEDPartitioner." ON "MEDTOOL_MED_ENABLE_PARTITIONER;NOT MEDTOOL_USE_MPI" OFF)
-CMAKE_DEPENDENT_OPTION(MEDTOOL_MED_PARTITIONER_PARMETIS "Enable parmetis graph library in MEDPartitioner." ON "MEDTOOL_MED_ENABLE_PARTITIONER;MEDTOOL_USE_MPI" OFF)
+OPTION(MEDCOUPLING_MED_MICROMED "Build MED without MED file dependancy." OFF)
+OPTION(MEDCOUPLING_MED_ENABLE_PYTHON "Build PYTHON bindings." ON)
+OPTION(MEDCOUPLING_MED_ENABLE_PARTITIONER "Build MEDPartitioner." ON)
+OPTION(MEDCOUPLING_MED_ENABLE_RENUMBER "Build Renumber." ON)
+OPTION(MEDCOUPLING_MED_WITH_FILE_EXAMPLES "Install examples of files containing meshes and fields of different formats." ON)
+OPTION(MEDCOUPLING_USE_MPI "(Use MPI containers) - For MED this triggers the build of ParaMEDMEM." OFF)
+OPTION(MEDCOUPLING_BUILD_TESTS "Build MED tests." ON)
+OPTION(MEDCOUPLING_BUILD_DOC "Build MED doc." ON)
+CMAKE_DEPENDENT_OPTION(MEDCOUPLING_MED_PARTITIONER_METIS "Enable metis graph library in MEDPartitioner." ON "MEDCOUPLING_MED_ENABLE_PARTITIONER" OFF)
+CMAKE_DEPENDENT_OPTION(MEDCOUPLING_MED_PARTITIONER_SCOTCH "Enable scotch graph library in MEDPartitioner." ON "MEDCOUPLING_MED_ENABLE_PARTITIONER;NOT MEDCOUPLING_USE_MPI" OFF)
+CMAKE_DEPENDENT_OPTION(MEDCOUPLING_MED_PARTITIONER_PARMETIS "Enable parmetis graph library in MEDPartitioner." ON "MEDCOUPLING_MED_ENABLE_PARTITIONER;MEDCOUPLING_USE_MPI" OFF)
IF(WIN32)
- CMAKE_DEPENDENT_OPTION(MEDTOOL_MED_MEDLOADER_USE_XDR "Enable use of XDR for SauvReader." ON "NOT MEDTOOL_MED_MICROMED" OFF)
+ CMAKE_DEPENDENT_OPTION(MEDCOUPLING_MED_MEDLOADER_USE_XDR "Enable use of XDR for SauvReader." ON "NOT MEDCOUPLING_MED_MICROMED" OFF)
ENDIF(WIN32)
#
LIST(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake_files")
-IF(NOT MEDTOOL_MED_MICROMED)
+IF(NOT MEDCOUPLING_MED_MICROMED)
#FIND_PACKAGE(SalomeHDF5 REQUIRED)
#FIND_PACKAGE(SalomeMEDFile REQUIRED)
FIND_PACKAGE(HDF5 REQUIRED)
#FIND_PACKAGE(SalomeXDR REQUIRED)
FIND_PACKAGE(XDR REQUIRED)
ELSE(NOT WIN32)
- IF(MEDTOOL_MED_MEDLOADER_USE_XDR)
+ IF(MEDCOUPLING_MED_MEDLOADER_USE_XDR)
#FIND_PACKAGE(SalomeXDR REQUIRED)
FIND_PACKAGE(XDR REQUIRED)
- ENDIF(MEDTOOL_MED_MEDLOADER_USE_XDR)
+ ENDIF(MEDCOUPLING_MED_MEDLOADER_USE_XDR)
ENDIF(NOT WIN32)
# End of XDR Stuff
- IF(MEDTOOL_MED_ENABLE_PARTITIONER)
+ IF(MEDCOUPLING_MED_ENABLE_PARTITIONER)
#FIND_PACKAGE(SalomeLibXml2)
- #SALOME_LOG_OPTIONAL_PACKAGE(LibXml2 MEDTOOL_MED_ENABLE_PARTITIONER)
+ #SALOME_LOG_OPTIONAL_PACKAGE(LibXml2 MEDCOUPLING_MED_ENABLE_PARTITIONER)
IF(DEFINED ENV{LIBXML2_ROOT_DIR})
SET(LIBXML2_ROOT_DIR $ENV{LIBXML2_ROOT_DIR} CACHE PATH "Path to the LibXml2.")
LIST(APPEND CMAKE_PREFIX_PATH "${LIBXML2_ROOT_DIR}")
ENDIF()
FIND_PACKAGE(LibXml2)
- IF(MEDTOOL_MED_PARTITIONER_METIS)
+ IF(MEDCOUPLING_MED_PARTITIONER_METIS)
#FIND_PACKAGE(SalomeMetis)
- #SALOME_LOG_OPTIONAL_PACKAGE(Metis MEDTOOL_MED_PARTITIONER_METIS)
+ #SALOME_LOG_OPTIONAL_PACKAGE(Metis MEDCOUPLING_MED_PARTITIONER_METIS)
FIND_PACKAGE(Metis)
ADD_DEFINITIONS("-DMED_ENABLE_METIS")
- ENDIF(MEDTOOL_MED_PARTITIONER_METIS)
- IF(MEDTOOL_MED_PARTITIONER_SCOTCH)
+ ENDIF(MEDCOUPLING_MED_PARTITIONER_METIS)
+ IF(MEDCOUPLING_MED_PARTITIONER_SCOTCH)
#FIND_PACKAGE(SalomeScotch)
- #SALOME_LOG_OPTIONAL_PACKAGE(Scotch MEDTOOL_MED_PARTITIONER_SCOTCH)
+ #SALOME_LOG_OPTIONAL_PACKAGE(Scotch MEDCOUPLING_MED_PARTITIONER_SCOTCH)
FIND_PACKAGE(Scotch)
ADD_DEFINITIONS("-DMED_ENABLE_SCOTCH")
- ENDIF(MEDTOOL_MED_PARTITIONER_SCOTCH)
- ENDIF(MEDTOOL_MED_ENABLE_PARTITIONER)
-ENDIF(NOT MEDTOOL_MED_MICROMED)
+ ENDIF(MEDCOUPLING_MED_PARTITIONER_SCOTCH)
+ ENDIF(MEDCOUPLING_MED_ENABLE_PARTITIONER)
+ENDIF(NOT MEDCOUPLING_MED_MICROMED)
-ENABLE_TESTING() # let it outsite because even if MEDTOOL_BUILD_TESTS is OFF, python tests that not need additional compilation can be run.
+ENABLE_TESTING() # let it outsite because even if MEDCOUPLING_BUILD_TESTS is OFF, python tests that not need additional compilation can be run.
-IF(MEDTOOL_BUILD_TESTS)
+IF(MEDCOUPLING_BUILD_TESTS)
#FIND_PACKAGE(SalomeCppUnit)
- #SALOME_LOG_OPTIONAL_PACKAGE(CppUnit MEDTOOL_BUILD_TESTS)
+ #SALOME_LOG_OPTIONAL_PACKAGE(CppUnit MEDCOUPLING_BUILD_TESTS)
FIND_PACKAGE(CppUnit)
-ENDIF(MEDTOOL_BUILD_TESTS)
+ENDIF(MEDCOUPLING_BUILD_TESTS)
-IF(MEDTOOL_USE_MPI)
+IF(MEDCOUPLING_USE_MPI)
#FIND_PACKAGE(SalomeMPI REQUIRED)
FIND_PACKAGE(MPI REQUIRED)
ADD_DEFINITIONS("-DHAVE_MPI")
SET(MPI_LIBRARIES ${MPI_C_LIBRARIES} ${MPI_CXX_LIBRARIES})
SET(MPI_DEFINITIONS "${MPI_CXX_COMPILE_FLAGS}")
- IF(MEDTOOL_MED_PARTITIONER_PARMETIS)
+ IF(MEDCOUPLING_MED_PARTITIONER_PARMETIS)
#FIND_PACKAGE(SalomeParMetis)
FIND_PACKAGE(ParMetis)
- #SALOME_LOG_OPTIONAL_PACKAGE(ParMetis MEDTOOL_MED_PARTITIONER_PARMETIS)
+ #SALOME_LOG_OPTIONAL_PACKAGE(ParMetis MEDCOUPLING_MED_PARTITIONER_PARMETIS)
ADD_DEFINITIONS("-DMED_ENABLE_PARMETIS")
- ENDIF(MEDTOOL_MED_PARTITIONER_PARMETIS)
-ENDIF(MEDTOOL_USE_MPI)
+ ENDIF(MEDCOUPLING_MED_PARTITIONER_PARMETIS)
+ENDIF(MEDCOUPLING_USE_MPI)
-IF(MEDTOOL_MED_ENABLE_RENUMBER)
+IF(MEDCOUPLING_MED_ENABLE_RENUMBER)
#FIND_PACKAGE(SalomeBoost)
- #SALOME_LOG_OPTIONAL_PACKAGE(Boost MEDTOOL_MED_ENABLE_RENUMBER)
+ #SALOME_LOG_OPTIONAL_PACKAGE(Boost MEDCOUPLING_MED_ENABLE_RENUMBER)
IF(DEFINED ENV{BOOST_ROOT_DIR})
SET(BOOST_ROOT_DIR $ENV{BOOST_ROOT_DIR} CACHE PATH "Path to the Boost.")
LIST(APPEND CMAKE_PREFIX_PATH "${BOOST_ROOT_DIR}")
SET(Boost_NO_BOOST_CMAKE ON)
#SET(SalomeBoost_FIND_COMPONENTS filesystem regex signals system thread date_time chrono)
FIND_PACKAGE(Boost)
-ENDIF(MEDTOOL_MED_ENABLE_RENUMBER)
+ENDIF(MEDCOUPLING_MED_ENABLE_RENUMBER)
-IF(MEDTOOL_BUILD_DOC)
+IF(MEDCOUPLING_BUILD_DOC)
#FIND_PACKAGE(SalomeDoxygen)
#FIND_PACKAGE(SalomeGraphviz)
#FIND_PACKAGE(SalomeSphinx)
- #SALOME_LOG_OPTIONAL_PACKAGE(Doxygen MEDTOOL_BUILD_DOC)
- #SALOME_LOG_OPTIONAL_PACKAGE(Graphviz MEDTOOL_BUILD_DOC)
- #SALOME_LOG_OPTIONAL_PACKAGE(Sphinx MEDTOOL_BUILD_DOC)
+ #SALOME_LOG_OPTIONAL_PACKAGE(Doxygen MEDCOUPLING_BUILD_DOC)
+ #SALOME_LOG_OPTIONAL_PACKAGE(Graphviz MEDCOUPLING_BUILD_DOC)
+ #SALOME_LOG_OPTIONAL_PACKAGE(Sphinx MEDCOUPLING_BUILD_DOC)
FIND_PACKAGE(Doxygen)
IF(DEFINED ENV{GRAPHVIZ_ROOT_DIR})
SET(GRAPHVIZ_ROOT_DIR $ENV{GRAPHVIZ_ROOT_DIR} CACHE PATH "Path to the Graphviz.")
ENDIF()
FIND_PACKAGE(Graphviz)
FIND_PACKAGE(Sphinx)
-ENDIF(MEDTOOL_BUILD_DOC)
+ENDIF(MEDCOUPLING_BUILD_DOC)
-IF(MEDTOOL_MED_ENABLE_PYTHON)
+IF(MEDCOUPLING_MED_ENABLE_PYTHON)
#FIND_PACKAGE(SalomePython)
#FIND_PACKAGE(SalomeSWIG)
- #SALOME_LOG_OPTIONAL_PACKAGE(Python MEDTOOL_MED_ENABLE_PYTHON)
- #SALOME_LOG_OPTIONAL_PACKAGE(SWIG MEDTOOL_MED_ENABLE_PYTHON)
+ #SALOME_LOG_OPTIONAL_PACKAGE(Python MEDCOUPLING_MED_ENABLE_PYTHON)
+ #SALOME_LOG_OPTIONAL_PACKAGE(SWIG MEDCOUPLING_MED_ENABLE_PYTHON)
FIND_PACKAGE(PythonInterp)
GET_FILENAME_COMPONENT(_python_dir "${PYTHON_EXECUTABLE}" PATH)
GET_FILENAME_COMPONENT(CMAKE_INCLUDE_PATH "${_python_dir}/../include/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}" ABSOLUTE)
IF(SCIPY_FOUND)
SET(SWIG_EXTRA_FLAGS_FOR_NUMPYANDSCIPY "${SWIG_EXTRA_FLAGS_FOR_NUMPYANDSCIPY};-DWITH_SCIPY")
ENDIF(SCIPY_FOUND)
-ENDIF(MEDTOOL_MED_ENABLE_PYTHON)
+ENDIF(MEDCOUPLING_MED_ENABLE_PYTHON)
# Detection report
#SALOME_PACKAGE_REPORT_AND_CHECK()
# Directories have to be given after prerequisites (to be able to use
# Python version string for example).
# ===========
-SET(MEDTOOL_INSTALL_BINS bin CACHE PATH "Install path: MEDtool binaries")
-SET(MEDTOOL_INSTALL_LIBS lib CACHE PATH "Install path: MEDtool libs")
-SET(MEDTOOL_INSTALL_HEADERS include CACHE PATH "Install path: MEDtool headers")
-SET(MEDTOOL_INSTALL_SCRIPT_SCRIPTS ${MEDTOOL_INSTALL_BINS} CACHE PATH "Install path: MEDtool scripts")
-SET(MEDTOOL_INSTALL_TESTS tests CACHE PATH "Install path: MEDtool tests")
-# SET(MEDTOOL_INSTALL_SCRIPT_DATA ${MEDTOOL_INSTALL_BINS} CACHE PATH
+SET(MEDCOUPLING_INSTALL_BINS bin CACHE PATH "Install path: MEDCoupling binaries")
+SET(MEDCOUPLING_INSTALL_LIBS lib CACHE PATH "Install path: MEDCoupling libs")
+SET(MEDCOUPLING_INSTALL_HEADERS include CACHE PATH "Install path: MEDCoupling headers")
+SET(MEDCOUPLING_INSTALL_SCRIPT_SCRIPTS ${MEDCOUPLING_INSTALL_BINS} CACHE PATH "Install path: MEDCoupling scripts")
+SET(MEDCOUPLING_INSTALL_TESTS tests CACHE PATH "Install path: MEDCoupling tests")
+# SET(MEDCOUPLING_INSTALL_SCRIPT_DATA ${MEDCOUPLING_INSTALL_BINS} CACHE PATH
# "Install path: SALOME script data")
-SET(MEDTOOL_INSTALL_SCRIPT_PYTHON ${MEDTOOL_INSTALL_BINS} CACHE PATH "Install path: MEDtool Python scripts")
-# SET(MEDTOOL_INSTALL_APPLISKEL_SCRIPTS ${MEDTOOL_INSTALL_BINS}/appliskel CACHE PATH
+SET(MEDCOUPLING_INSTALL_SCRIPT_PYTHON ${MEDCOUPLING_INSTALL_BINS} CACHE PATH "Install path: MEDCoupling Python scripts")
+# SET(MEDCOUPLING_INSTALL_APPLISKEL_SCRIPTS ${MEDCOUPLING_INSTALL_BINS}/appliskel CACHE PATH
# "Install path: SALOME application skeleton - scripts")
-# SET(MEDTOOL_INSTALL_APPLISKEL_PYTHON ${MEDTOOL_INSTALL_BINS}/appliskel CACHE PATH
+# SET(MEDCOUPLING_INSTALL_APPLISKEL_PYTHON ${MEDCOUPLING_INSTALL_BINS}/appliskel CACHE PATH
# "Install path: SALOME application skeleton - Python")
-# SET(MEDTOOL_INSTALL_CMAKE salome_adm/cmake_files CACHE PATH "Install path: SALOME CMake files")
-# SET(MEDTOOL_INSTALL_CMAKE_LOCAL adm_local/cmake_files CACHE PATH
+# SET(MEDCOUPLING_INSTALL_CMAKE salome_adm/cmake_files CACHE PATH "Install path: SALOME CMake files")
+# SET(MEDCOUPLING_INSTALL_CMAKE_LOCAL adm_local/cmake_files CACHE PATH
# "Install path: local SALOME CMake files")
-IF(MEDTOOL_MED_ENABLE_PYTHON)
+IF(MEDCOUPLING_MED_ENABLE_PYTHON)
SET(_pydir lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
- SET(MEDTOOL_INSTALL_PYTHON ${_pydir} CACHE PATH "Install path: MEDtool Python stuff")
- SET(MEDTOOL_INSTALL_PYTHON_SHARED ${MEDTOOL_INSTALL_PYTHON}/shared_modules CACHE PATH
- "Install path: MEDtool Python shared modules")
-ENDIF(MEDTOOL_MED_ENABLE_PYTHON)
+ SET(MEDCOUPLING_INSTALL_PYTHON ${_pydir} CACHE PATH "Install path: MEDCoupling Python stuff")
+ SET(MEDCOUPLING_INSTALL_PYTHON_SHARED ${MEDCOUPLING_INSTALL_PYTHON}/shared_modules CACHE PATH
+ "Install path: MEDCoupling Python shared modules")
+ENDIF(MEDCOUPLING_MED_ENABLE_PYTHON)
-SET(MEDTOOL_INSTALL_RES share/resources CACHE PATH "Install path: MEDTOOL resources")
-SET(MEDTOOL_INSTALL_DOC share/doc CACHE PATH "Install path: MEDTOOL documentation")
+SET(MEDCOUPLING_INSTALL_RES share/resources CACHE PATH "Install path: MEDCoupling resources")
+SET(MEDCOUPLING_INSTALL_DOC share/doc CACHE PATH "Install path: MEDCoupling documentation")
# Med specific:
-SET(MEDTOOL_INSTALL_RES_DATA "${MEDTOOL_INSTALL_RES}/med" CACHE PATH "Install path: MEDTOOL specific data")
-#SET(MEDTOOL_MED_INSTALL_RES_SCRIPTS "${MEDTOOL_INSTALL_RES}/med" CACHE PATH "Install path: SALOME MED specific scripts")
+SET(MEDCOUPLING_INSTALL_RES_DATA "${MEDCOUPLING_INSTALL_RES}/med" CACHE PATH "Install path: MEDCoupling specific data")
+#SET(MEDCOUPLING_MED_INSTALL_RES_SCRIPTS "${MEDCOUPLING_INSTALL_RES}/med" CACHE PATH "Install path: SALOME MED specific scripts")
-#MARK_AS_ADVANCED(MEDTOOL_INSTALL_BINS MEDTOOL_INSTALL_LIBS MEDTOOL_INSTALL_IDLS MEDTOOL_INSTALL_HEADERS)
-#MARK_AS_ADVANCED(MEDTOOL_INSTALL_SCRIPT_SCRIPTS MEDTOOL_INSTALL_SCRIPT_DATA MEDTOOL_INSTALL_SCRIPT_PYTHON)
-#MARK_AS_ADVANCED(MEDTOOL_INSTALL_APPLISKEL_SCRIPTS MEDTOOL_INSTALL_APPLISKEL_PYTHON MEDTOOL_INSTALL_CMAKE MEDTOOL_INSTALL_CMAKE_LOCAL MEDTOOL_INSTALL_RES)
-#MARK_AS_ADVANCED(MEDTOOL_INSTALL_PYTHON MEDTOOL_INSTALL_PYTHON_SHARED MEDTOOL_MED_INSTALL_RES_DATA MEDTOOL_MED_INSTALL_RES_SCRIPTS MEDTOOL_INSTALL_DOC)
+#MARK_AS_ADVANCED(MEDCOUPLING_INSTALL_BINS MEDCOUPLING_INSTALL_LIBS MEDCOUPLING_INSTALL_IDLS MEDCOUPLING_INSTALL_HEADERS)
+#MARK_AS_ADVANCED(MEDCOUPLING_INSTALL_SCRIPT_SCRIPTS MEDCOUPLING_INSTALL_SCRIPT_DATA MEDCOUPLING_INSTALL_SCRIPT_PYTHON)
+#MARK_AS_ADVANCED(MEDCOUPLING_INSTALL_APPLISKEL_SCRIPTS MEDCOUPLING_INSTALL_APPLISKEL_PYTHON MEDCOUPLING_INSTALL_CMAKE MEDCOUPLING_INSTALL_CMAKE_LOCAL MEDCOUPLING_INSTALL_RES)
+#MARK_AS_ADVANCED(MEDCOUPLING_INSTALL_PYTHON MEDCOUPLING_INSTALL_PYTHON_SHARED MEDCOUPLING_MED_INSTALL_RES_DATA MEDCOUPLING_MED_INSTALL_RES_SCRIPTS MEDCOUPLING_INSTALL_DOC)
# Header configuration
# ====================
-MEDTOOL_XVERSION(${PROJECT_NAME})
-#SALOME_CONFIGURE_FILE(MED_version.h.in MED_version.h INSTALL ${MEDTOOL_INSTALL_HEADERS})
-#SALOME_CONFIGURE_FILE(VERSION.in VERSION INSTALL ${MEDTOOL_INSTALL_BINS})
-CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/MEDtool_version.h.in ${CMAKE_CURRENT_BINARY_DIR}/MEDtool_version.h)
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/MEDtool_version.h DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+MEDCOUPLING_XVERSION(${PROJECT_NAME})
+#SALOME_CONFIGURE_FILE(MED_version.h.in MED_version.h INSTALL ${MEDCOUPLING_INSTALL_HEADERS})
+#SALOME_CONFIGURE_FILE(VERSION.in VERSION INSTALL ${MEDCOUPLING_INSTALL_BINS})
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/MEDCoupling_version.h.in ${CMAKE_CURRENT_BINARY_DIR}/MEDCoupling_version.h)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/MEDCoupling_version.h DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
# Accumulate environment variables for MED module
-#SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${MEDTOOL_INSTALL_BINS}
-# ${CMAKE_INSTALL_PREFIX}/${MEDTOOL_INSTALL_PYTHON})
-#SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${MEDTOOL_INSTALL_LIBS})
+#SALOME_ACCUMULATE_ENVIRONMENT(PYTHONPATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${MEDCOUPLING_INSTALL_BINS}
+# ${CMAKE_INSTALL_PREFIX}/${MEDCOUPLING_INSTALL_PYTHON})
+#SALOME_ACCUMULATE_ENVIRONMENT(LD_LIBRARY_PATH NOCHECK ${CMAKE_INSTALL_PREFIX}/${MEDCOUPLING_INSTALL_LIBS})
# Sources
ADD_DEFINITIONS("-D_USE_MATH_DEFINES")
ENDIF(WIN32)
-#ADD_DEFINITIONS("-DMEDTOOL_ROOT_DIR=${CMAKE_INSTALL_PREFIX}")
+#ADD_DEFINITIONS("-DMEDCOUPLING_ROOT_DIR=${CMAKE_INSTALL_PREFIX}")
ADD_SUBDIRECTORY(src)
#ADD_SUBDIRECTORY(adm_local)
-IF(MEDTOOL_BUILD_DOC)
+IF(MEDCOUPLING_BUILD_DOC)
ADD_SUBDIRECTORY(doc)
-ENDIF(MEDTOOL_BUILD_DOC)
+ENDIF(MEDCOUPLING_BUILD_DOC)
#ADD_SUBDIRECTORY(adm_local_without_kernel)
-IF(NOT MEDTOOL_MED_MICROMED)
- IF(MEDTOOL_MED_WITH_FILE_EXAMPLES)
+IF(NOT MEDCOUPLING_MED_MICROMED)
+ IF(MEDCOUPLING_MED_WITH_FILE_EXAMPLES)
ADD_SUBDIRECTORY(resources)
- ENDIF(MEDTOOL_MED_WITH_FILE_EXAMPLES)
-ENDIF(NOT MEDTOOL_MED_MICROMED)
+ ENDIF(MEDCOUPLING_MED_WITH_FILE_EXAMPLES)
+ENDIF(NOT MEDCOUPLING_MED_MICROMED)
# Configuration export
# ====================
SET(_${PROJECT_NAME}_exposed_targets
interpkernel medcoupling medcouplingremapper)
-IF(NOT MEDTOOL_MED_MICROMED)
+IF(NOT MEDCOUPLING_MED_MICROMED)
LIST(APPEND _${PROJECT_NAME}_exposed_targets medloader)
- IF(MEDTOOL_MED_ENABLE_RENUMBER)
+ IF(MEDCOUPLING_MED_ENABLE_RENUMBER)
LIST(APPEND _${PROJECT_NAME}_exposed_targets renumbercpp)
ENDIF()
- IF(MEDTOOL_MED_ENABLE_PARTITIONER)
+ IF(MEDCOUPLING_MED_ENABLE_PARTITIONER)
LIST(APPEND _${PROJECT_NAME}_exposed_targets medpartitionercpp)
- IF(MEDTOOL_BUILD_TESTS)
+ IF(MEDCOUPLING_BUILD_TESTS)
LIST(APPEND _${PROJECT_NAME}_exposed_targets MEDPARTITIONERTest)
ENDIF()
ENDIF()
- IF(MEDTOOL_BUILD_TESTS)
+ IF(MEDCOUPLING_BUILD_TESTS)
LIST(APPEND _${PROJECT_NAME}_exposed_targets InterpKernelTest)
ENDIF()
ENDIF()
-IF(MEDTOOL_USE_MPI)
+IF(MEDCOUPLING_USE_MPI)
LIST(APPEND _${PROJECT_NAME}_exposed_targets paramedmem)
- IF(NOT MEDTOOL_MED_MICROMED)
+ IF(NOT MEDCOUPLING_MED_MICROMED)
LIST(APPEND _${PROJECT_NAME}_exposed_targets paramedloader)
ENDIF()
- IF(MEDTOOL_BUILD_TESTS)
- IF(NOT MEDTOOL_MED_MICROMED)
+ IF(MEDCOUPLING_BUILD_TESTS)
+ IF(NOT MEDCOUPLING_MED_MICROMED)
LIST(APPEND _${PROJECT_NAME}_exposed_targets ParaMEDMEMTest)
ENDIF()
ENDIF()
# INCLUDE(CMakePackageConfigHelpers)
# CONFIGURE_PACKAGE_CONFIG_FILE(${PROJECT_NAME}Config.cmake.in
# ${PROJECT_BINARY_DIR}/to_install/${PROJECT_NAME}Config.cmake
-# INSTALL_DESTINATION "${MEDTOOL_INSTALL_CMAKE}_LOCAL"
-# PATH_VARS CONF_INCLUDE_DIRS MEDTOOL_INSTALL_CMAKE_LOCAL CMAKE_INSTALL_PREFIX
+# INSTALL_DESTINATION "${MEDCOUPLING_INSTALL_CMAKE}_LOCAL"
+# PATH_VARS CONF_INCLUDE_DIRS MEDCOUPLING_INSTALL_CMAKE_LOCAL CMAKE_INSTALL_PREFIX
# KERNEL_ROOT_DIR GUI_ROOT_DIR MEDFILE_ROOT_DIR MPI_ROOT_DIR
# HDF5_ROOT_DIR OMNIORB_ROOT_DIR PTHREAD_ROOT_DIR BOOST_ROOT_DIR
# SWIG_ROOT_DIR PYTHON_ROOT_DIR CPPUNIT_ROOT_DIR GRAPHVIZ_ROOT_DIR DOXYGEN_ROOT_DIR
# INSTALL(FILES
# "${PROJECT_BINARY_DIR}/to_install/${PROJECT_NAME}Config.cmake"
# "${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
-# DESTINATION "${MEDTOOL_INSTALL_CMAKE_LOCAL}")
+# DESTINATION "${MEDCOUPLING_INSTALL_CMAKE_LOCAL}")
# Install the export set for use with the install-tree
-#INSTALL(EXPORT ${PROJECT_NAME}TargetGroup DESTINATION "${MEDTOOL_INSTALL_CMAKE_LOCAL}"
+#INSTALL(EXPORT ${PROJECT_NAME}TargetGroup DESTINATION "${MEDCOUPLING_INSTALL_CMAKE_LOCAL}"
# FILE ${PROJECT_NAME}Targets.cmake)
--- /dev/null
+// Copyright (C) 2015 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#if !defined(__MEDCOUPLING_VERSION_H__)
+#define __MEDCOUPLING_VERSION_H__
+
+/*!
+ Specify version of MEDCoupling, as follows
+
+ MEDCOUPLING_VERSION_MAJOR : (integer) number identifying major version
+ MEDCOUPLING_VERSION_MINOR : (integer) number identifying minor version
+ MEDCOUPLING_VERSION_MAINTENANCE : (integer) number identifying maintenance version
+ MEDCOUPLING_VERSION_STR : (string) complete version number "major.minor.maintenance"
+ MEDCOUPLING_VERSION : (hex) complete version number (major << 16) + (minor << 8) + maintenance
+ MEDCOUPLING_DEVELOPMENT : (integer) indicates development version when set to 1
+*/
+
+#define MEDCOUPLING_VERSION_MAJOR @MEDCOUPLING_MAJOR_VERSION@
+#define MEDCOUPLING_VERSION_MINOR @MEDCOUPLING_MINOR_VERSION@
+#define MEDCOUPLING_VERSION_MAINTENANCE @MEDCOUPLING_PATCH_VERSION@
+#define MEDCOUPLING_VERSION_STR "@MEDCOUPLING_VERSION@"
+#define MEDCOUPLING_VERSION @MEDCOUPLING_XVERSION@
+#define MEDCOUPLING_DEVELOPMENT @MEDCOUPLING_VERSION_DEV@
+
+#endif // __MEDCOUPLING_VERSION_H__
+++ /dev/null
-// Copyright (C) 2015 CEA/DEN, EDF R&D, OPEN CASCADE
-//
-// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-//
-
-#if !defined(__MEDTOOL_VERSION_H__)
-#define __MEDTOOL_VERSION_H__
-
-/*!
- Specify version of MEDtool, as follows
-
- MEDTOOL_VERSION_MAJOR : (integer) number identifying major version
- MEDTOOL_VERSION_MINOR : (integer) number identifying minor version
- MEDTOOL_VERSION_MAINTENANCE : (integer) number identifying maintenance version
- MEDTOOL_VERSION_STR : (string) complete version number "major.minor.maintenance"
- MEDTOOL_VERSION : (hex) complete version number (major << 16) + (minor << 8) + maintenance
- MEDTOOL_DEVELOPMENT : (integer) indicates development version when set to 1
-*/
-
-#define MEDTOOL_VERSION_MAJOR @MEDTOOL_MAJOR_VERSION@
-#define MEDTOOL_VERSION_MINOR @MEDTOOL_MINOR_VERSION@
-#define MEDTOOL_VERSION_MAINTENANCE @MEDTOOL_PATCH_VERSION@
-#define MEDTOOL_VERSION_STR "@MEDTOOL_VERSION@"
-#define MEDTOOL_VERSION @MEDTOOL_XVERSION@
-#define MEDTOOL_DEVELOPMENT @MEDTOOL_VERSION_DEV@
-
-#endif // __MEDTOOL_VERSION_H__
ENDIF("${ln}" MATCHES "^#define METIS_VER_MAJOR")
ENDFOREACH(ln ${list_metis_h_content})
IF(metis_major_version STREQUAL 5)
- SET(MEDTOOL_METIS_V5 1)
+ SET(MEDCOUPLING_METIS_V5 1)
MESSAGE(STATUS "Metis maj version 5 detected.")
ELSE(metis_major_version STREQUAL 5)
MESSAGE(STATUS "Metis maj version 4 detected.")
--- /dev/null
+# Copyright (C) 2015 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+####################################################################
+# _TOHEXA()
+# Convert a number (smaller than 16) into hexadecimal representation
+# with a leading 0.
+MACRO(_TOHEXA num result)
+ SET(_hexa_map a b c d e f)
+ IF(${num} LESS 10)
+ SET(${result} "0${num}")
+ ELSE()
+ MATH(EXPR _res "${num}-10" )
+ LIST(GET _hexa_map ${_res} _out)
+ SET(${result} "0${_out}")
+ ENDIF()
+ENDMACRO(_TOHEXA)
+
+####################################################################
+# MEDCOUPLING_XVERSION()
+#
+# Computes hexadecimal version of MEDCOUPLING package
+#
+# USAGE: MEDCOUPLING_XVERSION(package)
+#
+# ARGUMENTS:
+#
+# package: IN: MEDCOUPLING package name
+#
+# The macro reads MEDCOUPLING package version from PACKAGE_VERSION variable
+# (note package name are uppercase);
+# hexadecimal version value in form 0xAABBCC (where AA, BB and CC are
+# major, minor and maintenance components of package version in
+# hexadecimal form) is put to the PACKAGE_XVERSION variable
+MACRO(MEDCOUPLING_XVERSION pkg)
+ STRING(TOUPPER ${pkg} _pkg_UC)
+ IF(${_pkg_UC}_VERSION)
+ SET(_major)
+ SET(_minor)
+ SET(_patch)
+ _TOHEXA(${${_pkg_UC}_MAJOR_VERSION} _major)
+ _TOHEXA(${${_pkg_UC}_MINOR_VERSION} _minor)
+ _TOHEXA(${${_pkg_UC}_PATCH_VERSION} _patch)
+ SET(${_pkg_UC}_XVERSION "0x${_major}${_minor}${_patch}")
+ ENDIF()
+ENDMACRO(MEDCOUPLING_XVERSION)
+++ /dev/null
-# Copyright (C) 2015 CEA/DEN, EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-
-####################################################################
-# _TOHEXA()
-# Convert a number (smaller than 16) into hexadecimal representation
-# with a leading 0.
-MACRO(_TOHEXA num result)
- SET(_hexa_map a b c d e f)
- IF(${num} LESS 10)
- SET(${result} "0${num}")
- ELSE()
- MATH(EXPR _res "${num}-10" )
- LIST(GET _hexa_map ${_res} _out)
- SET(${result} "0${_out}")
- ENDIF()
-ENDMACRO(_TOHEXA)
-
-####################################################################
-# MEDTOOL_XVERSION()
-#
-# Computes hexadecimal version of MEDTOOL package
-#
-# USAGE: MEDTOOL_XVERSION(package)
-#
-# ARGUMENTS:
-#
-# package: IN: MEDTOOL package name
-#
-# The macro reads MEDTOOL package version from PACKAGE_VERSION variable
-# (note package name are uppercase);
-# hexadecimal version value in form 0xAABBCC (where AA, BB and CC are
-# major, minor and maintenance components of package version in
-# hexadecimal form) is put to the PACKAGE_XVERSION variable
-MACRO(MEDTOOL_XVERSION pkg)
- STRING(TOUPPER ${pkg} _pkg_UC)
- IF(${_pkg_UC}_VERSION)
- SET(_major)
- SET(_minor)
- SET(_patch)
- _TOHEXA(${${_pkg_UC}_MAJOR_VERSION} _major)
- _TOHEXA(${${_pkg_UC}_MINOR_VERSION} _minor)
- _TOHEXA(${${_pkg_UC}_PATCH_VERSION} _patch)
- SET(${_pkg_UC}_XVERSION "0x${_major}${_minor}${_patch}")
- ENDIF()
-ENDMACRO(MEDTOOL_XVERSION)
ADD_DEPENDENCIES(usr_docs tutorial_doc)
#INSTALL(CODE "EXECUTE_PROCESS(COMMAND \"${CMAKE_COMMAND}\" --build ${PROJECT_BINARY_DIR} --target tutorial_doc)")
-INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/ DESTINATION ${MEDTOOL_INSTALL_DOC}/gui/MED/tutorial)
-INSTALL(DIRECTORY images/ DESTINATION ${MEDTOOL_INSTALL_DOC}/gui/MED/tutorial/images)
-INSTALL(DIRECTORY data/ DESTINATION ${MEDTOOL_INSTALL_DOC}/gui/MED/tutorial/data)
+INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/ DESTINATION ${MEDCOUPLING_INSTALL_DOC}/gui/MED/tutorial)
+INSTALL(DIRECTORY images/ DESTINATION ${MEDCOUPLING_INSTALL_DOC}/gui/MED/tutorial/images)
+INSTALL(DIRECTORY data/ DESTINATION ${MEDCOUPLING_INSTALL_DOC}/gui/MED/tutorial/data)
SET(make_clean_files html doctrees)
SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${make_clean_files}")
# built documents.
#
# The short X.Y version.
-version = '@MEDTOOL_VERSION@'
+version = '@MEDCOUPLING_VERSION@'
# The full version, including alpha/beta/rc tags.
-release = '@MEDTOOL_VERSION@'
+release = '@MEDCOUPLING_VERSION@'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile_med_user.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_med_user)
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/static/header.html.in ${CMAKE_CURRENT_BINARY_DIR}/static/header.html)
-IF(MEDTOOL_MED_ENABLE_PYTHON)
+IF(MEDCOUPLING_MED_ENABLE_PYTHON)
INCLUDE(doxy2swig/doxy2swig.cmake)
FILE(TO_NATIVE_PATH "${CMAKE_CURRENT_BINARY_DIR}/tmp/medcouplingexamples.in" input)
ADD_CUSTOM_TARGET(swig_ready)
ADD_DEPENDENCIES(swig_ready usr_docs)
- MEDTOOL_MED_SWIG_DOCSTRING_CONFIGURE(usr_docs swig_ready MEDCoupling)
- MEDTOOL_MED_SWIG_DOCSTRING_CONFIGURE(usr_docs swig_ready MEDLoader)
+ MEDCOUPLING_MED_SWIG_DOCSTRING_CONFIGURE(usr_docs swig_ready MEDCoupling)
+ MEDCOUPLING_MED_SWIG_DOCSTRING_CONFIGURE(usr_docs swig_ready MEDLoader)
SET(doxyfile_med_user ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_med_user)
FILE(STRINGS ${doxyfile_med_user} enabled_sections REGEX "ENABLED_SECTIONS")
ENDIF()
#INSTALL(CODE "EXECUTE_PROCESS(COMMAND \"${CMAKE_COMMAND}\" --build ${PROJECT_BINARY_DIR} --target usr_docs)")
-INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html/ DESTINATION ${MEDTOOL_INSTALL_DOC}/gui/MED)
-INSTALL(FILES images/head.png DESTINATION ${MEDTOOL_INSTALL_DOC}/gui/MED)
+INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html/ DESTINATION ${MEDCOUPLING_INSTALL_DOC}/gui/MED)
+INSTALL(FILES images/head.png DESTINATION ${MEDCOUPLING_INSTALL_DOC}/gui/MED)
SET(MAKE_CLEAN_FILES doc_ref_user tmp)
SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${MAKE_CLEAN_FILES}")
-
/*!
\page install Configuring and Installing MED from sources
This will configure the library without splitting functionalities. The \ref parallel "parallel functionalities" will be compiled if an MPI version has been found.
The following options can be useful to configure MEDCoupling :
-- \a -DMEDTOOL_MED_PARTITIONER_METIS=ON enables metis graph library in MEDPartitioner,
-- \a -DMEDTOOL_MED_PARTITIONER_PARMETIS=ON enables parmetis graph library in MEDPartitioner,
-- \a -DMEDTOOL_MED_PARTITIONER_SCOTCH=ON enables scotch graph library in MEDPartitioner,
-- \a -DMEDTOOL_MED_MICROMED=ON build MED with MED file dependancy,
-- \a -DMEDTOOL_MED_ENABLE_PYTHON=ON builds PYTHON bindings,
-- \a -DMEDTOOL_MED_ENABLE_PARTITIONER builds MEDPartitioner,
-- \a -DMEDTOOL_MED_ENABLE_RENUMBER builds Renumber,
-- \a -DMEDTOOL_USE_MPI=ON uses MPI containers.
+- \a -DMEDCOUPLING_MED_PARTITIONER_METIS=ON enables metis graph library in MEDPartitioner,
+- \a -DMEDCOUPLING_MED_PARTITIONER_PARMETIS=ON enables parmetis graph library in MEDPartitioner,
+- \a -DMEDCOUPLING_MED_PARTITIONER_SCOTCH=ON enables scotch graph library in MEDPartitioner,
+- \a -DMEDCOUPLING_MED_MICROMED=ON build MED with MED file dependancy,
+- \a -DMEDCOUPLING_MED_ENABLE_PYTHON=ON builds PYTHON bindings,
+- \a -DMEDCOUPLING_MED_ENABLE_PARTITIONER builds MEDPartitioner,
+- \a -DMEDCOUPLING_MED_ENABLE_RENUMBER builds Renumber,
+- \a -DMEDCOUPLING_USE_MPI=ON uses MPI containers.
According to set options and compilation environment, user may need to define some <prerequisite>_ROOT_DIR variables. For example if in SALOME environment:
\verbatim
## \param[in] swig_main_file main SWIG file including the other generated SWIG files
## \param[out] swig_files list of generated SWIG files
##
-MACRO(MEDTOOL_MED_SWIG_DOCSTRING_GENERATE target_doc target_swig cls_list swig_main_file swig_files)
+MACRO(MEDCOUPLING_MED_SWIG_DOCSTRING_GENERATE target_doc target_swig cls_list swig_main_file swig_files)
# List of generated SWIG files (.i) for doc purposes only:
SET(${swig_files})
FOREACH(_cls IN LISTS ${cls_list})
LIST(APPEND ${swig_files} ${_swig_file_base})
ENDFOREACH()
-ENDMACRO(MEDTOOL_MED_SWIG_DOCSTRING_GENERATE)
+ENDMACRO(MEDCOUPLING_MED_SWIG_DOCSTRING_GENERATE)
##
## \param[in] target_swig dummy target encompassing the final build of all SWIG files
## \param[in] root_name either 'MEDCoupling' or 'MEDLoader'
##
-MACRO(MEDTOOL_MED_SWIG_DOCSTRING_CONFIGURE target_doc target_swig root_name)
+MACRO(MEDCOUPLING_MED_SWIG_DOCSTRING_CONFIGURE target_doc target_swig root_name)
SET(_all_swig_docs)
SET(_swig_include_set)
SET(_in_file doxy2swig/${root_name}_doc.i.in)
SET(_out_file ${PROJECT_BINARY_DIR}/doc/${root_name}_doc.i)
- MEDTOOL_MED_SWIG_DOCSTRING_GENERATE(${target_doc} ${target_swig} _classes_${root_name} ${_out_file} _all_swig_docs)
+ MEDCOUPLING_MED_SWIG_DOCSTRING_GENERATE(${target_doc} ${target_swig} _classes_${root_name} ${_out_file} _all_swig_docs)
FOREACH(f IN LISTS _all_swig_docs)
SET(_swig_include_set "${_swig_include_set}\n%include \"${f}\"")
ENDFOREACH()
CONFIGURE_FILE(${_in_file} ${_out_file} @ONLY)
-ENDMACRO(MEDTOOL_MED_SWIG_DOCSTRING_CONFIGURE)
-
+ENDMACRO(MEDCOUPLING_MED_SWIG_DOCSTRING_CONFIGURE)
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="titlearea"><div align="right"><div class="version">Version: @MEDTOOL_VERSION@</div></div></div>
+<div id="titlearea"><div align="right"><div class="version">Version: @MEDCOUPLING_VERSION@</div></div></div>
<!-- end header part -->
CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/${resfile}" "${CMAKE_CURRENT_BINARY_DIR}/${resfile}" COPYONLY)
ENDFOREACH(resfile)
-INSTALL(FILES ${MED_RESOURCES_FILES} DESTINATION ${MEDTOOL_INSTALL_RES_DATA})
+INSTALL(FILES ${MED_RESOURCES_FILES} DESTINATION ${MEDCOUPLING_INSTALL_RES_DATA})
#MESSAGE(STATUS "Creation of ${CMAKE_CURRENT_BINARY_DIR}/MEDCatalog.xml")
#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/MEDCatalog.xml.in ${CMAKE_CURRENT_BINARY_DIR}/MEDCatalog.xml @ONLY)
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
-SET(MED_ENABLE_MICROMED ${MEDTOOL_MED_MICROMED})
+SET(MED_ENABLE_MICROMED ${MEDCOUPLING_MED_MICROMED})
ADD_SUBDIRECTORY(INTERP_KERNEL)
-IF(MEDTOOL_BUILD_TESTS)
+IF(MEDCOUPLING_BUILD_TESTS)
ADD_SUBDIRECTORY(INTERP_KERNELTest)
-ENDIF(MEDTOOL_BUILD_TESTS)
+ENDIF(MEDCOUPLING_BUILD_TESTS)
ADD_SUBDIRECTORY(MEDCoupling)
-IF(MEDTOOL_MED_ENABLE_PYTHON)
+IF(MEDCOUPLING_MED_ENABLE_PYTHON)
ADD_SUBDIRECTORY(MEDCoupling_Swig)
-ENDIF(MEDTOOL_MED_ENABLE_PYTHON)
+ENDIF(MEDCOUPLING_MED_ENABLE_PYTHON)
-IF(NOT MEDTOOL_MED_MICROMED)
+IF(NOT MEDCOUPLING_MED_MICROMED)
ADD_SUBDIRECTORY(MEDLoader)
- IF(MEDTOOL_MED_ENABLE_RENUMBER)
+ IF(MEDCOUPLING_MED_ENABLE_RENUMBER)
ADD_SUBDIRECTORY(RENUMBER)
- IF(MEDTOOL_MED_ENABLE_PYTHON)
+ IF(MEDCOUPLING_MED_ENABLE_PYTHON)
ADD_SUBDIRECTORY(RENUMBER_Swig)
- ENDIF(MEDTOOL_MED_ENABLE_PYTHON)
- ENDIF(MEDTOOL_MED_ENABLE_RENUMBER)
- IF(MEDTOOL_MED_ENABLE_PARTITIONER)
+ ENDIF(MEDCOUPLING_MED_ENABLE_PYTHON)
+ ENDIF(MEDCOUPLING_MED_ENABLE_RENUMBER)
+ IF(MEDCOUPLING_MED_ENABLE_PARTITIONER)
ADD_SUBDIRECTORY(MEDPartitioner)
- IF(MEDTOOL_MED_ENABLE_PYTHON)
+ IF(MEDCOUPLING_MED_ENABLE_PYTHON)
ADD_SUBDIRECTORY(MEDPartitioner_Swig)
- ENDIF(MEDTOOL_MED_ENABLE_PYTHON)
- ENDIF(MEDTOOL_MED_ENABLE_PARTITIONER)
-ENDIF(NOT MEDTOOL_MED_MICROMED)
+ ENDIF(MEDCOUPLING_MED_ENABLE_PYTHON)
+ ENDIF(MEDCOUPLING_MED_ENABLE_PARTITIONER)
+ENDIF(NOT MEDCOUPLING_MED_MICROMED)
-IF(MEDTOOL_USE_MPI)
+IF(MEDCOUPLING_USE_MPI)
ADD_SUBDIRECTORY(ParaMEDMEM)
- IF(NOT MEDTOOL_MED_MICROMED)
+ IF(NOT MEDCOUPLING_MED_MICROMED)
ADD_SUBDIRECTORY(ParaMEDLoader)
- ENDIF(NOT MEDTOOL_MED_MICROMED)
- IF(MEDTOOL_MED_ENABLE_PYTHON)
+ ENDIF(NOT MEDCOUPLING_MED_MICROMED)
+ IF(MEDCOUPLING_MED_ENABLE_PYTHON)
ADD_SUBDIRECTORY(ParaMEDMEM_Swig)
- ENDIF(MEDTOOL_MED_ENABLE_PYTHON)
- IF(MEDTOOL_BUILD_TESTS)
- IF(NOT MEDTOOL_MED_MICROMED)
+ ENDIF(MEDCOUPLING_MED_ENABLE_PYTHON)
+ IF(MEDCOUPLING_BUILD_TESTS)
+ IF(NOT MEDCOUPLING_MED_MICROMED)
ADD_SUBDIRECTORY(ParaMEDMEMTest)
- ENDIF(NOT MEDTOOL_MED_MICROMED)
- ENDIF(MEDTOOL_BUILD_TESTS)
-ENDIF(MEDTOOL_USE_MPI)
+ ENDIF(NOT MEDCOUPLING_MED_MICROMED)
+ ENDIF(MEDCOUPLING_BUILD_TESTS)
+ENDIF(MEDCOUPLING_USE_MPI)
# Application tests
INSTALL(FILES CTestTestfileInstall.cmake
- DESTINATION ${MEDTOOL_INSTALL_TESTS}
+ DESTINATION ${MEDCOUPLING_INSTALL_TESTS}
RENAME CTestTestfile.cmake)
INSTALL(FILES CTestTestfileInstallMEDCoupling.cmake
- DESTINATION ${MEDTOOL_INSTALL_TESTS}/MEDCoupling
+ DESTINATION ${MEDCOUPLING_INSTALL_TESTS}/MEDCoupling
RENAME CTestTestfile.cmake)
ADD_LIBRARY(interpkernel SHARED ${interpkernel_SOURCES})
SET_TARGET_PROPERTIES(interpkernel PROPERTIES COMPILE_FLAGS "${PLATFORM_MMAP}")
TARGET_LINK_LIBRARIES(interpkernel ${PLATFORM_LIBS})
-INSTALL(TARGETS interpkernel EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDTOOL_INSTALL_LIBS})
+INSTALL(TARGETS interpkernel EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
FILE(GLOB_RECURSE interpkernel_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
FILE(GLOB_RECURSE interpkernel_HEADERS_TXX "${CMAKE_CURRENT_SOURCE_DIR}/*.txx")
-INSTALL(FILES ${interpkernel_HEADERS_HXX} ${interpkernel_HEADERS_TXX} Bases/NormalizedGeometricTypes DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(FILES ${interpkernel_HEADERS_HXX} ${interpkernel_HEADERS_TXX} Bases/NormalizedGeometricTypes DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
# Will be used for SWIG dependencies:
SET (interpkernel_HEADERS_HXX PARENT_SCOPE)
)
ADD_EXECUTABLE(PerfTest ${PerfTest_SOURCES})
TARGET_LINK_LIBRARIES(PerfTest InterpKernelTest ${CPPUNIT_LIBRARIES} ${PLATFORM_LIBS})
- INSTALL(TARGETS PerfTest DESTINATION ${MEDTOOL_INSTALL_BINS})
+ INSTALL(TARGETS PerfTest DESTINATION ${MEDCOUPLING_INSTALL_BINS})
ENDIF(NOT MED_ENABLE_MICROMED)
ADD_LIBRARY(InterpKernelTest SHARED ${InterpKernelTest_SOURCES})
TARGET_LINK_LIBRARIES(TestINTERP_KERNEL InterpKernelTest ${CPPUNIT_LIBRARIES} ${PLATFORM_LIBS})
ADD_TEST(TestINTERP_KERNEL TestINTERP_KERNEL)
-INSTALL(TARGETS TestINTERP_KERNEL DESTINATION ${MEDTOOL_INSTALL_BINS})
-INSTALL(TARGETS InterpKernelTest DESTINATION ${MEDTOOL_INSTALL_LIBS})
-INSTALL(FILES CppUnitTest.hxx InterpKernelTestExport.hxx DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(TARGETS TestINTERP_KERNEL DESTINATION ${MEDCOUPLING_INSTALL_BINS})
+INSTALL(TARGETS InterpKernelTest DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
+INSTALL(FILES CppUnitTest.hxx InterpKernelTestExport.hxx DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
# Application tests
-SET(TEST_INSTALL_DIRECTORY ${MEDTOOL_INSTALL_TESTS}/MEDCoupling/INTERP_KERNELTest)
+SET(TEST_INSTALL_DIRECTORY ${MEDCOUPLING_INSTALL_TESTS}/MEDCoupling/INTERP_KERNELTest)
INSTALL(TARGETS TestINTERP_KERNEL InterpKernelTest DESTINATION ${TEST_INSTALL_DIRECTORY})
INSTALL(FILES CTestTestfileInstall.cmake
void Interpolation3DTest::calcIntersectionMatrix(const char* mesh1path, const char* mesh1, const char* mesh2path, const char* mesh2, IntersectionMatrix& m) const
{
string dataDir = "";
- if ( getenv("MEDTOOL_ROOT_DIR") ) {
- dataDir = getenv("MEDTOOL_ROOT_DIR");
+ if ( getenv("MEDCOUPLING_ROOT_DIR") ) {
+ dataDir = getenv("MEDCOUPLING_ROOT_DIR");
dataDir += "/share/resources/med/";
}
else {
* Calculates the intersection matrix for two meshes.
* If the source and target meshes are the same, a CppUnit assertion raised if testVolumes() returns false.
*
- * @param mesh1path the path to the file containing the source mesh, relative to {$MEDTOOL_ROOT_DIR}/share/resources/med/
+ * @param mesh1path the path to the file containing the source mesh, relative to {$MEDCOUPLING_ROOT_DIR}/share/resources/med/
* @param mesh1 the name of the source mesh
- * @param mesh2path the path to the file containing the target mesh, relative to {$MEDTOOL_ROOT_DIR}/share/resources/med/
+ * @param mesh2path the path to the file containing the target mesh, relative to {$MEDCOUPLING_ROOT_DIR}/share/resources/med/
* @param mesh2 the name of the target mesh
* @param m intersection matrix in which to store the result of the intersection
*/
* it will be confirmed that the intersection matrix is diagonal, otherwise the intersection matrices will be
* calculated once which each mesh as source mesh, and it will be verified that the they are each others' transpose.
*
- * @param mesh1path the path to the file containing the source mesh, relative to {$MEDTOOL_ROOT_DIR}/share/resources/med/
+ * @param mesh1path the path to the file containing the source mesh, relative to {$MEDCOUPLING_ROOT_DIR}/share/resources/med/
* @param mesh1 the name of the source mesh
- * @param mesh2path the path to the file containing the target mesh, relative to {$MEDTOOL_ROOT_DIR}/share/resources/med/
+ * @param mesh2path the path to the file containing the target mesh, relative to {$MEDCOUPLING_ROOT_DIR}/share/resources/med/
* @param mesh2 the name of the target mesh
* @param correctVol the total volume of the intersection of the two meshes
* @param prec maximum relative error to be tolerated in volume comparisions
*
* USAGE : PerfTest mesh1 mesh2
* where mesh1 and mesh2 are the names of two meshes located in
- * the files mesh1.med, mesh2.med in {$MEDTOOL_ROOT_DIR}/share/resources/med/
+ * the files mesh1.med, mesh2.med in {$MEDCOUPLING_ROOT_DIR}/share/resources/med/
*
*/
* the number of matrix elements and the number of non-zero matrix elements, etc.
* These values help to determine how well the filtering algorithm is working.
*
- * @param mesh1path the path to the file containing the source mesh, relative to {$MEDTOOL_ROOT_DIR}/share/resources/med/
+ * @param mesh1path the path to the file containing the source mesh, relative to {$MEDCOUPLING_ROOT_DIR}/share/resources/med/
* @param mesh1 the name of the source mesh
- * @param mesh2path the path to the file containing the target mesh, relative to {$MEDTOOL_ROOT_DIR}/share/resources/med/
+ * @param mesh2path the path to the file containing the target mesh, relative to {$MEDCOUPLING_ROOT_DIR}/share/resources/med/
* @param mesh2 the name of the target mesh
* @param m intersection matrix in which to store the result of the intersection
*/
{
std::string resourceFile = "";
- if ( getenv("MEDTOOL_ROOT_DIR") ) {
- // use MEDTOOL_ROOT_DIR env.var
- resourceFile = getenv("MEDTOOL_ROOT_DIR");
+ if ( getenv("MEDCOUPLING_ROOT_DIR") ) {
+ // use MEDCOUPLING_ROOT_DIR env.var
+ resourceFile = getenv("MEDCOUPLING_ROOT_DIR");
resourceFile += "/share/resources/med/";
}
else {
#
# Author : Anthony Geay (CEA/DEN)
-IF(MEDTOOL_BUILD_TESTS)
+IF(MEDCOUPLING_BUILD_TESTS)
ADD_SUBDIRECTORY(Test)
-ENDIF(MEDTOOL_BUILD_TESTS)
+ENDIF(MEDCOUPLING_BUILD_TESTS)
INCLUDE_DIRECTORIES(
${CMAKE_CURRENT_BINARY_DIR}/../..
ADD_LIBRARY(medcoupling SHARED ${medcoupling_SOURCES})
TARGET_LINK_LIBRARIES(medcoupling interpkernel)
-INSTALL(TARGETS medcoupling EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDTOOL_INSTALL_LIBS})
+INSTALL(TARGETS medcoupling EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
ADD_LIBRARY(medcouplingremapper SHARED ${medcouplingremapper_SOURCES})
TARGET_LINK_LIBRARIES(medcouplingremapper medcoupling)
-INSTALL(TARGETS medcouplingremapper EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDTOOL_INSTALL_LIBS})
+INSTALL(TARGETS medcouplingremapper EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
FILE(GLOB medcoupling_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
FILE(GLOB medcoupling_HEADERS_TXX "${CMAKE_CURRENT_SOURCE_DIR}/*.txx")
-INSTALL(FILES ${medcoupling_HEADERS_HXX} ${medcoupling_HEADERS_TXX} MEDCouplingNatureOfFieldEnum DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(FILES ${medcoupling_HEADERS_HXX} ${medcoupling_HEADERS_TXX} MEDCouplingNatureOfFieldEnum DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
# To allow usage as SWIG dependencies:
SET(medcoupling_HEADERS_HXX PARENT_SCOPE)
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingRefCountObject.hxx"
-#include "MEDtool_version.h"
+#include "MEDCoupling_version.h"
#include <sstream>
#include <algorithm>
const char *ParaMEDMEM::MEDCouplingVersionStr()
{
- return MEDTOOL_VERSION_STR;
+ return MEDCOUPLING_VERSION_STR;
}
int ParaMEDMEM::MEDCouplingVersion()
{
- return MEDTOOL_VERSION;
+ return MEDCOUPLING_VERSION;
}
void ParaMEDMEM::MEDCouplingVersionMajMinRel(int& maj, int& minor, int& releas)
{
- int ver=MEDTOOL_VERSION;
+ int ver=MEDCOUPLING_VERSION;
maj=(ver & 0xFF0000) >> 16;
minor=(ver & 0xFF00) >> 8;
releas=(ver & 0xFF);
TARGET_LINK_LIBRARIES(TestMEDCouplingExamples medcoupling ${CPPUNIT_LIBRARIES} ${PLATFORM_LIBS})
ADD_TEST(TestMEDCouplingExamples TestMEDCouplingExamples)
-INSTALL(TARGETS TestMEDCoupling TestMEDCouplingRemapper TestMEDCouplingExamples DESTINATION ${MEDTOOL_INSTALL_BINS})
+INSTALL(TARGETS TestMEDCoupling TestMEDCouplingRemapper TestMEDCouplingExamples DESTINATION ${MEDCOUPLING_INSTALL_BINS})
SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES UnitTestsResult)
# Application tests
-SET(TEST_INSTALL_DIRECTORY ${MEDTOOL_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDCoupling)
+SET(TEST_INSTALL_DIRECTORY ${MEDCOUPLING_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDCoupling)
INSTALL(TARGETS TestMEDCoupling TestMEDCouplingRemapper TestMEDCouplingExamples DESTINATION ${TEST_INSTALL_DIRECTORY})
INSTALL(FILES CTestTestfileInstall.cmake
# SWIG must run after the doc if we want to have the docstrings extracted from Doxygen
# into the Python module:
-IF(MEDTOOL_BUILD_DOC)
+IF(MEDCOUPLING_BUILD_DOC)
LIST(APPEND SWIG_MODULE_MEDCoupling_EXTRA_FLAGS -DWITH_DOCSTRINGS)
LIST(APPEND SWIG_MODULE_MEDCoupling_EXTRA_DEPS
${PROJECT_BINARY_DIR}/doc/MEDCoupling_doc.i
SET_TARGET_PROPERTIES(_MEDCouplingRemapper PROPERTIES DEBUG_OUTPUT_NAME _MEDCouplingRemapper_d)
SET_TARGET_PROPERTIES(_MEDCoupling PROPERTIES DEBUG_OUTPUT_NAME _MEDCoupling_d)
ENDIF(WIN32)
-INSTALL(TARGETS ${SWIG_MODULE_MEDCoupling_REAL_NAME} ${SWIG_MODULE_MEDCouplingRemapper_REAL_NAME} DESTINATION ${MEDTOOL_INSTALL_PYTHON})
+INSTALL(TARGETS ${SWIG_MODULE_MEDCoupling_REAL_NAME} ${SWIG_MODULE_MEDCouplingRemapper_REAL_NAME} DESTINATION ${MEDCOUPLING_INSTALL_PYTHON})
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/MEDCoupling.py ${CMAKE_CURRENT_BINARY_DIR}/MEDCouplingRemapper.py DESTINATION ${MEDTOOL_INSTALL_PYTHON})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/MEDCoupling.py ${CMAKE_CURRENT_BINARY_DIR}/MEDCouplingRemapper.py DESTINATION ${MEDCOUPLING_INSTALL_PYTHON})
-INSTALL(FILES MEDCoupling.i MEDCouplingCommon.i MEDCouplingRefCountObject.i MEDCouplingMemArray.i MEDCouplingFieldDiscretization.i MEDCouplingTimeDiscretization.i MEDCouplingFinalize.i MEDCouplingRemapper.i MEDCouplingTypemaps.i MEDCouplingDataArrayTypemaps.i DESTINATION ${MEDTOOL_INSTALL_HEADERS})
-INSTALL(FILES MEDCouplingBasicsTest.py MEDCouplingRemapperTest.py MEDCouplingDataForTest.py MEDCouplingNumPyTest.py MEDCouplingPickleTest.py DESTINATION ${MEDTOOL_INSTALL_SCRIPT_PYTHON})
-INSTALL(FILES MEDCouplingExamplesTest.py DESTINATION ${MEDTOOL_INSTALL_SCRIPT_PYTHON})
+INSTALL(FILES MEDCoupling.i MEDCouplingCommon.i MEDCouplingRefCountObject.i MEDCouplingMemArray.i MEDCouplingFieldDiscretization.i MEDCouplingTimeDiscretization.i MEDCouplingFinalize.i MEDCouplingRemapper.i MEDCouplingTypemaps.i MEDCouplingDataArrayTypemaps.i DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
+INSTALL(FILES MEDCouplingBasicsTest.py MEDCouplingRemapperTest.py MEDCouplingDataForTest.py MEDCouplingNumPyTest.py MEDCouplingPickleTest.py DESTINATION ${MEDCOUPLING_INSTALL_SCRIPT_PYTHON})
+INSTALL(FILES MEDCouplingExamplesTest.py DESTINATION ${MEDCOUPLING_INSTALL_SCRIPT_PYTHON})
ADD_TEST(MEDCouplingBasicsTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDCouplingBasicsTest.py)
ADD_TEST(MEDCouplingExamplesTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDCouplingExamplesTest.py)
# Application tests
-SET(TEST_INSTALL_DIRECTORY ${MEDTOOL_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDCoupling_Swig)
+SET(TEST_INSTALL_DIRECTORY ${MEDCOUPLING_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDCoupling_Swig)
INSTALL(FILES MEDCouplingBasicsTest.py MEDCouplingRemapperTest.py MEDCouplingDataForTest.py MEDCouplingNumPyTest.py MEDCouplingPickleTest.py MEDCouplingExamplesTest.py DESTINATION ${TEST_INSTALL_DIRECTORY})
INSTALL(FILES CTestTestfileInstall.cmake
ADD_DEFINITIONS(${HDF5_DEFINITIONS} ${MEDFILE_DEFINITIONS} ${XDR_DEFINITIONS})
-IF(MEDTOOL_MED_ENABLE_PYTHON)
+IF(MEDCOUPLING_MED_ENABLE_PYTHON)
ADD_SUBDIRECTORY(Swig)
-ENDIF(MEDTOOL_MED_ENABLE_PYTHON)
+ENDIF(MEDCOUPLING_MED_ENABLE_PYTHON)
-IF(MEDTOOL_BUILD_TESTS)
+IF(MEDCOUPLING_BUILD_TESTS)
ADD_SUBDIRECTORY(Test)
-ENDIF(MEDTOOL_BUILD_TESTS)
+ENDIF(MEDCOUPLING_BUILD_TESTS)
SET(MEDLOADER_XDR_INCLUDE_DIRS)
SET(MEDLOADER_XDR_LIBRARIES)
IF(WIN32)
- IF(MEDTOOL_MED_MEDLOADER_USE_XDR)
+ IF(MEDCOUPLING_MED_MEDLOADER_USE_XDR)
ADD_DEFINITIONS(-DNOMINMAX)
SET(MEDLOADER_XDR_INCLUDE_DIRS ${XDR_INCLUDE_DIRS})
SET(MEDLOADER_XDR_LIBRARIES ${XDR_LIBRARIES})
- ENDIF(MEDTOOL_MED_MEDLOADER_USE_XDR)
+ ENDIF(MEDCOUPLING_MED_MEDLOADER_USE_XDR)
ELSE(WIN32)
SET(MEDLOADER_XDR_INCLUDE_DIRS ${XDR_INCLUDE_DIRS})
ENDIF(WIN32)
ADD_LIBRARY(medloader SHARED ${medloader_SOURCES})
SET_TARGET_PROPERTIES(medloader PROPERTIES COMPILE_FLAGS "")
TARGET_LINK_LIBRARIES(medloader medcoupling ${MEDFILE_C_LIBRARIES} ${HDF5_LIBRARIES} ${MEDLOADER_XDR_LIBRARIES})
-INSTALL(TARGETS medloader EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDTOOL_INSTALL_LIBS})
+INSTALL(TARGETS medloader EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
FILE(GLOB medloader_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${medloader_HEADERS_HXX} DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(FILES ${medloader_HEADERS_HXX} DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
# To allow usage as SWIG dependencies:
SET(medloader_HEADERS_HXX PARENT_SCOPE)
# SWIG must run after the doc if we want to have the docstrings extracted from Doxygen
# into the Python module:
-IF(MEDTOOL_BUILD_DOC)
+IF(MEDCOUPLING_BUILD_DOC)
LIST(APPEND SWIG_MODULE_MEDLoader_EXTRA_FLAGS -DWITH_DOCSTRINGS)
LIST(APPEND SWIG_MODULE_MEDLoader_EXTRA_DEPS
${PROJECT_BINARY_DIR}/doc/MEDLoader_doc.i
SET_TARGET_PROPERTIES(_MEDLoader PROPERTIES DEBUG_OUTPUT_NAME _MEDLoader_d)
ENDIF(WIN32)
-INSTALL(TARGETS _MEDLoader DESTINATION ${MEDTOOL_INSTALL_PYTHON})
-INSTALL(FILES MEDLoader.i MEDLoaderTypemaps.i MEDLoaderCommon.i DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(TARGETS _MEDLoader DESTINATION ${MEDCOUPLING_INSTALL_PYTHON})
+INSTALL(FILES MEDLoader.i MEDLoaderTypemaps.i MEDLoaderCommon.i DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/MEDLoader.py DESTINATION ${MEDTOOL_INSTALL_PYTHON})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/MEDLoader.py DESTINATION ${MEDCOUPLING_INSTALL_PYTHON})
-INSTALL(FILES MEDLoaderDataForTest.py MEDLoaderTest.py MEDLoaderTest2.py MEDLoaderTest3.py MEDLoaderTest4.py SauvLoaderTest.py MEDLoaderExamplesTest.py MEDLoaderCouplingTrainingSession.py CaseIO.py CaseReader.py CaseWriter.py VTKReader.py MEDLoaderSplitter.py medutilities.py DESTINATION ${MEDTOOL_INSTALL_SCRIPT_SCRIPTS})
-INSTALL(FILES med2sauv PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ DESTINATION ${MEDTOOL_INSTALL_BINS} )
-INSTALL(FILES sauv2med PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ DESTINATION ${MEDTOOL_INSTALL_BINS} )
-INSTALL(FILES case2med PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ DESTINATION ${MEDTOOL_INSTALL_BINS} )
-INSTALL(FILES med2case PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ DESTINATION ${MEDTOOL_INSTALL_BINS} )
+INSTALL(FILES MEDLoaderDataForTest.py MEDLoaderTest.py MEDLoaderTest2.py MEDLoaderTest3.py MEDLoaderTest4.py SauvLoaderTest.py MEDLoaderExamplesTest.py MEDLoaderCouplingTrainingSession.py CaseIO.py CaseReader.py CaseWriter.py VTKReader.py MEDLoaderSplitter.py medutilities.py DESTINATION ${MEDCOUPLING_INSTALL_SCRIPT_SCRIPTS})
+INSTALL(FILES med2sauv PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ DESTINATION ${MEDCOUPLING_INSTALL_BINS} )
+INSTALL(FILES sauv2med PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ DESTINATION ${MEDCOUPLING_INSTALL_BINS} )
+INSTALL(FILES case2med PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ DESTINATION ${MEDCOUPLING_INSTALL_BINS} )
+INSTALL(FILES med2case PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ DESTINATION ${MEDCOUPLING_INSTALL_BINS} )
ADD_TEST(MEDLoaderTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDLoaderTest.py)
ADD_TEST(MEDLoaderTest2 ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDLoaderTest2.py)
# Application tests
-SET(TEST_INSTALL_DIRECTORY ${MEDTOOL_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDLoader/Swig)
+SET(TEST_INSTALL_DIRECTORY ${MEDCOUPLING_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDLoader/Swig)
SET(MEDLOADER_TEST_FILES MEDLoaderDataForTest.py MEDLoaderTest.py MEDLoaderTest2.py MEDLoaderTest3.py MEDLoaderTest4.py SauvLoaderTest.py MEDLoaderExamplesTest.py MEDLoaderCouplingTrainingSession.py CaseIO.py CaseReader.py CaseWriter.py VTKReader.py MEDLoaderSplitter.py medutilities.py)
from numpy import *
from math import acos
-med_root_dir=os.getenv("MEDTOOL_ROOT_DIR")
+med_root_dir=os.getenv("MEDCOUPLING_ROOT_DIR")
if med_root_dir:
- agitateur_file=os.path.join(os.getenv("MEDTOOL_ROOT_DIR"),"share","resources","med","agitateur.med")
+ agitateur_file=os.path.join(os.getenv("MEDCOUPLING_ROOT_DIR"),"share","resources","med","agitateur.med")
else:
current_dir = os.path.dirname(os.path.realpath(__file__))
agitateur_file=os.path.join(current_dir, "..", "..", "..", "resources","agitateur.med")
class SauvLoaderTest(unittest.TestCase):
def __getResourcesDirectory(self):
- med_root_dir=os.getenv("MEDTOOL_ROOT_DIR")
+ med_root_dir=os.getenv("MEDCOUPLING_ROOT_DIR")
if med_root_dir:
- return os.path.join( os.getenv("MEDTOOL_ROOT_DIR"), "share","resources","med")
+ return os.path.join( os.getenv("MEDCOUPLING_ROOT_DIR"), "share","resources","med")
else:
current_dir = os.path.dirname(os.path.realpath(__file__))
return os.path.join(current_dir, "..", "..", "..", "resources")
TARGET_LINK_LIBRARIES(TestSauvLoader medloader ${CPPUNIT_LIBRARIES} ${PLATFORM_LIBS})
ADD_TEST(TestSauvLoader TestSauvLoader)
-INSTALL(TARGETS TestMEDLoader TestSauvLoader DESTINATION ${MEDTOOL_INSTALL_BINS})
+INSTALL(TARGETS TestMEDLoader TestSauvLoader DESTINATION ${MEDCOUPLING_INSTALL_BINS})
# Application tests
-SET(TEST_INSTALL_DIRECTORY ${MEDTOOL_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDLoader)
+SET(TEST_INSTALL_DIRECTORY ${MEDCOUPLING_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDLoader)
INSTALL(TARGETS TestMEDLoader TestSauvLoader DESTINATION ${TEST_INSTALL_DIRECTORY})
INSTALL(FILES CTestTestfileInstall.cmake
{
std::string resourceFile = "";
- if ( getenv("MEDTOOL_ROOT_DIR") ) {
- // use MEDTOOL_ROOT_DIR env.var
- resourceFile = getenv("MEDTOOL_ROOT_DIR");
+ if ( getenv("MEDCOUPLING_ROOT_DIR") ) {
+ // use MEDCOUPLING_ROOT_DIR env.var
+ resourceFile = getenv("MEDCOUPLING_ROOT_DIR");
resourceFile += "/share/resources/med/";
}
else {
{
std::string resourceFile = "";
- if ( getenv("MEDTOOL_ROOT_DIR") ) {
- // use MEDTOOL_ROOT_DIR env.var
- resourceFile = getenv("MEDTOOL_ROOT_DIR");
+ if ( getenv("MEDCOUPLING_ROOT_DIR") ) {
+ // use MEDCOUPLING_ROOT_DIR env.var
+ resourceFile = getenv("MEDCOUPLING_ROOT_DIR");
resourceFile += "/share/resources/med/";
}
else {
${CMAKE_CURRENT_SOURCE_DIR}/../INTERP_KERNEL/GaussPoints
)
-IF(MEDTOOL_MED_PARTITIONER_METIS)
+IF(MEDCOUPLING_MED_PARTITIONER_METIS)
ADD_DEFINITIONS(${METIS_DEFINITIONS})
- IF(MEDTOOL_METIS_V5)
+ IF(MEDCOUPLING_METIS_V5)
ADD_DEFINITIONS("-DMED_ENABLE_METIS_V5")
- ENDIF(MEDTOOL_METIS_V5)
+ ENDIF(MEDCOUPLING_METIS_V5)
INCLUDE_DIRECTORIES(${METIS_INCLUDE_DIRS})
-ENDIF(MEDTOOL_MED_PARTITIONER_METIS)
+ENDIF(MEDCOUPLING_MED_PARTITIONER_METIS)
########
# VERY IMPORTANT PUT METIS BEFORE SCOTCH because
# metis.h is also in SCOTCH install dir !!!
########
-IF(MEDTOOL_MED_PARTITIONER_SCOTCH)
+IF(MEDCOUPLING_MED_PARTITIONER_SCOTCH)
ADD_DEFINITIONS(${SCOTCH_DEFINITIONS})
INCLUDE_DIRECTORIES(${SCOTCH_INCLUDE_DIRS})
-ENDIF(MEDTOOL_MED_PARTITIONER_SCOTCH)
+ENDIF(MEDCOUPLING_MED_PARTITIONER_SCOTCH)
-IF(MEDTOOL_MED_PARTITIONER_PARMETIS)
+IF(MEDCOUPLING_MED_PARTITIONER_PARMETIS)
ADD_DEFINITIONS(${PARMETIS_DEFINITIONS})
INCLUDE_DIRECTORIES(${PARMETIS_INCLUDE_DIRS})
-ENDIF(MEDTOOL_MED_PARTITIONER_PARMETIS)
+ENDIF(MEDCOUPLING_MED_PARTITIONER_PARMETIS)
-IF(MEDTOOL_USE_MPI)
+IF(MEDCOUPLING_USE_MPI)
ADD_DEFINITIONS(${MPI_DEFINITIONS})
INCLUDE_DIRECTORIES(${MPI_INCLUDE_DIRS})
-ENDIF(MEDTOOL_USE_MPI)
+ENDIF(MEDCOUPLING_USE_MPI)
-IF(MEDTOOL_BUILD_TESTS)
+IF(MEDCOUPLING_BUILD_TESTS)
ADD_SUBDIRECTORY(Test)
-ENDIF(MEDTOOL_BUILD_TESTS)
+ENDIF(MEDCOUPLING_BUILD_TESTS)
SET(medpartitionercpp_HEADERS_HXX
MEDPARTITIONER_MeshCollection.hxx
medcoupling
medloader
)
-IF(MEDTOOL_MED_PARTITIONER_PARMETIS)
+IF(MEDCOUPLING_MED_PARTITIONER_PARMETIS)
SET(medpartitionercpp_HEADERS_HXX ${medpartitionercpp_HEADERS_HXX} MEDPARTITIONER_ParMetisGraph.hxx)
SET(medpartitionercpp_SOURCES ${medpartitionercpp_SOURCES} MEDPARTITIONER_ParMetisGraph.cxx MEDPARTITIONER_MetisGraph.cxx)
SET(medpartitionercpp_DEFINITIONS "${medpartitionercpp_DEFINITIONS} ${PARMETIS_DEFINITIONS}")
SET(medpartitionercpp_LDFLAGS ${medpartitionercpp_LDFLAGS} ${PARMETIS_LIBRARIES})
-ENDIF(MEDTOOL_MED_PARTITIONER_PARMETIS)
-IF(MEDTOOL_MED_PARTITIONER_METIS)
+ENDIF(MEDCOUPLING_MED_PARTITIONER_PARMETIS)
+IF(MEDCOUPLING_MED_PARTITIONER_METIS)
SET(medpartitionercpp_HEADERS_HXX ${medpartitionercpp_HEADERS_HXX} MEDPARTITIONER_MetisGraph.hxx)
SET(medpartitionercpp_SOURCES ${medpartitionercpp_SOURCES} MEDPARTITIONER_MetisGraph.cxx)
SET(medpartitionercpp_DEFINITIONS "${medpartitionercpp_DEFINITIONS} ${METIS_DEFINITIONS}")
SET(medpartitionercpp_LDFLAGS ${medpartitionercpp_LDFLAGS} ${METIS_LIBRARIES})
-ENDIF(MEDTOOL_MED_PARTITIONER_METIS)
-IF(MEDTOOL_MED_PARTITIONER_SCOTCH)
+ENDIF(MEDCOUPLING_MED_PARTITIONER_METIS)
+IF(MEDCOUPLING_MED_PARTITIONER_SCOTCH)
SET(medpartitionercpp_HEADERS_HXX ${medpartitionercpp_HEADERS_HXX} MEDPARTITIONER_ScotchGraph.hxx)
SET(medpartitionercpp_SOURCES ${medpartitionercpp_SOURCES} MEDPARTITIONER_ScotchGraph.cxx)
SET(medpartitionercpp_DEFINITIONS "${medpartitionercpp_DEFINITIONS} ${SCOTCH_DEFINITIONS}")
SET(medpartitionercpp_LDFLAGS ${medpartitionercpp_LDFLAGS} ${SCOTCH_LIBRARIES})
-ENDIF(MEDTOOL_MED_PARTITIONER_SCOTCH)
+ENDIF(MEDCOUPLING_MED_PARTITIONER_SCOTCH)
-IF(${MEDTOOL_USE_MPI})
+IF(${MEDCOUPLING_USE_MPI})
SET(medpartitionercpp_SOURCES ${medpartitionercpp_SOURCES} MEDPARTITIONER_UtilsPara.cxx MEDPARTITIONER_JointFinder.cxx)
ADD_EXECUTABLE(medpartitioner_para medpartitioner_para.cxx)
SET(medpartitionercpp_LDFLAGS ${medpartitionercpp_LDFLAGS} ${MPI_LIBRARIES})
SET_TARGET_PROPERTIES(medpartitioner_para PROPERTIES COMPILE_FLAGS "${medpartitionercpp_DEFINITIONS}")
TARGET_LINK_LIBRARIES(medpartitioner_para medpartitionercpp ${medpartitionercpp_LDFLAGS})
- INSTALL(TARGETS medpartitioner_para DESTINATION ${MEDTOOL_INSTALL_BINS})
-ENDIF(${MEDTOOL_USE_MPI})
+ INSTALL(TARGETS medpartitioner_para DESTINATION ${MEDCOUPLING_INSTALL_BINS})
+ENDIF(${MEDCOUPLING_USE_MPI})
ADD_DEFINITIONS(${medpartitionercpp_DEFINITIONS})
ADD_LIBRARY(medpartitionercpp SHARED ${medpartitionercpp_SOURCES})
TARGET_LINK_LIBRARIES(medpartitionercpp ${medpartitionercpp_LDFLAGS} ${PLATFORM_LIBS} ${PTHREAD_LIBS})
-INSTALL(TARGETS medpartitionercpp DESTINATION ${MEDTOOL_INSTALL_LIBS})
+INSTALL(TARGETS medpartitionercpp DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
ADD_EXECUTABLE(medpartitioner medpartitioner.cxx)
TARGET_LINK_LIBRARIES(medpartitioner medpartitionercpp ${medpartitionercpp_LDFLAGS})
-INSTALL(TARGETS medpartitioner DESTINATION ${MEDTOOL_INSTALL_BINS})
+INSTALL(TARGETS medpartitioner DESTINATION ${MEDCOUPLING_INSTALL_BINS})
-INSTALL(FILES ${medpartitionercpp_HEADERS_HXX} DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(FILES ${medpartitionercpp_HEADERS_HXX} DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
SET(MEDPARTITIONERTest_LDFLAGS medpartitionercpp ${CPPUNIT_LIBRARIES})
-IF(MEDTOOL_USE_MPI)
- IF(MEDTOOL_MED_PARTITIONER_PARMETIS)
+IF(MEDCOUPLING_USE_MPI)
+ IF(MEDCOUPLING_MED_PARTITIONER_PARMETIS)
SET(MEDPARTITIONERTest_SOURCES ${MEDPARTITIONERTest_SOURCES} MEDPARTITIONERTestPara.cxx)
- ENDIF(MEDTOOL_MED_PARTITIONER_PARMETIS)
-ENDIF(MEDTOOL_USE_MPI)
+ ENDIF(MEDCOUPLING_MED_PARTITIONER_PARMETIS)
+ENDIF(MEDCOUPLING_USE_MPI)
ADD_LIBRARY(MEDPARTITIONERTest SHARED ${MEDPARTITIONERTest_SOURCES})
TARGET_LINK_LIBRARIES(MEDPARTITIONERTest ${MEDPARTITIONERTest_LDFLAGS})
-INSTALL(TARGETS MEDPARTITIONERTest DESTINATION ${MEDTOOL_INSTALL_LIBS})
+INSTALL(TARGETS MEDPARTITIONERTest DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
ADD_EXECUTABLE(TestMEDPARTITIONER TestMEDPARTITIONER.cxx)
TARGET_LINK_LIBRARIES(TestMEDPARTITIONER MEDPARTITIONERTest)
-INSTALL(TARGETS TestMEDPARTITIONER DESTINATION ${MEDTOOL_INSTALL_BINS})
+INSTALL(TARGETS TestMEDPARTITIONER DESTINATION ${MEDCOUPLING_INSTALL_BINS})
-INSTALL(FILES ${MEDPARTITIONERTest_HEADERS_HXX} DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(FILES ${MEDPARTITIONERTest_HEADERS_HXX} DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
ADD_TEST(TestMEDPARTITIONER TestMEDPARTITIONER)
# Application tests
-SET(TEST_INSTALL_DIRECTORY ${MEDTOOL_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDPartitioner)
+SET(TEST_INSTALL_DIRECTORY ${MEDCOUPLING_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDPartitioner)
INSTALL(TARGETS MEDPARTITIONERTest TestMEDPARTITIONER DESTINATION ${TEST_INSTALL_DIRECTORY})
INSTALL(FILES CTestTestfileInstall.cmake
std::string MEDPARTITIONERTest::getPartitionerExe() const
{
std::string execName;
- if ( getenv("MEDTOOL_ROOT_DIR") )
+ if ( getenv("MEDCOUPLING_ROOT_DIR") )
{
- execName=getenv("MEDTOOL_ROOT_DIR"); //.../INSTALL/MED
+ execName=getenv("MEDCOUPLING_ROOT_DIR"); //.../INSTALL/MED
execName+="/bin/medpartitioner";
}
else
execName = get_current_dir_name();
execName += "/../../MEDPartitioner/medpartitioner";
if (! std::ifstream(execName.c_str()))
- CPPUNIT_FAIL("Can't find medpartitioner, please set MEDTOOL_ROOT_DIR");
+ CPPUNIT_FAIL("Can't find medpartitioner, please set MEDCOUPLING_ROOT_DIR");
}
return execName;
}
std::string MEDPARTITIONERTest::getPartitionerParaExe() const
{
std::string execName;
- if ( getenv("MEDTOOL_ROOT_DIR") )
+ if ( getenv("MEDCOUPLING_ROOT_DIR") )
{
- execName=getenv("MEDTOOL_ROOT_DIR"); //.../INSTALL/MED
+ execName=getenv("MEDCOUPLING_ROOT_DIR"); //.../INSTALL/MED
execName+="/bin/medpartitioner_para";
}
else
execName = get_current_dir_name();
execName += "/../../MEDPartitioner/medpartitioner_para";
if (! std::ifstream(execName.c_str()))
- CPPUNIT_FAIL("Can't find medpartitioner_para, please set MEDTOOL_ROOT_DIR");
+ CPPUNIT_FAIL("Can't find medpartitioner_para, please set MEDCOUPLING_ROOT_DIR");
}
return execName;
}
IF(WIN32)
SET_TARGET_PROPERTIES(_MEDPartitioner PROPERTIES DEBUG_OUTPUT_NAME _MEDPartitioner_d)
ENDIF(WIN32)
-INSTALL(TARGETS ${SWIG_MODULE_MEDPartitioner_REAL_NAME} DESTINATION ${MEDTOOL_INSTALL_PYTHON})
+INSTALL(TARGETS ${SWIG_MODULE_MEDPartitioner_REAL_NAME} DESTINATION ${MEDCOUPLING_INSTALL_PYTHON})
SET(PYFILES_TO_INSTALL ${CMAKE_CURRENT_BINARY_DIR}/MEDPartitioner.py)
-INSTALL(FILES "${PYFILES_TO_INSTALL}" DESTINATION ${MEDTOOL_INSTALL_SCRIPT_PYTHON})
+INSTALL(FILES "${PYFILES_TO_INSTALL}" DESTINATION ${MEDCOUPLING_INSTALL_SCRIPT_PYTHON})
-INSTALL(FILES MEDPartitioner.i MEDPartitionerCommon.i DESTINATION ${MEDTOOL_INSTALL_HEADERS})
-INSTALL(FILES MEDPartitionerTest.py DESTINATION ${MEDTOOL_INSTALL_SCRIPT_PYTHON})
+INSTALL(FILES MEDPartitioner.i MEDPartitionerCommon.i DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
+INSTALL(FILES MEDPartitionerTest.py DESTINATION ${MEDCOUPLING_INSTALL_SCRIPT_PYTHON})
ADD_TEST(MEDPartitionerTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDPartitionerTest.py)
SET(MEDPartitionerTest_PYTHONPATH "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}:${CMAKE_CURRENT_BINARY_DIR}/../MEDLoader/Swig")
# Application tests
-SET(TEST_INSTALL_DIRECTORY ${MEDTOOL_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDPartitioner_Swig)
+SET(TEST_INSTALL_DIRECTORY ${MEDCOUPLING_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/MEDPartitioner_Swig)
INSTALL(FILES MEDPartitionerTest.py DESTINATION ${TEST_INSTALL_DIRECTORY})
INSTALL(FILES CTestTestfileInstall.cmake
ADD_LIBRARY(paramedloader SHARED ${paramedloader_SOURCES})
TARGET_LINK_LIBRARIES(paramedloader paramedmem medloader ${PLATFORM_LIBS})
-INSTALL(TARGETS paramedloader EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDTOOL_INSTALL_LIBS})
+INSTALL(TARGETS paramedloader EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
FILE(GLOB paramedloader_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${paramedloader_HEADERS_HXX} DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(FILES ${paramedloader_HEADERS_HXX} DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
ADD_LIBRARY(paramedmem SHARED ${paramedmem_SOURCES})
TARGET_LINK_LIBRARIES(paramedmem medcoupling ${MPI_LIBRARIES})
-INSTALL(TARGETS paramedmem EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDTOOL_INSTALL_LIBS})
+INSTALL(TARGETS paramedmem EXPORT ${PROJECT_NAME}TargetGroup DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
FILE(GLOB paramedmem_HEADERS_HXX "${CMAKE_CURRENT_SOURCE_DIR}/*.hxx")
-INSTALL(FILES ${paramedmem_HEADERS_HXX} DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(FILES ${paramedmem_HEADERS_HXX} DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
# To allow usage as SWIG dependencies:
SET(paramedmem_HEADERS_HXX PARENT_SCOPE)
ADD_LIBRARY(ParaMEDMEMTest SHARED ${ParaMEDMEMTest_SOURCES})
SET_TARGET_PROPERTIES(ParaMEDMEMTest PROPERTIES COMPILE_FLAGS "")
TARGET_LINK_LIBRARIES(ParaMEDMEMTest paramedmem paramedloader ${CPPUNIT_LIBRARIES})
-INSTALL(TARGETS ParaMEDMEMTest DESTINATION ${MEDTOOL_INSTALL_LIBS})
+INSTALL(TARGETS ParaMEDMEMTest DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
SET(TESTSParaMEDMEM)
SET(TestParaMEDMEM_SOURCES
ADD_TEST(NAME TestMPIAccessDEC_Proc4 COMMAND ${MPIEXEC} -np 4 $<TARGET_FILE:TestMPIAccessDEC>)
# Installation rules
-INSTALL(TARGETS ${TESTSParaMEDMEM} DESTINATION ${MEDTOOL_INSTALL_BINS})
+INSTALL(TARGETS ${TESTSParaMEDMEM} DESTINATION ${MEDCOUPLING_INSTALL_BINS})
SET(COMMON_HEADERS_HXX
MPIMainTest.hxx
MPIAccessDECTest.hxx
ParaMEDMEMTest.hxx
MPI2Connector.hxx
)
-INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(FILES ${COMMON_HEADERS_HXX} DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
{
std::string resourceFile = "";
- if ( getenv("MEDTOOL_ROOT_DIR") ) {
- // use MEDTOOL_ROOT_DIR env.var
- resourceFile = getenv("MEDTOOL_ROOT_DIR");
+ if ( getenv("MEDCOUPLING_ROOT_DIR") ) {
+ // use MEDCOUPLING_ROOT_DIR env.var
+ resourceFile = getenv("MEDCOUPLING_ROOT_DIR");
resourceFile += "/share/resources/med/";
}
else {
SET_SOURCE_FILES_PROPERTIES(ParaMEDMEM.i PROPERTIES CPLUSPLUS ON)
SET_SOURCE_FILES_PROPERTIES(ParaMEDMEM.i PROPERTIES SWIG_DEFINITIONS "-shadow")
-INSTALL(TARGETS _ParaMEDMEM DESTINATION ${MEDTOOL_INSTALL_PYTHON})
-INSTALL(FILES ParaMEDMEM.i DESTINATION ${MEDTOOL_INSTALL_HEADERS})
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/ParaMEDMEM.py test_InterpKernelDEC.py test_NonCoincidentDEC.py test_StructuredCoincidentDEC.py DESTINATION ${MEDTOOL_INSTALL_SCRIPT_PYTHON})
+INSTALL(TARGETS _ParaMEDMEM DESTINATION ${MEDCOUPLING_INSTALL_PYTHON})
+INSTALL(FILES ParaMEDMEM.i DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/ParaMEDMEM.py test_InterpKernelDEC.py test_NonCoincidentDEC.py test_StructuredCoincidentDEC.py DESTINATION ${MEDCOUPLING_INSTALL_SCRIPT_PYTHON})
paramesh =0
parafield =0
icocofield =0
- data_dir = os.environ['MEDTOOL_ROOT_DIR']
+ data_dir = os.environ['MEDCOUPLING_ROOT_DIR']
tmp_dir = os.environ['TMP']
if not tmp_dir or len(tmp_dir)==0:
dec = NonCoincidentDEC(source_group, target_group)
-data_dir = os.environ['MEDTOOL_ROOT_DIR']
+data_dir = os.environ['MEDCOUPLING_ROOT_DIR']
tmp_dir = os.environ['TMP']
if tmp_dir == '':
tmp_dir = "/tmp"
comptopo = 0
icocofield= 0
#
- data_dir = os.environ['MEDTOOL_ROOT_DIR']
+ data_dir = os.environ['MEDCOUPLING_ROOT_DIR']
tmp_dir = os.environ['TMP']
if tmp_dir == '':
tmp_dir = "/tmp"
${CMAKE_CURRENT_SOURCE_DIR}/../INTERP_KERNEL/GaussPoints
)
-IF(MEDTOOL_USE_MPI)
+IF(MEDCOUPLING_USE_MPI)
ADD_DEFINITIONS(${MPI_DEFINITIONS})
INCLUDE_DIRECTORIES(${MPI_INCLUDE_DIRS})
-ENDIF(MEDTOOL_USE_MPI)
+ENDIF(MEDCOUPLING_USE_MPI)
SET(renumbercpp_HEADERS_HXX
RENUMBER_Renumbering.hxx
SET(renumbercpp_LDFLAGS ${renumbercpp_LDFLAGS} ${BOOST_LIBRARIES})
ENDIF(Boost_FOUND)
-IF(MEDTOOL_USE_MPI)
+IF(MEDCOUPLING_USE_MPI)
SET(renumbercpp_LDFLAGS ${renumbercpp_LDFLAGS} ${MPI_LIBRARIES})
-ENDIF(MEDTOOL_USE_MPI)
+ENDIF(MEDCOUPLING_USE_MPI)
ADD_EXECUTABLE(renumber ${renumber_SOURCES})
SET_TARGET_PROPERTIES(renumber PROPERTIES COMPILE_FLAGS "${renumber_DEFINITIONS}")
TARGET_LINK_LIBRARIES(renumber renumbercpp)
-INSTALL(TARGETS renumber DESTINATION ${MEDTOOL_INSTALL_BINS})
+INSTALL(TARGETS renumber DESTINATION ${MEDCOUPLING_INSTALL_BINS})
ADD_LIBRARY(renumbercpp SHARED ${renumbercpp_SOURCES})
SET_TARGET_PROPERTIES(renumbercpp PROPERTIES COMPILE_FLAGS "${renumber_DEFINITIONS}")
TARGET_LINK_LIBRARIES(renumbercpp ${renumbercpp_LDFLAGS})
-INSTALL(TARGETS renumbercpp DESTINATION ${MEDTOOL_INSTALL_LIBS})
+INSTALL(TARGETS renumbercpp DESTINATION ${MEDCOUPLING_INSTALL_LIBS})
-INSTALL(FILES ${renumbercpp_HEADERS_HXX} DESTINATION ${MEDTOOL_INSTALL_HEADERS})
+INSTALL(FILES ${renumbercpp_HEADERS_HXX} DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
pass
def setUp(self):
- med_root_dir=os.getenv("MEDTOOL_ROOT_DIR")
+ med_root_dir=os.getenv("MEDCOUPLING_ROOT_DIR")
self.dir_renumber=os.path.join(med_root_dir, "bin/renumber")
self.dir_mesh=os.path.join(med_root_dir, "share","resources","med")
pass
IF(WIN32)
SET_TARGET_PROPERTIES(_MEDRenumber PROPERTIES DEBUG_OUTPUT_NAME _MEDRenumber_d)
ENDIF(WIN32)
-INSTALL(TARGETS ${SWIG_MODULE_MEDRenumber_REAL_NAME} DESTINATION ${MEDTOOL_INSTALL_PYTHON})
+INSTALL(TARGETS ${SWIG_MODULE_MEDRenumber_REAL_NAME} DESTINATION ${MEDCOUPLING_INSTALL_PYTHON})
-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/MEDRenumber.py DESTINATION ${MEDTOOL_INSTALL_SCRIPT_PYTHON})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/MEDRenumber.py DESTINATION ${MEDCOUPLING_INSTALL_SCRIPT_PYTHON})
-INSTALL(FILES MEDRenumber.i MEDRenumberCommon.i DESTINATION ${MEDTOOL_INSTALL_HEADERS})
-INSTALL(FILES MEDRenumberTest.py DESTINATION ${MEDTOOL_INSTALL_SCRIPT_PYTHON})
+INSTALL(FILES MEDRenumber.i MEDRenumberCommon.i DESTINATION ${MEDCOUPLING_INSTALL_HEADERS})
+INSTALL(FILES MEDRenumberTest.py DESTINATION ${MEDCOUPLING_INSTALL_SCRIPT_PYTHON})
ADD_TEST(MEDRenumberTest ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/MEDRenumberTest.py)
SET(MEDRenumberTest_PYTHONPATH "PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}:${CMAKE_CURRENT_BINARY_DIR}/../MEDCoupling_Swig")
# Application tests
-SET(TEST_INSTALL_DIRECTORY ${MEDTOOL_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/RENUMBER_Swig)
+SET(TEST_INSTALL_DIRECTORY ${MEDCOUPLING_INSTALL_SCRIPT_SCRIPTS}/test/MEDCoupling/RENUMBER_Swig)
INSTALL(FILES MEDRenumberTest.py DESTINATION ${TEST_INSTALL_DIRECTORY})
INSTALL(FILES CTestTestfileInstall.cmake
