ForkMaster/netgen
1
0
Fork 0
mirror of https://github.com/NGSolve/netgen.git synced 2024-12-26 22:00:33 +05:00
Code Issues Packages Projects Releases Wiki Activity

Merged master

Browse Source
This commit is contained in:
Lukas Kogler 2017-06-06 09:57:20 +02:00
commit 6524c0c170
87 changed files with 1848 additions and 1183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.gitlab-ci.yml
View File

@ -76,7 +76,7 @@ stages:
-DCMAKE_BUILD_TYPE=Release -DCMAKE_BUILD_TYPE=Release
- cmake --build . --target INSTALL --config Release - cmake --build . --target INSTALL --config Release
build_netgen_win32: .build_netgen_win32:
<<: *win32 <<: *win32
<<: *tbuild_netgen_win <<: *tbuild_netgen_win
cache: cache:
@ -126,7 +126,7 @@ build_ubuntu_1604:
- cd .. - cd ..
# skip since we have no machine with 32 bits # skip since we have no machine with 32 bits
test_win32: .test_win32:
<<: *win32 <<: *win32
<<: *test_win <<: *test_win
@ -197,7 +197,7 @@ win64_cleanup:
when: always when: always
allow_failure: true allow_failure: true
win32_cleanup: .win32_cleanup:
<<: *win32 <<: *win32
stage: cleanup stage: cleanup
tags: tags:

166
CMakeLists.txt
View File

