lammps: initial commit

4 files changed, 1289 insertions, 0 deletions

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 $<$<BOOL:${BUILD_SHARED_LIBS}>:-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 <junghans@votca.org>
+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
--- /dev/null
+++ b/lammps/lammps-patch_6Jul2017.tar.gz
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 <junghans@votca.org> - 20170706-1
+- Initial import
+