From 0f639775018867310acaa3242f70a9461db60a11 Mon Sep 17 00:00:00 2001 From: Christoph Junghans Date: Tue, 25 Jul 2017 09:31:02 -0600 Subject: lammps: initial commit --- lammps/573.diff | 1073 +++++++++++++++++++++++++++++++++++ lammps/594.patch | 22 + lammps/lammps-patch_6Jul2017.tar.gz | Bin 0 -> 85818362 bytes lammps/lammps.spec | 194 +++++++ 4 files changed, 1289 insertions(+) create mode 100644 lammps/573.diff create mode 100644 lammps/594.patch create mode 100644 lammps/lammps-patch_6Jul2017.tar.gz create mode 100644 lammps/lammps.spec diff --git a/lammps/573.diff b/lammps/573.diff new file mode 100644 index 0000000..45ad3b4 --- /dev/null +++ b/lammps/573.diff @@ -0,0 +1,1073 @@ +diff --git a/.gitignore b/.gitignore +index 74e511515e..50b970249a 100644 +--- a/.gitignore ++++ b/.gitignore +@@ -32,3 +32,11 @@ log.cite + .Trashes + ehthumbs.db + Thumbs.db ++ ++#cmake ++/build* ++/CMakeCache.txt ++/CMakeFiles/ ++/Makefile ++/cmake_install.cmake ++/lmp +diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt +new file mode 100644 +index 0000000000..15a87b7f6e +--- /dev/null ++++ b/cmake/CMakeLists.txt +@@ -0,0 +1,542 @@ ++######################################## ++# CMake build system ++# This file is part of LAMMPS ++# Created by Christoph Junghans and Richard Berger ++cmake_minimum_required(VERSION 3.1) ++ ++project(lammps) ++set(SOVERSION 0) ++set(LAMMPS_SOURCE_DIR ${CMAKE_SOURCE_DIR}/../src) ++set(LAMMPS_LIB_SOURCE_DIR ${CMAKE_SOURCE_DIR}/../lib) ++set(LAMMPS_LIB_BINARY_DIR ${CMAKE_BINARY_DIR}/lib) ++ ++#To not conflict with old Makefile build system, we build everything here ++file(GLOB LIB_SOURCES ${LAMMPS_SOURCE_DIR}/*.cpp) ++file(GLOB LMP_SOURCES ${LAMMPS_SOURCE_DIR}/main.cpp) ++list(REMOVE_ITEM LIB_SOURCES ${LMP_SOURCES}) ++ ++# Cmake modules/macros are in a subdirectory to keep this file cleaner ++set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/Modules) ++ ++if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_C_FLAGS) ++ #release comes with -O3 by default ++ set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." FORCE) ++endif(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_C_FLAGS) ++ ++foreach(STYLE_FILE style_angle.h style_atom.h style_body.h style_bond.h style_command.h style_compute.h style_dihedral.h style_dump.h ++ style_fix.h style_improper.h style_integrate.h style_kspace.h style_minimize.h style_nbin.h style_npair.h style_nstencil.h ++ style_ntopo.h style_pair.h style_reader.h style_region.h) ++ if(EXISTS ${LAMMPS_SOURCE_DIR}/${STYLE_FILE}) ++ message(FATAL_ERROR "There is a ${STYLE_FILE} in ${LAMMPS_SOURCE_DIR}, please clean up the source directory first") ++ endif() ++endforeach() ++ ++enable_language(CXX) ++ ++###################################################################### ++# compiler tests ++# these need ot be done early (before further tests). ++##################################################################### ++include(CheckCCompilerFlag) ++ ++######################################################################## ++# User input options # ++######################################################################## ++option(BUILD_SHARED_LIBS "Build shared libs" OFF) ++option(INSTALL_LIB "Install lammps library and header" ON) ++include(GNUInstallDirs) ++ ++set(LAMMPS_LINK_LIBS) ++option(ENABLE_MPI "Build MPI version" OFF) ++if(ENABLE_MPI) ++ find_package(MPI REQUIRED) ++ include_directories(${MPI_C_INCLUDE_PATH}) ++ list(APPEND LAMMPS_LINK_LIBS ${MPI_CXX_LIBRARIES}) ++ option(LAMMPS_LONGLONG_TO_LONG "Workaround if your system or MPI version does not recognize 'long long' data types" OFF) ++ if(LAMMPS_LONGLONG_TO_LONG) ++ add_definitions(-DLAMMPS_LONGLONG_TO_LONG) ++ endif() ++else() ++ file(GLOB MPI_SOURCES ${LAMMPS_SOURCE_DIR}/STUBS/mpi.c) ++ list(APPEND LIB_SOURCES ${MPI_SOURCES}) ++ include_directories(${LAMMPS_SOURCE_DIR}/STUBS) ++endif() ++ ++set(LAMMPS_SIZE_LIMIT "LAMMPS_SMALLBIG" CACHE STRING "Lammps size limit") ++set_property(CACHE LAMMPS_SIZE_LIMIT PROPERTY STRINGS LAMMPS_SMALLBIG LAMMPS_BIGBIG LAMMPS_SMALLSMALL) ++add_definitions(-D${LAMMPS_SIZE_LIMIT}) ++ ++set(LAMMPS_MEMALIGN "64" CACHE STRING "enables the use of the posix_memalign() call instead of malloc() when large chunks or memory are allocated by LAMMPS") ++add_definitions(-DLAMMPS_MEMALIGN=${LAMMPS_MEMALIGN}) ++ ++option(CMAKE_VERBOSE_MAKEFILE "Verbose makefile" OFF) ++ ++option(ENABLE_TESTING "Enable testing" OFF) ++if(ENABLE_TESTING) ++ enable_testing() ++endif(ENABLE_TESTING) ++ ++option(ENABLE_ALL "Build all default packages" OFF) ++set(DEFAULT_PACKAGES ASPHERE BODY CLASS2 COLLOID COMPRESS CORESHELL DIPOLE GRANULAR ++ KSPACE MANYBODY MC MEAM MISC MOLECULE PERI QEQ ++ REAX REPLICA RIGID SHOCK SNAP SRD) ++set(OTHER_PACKAGES KIM PYTHON MSCG MPIIO VORONOI POEMS ++ USER-ATC USER-AWPMD USER-CGDNA ++ USER-CGSDK USER-COLVARS USER-DIFFRACTION USER-DPD USER-DRUDE USER-EFF ++ USER-FEP USER-H5MD USER-LB USER-MANIFOLD USER-MEAMC USER-MGPT USER-MISC ++ USER-MOLFILE USER-NETCDF USER-PHONON USER-QTB USER-REAXC USER-SMD ++ USER-SMTBQ USER-SPH USER-TALLY USER-VTK USER-QUIP USER-QMMM) ++set(ACCEL_PACKAGES USER-OMP KOKKOS OPT USER-INTEL GPU) ++foreach(PKG ${DEFAULT_PACKAGES}) ++ option(ENABLE_${PKG} "Build ${PKG} Package" ${ENABLE_ALL}) ++endforeach() ++foreach(PKG ${ACCEL_PACKAGES} ${OTHER_PACKAGES}) ++ option(ENABLE_${PKG} "Build ${PKG} Package" OFF) ++endforeach() ++ ++macro(pkg_depends PKG1 PKG2) ++ if(ENABLE_${PKG1} AND NOT ENABLE_${PKG2}) ++ message(FATAL_ERROR "${PKG1} package needs LAMMPS to be build with ${PKG2}") ++ endif() ++endmacro() ++ ++pkg_depends(MPIIO MPI) ++pkg_depends(QEQ MANYBODY) ++pkg_depends(USER-ATC MANYBODY) ++pkg_depends(USER-H5MD MPI) ++pkg_depends(USER-LB MPI) ++pkg_depends(USER-MISC MANYBODY) ++pkg_depends(USER-PHONON KSPACE) ++ ++if(ENABLE_BODY AND ENABLE_POEMS) ++ message(FATAL_ERROR "BODY and POEMS cannot be enabled at the same time") ++endif() ++ ++###################################################### ++# packages with special compiler needs or external libs ++###################################################### ++if(ENABLE_REAX OR ENABLE_MEAM OR ENABLE_USER-QUIP OR ENABLE_USER-QMMM) ++ enable_language(Fortran) ++endif() ++ ++if(ENABLE_KOKKOS OR ENABLE_MSCG) ++ # starting with CMake 3.1 this is all you have to do to enforce C++11 ++ set(CMAKE_CXX_STANDARD 11) # C++11... ++ set(CMAKE_CXX_STANDARD_REQUIRED ON) #...is required... ++ set(CMAKE_CXX_EXTENSIONS OFF) #...without compiler extensions like gnu++11 ++endif() ++ ++if(ENABLE_USER-OMP OR ENABLE_KOKKOS OR ENABLE_USER-INTEL) ++ find_package(OpenMP REQUIRED) ++ set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}") ++ set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}") ++endif() ++ ++if(ENABLE_KSPACE) ++ set(FFT "KISSFFT" CACHE STRING "FFT library for KSPACE package") ++ set_property(CACHE FFT PROPERTY STRINGS KISSFFT FFTW3 MKL FFTW2) ++ if(NOT FFT STREQUAL "KISSFFT") ++ find_package(${FFT} REQUIRED) ++ add_definitions(-DFFT_${FFT}) ++ include_directories(${${FFT}_INCLUDE_DIRS}) ++ list(APPEND LAMMPS_LINK_LIBS ${${FFT}_LIBRARIES}) ++ endif() ++ set(PACK_OPTIMIZATION "PACK_ARRAY" CACHE STRING "Optimization for FFT") ++ set_property(CACHE PACK_OPTIMIZATION PROPERTY STRINGS PACK_ARRAY PACK_POINTER PACK_MEMCPY) ++ if(NOT PACK_OPTIMIZATION STREQUAL "PACK_ARRAY") ++ add_definitions(-D${PACK_OPTIMIZATION}) ++ endif() ++endif() ++ ++if(ENABLE_MISC) ++ option(LAMMPS_XDR "include XDR compatibility files for doing particle dumps in XTC format" OFF) ++ if(LAMMPS_XDR) ++ add_definitions(-DLAMMPS_XDR) ++ endif() ++endif() ++ ++if(ENABLE_MSCG OR ENABLE_USER-ATC OR ENABLE_USER-AWPMD OR ENABLE_USER-QUIP) ++ find_package(LAPACK) ++ if(LAPACK_FOUND) ++ list(APPEND LAMMPS_LINK_LIBS ${LAPACK_LIBRARIES}) ++ else() ++ enable_language(Fortran) ++ file(GLOB LAPACK_SOURCES ${LAMMPS_LIB_SOURCE_DIR}/linalg/*.f) ++ list(APPEND LIB_SOURCES ${LAPACK_SOURCES}) ++ endif() ++endif() ++ ++if(ENABLE_PYTHON) ++ find_package(PythonInterp REQUIRED) ++ find_package(PythonLibs REQUIRED) ++ add_definitions(-DLMP_PYTHON) ++ include_directories(${PYTHON_INCLUDE_DIR}) ++ list(APPEND LAMMPS_LINK_LIBS ${PYTHON_LIBRARY}) ++ if(NOT PYTHON_INSTDIR) ++ execute_process(COMMAND ${PYTHON_EXECUTABLE} ++ -c "import distutils.sysconfig as cg; print(cg.get_python_lib(1,0,prefix='${CMAKE_INSTALL_PREFIX}'))" ++ OUTPUT_VARIABLE PYTHON_INSTDIR OUTPUT_STRIP_TRAILING_WHITESPACE) ++ endif() ++ install(FILES ${CMAKE_SOURCE_DIR}/../python/lammps.py DESTINATION ${PYTHON_INSTDIR}) ++ if(NOT BUILD_SHARED_LIBS) ++ message(FATAL_ERROR "Python package need lammps to be build shared, -DBUILD_SHARED_LIBS=ON") ++ endif() ++endif() ++ ++find_package(JPEG) ++if(JPEG_FOUND) ++ add_definitions(-DLAMMPS_JPEG) ++ include_directories(${JPEG_INCLUDE_DIR}) ++ list(APPEND LAMMPS_LINK_LIBS ${JPEG_LIBRARIES}) ++endif() ++ ++find_package(PNG) ++find_package(ZLIB) ++if(PNG_FOUND AND ZLIB_FOUND) ++ include_directories(${PNG_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIRS}) ++ list(APPEND LAMMPS_LINK_LIBS ${PNG_LIBRARIES} ${ZLIB_LIBRARIES}) ++ add_definitions(-DLAMMPS_PNG) ++endif() ++ ++find_program(GZIP_EXECUTABLE gzip) ++find_package_handle_standard_args(GZIP REQUIRED_VARS GZIP_EXECUTABLE) ++if(GZIP_FOUND) ++ add_definitions(-DLAMMPS_GZIP) ++endif() ++ ++find_program(FFMPEG_EXECUTABLE ffmpeg) ++find_package_handle_standard_args(FFMPEG REQUIRED_VARS FFMPEG_EXECUTABLE) ++if(FFMPEG_FOUND) ++ add_definitions(-DLAMMPS_FFMPEG) ++endif() ++ ++if(ENABLE_VORONOI) ++ find_package(VORO REQUIRED) #some distros ++ include_directories(${VORO_INCLUDE_DIRS}) ++ list(APPEND LAMMPS_LINK_LIBS ${VORO_LIBRARIES}) ++endif() ++ ++if(ENABLE_USER-MOLFILE) ++ list(APPEND LAMMPS_LINK_LIBS ${CMAKE_DL_LIBS}) ++endif() ++ ++if(ENABLE_USER-NETCDF) ++ find_package(NetCDF REQUIRED) ++ include_directories(NETCDF_INCLUDE_DIR) ++ list(APPEND LAMMPS_LINK_LIBS ${NETCDF_LIBRARY}) ++ add_definitions(-DLMP_HAS_NETCDF -DNC_64BIT_DATA=0x0020) ++endif() ++ ++if(ENABLE_USER-SMD) ++ find_package(Eigen3 REQUIRED) ++ include_directories(${EIGEN3_INCLUDE_DIR}) ++endif() ++ ++if(ENABLE_USER-QUIP) ++ find_package(QUIP REQUIRED) ++ list(APPEND LAMMPS_LINK_LIBS ${QUIP_LIBRARIES} ${CMAKE_Fortran_IMPLICIT_LINK_LIBRARIES}) ++endif() ++ ++if(ENABLE_USER-QMMM) ++ find_package(QE REQUIRED) ++ include_directories(${QE_INCLUDE_DIRS}) ++ list(APPEND LAMMPS_LINK_LIBS ${QE_LIBRARIES} ${CMAKE_Fortran_IMPLICIT_LINK_LIBRARIES}) ++endif() ++ ++if(ENABLE_USER-AWPMD) ++ include_directories(${LAMMPS_LIB_SOURCE_DIR}/awpmd/systems/interact ++ ${LAMMPS_LIB_SOURCE_DIR}/awpmd/ivutils/include) ++endif() ++ ++if(ENABLE_USER-H5MD) ++ find_package(HDF5 REQUIRED) ++ list(APPEND LAMMPS_LINK_LIBS ${HDF5_LIBRARIES}) ++ include_directories(${HDF5_INCLUDE_DIRS} ${LAMMPS_LIB_SOURCE_DIR}/h5md/include) ++endif() ++ ++if(ENABLE_USER-VTK) ++ find_package(VTK REQUIRED NO_MODULE) ++ include(${VTK_USE_FILE}) ++ add_definitions(-DLAMMPS_VTK) ++ list(APPEND LAMMPS_LINK_LIBS ${VTK_LIBRARIES}) ++endif() ++ ++if(ENABLE_KIM) ++ find_package(KIM REQUIRED) ++ list(APPEND LAMMPS_LINK_LIBS ${KIM_LIBRARIES}) ++ include_directories(${KIM_INCLUDE_DIRS}) ++endif() ++ ++if(ENABLE_MSCG) ++ find_package(GSL REQUIRED) ++ set(LAMMPS_LIB_MSCG_BIN_DIR ${LAMMPS_LIB_BINARY_DIR}/mscg) ++ set(MSCG_TARBALL ${LAMMPS_LIB_MSCG_BIN_DIR}/MS-CG-master.zip) ++ set(LAMMPS_LIB_MSCG_BIN_DIR ${LAMMPS_LIB_MSCG_BIN_DIR}/MSCG-release-master/src) ++ if(NOT EXISTS ${LAMMPS_LIB_MSCG_BIN_DIR}) ++ if(NOT EXISTS ${MSCG_TARBALL}) ++ message(STATUS "Downloading ${MSCG_TARBALL}") ++ file(DOWNLOAD ++ https://github.com/uchicago-voth/MSCG-release/archive/master.zip ++ ${MSCG_TARBALL} SHOW_PROGRESS) #EXPECTED_MD5 cannot be due due to master ++ endif() ++ message(STATUS "Unpacking ${MSCG_TARBALL}") ++ execute_process(COMMAND ${CMAKE_COMMAND} -E tar xvf ${MSCG_TARBALL} ++ WORKING_DIRECTORY ${LAMMPS_LIB_BINARY_DIR}/mscg) ++ endif() ++ file(GLOB MSCG_SOURCES ${LAMMPS_LIB_MSCG_BIN_DIR}/*.cpp) ++ list(APPEND LIB_SOURCES ${MSCG_SOURCES}) ++ foreach(MSCG_SOURCE ${MSCG_SOURCES}) ++ set_property(SOURCE ${MSCG_SOURCE} APPEND PROPERTY COMPILE_DEFINITIONS ++ DIMENSION=3 _exclude_gromacs=1) ++ endforeach() ++ include_directories(${LAMMPS_LIB_MSCG_BIN_DIR} ${GSL_INCLUDE_DIRS}) ++ list(APPEND LAMMPS_LINK_LIBS ${GSL_LIBRARIES}) ++endif() ++ ++######################################################################## ++# Basic system tests (standard libraries, headers, functions, types) # ++######################################################################## ++include(CheckIncludeFile) ++foreach(HEADER math.h) ++ check_include_file(${HEADER} FOUND_${HEADER}) ++ if(NOT FOUND_${HEADER}) ++ message(FATAL_ERROR "Could not find needed header - ${HEADER}") ++ endif(NOT FOUND_${HEADER}) ++endforeach(HEADER) ++ ++set(MATH_LIBRARIES "m" CACHE STRING "math library") ++mark_as_advanced( MATH_LIBRARIES ) ++include(CheckLibraryExists) ++foreach(FUNC sin cos) ++ check_library_exists(${MATH_LIBRARIES} ${FUNC} "" FOUND_${FUNC}_${MATH_LIBRARIES}) ++ if(NOT FOUND_${FUNC}_${MATH_LIBRARIES}) ++ message(FATAL_ERROR "Could not find needed math function - ${FUNC}") ++ endif(NOT FOUND_${FUNC}_${MATH_LIBRARIES}) ++endforeach(FUNC) ++list(APPEND LAMMPS_LINK_LIBS ${MATH_LIBRARIES}) ++ ++###################################### ++# Generate Basic Style files ++###################################### ++include(StyleHeaderUtils) ++RegisterStyles(${LAMMPS_SOURCE_DIR}) ++ ++############################################## ++# add sources of enabled packages ++############################################ ++foreach(PKG ${DEFAULT_PACKAGES} ${OTHER_PACKAGES}) ++ if(ENABLE_${PKG}) ++ set(${PKG}_SOURCES_DIR ${LAMMPS_SOURCE_DIR}/${PKG}) ++ ++ # detects styles in package and adds them to global list ++ RegisterStyles(${${PKG}_SOURCES_DIR}) ++ ++ file(GLOB ${PKG}_SOURCES ${${PKG}_SOURCES_DIR}/*.cpp) ++ list(APPEND LIB_SOURCES ${${PKG}_SOURCES}) ++ include_directories(${${PKG}_SOURCES_DIR}) ++ endif() ++endforeach() ++ ++############################################## ++# add lib sources of (simple) enabled packages ++############################################ ++foreach(SIMPLE_LIB REAX MEAM POEMS USER-ATC USER-AWPMD USER-COLVARS USER-H5MD ++ USER-MOLFILE USER-QMMM) ++ if(ENABLE_${SIMPLE_LIB}) ++ string(REGEX REPLACE "^USER-" "" SIMPLE_LIB "${SIMPLE_LIB}") ++ string(TOLOWER "${SIMPLE_LIB}" INC_DIR) ++ file(GLOB_RECURSE ${SIMPLE_LIB}_SOURCES ${LAMMPS_LIB_SOURCE_DIR}/${INC_DIR}/*.F ++ ${LAMMPS_LIB_SOURCE_DIR}/${INC_DIR}/*.c ${LAMMPS_LIB_SOURCE_DIR}/${INC_DIR}/*.cpp) ++ list(APPEND LIB_SOURCES ${${SIMPLE_LIB}_SOURCES}) ++ include_directories(${LAMMPS_LIB_SOURCE_DIR}/${INC_DIR}) ++ endif() ++endforeach() ++ ++###################################################################### ++# packages which selectively include variants based on enabled styles ++# e.g. accelerator packages ++###################################################################### ++if(ENABLE_USER-OMP) ++ set(USER-OMP_SOURCES_DIR ${LAMMPS_SOURCE_DIR}/USER-OMP) ++ set(USER-OMP_SOURCES ${USER-OMP_SOURCES_DIR}/thr_data.cpp ++ ${USER-OMP_SOURCES_DIR}/thr_omp.cpp ++ ${USER-OMP_SOURCES_DIR}/fix_nh_omp.cpp ++ ${USER-OMP_SOURCES_DIR}/fix_nh_sphere_omp.cpp) ++ set_property(GLOBAL PROPERTY "OMP_SOURCES" "${USER-OMP_SOURCES}") ++ ++ # detects styles which have USER-OMP version ++ RegisterStylesExt(${USER-OMP_SOURCES_DIR} omp OMP_SOURCES) ++ ++ get_property(USER-OMP_SOURCES GLOBAL PROPERTY OMP_SOURCES) ++ ++ list(APPEND LIB_SOURCES ${USER-OMP_SOURCES}) ++ include_directories(${USER-OMP_SOURCES_DIR}) ++endif() ++ ++if(ENABLE_KOKKOS) ++ set(LAMMPS_LIB_KOKKOS_SRC_DIR ${LAMMPS_LIB_SOURCE_DIR}/kokkos) ++ set(LAMMPS_LIB_KOKKOS_BIN_DIR ${LAMMPS_LIB_BINARY_DIR}/kokkos) ++ add_definitions(-DLMP_KOKKOS) ++ add_subdirectory(${LAMMPS_LIB_KOKKOS_SRC_DIR} ${LAMMPS_LIB_KOKKOS_BIN_DIR}) ++ ++ set(Kokkos_INCLUDE_DIRS ${LAMMPS_LIB_KOKKOS_SRC_DIR}/core/src ++ ${LAMMPS_LIB_KOKKOS_SRC_DIR}/containers/src ++ ${LAMMPS_LIB_KOKKOS_SRC_DIR}/algorithms/src ++ ${LAMMPS_LIB_KOKKOS_BIN_DIR}) ++ include_directories(${Kokkos_INCLUDE_DIRS}) ++ list(APPEND LAMMPS_LINK_LIBS kokkos) ++ ++ set(KOKKOS_PKG_SOURCES_DIR ${LAMMPS_SOURCE_DIR}/KOKKOS) ++ set(KOKKOS_PKG_SOURCES ${KOKKOS_PKG_SOURCES_DIR}/kokkos.cpp ++ ${KOKKOS_PKG_SOURCES_DIR}/atom_kokkos.cpp ++ ${KOKKOS_PKG_SOURCES_DIR}/atom_vec_kokkos.cpp ++ ${KOKKOS_PKG_SOURCES_DIR}/comm_kokkos.cpp ++ ${KOKKOS_PKG_SOURCES_DIR}/comm_tiled_kokkos.cpp ++ ${KOKKOS_PKG_SOURCES_DIR}/neighbor_kokkos.cpp ++ ${KOKKOS_PKG_SOURCES_DIR}/neigh_list_kokkos.cpp ++ ${KOKKOS_PKG_SOURCES_DIR}/neigh_bond_kokkos.cpp ++ ${KOKKOS_PKG_SOURCES_DIR}/fix_nh_kokkos.cpp ++ ${KOKKOS_PKG_SOURCES_DIR}/domain_kokkos.cpp ++ ${KOKKOS_PKG_SOURCES_DIR}/modify_kokkos.cpp) ++ set_property(GLOBAL PROPERTY "KOKKOS_PKG_SOURCES" "${KOKKOS_PKG_SOURCES}") ++ ++ # detects styles which have KOKKOS version ++ RegisterStylesExt(${KOKKOS_PKG_SOURCES_DIR} kokkos KOKKOS_PKG_SOURCES) ++ ++ get_property(KOKKOS_PKG_SOURCES GLOBAL PROPERTY KOKKOS_PKG_SOURCES) ++ ++ list(APPEND LIB_SOURCES ${KOKKOS_PKG_SOURCES}) ++ include_directories(${KOKKOS_PKG_SOURCES_DIR}) ++endif() ++ ++if(ENABLE_OPT) ++ set(OPT_SOURCES_DIR ${LAMMPS_SOURCE_DIR}/OPT) ++ set(OPT_SOURCES) ++ set_property(GLOBAL PROPERTY "OPT_SOURCES" "${OPT_SOURCES}") ++ ++ # detects styles which have OPT version ++ RegisterStylesExt(${OPT_SOURCES_DIR} opt OPT_SOURCES) ++ ++ get_property(OPT_SOURCES GLOBAL PROPERTY OPT_SOURCES) ++ ++ list(APPEND LIB_SOURCES ${OPT_SOURCES}) ++ include_directories(${OPT_SOURCES_DIR}) ++endif() ++ ++if(ENABLE_USER-INTEL) ++ set(USER-INTEL_SOURCES_DIR ${LAMMPS_SOURCE_DIR}/USER-INTEL) ++ set(USER-INTEL_SOURCES ${USER-INTEL_SOURCES_DIR}/intel_preprocess.h ++ ${USER-INTEL_SOURCES_DIR}/intel_buffers.h ++ ${USER-INTEL_SOURCES_DIR}/intel_buffers.cpp ++ ${USER-INTEL_SOURCES_DIR}/math_extra_intel.h ++ ${USER-INTEL_SOURCES_DIR}/nbin_intel.h ++ ${USER-INTEL_SOURCES_DIR}/nbin_intel.cpp ++ ${USER-INTEL_SOURCES_DIR}/npair_intel.h ++ ${USER-INTEL_SOURCES_DIR}/npair_intel.cpp ++ ${USER-INTEL_SOURCES_DIR}/intel_simd.h ++ ${USER-INTEL_SOURCES_DIR}/intel_intrinsics.h) ++ ++ set_property(GLOBAL PROPERTY "USER-INTEL_SOURCES" "${USER-INTEL_SOURCES}") ++ ++ # detects styles which have USER-INTEL version ++ RegisterStylesExt(${USER-INTEL_SOURCES_DIR} opt USER-INTEL_SOURCES) ++ ++ get_property(USER-INTEL_SOURCES GLOBAL PROPERTY USER-INTEL_SOURCES) ++ ++ list(APPEND LIB_SOURCES ${USER-INTEL_SOURCES}) ++ include_directories(${USER-INTEL_SOURCES_DIR}) ++endif() ++ ++if(ENABLE_GPU) ++ find_package(CUDA REQUIRED) ++ find_program(BIN2C bin2c) ++ if(NOT BIN2C) ++ message(FATAL_ERROR "Couldn't find bin2c") ++ endif() ++ include_directories(${CUDA_INCLUDE_DIRS}) ++ list(APPEND LAMMPS_LINK_LIBS ${CUDA_LIBRARIES} ${CUDA_CUDA_LIBRARY}) ++ set(GPU_PREC "SINGLE_DOUBLE" CACHE STRING "Lammps gpu precision size") ++ set_property(CACHE GPU_PREC PROPERTY STRINGS SINGLE_DOUBLE SINGLE_SINGLE DOUBLE_DOUBLE) ++ add_definitions(-D_${GPU_PREC}) ++ add_definitions(-DNV_KERNEL -DUCL_CUDADR) ++ option(CUDPP_OPT "Enable CUDPP_OPT" ON) ++ ++ set(GPU_SOURCES_DIR ${LAMMPS_SOURCE_DIR}/GPU) ++ set(GPU_SOURCES ${GPU_SOURCES_DIR}/gpu_extra.h) ++ ++ set_property(GLOBAL PROPERTY "GPU_SOURCES" "${GPU_SOURCES}") ++ ++ # detects styles which have GPU version ++ RegisterStylesExt(${GPU_SOURCES_DIR} opt GPU_SOURCES) ++ ++ get_property(GPU_SOURCES GLOBAL PROPERTY GPU_SOURCES) ++ ++ file(GLOB GPU_LIB_SOURCES ${LAMMPS_LIB_SOURCE_DIR}/gpu/*.cpp) ++ file(GLOB GPU_LIB_CU ${LAMMPS_LIB_SOURCE_DIR}/gpu/*.cu ${CMAKE_SOURCE_DIR}/gpu/*.cu) ++ file(GLOB_RECURSE GPU_NOT_LIB_CU ${LAMMPS_LIB_SOURCE_DIR}/gpu/lal_pppm.cu) ++ list(REMOVE_ITEM GPU_LIB_CU ${GPU_NOT_LIB_CU}) ++ include_directories(${GPU_SOURCES_DIR} ${LAMMPS_LIB_SOURCE_DIR}/gpu ${LAMMPS_LIB_BINARY_DIR}/gpu) ++ if(CUDPP_OPT) ++ include_directories(${LAMMPS_LIB_SOURCE_DIR}/gpu/cudpp_mini) ++ add_definitions(-DCUDPP_OPT) ++ file(GLOB GPU_LIB_CUDPP_SOURCES ${LAMMPS_LIB_SOURCE_DIR}/gpu/cudpp_mini/*.cpp) ++ file(GLOB GPU_LIB_CUDPP_CU ${LAMMPS_LIB_SOURCE_DIR}/gpu/cudpp_mini/*.cu) ++ endif() ++ cuda_compile(GPU_OBJS ${GPU_LIB_CU} ${GPU_LIB_CUDPP_CU} OPTIONS $<$:-Xcompiler=-fPIC>) ++ file(MAKE_DIRECTORY ${LAMMPS_LIB_BINARY_DIR}/gpu) ++ foreach(CU_OBJ ${GPU_OBJS}) ++ get_filename_component(CU_NAME ${CU_OBJ} NAME_WE) ++ string(REGEX REPLACE "^.*_lal_" "" CU_NAME "${CU_NAME}") ++ add_custom_command(OUTPUT ${LAMMPS_LIB_BINARY_DIR}/gpu/${CU_NAME}_cubin.h ++ COMMAND ${BIN2C} -c -n ${CU_NAME} ${CU_OBJ} > ${LAMMPS_LIB_BINARY_DIR}/gpu/${CU_NAME}_cubin.h ++ DEPENDS ${CU_OBJ} ++ COMMENT "Generating ${CU_NAME}_cubin.h") ++ list(APPEND LIB_SOURCES ${LAMMPS_LIB_BINARY_DIR}/gpu/${CU_NAME}_cubin.h) ++ if(${CU_NAME} STREQUAL "pppm_d") #pppm_d doesn't get linked into the lib ++ set(CU_FORBIDDEN_OBJ "${CU_OBJ}") ++ endif() ++ endforeach() ++ list(REMOVE_ITEM GPU_OBJS "${CU_FORBIDDEN_OBJ}") ++ list(APPEND LIB_SOURCES ${GPU_SOURCES} ${GPU_LIB_SOURCES} ${GPU_LIB_CUDPP_SOURCES} ${GPU_OBJS}) ++ set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${AMMPS_LIB_BINARY_DIR}/gpu/*_cubin.h") ++endif() ++ ++###################################################### ++# Generate style headers based on global list of ++# styles registered during package selection ++###################################################### ++set(LAMMPS_STYLE_HEADERS_DIR ${CMAKE_CURRENT_BINARY_DIR}/styles) ++ ++GenerateStyleHeaders(${LAMMPS_STYLE_HEADERS_DIR}) ++ ++include_directories(${LAMMPS_SOURCE_DIR}) ++include_directories(${LAMMPS_STYLE_HEADERS_DIR}) ++ ++########################################### ++# Actually add executable and lib to build ++############################################ ++add_library(lammps ${LIB_SOURCES}) ++target_link_libraries(lammps ${LAMMPS_LINK_LIBS}) ++set_target_properties(lammps PROPERTIES SOVERSION ${SOVERSION}) ++if(INSTALL_LIB) ++ install(TARGETS lammps LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}) ++ install(FILES ${LAMMPS_SOURCE_DIR}/lammps.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) ++elseif(BUILD_SHARED_LIBS) ++ message(FATAL_ERROR "Shared library has to be installed, use -DBUILD_SHARED_LIBS=ON to install lammps with a library") ++endif() ++ ++add_executable(lmp ${LMP_SOURCES}) ++target_link_libraries(lmp lammps) ++install(TARGETS lmp DESTINATION ${CMAKE_INSTALL_BINDIR}) ++if(ENABLE_TESTING) ++ add_test(ShowHelp lmp -help) ++endif() ++ ++################################## ++# Print package summary ++################################## ++foreach(PKG ${DEFAULT_PACKAGES} ${OTHER_PACKAGES} ${ACCEL_PACKAGES}) ++ if(ENABLE_${PKG}) ++ message(STATUS "Building package: ${PKG}") ++ endif() ++endforeach() +diff --git a/cmake/Modules/FindFFTW2.cmake b/cmake/Modules/FindFFTW2.cmake +new file mode 100644 +index 0000000000..c77e6cf8e9 +--- /dev/null ++++ b/cmake/Modules/FindFFTW2.cmake +@@ -0,0 +1,22 @@ ++# - Find fftw2 ++# Find the native FFTW2 headers and libraries. ++# ++# FFTW2_INCLUDE_DIRS - where to find fftw2.h, etc. ++# FFTW2_LIBRARIES - List of libraries when using fftw2. ++# FFTW2_FOUND - True if fftw2 found. ++# ++ ++find_path(FFTW2_INCLUDE_DIR fftw.h) ++ ++find_library(FFTW2_LIBRARY NAMES fftw) ++ ++set(FFTW2_LIBRARIES ${FFTW2_LIBRARY}) ++set(FFTW2_INCLUDE_DIRS ${FFTW2_INCLUDE_DIR}) ++ ++include(FindPackageHandleStandardArgs) ++# handle the QUIETLY and REQUIRED arguments and set FFTW2_FOUND to TRUE ++# if all listed variables are TRUE ++ ++find_package_handle_standard_args(FFTW2 DEFAULT_MSG FFTW2_LIBRARY FFTW2_INCLUDE_DIR) ++ ++mark_as_advanced(FFTW2_INCLUDE_DIR FFTW2_LIBRARY ) +diff --git a/cmake/Modules/FindFFTW3.cmake b/cmake/Modules/FindFFTW3.cmake +new file mode 100644 +index 0000000000..552bcc4257 +--- /dev/null ++++ b/cmake/Modules/FindFFTW3.cmake +@@ -0,0 +1,25 @@ ++# - Find fftw3 ++# Find the native FFTW3 headers and libraries. ++# ++# FFTW3_INCLUDE_DIRS - where to find fftw3.h, etc. ++# FFTW3_LIBRARIES - List of libraries when using fftw3. ++# FFTW3_FOUND - True if fftw3 found. ++# ++ ++find_package(PkgConfig) ++ ++pkg_check_modules(PC_FFTW3 fftw3) ++find_path(FFTW3_INCLUDE_DIR fftw3.h HINTS ${PC_FFTW3_INCLUDE_DIRS}) ++ ++find_library(FFTW3_LIBRARY NAMES fftw3 HINTS ${PC_FFTW3_LIBRARY_DIRS}) ++ ++set(FFTW3_LIBRARIES ${FFTW3_LIBRARY}) ++set(FFTW3_INCLUDE_DIRS ${FFTW3_INCLUDE_DIR}) ++ ++include(FindPackageHandleStandardArgs) ++# handle the QUIETLY and REQUIRED arguments and set FFTW3_FOUND to TRUE ++# if all listed variables are TRUE ++ ++find_package_handle_standard_args(FFTW3 DEFAULT_MSG FFTW3_LIBRARY FFTW3_INCLUDE_DIR) ++ ++mark_as_advanced(FFTW3_INCLUDE_DIR FFTW3_LIBRARY ) +diff --git a/cmake/Modules/FindKIM.cmake b/cmake/Modules/FindKIM.cmake +new file mode 100644 +index 0000000000..a01f817cf6 +--- /dev/null ++++ b/cmake/Modules/FindKIM.cmake +@@ -0,0 +1,22 @@ ++# - Find kim ++# Find the native KIM headers and libraries. ++# ++# KIM_INCLUDE_DIRS - where to find kim.h, etc. ++# KIM_LIBRARIES - List of libraries when using kim. ++# KIM_FOUND - True if kim found. ++# ++ ++find_path(KIM_INCLUDE_DIR KIM_API.h PATH_SUFFIXES kim-api-v1) ++ ++find_library(KIM_LIBRARY NAMES kim-api-v1) ++ ++set(KIM_LIBRARIES ${KIM_LIBRARY}) ++set(KIM_INCLUDE_DIRS ${KIM_INCLUDE_DIR}) ++ ++include(FindPackageHandleStandardArgs) ++# handle the QUIETLY and REQUIRED arguments and set KIM_FOUND to TRUE ++# if all listed variables are TRUE ++ ++find_package_handle_standard_args(KIM DEFAULT_MSG KIM_LIBRARY KIM_INCLUDE_DIR) ++ ++mark_as_advanced(KIM_INCLUDE_DIR KIM_LIBRARY ) +diff --git a/cmake/Modules/FindMKL.cmake b/cmake/Modules/FindMKL.cmake +new file mode 100644 +index 0000000000..4246062103 +--- /dev/null ++++ b/cmake/Modules/FindMKL.cmake +@@ -0,0 +1,22 @@ ++# - Find mkl ++# Find the native MKL headers and libraries. ++# ++# MKL_INCLUDE_DIRS - where to find mkl.h, etc. ++# MKL_LIBRARIES - List of libraries when using mkl. ++# MKL_FOUND - True if mkl found. ++# ++ ++find_path(MKL_INCLUDE_DIR mkl_dfti.h HINTS $ENV{MKLROOT}/include) ++ ++find_library(MKL_LIBRARY NAMES mkl_rt HINTS $ENV{MKLROOT}/lib $ENV{MKLROOT}/lib/intel64) ++ ++set(MKL_LIBRARIES ${MKL_LIBRARY}) ++set(MKL_INCLUDE_DIRS ${MKL_INCLUDE_DIR}) ++ ++include(FindPackageHandleStandardArgs) ++# handle the QUIETLY and REQUIRED arguments and set MKL_FOUND to TRUE ++# if all listed variables are TRUE ++ ++find_package_handle_standard_args(MKL DEFAULT_MSG MKL_LIBRARY MKL_INCLUDE_DIR) ++ ++mark_as_advanced(MKL_INCLUDE_DIR MKL_LIBRARY ) +diff --git a/cmake/Modules/FindNetCDF.cmake b/cmake/Modules/FindNetCDF.cmake +new file mode 100644 +index 0000000000..a28c959acf +--- /dev/null ++++ b/cmake/Modules/FindNetCDF.cmake +@@ -0,0 +1,118 @@ ++# - Find NetCDF ++# Find the native NetCDF includes and library ++# ++# NETCDF_INCLUDE_DIR - user modifiable choice of where netcdf headers are ++# NETCDF_LIBRARY - user modifiable choice of where netcdf libraries are ++# ++# Your package can require certain interfaces to be FOUND by setting these ++# ++# NETCDF_CXX - require the C++ interface and link the C++ library ++# NETCDF_F77 - require the F77 interface and link the fortran library ++# NETCDF_F90 - require the F90 interface and link the fortran library ++# ++# Or equivalently by calling FindNetCDF with a COMPONENTS argument containing one or ++# more of "CXX;F77;F90". ++# ++# When interfaces are requested the user has access to interface specific hints: ++# ++# NETCDF_${LANG}_INCLUDE_DIR - where to search for interface header files ++# NETCDF_${LANG}_LIBRARY - where to search for interface libraries ++# ++# This module returns these variables for the rest of the project to use. ++# ++# NETCDF_FOUND - True if NetCDF found including required interfaces (see below) ++# NETCDF_LIBRARIES - All netcdf related libraries. ++# NETCDF_INCLUDE_DIRS - All directories to include. ++# NETCDF_HAS_INTERFACES - Whether requested interfaces were found or not. ++# NETCDF_${LANG}_INCLUDE_DIRS/NETCDF_${LANG}_LIBRARIES - C/C++/F70/F90 only interface ++# ++# Normal usage would be: ++# set (NETCDF_F90 "YES") ++# find_package (NetCDF REQUIRED) ++# target_link_libraries (uses_everthing ${NETCDF_LIBRARIES}) ++# target_link_libraries (only_uses_f90 ${NETCDF_F90_LIBRARIES}) ++ ++#search starting from user editable cache var ++if (NETCDF_INCLUDE_DIR AND NETCDF_LIBRARY) ++ # Already in cache, be silent ++ set (NETCDF_FIND_QUIETLY TRUE) ++endif () ++ ++set(USE_DEFAULT_PATHS "NO_DEFAULT_PATH") ++if(NETCDF_USE_DEFAULT_PATHS) ++ set(USE_DEFAULT_PATHS "") ++endif() ++ ++find_path (NETCDF_INCLUDE_DIR netcdf.h ++ HINTS "${NETCDF_DIR}/include") ++mark_as_advanced (NETCDF_INCLUDE_DIR) ++set (NETCDF_C_INCLUDE_DIRS ${NETCDF_INCLUDE_DIR}) ++ ++find_library (NETCDF_LIBRARY NAMES netcdf ++ HINTS "${NETCDF_DIR}/lib") ++mark_as_advanced (NETCDF_LIBRARY) ++ ++set (NETCDF_C_LIBRARIES ${NETCDF_LIBRARY}) ++ ++#start finding requested language components ++set (NetCDF_libs "") ++set (NetCDF_includes "${NETCDF_INCLUDE_DIR}") ++ ++get_filename_component (NetCDF_lib_dirs "${NETCDF_LIBRARY}" PATH) ++set (NETCDF_HAS_INTERFACES "YES") # will be set to NO if we're missing any interfaces ++ ++macro (NetCDF_check_interface lang header libs) ++ if (NETCDF_${lang}) ++ #search starting from user modifiable cache var ++ find_path (NETCDF_${lang}_INCLUDE_DIR NAMES ${header} ++ HINTS "${NETCDF_INCLUDE_DIR}" ++ HINTS "${NETCDF_${lang}_ROOT}/include" ++ ${USE_DEFAULT_PATHS}) ++ ++ find_library (NETCDF_${lang}_LIBRARY NAMES ${libs} ++ HINTS "${NetCDF_lib_dirs}" ++ HINTS "${NETCDF_${lang}_ROOT}/lib" ++ ${USE_DEFAULT_PATHS}) ++ ++ mark_as_advanced (NETCDF_${lang}_INCLUDE_DIR NETCDF_${lang}_LIBRARY) ++ ++ #export to internal varS that rest of project can use directly ++ set (NETCDF_${lang}_LIBRARIES ${NETCDF_${lang}_LIBRARY}) ++ set (NETCDF_${lang}_INCLUDE_DIRS ${NETCDF_${lang}_INCLUDE_DIR}) ++ ++ if (NETCDF_${lang}_INCLUDE_DIR AND NETCDF_${lang}_LIBRARY) ++ list (APPEND NetCDF_libs ${NETCDF_${lang}_LIBRARY}) ++ list (APPEND NetCDF_includes ${NETCDF_${lang}_INCLUDE_DIR}) ++ else () ++ set (NETCDF_HAS_INTERFACES "NO") ++ message (STATUS "Failed to find NetCDF interface for ${lang}") ++ endif () ++ endif () ++endmacro () ++ ++list (FIND NetCDF_FIND_COMPONENTS "CXX" _nextcomp) ++if (_nextcomp GREATER -1) ++ set (NETCDF_CXX 1) ++endif () ++list (FIND NetCDF_FIND_COMPONENTS "F77" _nextcomp) ++if (_nextcomp GREATER -1) ++ set (NETCDF_F77 1) ++endif () ++list (FIND NetCDF_FIND_COMPONENTS "F90" _nextcomp) ++if (_nextcomp GREATER -1) ++ set (NETCDF_F90 1) ++endif () ++NetCDF_check_interface (CXX netcdfcpp.h netcdf_c++) ++NetCDF_check_interface (F77 netcdf.inc netcdff) ++NetCDF_check_interface (F90 netcdf.mod netcdff) ++ ++#export accumulated results to internal varS that rest of project can depend on ++list (APPEND NetCDF_libs "${NETCDF_C_LIBRARIES}") ++set (NETCDF_LIBRARIES ${NetCDF_libs}) ++set (NETCDF_INCLUDE_DIRS ${NetCDF_includes}) ++ ++# handle the QUIETLY and REQUIRED arguments and set NETCDF_FOUND to TRUE if ++# all listed variables are TRUE ++include (FindPackageHandleStandardArgs) ++find_package_handle_standard_args (NetCDF ++ DEFAULT_MSG NETCDF_LIBRARIES NETCDF_INCLUDE_DIRS NETCDF_HAS_INTERFACES) +diff --git a/cmake/Modules/FindQE.cmake b/cmake/Modules/FindQE.cmake +new file mode 100644 +index 0000000000..4484bd4db2 +--- /dev/null ++++ b/cmake/Modules/FindQE.cmake +@@ -0,0 +1,29 @@ ++# - Find quantum-espresso ++# Find the native QE headers and libraries. ++# ++# QE_INCLUDE_DIRS - where to find quantum-espresso.h, etc. ++# QE_LIBRARIES - List of libraries when using quantum-espresso. ++# QE_FOUND - True if quantum-espresso found. ++# ++ ++find_path(QE_INCLUDE_DIR libqecouple.h PATH_SUFFIXES COUPLE/include) ++ ++find_library(QECOUPLE_LIBRARY NAMES qecouple) ++find_library(PW_LIBRARY NAMES pw) ++find_library(QEMOD_LIBRARY NAMES qemod) ++find_library(QEFFT_LIBRARY NAMES qefft) ++find_library(QELA_LIBRARY NAMES qela) ++find_library(CLIB_LIBRARY NAMES clib) ++find_library(IOTK_LIBRARY NAMES iotk) ++ ++ ++set(QE_LIBRARIES ${QECOUPLE_LIBRARY} ${PW_LIBRARY} ${QEMOD_LIBRARY} ${QEFFT_LIBRARY} ${QELA_LIBRARY} ${CLIB_LIBRARY} ${IOTK_LIBRARY}) ++set(QE_INCLUDE_DIRS ${QE_INCLUDE_DIR}) ++ ++include(FindPackageHandleStandardArgs) ++# handle the QUIETLY and REQUIRED arguments and set QE_FOUND to TRUE ++# if all listed variables are TRUE ++ ++find_package_handle_standard_args(QE DEFAULT_MSG QECOUPLE_LIBRARY PW_LIBRARY QEMOD_LIBRARY QEFFT_LIBRARY QELA_LIBRARY CLIB_LIBRARY IOTK_LIBRARY QE_INCLUDE_DIR) ++ ++mark_as_advanced(QE_INCLUDE_DIR QECOUPLE_LIBRARY PW_LIBRARY QEMOD_LIBRARY QEFFT_LIBRARY QELA_LIBRARY CLIB_LIBRARY IOTK_LIBRARY) +diff --git a/cmake/Modules/FindQUIP.cmake b/cmake/Modules/FindQUIP.cmake +new file mode 100644 +index 0000000000..4ee1baf4f8 +--- /dev/null ++++ b/cmake/Modules/FindQUIP.cmake +@@ -0,0 +1,18 @@ ++# - Find quip ++# Find the native QUIP libraries. ++# ++# QUIP_LIBRARIES - List of libraries when using fftw3. ++# QUIP_FOUND - True if fftw3 found. ++# ++ ++find_library(QUIP_LIBRARY NAMES quip) ++ ++set(QUIP_LIBRARIES ${QUIP_LIBRARY}) ++ ++include(FindPackageHandleStandardArgs) ++# handle the QUIETLY and REQUIRED arguments and set QUIP_FOUND to TRUE ++# if all listed variables are TRUE ++ ++find_package_handle_standard_args(QUIP DEFAULT_MSG QUIP_LIBRARY) ++ ++mark_as_advanced(QUIP_LIBRARY) +diff --git a/cmake/Modules/FindVORO.cmake b/cmake/Modules/FindVORO.cmake +new file mode 100644 +index 0000000000..b0cccbcd1d +--- /dev/null ++++ b/cmake/Modules/FindVORO.cmake +@@ -0,0 +1,22 @@ ++# - Find voro++ ++# Find the native VORO headers and libraries. ++# ++# VORO_INCLUDE_DIRS - where to find voro++.hh, etc. ++# VORO_LIBRARIES - List of libraries when using voro++. ++# VORO_FOUND - True if voro++ found. ++# ++ ++find_path(VORO_INCLUDE_DIR voro++.hh PATH_SUFFIXES voro++) ++ ++find_library(VORO_LIBRARY NAMES voro++) ++ ++set(VORO_LIBRARIES ${VORO_LIBRARY}) ++set(VORO_INCLUDE_DIRS ${VORO_INCLUDE_DIR}) ++ ++include(FindPackageHandleStandardArgs) ++# handle the QUIETLY and REQUIRED arguments and set VORO_FOUND to TRUE ++# if all listed variables are TRUE ++ ++find_package_handle_standard_args(VORO DEFAULT_MSG VORO_LIBRARY VORO_INCLUDE_DIR) ++ ++mark_as_advanced(VORO_INCLUDE_DIR VORO_LIBRARY ) +diff --git a/cmake/Modules/StyleHeaderUtils.cmake b/cmake/Modules/StyleHeaderUtils.cmake +new file mode 100644 +index 0000000000..9939a7505a +--- /dev/null ++++ b/cmake/Modules/StyleHeaderUtils.cmake +@@ -0,0 +1,132 @@ ++function(FindStyleHeaders path style_class file_pattern headers) ++ file(GLOB files "${path}/${file_pattern}*.h") ++ get_property(hlist GLOBAL PROPERTY ${headers}) ++ ++ foreach(file_name ${files}) ++ file(STRINGS ${file_name} is_style LIMIT_COUNT 1 REGEX ${style_class}) ++ if(is_style) ++ list(APPEND hlist ${file_name}) ++ endif() ++ endforeach() ++ set_property(GLOBAL PROPERTY ${headers} "${hlist}") ++endfunction(FindStyleHeaders) ++ ++function(FindStyleHeadersExt path style_class extension headers sources) ++ get_property(hlist GLOBAL PROPERTY ${headers}) ++ get_property(slist GLOBAL PROPERTY ${sources}) ++ set(ext_list) ++ get_filename_component(abs_path "${path}" ABSOLUTE) ++ ++ foreach(file_name ${hlist}) ++ get_filename_component(basename ${file_name} NAME_WE) ++ set(ext_file_name "${abs_path}/${basename}_${extension}.h") ++ if(EXISTS "${ext_file_name}") ++ file(STRINGS ${ext_file_name} is_style LIMIT_COUNT 1 REGEX ${style_class}) ++ if(is_style) ++ list(APPEND ext_list ${ext_file_name}) ++ ++ set(source_file_name "${abs_path}/${basename}_${extension}.cpp") ++ if(EXISTS "${source_file_name}") ++ list(APPEND slist ${source_file_name}) ++ endif() ++ endif() ++ endif() ++ endforeach() ++ ++ list(APPEND hlist ${ext_list}) ++ set_property(GLOBAL PROPERTY ${headers} "${hlist}") ++ set_property(GLOBAL PROPERTY ${sources} "${slist}") ++endfunction(FindStyleHeadersExt) ++ ++function(CreateStyleHeader path filename) ++ math(EXPR N "${ARGC}-2") ++ ++ set(temp "") ++ if(N GREATER 0) ++ math(EXPR ARG_END "${ARGC}-1") ++ ++ foreach(IDX RANGE 2 ${ARG_END}) ++ list(GET ARGV ${IDX} FNAME) ++ get_filename_component(FNAME ${FNAME} NAME) ++ set(temp "${temp}#include \"${FNAME}\"\n") ++ endforeach() ++ endif() ++ message(STATUS "Generating ${filename}...") ++ file(WRITE "${path}/${filename}.tmp" "${temp}" ) ++ execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${path}/${filename}.tmp" "${path}/${filename}") ++endfunction(CreateStyleHeader) ++ ++function(GenerateStyleHeader path property style) ++ get_property(files GLOBAL PROPERTY ${property}) ++ #message("${property} = ${files}") ++ CreateStyleHeader("${path}" "style_${style}.h" ${files}) ++endfunction(GenerateStyleHeader) ++ ++function(RegisterStyles search_path) ++ FindStyleHeaders(${search_path} ANGLE_CLASS angle_ ANGLE ) # angle ) # force ++ FindStyleHeaders(${search_path} ATOM_CLASS atom_vec_ ATOM_VEC ) # atom ) # atom atom_vec_hybrid ++ FindStyleHeaders(${search_path} BODY_CLASS body_ BODY ) # body ) # atom_vec_body ++ FindStyleHeaders(${search_path} BOND_CLASS bond_ BOND ) # bond ) # force ++ FindStyleHeaders(${search_path} COMMAND_CLASS "" COMMAND ) # command ) # input ++ FindStyleHeaders(${search_path} COMPUTE_CLASS compute_ COMPUTE ) # compute ) # modify ++ FindStyleHeaders(${search_path} DIHEDRAL_CLASS dihedral_ DIHEDRAL ) # dihedral ) # force ++ FindStyleHeaders(${search_path} DUMP_CLASS dump_ DUMP ) # dump ) # output write_dump ++ FindStyleHeaders(${search_path} FIX_CLASS fix_ FIX ) # fix ) # modify ++ FindStyleHeaders(${search_path} IMPROPER_CLASS improper_ IMPROPER ) # improper ) # force ++ FindStyleHeaders(${search_path} INTEGRATE_CLASS "" INTEGRATE ) # integrate ) # update ++ FindStyleHeaders(${search_path} KSPACE_CLASS "" KSPACE ) # kspace ) # force ++ FindStyleHeaders(${search_path} MINIMIZE_CLASS min_ MINIMIZE ) # minimize ) # update ++ FindStyleHeaders(${search_path} NBIN_CLASS nbin_ NBIN ) # nbin ) # neighbor ++ FindStyleHeaders(${search_path} NPAIR_CLASS npair_ NPAIR ) # npair ) # neighbor ++ FindStyleHeaders(${search_path} NSTENCIL_CLASS nstencil_ NSTENCIL ) # nstencil ) # neighbor ++ FindStyleHeaders(${search_path} NTOPO_CLASS ntopo_ NTOPO ) # ntopo ) # neighbor ++ FindStyleHeaders(${search_path} PAIR_CLASS pair_ PAIR ) # pair ) # force ++ FindStyleHeaders(${search_path} READER_CLASS reader_ READER ) # reader ) # read_dump ++ FindStyleHeaders(${search_path} REGION_CLASS region_ REGION ) # region ) # domain ++endfunction(RegisterStyles) ++ ++function(RegisterStylesExt search_path extension sources) ++ FindStyleHeadersExt(${search_path} ANGLE_CLASS ${extension} ANGLE ${sources}) ++ FindStyleHeadersExt(${search_path} ATOM_CLASS ${extension} ATOM_VEC ${sources}) ++ FindStyleHeadersExt(${search_path} BODY_CLASS ${extension} BODY ${sources}) ++ FindStyleHeadersExt(${search_path} BOND_CLASS ${extension} BOND ${sources}) ++ FindStyleHeadersExt(${search_path} COMMAND_CLASS ${extension} COMMAND ${sources}) ++ FindStyleHeadersExt(${search_path} COMPUTE_CLASS ${extension} COMPUTE ${sources}) ++ FindStyleHeadersExt(${search_path} DIHEDRAL_CLASS ${extension} DIHEDRAL ${sources}) ++ FindStyleHeadersExt(${search_path} DUMP_CLASS ${extension} DUMP ${sources}) ++ FindStyleHeadersExt(${search_path} FIX_CLASS ${extension} FIX ${sources}) ++ FindStyleHeadersExt(${search_path} IMPROPER_CLASS ${extension} IMPROPER ${sources}) ++ FindStyleHeadersExt(${search_path} INTEGRATE_CLASS ${extension} INTEGRATE ${sources}) ++ FindStyleHeadersExt(${search_path} KSPACE_CLASS ${extension} KSPACE ${sources}) ++ FindStyleHeadersExt(${search_path} MINIMIZE_CLASS ${extension} MINIMIZE ${sources}) ++ FindStyleHeadersExt(${search_path} NBIN_CLASS ${extension} NBIN ${sources}) ++ FindStyleHeadersExt(${search_path} NPAIR_CLASS ${extension} NPAIR ${sources}) ++ FindStyleHeadersExt(${search_path} NSTENCIL_CLASS ${extension} NSTENCIL ${sources}) ++ FindStyleHeadersExt(${search_path} NTOPO_CLASS ${extension} NTOPO ${sources}) ++ FindStyleHeadersExt(${search_path} PAIR_CLASS ${extension} PAIR ${sources}) ++ FindStyleHeadersExt(${search_path} READER_CLASS ${extension} READER ${sources}) ++ FindStyleHeadersExt(${search_path} REGION_CLASS ${extension} REGION ${sources}) ++endfunction(RegisterStylesExt) ++ ++function(GenerateStyleHeaders output_path) ++ GenerateStyleHeader(${output_path} ANGLE angle ) # force ++ GenerateStyleHeader(${output_path} ATOM_VEC atom ) # atom atom_vec_hybrid ++ GenerateStyleHeader(${output_path} BODY body ) # atom_vec_body ++ GenerateStyleHeader(${output_path} BOND bond ) # force ++ GenerateStyleHeader(${output_path} COMMAND command ) # input ++ GenerateStyleHeader(${output_path} COMPUTE compute ) # modify ++ GenerateStyleHeader(${output_path} DIHEDRAL dihedral ) # force ++ GenerateStyleHeader(${output_path} DUMP dump ) # output write_dump ++ GenerateStyleHeader(${output_path} FIX fix ) # modify ++ GenerateStyleHeader(${output_path} IMPROPER improper ) # force ++ GenerateStyleHeader(${output_path} INTEGRATE integrate ) # update ++ GenerateStyleHeader(${output_path} KSPACE kspace ) # force ++ GenerateStyleHeader(${output_path} MINIMIZE minimize ) # update ++ GenerateStyleHeader(${output_path} NBIN nbin ) # neighbor ++ GenerateStyleHeader(${output_path} NPAIR npair ) # neighbor ++ GenerateStyleHeader(${output_path} NSTENCIL nstencil ) # neighbor ++ GenerateStyleHeader(${output_path} NTOPO ntopo ) # neighbor ++ GenerateStyleHeader(${output_path} PAIR pair ) # force ++ GenerateStyleHeader(${output_path} READER reader ) # read_dump ++ GenerateStyleHeader(${output_path} REGION region ) # domain ++endfunction(GenerateStyleHeaders) +diff --git a/cmake/README b/cmake/README +new file mode 100644 +index 0000000000..cc67cceb52 +--- /dev/null ++++ b/cmake/README +@@ -0,0 +1,19 @@ ++cmake-buildsystem ++----------------- ++ ++To use the cmake build system instead of the make-driven one, do: ++``` ++cmake /path/to/lammps/source/cmake ++``` ++(please note the cmake directory as the very end) ++ ++To enable package, e.g. GPU do ++``` ++cmake /path/to/lammps/source/cmake -DENABLE_GPU=ON ++``` ++ ++cmake has many many options, do get an overview use the curses-based cmake interface, ccmake: ++``` ++ccmake /path/to/lammps/source/cmake ++``` ++(Don't forget to press "g" for generate once you are done with configuring) +diff --git a/cmake/gpu/lal_pppm_d.cu b/cmake/gpu/lal_pppm_d.cu +new file mode 100644 +index 0000000000..a49a535013 +--- /dev/null ++++ b/cmake/gpu/lal_pppm_d.cu +@@ -0,0 +1,4 @@ ++#define grdtyp double ++#define grdtyp4 double4 ++ ++#include "lal_pppm.cu" +diff --git a/cmake/gpu/lal_pppm_f.cu b/cmake/gpu/lal_pppm_f.cu +new file mode 100644 +index 0000000000..e7f5116fa0 +--- /dev/null ++++ b/cmake/gpu/lal_pppm_f.cu +@@ -0,0 +1,4 @@ ++#define grdtyp float ++#define grdtyp4 float4 ++ ++#include "lal_pppm.cu" diff --git a/lammps/594.patch b/lammps/594.patch new file mode 100644 index 0000000..fc21609 --- /dev/null +++ b/lammps/594.patch @@ -0,0 +1,22 @@ +From edc756a65f76ca56d7dd9a3bf567d7b8cf4a1871 Mon Sep 17 00:00:00 2001 +From: Christoph Junghans +Date: Fri, 21 Jul 2017 17:09:28 -0600 +Subject: [PATCH] LICENSE: update address of Free Software Foundation + +--- + LICENSE | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/LICENSE b/LICENSE +index a0c2723a0c..f9489c8cf8 100644 +--- a/LICENSE ++++ b/LICENSE +@@ -3,7 +3,7 @@ GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. +-59 Temple Place - Suite 330, Boston, MA 02111-1307, USA ++51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + + Everyone is permitted to copy and distribute verbatim copies of this + license document, but changing it is not allowed. diff --git a/lammps/lammps-patch_6Jul2017.tar.gz b/lammps/lammps-patch_6Jul2017.tar.gz new file mode 100644 index 0000000..d2fcd23 Binary files /dev/null and b/lammps/lammps-patch_6Jul2017.tar.gz differ diff --git a/lammps/lammps.spec b/lammps/lammps.spec new file mode 100644 index 0000000..d7612a1 --- /dev/null +++ b/lammps/lammps.spec @@ -0,0 +1,194 @@ +%if 0%{?fedora} > 12 || 0%{?rhel} > 6 +%global with_python3 1 +%else +%{!?python_sitearch: %global python_sitearch %(%{__python} -c "from distutils.sysconfig import get_python_lib; print get_python_lib(1)")} +%endif + +Name: lammps +Version: 20170706 +%global uversion patch_6Jul2017 +Release: 1%{?dist} +Summary: Molecular Dynamics Simulator +License: GPLv2 +Url: http://lammps.sandia.gov +Source0: https://github.com/lammps/lammps/archive/%{uversion}.tar.gz#/%{name}-%{uversion}.tar.gz +#PATCH-FIX-UPSTREAM 573.diff, add cmake build system https://github.com/lammps/lammps/pull/573 +Patch0: https://patch-diff.githubusercontent.com/raw/lammps/lammps/pull/573.diff +#PATCH-FIX-UPSTREAM 594.patch, fix fsf adress https://github.com/lammps/lammps/pull/594 +Patch1: https://patch-diff.githubusercontent.com/raw/lammps/lammps/pull/594.patch +BuildRequires: fftw-devel +BuildRequires: gcc-c++ +BuildRequires: gcc-gfortran +BuildRequires: libpng-devel +BuildRequires: libjpeg-devel +BuildRequires: openmpi-devel +BuildRequires: python-devel +BuildRequires: fftw3-devel +BuildRequires: zlib-devel +BuildRequires: gsl-devel +BuildRequires: cmake +BuildRoot: %{_tmppath}/%{name}-%{version}-build + +%description +LAMMPS is a classical molecular dynamics code, and an acronym for Large-scale +Atomic/Molecular Massively Parallel Simulator. + +LAMMPS has potentials for soft materials (biomolecules, polymers) and +solid-state materials (metals, semiconductors) and coarse-grained or +mesoscopic systems. It can be used to model atoms or, more generically, as a +parallel particle simulator at the atomic, meso, or continuum scale. + +LAMMPS runs on single processors or in parallel using message-passing +techniques and a spatial-decomposition of the simulation domain. The code is +designed to be easy to modify or extend with new functionality. + +%package openmpi +Summary: LAMMPS Open MPI binaries and libraries +BuildRequires: openmpi-devel + +%description openmpi +LAMMPS is a classical molecular dynamics code, and an acronym for Large-scale +Atomic/Molecular Massively Parallel Simulator. + +LAMMPS has potentials for soft materials (biomolecules, polymers) and +solid-state materials (metals, semiconductors) and coarse-grained or +mesoscopic systems. It can be used to model atoms or, more generically, as a +parallel particle simulator at the atomic, meso, or continuum scale. + +LAMMPS runs on single processors or in parallel using message-passing +techniques and a spatial-decomposition of the simulation domain. The code is +designed to be easy to modify or extend with new functionality. + +This package contains LAMMPS Open MPI binaries and libraries + +%package mpich +Summary: LAMMPS MPICH binaries and libraries +BuildRequires: mpich-devel + +%description mpich +LAMMPS is a classical molecular dynamics code, and an acronym for Large-scale +Atomic/Molecular Massively Parallel Simulator. + +LAMMPS has potentials for soft materials (biomolecules, polymers) and +solid-state materials (metals, semiconductors) and coarse-grained or +mesoscopic systems. It can be used to model atoms or, more generically, as a +parallel particle simulator at the atomic, meso, or continuum scale. + +LAMMPS runs on single processors or in parallel using message-passing +techniques and a spatial-decomposition of the simulation domain. The code is +designed to be easy to modify or extend with new functionality. + +This package contains LAMMPS MPICH binaries and libraries + +%package devel +Summary: Development headers and libraries for LAMMPS +Requires: %{name}%{?_isa} = %{version}-%{release} +BuildRequires: mpich-devel +BuildRequires: openmpi-devel + +%description devel +LAMMPS is a classical molecular dynamics code, and an acronym for Large-scale +Atomic/Molecular Massively Parallel Simulator. + +LAMMPS has potentials for soft materials (biomolecules, polymers) and +solid-state materials (metals, semiconductors) and coarse-grained or +mesoscopic systems. It can be used to model atoms or, more generically, as a +parallel particle simulator at the atomic, meso, or continuum scale. + +LAMMPS runs on single processors or in parallel using message-passing +techniques and a spatial-decomposition of the simulation domain. The code is +designed to be easy to modify or extend with new functionality. + +This package contains development headers and libraries for LAMMPS. + +%prep +%setup -q -n %{name}-%{uversion} +%patch0 -p1 +%patch1 -p1 + +%build +#python wrapper isn't mpi specific +%global defopts \\\ + -DENABLE_ALL=ON \\\ + -DENABLE_PYTHON=ON \\\ + -DENABLE_TESTING=ON \\\ + -DPYTHON_INST_DIR=%{python_sitearch} \\\ + -DFFT=FFTW3 + +mkdir -p {serial,mpich,openmpi} +cd openmpi +%{_openmpi_load} +%{cmake} %{defopts} \ + -DENABLE_MPI=ON \ + -DCMAKE_INSTALL_BINDIR=$MPI_BIN \ + -DCMAKE_INSTALL_LIBDIR=$MPI_LIB \ + ../cmake +%make_build +%{_openmpi_unload} +cd .. + +cd mpich +%{_mpich_load} +%{cmake} %{defopts} \ + -DENABLE_MPI=ON \ + -DCMAKE_INSTALL_BINDIR=$MPI_BIN \ + -DCMAKE_INSTALL_LIBDIR=$MPI_LIB \ + ../cmake +%make_build +%{_mpich_unload} +cd .. + +cd serial +%{cmake} %{defopts} \ + -DENABLE_MPI=OFF \ + ../cmake +%make_build +cd .. + +%install +%make_install -C serial +%make_install -C mpich +%make_install -C openmpi + +%check +make -C serial %{?_smp_mflags} test +%{_mpich_load} +make -C mpich %{?_smp_mflags} test +%{_mpich_unload} +%{_openmpi_load} +make -C openmpi %{?_smp_mflags} test +%{_openmpi_unload} + +# MPI subpackages don't need the ldconfig magic. They are hidden by +# default, in MPI back-end-specific directory, and only show to the +# user after the relevant environment module has been loaded. +# rpmlint will report that as errors, but it is fine. +%post -n lammps -p /sbin/ldconfig +%postun -n lammps -p /sbin/ldconfig + +%files +%doc README +%license LICENSE +%{_bindir}/lmp +%{_libdir}/liblammps.so.* + +%files devel +%doc LICENSE +%{_includedir}/lammps.h +%{_libdir}/liblammps.so +%{_libdir}/mpich*/lib/liblammps.so +%{_libdir}/openmpi*/lib/liblammps.so +%{python_sitearch}/%{name}.py* + +%files openmpi +%{_libdir}/openmpi*/bin/* +%{_libdir}/openmpi*/lib/liblammps.so.* + +%files mpich +%{_libdir}/mpich*/bin/* +%{_libdir}/mpich*/lib/liblammps.so.* + +%changelog +* Fri Jul 21 2017 Christoph Junghans - 20170706-1 +- Initial import + -- cgit