@ -16,19 +16,51 @@ option( USE_MPEG "enable video recording with FFmpeg, uses libavcodec" OFF )
option( INTEL_MIC "cross compile for intel xeon phi") option( INTEL_MIC "cross compile for intel xeon phi")
option( INSTALL_PROFILES "install environment variable settings to /etc/profile.d" OFF ) option( INSTALL_PROFILES "install environment variable settings to /etc/profile.d" OFF )
option( USE_CCACHE "use ccache") option( USE_CCACHE "use ccache")
option( USE_INTERNAL_TCL "Compile tcl files into the code and don't install them" ON)
option( USE_SUPERBUILD "use ccache" ON) option( USE_SUPERBUILD "use ccache" ON)
set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_modules") set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_modules")
if(APPLE)
set(INSTALL_DIR_DEFAULT /Applications/Netgen.app)
else(APPLE)
if(WIN32)
set(INSTALL_DIR_DEFAULT "C:/netgen")
else(WIN32)
set(INSTALL_DIR_DEFAULT /opt/netgen)
endif(WIN32)
endif(APPLE)
if(INSTALL_DIR)
message(WARNING "INSTALL_DIR is deprecated, use CMAKE_INSTALL_PREFIX instead")
set(INSTALL_DIR_DEFAULT ${INSTALL_DIR})
endif(INSTALL_DIR)
if(UNIX)
message("Checking for write permissions in install directory...")
execute_process(COMMAND mkdir -p ${CMAKE_INSTALL_PREFIX})
execute_process(COMMAND test -w ${CMAKE_INSTALL_PREFIX} RESULT_VARIABLE res)
if(res)
message(WARNING "No write access at install directory, please set correct permissions")
endif()
endif(UNIX)
if (USE_SUPERBUILD) if (USE_SUPERBUILD)
project (SUPERBUILD) project (SUPERBUILD)
if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
set(CMAKE_INSTALL_PREFIX "${INSTALL_DIR_DEFAULT}" CACHE PATH "Install directory" FORCE)
endif()
# execute the superbuild (this script will be invoked again without the # execute the superbuild (this script will be invoked again without the
# USE_SUPERBUILD option this time) # USE_SUPERBUILD option this time)
include (cmake/SuperBuild.cmake) include (cmake/SuperBuild.cmake)
return() # stop processing this file further return() # stop processing this file further
else() else()
project(Netgen) project(Netgen)
if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
set(CMAKE_INSTALL_PREFIX "${INSTALL_DIR_DEFAULT}" CACHE PATH "Install directory" FORCE)
endif()
endif() endif()
set(NETGEN_VERSION_MAJOR 6) set(NETGEN_VERSION_MAJOR 6)
@ -37,7 +69,6 @@ string(TIMESTAMP NETGEN_VERSION_PATCH "%y%U%w" )
set(NETGEN_VERSION "${NETGEN_VERSION_MAJOR}.${NETGEN_VERSION_MINOR}-dev") set(NETGEN_VERSION "${NETGEN_VERSION_MAJOR}.${NETGEN_VERSION_MINOR}-dev")
set(PACKAGE_VERSION "${NETGEN_VERSION_MAJOR}.${NETGEN_VERSION_MINOR}-${NETGEN_VERSION_PATCH}") set(PACKAGE_VERSION "${NETGEN_VERSION_MAJOR}.${NETGEN_VERSION_MINOR}-${NETGEN_VERSION_PATCH}")
set(CPACK_PACKAGE_VERSION "${PACKAGE_VERSION}") set(CPACK_PACKAGE_VERSION "${PACKAGE_VERSION}")
# set(CPACK_DEBIAN_PACKAGE_VERSION "${PACKAGE_VERSION}"
####################################################################### #######################################################################
@ -69,48 +100,81 @@ if (ADDITIONAL_PATHS)
set(CMAKE_PREFIX_PATH ${ADDITIONAL_PATHS}) set(CMAKE_PREFIX_PATH ${ADDITIONAL_PATHS})
endif (ADDITIONAL_PATHS) endif (ADDITIONAL_PATHS)
if(APPLE)
set(CMAKE_INSTALL_PREFIX "${INSTALL_DIR}/Contents/Resources" CACHE INTERNAL "Prefix prepended to install directories" FORCE)
else(APPLE)
set(CMAKE_INSTALL_PREFIX "${INSTALL_DIR}" CACHE INTERNAL "Prefix prepended to install directories" FORCE)
endif(APPLE)
#######################################################################
# use rpath
SET(CMAKE_SKIP_BUILD_RPATH FALSE)
SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir)
IF("${isSystemDir}" STREQUAL "-1")
SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
ENDIF("${isSystemDir}" STREQUAL "-1")
####################################################################### #######################################################################
# build options # build options
add_definitions(-DUSE_TIMEOFDAY)
include_directories ("${PROJECT_SOURCE_DIR}/include") include_directories ("${PROJECT_SOURCE_DIR}/include")
include_directories ("${PROJECT_SOURCE_DIR}/libsrc/include") include_directories ("${PROJECT_SOURCE_DIR}/libsrc/include")
include_directories ("${PROJECT_BINARY_DIR}") include_directories ("${PROJECT_BINARY_DIR}")
set(CMAKE_INCLUDE_CURRENT_DIR ON) set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(INCDIR include CACHE PATH "install directory for header files") set(NG_INSTALL_SUFFIX netgen CACHE STRING "Suffix appended to install directories (project name)")
if(APPLE) if(APPLE)
set(ng_install_dir_bin ../MacOS) set(NG_INSTALL_DIR_BIN_DEFAULT Contents/MacOS)
set(ng_install_dir_lib ../MacOS) set(NG_INSTALL_DIR_LIB_DEFAULT Contents/MacOS)
set(NG_INSTALL_DIR_CMAKE_DEFAULT Contents/Resources/CMake)
set(NG_INSTALL_DIR_PYTHON_DEFAULT Contents/Resources/${PYTHON_PACKAGES_INSTALL_DIR})
set(NG_INSTALL_DIR_RES_DEFAULT Contents/Resources/share)
set(NG_INSTALL_DIR_INCLUDE_DEFAULT Contents/Resources/include)
set(NG_RPATH_TOKEN "@loader_path")
else(APPLE) else(APPLE)
set(ng_install_dir_bin bin) set(NG_INSTALL_DIR_BIN_DEFAULT bin)
set(ng_install_dir_lib lib) set(NG_INSTALL_DIR_LIB_DEFAULT lib)
if(WIN32)
set(NG_INSTALL_DIR_CMAKE_DEFAULT cmake)
else(WIN32)
set(NG_INSTALL_DIR_CMAKE_DEFAULT lib/cmake/${NG_INSTALL_SUFFIX})
endif(WIN32)
set(NG_INSTALL_DIR_PYTHON_DEFAULT ${PYTHON_PACKAGES_INSTALL_DIR})
set(NG_INSTALL_DIR_RES_DEFAULT share)
set(NG_INSTALL_DIR_INCLUDE_DEFAULT include)
set(NG_RPATH_TOKEN "\$ORIGIN")
endif(APPLE) endif(APPLE)
set(ng_install_dir EXPORT netgen-targets RUNTIME DESTINATION ${ng_install_dir_bin} COMPONENT netgen LIBRARY DESTINATION ${ng_install_dir_lib} COMPONENT netgen_devel ARCHIVE DESTINATION ${ng_install_dir_lib} COMPONENT netgen_devel)
install(EXPORT netgen-targets DESTINATION share/cmake) set(NG_INSTALL_DIR_PYTHON ${NG_INSTALL_DIR_PYTHON_DEFAULT} CACHE STRING "Install directory for Python files")
set(NG_INSTALL_DIR_BIN ${NG_INSTALL_DIR_BIN_DEFAULT} CACHE STRING "Install directory for executables")
set(NG_INSTALL_DIR_LIB ${NG_INSTALL_DIR_LIB_DEFAULT} CACHE STRING "Install directory for libraries")
set(NG_INSTALL_DIR_INCLUDE ${NG_INSTALL_DIR_INCLUDE_DEFAULT} CACHE STRING "Install directory for header files")
set(NG_INSTALL_DIR_CMAKE ${NG_INSTALL_DIR_CMAKE_DEFAULT} CACHE STRING "Install directory for CMake files")
set(NG_INSTALL_DIR_RES ${NG_INSTALL_DIR_RES_DEFAULT} CACHE STRING "Install directory for resources")
get_filename_component(NETGEN_CMAKE_DIR_ABSOLUTE ${NG_INSTALL_DIR_CMAKE} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
get_filename_component(NETGEN_BINARY_DIR_ABSOLUTE ${NG_INSTALL_DIR_BIN} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
get_filename_component(NETGEN_LIBRARY_DIR_ABSOLUTE ${NG_INSTALL_DIR_LIB} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
get_filename_component(NETGEN_INCLUDE_DIR_ABSOLUTE ${NG_INSTALL_DIR_INCLUDE} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
get_filename_component(NETGEN_PYTHON_DIR_ABSOLUTE ${NG_INSTALL_DIR_PYTHON} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
get_filename_component(NETGEN_RESOURCE_DIR_ABSOLUTE ${NG_INSTALL_DIR_RES} ABSOLUTE BASE_DIR ${CMAKE_INSTALL_PREFIX})
file(RELATIVE_PATH NETGEN_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${CMAKE_INSTALL_PREFIX})
file(RELATIVE_PATH NETGEN_BINARY_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${NETGEN_BINARY_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_LIBRARY_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${NETGEN_LIBRARY_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_INCLUDE_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${NETGEN_INCLUDE_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_PYTHON_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${NETGEN_PYTHON_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_RESOURCE_DIR ${NETGEN_CMAKE_DIR_ABSOLUTE} ${NETGEN_RESOURCE_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_RPATH ${NETGEN_BINARY_DIR_ABSOLUTE} ${NETGEN_LIBRARY_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_PYTHON_RPATH_BIN ${NETGEN_PYTHON_DIR_ABSOLUTE} ${NETGEN_BINARY_DIR_ABSOLUTE})
file(RELATIVE_PATH NETGEN_PYTHON_RPATH ${NETGEN_PYTHON_DIR_ABSOLUTE} ${NETGEN_LIBRARY_DIR_ABSOLUTE})
if(WIN32)
set(NETGEN_PYTHON_RPATH ${NETGEN_PYTHON_RPATH_BIN})
endif(WIN32)
set(NG_INSTALL_DIR EXPORT netgen-targets RUNTIME DESTINATION ${NG_INSTALL_DIR_BIN} COMPONENT netgen LIBRARY DESTINATION ${NG_INSTALL_DIR_LIB} COMPONENT netgen_devel ARCHIVE DESTINATION ${NG_INSTALL_DIR_LIB} COMPONENT netgen_devel)
install(EXPORT netgen-targets DESTINATION ${NG_INSTALL_DIR_CMAKE} )
set(CMAKE_MACOSX_RPATH TRUE)
set(CMAKE_INSTALL_RPATH "${NG_RPATH_TOKEN};${NG_RPATH_TOKEN}/${NETGEN_RPATH}")
include (CheckIncludeFiles) include (CheckIncludeFiles)
check_include_files (dlfcn.h HAVE_DLFCN_H) check_include_files (dlfcn.h HAVE_DLFCN_H)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h) if(HAVE_DLFCN_H)
add_definitions(-DHAVE_CONFIG_H) add_definitions(-DHAVE_DLFCN_H)
endif()
add_definitions(-DPACKAGE_VERSION="${NETGEN_VERSION}")
include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}) include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR})
####################################################################### #######################################################################
@ -133,8 +197,6 @@ if(WIN32)
get_WIN32_WINNT(ver) get_WIN32_WINNT(ver)
add_definitions(-D_WIN32_WINNT=${ver} -DWNT -DWNT_WINDOW -DNOMINMAX) add_definitions(-D_WIN32_WINNT=${ver} -DWNT -DWNT_WINDOW -DNOMINMAX)
set(CMAKE_MFC_FLAG 0) set(CMAKE_MFC_FLAG 0)
# add_definitions(-DNGINTERFACE_EXPORTS)
# add_definitions(-DNGLIB_EXPORTS)
add_definitions(-DMSVC_EXPRESS -D_CRT_SECURE_NO_WARNINGS -DHAVE_STRUCT_TIMESPEC) add_definitions(-DMSVC_EXPRESS -D_CRT_SECURE_NO_WARNINGS -DHAVE_STRUCT_TIMESPEC)
# build convenience (aka object) libraries in windows) # build convenience (aka object) libraries in windows)
set(NG_LIB_TYPE OBJECT) set(NG_LIB_TYPE OBJECT)
@ -145,9 +207,7 @@ else(WIN32)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
endif(WIN32) endif(WIN32)
if(APPLE) if(APPLE)
# set(MACOSX_BUNDLE ON)
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -undefined dynamic_lookup") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -undefined dynamic_lookup")
# set(CMAKE_SHARED_LIBRARY_SUFFIX ".so")
endif(APPLE) endif(APPLE)
####################################################################### #######################################################################
@ -190,8 +250,8 @@ if (USE_PYTHON)
include_directories(${PYBIND_INCLUDE_DIR}) include_directories(${PYBIND_INCLUDE_DIR})
include_directories(${PYTHON_INCLUDE_DIRS}) include_directories(${PYTHON_INCLUDE_DIRS})
install(DIRECTORY ${PYBIND_INCLUDE_DIR}/pybind11 DESTINATION ${INCDIR} COMPONENT netgen_devel) install(DIRECTORY ${PYBIND_INCLUDE_DIR}/pybind11 DESTINATION ${NG_INSTALL_DIR_INCLUDE} COMPONENT netgen_devel)
install(FILES ${PYBIND_INCLUDE_DIR}/../LICENSE DESTINATION ${INCDIR}/pybind11 COMPONENT netgen_devel) install(FILES ${PYBIND_INCLUDE_DIR}/../LICENSE DESTINATION ${NG_INSTALL_DIR_INCLUDE}/pybind11 COMPONENT netgen_devel)
endif (USE_PYTHON) endif (USE_PYTHON)
####################################################################### #######################################################################
@ -227,10 +287,10 @@ endif (USE_MPEG)
####################################################################### #######################################################################
if(INSTALL_PROFILES) if(INSTALL_PROFILES)
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "#!/bin/sh\n") file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "#!/bin/sh\n")
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export PATH=${INSTALL_DIR}/bin:$PATH\n") file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export PATH=${CMAKE_INSTALL_PREFIX}/bin:$PATH\n")
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export NETGENDIR=${INSTALL_DIR}/bin\n") file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export NETGENDIR=${CMAKE_INSTALL_PREFIX}/bin\n")
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export PYTHONPATH=${INSTALL_DIR}/${PYTHON_PACKAGES_INSTALL_DIR}:.\n") file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export PYTHONPATH=${CMAKE_INSTALL_PREFIX}/${PYTHON_PACKAGES_INSTALL_DIR}:.\n")
file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export LD_LIBRARY_PATH=${INSTALL_DIR}/lib:.\n") file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh "export LD_LIBRARY_PATH=${CMAKE_INSTALL_PREFIX}/lib:.\n")
install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh DESTINATION /etc/profile.d COMPONENT netgen) install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/netgen.sh DESTINATION /etc/profile.d COMPONENT netgen)
string(ASCII 27 Esc) string(ASCII 27 Esc)
@ -242,19 +302,19 @@ endif(INSTALL_PROFILES)
####################################################################### #######################################################################
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/fixup.cmake "\ file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/fixup.cmake "\
include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/netgen_fixup.cmake) include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/netgen_fixup.cmake)
set(APP ${INSTALL_DIR}) set(APP ${CMAKE_INSTALL_PREFIX})
message(\${APP}) message(\${APP})
set(BU_CHMOD_BUNDLE_ITEMS ON) set(BU_CHMOD_BUNDLE_ITEMS ON)
file(GLOB libs ${CMAKE_INSTALL_PREFIX}/${ng_install_dir_lib}/*.dylib ${CMAKE_INSTALL_PREFIX}/${ng_install_dir_lib}/*.so) file(GLOB libs ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_LIB}/*.dylib ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_LIB}/*.so)
message(\"\${libs}\") message(\"\${libs}\")
netgen_fixup_bundle( \${APP}/Contents/MacOS/netgen \"\${libs}\" ${CMAKE_INSTALL_PREFIX}/${ng_install_dir_lib} ) netgen_fixup_bundle( \${APP}/Contents/MacOS/netgen \"\${libs}\" ${CMAKE_INSTALL_PREFIX}/${NG_INSTALL_DIR_LIB} )
execute_process(COMMAND ln -s /Applications ${INSTALL_DIR}/../Applications) execute_process(COMMAND ln -s /Applications ${CMAKE_INSTALL_PREFIX}/../Applications)
set (bundle_filename \$ENV{NETGEN_BUNDLE_NAME}) set (bundle_filename \$ENV{NETGEN_BUNDLE_NAME})
if(NOT bundle_filename) if(NOT bundle_filename)
set(bundle_filename netgen) set(bundle_filename netgen)
endif(NOT bundle_filename) endif(NOT bundle_filename)
execute_process(COMMAND hdiutil create -volname Netgen -srcfolder ${INSTALL_DIR} -ov -format UDZO \${bundle_filename}-${PACKAGE_VERSION}.dmg) execute_process(COMMAND hdiutil create -volname Netgen -srcfolder ${CMAKE_INSTALL_PREFIX} -ov -format UDZO \${bundle_filename}-${PACKAGE_VERSION}.dmg)
") ")
add_custom_target(bundle COMMAND ${CMAKE_COMMAND} "-P" "${CMAKE_CURRENT_BINARY_DIR}/fixup.cmake") add_custom_target(bundle COMMAND ${CMAKE_COMMAND} "-P" "${CMAKE_CURRENT_BINARY_DIR}/fixup.cmake")
####################################################################### #######################################################################
@ -328,7 +388,7 @@ export PYTHONPATH=$Netgen_BUNDLE/Contents/Resources/${PYTHON_PACKAGES_INSTALL_DI
cd $Netgen_MACOS cd $Netgen_MACOS
$Netgen_MACOS/netgen $Netgen_MACOS/netgen
") ")
install(PROGRAMS ${mac_startup} DESTINATION ${ng_install_dir_bin}) install(PROGRAMS ${mac_startup} DESTINATION ${NG_INSTALL_DIR_BIN})
set(mac_ngsuite ${CMAKE_CURRENT_BINARY_DIR}/ngsuite.sh) set(mac_ngsuite ${CMAKE_CURRENT_BINARY_DIR}/ngsuite.sh)
file(WRITE ${mac_ngsuite} "\ file(WRITE ${mac_ngsuite} "\
@ -337,7 +397,7 @@ Netgen_BUNDLE=\"`echo \"$0\" | sed -e 's/\\/Contents\\/MacOS\\/Netgen1//'`\"
Netgen_MACOS=\"$Netgen_BUNDLE/Contents/MacOS\" Netgen_MACOS=\"$Netgen_BUNDLE/Contents/MacOS\"
open -a /Applications/Utilities/Terminal.app $Netgen_MACOS/startup.sh open -a /Applications/Utilities/Terminal.app $Netgen_MACOS/startup.sh
") ")
install(PROGRAMS ${mac_ngsuite} DESTINATION ../MacOS RENAME Netgen1) install(PROGRAMS ${mac_ngsuite} DESTINATION ${NG_INSTALL_DIR_BIN} RENAME Netgen1)
set(mac_plist ${CMAKE_CURRENT_BINARY_DIR}/Info.plist) set(mac_plist ${CMAKE_CURRENT_BINARY_DIR}/Info.plist)
file(WRITE ${mac_plist} "<?xml version=\"1.0\" encoding=\"UTF-8\"?> file(WRITE ${mac_plist} "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
@ -355,8 +415,8 @@ open -a /Applications/Utilities/Terminal.app $Netgen_MACOS/startup.sh
</dict> </dict>
</plist> </plist>
") ")
install(FILES ${mac_plist} DESTINATION ../) install(FILES ${mac_plist} DESTINATION ${NG_INSTALL_DIR_BIN}/../)
install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/netgen.icns DESTINATION . RENAME Netgen.icns) install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/netgen.icns DESTINATION ${NG_INSTALL_DIR_RES}/../ RENAME Netgen.icns)
endif(APPLE) endif(APPLE)
@ -373,10 +433,14 @@ configure_file(
add_custom_target(uninstall add_custom_target(uninstall
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/NetgenConfig.cmake.in #######################################################################
${CMAKE_CURRENT_BINARY_DIR}/NetgenConfig.cmake @ONLY) # Generate package config file
get_directory_property(NETGEN_COMPILE_DEFINITIONS COMPILE_DEFINITIONS)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/NetgenConfig.cmake DESTINATION share/cmake) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/NetgenConfig.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/NetgenConfig.cmake @ONLY ESCAPE_QUOTES)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/NetgenConfig.cmake DESTINATION ${NG_INSTALL_DIR_CMAKE})
####################################################################### #######################################################################
# Configure message # Configure message

30
cmake/NetgenConfig.cmake.in
View File

@ -1,9 +1,20 @@
set(PACKAGE_VERSION "@NETGEN_VERSION@") set(PACKAGE_VERSION "@NETGEN_VERSION@")
set(NETGEN_DIR "@CMAKE_INSTALL_PREFIX@")
set(NETGEN_INCLUDE_DIR "@CMAKE_INSTALL_PREFIX@/@INCDIR@") get_filename_component(NETGEN_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
get_filename_component(NETGEN_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_DIR@" ABSOLUTE)
set(NETGEN_COMPILE_DEFINITIONS "@NETGEN_COMPILE_DEFINITIONS@")
get_filename_component(NETGEN_INCLUDE_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_INCLUDE_DIR@" ABSOLUTE)
get_filename_component(NETGEN_BINARY_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_BINARY_DIR@" ABSOLUTE)
get_filename_component(NETGEN_LIBRARY_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_LIBRARY_DIR@" ABSOLUTE)
get_filename_component(NETGEN_PYTHON_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_PYTHON_DIR@" ABSOLUTE)
get_filename_component(NETGEN_RESOURCE_DIR "${NETGEN_CMAKE_DIR}/@NETGEN_RESOURCE_DIR@" ABSOLUTE)
set(NETGEN_SOURCE_DIR "@PROJECT_SOURCE_DIR@") set(NETGEN_SOURCE_DIR "@PROJECT_SOURCE_DIR@")
set(NETGEN_INCLUDE_DIRS "${NETGEN_INCLUDE_DIR}/include;${NETGEN_INCLUDE_DIR}")
set(NETGEN_CMAKE_THREAD_LIBS_INIT "@CMAKE_THREAD_LIBS_INIT@") set(NETGEN_CMAKE_THREAD_LIBS_INIT "@CMAKE_THREAD_LIBS_INIT@")
set(NETGEN_FFMPEG_LIBRARIES "@FFMPEG_LIBRARIES@") set(NETGEN_FFMPEG_LIBRARIES "@FFMPEG_LIBRARIES@")
set(NETGEN_JPEG_INCLUDE_DIR "@JPEG_INCLUDE_DIR@") set(NETGEN_JPEG_INCLUDE_DIR "@JPEG_INCLUDE_DIR@")
@ -14,17 +25,14 @@ set(NETGEN_METIS_LIBRARY "@METIS_LIBRARY@")
set(NETGEN_MKL_LIBRARIES "@MKL_LIBRARIES@") set(NETGEN_MKL_LIBRARIES "@MKL_LIBRARIES@")
set(NETGEN_MPI_CXX_INCLUDE_PATH "@MPI_CXX_INCLUDE_PATH@") set(NETGEN_MPI_CXX_INCLUDE_PATH "@MPI_CXX_INCLUDE_PATH@")
set(NETGEN_MPI_CXX_LIBRARIES "@MPI_CXX_LIBRARIES@") set(NETGEN_MPI_CXX_LIBRARIES "@MPI_CXX_LIBRARIES@")
set(NETGEN_INCLUDE_DIRS "@CMAKE_INSTALL_PREFIX@/@INCDIR@;@CMAKE_INSTALL_PREFIX@/@INCDIR@/include")
set(NETGEN_OCC_INCLUDE_DIR "@OCC_INCLUDE_DIR@") set(NETGEN_OCC_INCLUDE_DIR "@OCC_INCLUDE_DIR@")
set(NETGEN_OCC_LIBRARIES_BIN "@OCC_LIBRARIES_BIN@") set(NETGEN_OCC_LIBRARIES_BIN "@OCC_LIBRARIES_BIN@")
set(NETGEN_OCC_LIBRARIES "@OCC_LIBRARIES@") set(NETGEN_OCC_LIBRARIES "@OCC_LIBRARIES@")
set(NETGEN_OCC_LIBRARY_DIR "@OCC_LIBRARY_DIR@") set(NETGEN_OCC_LIBRARY_DIR "@OCC_LIBRARY_DIR@")
set(NETGEN_OPENGL_LIBRARIES "@OPENGL_LIBRARIES@") set(NETGEN_OPENGL_LIBRARIES "@OPENGL_LIBRARIES@")
set(NETGEN_PYBIND_INCLUDE_DIR "@CMAKE_INSTALL_PREFIX@/include")
set(NETGEN_PYTHON_EXECUTABLE "@PYTHON_EXECUTABLE@") set(NETGEN_PYTHON_EXECUTABLE "@PYTHON_EXECUTABLE@")
set(NETGEN_PYTHON_INCLUDE_DIRS "@PYTHON_INCLUDE_DIRS@") set(NETGEN_PYTHON_INCLUDE_DIRS "@PYTHON_INCLUDE_DIRS@")
set(NETGEN_PYTHON_LIBRARIES "@PYTHON_LIBRARIES@") set(NETGEN_PYTHON_LIBRARIES "@PYTHON_LIBRARIES@")
set(NETGEN_PYTHON_PACKAGES_INSTALL_DIR "@PYTHON_PACKAGES_INSTALL_DIR@")
set(NETGEN_TCL_INCLUDE_PATH "@TCL_INCLUDE_PATH@") set(NETGEN_TCL_INCLUDE_PATH "@TCL_INCLUDE_PATH@")
set(NETGEN_TCL_LIBRARY "@TCL_LIBRARY@") set(NETGEN_TCL_LIBRARY "@TCL_LIBRARY@")
set(NETGEN_TK_DND_LIBRARY "@TK_DND_LIBRARY@") set(NETGEN_TK_DND_LIBRARY "@TK_DND_LIBRARY@")
@ -45,5 +53,15 @@ set(NETGEN_INTEL_MIC @INTEL_MIC@)
set(NETGEN_INSTALL_PROFILES @INSTALL_PROFILES@) set(NETGEN_INSTALL_PROFILES @INSTALL_PROFILES@)
set(NETGEN_USE_CCACHE @USE_CCACHE@) set(NETGEN_USE_CCACHE @USE_CCACHE@)
set(NETGEN_PYTHON_RPATH "@NETGEN_PYTHON_RPATH@")
set(NETGEN_RPATH_TOKEN "@NG_RPATH_TOKEN@")
set(NETGEN_INSTALL_DIR_PYTHON @NG_INSTALL_DIR_PYTHON@)
set(NETGEN_INSTALL_DIR_BIN @NG_INSTALL_DIR_BIN@)
set(NETGEN_INSTALL_DIR_LIB @NG_INSTALL_DIR_LIB@)
set(NETGEN_INSTALL_DIR_INCLUDE @NG_INSTALL_DIR_INCLUDE@)
set(NETGEN_INSTALL_DIR_CMAKE @NG_INSTALL_DIR_CMAKE@)
set(NETGEN_INSTALL_DIR_RES @NG_INSTALL_DIR_RES@)
include(${CMAKE_CURRENT_LIST_DIR}/netgen-targets.cmake) include(${CMAKE_CURRENT_LIST_DIR}/netgen-targets.cmake)
message(STATUS "Found Netgen: ${NETGEN_DIR}") message(STATUS "Found Netgen: ${CMAKE_CURRENT_LIST_DIR}")

26
cmake/SuperBuild.cmake
View File

@ -40,19 +40,10 @@ if(WIN32)
endif(${CMAKE_SIZEOF_VOID_P} MATCHES 4) endif(${CMAKE_SIZEOF_VOID_P} MATCHES 4)
endif(WIN32) endif(WIN32)
#######################################################################
# find netgen
if(APPLE)
set(INSTALL_DIR /Applications/Netgen.app CACHE PATH "Install path")
set(CMAKE_INSTALL_PREFIX "${INSTALL_DIR}/Contents/Resources" CACHE INTERNAL "Prefix prepended to install directories" FORCE)
else(APPLE)
set(INSTALL_DIR /opt/netgen CACHE PATH "Install path")
set(CMAKE_INSTALL_PREFIX "${INSTALL_DIR}" CACHE INTERNAL "Prefix prepended to install directories" FORCE)
endif(APPLE)
if(UNIX) if(UNIX)
message("Checking for write permissions in install directory...") message("Checking for write permissions in install directory...")
execute_process(COMMAND mkdir -p ${INSTALL_DIR}) execute_process(COMMAND mkdir -p ${CMAKE_INSTALL_PREFIX})
execute_process(COMMAND test -w ${INSTALL_DIR} RESULT_VARIABLE res) execute_process(COMMAND test -w ${CMAKE_INSTALL_PREFIX} RESULT_VARIABLE res)
if(res) if(res)
message(WARNING "No write access at install directory, please set correct permissions") message(WARNING "No write access at install directory, please set correct permissions")
endif() endif()
@ -94,7 +85,7 @@ if(USE_OCC AND WIN32 AND NOT OCC_INCLUDE_DIR)
BUILD_IN_SOURCE 1 BUILD_IN_SOURCE 1
CONFIGURE_COMMAND "" CONFIGURE_COMMAND ""
BUILD_COMMAND "" BUILD_COMMAND ""
INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_directory . ${INSTALL_DIR} INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_directory . ${CMAKE_INSTALL_PREFIX}
LOG_DOWNLOAD 1 LOG_DOWNLOAD 1
) )
list(APPEND NETGEN_DEPENDENCIES win_download_occ) list(APPEND NETGEN_DEPENDENCIES win_download_occ)
@ -140,10 +131,11 @@ set_vars( NETGEN_CMAKE_ARGS
USE_NATIVE_ARCH USE_NATIVE_ARCH
USE_OCC USE_OCC
USE_MPEG USE_MPEG
INSTALL_DIR USE_INTERNAL_TCL
INSTALL_PROFILES INSTALL_PROFILES
INTEL_MIC INTEL_MIC
CMAKE_PREFIX_PATH CMAKE_PREFIX_PATH
CMAKE_INSTALL_PREFIX
) )
# propagate all variables set on the command line using cmake -DFOO=BAR # propagate all variables set on the command line using cmake -DFOO=BAR
@ -166,7 +158,7 @@ endif()
ExternalProject_Add (netgen ExternalProject_Add (netgen
DEPENDS ${NETGEN_DEPENDENCIES} DEPENDS ${NETGEN_DEPENDENCIES}
SOURCE_DIR ${PROJECT_SOURCE_DIR} SOURCE_DIR ${PROJECT_SOURCE_DIR}
CMAKE_ARGS -DUSE_SUPERBUILD=OFF ${NETGEN_CMAKE_ARGS} -DCMAKE_PREFIX_PATH=${INSTALL_DIR} CMAKE_ARGS -DUSE_SUPERBUILD=OFF ${NETGEN_CMAKE_ARGS}
INSTALL_COMMAND "" INSTALL_COMMAND ""
BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/netgen BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/netgen
BUILD_COMMAND ${NETGEN_BUILD_COMMAND} BUILD_COMMAND ${NETGEN_BUILD_COMMAND}
@ -176,21 +168,21 @@ ExternalProject_Add (netgen
# Check if the git submodules (i.e. pybind11) are up to date # Check if the git submodules (i.e. pybind11) are up to date
# in case, something is wrong, emit a warning but continue # in case, something is wrong, emit a warning but continue
ExternalProject_Add_Step(netgen check_submodules ExternalProject_Add_Step(netgen check_submodules
COMMAND cmake -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/check_submodules.cmake COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/check_submodules.cmake
DEPENDERS install # Steps on which this step depends DEPENDERS install # Steps on which this step depends
) )
# Due to 'ALWAYS 1', this step is always run which also forces a build of # Due to 'ALWAYS 1', this step is always run which also forces a build of
# the Netgen subproject # the Netgen subproject
ExternalProject_Add_Step(netgen check_submodules1 ExternalProject_Add_Step(netgen check_submodules1
COMMAND cmake -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/check_submodules.cmake COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/check_submodules.cmake
DEPENDEES configure # Steps on which this step depends DEPENDEES configure # Steps on which this step depends
DEPENDERS build # Steps that depend on this step DEPENDERS build # Steps that depend on this step
ALWAYS 1 # No stamp file, step always runs ALWAYS 1 # No stamp file, step always runs
) )
install(CODE "execute_process(COMMAND cmake --build . --target install --config ${CMAKE_BUILD_TYPE} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/netgen)") install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} --build . --target install --config ${CMAKE_BUILD_TYPE} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/netgen)")
add_custom_target(test_netgen add_custom_target(test_netgen
${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/netgen ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/netgen

111
cmake/external_projects/tcltk.cmake
View File

@ -1,59 +1,58 @@
if(APPLE) if(APPLE)
set(HOME $ENV{HOME}) # use system tcl/tk
set(tcl_prefix ${CMAKE_INSTALL_PREFIX}/../../) find_package(TCL 8.5 REQUIRED)
ExternalProject_Add(project_tcl # set(HOME $ENV{HOME})
URL "http://sourceforge.net/projects/tcl/files/Tcl/8.6.4/tcl8.6.4-src.tar.gz" # set(tcl_prefix ${CMAKE_INSTALL_PREFIX}/../../)
URL_MD5 d7cbb91f1ded1919370a30edd1534304 # ExternalProject_Add(project_tcl
DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies # URL "http://sourceforge.net/projects/tcl/files/Tcl/8.6.4/tcl8.6.4-src.tar.gz"
UPDATE_COMMAND "" # Disable update # URL_MD5 d7cbb91f1ded1919370a30edd1534304
CONFIGURE_COMMAND ../project_tcl/macosx/configure --enable-threads --enable-framework --prefix=${tcl_prefix} --libdir=${tcl_prefix}/Contents/Frameworks --bindir=${tcl_prefix}/Contents/Frameworks/Tcl.framework/bin # DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
BUILD_COMMAND make -j4 binaries libraries # UPDATE_COMMAND "" # Disable update
INSTALL_COMMAND make install-binaries install-headers install-libraries install-private-headers # CONFIGURE_COMMAND ../project_tcl/macosx/configure --enable-threads --enable-framework --prefix=${tcl_prefix} --libdir=${tcl_prefix}/Contents/Frameworks --bindir=${tcl_prefix}/Contents/Frameworks/Tcl.framework/bin
LOG_DOWNLOAD 1 # BUILD_COMMAND make -j4 binaries libraries
LOG_BUILD 1 # INSTALL_COMMAND make install-binaries install-headers install-libraries install-private-headers
LOG_CONFIGURE 1 # LOG_DOWNLOAD 1
LOG_INSTALL 1 # LOG_BUILD 1
) # LOG_CONFIGURE 1
# LOG_INSTALL 1
ExternalProject_Add(project_tk # )
DEPENDS project_tcl #
URL "http://sourceforge.net/projects/tcl/files/Tcl/8.6.4/tk8.6.4-src.tar.gz" # ExternalProject_Add(project_tk
URL_MD5 261754d7dc2a582f00e35547777e1fea # DEPENDS project_tcl
DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies # URL "http://sourceforge.net/projects/tcl/files/Tcl/8.6.4/tk8.6.4-src.tar.gz"
UPDATE_COMMAND "" # Disable update # URL_MD5 261754d7dc2a582f00e35547777e1fea
CONFIGURE_COMMAND ../project_tk/macosx/configure --enable-aqua=yes --enable-threads --enable-framework --prefix=${tcl_prefix} --libdir=${tcl_prefix}/Contents/Frameworks --bindir=${tcl_prefix}/Contents/Frameworks/Tcl.framework/bin --with-tcl=${tcl_prefix}/Contents/Frameworks/Tcl.framework # DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
BUILD_COMMAND make -j4 binaries libraries # UPDATE_COMMAND "" # Disable update
INSTALL_COMMAND make install-binaries install-headers install-libraries install-private-headers # CONFIGURE_COMMAND ../project_tk/macosx/configure --enable-aqua=yes --enable-threads --enable-framework --prefix=${tcl_prefix} --libdir=${tcl_prefix}/Contents/Frameworks --bindir=${tcl_prefix}/Contents/Frameworks/Tcl.framework/bin --with-tcl=${tcl_prefix}/Contents/Frameworks/Tcl.framework
LOG_DOWNLOAD 1 # BUILD_COMMAND make -j4 binaries libraries
LOG_BUILD 1 # INSTALL_COMMAND make install-binaries install-headers install-libraries install-private-headers
LOG_CONFIGURE 1 # LOG_DOWNLOAD 1
LOG_INSTALL 1 # LOG_BUILD 1
) # LOG_CONFIGURE 1
# LOG_INSTALL 1
#ExternalProject_Add(tkdnd # )
#DEPENDS tcl tk #
#URL "http://sourceforge.net/projects/tkdnd/files/TkDND/TkDND%202.8/tkdnd2.8-src.tar.gz" # ExternalProject_Add(project_tkdnd
#URL_MD5 a6d47a996ea957416469b12965d4db91 # URL "https://sourceforge.net/projects/tkdnd/files/OS%20X%20Binaries/TkDND%202.8/tkdnd2.8-OSX-MountainLion.tar.gz"
#DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies # URL_MD5 2dbb471b1d66c5f391f3c3c5b71548fb
#PATCH_COMMAND patch -p1 < ${CMAKE_CURRENT_LIST_DIR}/tkdnd_macosx.patch # DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external_dependencies
#UPDATE_COMMAND "" # Disable update # BUILD_IN_SOURCE 1
#BUILD_IN_SOURCE 1 # CONFIGURE_COMMAND ""
#CONFIGURE_COMMAND ./configure --with-tcl=${CMAKE_INSTALL_PREFIX}/../Frameworks/Tcl.framework --with-tk=${CMAKE_INSTALL_PREFIX}/../Frameworks/Tk.framework --prefix=${CMAKE_INSTALL_PREFIX}/../MacOS --libdir=${CMAKE_INSTALL_PREFIX}/../MacOS # BUILD_COMMAND ""
#BUILD_COMMAND make # INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_directory . ${CMAKE_INSTALL_PREFIX}/../MacOS
#INSTALL_COMMAND make install # LOG_DOWNLOAD 1
#LOG_DOWNLOAD 1 # LOG_CONFIGURE 1
#LOG_CONFIGURE 1 # LOG_BUILD 1
#LOG_BUILD 1 # LOG_INSTALL 1
#LOG_INSTALL 1 # )
#) #
# list(APPEND NETGEN_DEPENDENCIES project_tcl project_tk project_tkdnd)
list(APPEND NETGEN_DEPENDENCIES project_tcl project_tk) # list(APPEND CMAKE_PREFIX_PATH ${CMAKE_INSTALL_PREFIX}../Frameworks)
list(APPEND CMAKE_PREFIX_PATH ${CMAKE_INSTALL_PREFIX}../Frameworks) # set(TCL_INCLUDE_PATH ${CMAKE_INSTALL_PREFIX}/../Frameworks/Tcl.framework/Headers)
set(TCL_INCLUDE_PATH ${CMAKE_INSTALL_PREFIX}/../Frameworks/Tcl.framework/Headers) # set(TCL_LIBRARY ${CMAKE_INSTALL_PREFIX}/../Frameworks/Tcl.framework)
set(TCL_LIBRARY ${CMAKE_INSTALL_PREFIX}/../Frameworks/Tcl.framework) # set(TK_LIBRARY ${CMAKE_INSTALL_PREFIX}/../Frameworks/Tk.framework)
set(TK_LIBRARY ${CMAKE_INSTALL_PREFIX}/../Frameworks/Tk.framework) # set(TK_INCLUDE_PATH ${CMAKE_INSTALL_PREFIX}/../Frameworks/Tk.framework/Headers)
set(TK_INCLUDE_PATH ${CMAKE_INSTALL_PREFIX}/../Frameworks/Tk.framework/Headers) #
elseif(WIN32) elseif(WIN32)
ExternalProject_Add(project_win_extlibs ExternalProject_Add(project_win_extlibs
@ -62,7 +61,7 @@ elseif(WIN32)
BUILD_IN_SOURCE 1 BUILD_IN_SOURCE 1
CONFIGURE_COMMAND "" CONFIGURE_COMMAND ""
BUILD_COMMAND "" BUILD_COMMAND ""
INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_directory . ${INSTALL_DIR} INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_directory . ${CMAKE_INSTALL_PREFIX}
LOG_DOWNLOAD 1 LOG_DOWNLOAD 1
) )

2
config.h.cmake
View File

@ -1,2 +0,0 @@
#cmakedefine HAVE_DLFCN_H 1
#define PACKAGE_VERSION "${NETGEN_VERSION}"

2
doc/CMakeLists.txt
View File

@ -1 +1 @@
INSTALL(FILES ng4.pdf DESTINATION doc COMPONENT netgen_doc) INSTALL(FILES ng4.pdf DESTINATION ${NG_INSTALL_DIR_RES}/${NG_INSTALL_SUFFIX}/doc COMPONENT netgen_doc)

2
external_dependencies/pybind11

@ -1 +1 @@
Subproject commit 07de0d8627101be53986e841cd4e21ee38c2498a Subproject commit fe0cf8b73b8e068c205e062c779eb694b194d6b4

6
libsrc/csg/CMakeLists.txt
View File

@ -14,7 +14,7 @@ endif(APPLE)
if(NOT WIN32) if(NOT WIN32)
target_link_libraries(csg mesh ${PYTHON_LIBRARIES}) target_link_libraries(csg mesh ${PYTHON_LIBRARIES})
target_link_libraries(csg ${PYTHON_LIBRARIES}) target_link_libraries(csg ${PYTHON_LIBRARIES})
install( TARGETS csg ${ng_install_dir}) install( TARGETS csg ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)
@ -25,7 +25,7 @@ if(USE_GUI)
if(APPLE) if(APPLE)
set_target_properties( csgvis PROPERTIES SUFFIX ".so") set_target_properties( csgvis PROPERTIES SUFFIX ".so")
endif(APPLE) endif(APPLE)
install( TARGETS csgvis ${ng_install_dir}) install( TARGETS csgvis ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)
endif(USE_GUI) endif(USE_GUI)
@ -36,5 +36,5 @@ install(FILES
polyhedra.hpp revolution.hpp singularref.hpp solid.hpp polyhedra.hpp revolution.hpp singularref.hpp solid.hpp
specpoin.hpp spline3d.hpp splinesurface.hpp surface.hpp specpoin.hpp spline3d.hpp splinesurface.hpp surface.hpp
triapprox.hpp vscsg.hpp triapprox.hpp vscsg.hpp
DESTINATION ${INCDIR}/csg COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/csg COMPONENT netgen_devel
) )

3
libsrc/csg/python_csg.cpp
View File

@ -441,6 +441,9 @@ DLL_HEADER void ExportCSG(py::module &m)
} }
spsol->AddSurfaces(self); spsol->AddSurfaces(self);
int tlonr = self.SetTopLevelObject(spsol->GetSolid(), surf.get()); int tlonr = self.SetTopLevelObject(spsol->GetSolid(), surf.get());
self.GetTopLevelObject(tlonr) -> SetBCProp(surf->GetBase()->GetBCProperty());
self.GetTopLevelObject(tlonr) -> SetBCName(surf->GetBase()->GetBCName());
self.GetTopLevelObject(tlonr) -> SetMaxH(surf->GetBase()->GetMaxH());
for(auto p : surf->GetPoints()) for(auto p : surf->GetPoints())
self.AddUserPoint(p); self.AddUserPoint(p);
self.AddSplineSurface(surf); self.AddSplineSurface(surf);

4
libsrc/csg/zrefine.cpp
View File

@ -259,11 +259,11 @@ namespace netgen
first_id.Set(); first_id.Set();
if (mesh.GetIdentifications().HasIdentifiedPoints())
{
INDEX_2_HASHTABLE<int> & identpts = INDEX_2_HASHTABLE<int> & identpts =
mesh.GetIdentifications().GetIdentifiedPoints (); mesh.GetIdentifications().GetIdentifiedPoints ();
if (&identpts)
{
for (i = 1; i <= identpts.GetNBags(); i++) for (i = 1; i <= identpts.GetNBags(); i++)
for (j = 1; j <= identpts.GetBagSize(i); j++) for (j = 1; j <= identpts.GetBagSize(i); j++)
{ {

6
libsrc/general/CMakeLists.txt
View File

@ -8,14 +8,14 @@ add_library(gen OBJECT
set_target_properties( gen PROPERTIES POSITION_INDEPENDENT_CODE ON ) set_target_properties( gen PROPERTIES POSITION_INDEPENDENT_CODE ON )
install( FILES ngexception.hpp DESTINATION ${INCDIR} COMPONENT netgen_devel ) install( FILES ngexception.hpp DESTINATION ${NG_INSTALL_DIR_INCLUDE} COMPONENT netgen_devel )
install(FILES install(FILES
archive_base.hpp array.hpp autodiff.hpp autoptr.hpp bitarray.hpp archive_base.hpp array.hpp autodiff.hpp autoptr.hpp bitarray.hpp
dynamicmem.hpp flags.hpp hashtabl.hpp mpi_interface.hpp myadt.hpp dynamicmem.hpp flags.hpp hashtabl.hpp mpi_interface.hpp myadt.hpp
mysimd.hpp mystring.hpp netgenout.hpp ngexception.hpp ngpython.hpp ngsimd.hpp mystring.hpp netgenout.hpp ngexception.hpp ngpython.hpp
optmem.hpp parthreads.hpp profiler.hpp seti.hpp sort.hpp optmem.hpp parthreads.hpp profiler.hpp seti.hpp sort.hpp
spbita2d.hpp stack.hpp symbolta.hpp table.hpp template.hpp spbita2d.hpp stack.hpp symbolta.hpp table.hpp template.hpp
gzstream.h gzstream.h
DESTINATION ${INCDIR}/general COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/general COMPONENT netgen_devel
) )

4
libsrc/general/array.hpp
View File

@ -329,7 +329,7 @@ namespace netgen
RangeCheck (i+1); RangeCheck (i+1);
#endif #endif
data[i] = data[size-1]; data[i] = std::move(data[size-1]);
size--; size--;
// DeleteElement (i+1); // DeleteElement (i+1);
} }
@ -342,7 +342,7 @@ namespace netgen
RangeCheck (i); RangeCheck (i);
#endif #endif
data[i-1] = data[size-1]; data[i-1] = std::move(data[size-1]);
size--; size--;
} }

32
libsrc/general/hashtabl.cpp
View File

@ -213,22 +213,27 @@ namespace netgen
BASE_INDEX_2_CLOSED_HASHTABLE :: BASE_INDEX_2_CLOSED_HASHTABLE ::
BASE_INDEX_2_CLOSED_HASHTABLE (int size) BASE_INDEX_2_CLOSED_HASHTABLE (size_t size)
: hash(size) : hash(RoundUp2(size))
{ {
size = hash.Size();
mask = size-1;
// hash.SetName ("i2-hashtable, hash"); // hash.SetName ("i2-hashtable, hash");
invalid = -1; invalid = -1;
for (int i = 1; i <= size; i++) for (size_t i = 0; i < size; i++)
hash.Elem(i).I1() = invalid; hash[i].I1() = invalid;
} }
void BASE_INDEX_2_CLOSED_HASHTABLE :: void BASE_INDEX_2_CLOSED_HASHTABLE ::
BaseSetSize (int size) BaseSetSize (int size)
{ {
size = RoundUp2 (size);
mask = size-1;
hash.SetSize(size); hash.SetSize(size);
for (int i = 1; i <= size; i++) for (size_t i = 0; i < size; i++)
hash.Elem(i).I1() = invalid; hash[i].I1() = invalid;
} }
@ -245,25 +250,28 @@ namespace netgen
} }
} }
int BASE_INDEX_2_CLOSED_HASHTABLE :: bool BASE_INDEX_2_CLOSED_HASHTABLE ::
PositionCreate2 (const INDEX_2 & ind, int & apos) PositionCreate2 (const INDEX_2 & ind, int & apos)
{ {
int i = HashValue(ind); int i = HashValue(ind);
int startpos = i; int startpos = i;
while (1) while (1)
{ {
/*
i++; i++;
if (i > hash.Size()) i = 1; if (i > hash.Size()) i = 1;
if (hash.Get(i) == ind) */
i = (i+1) % hash.Size();
if (hash[i] == ind)
{ {
apos = i; apos = i;
return 0; return false;
} }
if (hash.Get(i).I1() == invalid) if (hash[i].I1() == invalid)
{ {
hash.Elem(i) = ind; hash[i] = ind;
apos = i; apos = i;
return 1; return true;
} }
if (i == startpos) if (i == startpos)
throw NgException ("Try to set new element in full closed hashtable"); throw NgException ("Try to set new element in full closed hashtable");

198
libsrc/general/hashtabl.hpp
View File

@ -628,7 +628,12 @@ public:
inline size_t RoundUp2 (size_t i)
{
size_t res = 1;
while (res < i) res *= 2; // hope it will never be too large
return res;
}
/// Closed Hashing HT /// Closed Hashing HT
@ -640,47 +645,52 @@ protected:
Array<INDEX_2> hash; Array<INDEX_2> hash;
/// ///
int invalid; int invalid;
size_t mask;
public: public:
/// ///
BASE_INDEX_2_CLOSED_HASHTABLE (int size); BASE_INDEX_2_CLOSED_HASHTABLE (size_t size);
int Size() const { return hash.Size(); } int Size() const { return hash.Size(); }
int UsedPos (int pos) const { return ! (hash.Get(pos).I1() == invalid); } bool UsedPos0 (int pos) const { return ! (hash[pos].I1() == invalid); }
int UsedElements () const; int UsedElements () const;
/// ///
int HashValue (const INDEX_2 & ind) const int HashValue (const INDEX_2 & ind) const
{ {
return (ind.I1() + 71 * ind.I2()) % hash.Size() + 1; // return (ind.I1() + 71 * ind.I2()) % hash.Size() + 1;
return (ind.I1() + 71 * ind.I2()) & mask;
} }
int Position (const INDEX_2 & ind) const int Position0 (const INDEX_2 & ind) const
{ {
int i = HashValue(ind); int i = HashValue(ind);
while (1) while (1)
{ {
if (hash.Get(i) == ind) return i; if (hash[i] == ind) return i;
if (hash.Get(i).I1() == invalid) return 0; if (hash[i].I1() == invalid) return -1;
i = (i+1) & mask;
/*
i++; i++;
if (i > hash.Size()) i = 1; if (i > hash.Size()) i = 1;
*/
} }
} }
// returns 1, if new postion is created // returns 1, if new postion is created
int PositionCreate (const INDEX_2 & ind, int & apos) bool PositionCreate0 (const INDEX_2 & ind, int & apos)
{ {
int i = HashValue (ind); int i = HashValue (ind);
if (hash.Get(i) == ind) if (hash[i] == ind)
{ {
apos = i; apos = i;
return 0; return false;
} }
if (hash.Get(i).I1() == invalid) if (hash[i].I1() == invalid)
{ {
hash.Elem(i) = ind; hash[i] = ind;
apos = i; apos = i;
return 1; return true;
} }
return PositionCreate2 (ind, apos); return PositionCreate2 (ind, apos);
} }
@ -689,7 +699,7 @@ protected:
/// ///
int Position2 (const INDEX_2 & ind) const; int Position2 (const INDEX_2 & ind) const;
int PositionCreate2 (const INDEX_2 & ind, int & apos); bool PositionCreate2 (const INDEX_2 & ind, int & apos);
void BaseSetSize (int asize); void BaseSetSize (int asize);
}; };
@ -697,31 +707,65 @@ protected:
template <class T> template <class T>
class INDEX_2_CLOSED_HASHTABLE : public BASE_INDEX_2_CLOSED_HASHTABLE class INDEX_2_CLOSED_HASHTABLE : public BASE_INDEX_2_CLOSED_HASHTABLE
{ {
///
// MoveableArray<T> cont;
Array<T> cont; Array<T> cont;
public: public:
INDEX_2_CLOSED_HASHTABLE (size_t size)
: BASE_INDEX_2_CLOSED_HASHTABLE(size), cont(RoundUp2(size))
{ ; }
void Set (const INDEX_2 & ahash, const T & acont)
{
int pos;
PositionCreate0 (ahash, pos);
hash[pos] = ahash;
cont[pos] = acont;
}
const T & Get (const INDEX_2 & ahash) const
{
int pos = Position0 (ahash);
return cont[pos];
}
inline bool Used (const INDEX_2 & ahash) const
{
int pos = Position0 (ahash);
return (pos != -1);
}
inline void SetData0 (int pos, const INDEX_2 & ahash, const T & acont)
{
hash[pos] = ahash;
cont[pos] = acont;
}
/// ///
inline INDEX_2_CLOSED_HASHTABLE (int size); inline void GetData0 (int pos, INDEX_2 & ahash, T & acont) const
{
ahash = hash[pos];
acont = cont[pos];
}
inline void SetData0 (int pos, const T & acont)
{
cont[pos] = acont;
}
inline void GetData0 (int pos, T & acont) const
{
acont = cont[pos];
}
/// ///
inline void Set (const INDEX_2 & ahash, const T & acont); const T & GetData0 (int pos) { return cont[pos]; }
/// ///
inline const T & Get (const INDEX_2 & ahash) const; inline void SetSize (size_t size)
/// {
inline bool Used (const INDEX_2 & ahash) const; BaseSetSize(size);
/// cont.SetSize(RoundUp2(size));
inline void SetData (int pos, const INDEX_2 & ahash, const T & acont); }
///
inline void GetData (int pos, INDEX_2 & ahash, T & acont) const;
///
inline void SetData (int pos, const T & acont);
///
inline void GetData (int pos, T & acont) const;
///
const T & GetData (int pos) { return cont.Get(pos); }
///
inline void SetSize (int size);
/// ///
inline void PrintMemInfo (ostream & ost) const; inline void PrintMemInfo (ostream & ost) const;
/// ///
@ -746,7 +790,7 @@ inline ostream & operator<< (ostream & ost, const INDEX_2_CLOSED_HASHTABLE<T> &
{ {
INDEX_2 hash; INDEX_2 hash;
T data; T data;
ht.GetData (i, hash, data); ht.GetData0 (i, hash, data);
ost << "hash = " << hash << ", data = " << data << endl; ost << "hash = " << hash << ", data = " << data << endl;
} }
return ost; return ost;
@ -755,13 +799,6 @@ inline ostream & operator<< (ostream & ost, const INDEX_2_CLOSED_HASHTABLE<T> &
inline size_t RoundUp2 (size_t i)
{
size_t res = 1;
while (res < i) res *= 2; // hope it will never be too large
return res;
}
class BASE_INDEX_3_CLOSED_HASHTABLE class BASE_INDEX_3_CLOSED_HASHTABLE
{ {
protected: protected:
@ -1187,83 +1224,6 @@ inline void INDEX_HASHTABLE<T> :: PrintMemInfo (ostream & ost) const
/* *********** Closed Hashing ************************* */ /* *********** Closed Hashing ************************* */
template<class T>
inline INDEX_2_CLOSED_HASHTABLE<T> ::
INDEX_2_CLOSED_HASHTABLE (int size)
: BASE_INDEX_2_CLOSED_HASHTABLE(size), cont(size)
{
// cont.SetName ("i2-hashtable, contents");
}
template<class T>
inline void INDEX_2_CLOSED_HASHTABLE<T> ::
Set (const INDEX_2 & ahash, const T & acont)
{
int pos;
PositionCreate (ahash, pos);
hash.Elem(pos) = ahash;
cont.Elem(pos) = acont;
}
template<class T>
inline const T & INDEX_2_CLOSED_HASHTABLE<T> ::
Get (const INDEX_2 & ahash) const
{
int pos = Position (ahash);
return cont.Get(pos);
}
template<class T>
inline bool INDEX_2_CLOSED_HASHTABLE<T> ::
Used (const INDEX_2 & ahash) const
{
int pos = Position (ahash);
return (pos != 0);
}
template<class T>
inline void INDEX_2_CLOSED_HASHTABLE<T> ::
SetData (int pos, const INDEX_2 & ahash, const T & acont)
{
hash.Elem(pos) = ahash;
cont.Elem(pos) = acont;
}
template<class T>
inline void INDEX_2_CLOSED_HASHTABLE<T> ::
GetData (int pos, INDEX_2 & ahash, T & acont) const
{
ahash = hash.Get(pos);
acont = cont.Get(pos);
}
template<class T>
inline void INDEX_2_CLOSED_HASHTABLE<T> ::
SetData (int pos, const T & acont)
{
cont.Elem(pos) = acont;
}
template<class T>
inline void INDEX_2_CLOSED_HASHTABLE<T> ::
GetData (int pos, T & acont) const
{
acont = cont.Get(pos);
}
template<class T>
inline void INDEX_2_CLOSED_HASHTABLE<T> ::
SetSize (int size)
{
BaseSetSize(size);
cont.SetSize(size);
}
template<class T> template<class T>
inline void INDEX_2_CLOSED_HASHTABLE<T> :: inline void INDEX_2_CLOSED_HASHTABLE<T> ::
PrintMemInfo (ostream & ost) const PrintMemInfo (ostream & ost) const

2
libsrc/general/myadt.hpp
View File

@ -46,7 +46,7 @@
#include "gzstream.h" #include "gzstream.h"
#include "archive_base.hpp" #include "archive_base.hpp"
#include "mysimd.hpp" #include "ngsimd.hpp"
#endif #endif

403
libsrc/general/mysimd.hpp
View File

@ -1,403 +0,0 @@
#ifndef FILE_MYSIMD
#define FILE_MYSIMD
/**************************************************************************/
/* File: mysimd.hpp */
/* Author: Joachim Schoeberl */
/* Date: 25. Mar. 16 */
/**************************************************************************/
#include <immintrin.h>
#ifdef WIN32
#ifndef AVX_OPERATORS_DEFINED
#define AVX_OPERATORS_DEFINED
inline __m128d operator- (__m128d a) { return _mm_xor_pd(a, _mm_set1_pd(-0.0)); }
inline __m128d operator+ (__m128d a, __m128d b) { return _mm_add_pd(a,b); }
inline __m128d operator- (__m128d a, __m128d b) { return _mm_sub_pd(a,b); }
inline __m128d operator* (__m128d a, __m128d b) { return _mm_mul_pd(a,b); }
inline __m128d operator/ (__m128d a, __m128d b) { return _mm_div_pd(a,b); }
inline __m128d operator* (double a, __m128d b) { return _mm_set1_pd(a)*b; }
inline __m128d operator* (__m128d b, double a) { return _mm_set1_pd(a)*b; }
inline __m128d operator+= (__m128d &a, __m128d b) { return a = a+b; }
inline __m128d operator-= (__m128d &a, __m128d b) { return a = a-b; }
inline __m128d operator*= (__m128d &a, __m128d b) { return a = a*b; }
inline __m128d operator/= (__m128d &a, __m128d b) { return a = a/b; }
inline __m256d operator- (__m256d a) { return _mm256_xor_pd(a, _mm256_set1_pd(-0.0)); }
inline __m256d operator+ (__m256d a, __m256d b) { return _mm256_add_pd(a,b); }
inline __m256d operator- (__m256d a, __m256d b) { return _mm256_sub_pd(a,b); }
inline __m256d operator* (__m256d a, __m256d b) { return _mm256_mul_pd(a,b); }
inline __m256d operator/ (__m256d a, __m256d b) { return _mm256_div_pd(a,b); }
inline __m256d operator* (double a, __m256d b) { return _mm256_set1_pd(a)*b; }
inline __m256d operator* (__m256d b, double a) { return _mm256_set1_pd(a)*b; }
inline __m256d operator+= (__m256d &a, __m256d b) { return a = a+b; }
inline __m256d operator-= (__m256d &a, __m256d b) { return a = a-b; }
inline __m256d operator*= (__m256d &a, __m256d b) { return a = a*b; }
inline __m256d operator/= (__m256d &a, __m256d b) { return a = a/b; }
#endif
#endif
namespace netgen
{
template <typename T> class SIMD;
template <typename T>
struct has_call_operator
{
template <typename C> static std::true_type check( decltype( sizeof(&C::operator() )) ) { return std::true_type(); }
template <typename> static std::false_type check(...) { return std::false_type(); }
typedef decltype( check<T>(sizeof(char)) ) type;
static constexpr type value = type();
};
#ifdef __AVX__
template <typename T>
class AlignedAlloc
{
protected:
static void * aligned_malloc(size_t s)
{
// Assume 16 byte alignment of standard library
if(alignof(T)<=16)
return malloc(s);
else
return _mm_malloc(s, alignof(T));
}
static void aligned_free(void *p)
{
if(alignof(T)<=16)
free(p);
else
_mm_free(p);
}
public:
void * operator new (size_t s, void *p) { return p; }
void * operator new (size_t s) { return aligned_malloc(s); }
void * operator new[] (size_t s) { return aligned_malloc(s); }
void operator delete (void * p) { aligned_free(p); }
void operator delete[] (void * p) { aligned_free(p); }
};
template<>
class alignas(32) SIMD<double> : public AlignedAlloc<SIMD<double>>
{
__m256d data;
public:
static constexpr int Size() { return 4; }
SIMD () = default;
SIMD (const SIMD &) = default;
SIMD & operator= (const SIMD &) = default;
SIMD (double val)
{
data = _mm256_set1_pd(val);
}
SIMD (__m256d adata)
: data(adata)
{ ; }
/*
template <typename T>
SIMD (const T & val)
{
// SIMD_function(val, std::is_convertible<T, std::function<double(int)>>());
SIMD_function(val, has_call_operator<T>::value);
}
*/
/*
template <typename T>
SIMD & operator= (const T & val)
{
// SIMD_function(val, std::is_convertible<T, std::function<double(int)>>());
SIMD_function(val, has_call_operator<T>::value);
return *this;
}
*/
template <typename Function>
void SIMD_function (const Function & func, std::true_type)
{
data = _mm256_set_pd(func(3), func(2), func(1), func(0));
}
// not a function
void SIMD_function (double const * p, std::false_type)
{
data = _mm256_loadu_pd(p);
}
void SIMD_function (double val, std::false_type)
{
data = _mm256_set1_pd(val);
}
void SIMD_function (__m256d _data, std::false_type)
{
data = _data;
}
inline double operator[] (int i) const { return ((double*)(&data))[i]; }
inline __m256d Data() const { return data; }
inline __m256d & Data() { return data; }
};
inline SIMD<double> operator+ (SIMD<double> a, SIMD<double> b) { return a.Data()+b.Data(); }
inline SIMD<double> operator- (SIMD<double> a, SIMD<double> b) { return a.Data()-b.Data(); }
inline SIMD<double> operator- (SIMD<double> a) { return -a.Data(); }
inline SIMD<double> operator* (SIMD<double> a, SIMD<double> b) { return a.Data()*b.Data(); }
inline SIMD<double> operator/ (SIMD<double> a, SIMD<double> b) { return a.Data()/b.Data(); }
inline SIMD<double> operator* (double a, SIMD<double> b) { return SIMD<double>(a)*b; }
inline SIMD<double> operator* (SIMD<double> b, double a) { return SIMD<double>(a)*b; }
inline SIMD<double> operator+= (SIMD<double> & a, SIMD<double> b) { return a.Data()+=b.Data(); }
inline SIMD<double> operator-= (SIMD<double> & a, SIMD<double> b) { return a.Data()-=b.Data(); }
inline SIMD<double> operator*= (SIMD<double> & a, SIMD<double> b) { return a.Data()*=b.Data(); }
inline SIMD<double> operator/= (SIMD<double> & a, SIMD<double> b) { return a.Data()/=b.Data(); }
using std::sqrt;
using std::fabs;
inline SIMD<double> sqrt (SIMD<double> a) { return _mm256_sqrt_pd(a.Data()); }
inline SIMD<double> fabs (SIMD<double> a) { return _mm256_max_pd(a.Data(), -a.Data()); }
inline SIMD<double> L2Norm2 (SIMD<double> a) { return a.Data()*a.Data(); }
inline SIMD<double> Trans (SIMD<double> a) { return a; }
inline SIMD<double> IfPos (SIMD<double> a, SIMD<double> b, SIMD<double> c)
{
auto cp = _mm256_cmp_pd (a.Data(), _mm256_setzero_pd(), _CMP_GT_OS);
return _mm256_blendv_pd(c.Data(), b.Data(), cp);
}
inline double HSum (SIMD<double> sd)
{
__m128d hv = _mm_add_pd (_mm256_extractf128_pd(sd.Data(),0), _mm256_extractf128_pd(sd.Data(),1));
return _mm_cvtsd_f64 (_mm_hadd_pd (hv, hv));
}
#else
// it's only a dummy without AVX
template <typename T>
class AlignedAlloc { ; };
template<>
class SIMD<double>
{
double data;
public:
static constexpr int Size() { return 1; }
SIMD () = default;
SIMD (const SIMD &) = default;
SIMD & operator= (const SIMD &) = default;
SIMD (double val)
: data(val) { ; }
/*
template <typename T>
SIMD (const T & val)
{
// SIMD_function(val, std::is_convertible<T, std::function<double(int)>>());
SIMD_function(val, has_call_operator<T>::value);
}
*/
template <typename T>
SIMD & operator= (const T & val)
{
// SIMD_function(val, std::is_convertible<T, std::function<double(int)>>());
SIMD_function(val, has_call_operator<T>::value);
return *this;
}
template <typename Function>
void SIMD_function (const Function & func, std::true_type)
{
data = func(0);
}
// not a function
void SIMD_function (double const * p, std::false_type)
{
data = *p;
}
void SIMD_function (double val, std::false_type)
{
data = val;
}
double operator[] (int i) const { return ((double*)(&data))[i]; }
double Data() const { return data; }
double & Data() { return data; }
};
inline SIMD<double> operator+ (SIMD<double> a, SIMD<double> b) { return a.Data()+b.Data(); }
inline SIMD<double> operator- (SIMD<double> a, SIMD<double> b) { return a.Data()-b.Data(); }
inline SIMD<double> operator- (SIMD<double> a) { return -a.Data(); }
inline SIMD<double> operator* (SIMD<double> a, SIMD<double> b) { return a.Data()*b.Data(); }
inline SIMD<double> operator/ (SIMD<double> a, SIMD<double> b) { return a.Data()/b.Data(); }
inline SIMD<double> operator* (double a, SIMD<double> b) { return SIMD<double>(a)*b; }
inline SIMD<double> operator* (SIMD<double> b, double a) { return SIMD<double>(a)*b; }
inline SIMD<double> operator+= (SIMD<double> & a, SIMD<double> b) { return a.Data()+=b.Data(); }
inline SIMD<double> operator-= (SIMD<double> & a, SIMD<double> b) { return a.Data()-=b.Data(); }
inline SIMD<double> operator*= (SIMD<double> & a, SIMD<double> b) { return a.Data()*=b.Data(); }
inline SIMD<double> operator/= (SIMD<double> & a, SIMD<double> b) { return a.Data()/=b.Data(); }
using std::sqrt;
using std::fabs;
inline SIMD<double> sqrt (SIMD<double> a) { return std::sqrt(a.Data()); }
inline SIMD<double> fabs (SIMD<double> a) { return std::fabs(a.Data()); }
inline SIMD<double> L2Norm2 (SIMD<double> a) { return a.Data()*a.Data(); }
inline SIMD<double> Trans (SIMD<double> a) { return a; }
inline SIMD<double> IfPos (SIMD<double> a, SIMD<double> b, SIMD<double> c)
{
return (a.Data() > 0) ? b : c;
}
inline double HSum (SIMD<double> sd)
{ return sd.Data(); }
#endif
template <typename T>
ostream & operator<< (ostream & ost, SIMD<T> simd)
{
ost << simd[0];
for (int i = 1; i < simd.Size(); i++)
ost << " " << simd[i];
return ost;
}
/*
using std::exp;
inline netgen::SIMD<double> exp (netgen::SIMD<double> a) {
return netgen::SIMD<double>([&](int i)->double { return exp(a[i]); } );
}
using std::log;
inline netgen::SIMD<double> log (netgen::SIMD<double> a) {
return netgen::SIMD<double>([&](int i)->double { return log(a[i]); } );
}
using std::pow;
inline netgen::SIMD<double> pow (netgen::SIMD<double> a, double x) {
return netgen::SIMD<double>([&](int i)->double { return pow(a[i],x); } );
}
*/
template <int D, typename T>
class MultiSIMD
{
SIMD<T> head;
MultiSIMD<D-1,T> tail;
public:
MultiSIMD () = default;
MultiSIMD (const MultiSIMD & ) = default;
MultiSIMD (T v) : head(v), tail(v) { ; }
MultiSIMD (SIMD<T> _head, MultiSIMD<D-1,T> _tail)
: head(_head), tail(_tail) { ; }
SIMD<T> Head() const { return head; }
MultiSIMD<D-1,T> Tail() const { return tail; }
SIMD<T> & Head() { return head; }
MultiSIMD<D-1,T> & Tail() { return tail; }
template <int NR>
SIMD<T> Get() const { return NR==0 ? head : tail.template Get<NR-1>(); }
template <int NR>
SIMD<T> & Get() { return NR==0 ? head : tail.template Get<NR-1>(); }
};
template <typename T>
class MultiSIMD<2,T>
{
SIMD<T> v0, v1;
public:
MultiSIMD () = default;
MultiSIMD (const MultiSIMD & ) = default;
MultiSIMD (T v) : v0(v), v1(v) { ; }
MultiSIMD (SIMD<T> _v0, SIMD<T> _v1) : v0(_v0), v1(_v1) { ; }
SIMD<T> Head() const { return v0; }
SIMD<T> Tail() const { return v1; }
SIMD<T> & Head() { return v0; }
SIMD<T> & Tail() { return v1; }
template <int NR>
SIMD<T> Get() const { return NR==0 ? v0 : v1; }
template <int NR>
SIMD<T> & Get() { return NR==0 ? v0 : v1; }
};
template <int D> inline MultiSIMD<D,double> operator+ (MultiSIMD<D,double> a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a.Head()+b.Head(), a.Tail()+b.Tail()); }
template <int D> inline MultiSIMD<D,double> operator+ (double a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a+b.Head(), a+b.Tail()); }
template <int D> inline MultiSIMD<D,double> operator+ (MultiSIMD<D,double> b, double a)
{ return MultiSIMD<D,double> (a+b.Head(), a+b.Tail()); }
template <int D> inline MultiSIMD<D,double> operator- (MultiSIMD<D,double> a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a.Head()-b.Head(), a.Tail()-b.Tail()); }
template <int D> inline MultiSIMD<D,double> operator- (double a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a-b.Head(), a-b.Tail()); }
template <int D> inline MultiSIMD<D,double> operator- (MultiSIMD<D,double> b, double a)
{ return MultiSIMD<D,double> (b.Head()-a, b.Tail()-a); }
template <int D> inline MultiSIMD<D,double> operator- (MultiSIMD<D,double> a)
{ return MultiSIMD<D,double> (-a.Head(), -a.Tail()); }
template <int D> inline MultiSIMD<D,double> operator* (MultiSIMD<D,double> a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a.Head()*b.Head(), a.Tail()*b.Tail()); }
template <int D> inline MultiSIMD<D,double> operator/ (MultiSIMD<D,double> a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a.Head()/b.Head(), a.Tail()/b.Tail()); }
template <int D> inline MultiSIMD<D,double> operator* (double a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> ( a*b.Head(), a*b.Tail()); }
template <int D> inline MultiSIMD<D,double> operator* (MultiSIMD<D,double> b, double a)
{ return MultiSIMD<D,double> ( a*b.Head(), a*b.Tail()); }
template <int D> inline MultiSIMD<D,double> & operator+= (MultiSIMD<D,double> & a, MultiSIMD<D,double> b)
{ a.Head()+=b.Head(); a.Tail()+=b.Tail(); return a; }
template <int D> inline MultiSIMD<D,double> operator-= (MultiSIMD<D,double> & a, double b)
{ a.Head()-=b; a.Tail()-=b; return a; }
template <int D> inline MultiSIMD<D,double> operator-= (MultiSIMD<D,double> & a, MultiSIMD<D,double> b)
{ a.Head()-=b.Head(); a.Tail()-=b.Tail(); return a; }
template <int D> inline MultiSIMD<D,double> & operator*= (MultiSIMD<D,double> & a, MultiSIMD<D,double> b)
{ a.Head()*=b.Head(); a.Tail()*=b.Tail(); return a; }
template <int D> inline MultiSIMD<D,double> & operator*= (MultiSIMD<D,double> & a, double b)
{ a.Head()*=b; a.Tail()*=b; return a; }
// inline MultiSIMD<double> operator/= (MultiSIMD<double> & a, MultiSIMD<double> b) { return a.Data()/=b.Data(); }
template <int D, typename T>
ostream & operator<< (ostream & ost, MultiSIMD<D,T> multi)
{
ost << multi.Head() << " " << multi.Tail();
return ost;
}
}
#endif

558
libsrc/general/ngsimd.hpp Normal file
View File

@ -0,0 +1,558 @@
#ifndef FILE_NGSIMD
#define FILE_NGSIMD
/**************************************************************************/
/* File: ngsimd.hpp */
/* Author: Joachim Schoeberl */
/* Date: 25. Mar. 16 */
/**************************************************************************/
#include <immintrin.h>
#include <tuple>
#include <ostream>
#include <stdexcept>
#include <string>
#include <type_traits>
#ifdef WIN32
#ifndef AVX_OPERATORS_DEFINED
#define AVX_OPERATORS_DEFINED
NG_INLINE __m128d operator- (__m128d a) { return _mm_xor_pd(a, _mm_set1_pd(-0.0)); }
NG_INLINE __m128d operator+ (__m128d a, __m128d b) { return _mm_add_pd(a,b); }
NG_INLINE __m128d operator- (__m128d a, __m128d b) { return _mm_sub_pd(a,b); }
NG_INLINE __m128d operator* (__m128d a, __m128d b) { return _mm_mul_pd(a,b); }
NG_INLINE __m128d operator/ (__m128d a, __m128d b) { return _mm_div_pd(a,b); }
NG_INLINE __m128d operator* (double a, __m128d b) { return _mm_set1_pd(a)*b; }
NG_INLINE __m128d operator* (__m128d b, double a) { return _mm_set1_pd(a)*b; }
NG_INLINE __m128d operator+= (__m128d &a, __m128d b) { return a = a+b; }
NG_INLINE __m128d operator-= (__m128d &a, __m128d b) { return a = a-b; }
NG_INLINE __m128d operator*= (__m128d &a, __m128d b) { return a = a*b; }
NG_INLINE __m128d operator/= (__m128d &a, __m128d b) { return a = a/b; }
NG_INLINE __m256d operator- (__m256d a) { return _mm256_xor_pd(a, _mm256_set1_pd(-0.0)); }
NG_INLINE __m256d operator+ (__m256d a, __m256d b) { return _mm256_add_pd(a,b); }
NG_INLINE __m256d operator- (__m256d a, __m256d b) { return _mm256_sub_pd(a,b); }
NG_INLINE __m256d operator* (__m256d a, __m256d b) { return _mm256_mul_pd(a,b); }
NG_INLINE __m256d operator/ (__m256d a, __m256d b) { return _mm256_div_pd(a,b); }
NG_INLINE __m256d operator* (double a, __m256d b) { return _mm256_set1_pd(a)*b; }
NG_INLINE __m256d operator* (__m256d b, double a) { return _mm256_set1_pd(a)*b; }
NG_INLINE __m256d operator+= (__m256d &a, __m256d b) { return a = a+b; }
NG_INLINE __m256d operator-= (__m256d &a, __m256d b) { return a = a-b; }
NG_INLINE __m256d operator*= (__m256d &a, __m256d b) { return a = a*b; }
NG_INLINE __m256d operator/= (__m256d &a, __m256d b) { return a = a/b; }
#endif
#endif
namespace ngsimd
{
constexpr int GetDefaultSIMDSize() {
#if defined __AVX512F__
return 8;
#elif defined __AVX__
return 4;
#else
return 1;
#endif
}
template <typename T, int N=GetDefaultSIMDSize()> class SIMD;
template <typename T>
struct has_call_operator
{
template <typename C> static std::true_type check( decltype( sizeof(&C::operator() )) ) { return std::true_type(); }
template <typename> static std::false_type check(...) { return std::false_type(); }
typedef decltype( check<T>(sizeof(char)) ) type;
static constexpr type value = type();
};
template <typename T1, typename T2, typename T3>
// a*b+c
NG_INLINE auto FMA(T1 a, T2 b, T3 c)
{
return a*b+c;
}
template<int N, typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
NG_INLINE SIMD<double,N> operator+ (T a, SIMD<double,N> b) { return SIMD<double,N>(a) + b; }
template<int N, typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
NG_INLINE SIMD<double,N> operator- (T a, SIMD<double,N> b) { return SIMD<double,N>(a) - b; }
template<int N, typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
NG_INLINE SIMD<double,N> operator* (T a, SIMD<double,N> b) { return SIMD<double,N>(a) * b; }
template<int N, typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
NG_INLINE SIMD<double,N> operator/ (T a, SIMD<double,N> b) { return SIMD<double,N>(a) / b; }
template<int N, typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
NG_INLINE SIMD<double,N> operator+ (SIMD<double,N> a, T b) { return a + SIMD<double,N>(b); }
template<int N, typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
NG_INLINE SIMD<double,N> operator- (SIMD<double,N> a, T b) { return a - SIMD<double,N>(b); }
template<int N, typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
NG_INLINE SIMD<double,N> operator* (SIMD<double,N> a, T b) { return a * SIMD<double,N>(b); }
template<int N, typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
NG_INLINE SIMD<double,N> operator/ (SIMD<double,N> a, T b) { return a / SIMD<double,N>(b); }
#ifdef __AVX__
template <typename T>
class AlignedAlloc
{
protected:
static void * aligned_malloc(size_t s)
{
// Assume 16 byte alignment of standard library
if(alignof(T)<=16)
return malloc(s);
else
return _mm_malloc(s, alignof(T));
}
static void aligned_free(void *p)
{
if(alignof(T)<=16)
free(p);
else
_mm_free(p);
}
public:
void * operator new (size_t s, void *p) { return p; }
void * operator new (size_t s) { return aligned_malloc(s); }
void * operator new[] (size_t s) { return aligned_malloc(s); }
void operator delete (void * p) { aligned_free(p); }
void operator delete[] (void * p) { aligned_free(p); }
};
#else
// it's only a dummy without AVX
template <typename T>
class AlignedAlloc { ; };
#endif
using std::sqrt;
using std::fabs;
class ExceptionNOSIMD : public std::runtime_error
{
public:
using std::runtime_error::runtime_error;
std::string What() { return what(); }
};
using std::exp;
template<int N> NG_INLINE SIMD<double,N> exp (SIMD<double,N> a)
{
return SIMD<double,N>([&](int i)->double { return exp(a[i]); } );
}
using std::log;
template<int N> NG_INLINE SIMD<double,N> log (SIMD<double,N> a)
{
return SIMD<double,N>([&](int i)->double { return log(a[i]); } );
}
using std::pow;
template<int N> NG_INLINE SIMD<double,N> pow (SIMD<double,N> a, double x)
{
return SIMD<double,N>([&](int i)->double { return pow(a[i],x); } );
}
using std::sin;
template<int N> NG_INLINE SIMD<double,N> sin (SIMD<double,N> a)
{
return SIMD<double,N>([&](int i)->double { return sin(a[i]); } );
}
using std::cos;
template<int N> NG_INLINE SIMD<double,N> cos (SIMD<double,N> a)
{
return SIMD<double,N>([&](int i)->double { return cos(a[i]); } );
}
using std::tan;
template<int N> NG_INLINE SIMD<double,N> tan (SIMD<double,N> a)
{
return SIMD<double,N>([&](int i)->double { return tan(a[i]); } );
}
using std::atan;
template<int N> NG_INLINE SIMD<double,N> atan (SIMD<double,N> a)
{
return SIMD<double,N>([&](int i)->double { return atan(a[i]); } );
}
/////////////////////////////////////////////////////////////////////////////
// SIMD width 1 (in case no AVX support is available)
/////////////////////////////////////////////////////////////////////////////
template<>
class SIMD<double,1>
{
double data;
public:
static constexpr int Size() { return 1; }
SIMD () = default;
SIMD (const SIMD &) = default;
SIMD & operator= (const SIMD &) = default;
// only called if T has a call operator of appropriate type
template<typename T, typename std::enable_if<std::is_convertible<T, std::function<double(int)>>::value, int>::type = 0>
SIMD (const T & func)
{
data = func(0);
}
// only called if T is arithmetic (integral or floating point types)
template<typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
SIMD (const T & val)
{
data = val;
}
SIMD (double const * p)
{
data = *p;
}
NG_INLINE operator double() const { return data; }
NG_INLINE double operator[] (int i) const { return ((double*)(&data))[i]; }
NG_INLINE double Data() const { return data; }
NG_INLINE double & Data() { return data; }
NG_INLINE SIMD<double,1> &operator+= (SIMD<double,1> b) { data+=b.Data(); return *this; }
NG_INLINE SIMD<double,1> &operator-= (SIMD<double,1> b) { data-=b.Data(); return *this; }
NG_INLINE SIMD<double,1> &operator*= (SIMD<double,1> b) { data*=b.Data(); return *this; }
NG_INLINE SIMD<double,1> &operator/= (SIMD<double,1> b) { data/=b.Data(); return *this; }
};
NG_INLINE SIMD<double,1> operator+ (SIMD<double,1> a, SIMD<double,1> b) { return a.Data()+b.Data(); }
NG_INLINE SIMD<double,1> operator- (SIMD<double,1> a, SIMD<double,1> b) { return a.Data()-b.Data(); }
NG_INLINE SIMD<double,1> operator- (SIMD<double,1> a) { return -a.Data(); }
NG_INLINE SIMD<double,1> operator* (SIMD<double,1> a, SIMD<double,1> b) { return a.Data()*b.Data(); }
NG_INLINE SIMD<double,1> operator/ (SIMD<double,1> a, SIMD<double,1> b) { return a.Data()/b.Data(); }
NG_INLINE SIMD<double,1> sqrt (SIMD<double,1> a) { return std::sqrt(a.Data()); }
NG_INLINE SIMD<double,1> fabs (SIMD<double,1> a) { return std::fabs(a.Data()); }
NG_INLINE SIMD<double,1> L2Norm2 (SIMD<double,1> a) { return a.Data()*a.Data(); }
NG_INLINE SIMD<double,1> Trans (SIMD<double,1> a) { return a; }
NG_INLINE SIMD<double,1> IfPos (SIMD<double,1> a, SIMD<double,1> b, SIMD<double,1> c)
{
return (a.Data() > 0) ? b : c;
}
NG_INLINE double HSum (SIMD<double,1> sd)
{
return sd.Data();
}
NG_INLINE auto HSum (SIMD<double,1> sd1, SIMD<double,1> sd2)
{
return std::make_tuple(sd1.Data(), sd2.Data());
}
/////////////////////////////////////////////////////////////////////////////
// AVX - Simd width 4
/////////////////////////////////////////////////////////////////////////////
#ifdef __AVX__
template<>
class alignas(32) SIMD<double,4> : public AlignedAlloc<SIMD<double,4>>
{
__m256d data;
public:
static constexpr int Size() { return 4; }
SIMD () = default;
SIMD (const SIMD &) = default;
SIMD & operator= (const SIMD &) = default;
SIMD (__m256d adata)
: data(adata)
{ ; }
// only called if T has a call operator of appropriate type
template<typename T, typename std::enable_if<std::is_convertible<T, std::function<double(int)>>::value, int>::type = 0>
SIMD (const T & func)
{
data = _mm256_set_pd(func(3), func(2), func(1), func(0));
}
// only called if T is arithmetic (integral or floating point types)
template<typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
SIMD (const T & val)
{
data = _mm256_set1_pd(val);
}
SIMD (double const * p)
{
data = _mm256_loadu_pd(p);
}
NG_INLINE operator __m256d() const { return data; }
NG_INLINE double operator[] (int i) const { return ((double*)(&data))[i]; }
NG_INLINE __m256d Data() const { return data; }
NG_INLINE __m256d & Data() { return data; }
NG_INLINE SIMD<double,4> &operator+= (SIMD<double,4> b) { data+=b.Data(); return *this; }
NG_INLINE SIMD<double,4> &operator-= (SIMD<double,4> b) { data-=b.Data(); return *this; }
NG_INLINE SIMD<double,4> &operator*= (SIMD<double,4> b) { data*=b.Data(); return *this; }
NG_INLINE SIMD<double,4> &operator/= (SIMD<double,4> b) { data/=b.Data(); return *this; }
};
NG_INLINE SIMD<double,4> operator+ (SIMD<double,4> a, SIMD<double,4> b) { return a.Data()+b.Data(); }
NG_INLINE SIMD<double,4> operator- (SIMD<double,4> a, SIMD<double,4> b) { return a.Data()-b.Data(); }
NG_INLINE SIMD<double,4> operator- (SIMD<double,4> a) { return -a.Data(); }
NG_INLINE SIMD<double,4> operator* (SIMD<double,4> a, SIMD<double,4> b) { return a.Data()*b.Data(); }
NG_INLINE SIMD<double,4> operator/ (SIMD<double,4> a, SIMD<double,4> b) { return a.Data()/b.Data(); }
NG_INLINE SIMD<double,4> sqrt (SIMD<double,4> a) { return _mm256_sqrt_pd(a.Data()); }
NG_INLINE SIMD<double,4> fabs (SIMD<double,4> a) { return _mm256_max_pd(a.Data(), -a.Data()); }
NG_INLINE SIMD<double,4> L2Norm2 (SIMD<double,4> a) { return a.Data()*a.Data(); }
NG_INLINE SIMD<double,4> Trans (SIMD<double,4> a) { return a; }
NG_INLINE SIMD<double,4> IfPos (SIMD<double,4> a, SIMD<double,4> b, SIMD<double,4> c)
{
auto cp = _mm256_cmp_pd (a.Data(), _mm256_setzero_pd(), _CMP_GT_OS);
return _mm256_blendv_pd(c.Data(), b.Data(), cp);
}
NG_INLINE double HSum (SIMD<double,4> sd)
{
__m128d hv = _mm_add_pd (_mm256_extractf128_pd(sd.Data(),0), _mm256_extractf128_pd(sd.Data(),1));
return _mm_cvtsd_f64 (_mm_hadd_pd (hv, hv));
}
NG_INLINE auto HSum (SIMD<double,4> sd1, SIMD<double,4> sd2)
{
__m256d hv = _mm256_hadd_pd(sd1.Data(), sd2.Data());
__m128d hv2 = _mm_add_pd (_mm256_extractf128_pd(hv,0), _mm256_extractf128_pd(hv,1));
return std::make_tuple(_mm_cvtsd_f64 (hv2), _mm_cvtsd_f64(_mm_shuffle_pd (hv2, hv2, 3)));
}
NG_INLINE SIMD<double,4> HSum (SIMD<double,4> v1, SIMD<double,4> v2, SIMD<double,4> v3, SIMD<double,4> v4)
{
__m256d hsum1 = _mm256_hadd_pd (v1.Data(), v2.Data());
__m256d hsum2 = _mm256_hadd_pd (v3.Data(), v4.Data());
__m256d hsum = _mm256_add_pd (_mm256_permute2f128_pd (hsum1, hsum2, 1+2*16),
_mm256_blend_pd (hsum1, hsum2, 12));
return hsum;
}
#endif // __AVX__
/////////////////////////////////////////////////////////////////////////////
// AVX512 - Simd width 8
/////////////////////////////////////////////////////////////////////////////
#ifdef __AVX512F__
template<>
class alignas(64) SIMD<double,8> : public AlignedAlloc<SIMD<double,8>>
{
__m512d data;
public:
static constexpr int Size() { return 8; }
SIMD () = default;
SIMD (const SIMD &) = default;
SIMD & operator= (const SIMD &) = default;
SIMD (__m512d adata)
: data(adata)
{ ; }
// only called if T has a call operator of appropriate type
template<typename T, typename std::enable_if<std::is_convertible<T, std::function<double(int)>>::value, int>::type = 0>
SIMD (const T & func)
{
data = _mm512_set_pd(func(7), func(6), func(5), func(4),
func(3), func(2), func(1), func(0));
}
// only called if T is arithmetic (integral or floating point types)
template<typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
SIMD (const T & val)
{
data = _mm512_set1_pd(val);
}
SIMD (double const * p)
{
data = _mm512_loadu_pd(p);
}
NG_INLINE operator __m512d() const { return data; }
NG_INLINE double operator[] (int i) const { return ((double*)(&data))[i]; }
NG_INLINE __m512d Data() const { return data; }
NG_INLINE __m512d & Data() { return data; }
NG_INLINE SIMD<double,8> &operator+= (SIMD<double,8> b) { data+=b.Data(); return *this; }
NG_INLINE SIMD<double,8> &operator-= (SIMD<double,8> b) { data-=b.Data(); return *this; }
NG_INLINE SIMD<double,8> &operator*= (SIMD<double,8> b) { data*=b.Data(); return *this; }
NG_INLINE SIMD<double,8> &operator/= (SIMD<double,8> b) { data/=b.Data(); return *this; }
};
NG_INLINE SIMD<double,8> operator- (SIMD<double,8> a) { return _mm512_sub_pd(_mm512_setzero_pd(), a.Data()); }
NG_INLINE SIMD<double,8> operator+ (SIMD<double,8> a, SIMD<double,8> b) { return _mm512_add_pd(a.Data(),b.Data()); }
NG_INLINE SIMD<double,8> operator- (SIMD<double,8> a, SIMD<double,8> b) { return _mm512_sub_pd(a.Data(),b.Data()); }
NG_INLINE SIMD<double,8> operator* (SIMD<double,8> a, SIMD<double,8> b) { return _mm512_mul_pd(a.Data(),b.Data()); }
NG_INLINE SIMD<double,8> operator/ (SIMD<double,8> a, SIMD<double,8> b) { return _mm512_div_pd(a.Data(),b.Data()); }
NG_INLINE SIMD<double,8> sqrt (SIMD<double,8> a) { return _mm512_sqrt_pd(a.Data()); }
NG_INLINE SIMD<double,8> fabs (SIMD<double,8> a) { return _mm512_max_pd(a.Data(), -a.Data()); }
NG_INLINE SIMD<double,8> L2Norm2 (SIMD<double,8> a) { return a.Data()*a.Data(); }
NG_INLINE SIMD<double,8> Trans (SIMD<double,8> a) { return a; }
NG_INLINE SIMD<double,8> IfPos (SIMD<double,8> a, SIMD<double,8> b, SIMD<double,8> c)
{
auto cp = _mm512_cmp_pd_mask (a.Data(), _mm512_setzero_pd(), _MM_CMPINT_GT);
return _mm512_mask_blend_pd(cp, c.Data(), b.Data());
}
template<> NG_INLINE auto FMA (SIMD<double,8> a, SIMD<double,8> b, SIMD<double,8> c)
{
return _mm512_fmadd_pd (a.Data(), b.Data(), c.Data());
}
NG_INLINE double HSum (SIMD<double,8> sd)
{
SIMD<double,4> low = _mm512_extractf64x4_pd(sd.Data(),0);
SIMD<double,4> high = _mm512_extractf64x4_pd(sd.Data(),1);
return HSum(low)+HSum(high);
}
NG_INLINE auto HSum (SIMD<double,8> sd1, SIMD<double,8> sd2)
{
return std::make_tuple(HSum(sd1), HSum(sd2));
}
NG_INLINE SIMD<double,4> HSum (SIMD<double,8> v1, SIMD<double,8> v2, SIMD<double,8> v3, SIMD<double,8> v4)
{
SIMD<double,4> high1 = _mm512_extractf64x4_pd(v1.Data(),1);
SIMD<double,4> high2 = _mm512_extractf64x4_pd(v2.Data(),1);
SIMD<double,4> high3 = _mm512_extractf64x4_pd(v3.Data(),1);
SIMD<double,4> high4 = _mm512_extractf64x4_pd(v4.Data(),1);
SIMD<double,4> low1 = _mm512_extractf64x4_pd(v1.Data(),0);
SIMD<double,4> low2 = _mm512_extractf64x4_pd(v2.Data(),0);
SIMD<double,4> low3 = _mm512_extractf64x4_pd(v3.Data(),0);
SIMD<double,4> low4 = _mm512_extractf64x4_pd(v4.Data(),0);
return HSum(low1,low2,low3,low4) + HSum(high1,high2,high3,high4);
}
#endif // __AVX512F__
////////////////////////////////////////////////////////////////////////////////
// MultiSIMD - Multiple SIMD values in one struct using head-tail implementation
////////////////////////////////////////////////////////////////////////////////
template <int D, typename T>
class MultiSIMD : public AlignedAlloc<MultiSIMD<D,T>>
{
SIMD<T> head;
MultiSIMD<D-1,T> tail;
public:
MultiSIMD () = default;
MultiSIMD (const MultiSIMD & ) = default;
MultiSIMD (T v) : head(v), tail(v) { ; }
MultiSIMD (SIMD<T> _head, MultiSIMD<D-1,T> _tail)
: head(_head), tail(_tail) { ; }
SIMD<T> Head() const { return head; }
MultiSIMD<D-1,T> Tail() const { return tail; }
SIMD<T> & Head() { return head; }
MultiSIMD<D-1,T> & Tail() { return tail; }
template <int NR>
SIMD<T> Get() const { return NR==0 ? head : tail.template Get<NR-1>(); }
template <int NR>
SIMD<T> & Get() { return NR==0 ? head : tail.template Get<NR-1>(); }
};
template <typename T>
class MultiSIMD<2,T> : public AlignedAlloc<MultiSIMD<2,T>>
{
SIMD<T> v0, v1;
public:
MultiSIMD () = default;
MultiSIMD (const MultiSIMD & ) = default;
MultiSIMD (T v) : v0(v), v1(v) { ; }
MultiSIMD (SIMD<T> _v0, SIMD<T> _v1) : v0(_v0), v1(_v1) { ; }
SIMD<T> Head() const { return v0; }
SIMD<T> Tail() const { return v1; }
SIMD<T> & Head() { return v0; }
SIMD<T> & Tail() { return v1; }
template <int NR>
SIMD<T> Get() const { return NR==0 ? v0 : v1; }
template <int NR>
SIMD<T> & Get() { return NR==0 ? v0 : v1; }
};
template <int D> NG_INLINE MultiSIMD<D,double> operator+ (MultiSIMD<D,double> a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a.Head()+b.Head(), a.Tail()+b.Tail()); }
template <int D> NG_INLINE MultiSIMD<D,double> operator+ (double a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a+b.Head(), a+b.Tail()); }
template <int D> NG_INLINE MultiSIMD<D,double> operator+ (MultiSIMD<D,double> b, double a)
{ return MultiSIMD<D,double> (a+b.Head(), a+b.Tail()); }
template <int D> NG_INLINE MultiSIMD<D,double> operator- (MultiSIMD<D,double> a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a.Head()-b.Head(), a.Tail()-b.Tail()); }
template <int D> NG_INLINE MultiSIMD<D,double> operator- (double a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a-b.Head(), a-b.Tail()); }
template <int D> NG_INLINE MultiSIMD<D,double> operator- (MultiSIMD<D,double> b, double a)
{ return MultiSIMD<D,double> (b.Head()-a, b.Tail()-a); }
template <int D> NG_INLINE MultiSIMD<D,double> operator- (MultiSIMD<D,double> a)
{ return MultiSIMD<D,double> (-a.Head(), -a.Tail()); }
template <int D> NG_INLINE MultiSIMD<D,double> operator* (MultiSIMD<D,double> a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a.Head()*b.Head(), a.Tail()*b.Tail()); }
template <int D> NG_INLINE MultiSIMD<D,double> operator/ (MultiSIMD<D,double> a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> (a.Head()/b.Head(), a.Tail()/b.Tail()); }
template <int D> NG_INLINE MultiSIMD<D,double> operator* (double a, MultiSIMD<D,double> b)
{ return MultiSIMD<D,double> ( a*b.Head(), a*b.Tail()); }
template <int D> NG_INLINE MultiSIMD<D,double> operator* (MultiSIMD<D,double> b, double a)
{ return MultiSIMD<D,double> ( a*b.Head(), a*b.Tail()); }
template <int D> NG_INLINE MultiSIMD<D,double> & operator+= (MultiSIMD<D,double> & a, MultiSIMD<D,double> b)
{ a.Head()+=b.Head(); a.Tail()+=b.Tail(); return a; }
template <int D> NG_INLINE MultiSIMD<D,double> operator-= (MultiSIMD<D,double> & a, double b)
{ a.Head()-=b; a.Tail()-=b; return a; }
template <int D> NG_INLINE MultiSIMD<D,double> operator-= (MultiSIMD<D,double> & a, MultiSIMD<D,double> b)
{ a.Head()-=b.Head(); a.Tail()-=b.Tail(); return a; }
template <int D> NG_INLINE MultiSIMD<D,double> & operator*= (MultiSIMD<D,double> & a, MultiSIMD<D,double> b)
{ a.Head()*=b.Head(); a.Tail()*=b.Tail(); return a; }
template <int D> NG_INLINE MultiSIMD<D,double> & operator*= (MultiSIMD<D,double> & a, double b)
{ a.Head()*=b; a.Tail()*=b; return a; }
// NG_INLINE MultiSIMD<double> operator/= (MultiSIMD<double> & a, MultiSIMD<double> b) { return a.Data()/=b.Data(); }
NG_INLINE SIMD<double> HVSum (SIMD<double> a) { return a; }
template <int D>
NG_INLINE SIMD<double> HVSum (MultiSIMD<D,double> a) { return a.Head() + HVSum(a.Tail()); }
template <int D> NG_INLINE double HSum (MultiSIMD<D,double> a) { return HSum(HVSum(a)); }
template <int D> NG_INLINE auto HSum (MultiSIMD<D,double> a, MultiSIMD<D,double> b)
{ return HSum(HVSum(a), HVSum(b)); }
template <int D, typename T>
std::ostream & operator<< (std::ostream & ost, MultiSIMD<D,T> multi)
{
ost << multi.Head() << " " << multi.Tail();
return ost;
}
template <typename T>
std::ostream & operator<< (std::ostream & ost, SIMD<T> simd)
{
ost << simd[0];
for (int i = 1; i < simd.Size(); i++)
ost << " " << simd[i];
return ost;
}
}
namespace netgen
{
using namespace ngsimd;
}
#endif

6
libsrc/geom2d/CMakeLists.txt
View File

@ -6,19 +6,19 @@ endif(APPLE)
if(NOT WIN32) if(NOT WIN32)
target_link_libraries(geom2d mesh ${PYTHON_LIBRARIES}) target_link_libraries(geom2d mesh ${PYTHON_LIBRARIES})
install( TARGETS geom2d ${ng_install_dir}) install( TARGETS geom2d ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)
if(USE_GUI) if(USE_GUI)
add_library(geom2dvis ${NG_LIB_TYPE} vsgeom2d.cpp) add_library(geom2dvis ${NG_LIB_TYPE} vsgeom2d.cpp)
if(NOT WIN32) if(NOT WIN32)
target_link_libraries(geom2dvis geom2d) target_link_libraries(geom2dvis geom2d)
install( TARGETS geom2dvis ${ng_install_dir}) install( TARGETS geom2dvis ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)
endif(USE_GUI) endif(USE_GUI)
install(FILES install(FILES
geom2dmesh.hpp geometry2d.hpp spline2d.hpp geom2dmesh.hpp geometry2d.hpp spline2d.hpp
splinegeometry2.hpp vsgeom2d.hpp splinegeometry2.hpp vsgeom2d.hpp
DESTINATION ${INCDIR}/geom2d COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/geom2d COMPONENT netgen_devel
) )

2
libsrc/gprim/CMakeLists.txt
View File

@ -10,5 +10,5 @@ install(FILES
adtree.hpp geom2d.hpp geom3d.hpp geomfuncs.hpp geomobjects2.hpp adtree.hpp geom2d.hpp geom3d.hpp geomfuncs.hpp geomobjects2.hpp
geomobjects.hpp geomops2.hpp geomops.hpp geomtest3d.hpp gprim.hpp geomobjects.hpp geomops2.hpp geomops.hpp geomtest3d.hpp gprim.hpp
splinegeometry.hpp spline.hpp transform3d.hpp splinegeometry.hpp spline.hpp transform3d.hpp
DESTINATION ${INCDIR}/gprim COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/gprim COMPONENT netgen_devel
) )

6
libsrc/gprim/geomobjects.hpp
View File

@ -17,7 +17,7 @@ namespace netgen
template <int D, typename T> template <int D, typename T>
class Point : public AlignedAlloc<Point<D,T>> class Point : public ngsimd::AlignedAlloc<Point<D,T>>
{ {
protected: protected:
@ -67,7 +67,7 @@ namespace netgen
}; };
template <int D, typename T> template <int D, typename T>
class Vec : public AlignedAlloc<Vec<D,T>> class Vec : public ngsimd::AlignedAlloc<Vec<D,T>>
{ {
protected: protected:
@ -150,7 +150,7 @@ namespace netgen
template <int H, int W=H, typename T = double> template <int H, int W=H, typename T = double>
class Mat : public AlignedAlloc<Mat<H,W,T>> class Mat : public ngsimd::AlignedAlloc<Mat<H,W,T>>
{ {
protected: protected:

6
libsrc/include/CMakeLists.txt
View File

@ -1,10 +1,10 @@
install(FILES nginterface.h nginterface_v2.hpp DESTINATION ${INCDIR} COMPONENT netgen_devel) install(FILES nginterface.h nginterface_v2.hpp DESTINATION ${NG_INSTALL_DIR_INCLUDE} COMPONENT netgen_devel)
install(FILES install(FILES
acisgeom.hpp csg.hpp geometry2d.hpp gprim.hpp incopengl.hpp acisgeom.hpp csg.hpp geometry2d.hpp gprim.hpp incopengl.hpp
inctcl.hpp incvis.hpp linalg.hpp meshing.hpp myadt.hpp mydefs.hpp inctcl.hpp incvis.hpp linalg.hpp meshing.hpp myadt.hpp mydefs.hpp
mystdlib.h nginterface_v2_impl.hpp occgeom.hpp mystdlib.h nginterface_v2_impl.hpp occgeom.hpp ngsimd.hpp
opti.hpp parallel.hpp parallelinterface.hpp stlgeom.hpp visual.hpp opti.hpp parallel.hpp parallelinterface.hpp stlgeom.hpp visual.hpp
DESTINATION ${INCDIR}/include COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/include COMPONENT netgen_devel
) )

16
libsrc/include/mydefs.hpp
View File

@ -36,6 +36,22 @@
#endif #endif
#ifndef NG_INLINE
#ifdef __INTEL_COMPILER
#ifdef WIN32
#define NG_INLINE __forceinline inline
#else
#define NG_INLINE __forceinline inline
#endif
#else
#ifdef __GNUC__
#define NG_INLINE __attribute__ ((__always_inline__)) inline
#define VLA
#else
#define NG_INLINE inline
#endif
#endif
#endif
// #define BASE0 // #define BASE0

5
libsrc/include/mystdlib.h
View File

@ -1,11 +1,6 @@
#ifndef FILE_MYSTDLIB #ifndef FILE_MYSTDLIB
#define FILE_MYSTDLIB #define FILE_MYSTDLIB
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <iostream> #include <iostream>
#include <iomanip> #include <iomanip>
#include <fstream> #include <fstream>

31
libsrc/include/nginterface_v2.hpp
View File

@ -78,10 +78,11 @@ namespace netgen
{ {
public: public:
size_t num; size_t num;
int base;
const int * ptr; const int * ptr;
size_t Size() const { return num; } size_t Size() const { return num; }
int operator[] (size_t i) const { return ptr[i]; } int operator[] (size_t i) const { return ptr[i]-base; }
}; };
@ -105,7 +106,7 @@ namespace netgen
double * pt; double * pt;
public: public:
Ng_Point (double * apt) : pt(apt) { ; } Ng_Point (double * apt) : pt(apt) { ; }
double operator[] (int i) double operator[] (size_t i)
{ return pt[i]; } { return pt[i]; }
operator const double * () { return pt; } operator const double * () { return pt; }
}; };
@ -121,11 +122,11 @@ namespace netgen
class Ng_Elements class Ng_Elements
{ {
public: public:
int ne; size_t ne;
const int * ptr; const int * ptr;
int Size() const { return ne; } size_t Size() const { return ne; }
int operator[] (int i) const { return ptr[i]; } int operator[] (size_t i) const { return ptr[i]; }
}; };
@ -145,8 +146,8 @@ namespace netgen
public: public:
const int * ptr; const int * ptr;
int Size() const { return 2; } size_t Size() const { return 2; }
int operator[] (int i) const { return ptr[i]-POINTINDEX_BASE; } int operator[] (size_t i) const { return ptr[i]-POINTINDEX_BASE; }
}; };
@ -162,27 +163,28 @@ namespace netgen
class Ng_Vertices class Ng_Vertices
{ {
public: public:
int nv; size_t nv;
const int * ptr; const int * ptr;
int Size() const { return nv; } size_t Size() const { return nv; }
int operator[] (int i) const { return ptr[i]-POINTINDEX_BASE; } int operator[] (size_t i) const { return ptr[i]-POINTINDEX_BASE; }
}; };
class Ng_Edges class Ng_Edges
{ {
public: public:
int ned; size_t ned;
const int * ptr; const int * ptr;
int Size() const { return ned; } size_t Size() const { return ned; }
int operator[] (int i) const { return ptr[i]-1; } int operator[] (size_t i) const { return ptr[i]-1; }
}; };
public: public:
Ng_Vertices vertices; Ng_Vertices vertices;
Ng_Edges edges; Ng_Edges edges;
int surface_el; // -1 if face not on surface
}; };
@ -269,6 +271,9 @@ namespace netgen
template <int DIM> template <int DIM>
int GetNNodes (); int GetNNodes ();
// returns domain numbers of domains next to boundary bnr -> (domin, domout)
// 3D only
// std::pair<int,int> GetBoundaryNeighbouringDomains (int bnr);
void Refine (NG_REFINEMENT_TYPE reftype, void Refine (NG_REFINEMENT_TYPE reftype,
void (*taskmanager)(function<void(int,int)>) = &DummyTaskManager2); void (*taskmanager)(function<void(int,int)>) = &DummyTaskManager2);

25
libsrc/include/nginterface_v2_impl.hpp
View File

@ -72,8 +72,14 @@ NGX_INLINE DLL_HEADER Ng_Element Ngx_Mesh :: GetElement<1> (size_t nr) const
ret.index = el.si; ret.index = el.si;
if (mesh->GetDimension() == 2) if (mesh->GetDimension() == 2)
ret.mat = mesh->GetBCNamePtr(el.si-1); ret.mat = mesh->GetBCNamePtr(el.si-1);
else
{
if (mesh->GetDimension() == 3)
ret.mat = mesh->GetCD2NamePtr(el.edgenr-1);
else else
ret.mat = nullptr; ret.mat = nullptr;
}
ret.points.num = el.GetNP(); ret.points.num = el.GetNP();
ret.points.ptr = (int*)&(el[0]); ret.points.ptr = (int*)&(el[0]);
@ -89,15 +95,14 @@ NGX_INLINE DLL_HEADER Ng_Element Ngx_Mesh :: GetElement<1> (size_t nr) const
if (mesh->GetDimension() == 2) if (mesh->GetDimension() == 2)
{ {
ret.facets.num = 1; ret.facets.num = 1;
ret.facets.base = 0;
ret.facets.ptr = (int*)ret.edges.ptr; ret.facets.ptr = (int*)ret.edges.ptr;
} }
else else
{ {
ret.facets.num = 0; ret.facets.num = 2;
ret.facets.ptr = nullptr; ret.facets.base = 1;
// not working as long as vertices are 1-based ret.facets.ptr = (int*)&(el[0]);
// ret.facets.num = 2;
// ret.facets.ptr = (int*)&(el[0]);
} }
// ret.is_curved = mesh->GetCurvedElements().IsSegmentCurved(nr); // ret.is_curved = mesh->GetCurvedElements().IsSegmentCurved(nr);
@ -109,7 +114,8 @@ NGX_INLINE DLL_HEADER Ng_Element Ngx_Mesh :: GetElement<1> (size_t nr) const
template <> template <>
NGX_INLINE DLL_HEADER Ng_Element Ngx_Mesh :: GetElement<2> (size_t nr) const NGX_INLINE DLL_HEADER Ng_Element Ngx_Mesh :: GetElement<2> (size_t nr) const
{ {
const Element2d & el = mesh->SurfaceElement (SurfaceElementIndex (nr)); // const Element2d & el = mesh->SurfaceElement (SurfaceElementIndex (nr));
const Element2d & el = mesh->SurfaceElements()[nr];
Ng_Element ret; Ng_Element ret;
ret.type = NG_ELEMENT_TYPE(el.GetType()); ret.type = NG_ELEMENT_TYPE(el.GetType());
@ -134,11 +140,13 @@ NGX_INLINE DLL_HEADER Ng_Element Ngx_Mesh :: GetElement<2> (size_t nr) const
if (mesh->GetDimension() == 3) if (mesh->GetDimension() == 3)
{ {
ret.facets.num = ret.faces.num; ret.facets.num = ret.faces.num;
ret.facets.base = 0;
ret.facets.ptr = (int*)ret.faces.ptr; ret.facets.ptr = (int*)ret.faces.ptr;
} }
else else
{ {
ret.facets.num = ret.edges.num; ret.facets.num = ret.edges.num;
ret.facets.base = 0;
ret.facets.ptr = (int*)ret.edges.ptr; ret.facets.ptr = (int*)ret.edges.ptr;
} }
ret.is_curved = el.IsCurved(); ret.is_curved = el.IsCurved();
@ -148,7 +156,8 @@ NGX_INLINE DLL_HEADER Ng_Element Ngx_Mesh :: GetElement<2> (size_t nr) const
template <> template <>
NGX_INLINE DLL_HEADER Ng_Element Ngx_Mesh :: GetElement<3> (size_t nr) const NGX_INLINE DLL_HEADER Ng_Element Ngx_Mesh :: GetElement<3> (size_t nr) const
{ {
const Element & el = mesh->VolumeElement (ElementIndex (nr)); // const Element & el = mesh->VolumeElement (ElementIndex (nr));
const Element & el = mesh->VolumeElements()[nr];
Ng_Element ret; Ng_Element ret;
ret.type = NG_ELEMENT_TYPE(el.GetType()); ret.type = NG_ELEMENT_TYPE(el.GetType());
@ -167,6 +176,7 @@ NGX_INLINE DLL_HEADER Ng_Element Ngx_Mesh :: GetElement<3> (size_t nr) const
ret.faces.ptr = (T_FACE2*)mesh->GetTopology().GetElementFacesPtr (nr); ret.faces.ptr = (T_FACE2*)mesh->GetTopology().GetElementFacesPtr (nr);
ret.facets.num = ret.faces.num; ret.facets.num = ret.faces.num;
ret.facets.base = 0;
ret.facets.ptr = (int*)ret.faces.ptr; ret.facets.ptr = (int*)ret.faces.ptr;
ret.is_curved = el.IsCurved(); ret.is_curved = el.IsCurved();
@ -264,6 +274,7 @@ template <> NGX_INLINE DLL_HEADER const Ng_Node<2> Ngx_Mesh :: GetNode<2> (int n
Ng_Node<2> node; Ng_Node<2> node;
node.vertices.ptr = mesh->GetTopology().GetFaceVerticesPtr(nr); node.vertices.ptr = mesh->GetTopology().GetFaceVerticesPtr(nr);
node.vertices.nv = (node.vertices.ptr[3] == 0) ? 3 : 4; node.vertices.nv = (node.vertices.ptr[3] == 0) ? 3 : 4;
node.surface_el = mesh->GetTopology().GetFace2SurfaceElement (nr+1)-1;
return node; return node;
} }

1
libsrc/include/ngsimd.hpp Normal file
View File

@ -0,0 +1 @@
#include <../general/ngsimd.hpp>

12
libsrc/interface/CMakeLists.txt
View File

@ -1,11 +1,5 @@
add_definitions(-DNGINTERFACE_EXPORTS) add_definitions(-DNGINTERFACE_EXPORTS)
add_library(interface ${NG_LIB_TYPE} add_library(interface ${NG_LIB_TYPE}
# $<TARGET_OBJECTS:mesh>
# $<TARGET_OBJECTS:csg>
# $<TARGET_OBJECTS:visual>
# $<TARGET_OBJECTS:la>
# $<TARGET_OBJECTS:gprim>
# $<TARGET_OBJECTS:gen>
nginterface.cpp nginterface_v2.cpp nginterface.cpp nginterface_v2.cpp
read_fnf_mesh.cpp readtetmesh.cpp readuser.cpp writeabaqus.cpp writediffpack.cpp read_fnf_mesh.cpp readtetmesh.cpp readuser.cpp writeabaqus.cpp writediffpack.cpp
writedolfin.cpp writeelmer.cpp writefeap.cpp writefluent.cpp writegmsh.cpp writejcm.cpp writedolfin.cpp writeelmer.cpp writefeap.cpp writefluent.cpp writegmsh.cpp writejcm.cpp
@ -13,17 +7,15 @@ add_library(interface ${NG_LIB_TYPE}
wuchemnitz.cpp writegmsh2.cpp writeOpenFOAM15x.cpp wuchemnitz.cpp writegmsh2.cpp writeOpenFOAM15x.cpp
) )
# TARGET_LINK_LIBRARIES(interface ${MPI_CXX_LIBRARIES} ${PYTHON_LIBS})
# TARGET_LINK_LIBRARIES( interface ${LIBPTHREAD} ${OCC_LIBRARIES} ${LIBTOGL} ${MPI_CXX_LIBRARIES} ${OPENGL_LIBRARIES} ${TK_LIBRARY} ${TCL_LIBRARY} ${CMAKE_THREAD_LIBS_INIT} ${X11_Xmu_LIB} ${JPEG_LIBRARIES} ${MKL_LIBRARIES} ${ZLIB_LIBRARIES} )
if(NOT WIN32) if(NOT WIN32)
target_link_libraries(interface mesh csg geom2d) target_link_libraries(interface mesh csg geom2d)
if(USE_GUI) if(USE_GUI)
target_link_libraries(interface visual) target_link_libraries(interface visual)
endif(USE_GUI) endif(USE_GUI)
install( TARGETS interface ${ng_install_dir}) install( TARGETS interface ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)
install(FILES install(FILES
writeuser.hpp writeuser.hpp
DESTINATION ${INCDIR}/interface COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/interface COMPONENT netgen_devel
) )

3
libsrc/interface/nginterface.cpp
View File

@ -108,7 +108,8 @@ void Ng_LoadMeshFromStream ( istream & input )
break; break;
} }
} }
if (!ng_geometry)
ng_geometry = make_shared<NetgenGeometry>();
mesh->SetGeometry (ng_geometry); mesh->SetGeometry (ng_geometry);
} }

8
libsrc/interface/nginterface_v2.cpp
View File

@ -757,7 +757,7 @@ namespace netgen
double hdxdxi[4][3]; double hdxdxi[4][3];
for (int j = 0; j<4;j++) for (int j = 0; j<4;j++)
hxi[j][0] = ((double*)&(xi[0]))[j]; hxi[j][0] = ((double*)&(xi[0]))[j];
MultiElementTransformation<1,3> (elnr, 4, &hxi[0][0], 1, &hx[0][0], 2, &hdxdxi[0][0],4); MultiElementTransformation<1,3> (elnr, 4, &hxi[0][0], 1, &hx[0][0], 3, &hdxdxi[0][0],3);
for(int j=0; j<4; j++) for(int j=0; j<4; j++)
for(int k=0; k<3; k++) for(int k=0; k<3; k++)
((double*)&(x[k]))[j] = hx[j][k]; ((double*)&(x[k]))[j] = hx[j][k];
@ -780,16 +780,16 @@ namespace netgen
{ {
double hxi[4][1]; double hxi[4][1];
double hx[4][2]; double hx[4][2];
double hdxdxi[4][4]; double hdxdxi[4][2];
for (int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
for (int k = 0; k < 1; k++) for (int k = 0; k < 1; k++)
hxi[j][k] = ((double*)&(xi[k]))[j]; hxi[j][k] = ((double*)&(xi[k]))[j];
MultiElementTransformation<1,2> (elnr, 4, &hxi[0][0], 1, &hx[0][0], 2, &hdxdxi[0][0], 4); MultiElementTransformation<1,2> (elnr, 4, &hxi[0][0], 1, &hx[0][0], 2, &hdxdxi[0][0], 2);
for (int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
for (int k = 0; k < 2; k++) for (int k = 0; k < 2; k++)
((double*)&(x[k]))[j] = hx[j][k]; ((double*)&(x[k]))[j] = hx[j][k];
for (int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
for (int k = 0; k < 4; k++) for (int k = 0; k < 2; k++)
((double*)&(dxdxi[k]))[j] = hdxdxi[j][k]; ((double*)&(dxdxi[k]))[j] = hdxdxi[j][k];
xi += sxi; xi += sxi;

2
libsrc/linalg/CMakeLists.txt
View File

@ -7,5 +7,5 @@ set_target_properties(la PROPERTIES POSITION_INDEPENDENT_CODE ON )
install(FILES install(FILES
densemat.hpp linalg.hpp opti.hpp densemat.hpp linalg.hpp opti.hpp
polynomial.hpp vector.hpp polynomial.hpp vector.hpp
DESTINATION ${INCDIR}/linalg COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/linalg COMPONENT netgen_devel
) )

5
libsrc/meshing/CMakeLists.txt
View File

@ -21,6 +21,7 @@ add_library(mesh ${NG_LIB_TYPE}
topology.cpp triarls.cpp validate.cpp bcfunctions.cpp topology.cpp triarls.cpp validate.cpp bcfunctions.cpp
parallelmesh.cpp paralleltop.cpp paralleltop.hpp basegeom.cpp parallelmesh.cpp paralleltop.cpp paralleltop.hpp basegeom.cpp
python_mesh.cpp hexarls.cpp python_mesh.cpp hexarls.cpp
../../ng/onetcl.cpp
${mesh_object_libs} ${mesh_object_libs}
) )
@ -30,7 +31,7 @@ endif(APPLE)
if(NOT WIN32) if(NOT WIN32)
target_link_libraries( mesh ${ZLIB_LIBRARIES} ${MPI_CXX_LIBRARIES} ${PYTHON_LIBRARIES} ${METIS_LIBRARY}) target_link_libraries( mesh ${ZLIB_LIBRARIES} ${MPI_CXX_LIBRARIES} ${PYTHON_LIBRARIES} ${METIS_LIBRARY})
install( TARGETS mesh ${ng_install_dir}) install( TARGETS mesh ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)
install(FILES install(FILES
@ -42,5 +43,5 @@ install(FILES
localh.hpp meshclass.hpp meshfunc.hpp meshing2.hpp meshing3.hpp localh.hpp meshclass.hpp meshfunc.hpp meshing2.hpp meshing3.hpp
meshing.hpp meshtool.hpp meshtype.hpp msghandler.hpp paralleltop.hpp meshing.hpp meshtool.hpp meshtype.hpp msghandler.hpp paralleltop.hpp
ruler2.hpp ruler3.hpp specials.hpp topology.hpp validate.hpp ruler2.hpp ruler3.hpp specials.hpp topology.hpp validate.hpp
DESTINATION ${INCDIR}/meshing COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/meshing COMPONENT netgen_devel
) )

134
libsrc/meshing/bisect.cpp
View File

@ -44,10 +44,17 @@ namespace netgen
bool incorder; bool incorder;
unsigned int order:6; unsigned int order:6;
MarkedTet() MarkedTet() = default;
/*
{ {
for (int i = 0; i < 4; i++) { faceedges[i] = 255; } for (int i = 0; i < 4; i++) { faceedges[i] = 127; }
} }
*/
MarkedTet (const MarkedTet&) = default;
MarkedTet (MarkedTet &&) = default;
MarkedTet & operator= (const MarkedTet&) = default;
MarkedTet & operator= (MarkedTet&&) = default;
}; };
ostream & operator<< (ostream & ost, const MarkedTet & mt) ostream & operator<< (ostream & ost, const MarkedTet & mt)
@ -178,6 +185,12 @@ namespace netgen
class MarkedTri class MarkedTri
{ {
public: public:
MarkedTri () = default;
MarkedTri (const MarkedTri&) = default;
MarkedTri (MarkedTri &&) = default;
MarkedTri & operator= (const MarkedTri&) = default;
MarkedTri & operator= (MarkedTri&&) = default;
/// three point numbers /// three point numbers
PointIndex pnums[3]; PointIndex pnums[3];
/// three geominfos /// three geominfos
@ -1657,16 +1670,25 @@ namespace netgen
int MarkHangingTets (T_MTETS & mtets, int MarkHangingTets (T_MTETS & mtets,
const INDEX_2_CLOSED_HASHTABLE<PointIndex> & cutedges) const INDEX_2_CLOSED_HASHTABLE<PointIndex> & cutedges,
TaskManager tm)
{ {
static int timer = NgProfiler::CreateTimer ("MarkHangingTets");
NgProfiler::RegionTimer reg (timer);
int hanging = 0; int hanging = 0;
for (int i = 1; i <= mtets.Size(); i++) // for (int i = 1; i <= mtets.Size(); i++)
ParallelForRange
(tm, mtets.Size(), [&] (size_t begin, size_t end)
{ {
MarkedTet & teti = mtets.Elem(i); bool my_hanging = false;
for (size_t i = begin; i < end; i++)
{
MarkedTet & teti = mtets[i];
if (teti.marked) if (teti.marked)
{ {
hanging = 1; my_hanging = true;
continue; continue;
} }
@ -1679,10 +1701,12 @@ namespace netgen
if (cutedges.Used (edge)) if (cutedges.Used (edge))
{ {
teti.marked = 1; teti.marked = 1;
hanging = 1; my_hanging = true;
} }
} }
} }
if (my_hanging) hanging = true;
});
return hanging; return hanging;
} }
@ -1723,30 +1747,40 @@ namespace netgen
int MarkHangingTris (T_MTRIS & mtris, bool MarkHangingTris (T_MTRIS & mtris,
const INDEX_2_CLOSED_HASHTABLE<PointIndex> & cutedges) const INDEX_2_CLOSED_HASHTABLE<PointIndex> & cutedges,
TaskManager tm)
{ {
int hanging = 0; bool hanging = false;
for (int i = 1; i <= mtris.Size(); i++) // for (int i = 1; i <= mtris.Size(); i++)
// for (auto & tri : mtris)
ParallelForRange
(tm, mtris.Size(), [&] (size_t begin, size_t end)
{ {
if (mtris.Get(i).marked) bool my_hanging = false;
for (size_t i = begin; i < end; i++)
{ {
hanging = 1; auto & tri = mtris[i];
if (tri.marked)
{
my_hanging = true;
continue; continue;
} }
for (int j = 0; j < 2; j++) for (int j = 0; j < 2; j++)
for (int k = j+1; k < 3; k++) for (int k = j+1; k < 3; k++)
{ {
INDEX_2 edge(mtris.Get(i).pnums[j], INDEX_2 edge(tri.pnums[j],
mtris.Get(i).pnums[k]); tri.pnums[k]);
edge.Sort(); edge.Sort();
if (cutedges.Used (edge)) if (cutedges.Used (edge))
{ {
mtris.Elem(i).marked = 1; tri.marked = 1;
hanging = 1; my_hanging = true;
} }
} }
} }
if (my_hanging) hanging = true;
});
return hanging; return hanging;
} }
@ -2620,14 +2654,22 @@ namespace netgen
static int timer = NgProfiler::CreateTimer ("Bisect"); static int timer = NgProfiler::CreateTimer ("Bisect");
static int timer1 = NgProfiler::CreateTimer ("Bisect 1"); static int timer1 = NgProfiler::CreateTimer ("Bisect 1");
static int timer1a = NgProfiler::CreateTimer ("Bisect 1a");
static int timer1b = NgProfiler::CreateTimer ("Bisect 1b");
static int timer2 = NgProfiler::CreateTimer ("Bisect 2"); static int timer2 = NgProfiler::CreateTimer ("Bisect 2");
static int timer2a = NgProfiler::CreateTimer ("Bisect 2a");
static int timer2b = NgProfiler::CreateTimer ("Bisect 2b");
static int timer2c = NgProfiler::CreateTimer ("Bisect 2c");
static int timer3 = NgProfiler::CreateTimer ("Bisect 3"); static int timer3 = NgProfiler::CreateTimer ("Bisect 3");
static int timer3a = NgProfiler::CreateTimer ("Bisect 3a");
static int timer3b = NgProfiler::CreateTimer ("Bisect 3b");
static int timer_bisecttet = NgProfiler::CreateTimer ("Bisect tets"); static int timer_bisecttet = NgProfiler::CreateTimer ("Bisect tets");
static int timer_bisecttrig = NgProfiler::CreateTimer ("Bisect trigs"); static int timer_bisecttrig = NgProfiler::CreateTimer ("Bisect trigs");
static int timer_bisectsegms = NgProfiler::CreateTimer ("Bisect segms");
NgProfiler::RegionTimer reg1 (timer); NgProfiler::RegionTimer reg1 (timer);
NgProfiler::StartTimer (timer1); NgProfiler::StartTimer (timer1);
NgProfiler::StartTimer (timer1a);
static int localizetimer = NgProfiler::CreateTimer("localize edgepoints"); static int localizetimer = NgProfiler::CreateTimer("localize edgepoints");
NgProfiler::RegionTimer * loct = new NgProfiler::RegionTimer(localizetimer); NgProfiler::RegionTimer * loct = new NgProfiler::RegionTimer(localizetimer);
LocalizeEdgePoints(mesh); LocalizeEdgePoints(mesh);
@ -2756,6 +2798,7 @@ namespace netgen
INDEX_2_CLOSED_HASHTABLE<PointIndex> cutedges(10 + 9 * (mtets.Size()+mprisms.Size()+mtris.Size()+mquads.Size())); INDEX_2_CLOSED_HASHTABLE<PointIndex> cutedges(10 + 9 * (mtets.Size()+mprisms.Size()+mtris.Size()+mquads.Size()));
bool noprojection = false; bool noprojection = false;
NgProfiler::StopTimer (timer1a);
for (int l = 1; l <= 1; l++) for (int l = 1; l <= 1; l++)
{ {
@ -3169,7 +3212,6 @@ namespace netgen
//string yn; //string yn;
//cin >> yn; //cin >> yn;
NgProfiler::StopTimer (timer1);
(*testout) << "refine volume elements" << endl; (*testout) << "refine volume elements" << endl;
do do
@ -3312,7 +3354,7 @@ namespace netgen
hangingvol = hangingvol =
MarkHangingTets (mtets, cutedges) + MarkHangingTets (mtets, cutedges, opt.task_manager) +
MarkHangingPrisms (mprisms, cutedges) + MarkHangingPrisms (mprisms, cutedges) +
MarkHangingIdentifications (mids, cutedges); MarkHangingIdentifications (mids, cutedges);
@ -3370,6 +3412,9 @@ namespace netgen
mesh.mlparentsurfaceelement.Append (i); mesh.mlparentsurfaceelement.Append (i);
} }
NgProfiler::StopTimer (timer_bisecttrig);
int nquad = mquads.Size(); int nquad = mquads.Size();
for (int i = 1; i <= nquad; i++) for (int i = 1; i <= nquad; i++)
if (mquads.Elem(i).marked) if (mquads.Elem(i).marked)
@ -3462,14 +3507,14 @@ namespace netgen
mquads.Append (newquad2); mquads.Append (newquad2);
} }
NgProfiler::StopTimer (timer_bisecttrig); NgProfiler::StartTimer (timer1b);
hangingsurf = hangingsurf =
MarkHangingTris (mtris, cutedges) + MarkHangingTris (mtris, cutedges, opt.task_manager) +
MarkHangingQuads (mquads, cutedges); MarkHangingQuads (mquads, cutedges);
hangingedge = 0; hangingedge = 0;
NgProfiler::StopTimer (timer1b);
NgProfiler::StartTimer (timer_bisectsegms);
int nseg = mesh.GetNSeg (); int nseg = mesh.GetNSeg ();
for (int i = 1; i <= nseg; i++) for (int i = 1; i <= nseg; i++)
{ {
@ -3506,6 +3551,8 @@ namespace netgen
mesh.AddSegment (nseg2); mesh.AddSegment (nseg2);
} }
} }
NgProfiler::StopTimer (timer_bisectsegms);
} }
while (hangingvol || hangingsurf || hangingedge); while (hangingvol || hangingsurf || hangingedge);
@ -3534,6 +3581,8 @@ namespace netgen
PrintMessage (4, mesh.GetNP(), " points"); PrintMessage (4, mesh.GetNP(), " points");
} }
NgProfiler::StopTimer (timer1);
// (*testout) << "mtets = " << mtets << endl; // (*testout) << "mtets = " << mtets << endl;
@ -3580,6 +3629,8 @@ namespace netgen
NgProfiler::StartTimer (timer2); NgProfiler::StartTimer (timer2);
NgProfiler::StartTimer (timer2a);
mtets.SetAllocSize (mtets.Size()); mtets.SetAllocSize (mtets.Size());
mprisms.SetAllocSize (mprisms.Size()); mprisms.SetAllocSize (mprisms.Size());
mids.SetAllocSize (mids.Size()); mids.SetAllocSize (mids.Size());
@ -3654,15 +3705,18 @@ namespace netgen
} }
mesh.ClearSurfaceElements(); mesh.ClearSurfaceElements();
for (int i = 1; i <= mtris.Size(); i++) mesh.SurfaceElements().SetAllocSize (mtris.Size()+mquads.Size());
NgProfiler::StopTimer (timer2a);
NgProfiler::StartTimer (timer2b);
for (auto & trig : mtris)
{ {
Element2d el(TRIG); Element2d el(TRIG);
el.SetIndex (mtris.Get(i).surfid); el.SetIndex (trig.surfid);
el.SetOrder (mtris.Get(i).order); el.SetOrder (trig.order);
for (int j = 1; j <= 3; j++) for (int j = 0; j < 3; j++)
{ {
el.PNum(j) = mtris.Get(i).pnums[j-1]; el[j] = trig.pnums[j];
el.GeomInfoPi(j) = mtris.Get(i).pgeominfo[j-1]; el.GeomInfoPi(j+1) = trig.pgeominfo[j];
} }
mesh.AddSurfaceElement (el); mesh.AddSurfaceElement (el);
} }
@ -3675,7 +3729,7 @@ namespace netgen
Swap (el.PNum(3), el.PNum(4)); Swap (el.PNum(3), el.PNum(4));
mesh.AddSurfaceElement (el); mesh.AddSurfaceElement (el);
} }
NgProfiler::StopTimer (timer2b);
// write multilevel hierarchy to mesh: // write multilevel hierarchy to mesh:
@ -3705,12 +3759,12 @@ namespace netgen
BitArray isnewpoint(np); BitArray isnewpoint(np);
isnewpoint.Clear(); isnewpoint.Clear();
for (int i = 1; i <= cutedges.Size(); i++) for (int i = 0; i < cutedges.Size(); i++)
if (cutedges.UsedPos(i)) if (cutedges.UsedPos0(i))
{ {
INDEX_2 edge; INDEX_2 edge;
PointIndex newpi; PointIndex newpi;
cutedges.GetData (i, edge, newpi); cutedges.GetData0 (i, edge, newpi);
isnewpoint.Set(newpi); isnewpoint.Set(newpi);
mesh.mlbetweennodes.Elem(newpi) = edge; mesh.mlbetweennodes.Elem(newpi) = edge;
} }
@ -3811,12 +3865,12 @@ namespace netgen
} }
*/ */
for (int j = 1; j <= cutedges.Size(); j++) for (int j = 0; j < cutedges.Size(); j++)
if (cutedges.UsedPos(j)) if (cutedges.UsedPos0(j))
{ {
INDEX_2 i2; INDEX_2 i2;
PointIndex newpi; PointIndex newpi;
cutedges.GetData (j, i2, newpi); cutedges.GetData0 (j, i2, newpi);
INDEX_2 oi2(identmap.Get(i2.I1()), INDEX_2 oi2(identmap.Get(i2.I1()),
identmap.Get(i2.I2())); identmap.Get(i2.I2()));
oi2.Sort(); oi2.Sort();
@ -3961,8 +4015,9 @@ namespace netgen
NgProfiler::StopTimer (timer2); NgProfiler::StopTimer (timer2);
NgProfiler::StartTimer (timer3); NgProfiler::StartTimer (timer3);
NgProfiler::StartTimer (timer3a);
mesh.UpdateTopology(opt.task_manager); mesh.UpdateTopology(opt.task_manager);
NgProfiler::StopTimer (timer3a);
@ -3976,8 +4031,9 @@ namespace netgen
ofst.close(); ofst.close();
} }
NgProfiler::StartTimer (timer3b);
mesh.CalcSurfacesOfNode(); mesh.CalcSurfacesOfNode();
NgProfiler::StopTimer (timer3b);
PrintMessage (1, "Bisection done"); PrintMessage (1, "Bisection done");

38
libsrc/meshing/clusters.cpp
View File

@ -21,6 +21,7 @@ namespace netgen
static int timer = NgProfiler::CreateTimer ("clusters"); static int timer = NgProfiler::CreateTimer ("clusters");
static int timer1 = NgProfiler::CreateTimer ("clusters1"); static int timer1 = NgProfiler::CreateTimer ("clusters1");
static int timer2 = NgProfiler::CreateTimer ("clusters2"); static int timer2 = NgProfiler::CreateTimer ("clusters2");
static int timer3 = NgProfiler::CreateTimer ("clusters3");
NgProfiler::RegionTimer reg (timer); NgProfiler::RegionTimer reg (timer);
const MeshTopology & top = mesh.GetTopology(); const MeshTopology & top = mesh.GetTopology();
@ -110,7 +111,7 @@ namespace netgen
NgProfiler::StopTimer(timer1); NgProfiler::StopTimer(timer1);
NgProfiler::StartTimer(timer2); NgProfiler::StartTimer(timer2);
/*
for (int i = 1; i <= nse; i++) for (int i = 1; i <= nse; i++)
{ {
const Element2d & el = mesh.SurfaceElement(i); const Element2d & el = mesh.SurfaceElement(i);
@ -132,6 +133,39 @@ namespace netgen
for (int j = 0; j < nnums.Size(); j++) for (int j = 0; j < nnums.Size(); j++)
cluster_reps.Elem(nnums[j]) = nnums[j]; cluster_reps.Elem(nnums[j]) = nnums[j];
} }
*/
ParallelForRange
(tm, nse,
[&] (size_t begin, size_t end)
{
ArrayMem<int,9> nnums, ednums;
for (int i = begin+1; i <= end; i++)
{
const Element2d & el = mesh.SurfaceElement(i);
ELEMENT_TYPE typ = el.GetType();
top.GetSurfaceElementEdges (i, ednums);
int fanum = top.GetSurfaceElementFace (i);
int elnv = top.GetNVertices (typ);
int elned = ednums.Size();
nnums.SetSize(elnv+elned+1);
for (int j = 1; j <= elnv; j++)
nnums.Elem(j) = el.PNum(j)+1-PointIndex::BASE;
for (int j = 1; j <= elned; j++)
nnums.Elem(elnv+j) = nv+ednums.Elem(j);
nnums.Elem(elnv+elned+1) = fanum;
for (int j = 0; j < nnums.Size(); j++)
cluster_reps.Elem(nnums[j]) = nnums[j];
}
});
NgProfiler::StopTimer(timer2);
NgProfiler::StartTimer(timer3);
static const int hex_cluster[] = static const int hex_cluster[] =
{ {
@ -300,7 +334,7 @@ namespace netgen
} }
} }
while (changed); while (changed);
NgProfiler::StopTimer(timer2); NgProfiler::StopTimer(timer3);
/* /*
(*testout) << "cluster reps:" << endl; (*testout) << "cluster reps:" << endl;
for (i = 1; i <= cluster_reps.Size(); i++) for (i = 1; i <= cluster_reps.Size(); i++)

8
libsrc/meshing/global.cpp
View File

@ -27,7 +27,9 @@ namespace netgen
global_mesh = m; global_mesh = m;
} }
// true if netgen was started using the netgen executable
// false if netgen.gui was imported from python
DLL_HEADER bool netgen_executable_started = false;
// Flags parameters; // Flags parameters;
int silentflag = 0; int silentflag = 0;
@ -88,7 +90,8 @@ namespace netgen
DebugParameters debugparam; DebugParameters debugparam;
bool verbose = 0; bool verbose = 0;
int timestamp = 0; size_t timestamp = 0;
/*
int GetTimeStamp() int GetTimeStamp()
{ {
return timestamp; return timestamp;
@ -99,4 +102,5 @@ namespace netgen
timestamp++; timestamp++;
return timestamp; return timestamp;
} }
*/
} }

2
libsrc/meshing/improve3.cpp
View File

@ -455,7 +455,7 @@ void MeshOptimize3d :: SplitImprove (Mesh & mesh,
if (el[l] == pi1 || el[l] == pi2) if (el[l] == pi1 || el[l] == pi2)
{ {
INDEX_3 i3; INDEX_3 i3;
Element2d face; Element2d face(TRIG);
el.GetFace (l+1, face); el.GetFace (l+1, face);
for (int kk = 1; kk <= 3; kk++) for (int kk = 1; kk <= 3; kk++)
i3.I(kk) = face.PNum(kk); i3.I(kk) = face.PNum(kk);

53
libsrc/meshing/meshclass.cpp
View File

@ -116,7 +116,7 @@ namespace netgen
surfelements.SetSize(0); surfelements.SetSize(0);
volelements.SetSize(0); volelements.SetSize(0);
lockedpoints.SetSize(0); lockedpoints.SetSize(0);
surfacesonnode.SetSize(0); // surfacesonnode.SetSize(0);
delete boundaryedges; delete boundaryedges;
boundaryedges = NULL; boundaryedges = NULL;
@ -926,7 +926,7 @@ namespace netgen
PrintMessage (3, n, " volume elements"); PrintMessage (3, n, " volume elements");
for (i = 1; i <= n; i++) for (i = 1; i <= n; i++)
{ {
Element el; Element el(TET);
int hi, nep; int hi, nep;
infile >> hi; infile >> hi;
if (hi == 0) hi = 1; if (hi == 0) hi = 1;
@ -1423,7 +1423,7 @@ namespace netgen
PrintMessage (3, n, " volume elements"); PrintMessage (3, n, " volume elements");
for (i = 1; i <= n; i++) for (i = 1; i <= n; i++)
{ {
Element el; Element el(TET);
int hi, nep; int hi, nep;
infile >> hi; infile >> hi;
if (hi == 0) hi = 1; if (hi == 0) hi = 1;
@ -1593,12 +1593,14 @@ namespace netgen
void Mesh :: CalcSurfacesOfNode () void Mesh :: CalcSurfacesOfNode ()
{ {
surfacesonnode.SetSize (GetNP()); // surfacesonnode.SetSize (GetNP());
TABLE<int,PointIndex::BASE> surfacesonnode(GetNP());
delete boundaryedges; delete boundaryedges;
boundaryedges = NULL; boundaryedges = NULL;
delete surfelementht; delete surfelementht;
surfelementht = nullptr;
delete segmentht; delete segmentht;
/* /*
@ -1606,9 +1608,11 @@ namespace netgen
segmentht = new INDEX_2_HASHTABLE<int> (GetNSeg() + 1); segmentht = new INDEX_2_HASHTABLE<int> (GetNSeg() + 1);
*/ */
if (dimension == 3)
surfelementht = new INDEX_3_CLOSED_HASHTABLE<int> (3*GetNSE() + 1); surfelementht = new INDEX_3_CLOSED_HASHTABLE<int> (3*GetNSE() + 1);
segmentht = new INDEX_2_CLOSED_HASHTABLE<int> (3*GetNSeg() + 1); segmentht = new INDEX_2_CLOSED_HASHTABLE<int> (3*GetNSeg() + 1);
if (dimension == 3)
for (SurfaceElementIndex sei = 0; sei < GetNSE(); sei++) for (SurfaceElementIndex sei = 0; sei < GetNSE(); sei++)
{ {
const Element2d & sel = surfelements[sei]; const Element2d & sel = surfelements[sei];
@ -1619,6 +1623,9 @@ namespace netgen
for (int j = 0; j < sel.GetNP(); j++) for (int j = 0; j < sel.GetNP(); j++)
{ {
PointIndex pi = sel[j]; PointIndex pi = sel[j];
if (!surfacesonnode[pi].Contains(si))
surfacesonnode.Add (pi, si);
/*
bool found = 0; bool found = 0;
for (int k = 0; k < surfacesonnode[pi].Size(); k++) for (int k = 0; k < surfacesonnode[pi].Size(); k++)
if (surfacesonnode[pi][k] == si) if (surfacesonnode[pi][k] == si)
@ -1629,6 +1636,7 @@ namespace netgen
if (!found) if (!found)
surfacesonnode.Add (pi, si); surfacesonnode.Add (pi, si);
*/
} }
} }
/* /*
@ -1647,6 +1655,8 @@ namespace netgen
surfelementht -> AllocateElements(); surfelementht -> AllocateElements();
*/ */
if (dimension==3)
for (SurfaceElementIndex sei = 0; sei < GetNSE(); sei++) for (SurfaceElementIndex sei = 0; sei < GetNSE(); sei++)
{ {
const Element2d & sel = surfelements[sei]; const Element2d & sel = surfelements[sei];
@ -1891,7 +1901,7 @@ namespace netgen
int ii; int ii;
PointIndex pi; PointIndex pi;
SurfaceElementIndex sei; SurfaceElementIndex sei;
Element2d hel; // Element2d hel;
INDEX_3_CLOSED_HASHTABLE<INDEX_2> faceht(100); INDEX_3_CLOSED_HASHTABLE<INDEX_2> faceht(100);
@ -1905,7 +1915,7 @@ namespace netgen
FlatArray<SurfaceElementIndex> row = selsonpoint[pi]; FlatArray<SurfaceElementIndex> row = selsonpoint[pi];
for (ii = 0; ii < row.Size(); ii++) for (ii = 0; ii < row.Size(); ii++)
{ {
hel = SurfaceElement(row[ii]); Element2d hel = SurfaceElement(row[ii]);
if (hel.GetType() == TRIG6) hel.SetType(TRIG); if (hel.GetType() == TRIG6) hel.SetType(TRIG);
int ind = hel.GetIndex(); int ind = hel.GetIndex();
@ -1950,6 +1960,7 @@ namespace netgen
{ {
for (int j = 1; j <= el.GetNFaces(); j++) for (int j = 1; j <= el.GetNFaces(); j++)
{ {
Element2d hel(TRIG);
el.GetFace (j, hel); el.GetFace (j, hel);
hel.Invert(); hel.Invert();
hel.NormalizeNumbering(); hel.NormalizeNumbering();
@ -2004,8 +2015,9 @@ namespace netgen
faceht.GetData (i, i3, i2); faceht.GetData (i, i3, i2);
if (i2.I1() != PointIndex::BASE-1) if (i2.I1() != PointIndex::BASE-1)
{ {
Element2d tri; // Element2d tri;
tri.SetType ( (i2.I2() == PointIndex::BASE-1) ? TRIG : QUAD); // tri.SetType ( (i2.I2() == PointIndex::BASE-1) ? TRIG : QUAD);
Element2d tri ( (i2.I2() == PointIndex::BASE-1) ? TRIG : QUAD);
for (int l = 0; l < 3; l++) for (int l = 0; l < 3; l++)
tri[l] = i3.I(l+1); tri[l] = i3.I(l+1);
tri.PNum(4) = i2.I2(); tri.PNum(4) = i2.I2();
@ -3665,11 +3677,11 @@ namespace netgen
{ {
bool sege = false, be = false; bool sege = false, be = false;
int pos = boundaryedges -> Position(INDEX_2::Sort(el[i], el[j])); int pos = boundaryedges -> Position0(INDEX_2::Sort(el[i], el[j]));
if (pos) if (pos != -1)
{ {
be = true; be = true;
if (boundaryedges -> GetData(pos) == 2) if (boundaryedges -> GetData0(pos) == 2)
sege = true; sege = true;
} }
@ -5351,7 +5363,7 @@ namespace netgen
// angles in faces // angles in faces
for (j = 1; j <= 4; j++) for (j = 1; j <= 4; j++)
{ {
Element2d face; Element2d face(TRIG);
el.GetFace (j, face); el.GetFace (j, face);
for (lpi1 = 1; lpi1 <= 3; lpi1++) for (lpi1 = 1; lpi1 <= 3; lpi1++)
{ {
@ -5545,6 +5557,7 @@ namespace netgen
if (el[j] > numvertices) if (el[j] > numvertices)
numvertices = el[j]; numvertices = el[j];
} }
/*
for (i = 1; i <= nse; i++) for (i = 1; i <= nse; i++)
{ {
const Element2d & el = SurfaceElement(i); const Element2d & el = SurfaceElement(i);
@ -5553,6 +5566,10 @@ namespace netgen
if (el.PNum(j) > numvertices) if (el.PNum(j) > numvertices)
numvertices = el.PNum(j); numvertices = el.PNum(j);
} }
*/
for (auto & el : SurfaceElements())
for (PointIndex v : el.Vertices())
if (v > numvertices) numvertices = v;
numvertices += 1- PointIndex::BASE; numvertices += 1- PointIndex::BASE;
} }
@ -5741,8 +5758,8 @@ namespace netgen
{ {
int olds = materials.Size(); int olds = materials.Size();
materials.SetSize (domnr); materials.SetSize (domnr);
for (int i = olds; i < domnr; i++) for (int i = olds; i < domnr-1; i++)
materials[i] = 0; materials[i] = new string("default");
} }
/* /*
materials.Elem(domnr) = new char[strlen(mat)+1]; materials.Elem(domnr) = new char[strlen(mat)+1];
@ -5751,11 +5768,12 @@ namespace netgen
materials.Elem(domnr) = new string(mat); materials.Elem(domnr) = new string(mat);
} }
string Mesh :: defaultmat = "default";
const string & Mesh :: GetMaterial (int domnr) const const string & Mesh :: GetMaterial (int domnr) const
{ {
if (domnr <= materials.Size()) if (domnr <= materials.Size())
return *materials.Get(domnr); return *materials.Get(domnr);
static string emptystring; static string emptystring("default");
return emptystring; return emptystring;
} }
@ -5832,6 +5850,7 @@ namespace netgen
cd2names[cd2nr] = nullptr; cd2names[cd2nr] = nullptr;
} }
string Mesh :: cd2_default_name = "default";
const string & Mesh :: GetCD2Name (int cd2nr) const const string & Mesh :: GetCD2Name (int cd2nr) const
{ {
static string defaultstring = "default"; static string defaultstring = "default";
@ -5916,8 +5935,8 @@ namespace netgen
<< sizeof (Element) << " = " << sizeof (Element) << " = "
<< GetNE() * sizeof(Element) << endl; << GetNE() * sizeof(Element) << endl;
ost << "surfs on node:"; // ost << "surfs on node:";
surfacesonnode.PrintMemInfo (cout); // surfacesonnode.PrintMemInfo (cout);
ost << "boundaryedges: "; ost << "boundaryedges: ";
if (boundaryedges) if (boundaryedges)

18
libsrc/meshing/meshclass.hpp
View File

@ -24,8 +24,9 @@ namespace netgen
{ {
public: public:
typedef ::netgen::T_POINTS T_POINTS; typedef ::netgen::T_POINTS T_POINTS;
typedef Array<Element, 0, ElementIndex> T_VOLELEMENTS; typedef Array<Element, 0, size_t> T_VOLELEMENTS;
typedef Array<Element2d, 0, SurfaceElementIndex> T_SURFELEMENTS; // typedef Array<Element2d, 0, SurfaceElementIndex> T_SURFELEMENTS;
typedef Array<Element2d, 0, size_t> T_SURFELEMENTS;
private: private:
/// point coordinates /// point coordinates
@ -42,7 +43,7 @@ namespace netgen
/// surface indices at boundary nodes /// surface indices at boundary nodes
TABLE<int,PointIndex::BASE> surfacesonnode; // TABLE<int,PointIndex::BASE> surfacesonnode;
/// boundary edges (1..normal bedge, 2..segment) /// boundary edges (1..normal bedge, 2..segment)
INDEX_2_CLOSED_HASHTABLE<int> * boundaryedges; INDEX_2_CLOSED_HASHTABLE<int> * boundaryedges;
/// ///
@ -592,8 +593,11 @@ namespace netgen
DLL_HEADER void SetMaterial (int domnr, const string & mat); DLL_HEADER void SetMaterial (int domnr, const string & mat);
/// ///
const string & GetMaterial (int domnr) const; const string & GetMaterial (int domnr) const;
static string defaultmat;
const string * GetMaterialPtr (int domnr) const // 1-based const string * GetMaterialPtr (int domnr) const // 1-based
{ return domnr <= materials.Size() ? materials.Get(domnr) : nullptr; } {
return domnr <= materials.Size() ? materials.Get(domnr) : &defaultmat;
}
DLL_HEADER void SetNBCNames ( int nbcn ); DLL_HEADER void SetNBCNames ( int nbcn );
@ -605,6 +609,12 @@ namespace netgen
DLL_HEADER void SetCD2Name (int cd2nr, const string & abcname); DLL_HEADER void SetCD2Name (int cd2nr, const string & abcname);
const string & GetCD2Name (int cd2nr ) const; const string & GetCD2Name (int cd2nr ) const;
static string cd2_default_name;
string * GetCD2NamePtr (int cd2nr ) const
{
if (cd2nr < cd2names.Size() && cd2names[cd2nr]) return cd2names[cd2nr];
return &cd2_default_name;
}
size_t GetNCD2Names() const { return cd2names.Size(); } size_t GetNCD2Names() const { return cd2names.Size(); }
string * GetBCNamePtr (int bcnr) const string * GetBCNamePtr (int bcnr) const

56
libsrc/meshing/meshing3.cpp
View File

@ -109,7 +109,7 @@ static double CalcLocH (const Array<Point3d> & locpoints,
sum = 0; sum = 0;
weight = 0; weight = 0;
for (i = 1; i <= locfaces.Size(); i++) for(int i = 1; i <= locfaces.Size(); i++)
{ {
pc.X() = pc.Y() = pc.Z() = 0; pc.X() = pc.Y() = pc.Z() = 0;
for (j = 1; j <= 3; j++) for (j = 1; j <= 3; j++)
@ -187,7 +187,7 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
Array<int> delpoints, delfaces; // points and lines to be deleted Array<int> delpoints, delfaces; // points and lines to be deleted
Array<Element> locelements; // new generated elements Array<Element> locelements; // new generated elements
int i, j, oldnp, oldnf; int j, oldnp, oldnf;
int found; int found;
referencetransform trans; referencetransform trans;
int rotind; int rotind;
@ -344,7 +344,7 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
allowpoint.SetSize(locpoints.Size()); allowpoint.SetSize(locpoints.Size());
if (uselocalh && stat.qualclass <= 3) if (uselocalh && stat.qualclass <= 3)
for (i = 1; i <= allowpoint.Size(); i++) for(int i = 1; i <= allowpoint.Size(); i++)
{ {
allowpoint.Elem(i) = allowpoint.Elem(i) =
(mesh.GetH (locpoints.Get(i)) > 0.4 * hshould / mp.sloppy) ? 2 : 1; (mesh.GetH (locpoints.Get(i)) > 0.4 * hshould / mp.sloppy) ? 2 : 1;
@ -378,10 +378,10 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
{ {
(*testout) << "inner point found" << endl; (*testout) << "inner point found" << endl;
for (i = 1; i <= groupfaces.Size(); i++) for(int i = 1; i <= groupfaces.Size(); i++)
adfront -> DeleteFace (groupfindex.Get(i)); adfront -> DeleteFace (groupfindex.Get(i));
for (i = 1; i <= groupfaces.Size(); i++) for(int i = 1; i <= groupfaces.Size(); i++)
for (j = 1; j <= locfaces.Size(); j++) for (j = 1; j <= locfaces.Size(); j++)
if (findex.Get(j) == groupfindex.Get(i)) if (findex.Get(j) == groupfindex.Get(i))
delfaces.Append (j); delfaces.Append (j);
@ -390,13 +390,13 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
delfaces.SetSize (0); delfaces.SetSize (0);
INDEX npi; INDEX npi;
Element newel; Element newel(TET);
npi = mesh.AddPoint (inp); npi = mesh.AddPoint (inp);
newel.SetNP(4); newel.SetNP(4);
newel.PNum(4) = npi; newel.PNum(4) = npi;
for (i = 1; i <= groupfaces.Size(); i++) for(int i = 1; i <= groupfaces.Size(); i++)
{ {
for (j = 1; j <= 3; j++) for (j = 1; j <= 3; j++)
{ {
@ -417,14 +417,14 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
// int optother = 0; // int optother = 0;
/* /*
for (i = 1; i <= locfaces.Size(); i++) for(int i = 1; i <= locfaces.Size(); i++)
{ {
(*testout) << "Face " << i << ": "; (*testout) << "Face " << i << ": ";
for (j = 1; j <= locfaces.Get(i).GetNP(); j++) for (j = 1; j <= locfaces.Get(i).GetNP(); j++)
(*testout) << pindex.Get(locfaces.Get(i).PNum(j)) << " "; (*testout) << pindex.Get(locfaces.Get(i).PNum(j)) << " ";
(*testout) << endl; (*testout) << endl;
} }
for (i = 1; i <= locpoints.Size(); i++) for(int i = 1; i <= locpoints.Size(); i++)
{ {
(*testout) << "p" << i (*testout) << "p" << i
<< ", gi = " << pindex.Get(i) << ", gi = " << pindex.Get(i)
@ -470,7 +470,7 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
if (stat.cnttrials % 100 == 0) if (stat.cnttrials % 100 == 0)
{ {
(*testout) << "\n"; (*testout) << "\n";
for (i = 1; i <= canuse.Size(); i++) for(int i = 1; i <= canuse.Size(); i++)
{ {
(*testout) << foundmap.Get(i) << "/" (*testout) << foundmap.Get(i) << "/"
<< canuse.Get(i) << "/" << canuse.Get(i) << "/"
@ -565,7 +565,7 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
if (testmode) if (testmode)
{ {
(*testout) << "found is active, 3" << endl; (*testout) << "found is active, 3" << endl;
for (i = 1; i <= plainpoints.Size(); i++) for(int i = 1; i <= plainpoints.Size(); i++)
{ {
(*testout) << "p"; (*testout) << "p";
if (i <= pindex.Size()) if (i <= pindex.Size())
@ -582,19 +582,19 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
minerr = err; minerr = err;
tempnewpoints.SetSize (0); tempnewpoints.SetSize (0);
for (i = oldnp+1; i <= locpoints.Size(); i++) for(int i = oldnp+1; i <= locpoints.Size(); i++)
tempnewpoints.Append (locpoints.Get(i)); tempnewpoints.Append (locpoints.Get(i));
tempnewfaces.SetSize (0); tempnewfaces.SetSize (0);
for (i = oldnf+1; i <= locfaces.Size(); i++) for(int i = oldnf+1; i <= locfaces.Size(); i++)
tempnewfaces.Append (locfaces.Get(i)); tempnewfaces.Append (locfaces.Get(i));
tempdelfaces.SetSize (0); tempdelfaces.SetSize (0);
for (i = 1; i <= delfaces.Size(); i++) for(int i = 1; i <= delfaces.Size(); i++)
tempdelfaces.Append (delfaces.Get(i)); tempdelfaces.Append (delfaces.Get(i));
templocelements.SetSize (0); templocelements.SetSize (0);
for (i = 1; i <= locelements.Size(); i++) for(int i = 1; i <= locelements.Size(); i++)
templocelements.Append (locelements.Get(i)); templocelements.Append (locelements.Get(i));
/* /*
@ -624,20 +624,20 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
} }
*/ */
for (i = 1; i <= tempnewpoints.Size(); i++) for(int i = 1; i <= tempnewpoints.Size(); i++)
locpoints.Append (tempnewpoints.Get(i)); locpoints.Append (tempnewpoints.Get(i));
for (i = 1; i <= tempnewfaces.Size(); i++) for(int i = 1; i <= tempnewfaces.Size(); i++)
locfaces.Append (tempnewfaces.Get(i)); locfaces.Append (tempnewfaces.Get(i));
for (i = 1; i <= tempdelfaces.Size(); i++) for(int i = 1; i <= tempdelfaces.Size(); i++)
delfaces.Append (tempdelfaces.Get(i)); delfaces.Append (tempdelfaces.Get(i));
for (i = 1; i <= templocelements.Size(); i++) for(int i = 1; i <= templocelements.Size(); i++)
locelements.Append (templocelements.Get(i)); locelements.Append (templocelements.Get(i));
if (loktestmode) if (loktestmode)
{ {
(*testout) << "apply rule" << endl; (*testout) << "apply rule" << endl;
for (i = 1; i <= locpoints.Size(); i++) for(int i = 1; i <= locpoints.Size(); i++)
{ {
(*testout) << "p"; (*testout) << "p";
if (i <= pindex.Size()) if (i <= pindex.Size())
@ -676,7 +676,7 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
stat.cntelem++; stat.cntelem++;
} }
for (i = oldnf+1; i <= locfaces.Size(); i++) for(int i = oldnf+1; i <= locfaces.Size(); i++)
{ {
for (j = 1; j <= locfaces.Get(i).GetNP(); j++) for (j = 1; j <= locfaces.Get(i).GetNP(); j++)
locfaces.Elem(i).PNum(j) = locfaces.Elem(i).PNum(j) =
@ -685,7 +685,7 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
adfront->AddFace (locfaces.Get(i)); adfront->AddFace (locfaces.Get(i));
} }
for (i = 1; i <= delfaces.Size(); i++) for(int i = 1; i <= delfaces.Size(); i++)
adfront->DeleteFace (findex.Get(delfaces.Get(i))); adfront->DeleteFace (findex.Get(delfaces.Get(i)));
} }
else else
@ -709,7 +709,7 @@ GenerateMesh (Mesh & mesh, const MeshingParameters & mp)
PrintMessage (5, ""); // line feed after statistics PrintMessage (5, ""); // line feed after statistics
for (i = 1; i <= ruleused.Size(); i++) for(int i = 1; i <= ruleused.Size(); i++)
(*testout) << setw(4) << ruleused.Get(i) (*testout) << setw(4) << ruleused.Get(i)
<< " times used rule " << rules.Get(i) -> Name() << endl; << " times used rule " << rules.Get(i) -> Name() << endl;
@ -742,7 +742,7 @@ void Meshing3 :: BlockFill (Mesh & mesh, double gh)
double xminb, xmaxb, yminb, ymaxb, zminb, zmaxb; double xminb, xmaxb, yminb, ymaxb, zminb, zmaxb;
//double rad = 0.7 * gh; //double rad = 0.7 * gh;
for (i = 1; i <= adfront->GetNP(); i++) for(int i = 1; i <= adfront->GetNP(); i++)
{ {
const Point3d & p = adfront->GetPoint(PointIndex(i)); const Point3d & p = adfront->GetPoint(PointIndex(i));
if (i == 1) if (i == 1)
@ -780,13 +780,13 @@ void Meshing3 :: BlockFill (Mesh & mesh, double gh)
// initialize inner to 1 // initialize inner to 1
for (i = 1; i <= n; i++) for(int i = 1; i <= n; i++)
inner.Elem(i) = BLOCKUNDEF; inner.Elem(i) = BLOCKUNDEF;
// set blocks cutting surfaces to 0 // set blocks cutting surfaces to 0
for (i = 1; i <= adfront->GetNF(); i++) for(int i = 1; i <= adfront->GetNF(); i++)
{ {
const MiniElement2d & el = adfront->GetFace(i); const MiniElement2d & el = adfront->GetFace(i);
xminb = xmax; xmaxb = xmin; xminb = xmax; xmaxb = xmin;
@ -916,14 +916,14 @@ void Meshing3 :: BlockFill (Mesh & mesh, double gh)
filled = 0; filled = 0;
for (i = 1; i <= n; i++) for(int i = 1; i <= n; i++)
if (inner.Elem(i) == BLOCKINNER) if (inner.Elem(i) == BLOCKINNER)
{ {
filled++; filled++;
} }
PrintMessage (5, "Filled blocks: ", filled); PrintMessage (5, "Filled blocks: ", filled);
for (i = 1; i <= n; i++) for(int i = 1; i <= n; i++)
{ {
pointnr.Elem(i) = 0; pointnr.Elem(i) = 0;
frontpointnr.Elem(i) = 0; frontpointnr.Elem(i) = 0;

18
libsrc/meshing/meshtype.cpp
View File

@ -157,8 +157,7 @@ namespace netgen
<< " si = " << seg.si << ", edgenr = " << seg.edgenr; << " si = " << seg.si << ", edgenr = " << seg.edgenr;
return s; return s;
} }
/*
Element2d :: Element2d () Element2d :: Element2d ()
{ {
for (int i = 0; i < ELEMENT2D_MAXPOINTS; i++) for (int i = 0; i < ELEMENT2D_MAXPOINTS; i++)
@ -177,8 +176,7 @@ namespace netgen
strongrefflag = false; strongrefflag = false;
is_curved = false; is_curved = false;
} }
*/
Element2d :: Element2d (int anp) Element2d :: Element2d (int anp)
{ {
for (int i = 0; i < ELEMENT2D_MAXPOINTS; i++) for (int i = 0; i < ELEMENT2D_MAXPOINTS; i++)
@ -969,7 +967,7 @@ namespace netgen
return s; return s;
} }
/*
Element :: Element () Element :: Element ()
{ {
typ = TET; typ = TET;
@ -992,9 +990,8 @@ namespace netgen
#ifdef PARALLEL #ifdef PARALLEL
partitionNumber = -1; partitionNumber = -1;
#endif #endif
} }
*/
Element :: Element (int anp) Element :: Element (int anp)
{ {
@ -1063,12 +1060,15 @@ namespace netgen
flags.fixed = 0; flags.fixed = 0;
orderx = ordery = orderz = 1; orderx = ordery = orderz = 1;
is_curved = typ != TET; // false; is_curved = typ != TET; // false;
#ifdef PARALLEL
partitionNumber = -1;
#endif
} }
/*
Element & Element :: operator= (const Element & el2) Element & Element :: operator= (const Element & el2)
{ {
typ = el2.typ; typ = el2.typ;
@ -1085,7 +1085,7 @@ namespace netgen
is_curved = el2.is_curved; is_curved = el2.is_curved;
return *this; return *this;
} }
*/
void Element :: SetNP (int anp) void Element :: SetNP (int anp)

52
libsrc/meshing/meshtype.hpp
View File

@ -54,18 +54,35 @@ namespace netgen
enum OPTIMIZEGOAL { OPT_QUALITY, OPT_CONFORM, OPT_REST, OPT_WORSTCASE, OPT_LEGAL }; enum OPTIMIZEGOAL { OPT_QUALITY, OPT_CONFORM, OPT_REST, OPT_WORSTCASE, OPT_LEGAL };
extern DLL_HEADER size_t timestamp;
inline size_t GetTimeStamp()
{
return timestamp;
}
inline size_t NextTimeStamp()
{
timestamp++;
return timestamp;
}
/*
extern DLL_HEADER int GetTimeStamp(); extern DLL_HEADER int GetTimeStamp();
extern DLL_HEADER int NextTimeStamp(); extern DLL_HEADER int NextTimeStamp();
*/
class PointGeomInfo class PointGeomInfo
{ {
public: public:
int trignum; // for STL Meshing int trignum; // for STL Meshing
double u, v; // for OCC Meshing double u, v; // for OCC Meshing
PointGeomInfo () PointGeomInfo () = default;
: trignum(-1), u(0), v(0) { ; } // : trignum(-1), u(0), v(0) { ; }
PointGeomInfo (const PointGeomInfo&) = default;
PointGeomInfo (PointGeomInfo &&) = default;
PointGeomInfo & operator= (const PointGeomInfo&) = default;
PointGeomInfo & operator= (PointGeomInfo&&) = default;
}; };
inline ostream & operator<< (ostream & ost, const PointGeomInfo & gi) inline ostream & operator<< (ostream & ost, const PointGeomInfo & gi)
@ -133,9 +150,14 @@ namespace netgen
{ {
int i; int i;
public: public:
PointIndex () { ; } PointIndex () = default;
PointIndex (const PointIndex&) = default;
PointIndex (PointIndex &&) = default;
PointIndex & operator= (const PointIndex&) = default;
PointIndex & operator= (PointIndex&&) = default;
PointIndex (int ai) : i(ai) { ; } PointIndex (int ai) : i(ai) { ; }
PointIndex & operator= (const PointIndex &ai) { i = ai.i; return *this; } // PointIndex & operator= (const PointIndex &ai) { i = ai.i; return *this; }
operator int () const { return i; } operator int () const { return i; }
PointIndex operator++ (int) { PointIndex hi(*this); i++; return hi; } PointIndex operator++ (int) { PointIndex hi(*this); i++; return hi; }
PointIndex operator-- (int) { PointIndex hi(*this); i--; return hi; } PointIndex operator-- (int) { PointIndex hi(*this); i--; return hi; }
@ -352,7 +374,11 @@ namespace netgen
public: public:
/// ///
Element2d (); Element2d () = default;
Element2d (const Element2d &) = default;
Element2d (Element2d &&) = default;
Element2d & operator= (const Element2d &) = default;
Element2d & operator= (Element2d &&) = default;
/// ///
Element2d (int anp); Element2d (int anp);
/// ///
@ -422,6 +448,8 @@ namespace netgen
{ return FlatArray<const PointIndex> (np, &pnum[0]); } { return FlatArray<const PointIndex> (np, &pnum[0]); }
FlatArray<PointIndex> PNums () FlatArray<PointIndex> PNums ()
{ return FlatArray<PointIndex> (np, &pnum[0]); } { return FlatArray<PointIndex> (np, &pnum[0]); }
auto Vertices() const
{ return FlatArray<const PointIndex> (GetNV(), &pnum[0]); }
/// ///
PointIndex & PNum (int i) { return pnum[i-1]; } PointIndex & PNum (int i) { return pnum[i-1]; }
@ -632,13 +660,18 @@ namespace netgen
flagstruct flags; flagstruct flags;
/// ///
DLL_HEADER Element (); DLL_HEADER Element () = default;
Element (const Element &) = default;
Element (Element &&) = default;
Element & operator= (const Element &) = default;
Element & operator= (Element &&) = default;
/// ///
Element (int anp); Element (int anp);
/// ///
Element (ELEMENT_TYPE type); Element (ELEMENT_TYPE type);
/// ///
Element & operator= (const Element & el2); // Element & operator= (const Element & el2);
/// ///
void SetNP (int anp); void SetNP (int anp);
@ -647,7 +680,7 @@ namespace netgen
/// ///
int GetNP () const { return np; } int GetNP () const { return np; }
/// ///
short int GetNV() const uint8_t GetNV() const
{ {
__assume(typ >= TET && typ <= HEX); __assume(typ >= TET && typ <= HEX);
switch (typ) switch (typ)
@ -666,6 +699,7 @@ namespace netgen
#ifdef DEBUG #ifdef DEBUG
PrintSysError ("Element3d::GetNV not implemented for typ ", typ); PrintSysError ("Element3d::GetNV not implemented for typ ", typ);
#endif #endif
__assume(false);
return -1; return -1;
} }
} }

2
libsrc/meshing/parser2.cpp
View File

@ -329,7 +329,7 @@ void netrule :: LoadRule (istream & ist)
while (ch == '(') while (ch == '(')
{ {
elements.Append (Element2d()); elements.Append (Element2d(TRIG));
ist >> elements.Last().PNum(1); ist >> elements.Last().PNum(1);
ist >> ch; // ',' ist >> ch; // ','

2
libsrc/meshing/parser3.cpp
View File

@ -84,7 +84,7 @@ void vnetrule :: LoadRule (istream & ist)
char buf[256]; char buf[256];
char ch, ok; char ch, ok;
Point3d p; Point3d p;
Element2d face; Element2d face(TRIG);
int i, j, i1, i2, i3, fs, ii, ii1, ii2, ii3; int i, j, i1, i2, i3, fs, ii, ii1, ii2, ii3;
twoint edge; twoint edge;
DenseMatrix tempoldutonewu(30, 20), DenseMatrix tempoldutonewu(30, 20),

40
libsrc/meshing/python_mesh.cpp
View File

@ -11,8 +11,11 @@
using namespace netgen; using namespace netgen;
extern const char *ngscript[];
namespace netgen namespace netgen
{ {
extern bool netgen_executable_started;
extern shared_ptr<NetgenGeometry> ng_geometry; extern shared_ptr<NetgenGeometry> ng_geometry;
} }
@ -49,6 +52,14 @@ static Transformation<3> global_trafo(Vec<3> (0,0,0));
DLL_HEADER void ExportNetgenMeshing(py::module &m) DLL_HEADER void ExportNetgenMeshing(py::module &m)
{ {
m.attr("_netgen_executable_started") = py::cast(netgen::netgen_executable_started);
string script;
const char ** hcp = ngscript;
while (*hcp)
script += *hcp++;
m.attr("_ngscript") = py::cast(script);
py::class_<NGDummyArgument>(m, "NGDummyArgument") py::class_<NGDummyArgument>(m, "NGDummyArgument")
.def("__bool__", []( NGDummyArgument &self ) { return false; } ) .def("__bool__", []( NGDummyArgument &self ) { return false; } )
; ;
@ -226,6 +237,14 @@ DLL_HEADER void ExportNetgenMeshing(py::module &m)
li.append (py::cast(self[i])); li.append (py::cast(self[i]));
return li; return li;
})) }))
.def_property_readonly("points",
FunctionPointer ([](const Element & self) -> py::list
{
py::list li;
for (int i = 0; i < self.GetNP(); i++)
li.append (py::cast(self[i]));
return li;
}))
; ;
py::class_<Element2d>(m, "Element2D") py::class_<Element2d>(m, "Element2D")
@ -375,8 +394,8 @@ DLL_HEADER void ExportNetgenMeshing(py::module &m)
ExportArray<Element,0,ElementIndex>(m); ExportArray<Element,0,size_t>(m);
ExportArray<Element2d,0,SurfaceElementIndex>(m); ExportArray<Element2d,0,size_t>(m);
ExportArray<Segment>(m); ExportArray<Segment>(m);
ExportArray<Element0d>(m); ExportArray<Element0d>(m);
ExportArray<MeshPoint,PointIndex::BASE,PointIndex>(m); ExportArray<MeshPoint,PointIndex::BASE,PointIndex>(m);
@ -458,11 +477,11 @@ DLL_HEADER void ExportNetgenMeshing(py::module &m)
.def_property("dim", &Mesh::GetDimension, &Mesh::SetDimension) .def_property("dim", &Mesh::GetDimension, &Mesh::SetDimension)
.def("Elements3D", .def("Elements3D",
static_cast<Array<Element,0,ElementIndex>&(Mesh::*)()> (&Mesh::VolumeElements), static_cast<Array<Element,0,size_t>&(Mesh::*)()> (&Mesh::VolumeElements),
py::return_value_policy::reference) py::return_value_policy::reference)
.def("Elements2D", .def("Elements2D",
static_cast<Array<Element2d,0,SurfaceElementIndex>&(Mesh::*)()> (&Mesh::SurfaceElements), static_cast<Array<Element2d,0,size_t>&(Mesh::*)()> (&Mesh::SurfaceElements),
py::return_value_policy::reference) py::return_value_policy::reference)
.def("Elements1D", .def("Elements1D",
@ -590,6 +609,15 @@ DLL_HEADER void ExportNetgenMeshing(py::module &m)
Refinement().Refine(self); Refinement().Refine(self);
})) }))
.def ("SecondOrder", FunctionPointer
([](Mesh & self)
{
if (self.GetGeometry())
self.GetGeometry()->GetRefinement().MakeSecondOrder(self);
else
Refinement().MakeSecondOrder(self);
}))
.def ("SetGeometry", FunctionPointer .def ("SetGeometry", FunctionPointer
([](Mesh & self, shared_ptr<NetgenGeometry> geo) ([](Mesh & self, shared_ptr<NetgenGeometry> geo)
{ {
@ -684,7 +712,7 @@ DLL_HEADER void ExportNetgenMeshing(py::module &m)
.def(py::init<>()) .def(py::init<>())
.def("__init__", .def("__init__",
[](MP *instance, double maxh, bool quad_dominated, int optsteps2d, int optsteps3d, [](MP *instance, double maxh, bool quad_dominated, int optsteps2d, int optsteps3d,
MESHING_STEP perfstepsend, int only3D_domain) MESHING_STEP perfstepsend, int only3D_domain, const string & meshsizefilename)
{ {
new (instance) MeshingParameters; new (instance) MeshingParameters;
instance->maxh = maxh; instance->maxh = maxh;
@ -693,6 +721,7 @@ DLL_HEADER void ExportNetgenMeshing(py::module &m)
instance->optsteps3d = optsteps3d; instance->optsteps3d = optsteps3d;
instance->only3D_domain_nr = only3D_domain; instance->only3D_domain_nr = only3D_domain;
instance->perfstepsend = perfstepsend; instance->perfstepsend = perfstepsend;
instance->meshsizefilename = meshsizefilename;
}, },
py::arg("maxh")=1000, py::arg("maxh")=1000,
py::arg("quad_dominated")=false, py::arg("quad_dominated")=false,
@ -700,6 +729,7 @@ DLL_HEADER void ExportNetgenMeshing(py::module &m)
py::arg("optsteps3d") = 3, py::arg("optsteps3d") = 3,
py::arg("perfstepsend") = MESHCONST_OPTVOLUME, py::arg("perfstepsend") = MESHCONST_OPTVOLUME,
py::arg("only3D_domain") = 0, py::arg("only3D_domain") = 0,
py::arg("meshsizefilename") = "",
"create meshing parameters" "create meshing parameters"
) )
.def("__str__", &ToString<MP>) .def("__str__", &ToString<MP>)

2
libsrc/meshing/refine.cpp
View File

@ -436,7 +436,7 @@ namespace netgen
int ind = el.GetIndex(); int ind = el.GetIndex();
for (int j = 0; j < 8; j++) for (int j = 0; j < 8; j++)
{ {
Element nel; Element nel(TET);
for (int k = 1; k <= 4; k++) for (int k = 1; k <= 4; k++)
nel.PNum(k) = pnums.Get(reftab[j][k-1]); nel.PNum(k) = pnums.Get(reftab[j][k-1]);
nel.SetIndex(ind); nel.SetIndex(ind);

4
libsrc/meshing/secondorder.cpp
View File

@ -112,7 +112,7 @@ namespace netgen
int onp(0); int onp(0);
Element2d newel; Element2d newel(TRIG);
newel.SetIndex (el.GetIndex()); newel.SetIndex (el.GetIndex());
static int betw_trig[3][3] = static int betw_trig[3][3] =
@ -204,7 +204,7 @@ namespace netgen
const Element & el = mesh.VolumeElement(i); const Element & el = mesh.VolumeElement(i);
int onp = 0; int onp = 0;
Element newel; Element newel(TET);
newel.SetIndex (el.GetIndex()); newel.SetIndex (el.GetIndex());
static int betw_tet[6][3] = static int betw_tet[6][3] =

2
libsrc/meshing/smoothing3.cpp
View File

@ -432,7 +432,7 @@ namespace netgen
for (int k = 1; k <= 4; k++) for (int k = 1; k <= 4; k++)
if (el.PNum(k) == actpind) if (el.PNum(k) == actpind)
{ {
Element2d face; Element2d face(TRIG);
el.GetFace (k, face); el.GetFace (k, face);
Swap (face.PNum(2), face.PNum(3)); Swap (face.PNum(2), face.PNum(3));
faces.Append (face); faces.Append (face);

2
libsrc/meshing/topology.cpp
View File

@ -1120,7 +1120,7 @@ namespace netgen
(*testout) << "pos = "; (*testout) << "pos = ";
for (int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
if (face2vert[i].I(j+1) >= 1) if (face2vert[i].I(j+1) >= 1)
(*testout) << mesh[(PointIndex)face2vert[i].I(j+1)] << " "; (*testout) << (*mesh)[(PointIndex)face2vert[i].I(j+1)] << " ";
(*testout) << endl; (*testout) << endl;
FlatArray<ElementIndex> vertels = GetVertexElements (face2vert[i].I(1)); FlatArray<ElementIndex> vertels = GetVertexElements (face2vert[i].I(1));

6
libsrc/occ/CMakeLists.txt
View File

@ -2,7 +2,7 @@ add_definitions(-DNGINTERFACE_EXPORTS)
add_library(occ ${NG_LIB_TYPE} add_library(occ ${NG_LIB_TYPE}
Partition_Inter2d.cxx Partition_Inter3d.cxx Partition_Inter2d.cxx Partition_Inter3d.cxx
Partition_Loop.cxx Partition_Loop2d.cxx Partition_Loop3d.cxx Partition_Spliter.cxx Partition_Loop.cxx Partition_Loop2d.cxx Partition_Loop3d.cxx Partition_Spliter.cxx
occconstruction.cpp occgenmesh.cpp occgeom.cpp occmeshsurf.cpp occconstruction.cpp occgenmesh.cpp occgeom.cpp occmeshsurf.cpp python_occ.cpp
) )
add_library(occvis ${NG_LIB_TYPE} vsocc.cpp) add_library(occvis ${NG_LIB_TYPE} vsocc.cpp)
@ -10,10 +10,10 @@ add_library(occvis ${NG_LIB_TYPE} vsocc.cpp)
if(NOT WIN32) if(NOT WIN32)
target_link_libraries( occ ${OCC_LIBRARIES} ${PYTHON_LIBRARIES}) target_link_libraries( occ ${OCC_LIBRARIES} ${PYTHON_LIBRARIES})
target_link_libraries( occvis occ ) target_link_libraries( occvis occ )
install( TARGETS occ occvis ${ng_install_dir}) install( TARGETS occ occvis ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)
install(FILES install(FILES
occgeom.hpp occmeshsurf.hpp vsocc.hpp occgeom.hpp occmeshsurf.hpp vsocc.hpp
DESTINATION ${INCDIR}/occ COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/occ COMPONENT netgen_devel
) )

14
libsrc/occ/occgenmesh.cpp
View File

@ -422,6 +422,10 @@ namespace netgen
{ {
mesh.GetFaceDescriptor(facenr).SetSurfColour(Vec3d(0.0,1.0,0.0)); mesh.GetFaceDescriptor(facenr).SetSurfColour(Vec3d(0.0,1.0,0.0));
} }
if(geom.fnames.Size()>=facenr)
mesh.GetFaceDescriptor(facenr).SetBCName(&geom.fnames[facenr-1]);
mesh.GetFaceDescriptor(facenr).SetBCProperty(facenr);
// ACHTUNG! STIMMT NICHT ALLGEMEIN (RG) // ACHTUNG! STIMMT NICHT ALLGEMEIN (RG)
@ -974,6 +978,13 @@ namespace netgen
NgProfiler::StopTimer (timer_opt2d); NgProfiler::StopTimer (timer_opt2d);
multithread.task = savetask; multithread.task = savetask;
// Gerhard BEGIN
for(int i = 0; i<mesh.GetNFD();i++)
mesh.SetBCName(i,mesh.GetFaceDescriptor(i+1).GetBCName());
// for(int i = 0; i<mesh.GetNDomains();i++)
// mesh.SetMaterial(i,geom.snames[i]);
// Gerhard END
} }
@ -1459,6 +1470,9 @@ namespace netgen
for (int i = 1; i <= mesh->GetNSeg(); i++) for (int i = 1; i <= mesh->GetNSeg(); i++)
(*testout) << mesh->LineSegment(i) << endl; (*testout) << mesh->LineSegment(i) << endl;
for (int i = 0; i < mesh->GetNDomains(); i++)
if(geom.snames.Size())
mesh->SetMaterial( i+1, geom.snames[i] );
return TCL_OK; return TCL_OK;
} }
} }

75
libsrc/occ/occgeom.cpp
View File

@ -17,6 +17,10 @@
#include "Partition_Spliter.hxx" #include "Partition_Spliter.hxx"
#include "BRepAlgoAPI_Fuse.hxx" #include "BRepAlgoAPI_Fuse.hxx"
#include "XSControl_WorkSession.hxx"
#include "XSControl_TransferReader.hxx"
#include "StepRepr_RepresentationItem.hxx"
#ifndef _Standard_Version_HeaderFile #ifndef _Standard_Version_HeaderFile
#include <Standard_Version.hxx> #include <Standard_Version.hxx>
#endif #endif
@ -29,6 +33,44 @@
namespace netgen namespace netgen
{ {
void STEP_GetEntityName(const TopoDS_Shape & theShape, STEPCAFControl_Reader * aReader, char * acName)
{
const Handle(XSControl_WorkSession)& theSession = aReader->Reader().WS();
const Handle(XSControl_TransferReader)& aTransferReader =
theSession->TransferReader();
Handle(Standard_Transient) anEntity =
aTransferReader->EntityFromShapeResult(theShape, 1);
if (anEntity.IsNull()) {
// as just mapped
anEntity = aTransferReader->EntityFromShapeResult (theShape,-1);
}
if (anEntity.IsNull()) {
// as anything
anEntity = aTransferReader->EntityFromShapeResult (theShape,4);
}
if (anEntity.IsNull()) {
cout<<"Warning: XSInterVertex_STEPReader::ReadAttributes()\nentity not found"<<endl;
strcpy(acName, "none");
}
else
{
Handle(StepRepr_RepresentationItem) aReprItem;
aReprItem =
Handle(StepRepr_RepresentationItem)::DownCast(anEntity);
if (aReprItem.IsNull()) {
cout<<"Error: STEPReader::ReadAttributes():\nStepRepr_RepresentationItem Is NULL"<<endl;
}
else
strcpy(acName, aReprItem->Name()->ToCString());
}
}
void OCCGeometry :: PrintNrShapes () void OCCGeometry :: PrintNrShapes ()
{ {
TopExp_Explorer e; TopExp_Explorer e;
@ -1169,7 +1211,7 @@ namespace netgen
// Enable transfer of colours // Enable transfer of colours
reader.SetColorMode(Standard_True); reader.SetColorMode(Standard_True);
reader.SetNameMode(Standard_True);
Standard_Integer stat = reader.ReadFile((char*)filename); Standard_Integer stat = reader.ReadFile((char*)filename);
if(stat != IFSelect_RetDone) if(stat != IFSelect_RetDone)
@ -1210,7 +1252,38 @@ namespace netgen
occgeo->CalcBoundingBox(); occgeo->CalcBoundingBox();
PrintContents (occgeo); PrintContents (occgeo);
char * name = new char(50);
//string name;
STEP_GetEntityName(occgeo->shape,&reader,name);
occgeo->snames.Append(name);
TopExp_Explorer exp0,exp1;
for (exp0.Init(occgeo->shape, TopAbs_FACE); exp0.More(); exp0.Next())
{
TopoDS_Face face = TopoDS::Face(exp0.Current());
STEP_GetEntityName(face,&reader,name);
occgeo->fnames.Append(name);
for (exp1.Init(face, TopAbs_EDGE); exp1.More(); exp1.Next())
{
TopoDS_Edge edge = TopoDS::Edge(exp1.Current());
STEP_GetEntityName(edge,&reader,name);
occgeo->enames.Append(name);
}
}
// Gerhard BEGIN
// cout << "Solid Names: "<<endl;
// for (int i=0;i<occgeo->snames.Size();i++)
// cout << occgeo->snames[i] << endl;
// cout << " " <<endl;
// cout << "Face Names: "<<endl;
// for (int i=0;i<occgeo->fnames.Size();i++)
// cout << occgeo->fnames[i] << endl;
// cout << " " <<endl;
// cout << "Edge Names: "<<endl;
// for (int i=0;i<occgeo->enames.Size();i++)
// cout << occgeo->enames[i] << endl;
// cout << " " <<endl;
// Gerhard END
return occgeo; return occgeo;
} }

2
libsrc/occ/occgeom.hpp
View File

@ -198,7 +198,7 @@ namespace netgen
TopTools_IndexedMapOfShape fmap, emap, vmap, somap, shmap, wmap; TopTools_IndexedMapOfShape fmap, emap, vmap, somap, shmap, wmap;
Array<bool> fsingular, esingular, vsingular; Array<bool> fsingular, esingular, vsingular;
Box<3> boundingbox; Box<3> boundingbox;
Array<string> fnames, enames, snames;
// Philippose - 29/01/2009 // Philippose - 29/01/2009
// OpenCascade XDE Support // OpenCascade XDE Support
// XCAF Handle to make the face colours available to the rest of // XCAF Handle to make the face colours available to the rest of

56
libsrc/occ/python_occ.cpp Normal file
View File

@ -0,0 +1,56 @@
#ifdef NG_PYTHON
#ifdef OCCGEOMETRY
#include <../general/ngpython.hpp>
#include <meshing.hpp>
#include <occgeom.hpp>
using namespace netgen;
namespace netgen
{
extern std::shared_ptr<NetgenGeometry> ng_geometry;
}
DLL_HEADER void ExportNgOCC(py::module &m)
{
py::class_<OCCGeometry, shared_ptr<OCCGeometry>> (m, "OCCGeometry")
.def(py::init<>())
;
m.def("LoadOCCGeometry",FunctionPointer([] (const string & filename)
{
cout << "load OCC geometry";
ifstream ist(filename);
OCCGeometry * instance = new OCCGeometry();
instance = LoadOCC_STEP(filename.c_str());
return shared_ptr<OCCGeometry>(instance, NOOP_Deleter);
}));
m.def("GenerateMesh", FunctionPointer([] (shared_ptr<OCCGeometry> geo, MeshingParameters &param)
{
auto mesh = make_shared<Mesh>();
SetGlobalMesh(mesh);
mesh->SetGeometry(geo);
ng_geometry = geo;
try
{
geo->GenerateMesh(mesh,param);
}
catch (NgException ex)
{
cout << "Caught NgException: " << ex.What() << endl;
}
return mesh;
}))
;
}
PYBIND11_PLUGIN(libNgOCC) {
py::module m("NgOCC", "pybind NgOCC");
ExportNgOCC(m);
return m.ptr();
}
#endif // OCCGEOMETRY
#endif // NG_PYTHON

6
libsrc/stlgeom/CMakeLists.txt
View File

@ -6,7 +6,7 @@ add_library(stl ${NG_LIB_TYPE}
if(NOT WIN32) if(NOT WIN32)
target_link_libraries( stl mesh ${PYTHON_LIBRARIES}) target_link_libraries( stl mesh ${PYTHON_LIBRARIES})
target_link_libraries( stl ${PYTHON_LIBRARIES}) target_link_libraries( stl ${PYTHON_LIBRARIES})
install( TARGETS stl ${ng_install_dir}) install( TARGETS stl ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)
if(USE_GUI) if(USE_GUI)
@ -15,12 +15,12 @@ if(USE_GUI)
) )
if(NOT WIN32) if(NOT WIN32)
target_link_libraries( stlvis stl ) target_link_libraries( stlvis stl )
install( TARGETS stlvis ${ng_install_dir}) install( TARGETS stlvis ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)
endif(USE_GUI) endif(USE_GUI)
install(FILES install(FILES
meshstlsurface.hpp stlgeom.hpp stlline.hpp meshstlsurface.hpp stlgeom.hpp stlline.hpp
stltool.hpp stltopology.hpp vsstl.hpp stltool.hpp stltopology.hpp vsstl.hpp
DESTINATION ${INCDIR}/stlgeom COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/stlgeom COMPONENT netgen_devel
) )

10
libsrc/visualization/CMakeLists.txt
View File

@ -1,7 +1,5 @@
add_definitions(-DNGINTERFACE_EXPORTS) add_definitions(-DNGINTERFACE_EXPORTS)
install(FILES soldata.hpp DESTINATION ${INCDIR} COMPONENT netgen_devel ) install(FILES soldata.hpp DESTINATION ${NG_INSTALL_DIR_INCLUDE} COMPONENT netgen_devel )
# AM_CPPFLAGS = $(MPI_INCLUDES) -I$(top_srcdir)/libsrc/include -DOPENGL -D$(TOGL_WINDOWINGSYSTEM) $(OCCFLAGS) $(TCL_INCLUDES)
if(USE_GUI) if(USE_GUI)
set( LIB_VISUAL_SOURCES meshdoc.cpp mvdraw.cpp vsfieldlines.cpp vsmesh.cpp vssolution.cpp importsolution.cpp ) set( LIB_VISUAL_SOURCES meshdoc.cpp mvdraw.cpp vsfieldlines.cpp vsmesh.cpp vssolution.cpp importsolution.cpp )
@ -12,12 +10,12 @@ endif(USE_GUI)
add_library(visual ${NG_LIB_TYPE} ${LIB_VISUAL_SOURCES}) add_library(visual ${NG_LIB_TYPE} ${LIB_VISUAL_SOURCES})
if(NOT WIN32) if(NOT WIN32)
target_link_libraries( visual ${PYTHON_LIBRARIES} ${MPI_CXX_LIBRARIES} ${OPENGL_LIBRARIES} ${TCL_LIBRARY} ) target_link_libraries( visual ${PYTHON_LIBRARIES} ${MPI_CXX_LIBRARIES} ${OPENGL_LIBRARIES} )
install( TARGETS visual ${ng_install_dir}) install( TARGETS visual ${NG_INSTALL_DIR})
endif(NOT WIN32) endif(NOT WIN32)
install(FILES install(FILES
meshdoc.hpp mvdraw.hpp meshdoc.hpp mvdraw.hpp
vispar.hpp visual.hpp vssolution.hpp vispar.hpp visual.hpp vssolution.hpp
DESTINATION ${INCDIR}/visualization COMPONENT netgen_devel DESTINATION ${NG_INSTALL_DIR_INCLUDE}/visualization COMPONENT netgen_devel
) )

2
libsrc/visualization/soldata.hpp
View File

@ -99,7 +99,7 @@ namespace netgen
const __m256d * dxdxref, const __m256d * dxdxref,
__m256d * values) __m256d * values)
{ {
cerr << "GetMultiSurfVaue not overloaded" << endl; cerr << "GetMultiSurfVaue not overloaded for SIMD<double>" << endl;
return false; return false;
} }
#endif #endif

69
libsrc/visualization/vssolution.cpp
View File

@ -1279,7 +1279,6 @@ namespace netgen
Array<double> mvalues(npt); Array<double> mvalues(npt);
int sol_comp = (sol && sol->draw_surface) ? sol->components : 0; int sol_comp = (sol && sol->draw_surface) ? sol->components : 0;
#ifdef __AVX__
Array<Point<2,SIMD<double>> > simd_pref ( (npt+SIMD<double>::Size()-1)/SIMD<double>::Size() ); Array<Point<2,SIMD<double>> > simd_pref ( (npt+SIMD<double>::Size()-1)/SIMD<double>::Size() );
Array<Point<3,SIMD<double>> > simd_points ( (npt+SIMD<double>::Size()-1)/SIMD<double>::Size() ); Array<Point<3,SIMD<double>> > simd_points ( (npt+SIMD<double>::Size()-1)/SIMD<double>::Size() );
Array<Mat<3,2,SIMD<double>> > simd_dxdxis ( (npt+SIMD<double>::Size()-1)/SIMD<double>::Size() ); Array<Mat<3,2,SIMD<double>> > simd_dxdxis ( (npt+SIMD<double>::Size()-1)/SIMD<double>::Size() );
@ -1287,7 +1286,6 @@ namespace netgen
Array<SIMD<double>> simd_values( (npt+SIMD<double>::Size()-1)/SIMD<double>::Size() * sol_comp); Array<SIMD<double>> simd_values( (npt+SIMD<double>::Size()-1)/SIMD<double>::Size() * sol_comp);
#endif
// Array<Point<3,float>> glob_pnts; // Array<Point<3,float>> glob_pnts;
// Array<Vec<3,float>> glob_nvs; // Array<Vec<3,float>> glob_nvs;
@ -1486,7 +1484,6 @@ namespace netgen
NgProfiler::StartTimer(timerloops); NgProfiler::StartTimer(timerloops);
size_t base_pi = 0; size_t base_pi = 0;
#ifdef __AVX__
for (int iy = 0, ii = 0; iy <= n; iy++) for (int iy = 0, ii = 0; iy <= n; iy++)
for (int ix = 0; ix <= n-iy; ix++, ii++) for (int ix = 0; ix <= n-iy; ix++, ii++)
pref[ii] = Point<2> (ix*invn, iy*invn); pref[ii] = Point<2> (ix*invn, iy*invn);
@ -1496,10 +1493,9 @@ namespace netgen
for (size_t i = 0; i < simd_npt; i++) for (size_t i = 0; i < simd_npt; i++)
{ {
simd_pref[i](0).SIMD_function ([&] (size_t j) { size_t ii = i*simd_size+j; return (ii < npt) ? pref[ii](0) : 0; }, std::true_type()); simd_pref[i](0) = [&] (size_t j) { size_t ii = i*simd_size+j; return (ii < npt) ? pref[ii](0) : 0; };
simd_pref[i](1).SIMD_function ([&] (size_t j) { size_t ii = i*simd_size+j; return (ii < npt) ? pref[ii](1) : 0; }, std::true_type()); simd_pref[i](1) = [&] (size_t j) { size_t ii = i*simd_size+j; return (ii < npt) ? pref[ii](1) : 0; };
} }
#endif
Array<int> ind_reftrig; Array<int> ind_reftrig;
for (int iy = 0, ii = 0; iy < n; iy++,ii++) for (int iy = 0, ii = 0; iy < n; iy++,ii++)
@ -1928,12 +1924,12 @@ namespace netgen
Array<Point<3> > grid(n3); Array<Point<3> > grid(n3);
Array<Point<3> > locgrid(n3); Array<Point<3> > locgrid(n3);
Array<Mat<3,3> > trans(n3); Array<Mat<3,3> > trans(n3);
Array<double> val(n3); Array<double> val1(n3*sol->components);
Array<Vec<3> > grads(n3); Array<Vec<3> > grads1(n3);
Array<int> compress(n3); Array<int> compress(n3);
MatrixFixWidth<3> pointmat(8); MatrixFixWidth<3> pointmat(8);
grads = Vec<3> (0.0); grads1 = Vec<3> (0.0);
for (ElementIndex ei = 0; ei < ne; ei++) for (ElementIndex ei = 0; ei < ne; ei++)
{ {
@ -2023,26 +2019,47 @@ namespace netgen
} }
bool has_pos = 0, has_neg = 0; bool has_pos = 0, has_neg = 0;
GetMultiValues( sol, ei, -1, n3,
&locgrid[0](0), &locgrid[1](0)-&locgrid[0](0),
&grid[0](0), &grid[1](0)-&grid[0](0),
&trans[0](0), &trans[1](0)-&trans[0](0),
&val1[0], sol->components);
for (int i = 0; i < cnt_valid; i++) for (int i = 0; i < cnt_valid; i++)
{ {
GetValue (sol, ei, &locgrid[i](0), &grid[i](0), &trans[i](0), comp, val[i]); // GetValue (sol, ei, &locgrid[i](0), &grid[i](0), &trans[i](0), comp, val[i]);
val[i] -= minval; // val[i] -= minval;
val1[sol->components*i+comp-1] -= minval;
if (vsol)
GetValues (vsol, ei, &locgrid[i](0), &grid[i](0), &trans[i](0), &grads[i](0));
grads[i] *= -1;
if (val[i] > 0) // if (vsol)
// GetValues (vsol, ei, &locgrid[i](0), &grid[i](0), &trans[i](0), &grads[i](0));
// grads[i] *= -1;
if (val1[i*sol->components+comp-1] > 0)
has_pos = 1; has_pos = 1;
else else
has_neg = 1; has_neg = 1;
// if (val[i] > 0)
// has_pos = 1;
// else
// has_neg = 1;
} }
if (!has_pos || !has_neg) continue; if (!has_pos || !has_neg) continue;
if (vsol)
{
GetMultiValues(vsol, ei, -1, n3,
&locgrid[0](0), &locgrid[1](0)-&locgrid[0](0),
&grid[0](0), &grid[1](0)-&grid[0](0),
&trans[0](0), &trans[1](0)-&trans[0](0),
&grads1[0](0), vsol->components);
// for (int i = 0; i < cnt_valid; i++)
// grads1[i*sol->components+comp-1] *= -1;
for (int i = 0; i < cnt_valid; i++)
grads1[i] *= -1;
}
for (int ix = 0; ix < n; ix++) for (int ix = 0; ix < n; ix++)
for (int iy = 0; iy < n; iy++) for (int iy = 0; iy < n; iy++)
for (int iz = 0; iz < n; iz++) for (int iz = 0; iz < n; iz++)
@ -2075,8 +2092,10 @@ namespace netgen
if (!is_valid) continue; if (!is_valid) continue;
// for (int j = 0; j < 4; j++)
// nodevali[j] = val[teti[j]];
for (int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
nodevali[j] = val[teti[j]]; nodevali[j] = val1[sol->components*teti[j]+comp-1];
cntce = 0; cntce = 0;
for (int j = 0; j < 6; j++) for (int j = 0; j < 6; j++)
@ -2091,8 +2110,9 @@ namespace netgen
edgelam[j] = nodevali[lpi2] / (nodevali[lpi2] - nodevali[lpi1]); edgelam[j] = nodevali[lpi2] / (nodevali[lpi2] - nodevali[lpi1]);
edgep[j] = grid[teti[lpi1]] + (1-edgelam[j]) * (grid[teti[lpi2]]-grid[teti[lpi1]]); edgep[j] = grid[teti[lpi1]] + (1-edgelam[j]) * (grid[teti[lpi2]]-grid[teti[lpi1]]);
normp[j] = grads[teti[lpi1]] + (1-edgelam[j]) * (grads[teti[lpi2]]-grads[teti[lpi1]]); // normp[j] = grads[teti[lpi1]] + (1-edgelam[j]) * (grads[teti[lpi2]]-grads[teti[lpi1]]);
normp[j] = grads1[teti[lpi1]] + (1-edgelam[j]) * (grads1[teti[lpi2]]-grads1[teti[lpi1]]);
// normp[j] = grads1[sol->components*teti[lpi1]+comp-1] + (1-edgelam[j]) * (grads1[sol->components*teti[lpi2]+comp-1]-grads1[sol->components*teti[lpi1]+comp-1]);
cntce++; cntce++;
cpe3 = cpe2; cpe3 = cpe2;
cpe2 = cpe1; cpe2 = cpe1;
@ -3350,8 +3370,6 @@ namespace netgen
double lam1, double lam2, double lam1, double lam2,
int comp, double & val) const int comp, double & val) const
{ {
shared_ptr<Mesh> mesh = GetMesh();
bool ok; bool ok;
if (comp == 0) if (comp == 0)
{ {
@ -3399,6 +3417,7 @@ namespace netgen
case SOL_NODAL: case SOL_NODAL:
{ {
shared_ptr<Mesh> mesh = GetMesh();
const Element2d & el = (*mesh)[selnr]; const Element2d & el = (*mesh)[selnr];
double lami[8]; double lami[8];
@ -3457,6 +3476,7 @@ namespace netgen
case SOL_ELEMENT: case SOL_ELEMENT:
{ {
shared_ptr<Mesh> mesh = GetMesh();
int el1, el2; int el1, el2;
mesh->GetTopology().GetSurface2VolumeElement (selnr+1, el1, el2); mesh->GetTopology().GetSurface2VolumeElement (selnr+1, el1, el2);
el1--; el1--;
@ -3480,6 +3500,7 @@ namespace netgen
case SOL_SURFACE_NONCONTINUOUS: case SOL_SURFACE_NONCONTINUOUS:
{ {
shared_ptr<Mesh> mesh = GetMesh();
const Element2d & el = (*mesh)[selnr]; const Element2d & el = (*mesh)[selnr];
double lami[8]; double lami[8];
@ -3554,12 +3575,14 @@ namespace netgen
case SOL_MARKED_ELEMENTS: case SOL_MARKED_ELEMENTS:
{ {
shared_ptr<Mesh> mesh = GetMesh();
val = (*mesh)[selnr].TestRefinementFlag(); val = (*mesh)[selnr].TestRefinementFlag();
return 1; return 1;
} }
case SOL_ELEMENT_ORDER: case SOL_ELEMENT_ORDER:
{ {
shared_ptr<Mesh> mesh = GetMesh();
val = (*mesh)[selnr].GetOrder(); val = (*mesh)[selnr].GetOrder();
return 1; return 1;
} }
@ -4813,12 +4836,14 @@ void (*glGenBuffers) (GLsizei a, GLuint *b);
void (*glBufferData) (GLenum a, GLsizeiptr b, const GLvoid *c, GLenum d); void (*glBufferData) (GLenum a, GLsizeiptr b, const GLvoid *c, GLenum d);
void (*glBufferSubData) (GLenum a, GLintptr b, GLsizeiptr c, const GLvoid *d); void (*glBufferSubData) (GLenum a, GLintptr b, GLsizeiptr c, const GLvoid *d);
DLL_HEADER void LoadOpenGLFunctionPointers() { DLL_HEADER void LoadOpenGLFunctionPointers() {
#ifdef USE_BUFFERS
glBindBuffer = (decltype(glBindBuffer)) wglGetProcAddress("glBindBuffer"); glBindBuffer = (decltype(glBindBuffer)) wglGetProcAddress("glBindBuffer");
glBufferSubData = (decltype(glBufferSubData)) wglGetProcAddress("glBufferSubData"); glBufferSubData = (decltype(glBufferSubData)) wglGetProcAddress("glBufferSubData");
glBufferData = (decltype(glBufferData)) wglGetProcAddress("glBufferData"); glBufferData = (decltype(glBufferData)) wglGetProcAddress("glBufferData");
glDeleteBuffers = (decltype(glDeleteBuffers)) wglGetProcAddress("glDeleteBuffers"); glDeleteBuffers = (decltype(glDeleteBuffers)) wglGetProcAddress("glDeleteBuffers");
glGenBuffers = (decltype(glGenBuffers)) wglGetProcAddress("glGenBuffers"); glGenBuffers = (decltype(glGenBuffers)) wglGetProcAddress("glGenBuffers");
if(!glBindBuffer) throw std::runtime_error("Could not load OpenGL functions!"); if(!glBindBuffer) throw std::runtime_error("Could not load OpenGL functions!");
#endif
} }
#else // WIN32 #else // WIN32
DLL_HEADER void LoadOpenGLFunctionPointers() { } DLL_HEADER void LoadOpenGLFunctionPointers() { }

8
libsrc/visualization/vssolution.hpp
View File

@ -43,7 +43,13 @@ class DLL_HEADER VisualSceneSolution : public VisualScene
Point<3> p; Point<3> p;
}; };
// #define USE_BUFFERS #ifndef WIN32
// use OpenGL vertex buffers from OpenGL 2.x
// not supported by some drivers on windows
// try on your own responsibility
#define USE_BUFFERS
#endif
#ifdef USE_BUFFERS #ifdef USE_BUFFERS
bool has_surfel_vbo = false; bool has_surfel_vbo = false;
GLuint surfel_vbo[4]; // GLuint surfel_vbo[4]; //

57
ng/CMakeLists.txt
View File

@ -1,24 +1,57 @@
set(netgen_sources demoview.cpp ngappinit.cpp onetcl.cpp parallelfunc.cpp ngpkg.cpp ../libsrc/stlgeom/stlpkg.cpp ../libsrc/visualization/visualpkg.cpp ../libsrc/csg/csgpkg.cpp ../libsrc/geom2d/geom2dpkg.cpp ../libsrc/occ/occpkg.cpp ../libsrc/occ/vsocc.cpp) if(USE_INTERNAL_TCL)
add_definitions(-DINTERNAL_TCL_DEFAULT=1)
else()
add_definitions(-DINTERNAL_TCL_DEFAULT=0)
endif()
if(USE_GUI) set(netgen_sources ngappinit.cpp onetcl.cpp)
if(WIN32) if(WIN32)
# add icon to netgen executable # add icon to netgen executable
enable_language(RC) enable_language(RC)
set(netgen_sources ${netgen_sources} ../windows/netgen.rc) set(netgen_sources ${netgen_sources} ../windows/netgen.rc)
# Don't use ccache here due to incompatiblity with the resource compiler # Don't use ccache here due to incompatiblity with the resource compiler
set_directory_properties(PROPERTIES RULE_LAUNCH_COMPILE "") set_directory_properties(PROPERTIES RULE_LAUNCH_COMPILE "")
endif(WIN32) endif(WIN32)
if(USE_GUI)
add_library(gui SHARED
gui.cpp ngpkg.cpp demoview.cpp parallelfunc.cpp
../libsrc/stlgeom/stlpkg.cpp ../libsrc/visualization/visualpkg.cpp
../libsrc/csg/csgpkg.cpp ../libsrc/geom2d/geom2dpkg.cpp
../libsrc/occ/occpkg.cpp ../libsrc/occ/vsocc.cpp
)
add_executable(netgen ngappinit.cpp onetcl.cpp)
target_link_libraries( gui PUBLIC nglib ${ZLIB_LIBRARIES} ${JPEG_LIBRARIES} ${FFMPEG_LIBRARIES} ${X11_X11_LIB} ${OCC_LIBRARIES} )
target_link_libraries( gui PRIVATE ${LIBTOGL})
target_link_libraries( netgen nglib gui )
if(APPLE)
# Leave decision about which tcl/tk version to use open to python (and it's tkinter package).
# Thus, only link tcl/tk to the netgen executable and not to the gui library.
target_link_libraries( netgen ${TK_LIBRARY} ${TCL_LIBRARY})
else(APPLE)
# On other systems assume that the found libraries are compatible with python/tkinter
target_link_libraries( gui PUBLIC ${TK_LIBRARY} ${TCL_LIBRARY})
endif(APPLE)
add_executable(netgen ${netgen_sources})
target_link_libraries( netgen nglib ${ZLIB_LIBRARIES} ${LIBTOGL} ${TK_LIBRARY} ${TCL_LIBRARY} ${JPEG_LIBRARIES} ${FFMPEG_LIBRARIES} ${X11_X11_LIB} ${OCC_LIBRARIES})
if(NOT WIN32) if(NOT WIN32)
target_link_libraries( netgen mesh stlvis stl geom2dvis interface geom2d csg stl visual csgvis ) target_link_libraries( netgen mesh stlvis stl geom2dvis interface geom2d csg stl visual csgvis )
target_link_libraries( gui PUBLIC mesh stlvis stl geom2dvis interface geom2d csg stl visual csgvis )
endif(NOT WIN32) endif(NOT WIN32)
install(TARGETS netgen ${ng_install_dir}) install(TARGETS netgen ${NG_INSTALL_DIR})
install(TARGETS gui ${NG_INSTALL_DIR})
if(APPLE) if(APPLE)
set_target_properties(netgen PROPERTIES OUTPUT_NAME netgen) set_target_properties(netgen PROPERTIES OUTPUT_NAME netgen)
endif(APPLE) endif(APPLE)
if(WIN32)
set_target_properties( gui PROPERTIES OUTPUT_NAME libgui )
endif(WIN32)
endif(USE_GUI) endif(USE_GUI)
@ -31,18 +64,20 @@ if(USE_PYTHON)
set_target_properties( ngpy PROPERTIES SUFFIX ".pyd") set_target_properties( ngpy PROPERTIES SUFFIX ".pyd")
set_target_properties( ngpy PROPERTIES OUTPUT_NAME "libngpy") set_target_properties( ngpy PROPERTIES OUTPUT_NAME "libngpy")
endif() endif()
install(TARGETS ngpy ${ng_install_dir}) set_target_properties(ngpy PROPERTIES INSTALL_RPATH "${NG_RPATH_TOKEN}/../${NETGEN_PYTHON_RPATH}")
install(TARGETS ngpy DESTINATION ${NG_INSTALL_DIR_PYTHON}/${NG_INSTALL_SUFFIX})
endif(USE_PYTHON) endif(USE_PYTHON)
if(USE_GUI) if(USE_GUI)
if(NOT USE_INTERNAL_TCL)
install(FILES install(FILES
dialog.tcl menustat.tcl ngicon.tcl ng.tcl dialog.tcl menustat.tcl ngicon.tcl ng.tcl
ngvisual.tcl sockets.tcl nghelp.tcl ngshell.tcl ngvisual.tcl sockets.tcl nghelp.tcl ngshell.tcl
ngtesting.tcl parameters.tcl variables.tcl csgeom.tcl stlgeom.tcl ngtesting.tcl parameters.tcl variables.tcl csgeom.tcl stlgeom.tcl
occgeom.tcl acisgeom.tcl netgen.ocf occgeom.tcl acisgeom.tcl netgen.ocf drawing.tcl
DESTINATION ${ng_install_dir_bin} COMPONENT netgen) DESTINATION ${NG_INSTALL_DIR_BIN} COMPONENT netgen)
endif()
add_subdirectory(Togl2.1) add_subdirectory(Togl2.1)
install(FILES drawing.tcl DESTINATION ${ng_install_dir_bin} COMPONENT netgen)
endif(USE_GUI) endif(USE_GUI)

7
ng/Togl2.1/CMakeLists.txt
View File

@ -7,13 +7,14 @@ endif(APPLE)
if(WIN32) if(WIN32)
add_definitions("-DBUILD_togl -DUNICODE -D_UNICODE -DTOGL_USE_FONTS=0 -DSTDC_HEADERS -DSTDC_HEADER") add_definitions("-DBUILD_togl -DUNICODE -D_UNICODE -DTOGL_USE_FONTS=0 -DSTDC_HEADERS -DSTDC_HEADER")
add_library(togl SHARED togl.c toglProcAddr.c toglStubInit.c) add_library(togl SHARED togl.c toglProcAddr.c toglStubInit.c)
install(TARGETS togl DESTINATION ${ng_install_dir} COMPONENT netgen) install(TARGETS togl DESTINATION ${NG_INSTALL_DIR} COMPONENT netgen)
target_link_libraries(togl ${TCL_LIBRARY} ${TK_LIBRARY})
else(WIN32) else(WIN32)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fomit-frame-pointer -Wno-implicit-int") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fomit-frame-pointer -Wno-implicit-int")
add_definitions("-DPACKAGE_NAME=\"Togl\" -DPACKAGE_TARNAME=\"togl\" -DPACKAGE_VERSION=\"2.1\" -DPACKAGE_STRING=\"Togl\ 2.1\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=0 -DHAVE_LIMITS_H=1 -DHAVE_SYS_PARAM_H=1 -DUSE_THREAD_ALLOC=1 -D_REENTRANT=1 -D_THREAD_SAFE=1 -DTCL_THREADS=1 -DMODULE_SCOPE=extern\ __attribute__\(\(__visibility__\(\"hidden\"\)\)\) -D_LARGEFILE64_SOURCE=1 -DTCL_WIDE_INT_IS_LONG=1 -DUSE_TCL_STUBS=1 -DUSE_TK_STUBS=1 -DAUTOSTEREOD=\"\"") add_definitions("-DPACKAGE_NAME=\"Togl\" -DPACKAGE_TARNAME=\"togl\" -DPACKAGE_VERSION=\"2.1\" -DPACKAGE_STRING=\"Togl\ 2.1\" -DPACKAGE_BUGREPORT=\"\" -DPACKAGE_URL=\"\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=0 -DHAVE_LIMITS_H=1 -DHAVE_SYS_PARAM_H=1 -DUSE_THREAD_ALLOC=1 -D_REENTRANT=1 -D_THREAD_SAFE=1 -DTCL_THREADS=1 -DMODULE_SCOPE=extern\ __attribute__\(\(__visibility__\(\"hidden\"\)\)\) -D_LARGEFILE64_SOURCE=1 -DTCL_WIDE_INT_IS_LONG=1 -DUSE_TCL_STUBS=1 -DUSE_TK_STUBS=1 -DAUTOSTEREOD=\"\"")
include_directories(BEFORE "${TCL_INCLUDE_PATH}/tcl-private/generic" "${TCL_INCLUDE_PATH}/tcl-private/unix") include_directories(BEFORE "${TCL_INCLUDE_PATH}/tcl-private/generic" "${TCL_INCLUDE_PATH}/tcl-private/unix")
include_directories(BEFORE "${TCL_INCLUDE_PATH}/tk-private/generic" "${TCL_INCLUDE_PATH}/tk-private/unix") include_directories(BEFORE "${TK_INCLUDE_PATH}/tk-private/generic" "${TK_INCLUDE_PATH}/tk-private/unix" "${TK_INCLUDE_PATH}/tk-private")
include_directories(BEFORE "${TCL_INCLUDE_PATH}/tk-private/generic/ttk") include_directories(BEFORE "${TCL_INCLUDE_PATH}/tk-private/generic/ttk")
include_directories(BEFORE "${TK_INCLUDE_PATH}/../PrivateHeaders") include_directories(BEFORE "${TK_INCLUDE_PATH}/../PrivateHeaders")
include_directories(BEFORE "${TCL_INCLUDE_PATH}") include_directories(BEFORE "${TCL_INCLUDE_PATH}")
@ -23,5 +24,5 @@ else(WIN32)
target_link_libraries(togl -ldl) target_link_libraries(togl -ldl)
endif(WIN32) endif(WIN32)
target_link_libraries(togl ${OPENGL_LIBRARIES} ${TK_LIBRARY} ${TCL_LIBRARY} ) target_link_libraries(togl ${OPENGL_LIBRARIES})
set_target_properties(togl PROPERTIES POSITION_INDEPENDENT_CODE ON ) set_target_properties(togl PROPERTIES POSITION_INDEPENDENT_CODE ON )

11
ng/Togl2.1/togl.c
View File

@ -165,11 +165,12 @@
# endif # endif
#endif /* TOGL_AGL */ #endif /* TOGL_AGL */
#if defined(TOGL_NSOPENGL) // Seems to work with Apple Tcl 8.5 too....
# if TK_MAJOR_VERSION < 8 || (TK_MAJOR_VERSION == 8 && TK_MINOR_VERSION < 6) // #if defined(TOGL_NSOPENGL)
# error Sorry Mac Cocoa version requires Tcl/Tk ver 8.6.0 or higher. // # if TK_MAJOR_VERSION < 8 || (TK_MAJOR_VERSION == 8 && TK_MINOR_VERSION < 6)
# endif // # error Sorry Mac Cocoa version requires Tcl/Tk ver 8.6.0 or higher.
#endif /* TOGL_NSOPENGL */ // # endif
// #endif /* TOGL_NSOPENGL */
#if defined(TOGL_WGL) && defined(_MSC_VER) #if defined(TOGL_WGL) && defined(_MSC_VER)
# define snprintf _snprintf # define snprintf _snprintf

41
ng/gui.cpp Normal file
View File

@ -0,0 +1,41 @@
#include <mystdlib.h>
#include <inctcl.hpp>
#include <meshing.hpp>
#ifdef WIN32
#define DLL_HEADER_IMPORT __declspec(dllimport)
#define DLL_HEADER_EXPORT __declspec(dllexport)
#else
#define DLL_HEADER_IMPORT
#define DLL_HEADER_EXPORT
#endif
namespace netgen
{
DLL_HEADER_EXPORT Flags parameters;
}
DLL_HEADER_EXPORT bool nodisplay = false;
extern "C" int Ng_Init (Tcl_Interp * interp);
extern "C" int Ng_Vis_Init (Tcl_Interp * interp);
extern "C" void Ng_TclCmd(string);
// tcl package dynamic load
extern "C" int DLL_HEADER_EXPORT Gui_Init (Tcl_Interp * interp)
{
if (Ng_Init(interp) == TCL_ERROR) {
cerr << "Problem in Ng_Init: " << endl;
cout << "result = " << Tcl_GetStringResult (interp) << endl;
return TCL_ERROR;
}
if (!nodisplay && Ng_Vis_Init(interp) == TCL_ERROR) {
cerr << "Problem in Ng_Vis_Init: " << endl;
cout << "result = " << Tcl_GetStringResult (interp) << endl;
return TCL_ERROR;
}
return TCL_OK;
}

3
ng/menustat.tcl
View File

@ -352,7 +352,7 @@ proc demoredraw { } {
set file [tk_getSaveFile -filetypes $types] set file [tk_getSaveFile -filetypes $types]
# -defaultextension ".ppm"] # -defaultextension ".ppm"]
if {$file != ""} { if {$file != ""} {
.ndraw Ng_SnapShot $file } Ng_SnapShot .ndraw $file }
} }
@ -421,6 +421,7 @@ set videoactive 0
# puts "error: $result" # puts "error: $result"
} }
after cancel { timer2 }
Ng_Exit; Ng_Exit;
destroy . destroy .
} }

7
ng/netgenpy.cpp
View File

@ -17,6 +17,9 @@ void DLL_HEADER ExportCSGVis(py::module &m);
void DLL_HEADER ExportGeom2d(py::module &m); void DLL_HEADER ExportGeom2d(py::module &m);
void DLL_HEADER ExportSTL(py::module &m); void DLL_HEADER ExportSTL(py::module &m);
void DLL_HEADER ExportSTLVis(py::module &m); void DLL_HEADER ExportSTLVis(py::module &m);
#ifdef OCCGEOMETRY
void DLL_HEADER ExportNgOCC(py::module &m);
#endif // OCCGEOMETRY
PYBIND11_PLUGIN(libngpy) PYBIND11_PLUGIN(libngpy)
{ {
@ -29,6 +32,10 @@ PYBIND11_PLUGIN(libngpy)
ExportGeom2d(geom2d); ExportGeom2d(geom2d);
py::module stl = ngpy.def_submodule("_stl", "pybind stl module"); py::module stl = ngpy.def_submodule("_stl", "pybind stl module");
ExportSTL(stl); ExportSTL(stl);
#ifdef OCCGEOMETRY
py::module NgOCC = ngpy.def_submodule("_NgOCC", "pybind NgOCC module");
ExportNgOCC(NgOCC);
#endif // OCCGEOMETRY
#ifdef OPENGL #ifdef OPENGL
py::module meshvis = ngpy.def_submodule("meshvis", "pybind meshvis module"); py::module meshvis = ngpy.def_submodule("meshvis", "pybind meshvis module");
ExportMeshVis(meshvis); ExportMeshVis(meshvis);

22
ng/ng.tcl
View File

@ -1,4 +1,9 @@
catch {lappend auto_path $env(NETGENDIR) } catch {lappend auto_path $env(NETGENDIR) }
catch {lappend auto_path $env(NETGENDIR)/../lib }
if {[catch {Ng_GetCommandLineParameter batchmode} result ]} {
load libgui[info sharedlibextension] gui
}
set batchmode [Ng_GetCommandLineParameter batchmode] set batchmode [Ng_GetCommandLineParameter batchmode]
if {$batchmode=="undefined"} { if {$batchmode=="undefined"} {
@ -264,7 +269,22 @@ if { $stereo == "defined" } {
} }
catch { source ${ngdir}/ngsolve.tcl } set ngsolve_loaded 0
catch {
source ${ngdir}/ngsolve.tcl;
set ngsolve_loaded 1
}
# try to find ngsolve.tcl in PATH
set pathlist [split $::env(PATH) \ [expr {$::tcl_platform(platform) == "windows" ? ";" : ":"}]]
foreach dir $pathlist {
if { $ngsolve_loaded != 1 } {
catch {
source ${dir}/ngsolve.tcl
set ngsolve_loaded 1
}
}
}
set scriptfilename [Ng_GetCommandLineParameter script] set scriptfilename [Ng_GetCommandLineParameter script]

57
ng/ngappinit.cpp
View File

@ -7,17 +7,6 @@
#include <inctcl.hpp> #include <inctcl.hpp>
#include <meshing.hpp> #include <meshing.hpp>
#ifdef NGPYTHON
#include <boost/python.hpp>
#endif
/*
namespace netgen
{
int id = 0, ntasks = 1;
}
*/
#ifdef PARALLEL #ifdef PARALLEL
#include <mpi.h> #include <mpi.h>
@ -33,9 +22,11 @@ namespace netgen
namespace netgen namespace netgen
{ {
Flags parameters; DLL_HEADER extern Flags parameters;
DLL_HEADER extern bool netgen_executable_started;
} }
DLL_HEADER extern bool nodisplay;
using netgen::parameters; using netgen::parameters;
@ -58,7 +49,6 @@ using netgen::RegisterUserFormats;
extern "C" int Ng_ServerSocketManagerInit (int port); extern "C" int Ng_ServerSocketManagerInit (int port);
extern "C" int Ng_ServerSocketManagerRun (void); extern "C" int Ng_ServerSocketManagerRun (void);
bool nodisplay = false;
bool shellmode = false; bool shellmode = false;
@ -70,6 +60,7 @@ bool shellmode = false;
int main(int argc, char ** argv) int main(int argc, char ** argv)
{ {
netgen::netgen_executable_started = true;
#ifdef PARALLEL #ifdef PARALLEL
int mpi_required = MPI_THREAD_MULTIPLE; int mpi_required = MPI_THREAD_MULTIPLE;
@ -200,7 +191,7 @@ int main(int argc, char ** argv)
// parse tcl-script // parse tcl-script
int errcode; int errcode;
bool internaltcl = false; bool internaltcl = INTERNAL_TCL_DEFAULT;
if (shellmode) if (shellmode)
internaltcl = false; internaltcl = false;
@ -348,26 +339,6 @@ int Tcl_AppInit(Tcl_Interp * interp)
// return TCL_ERROR; // return TCL_ERROR;
} }
if (Ng_Init(interp) == TCL_ERROR) {
cerr << "Problem in Ng_Init: " << endl;
cout << "result = " << Tcl_GetStringResult (interp) << endl;
// cerr << interp->result << endl;
// return TCL_ERROR;
}
if (!nodisplay && Ng_Vis_Init(interp) == TCL_ERROR) {
cerr << "Problem in Ng_Vis_Init: " << endl;
cout << "result = " << Tcl_GetStringResult (interp) << endl;
// cerr << interp->result << endl;
// return TCL_ERROR;
}
#ifdef TRAFO #ifdef TRAFO
// extern int Trafo_Init (Tcl_Interp * interp); // extern int Trafo_Init (Tcl_Interp * interp);
// if (Trafo_Init(interp) == TCL_ERROR) // if (Trafo_Init(interp) == TCL_ERROR)
@ -427,21 +398,3 @@ int Tcl_AppInit(Tcl_Interp * interp)
return TCL_OK; return TCL_OK;
} }
// link MKL with netgen
// necessary for MKL 11.x, since MKL complains if started
// from the ngsolve shared library
#ifdef LINKMKL
extern "C" double ddot_(int *n, double *dx, int *incx, double *dy,
int *incy);
void mkldummy()
{
int n = 1, one = 1;
double a = 1, b = 1;
ddot_(&n, &a, &one, &b, &one);
}
#endif

146
ng/ngpkg.cpp
View File

@ -1994,91 +1994,26 @@ namespace netgen
} }
#if TOGL_MAJOR_VERSION==1 static int Ng_SnapShot(ClientData clientData, Tcl_Interp *interp, int argc, Tcl_Obj *const *argv)
#ifndef JPEGLIB
static int Ng_SnapShot (struct Togl * togl,
int argc, tcl_const char *argv[])
{ {
const char * filename = argv[2]; struct Togl *togl;
if (Togl_GetToglFromObj(interp, argv[1], &togl) != TCL_OK)
return TCL_ERROR;
const char * filename = Tcl_GetString(argv[2]);
char str[250];
char filename2[250];
int len = strlen(filename); int len = strlen(filename);
strcpy (filename2, filename);
filename2[len-3] = 'p';
filename2[len-2] = 'p';
filename2[len-1] = 'm';
filename2[len] = 0;
cout << "Snapshot to file '" << filename << endl;
int w = Togl_Width (togl); int w = Togl_Width (togl);
w = int((w + 1) / 4) * 4 + 4;
int h = Togl_Height (togl); int h = Togl_Height (togl);
// unsigned char * buffer = new unsigned char[w*h*4]; Array<char> buffer(w*h*3);
unsigned char * buffer = new unsigned char[w*h*3]; glReadPixels (0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, &buffer[0]);
glReadPixels (0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, buffer);
ofstream outfile(filename2);
outfile << "P6" << endl
<< "# CREATOR: Netgen" << endl
<< w << " " << h << endl
<< "255" << endl;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
for (int k = 0; k < 3; k++)
outfile.put (buffer[k+3*j+3*w*(h-i-1)]);
outfile << flush;
delete[] buffer;
// convert image file (Unix/Linux only):
sprintf(str,"convert -quality 100 %s %s", filename2, filename);
int err = system(str);
if (err != 0)
{
Tcl_SetResult (Togl_Interp(togl), (char*)"Cannot convert image file", TCL_VOLATILE);
return TCL_ERROR;
}
sprintf(str,"rm %s", filename2);
err = system(str);
if (err != 0)
{
Tcl_SetResult (Togl_Interp(togl), (char*)"Cannot delete temporary file", TCL_VOLATILE);
return TCL_ERROR;
}
return TCL_OK;
}
#else
static int Ng_SnapShot (struct Togl * togl,
int argc, tcl_const char *argv[])
{
const char * filename = argv[2];
int len = strlen(filename);
#ifdef JPEGLIB
if (strcmp ("jpg", filename+len-3) == 0) if (strcmp ("jpg", filename+len-3) == 0)
{ {
cout << "Snapshot to file '" << filename << "'" << endl; cout << "Snapshot to file '" << filename << "'" << endl;
int w = Togl_Width (togl);
// w = int((w + 1) / 4) * 4 + 4;
int h = Togl_Height (togl);
// unsigned char * buffer = new unsigned char[w*h*4];
unsigned char * buffer = new unsigned char[w*h*3];
glReadPixels (0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, buffer);
struct jpeg_compress_struct cinfo; struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr; struct jpeg_error_mgr jerr;
FILE *outfile = fopen(filename,"wb"); FILE *outfile = fopen(filename,"wb");
@ -2112,10 +2047,57 @@ namespace netgen
fprintf( stdout, "done [ok]\n" ); fprintf( stdout, "done [ok]\n" );
fflush( stdout ); fflush( stdout );
free( buffer );
return TCL_OK; return TCL_OK;
} }
else #endif // JPEGLIB
{
char str[250];
char filename2[250];
int len = strlen(filename);
strcpy (filename2, filename);
filename2[len-3] = 'p';
filename2[len-2] = 'p';
filename2[len-1] = 'm';
filename2[len] = 0;
cout << "Snapshot to file '" << filename << endl;
int w = Togl_Width (togl);
w = int((w + 1) / 4) * 4 + 4;
int h = Togl_Height (togl);
ofstream outfile(filename2);
outfile << "P6" << endl
<< "# CREATOR: Netgen" << endl
<< w << " " << h << endl
<< "255" << endl;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
for (int k = 0; k < 3; k++)
outfile.put (buffer[k+3*j+3*w*(h-i-1)]);
outfile << flush;
// convert image file (Unix/Linux only):
sprintf(str,"convert -quality 100 %s %s", filename2, filename);
int err = system(str);
if (err != 0)
{
Tcl_SetResult (Togl_Interp(togl), (char*)"Cannot convert image file", TCL_VOLATILE);
return TCL_ERROR;
}
sprintf(str,"rm %s", filename2);
err = system(str);
if (err != 0)
{
Tcl_SetResult (Togl_Interp(togl), (char*)"Cannot delete temporary file", TCL_VOLATILE);
return TCL_ERROR;
}
}
{ {
cout << "Snapshot to " << filename << " not supported" << endl; cout << "Snapshot to " << filename << " not supported" << endl;
return TCL_ERROR; return TCL_ERROR;
@ -2123,18 +2105,6 @@ namespace netgen
} }
#endif
#else
// TODO: JPEGLIB for Togl2
#endif
#ifdef FFMPEG #ifdef FFMPEG
static int Ng_VideoClip(ClientData clientData, Tcl_Interp *interp, int argc, Tcl_Obj *const *argv) static int Ng_VideoClip(ClientData clientData, Tcl_Interp *interp, int argc, Tcl_Obj *const *argv)
@ -3083,7 +3053,7 @@ void PlayAnimFile(const char* name, int speed, int maxcnt)
Tcl_CreateObjCommand(interp, "reshape", reshape, NULL, NULL); Tcl_CreateObjCommand(interp, "reshape", reshape, NULL, NULL);
// Togl_TimerFunc( idle ); // Togl_TimerFunc( idle );
// Togl_CreateCommand( (char*)"Ng_SnapShot", Ng_SnapShot); Tcl_CreateObjCommand(interp, "Ng_SnapShot", Ng_SnapShot, NULL, NULL);
Tcl_CreateObjCommand(interp, "Ng_VideoClip", Ng_VideoClip, NULL, NULL); Tcl_CreateObjCommand(interp, "Ng_VideoClip", Ng_VideoClip, NULL, NULL);
} }

47
ng/onetcl.cpp
View File

@ -1,5 +1,9 @@
const char * ngscript[] = {"" const char * ngscript[] = {""
,"catch {lappend auto_path $env(NETGENDIR) }\n" ,"catch {lappend auto_path $env(NETGENDIR) }\n"
,"catch {lappend auto_path $env(NETGENDIR)/../lib }\n"
,"if {[catch {Ng_GetCommandLineParameter batchmode} result ]} {\n"
,"load libgui[info sharedlibextension] gui\n"
,"}\n"
,"set batchmode [Ng_GetCommandLineParameter batchmode]\n" ,"set batchmode [Ng_GetCommandLineParameter batchmode]\n"
,"if {$batchmode==\"undefined\"} {\n" ,"if {$batchmode==\"undefined\"} {\n"
,"if {[catch {package require tkdnd } result ]} {\n" ,"if {[catch {package require tkdnd } result ]} {\n"
@ -922,7 +926,7 @@ const char * ngscript[] = {""
,"global videoactive\n" ,"global videoactive\n"
,"if { $videoactive == 1 } {\n" ,"if { $videoactive == 1 } {\n"
,"puts \"addframe\"\n" ,"puts \"addframe\"\n"
,".ndraw Ng_VideoClip addframe\n" ,"Ng_VideoClip .ndraw addframe\n"
,"}\n" ,"}\n"
,"if { $result == 0 && $stopdemo == 0 } {\n" ,"if { $result == 0 && $stopdemo == 0 } {\n"
,"after 1 { demoredraw }\n" ,"after 1 { demoredraw }\n"
@ -949,7 +953,7 @@ const char * ngscript[] = {""
,"}\n" ,"}\n"
,"set file [tk_getSaveFile -filetypes $types]\n" ,"set file [tk_getSaveFile -filetypes $types]\n"
,"if {$file != \"\"} {\n" ,"if {$file != \"\"} {\n"
,".ndraw Ng_SnapShot $file }\n" ,"Ng_SnapShot .ndraw $file }\n"
,"}\n" ,"}\n"
,".ngmenu.file add cascade -label \"Video clip\" -menu .ngmenu.file.video\n" ,".ngmenu.file add cascade -label \"Video clip\" -menu .ngmenu.file.video\n"
,"menu .ngmenu.file.video\n" ,"menu .ngmenu.file.video\n"
@ -961,13 +965,13 @@ const char * ngscript[] = {""
,"}\n" ,"}\n"
,"set file [tk_getSaveFile -filetypes $types]\n" ,"set file [tk_getSaveFile -filetypes $types]\n"
,"if {$file != \"\"} {\n" ,"if {$file != \"\"} {\n"
,".ndraw Ng_VideoClip init $file\n" ,"Ng_VideoClip .ndraw init $file\n"
,"global videoactive\n" ,"global videoactive\n"
,"set videoactive 1\n" ,"set videoactive 1\n"
,"}\n" ,"}\n"
,"}\n" ,"}\n"
,".ngmenu.file.video add command -label \"add frame...\" \\\n" ,".ngmenu.file.video add command -label \"add frame...\" \\\n"
,"-command {.ndraw Ng_VideoClip addframe }\n" ,"-command {Ng_VideoClip .ndraw addframe }\n"
,".ngmenu.file.video add command -label \"one cycle\" \\\n" ,".ngmenu.file.video add command -label \"one cycle\" \\\n"
,"-command {\n" ,"-command {\n"
,"set visoptions.redrawperiodic 1\n" ,"set visoptions.redrawperiodic 1\n"
@ -975,13 +979,13 @@ const char * ngscript[] = {""
,"puts \"j = $j\"\n" ,"puts \"j = $j\"\n"
,"Ng_Vis_Set time [expr (1000 * $j / 100)]\n" ,"Ng_Vis_Set time [expr (1000 * $j / 100)]\n"
,"redraw\n" ,"redraw\n"
,".ndraw Ng_VideoClip addframe\n" ,"Ng_VideoClip .ndraw addframe\n"
,"after 200\n" ,"after 200\n"
,"}\n" ,"}\n"
,"}\n" ,"}\n"
,".ngmenu.file.video add command -label \"finalize...\" \\\n" ,".ngmenu.file.video add command -label \"finalize...\" \\\n"
,"-command {\n" ,"-command {\n"
,".ndraw Ng_VideoClip finalize\n" ,"Ng_VideoClip .ndraw finalize\n"
,"global videoactive\n" ,"global videoactive\n"
,"set videoactive 0\n" ,"set videoactive 0\n"
,"}\n" ,"}\n"
@ -993,6 +997,7 @@ const char * ngscript[] = {""
,"puts \"Thank you for using $progname\";\n" ,"puts \"Thank you for using $progname\";\n"
,"if { [catch { unload libngsolve[info sharedlibextension] ngsolve } result ] } {\n" ,"if { [catch { unload libngsolve[info sharedlibextension] ngsolve } result ] } {\n"
,"}\n" ,"}\n"
,"after cancel { timer2 }\n"
,"Ng_Exit;\n" ,"Ng_Exit;\n"
,"destroy .\n" ,"destroy .\n"
,"}\n" ,"}\n"
@ -1336,7 +1341,7 @@ const char * ngscript[] = {""
,"global videoactive\n" ,"global videoactive\n"
,"if { $videoactive == 1 } {\n" ,"if { $videoactive == 1 } {\n"
,"puts \"addframe\"\n" ,"puts \"addframe\"\n"
,".ndraw Ng_VideoClip addframe\n" ,"Ng_VideoClip .ndraw addframe\n"
,"}\n" ,"}\n"
,"}\n" ,"}\n"
,"if { $multithread_redraw == 2 } {\n" ,"if { $multithread_redraw == 2 } {\n"
@ -1345,7 +1350,7 @@ const char * ngscript[] = {""
,"global videoactive\n" ,"global videoactive\n"
,"if { $videoactive == 1 } {\n" ,"if { $videoactive == 1 } {\n"
,"puts \"addframe\"\n" ,"puts \"addframe\"\n"
,".ndraw Ng_VideoClip addframe\n" ,"Ng_VideoClip .ndraw addframe\n"
,"}\n" ,"}\n"
,"after 1 { timer2 }\n" ,"after 1 { timer2 }\n"
,"return\n" ,"return\n"
@ -2535,10 +2540,10 @@ const char * ngscript[] = {""
,"wm deiconify $w\n" ,"wm deiconify $w\n"
,"} {\n" ,"} {\n"
,"toplevel $w\n" ,"toplevel $w\n"
,"frame $w.face -borderwidth 3\n" ,"ttk::frame $w.face -borderwidth 3\n"
,"pack $w.face -fill x\n" ,"pack $w.face -fill x\n"
,"ttk::label $w.face.lab -text \"face index:\"\n" ,"ttk::label $w.face.lab -text \"face index:\"\n"
,"ttk::label $w.face.ent -text 1 -padx 4\n" ,"ttk::label $w.face.ent -text 1\n"
,"ttk::button $w.face.next -text \"next\" -command {\n" ,"ttk::button $w.face.next -text \"next\" -command {\n"
,"set w .bcprop_dlg;\n" ,"set w .bcprop_dlg;\n"
,"set facenr [$w.face.ent cget -text]\n" ,"set facenr [$w.face.ent cget -text]\n"
@ -2570,7 +2575,7 @@ const char * ngscript[] = {""
,"redraw\n" ,"redraw\n"
,"}\n" ,"}\n"
,"pack $w.face.lab $w.face.ent $w.face.prev $w.face.next -side left\n" ,"pack $w.face.lab $w.face.ent $w.face.prev $w.face.next -side left\n"
,"frame $w.bc -borderwidth 3\n" ,"ttk::frame $w.bc -borderwidth 3\n"
,"pack $w.bc -fill x\n" ,"pack $w.bc -fill x\n"
,"ttk::label $w.bc.lab -text \"bc property:\"\n" ,"ttk::label $w.bc.lab -text \"bc property:\"\n"
,"entry $w.bc.ent -width 5 -relief sunken\n" ,"entry $w.bc.ent -width 5 -relief sunken\n"
@ -2583,12 +2588,12 @@ const char * ngscript[] = {""
,"Ng_BCProp setall [$w.bc.ent get];\n" ,"Ng_BCProp setall [$w.bc.ent get];\n"
,"}\n" ,"}\n"
,"pack $w.bc.lab $w.bc.ent $w.bc.but $w.bc.but2 -side left -expand yes\n" ,"pack $w.bc.lab $w.bc.ent $w.bc.but $w.bc.but2 -side left -expand yes\n"
,"frame $w.bcname -borderwidth 3\n" ,"ttk::frame $w.bcname -borderwidth 3\n"
,"pack $w.bcname -fill x\n" ,"pack $w.bcname -fill x\n"
,"ttk::label $w.bcname.lab -text \"bc name:\"\n" ,"ttk::label $w.bcname.lab -text \"bc name:\"\n"
,"ttk::label $w.bcname.ent -text \"-\"\n" ,"ttk::label $w.bcname.ent -text \"-\"\n"
,"pack $w.bcname.lab $w.bcname.ent -side left -expand yes\n" ,"pack $w.bcname.lab $w.bcname.ent -side left -expand yes\n"
,"frame $w.bu\n" ,"ttk::frame $w.bu\n"
,"pack $w.bu -fill x -ipady 3\n" ,"pack $w.bu -fill x -ipady 3\n"
,"ttk::button $w.bu.close -text \"Close\" -command { destroy .bcprop_dlg }\n" ,"ttk::button $w.bu.close -text \"Close\" -command { destroy .bcprop_dlg }\n"
,"pack $w.bu.close -expand yes -side left\n" ,"pack $w.bu.close -expand yes -side left\n"
@ -5943,7 +5948,20 @@ const char * ngscript[] = {""
,"Ng_SetVisParameters;\n" ,"Ng_SetVisParameters;\n"
,"redraw\n" ,"redraw\n"
,"}\n" ,"}\n"
,"catch { source ${ngdir}/ngsolve.tcl }\n" ,"set ngsolve_loaded 0\n"
,"catch {\n"
,"source ${ngdir}/ngsolve.tcl;\n"
,"set ngsolve_loaded 1\n"
,"}\n"
,"set pathlist [split $::env(PATH) \\ [expr {$::tcl_platform(platform) == \"windows\" ? \";\" : \":\"}]]\n"
,"foreach dir $pathlist {\n"
,"if { $ngsolve_loaded != 1 } {\n"
,"catch {\n"
,"source ${dir}/ngsolve.tcl\n"
,"set ngsolve_loaded 1\n"
,"}\n"
,"}\n"
,"}\n"
,"set scriptfilename [Ng_GetCommandLineParameter script]\n" ,"set scriptfilename [Ng_GetCommandLineParameter script]\n"
,"if { $scriptfilename != \"undefined\" } {\n" ,"if { $scriptfilename != \"undefined\" } {\n"
,"if { [catch { source $scriptfilename } errstring] == 1 } {\n" ,"if { [catch { source $scriptfilename } errstring] == 1 } {\n"
@ -5968,4 +5986,5 @@ const char * ngscript[] = {""
,"source startup.tcl }\n" ,"source startup.tcl }\n"
,"catch { source ${ngdir}/demoapp.tcl }\n" ,"catch { source ${ngdir}/demoapp.tcl }\n"
,"catch { source ${ngdir}/dropsexp.tcl }\n" ,"catch { source ${ngdir}/dropsexp.tcl }\n"
, nullptr
}; };

3
ng/onetcl.py
View File

@ -40,5 +40,6 @@ for line in tclfiles["ng.tcl"].split('\n'):
s = ',"' + line.replace('\\', r'\\').replace('"', r'\"') + '\\n"\n' s = ',"' + line.replace('\\', r'\\').replace('"', r'\"') + '\\n"\n'
onetclcpp.write(s) onetclcpp.write(s)
onetclcpp.write('};'+'\n'); onetclcpp.write(', nullptr\n');
onetclcpp.write('};\n');
onetclcpp.close(); onetclcpp.close();

17
nglib/CMakeLists.txt
View File

@ -28,7 +28,7 @@ if(NOT WIN32)
endif(USE_GUI) endif(USE_GUI)
endif(NOT WIN32) endif(NOT WIN32)
target_link_libraries( nglib ${OCC_LIBRARIES} ${MPI_CXX_LIBRARIES} ${OPENGL_LIBRARIES} ${TK_LIBRARY} ${TCL_LIBRARY} ${CMAKE_THREAD_LIBS_INIT} ${X11_Xmu_LIB} ${JPEG_LIBRARIES} ${MKL_LIBRARIES} ${ZLIB_LIBRARIES} ${OCC_LIBRARIES} ) target_link_libraries( nglib ${OCC_LIBRARIES} ${MPI_CXX_LIBRARIES} ${OPENGL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${X11_Xmu_LIB} ${JPEG_LIBRARIES} ${MKL_LIBRARIES} ${ZLIB_LIBRARIES} ${OCC_LIBRARIES} )
if(USE_OCC AND NOT WIN32) if(USE_OCC AND NOT WIN32)
target_link_libraries(nglib occ) target_link_libraries(nglib occ)
@ -38,16 +38,5 @@ if(USE_PYTHON)
target_link_libraries(nglib ${PYTHON_LIBRARIES}) target_link_libraries(nglib ${PYTHON_LIBRARIES})
endif(USE_PYTHON) endif(USE_PYTHON)
# if(NOT WIN32) install(TARGETS nglib ${NG_INSTALL_DIR})
# add_executable(ng_vol ng_vol.cpp ${nglib_objects}) install(FILES nglib.h DESTINATION ${NG_INSTALL_DIR_INCLUDE}/include COMPONENT netgen_devel)
# target_link_libraries( ng_vol nglib ${OCC_LIBRARIES} ${MPI_CXX_LIBRARIES} )
# target_link_libraries( ng_vol nglib interface geom2d csg stl occ mesh )
#
# add_executable(ng_stl ng_stl.cpp ${nglib_objects})
# target_link_libraries( ng_stl nglib ${OCC_LIBRARIES} ${OCC_OCAF_LIBRARIES} ${MPI_CXX_LIBRARIES} )
# target_link_libraries( ng_stl nglib interface geom2d csg stl occ mesh )
#
# install(TARGETS nglib ng_vol ng_stl ${ng_install_dir})
# endif(NOT WIN32)
install(TARGETS nglib ${ng_install_dir})

2
py_tutorials/CMakeLists.txt
View File

@ -1,5 +1,5 @@
install( FILES install( FILES
shaft.geo mesh.py exportNeutral.py shaft.geo mesh.py exportNeutral.py
DESTINATION share/netgen/py_tutorials DESTINATION ${NG_INSTALL_DIR_RES}/${NG_INSTALL_SUFFIX}/py_tutorials
COMPONENT netgen_tutorial COMPONENT netgen_tutorial
) )

4
py_tutorials/exportNeutral.py
View File

@ -17,8 +17,8 @@ def Export (mesh, filename):
print (len(volels), file=f) print (len(volels), file=f)
for el in volels: for el in volels:
print (el.index, end=" ", file=f) print (el.index, end=" ", file=f)
for j in el.vertices: for p in el.points:
print (j.nr, end=" ", file=f) print (p.nr, end=" ", file=f)
print(file=f) print(file=f)

29
py_tutorials/merge.py
View File

@ -3,28 +3,35 @@ from netgen.csg import *
from ngsolve import ngsglobals from ngsolve import ngsglobals
ngsglobals.msg_level = 2 ngsglobals.msg_level = 2
# generate brick and mesh it
geo1 = CSGeometry() geo1 = CSGeometry()
geo1.Add (OrthoBrick( Pnt(0,0,0), Pnt(1,1,1) )) geo1.Add (OrthoBrick( Pnt(0,0,0), Pnt(1,1,1) ))
m1 = geo1.GenerateMesh (maxh=0.1) m1 = geo1.GenerateMesh (maxh=0.1)
m1.Refine() m1.Refine()
m1.Refine()
# generate sphere and mesh it
geo2 = CSGeometry() geo2 = CSGeometry()
geo2.Add (Sphere (Pnt(0.5,0.5,0.5), 0.1)) geo2.Add (Sphere (Pnt(0.5,0.5,0.5), 0.1))
m2 = geo2.GenerateMesh (maxh=0.05) m2 = geo2.GenerateMesh (maxh=0.05)
m2.Refine() m2.Refine()
m2.Refine() m2.Refine()
print ("********************") print ("***************************")
print ("** start merging **") print ("** merging suface meshes **")
print ("********************") print ("***************************")
# create an empty mesh
mesh = Mesh() mesh = Mesh()
fd_outside = mesh.Add (FaceDescriptor(surfnr=1,domin=1))
fd_inside = mesh.Add (FaceDescriptor(surfnr=2,domin=2,domout=1))
# a face-descriptor stores properties associated with a set of surface elements
# bc .. boundary condition marker,
# domin/domout .. domain-number in front/back of surface elements (0 = void),
# surfnr .. number of the surface described by the face-descriptor
fd_outside = mesh.Add (FaceDescriptor(bc=1,domin=1,surfnr=1))
fd_inside = mesh.Add (FaceDescriptor(bc=2,domin=2,domout=1,surfnr=2))
# copy all boundary points from first mesh to new mesh.
# pmap1 maps point-numbers from old to new mesh
pmap1 = { } pmap1 = { }
for e in m1.Elements2D(): for e in m1.Elements2D():
@ -32,11 +39,17 @@ for e in m1.Elements2D():
if (v not in pmap1): if (v not in pmap1):
pmap1[v] = mesh.Add (m1[v]) pmap1[v] = mesh.Add (m1[v])
# copy surface elements from first mesh to new mesh
# we have to map point-numbers:
for e in m1.Elements2D(): for e in m1.Elements2D():
mesh.Add (Element2D (fd_outside, [pmap1[v] for v in e.vertices])) mesh.Add (Element2D (fd_outside, [pmap1[v] for v in e.vertices]))
# same for the second mesh:
pmap2 = { } pmap2 = { }
for e in m2.Elements2D(): for e in m2.Elements2D():
for v in e.vertices: for v in e.vertices:

3
py_tutorials/mesh.py
View File

@ -8,7 +8,7 @@ param.maxh = 10
print (param) print (param)
m1 = GenerateMesh (geo, param) m1 = GenerateMesh (geo, param)
m1.SecondOrder()
import exportNeutral import exportNeutral
exportNeutral.Export (m1, "shaft.mesh") exportNeutral.Export (m1, "shaft.mesh")
@ -16,3 +16,4 @@ exportNeutral.Export (m1, "shaft.mesh")
Save (m1, "mesh.vol", geo) Save (m1, "mesh.vol", geo)

9
python/CMakeLists.txt
View File

@ -1,5 +1,8 @@
install(FILES __init__.py meshing.py csg.py geom2d.py stl.py configure_file(__init__.py ${CMAKE_CURRENT_BINARY_DIR}/__init__.py @ONLY)
DESTINATION ${PYTHON_PACKAGES_INSTALL_DIR}/netgen
install(FILES
${CMAKE_CURRENT_BINARY_DIR}/__init__.py
meshing.py csg.py geom2d.py stl.py gui.py NgOCC.py
DESTINATION ${NG_INSTALL_DIR_PYTHON}/${NG_INSTALL_SUFFIX}
COMPONENT netgen COMPONENT netgen
) )

11
python/NgOCC.py Normal file
View File

@ -0,0 +1,11 @@
import libngpy
from libngpy._NgOCC import *
from libngpy._meshing import MeshingParameters
def NgOCC_meshing_func (geom, **args):
if "mp" in args:
return GenerateMesh (geom, args["mp"])
else:
return GenerateMesh (geom, MeshingParameters (**args))
OCCGeometry.GenerateMesh = NgOCC_meshing_func

20
python/__init__.py
View File

@ -1,13 +1,13 @@
import os import os
from sys import path import sys
from sys import platform as __platform
if __platform.startswith('linux'): _netgen_bin_dir=os.path.realpath(os.path.join(os.path.dirname(__file__),'..','@NETGEN_PYTHON_RPATH_BIN@'))
path.append(os.path.dirname(__file__) + '/../../..') _netgen_lib_dir=os.path.realpath(os.path.join(os.path.dirname(__file__),'..','@NETGEN_PYTHON_RPATH@'))
if __platform.startswith('win'):
path.append(os.path.dirname(__file__) + '/../../../bin')
if __platform.startswith('darwin'):
path.append(os.path.dirname(__file__) + '/../../../../../MacOS')
import libngpy if sys.platform.startswith('win'):
del path os.environ['PATH'] += ';'+os.path.realpath(os.path.join(os.path.dirname(__file__),'../../../bin'))
del sys
del os
from . import libngpy

9
python/csg.py
View File

@ -1,8 +1,7 @@
import libngpy from netgen.libngpy._csg import *
from libngpy._csg import * from netgen.libngpy._meshing import MeshingParameters
from libngpy._meshing import MeshingParameters from netgen.libngpy._meshing import Pnt
from libngpy._meshing import Pnt from netgen.libngpy._meshing import Vec
from libngpy._meshing import Vec
try: try:

4
python/geom2d.py
View File

@ -1,5 +1,5 @@
from libngpy._geom2d import * from netgen.libngpy._geom2d import *
from libngpy._meshing import * from netgen.libngpy._meshing import *
tmp_generate_mesh = SplineGeometry.GenerateMesh tmp_generate_mesh = SplineGeometry.GenerateMesh

15
python/gui.py Normal file
View File

@ -0,0 +1,15 @@
import netgen
def StartGUI():
from tkinter import Tk
global win
win = Tk()
win.tk.eval('lappend ::auto_path ' + netgen._netgen_lib_dir)
win.tk.eval('lappend ::auto_path ' + netgen._netgen_bin_dir)
# load with absolute path to avoid issues on MacOS
win.tk.eval('load '+netgen._netgen_lib_dir.replace('\\','/')+'/libgui[info sharedlibextension] gui')
win.tk.eval( netgen.libngpy._meshing._ngscript)
if not netgen.libngpy._meshing._netgen_executable_started:
StartGUI()

2
python/meshing.py
View File

@ -1 +1 @@
from libngpy._meshing import * from netgen.libngpy._meshing import *

5
python/stl.py
View File

@ -1,6 +1,5 @@
import libngpy from netgen.libngpy._stl import *
from libngpy._stl import * from netgen.libngpy._meshing import MeshingParameters
from libngpy._meshing import MeshingParameters
def stl_meshing_func (geom, **args): def stl_meshing_func (geom, **args):

2
tests/docker_15.10
View File

@ -1,4 +1,4 @@
FROM ubuntu:15.10 FROM ubuntu:15.10
MAINTAINER Matthias Hochsteger <matthias.hochsteger@tuwien.ac.at> MAINTAINER Matthias Hochsteger <matthias.hochsteger@tuwien.ac.at>
RUN apt-get update && apt-get -y install python3 libpython3-dev libxmu-dev tk-dev tcl-dev cmake git g++ libglu1-mesa-dev ccache python3-pytest python3-numpy RUN apt-get update && apt-get -y install python3 libpython3-dev libxmu-dev tk-dev tcl-dev cmake git g++ libglu1-mesa-dev ccache python3-pytest python3-numpy python3-tk
ADD . /root/src/netgen ADD . /root/src/netgen

2
tests/docker_16.04
View File

@ -1,4 +1,4 @@
FROM ubuntu:16.04 FROM ubuntu:16.04
MAINTAINER Matthias Hochsteger <matthias.hochsteger@tuwien.ac.at> MAINTAINER Matthias Hochsteger <matthias.hochsteger@tuwien.ac.at>
RUN apt-get update && apt-get -y install python3 libpython3-dev libxmu-dev tk-dev tcl-dev cmake git g++ libglu1-mesa-dev ccache python3-pytest python3-numpy RUN apt-get update && apt-get -y install python3 libpython3-dev libxmu-dev tk-dev tcl-dev cmake git g++ libglu1-mesa-dev ccache python3-pytest python3-numpy python3-tk
ADD . /root/src/netgen ADD . /root/src/netgen

11
tests/pytest/test_gui.py Normal file
View File

@ -0,0 +1,11 @@
import netgen
import pytest
def test_gui():
try:
from tkinter import Tk
win = Tk()
except:
pytest.skip("can't create a window")
import netgen.gui

2
tutorials/CMakeLists.txt
View File

@ -7,6 +7,6 @@ install( FILES
twobricks.geo twocubes.geo twocyl.geo boundarycondition.geo twobricks.geo twocubes.geo twocyl.geo boundarycondition.geo
hinge.stl part1.stl frame.step screw.step hinge.stl part1.stl frame.step screw.step
squarehole.in2d squarecircle.in2d square.in2d squarehole.in2d squarecircle.in2d square.in2d
DESTINATION share/netgen DESTINATION ${NG_INSTALL_DIR_RES}/${NG_INSTALL_SUFFIX}
COMPONENT netgen_tutorial COMPONENT netgen_tutorial
) )

3
windows/CMakeLists.txt
View File

@ -1,3 +0,0 @@
# dist_noinst_DATA = netgen.sln netgen.vcproj \
# postBuild_netgen.bat nglib.sln nglib.vcproj \
# postBuild_nglib.bat netgen.ico netgen.rc