jianmu
/
lammps
forked from lijiext/lammps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'clean-master2' of github.com:julient31/lammps into STT2

This commit is contained in:
julient31 2021-04-19 17:32:16 -06:00
parent a64378ba5b 288c0a8023
commit 58549fa10d
261 changed files with 17830 additions and 982 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
cmake/CMakeLists.txt
View File

@ -124,7 +124,7 @@ set(STANDARD_PACKAGES ASPHERE BODY CLASS2 COLLOID COMPRESS DIPOLE
USER-LB USER-MANIFOLD USER-MEAMC USER-MESONT USER-MGPT USER-MISC USER-MOFFF
USER-MOLFILE USER-NETCDF USER-PHONON USER-PLUMED USER-PTM USER-QTB
USER-REACTION USER-REAXC USER-SCAFACOS USER-SDPD USER-SMD USER-SMTBQ USER-SPH
USER-TALLY USER-UEF USER-VTK USER-QUIP USER-QMMM USER-YAFF)
USER-TALLY USER-UEF USER-VTK USER-QUIP USER-QMMM USER-YAFF USER-PACE)
set(SUFFIX_PACKAGES CORESHELL GPU KOKKOS OPT USER-INTEL USER-OMP)
@ -269,6 +269,7 @@ endif()
set(ENABLE_IWYU OFF CACHE BOOL "Add 'iwyu' build target to call the include-what-you-use tool")
mark_as_advanced(ENABLE_IWYU)
if(ENABLE_IWYU)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
find_program(IWYU_EXE NAMES include-what-you-use iwyu)
find_program(IWYU_TOOL NAMES iwyu_tool iwyu-tool iwyu_tool.py)
if (IWYU_EXE AND IWYU_TOOL)
@ -387,9 +388,9 @@ else()
endif()
foreach(PKG_WITH_INCL KSPACE PYTHON MLIAP VORONOI USER-COLVARS USER-MOLFILE USER-NETCDF USER-PLUMED USER-QMMM
USER-QUIP USER-SCAFACOS USER-SMD USER-VTK KIM LATTE MESSAGE MSCG COMPRESS)
USER-QUIP USER-SCAFACOS USER-SMD USER-VTK KIM LATTE MESSAGE MSCG COMPRESS USER-PACE)
if(PKG_${PKG_WITH_INCL})
include(Packages/${PKG_WITH_INCL})
include(Packages/${PKG_WITH_INCL})
endif()
endforeach()
@ -730,7 +731,7 @@ get_target_property(DEFINES lammps COMPILE_DEFINITIONS)
include(FeatureSummary)
feature_summary(DESCRIPTION "The following tools and libraries have been found and configured:" WHAT PACKAGES_FOUND)
message(STATUS "<<< Build configuration >>>
Operating System: ${CMAKE_SYSTEM_NAME}
Operating System: ${CMAKE_SYSTEM_NAME} ${CMAKE_LINUX_DISTRO} ${CMAKE_DISTRO_VERSION}
Build type: ${CMAKE_BUILD_TYPE}
Install path: ${CMAKE_INSTALL_PREFIX}
Generator: ${CMAKE_GENERATOR} using ${CMAKE_MAKE_PROGRAM}")

10
cmake/Modules/LAMMPSUtils.cmake
View File

@ -104,3 +104,13 @@ function(FetchPotentials pkgfolder potfolder)
endforeach()
endif()
endfunction(FetchPotentials)
# set CMAKE_LINUX_DISTRO and CMAKE_DISTRO_VERSION on Linux
if((CMAKE_SYSTEM_NAME STREQUAL Linux) AND (EXISTS /etc/os-release))
file(STRINGS /etc/os-release distro REGEX "^NAME=")
string(REGEX REPLACE "NAME=\"?([^\"]*)\"?" "\\1" distro "${distro}")
file(STRINGS /etc/os-release disversion REGEX "^VERSION_ID=")
string(REGEX REPLACE "VERSION_ID=\"?([^\"]*)\"?" "\\1" disversion "${disversion}")
set(CMAKE_LINUX_DISTRO ${distro})
set(CMAKE_DISTRO_VERSION ${disversion})
endif()

26
cmake/Modules/Packages/USER-PACE.cmake Normal file
View File

@ -0,0 +1,26 @@
set(PACELIB_URL "https://github.com/ICAMS/lammps-user-pace/archive/refs/tags/v.2021.4.9.tar.gz" CACHE STRING "URL for PACE evaluator library sources")
set(PACELIB_MD5 "4db54962fbd6adcf8c18d46e1798ceb5" CACHE STRING "MD5 checksum of PACE evaluator library tarball")
mark_as_advanced(PACELIB_URL)
mark_as_advanced(PACELIB_MD5)
# download library sources to build folder
file(DOWNLOAD ${PACELIB_URL} ${CMAKE_BINARY_DIR}/libpace.tar.gz SHOW_PROGRESS EXPECTED_HASH MD5=${PACELIB_MD5})
# uncompress downloaded sources
execute_process(
COMMAND ${CMAKE_COMMAND} -E remove_directory lammps-user-pace*
COMMAND ${CMAKE_COMMAND} -E tar xzf libpace.tar.gz
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
file(GLOB PACE_EVALUATOR_INCLUDE_DIR ${CMAKE_BINARY_DIR}/lammps-user-pace-*/USER-PACE)
file(GLOB PACE_EVALUATOR_SOURCES ${CMAKE_BINARY_DIR}/lammps-user-pace-*/USER-PACE/*.cpp)
list(FILTER PACE_EVALUATOR_SOURCES EXCLUDE REGEX pair_pace.cpp)
add_library(pace STATIC ${PACE_EVALUATOR_SOURCES})
set_target_properties(pace PROPERTIES OUTPUT_NAME pace${LAMMPS_MACHINE})
target_include_directories(pace PUBLIC ${PACE_EVALUATOR_INCLUDE_DIR})
target_link_libraries(lammps PRIVATE pace)

5
cmake/Modules/Packages/USER-PLUMED.cmake
View File

@ -54,8 +54,9 @@ if(DOWNLOAD_PLUMED)
set(PLUMED_BUILD_BYPRODUCTS "<INSTALL_DIR>/lib/libplumedWrapper.a")
endif()
set(PLUMED_URL "https://github.com/plumed/plumed2/releases/download/v2.7.0/plumed-src-2.7.0.tgz" CACHE STRING "URL for PLUMED tarball")
set(PLUMED_MD5 "95f29dd0c067577f11972ff90dfc7d12" CACHE STRING "MD5 checksum of PLUMED tarball")
set(PLUMED_URL "https://github.com/plumed/plumed2/releases/download/v2.7.1/plumed-src-2.7.1.tgz" CACHE STRING "URL for PLUMED tarball")
set(PLUMED_MD5 "4eac6a462ec84dfe0cec96c82421b8e8" CACHE STRING "MD5 checksum of PLUMED tarball")
mark_as_advanced(PLUMED_URL)
mark_as_advanced(PLUMED_MD5)

13
cmake/Modules/Testing.cmake
View File

@ -16,11 +16,14 @@ if(ENABLE_TESTING)
set(MEMORYCHECK_COMMAND "${VALGRIND_BINARY}" CACHE FILEPATH "Memory Check Command")
set(MEMORYCHECK_COMMAND_OPTIONS "${VALGRIND_DEFAULT_OPTIONS}" CACHE STRING "Memory Check Command Options")
# check if a faster linker is available.
# only verified with GNU and Clang compilers and new CMake
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.13)
if((${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
OR (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang"))
# we need to build and link a LOT of tester executables, so it is worth checking if
# a faster linker is available. requires GNU or Clang compiler, newer CMake.
# also only verified with Fedora Linux > 30 and Ubuntu <= 18.04 (Ubuntu 20.04 fails)
if((CMAKE_SYSTEM_NAME STREQUAL Linux) AND (CMAKE_VERSION VERSION_GREATER_EQUAL 3.13)
AND ((${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
OR (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")))
if (((CMAKE_LINUX_DISTRO STREQUAL Ubuntu) AND (CMAKE_DISTRO_VERSION VERSION_LESS_EQUAL 18.04))
OR ((CMAKE_LINUX_DISTRO STREQUAL Fedora) AND (CMAKE_DISTRO_VERSION VERSION_GREATER 30)))
include(CheckCXXCompilerFlag)
set(CMAKE_CUSTOM_LINKER_DEFAULT default)
check_cxx_compiler_flag(-fuse-ld=lld HAVE_LLD_LINKER_FLAG)

10
doc/graphviz/lammps-classes.dot
View File

@ -18,8 +18,8 @@ digraph lammps {
Up [shape=box label="Update" color=blue]
Un [shape=box label="Universe" color=blue]
Ti [shape=box label="Timer" color=blue]
Lt [label="Lattice"]
Rg [label="Region" color=red]
Lt [label="Lattice"]
Rb [shape=box label="RegionBlock"]
Rs [shape=box label="RegionSphere"]
Av [label="AtomVec" color=red]
@ -34,6 +34,7 @@ digraph lammps {
Du [label="Dump" color=red]
Fi [label="Fix" color=red]
Cp [label="Compute" color=red]
Cm [label="Command" color=red]
Th [label="Thermo"]
Va [label="Variable"]
Ew [shape=box label="Ewald"]
@ -71,16 +72,19 @@ digraph lammps {
Dg [shape=box label="DumpCFG"]
Ve [shape=box label="Verlet"]
Rr [shape=box label="Respa"]
Ru [shape=box label="Run"]
Se [shape=box label="Set"]
Pt [shape=box label="PPPMTIP4P"]
Vs [shape=box label="VerletSplit"]
Ro [shape=box label="RespaOMP"]
Mc [shape=box label="MinCG"]
Mf [shape=box label="MinFire"]
La -> {At Ci Co Do Er Fo Gr In Me Mo Ne Ou Ti Up Un} [penwidth=2]
Do -> {Lt Rg} [penwidth=2]
Do -> {Rg Lt} [penwidth=2]
Rg -> {Rb Rs} [style=dashed penwidth=2]
Co -> {Cb Ct} [style=dashed penwidth=2]
In -> Va [penwidth=2]
In -> {Va Cm} [penwidth=2]
Cm -> {Ru Se} [style=dashed penwidth=2]
Mo -> {Fi Cp} [penwidth=2]
Fo -> {Pa Bo An Di Im Ks} [penwidth=2]
Ks -> {Ew Pp} [style=dashed penwidth=2]

41
doc/src/Build_extras.rst
View File

@ -52,6 +52,7 @@ This is the list of packages that may require additional steps.
* :ref:`USER-MESONT <user-mesont>`
* :ref:`USER-MOLFILE <user-molfile>`
* :ref:`USER-NETCDF <user-netcdf>`
* :ref:`USER-PACE <user-pace>`
* :ref:`USER-PLUMED <user-plumed>`
* :ref:`USER-OMP <user-omp>`
* :ref:`USER-QMMM <user-qmmm>`
@ -1247,6 +1248,46 @@ be built for the most part with all major versions of the C++ language.
----------
.. _user-pace:
USER-PACE package
-----------------------------
This package requires a library that can be downloaded and built
in lib/pace or somewhere else, which must be done before building
LAMMPS with this package. The code for the library can be found
at: `https://github.com/ICAMS/lammps-user-pace/ <https://github.com/ICAMS/lammps-user-pace/>`_
.. tabs::
.. tab:: CMake build
By default the library will be downloaded from the git repository
and built automatically when the USER-PACE package is enabled with
``-D PKG_USER-PACE=yes``. The location for the sources may be
customized by setting the variable ``PACELIB_URL`` when
configuring with CMake (e.g. to use a local archive on machines
without internet access). Since CMake checks the validity of the
archive with ``md5sum`` you may also need to set ``PACELIB_MD5``
if you provide a different library version than what is downloaded
automatically.
.. tab:: Traditional make
You can download and build the USER-PACE library
in one step from the ``lammps/src`` dir, using these commands,
which invoke the ``lib/pace/Install.py`` script.
.. code-block:: bash
$ make lib-pace # print help message
$ make lib-pace args="-b" # download and build the default version in lib/pace
You should not need to edit the ``lib/pace/Makefile.lammps`` file.
----------
.. _user-plumed:
USER-PLUMED package

22
doc/src/Build_package.rst
View File

@ -30,17 +30,17 @@ steps, as explained on the :doc:`Build extras <Build_extras>` page.
These links take you to the extra instructions for those select
packages:
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
| :ref:`COMPRESS <compress>` | :ref:`GPU <gpu>` | :ref:`KIM <kim>` | :ref:`KOKKOS <kokkos>` | :ref:`LATTE <latte>` | :ref:`MESSAGE <message>` |
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
| :ref:`MSCG <mscg>` | :ref:`OPT <opt>` | :ref:`POEMS <poems>` | :ref:`PYTHON <python>` | :ref:`VORONOI <voronoi>` | :ref:`USER-ADIOS <user-adios>` |
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
| :ref:`USER-ATC <user-atc>` | :ref:`USER-AWPMD <user-awpmd>` | :ref:`USER-COLVARS <user-colvars>` | :ref:`USER-H5MD <user-h5md>` | :ref:`USER-INTEL <user-intel>` | :ref:`USER-MOLFILE <user-molfile>` |
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
| :ref:`USER-NETCDF <user-netcdf>` | :ref:`USER-PLUMED <user-plumed>` | :ref:`USER-OMP <user-omp>` | :ref:`USER-QMMM <user-qmmm>` | :ref:`USER-QUIP <user-quip>` | :ref:`USER-SCAFACOS <user-scafacos>` |
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
| :ref:`USER-SMD <user-smd>` | :ref:`USER-VTK <user-vtk>` | | | | |
+----------------------------------+----------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
+--------------------------------------+--------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
| :ref:`COMPRESS <compress>` | :ref:`GPU <gpu>` | :ref:`KIM <kim>` | :ref:`KOKKOS <kokkos>` | :ref:`LATTE <latte>` | :ref:`MESSAGE <message>` |
+--------------------------------------+--------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
| :ref:`MSCG <mscg>` | :ref:`OPT <opt>` | :ref:`POEMS <poems>` | :ref:`PYTHON <python>` | :ref:`VORONOI <voronoi>` | :ref:`USER-ADIOS <user-adios>` |
+--------------------------------------+--------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
| :ref:`USER-ATC <user-atc>` | :ref:`USER-AWPMD <user-awpmd>` | :ref:`USER-COLVARS <user-colvars>` | :ref:`USER-H5MD <user-h5md>` | :ref:`USER-INTEL <user-intel>` | :ref:`USER-MOLFILE <user-molfile>` |
+--------------------------------------+--------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
| :ref:`USER-NETCDF <user-netcdf>` | :ref:`USER-PACE <user-pace>` | :ref:`USER-PLUMED <user-plumed>` | :ref:`USER-OMP <user-omp>` | :ref:`USER-QMMM <user-qmmm>` | :ref:`USER-QUIP <user-quip>` |
+--------------------------------------+--------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
| :ref:`USER-SCAFACOS <user-scafacos>` | :ref:`USER-SMD <user-smd>` | :ref:`USER-VTK <user-vtk>` | | | |
+--------------------------------------+--------------------------------+------------------------------------+------------------------------+--------------------------------+--------------------------------------+
The mechanism for including packages is simple but different for CMake
versus make.

1
doc/src/Commands_fix.rst
View File

@ -46,6 +46,7 @@ OPT.
* :doc:`bond/react <fix_bond_react>`
* :doc:`bond/swap <fix_bond_swap>`
* :doc:`box/relax <fix_box_relax>`
* :doc:`charge/regulation <fix_charge_regulation>`
* :doc:`client/md <fix_client_md>`
* :doc:`cmap <fix_cmap>`
* :doc:`colvars <fix_colvars>`

1
doc/src/Commands_pair.rst
View File

@ -216,6 +216,7 @@ OPT.
* :doc:`oxrna2/stk <pair_oxrna2>`
* :doc:`oxrna2/xstk <pair_oxrna2>`
* :doc:`oxrna2/coaxstk <pair_oxrna2>`
* :doc:`pace <pair_pace>`
* :doc:`peri/eps <pair_peri>`
* :doc:`peri/lps (o) <pair_peri>`
* :doc:`peri/pmb (o) <pair_peri>`

16
doc/src/Developer_org.rst
View File

@ -49,8 +49,8 @@ underscore character '_' to separate words. Outside of bundled libraries
which may have different conventions, all C and C++ header files have a
``.h`` extension, all C++ files have a ``.cpp`` extension, and C files a
``.c`` extension. A small number of C++ classes and utility functions
are implemented with only a ``.h`` file. Examples are the Pointer class
or the MathVec functions.
are implemented with only a ``.h`` file. Examples are the Pointers and
Commands classes or the MathVec functions.
Class topology
--------------
@ -144,7 +144,7 @@ implement specific commands that can be invoked before, after, or in
between runs. For these an instance of the class is created, its
command() method called and then, after completion, the class instance
deleted. Examples for this are the create_box, create_atoms, minimize,
run, or velocity command styles.
run, set, or velocity command styles.
For all those ``styles`` certain naming conventions are employed: for
the fix nve command the class is called FixNVE and the source files are
@ -175,11 +175,11 @@ follows:
- The Input class reads and processes input input strings and files,
stores variables, and invokes :doc:`commands <Commands_all>`.
- As discussed above, command style classes are directly derived from
the Pointers class. They provide input script commands that perform
one-time operations before/after/between simulations or which invoke a
simulation. They are instantiated from within the Input class,
invoked, then immediately destructed.
- Command style classes are derived from the Command class. They provide
input script commands that perform one-time operations
before/after/between simulations or which invoke a simulation. They
are usually instantiated from within the Input class, its ``command``
method invoked, and then immediately destructed.
- The Finish class is instantiated to print statistics to the screen
after a simulation is performed, by commands like run and minimize.

61
doc/src/Developer_plugins.rst
View File

@ -59,31 +59,25 @@ Members of ``lammpsplugin_t``
* - author
- String with the name and email of the author
* - creator.v1
- Pointer to factory function for pair, bond, angle, dihedral, or improper styles
- Pointer to factory function for pair, bond, angle, dihedral, improper or command styles
* - creator.v2
- Pointer to factory function for compute, fix, or region styles
* - creator.v3
- Pointer to factory function for command styles
* - handle
- Pointer to the open DSO file handle
Only one of the three alternate creator entries can be used at a time
and which of those is determined by the style of plugin. The "creator.v1"
element is for factory functions of supported styles computing forces (i.e.
pair, bond, angle, dihedral, or improper styles) and the function takes
as single argument the pointer to the LAMMPS instance. The factory function
is cast to the ``lammpsplugin_factory1`` type before assignment. The
"creator.v2" element is for factory functions creating an instance of
a fix, compute, or region style and takes three arguments: a pointer to
the LAMMPS instance, an integer with the length of the argument list and
a ``char **`` pointer to the list of arguments. The factory function pointer
needs to be cast to the ``lammpsplugin_factory2`` type before assignment.
The "creator.v3" element takes the same arguments as "creator.v3" but is
specific to creating command styles: the factory function has to instantiate
the command style locally passing the LAMMPS pointer as argument and then
call its "command" member function with the number and list of arguments.
The factory function pointer needs to be cast to the
``lammpsplugin_factory3`` type before assignment.
and which of those is determined by the style of plugin. The
"creator.v1" element is for factory functions of supported styles
computing forces (i.e. command, pair, bond, angle, dihedral, or
improper styles) and the function takes as single argument the pointer
to the LAMMPS instance. The factory function is cast to the
``lammpsplugin_factory1`` type before assignment. The "creator.v2"
element is for factory functions creating an instance of a fix, compute,
or region style and takes three arguments: a pointer to the LAMMPS
instance, an integer with the length of the argument list and a ``char
**`` pointer to the list of arguments. The factory function pointer
needs to be cast to the ``lammpsplugin_factory2`` type before
assignment.
Pair style example
^^^^^^^^^^^^^^^^^^
@ -123,12 +117,12 @@ function would look like this:
The factory function in this example is called ``morse2creator()``. It
receives a pointer to the LAMMPS class as only argument and thus has to
be assigned to the *creator.v1* member of the plugin struct and cast to the
``lammpsplugin_factory1`` pointer type. It returns a
be assigned to the *creator.v1* member of the plugin struct and cast to
the ``lammpsplugin_factory1`` function pointer type. It returns a
pointer to the allocated class instance derived from the ``Pair`` class.
This function may be declared static to avoid clashes with other plugins.
The name of the derived class, ``PairMorse2``, must be unique inside
the entire LAMMPS executable.
This function may be declared static to avoid clashes with other
plugins. The name of the derived class, ``PairMorse2``, however must be
unique inside the entire LAMMPS executable.
Fix style example
^^^^^^^^^^^^^^^^^
@ -169,9 +163,9 @@ Below is an example for that:
Command style example
^^^^^^^^^^^^^^^^^^^^^
For command styles there is a third variant of factory function as
Command styles also use the first variant of factory function as
demonstrated in the following example, which also shows that the
implementation of the plugin class may also be within the same
implementation of the plugin class may be within the same source
file as the plugin interface code:
.. code-block:: C++
@ -180,15 +174,15 @@ file as the plugin interface code:
#include "comm.h"
#include "error.h"
#include "pointers.h"
#include "command.h"
#include "version.h"
#include <cstring>
namespace LAMMPS_NS {
class Hello : protected Pointers {
class Hello : public Command {
public:
Hello(class LAMMPS *lmp) : Pointers(lmp) {};
Hello(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
};
}
@ -202,10 +196,9 @@ file as the plugin interface code:
utils::logmesg(lmp,fmt::format("Hello, {}!\n",argv[0]));
}
static void hellocreator(LAMMPS *lmp, int argc, char **argv)
static void hellocreator(LAMMPS *lmp)
{
Hello hello(lmp);
hello.command(argc,argv);
return new Hello(lmp);
}
extern "C" void lammpsplugin_init(void *lmp, void *handle, void *regfunc)
@ -216,9 +209,9 @@ file as the plugin interface code:
plugin.version = LAMMPS_VERSION;
plugin.style = "command";
plugin.name = "hello";
plugin.info = "Hello world command v1.0";
plugin.info = "Hello world command v1.1";
plugin.author = "Axel Kohlmeyer (akohlmey@gmail.com)";
plugin.creator.v3 = (lammpsplugin_factory3 *) &hellocreator;
plugin.creator.v1 = (lammpsplugin_factory1 *) &hellocreator;
plugin.handle = handle;
(*register_plugin)(&plugin,lmp);
}

4
doc/src/Howto_spins.rst
View File

@ -21,8 +21,8 @@ orientations and their associated inter-atomic distances.
The command :doc:`fix precession/spin <fix_precession_spin>` allows to
apply a constant magnetic torque on all the spins in the system. This
torque can be an external magnetic field (Zeeman interaction), or an
uniaxial magnetic anisotropy.
torque can be an external magnetic field (Zeeman interaction), and an
uniaxial or cubic magnetic anisotropy.
A Langevin thermostat can be applied to those magnetic spins using
:doc:`fix langevin/spin <fix_langevin_spin>`. Typically, this thermostat

BIN
doc/src/JPG/lammps-classes.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 254 KiB

After

Width:  |  Height:  |  Size: 286 KiB

17
doc/src/Modify_command.rst
View File

@ -1,14 +1,15 @@
Input script command style
==========================
New commands can be added to LAMMPS input scripts by adding new
classes that have a "command" method. For example, the create_atoms,
read_data, velocity, and run commands are all implemented in this
fashion. When such a command is encountered in the LAMMPS input
script, LAMMPS simply creates a class with the corresponding name,
invokes the "command" method of the class, and passes it the arguments
from the input script. The command method can perform whatever
operations it wishes on LAMMPS data structures.
New commands can be added to LAMMPS input scripts by adding new classes
that are derived from the Command class and thus must have a "command"
method. For example, the create_atoms, read_data, velocity, and run
commands are all implemented in this fashion. When such a command is
encountered in the LAMMPS input script, LAMMPS simply creates a class
instance with the corresponding name, invokes the "command" method of
the class, and passes it the arguments from the input script. The
command method can perform whatever operations it wishes on LAMMPS data
structures.
The single method your new class must define is as follows:

47
doc/src/Packages_details.rst
View File

@ -90,6 +90,7 @@ page gives those details.
* :ref:`USER-MOLFILE <PKG-USER-MOLFILE>`
* :ref:`USER-NETCDF <PKG-USER-NETCDF>`
* :ref:`USER-OMP <PKG-USER-OMP>`
* :ref:`USER-PACE <PKG-USER-PACE>`
* :ref:`USER-PHONON <PKG-USER-PHONON>`
* :ref:`USER-PLUMED <PKG-USER-PLUMED>`
* :ref:`USER-PTM <PKG-USER-PTM>`
@ -585,7 +586,7 @@ MC package
Several fixes and a pair style that have Monte Carlo (MC) or MC-like
attributes. These include fixes for creating, breaking, and swapping
bonds, for performing atomic swaps, and performing grand-canonical MC
(GCMC) in conjunction with dynamics.
(GCMC) or similar processes in conjunction with dynamics.
**Supporting info:**
@ -593,8 +594,12 @@ bonds, for performing atomic swaps, and performing grand-canonical MC
* :doc:`fix atom/swap <fix_atom_swap>`
* :doc:`fix bond/break <fix_bond_break>`
* :doc:`fix bond/create <fix_bond_create>`
* :doc:`fix bond/create/angle <fix_bond_create>`
* :doc:`fix bond/swap <fix_bond_swap>`
* :doc:`fix charge/regulation <fix_charge_regulation>`
* :doc:`fix gcmc <fix_gcmc>`
* :doc:`fix tfmc <fix_tfmc>`
* :doc:`fix widom <fix_widom>`
* :doc:`pair_style dsmc <pair_dsmc>`
* https://lammps.sandia.gov/movies.html#gcmc
@ -1349,6 +1354,46 @@ This package has :ref:`specific installation instructions <user-colvars>` on the
----------
.. _PKG-USER-PACE:
USER-PACE package
-------------------
**Contents:**
A pair style for the Atomic Cluster Expansion potential (ACE).
ACE is a methodology for deriving a highly accurate classical potential
fit to a large archive of quantum mechanical (DFT) data. The USER-PACE
package provides an efficient implementation for running simulations
with ACE potentials.
**Authors:**
This package was written by Yury Lysogorskiy^1,
Cas van der Oord^2, Anton Bochkarev^1,
Sarath Menon^1, Matteo Rinaldi^1, Thomas Hammerschmidt^1, Matous Mrovec^1,
Aidan Thompson^3, Gabor Csanyi^2, Christoph Ortner^4, Ralf Drautz^1.
^1: Ruhr-University Bochum, Bochum, Germany
^2: University of Cambridge, Cambridge, United Kingdom
^3: Sandia National Laboratories, Albuquerque, New Mexico, USA
^4: University of British Columbia, Vancouver, BC, Canada
**Install:**
This package has :ref:`specific installation instructions <user-pace>` on the :doc:`Build extras <Build_extras>` page.
**Supporting info:**
* src/USER-PACE: filenames -> commands
* :doc:`pair_style pace <pair_pace>`
* examples/USER/pace
----------
.. _PKG-USER-PLUMED:
USER-PLUMED package

2
doc/src/Packages_user.rst
View File

@ -81,6 +81,8 @@ package:
+------------------------------------------------+-----------------------------------------------------------------+-------------------------------------------------------------------------------+------------------------------------------------------+---------+
| :ref:`USER-OMP <PKG-USER-OMP>` | OpenMP-enabled styles | :doc:`Speed omp <Speed_omp>` | `Benchmarks <https://lammps.sandia.gov/bench.html>`_ | no |
+------------------------------------------------+-----------------------------------------------------------------+-------------------------------------------------------------------------------+------------------------------------------------------+---------+
| :ref:`USER-PACE <PKG-USER-PACE>` | Fast implementation of Atomic Cluster Expansion (ACE) potential | :doc:`pair pace <pair_pace>` | USER/pace | ext |
+------------------------------------------------+-----------------------------------------------------------------+-------------------------------------------------------------------------------+------------------------------------------------------+---------+
| :ref:`USER-PHONON <PKG-USER-PHONON>` | phonon dynamical matrix | :doc:`fix phonon <fix_phonon>` | USER/phonon | no |
+------------------------------------------------+-----------------------------------------------------------------+-------------------------------------------------------------------------------+------------------------------------------------------+---------+
| :ref:`USER-PLUMED <PKG-USER-PLUMED>` | :ref:`PLUMED <PLUMED>` free energy library | :doc:`fix plumed <fix_plumed>` | USER/plumed | ext |

2
doc/src/atom_style.rst
View File

@ -27,7 +27,7 @@ Syntax
template-ID = ID of molecule template specified in a separate :doc:`molecule <molecule>` command
*hybrid* args = list of one or more sub-styles, each with their args
* accelerated styles (with same args) = *angle/kk* or *atomic/kk* or *bond/kk* or *charge/kk* or *full/kk* or *molecular/kk*
* accelerated styles (with same args) = *angle/kk* or *atomic/kk* or *bond/kk* or *charge/kk* or *full/kk* or *molecular/kk* or *spin/kk*
Examples
""""""""

8
doc/src/dump_modify.rst
View File

@ -308,9 +308,9 @@ performed with dump style *xtc*\ .
----------
The *format* keyword can be used to change the default numeric format
output by the text-based dump styles: *atom*\ , *custom*\ , *cfg*\ , and
*xyz* styles, and their MPIIO variants. Only the *line* or *none*
The *format* keyword can be used to change the default numeric format output
by the text-based dump styles: *atom*\ , *local*\ , *custom*\ , *cfg*\ , and
*xyz* styles, and their MPIIO variants. Only the *line* or *none*
options can be used with the *atom* and *xyz* styles.
All the specified format strings are C-style formats, e.g. as used by
@ -362,7 +362,7 @@ settings, reverting all values to their default format.
compute 1 all property/local batom1 batom2
dump 1 all local 100 tmp.bonds index c_1[1] c_1[2]
dump_modify 1 format "%d %0.0f %0.0f"
dump_modify 1 format line "%d %0.0f %0.0f"
will output the two atom IDs for atoms in each bond as integers. If
the dump_modify command were omitted, they would appear as

1
doc/src/fix.rst
View File

@ -189,6 +189,7 @@ accelerated styles exist.
* :doc:`bond/react <fix_bond_react>` - apply topology changes to model reactions
* :doc:`bond/swap <fix_bond_swap>` - Monte Carlo bond swapping
* :doc:`box/relax <fix_box_relax>` - relax box size during energy minimization
* :doc:`charge/regulation <fix_charge_regulation>` - Monte Carlo sampling of charge regulation
* :doc:`client/md <fix_client_md>` - MD client for client/server simulations
* :doc:`cmap <fix_cmap>` - enables CMAP cross-terms of the CHARMM force field
* :doc:`colvars <fix_colvars>` - interface to the collective variables "Colvars" library

276
doc/src/fix_charge_regulation.rst Normal file
View File

@ -0,0 +1,276 @@
.. index:: fix charge/regulation
fix charge/regulation command
=============================
Syntax
""""""
.. parsed-literal::
fix ID group-ID charge/regulation cation_type anion_type keyword value(s)
* ID, group-ID are documented in fix command
* charge/regulation = style name of this fix command
* cation_type = atom type of free cations
* anion_type = atom type of free anions
* zero or more keyword/value pairs may be appended
.. parsed-literal::
keyword = *pH*, *pKa*, *pKb*, *pIp*, *pIm*, *pKs*, *acid_type*, *base_type*, *lunit_nm*, *temp*, *tempfixid*, *nevery*, *nmc*, *xrd*, *seed*, *tag*, *group*, *onlysalt*, *pmcmoves*
*pH* value = pH of the solution
*pKa* value = acid dissociation constant
*pKb* value = base dissociation constant
*pIp* value = chemical potential of free cations
*pIm* value = chemical potential of free anions
*pKs* value = solution self-dissociation constant
*acid_type* = atom type of acid groups
*base_type* = atom type of base groups
*lunit_nm* value = unit length used by LAMMPS (# in the units of nanometers)
*temp* value = temperature
*tempfixid* value = fix ID of temperature thermostat
*nevery* value = invoke this fix every nevery steps
*nmc* value = number of charge regulation MC moves to attempt every nevery steps
*xrd* value = cutoff distance for acid/base reaction
*seed* value = random # seed (positive integer)
*tag* value = yes or no (yes: The code assign unique tags to inserted ions; no: The tag of all inserted ions is "0")
*group* value = group-ID, inserted ions are assigned to group group-ID. Can be used multiple times to assign inserted ions to multiple groups.
*onlysalt* values = flag charge_cation charge_anion.
flag = yes or no (yes: the fix performs only ion insertion/deletion, no: perform acid/base dissociation and ion insertion/deletion)
charge_cation, charge_anion = value of cation/anion charge, must be an integer (only specify if flag = yes)
*pmcmoves* values = pmcA pmcB pmcI - MC move fractions for acid ionization (pmcA), base ionization (pmcB) and free ion exchange (pmcI)
Examples
""""""""
.. code-block:: LAMMPS
fix chareg all charge/regulation 1 2 acid_type 3 base_type 4 pKa 5 pKb 7 lb 1.0 nevery 200 nexchange 200 seed 123 tempfixid fT
fix chareg all charge/regulation 1 2 pIp 3 pIm 3 onlysalt yes 2 -1 seed 123 tag yes temp 1.0
Description
"""""""""""
This fix performs Monte Carlo (MC) sampling of charge regulation and
exchange of ions with a reservoir as discussed in :ref:`(Curk1) <Curk1>`
and :ref:`(Curk2) <Curk2>`. The implemented method is largely analogous
to the grand-reaction ensemble method in :ref:`(Landsgesell)
<Landsgesell>`. The implementation is parallelized, compatible with
existing LAMMPS functionalities, and applicable to any system utilizing
discrete, ionizable groups or surface sites.
Specifically, the fix implements the following three types of MC moves,
which discretely change the charge state of individual particles and
insert ions into the systems: :math:`\mathrm{A} \rightleftharpoons
\mathrm{A}^-+\mathrm{X}^+`, :math:`\mathrm{B} \rightleftharpoons
\mathrm{B}^++\mathrm{X}^-`, and :math:`\emptyset \rightleftharpoons
Z^-\mathrm{X}^{Z^+}+Z^+\mathrm{X}^{-Z^-}`. In the former two types of
reactions, Monte Carlo moves alter the charge value of specific atoms
(:math:`\mathrm{A}`, :math:`\mathrm{B}`) and simultaneously insert a
counterion to preserve the charge neutrality of the system, modeling the
dissociation/association process. The last type of reaction performs
grand canonical MC exchange of ion pairs with a (fictitious) reservoir.
In our implementation "acid" refers to particles that can attain charge
:math:`q=\{0,-1\}` and "base" to particles with :math:`q=\{0,1\}`,
whereas the MC exchange of free ions allows any integer charge values of
:math:`{Z^+}` and :math:`{Z^-}`.
Here we provide several practical examples for modeling charge
regulation effects in solvated systems. An acid ionization reaction
(:math:`\mathrm{A} \rightleftharpoons \mathrm{A}^-+\mathrm{H}^+`) can be
defined via a single line in the input file
.. code-block:: LAMMPS
fix acid_reaction all charge/regulation 2 3 acid_type 1 pH 7.0 pKa 5.0 pIp 7.0 pIm 7.0
where the fix attempts to charge :math:`\mathrm{A}` (discharge
:math:`\mathrm{A}^-`) to :math:`\mathrm{A}^-` (:math:`\mathrm{A}`) and
insert (delete) a proton (atom type 2). Besides, the fix implements
self-ionization reaction of water :math:`\emptyset \rightleftharpoons
\mathrm{H}^++\mathrm{OH}^-`. However, this approach is highly
inefficient at :math:`\mathrm{pH} \approx 7` when the concentration of
both protons and hydroxyl ions is low, resulting in a relatively low
acceptance rate of MC moves.
A more efficient way is to allow salt ions to participate in ionization
reactions, which can be easily achieved via
.. code-block:: LAMMPS
fix acid_reaction all charge/regulation 4 5 acid_type 1 pH 7.0 pKa 5.0 pIp 2.0 pIm 2.0
where particles of atom type 4 and 5 are the salt cations and anions,
both at chemical potential pI=2.0, see :ref:`(Curk1) <Curk1>` and
:ref:`(Landsgesell) <Landsgesell>` for more details.
Similarly, we could have simultaneously added a base ionization reaction
(:math:`\mathrm{B} \rightleftharpoons \mathrm{B}^++\mathrm{OH}^-`)
.. code-block:: LAMMPS
fix base_reaction all charge/regulation 2 3 base_type 6 pH 7.0 pKb 6.0 pIp 7.0 pIm 7.0
where the fix will attempt to charge :math:`\mathrm{B}` (discharge
:math:`\mathrm{B}^+`) to :math:`\mathrm{B}^+` (:math:`\mathrm{B}`) and
insert (delete) a hydroxyl ion :math:`\mathrm{OH}^-` of atom type 3. If
neither the acid or the base type is specified, for example,
.. code-block:: LAMMPS
fix salt_reaction all charge/regulation 4 5 pIp 2.0 pIm 2.0
the fix simply inserts or deletes an ion pair of a free cation (atom
type 4) and a free anion (atom type 5) as done in a conventional
grand-canonical MC simulation.
The fix is compatible with LAMMPS sub-packages such as *molecule* or
*rigid*. That said, the acid and base particles can be part of larger
molecules or rigid bodies. Free ions that are inserted to or deleted
from the system must be defined as single particles (no bonded
interactions allowed) and cannot be part of larger molecules or rigid
bodies. If *molecule* package is used, all inserted ions have a molecule
ID equal to zero.
Note that LAMMPS implicitly assumes a constant number of particles
(degrees of freedom). Since using this fix alters the total number of
particles during the simulation, any thermostat used by LAMMPS, such as
NVT or Langevin, must use a dynamic calculation of system
temperature. This can be achieved by specifying a dynamic temperature
compute (e.g. dtemp) and using it with the desired thermostat, e.g. a
Langevin thermostat:
.. code-block:: LAMMPS
compute dtemp all temp
compute_modify dtemp dynamic yes
fix fT all langevin 1.0 1.0 1.0 123
fix_modify fT temp dtemp
The chemical potential units (e.g. pH) are in the standard log10
representation assuming reference concentration :math:`\rho_0 =
\mathrm{mol}/\mathrm{l}`. Therefore, to perform the internal unit
conversion, the length (in nanometers) of the LAMMPS unit length must be
specified via *lunit_nm* (default is set to the Bjerrum length in water
at room temperature *lunit_nm* = 0.71nm). For example, in the dilute
ideal solution limit, the concentration of free ions will be
:math:`c_\mathrm{I} = 10^{-\mathrm{pIp}}\mathrm{mol}/\mathrm{l}`.
The temperature used in MC acceptance probability is set by *temp*. This
temperature should be the same as the temperature set by the molecular
dynamics thermostat. For most purposes, it is probably best to use
*tempfixid* keyword which dynamically sets the temperature equal to the
chosen MD thermostat temperature, in the example above we assumed the
thermostat fix-ID is *fT*. The inserted particles attain a random
velocity corresponding to the specified temperature. Using *tempfixid*
overrides any fixed temperature set by *temp*.
The *xrd* keyword can be used to restrict the inserted/deleted
counterions to a specific radial distance from an acid or base particle
that is currently participating in a reaction. This can be used to
simulate more realist reaction dynamics. If *xrd* = 0 or *xrd* > *L* /
2, where *L* is the smallest box dimension, the radial restriction is
automatically turned off and free ion can be inserted or deleted
anywhere in the simulation box.
If the *tag yes* is used, every inserted atom gets a unique tag ID,
otherwise, the tag of every inserted atom is set to 0. *tag yes* might
cause an integer overflow in very long simulations since the tags are
unique to every particle and thus increase with every successful
particle insertion.
The *pmcmoves* keyword sets the relative probability of attempting the
three types of MC moves (reactions): acid charging, base charging, and
ion pair exchange. The fix only attempts to perform particle charging
MC moves if *acid_type* or *base_type* is defined. Otherwise fix only
performs free ion insertion/deletion. For example, if *acid_type* is not
defined, *pmcA* is automatically set to 0. The vector *pmcmoves* is
automatically normalized, for example, if set to *pmcmoves* 0 0.33 0.33,
the vector would be normalized to [0,0.5,0.5].
The *only_salt* option can be used to perform multivalent
grand-canonical ion-exchange moves. If *only_salt yes* is used, no
charge exchange is performed, only ion insertion/deletion (*pmcmoves* is
set to [0,0,1]), but ions can be multivalent. In the example above, an
MC move would consist of three ion insertion/deletion to preserve the
charge neutrality of the system.
The *group* keyword can be used to add inserted particles to a specific
group-ID. All inserted particles are automatically added to group *all*.
Output
""""""
This fix computes a global vector of length 8, which can be accessed by
various output commands. The vector values are the following global
quantities:
* 1 = cumulative MC attempts
* 2 = cumulative MC successes
* 3 = current # of neutral acid atoms
* 4 = current # of -1 charged acid atoms
* 5 = current # of neutral base atoms
* 6 = current # of +1 charged base atoms
* 7 = current # of free cations
* 8 = current # of free anions
Restrictions
""""""""""""
This fix is part of the MC package. It is only enabled if LAMMPS
was built with that package. See the :doc:`Build package
<Build_package>` doc page for more info.
The :doc:`atom_style <atom_style>`, used must contain the charge
property, for example, the style could be *charge* or *full*. Only
usable for 3D simulations. Atoms specified as free ions cannot be part
of rigid bodies or molecules and cannot have bonding interactions. The
scheme is limited to integer charges, any atoms with non-integer charges
will not be considered by the fix.
All interaction potentials used must be continuous, otherwise the MD
integration and the particle exchange MC moves do not correspond to the
same equilibrium ensemble. For example, if an lj/cut pair style is used,
the LJ potential must be shifted so that it vanishes at the cutoff. This
can be easily achieved using the :doc:`pair_modify <pair_modify>`
command, i.e., by using: *pair_modify shift yes*.
.. note::
Region restrictions are not yet implemented.
Related commands
""""""""""""""""
:doc:`fix gcmc <fix_gcmc>`,
:doc:`fix atom/swap <fix_atom_swap>`
Default
"""""""
pH = 7.0; pKa = 100.0; pKb = 100.0; pIp = 5.0; pIm = 5.0; pKs = 14.0;
acid_type = -1; base_type = -1; lunit_nm = 0.71; temp = 1.0; nevery =
100; nmc = 100; xrd = 0; seed = 0; tag = no; onlysalt = no, pmcmoves =
[1/3, 1/3, 1/3], group-ID = all
----------
.. _Curk1:
**(Curk1)** T. Curk, J. Yuan, and E. Luijten, "Coarse-grained simulation of charge regulation using LAMMPS", preprint (2021).
.. _Curk2:
**(Curk2)** T. Curk and E. Luijten, "Charge-regulation effects in nanoparticle self-assembly", PRL (2021)
.. _Landsgesell:
**(Landsgesell)** J. Landsgesell, P. Hebbeker, O. Rud, R. Lunkad, P. Kosovan, and C. Holm, "Grand-reaction method for simulations of ionization equilibria coupled to ion partitioning", Macromolecules 53, 3007-3020 (2020).

125
doc/src/fix_qeq.rst
View File

@ -56,27 +56,28 @@ Examples
Description
"""""""""""
Perform the charge equilibration (QEq) method as described in :ref:`(Rappe and Goddard) <Rappe1>` and formulated in :ref:`(Nakano) <Nakano1>` (also known
as the matrix inversion method) and in :ref:`(Rick and Stuart) <Rick1>` (also
known as the extended Lagrangian method) based on the
electronegativity equilization principle.
Perform the charge equilibration (QEq) method as described in
:ref:`(Rappe and Goddard) <Rappe1>` and formulated in :ref:`(Nakano)
<Nakano1>` (also known as the matrix inversion method) and in
:ref:`(Rick and Stuart) <Rick1>` (also known as the extended Lagrangian
method) based on the electronegativity equilization principle.
These fixes can be used with any :doc:`pair style <pair_style>` in
LAMMPS, so long as per-atom charges are defined. The most typical
use-case is in conjunction with a :doc:`pair style <pair_style>` that
performs charge equilibration periodically (e.g. every timestep), such
as the ReaxFF or Streitz-Mintmire potential.
But these fixes can also be used with
potentials that normally assume per-atom charges are fixed, e.g. a
:doc:`Buckingham <pair_buck>` or :doc:`LJ/Coulombic <pair_lj>` potential.
as the ReaxFF or Streitz-Mintmire potential. But these fixes can also
be used with potentials that normally assume per-atom charges are fixed,
e.g. a :doc:`Buckingham <pair_buck>` or :doc:`LJ/Coulombic <pair_lj>`
potential.
Because the charge equilibration calculation is effectively
independent of the pair style, these fixes can also be used to perform
a one-time assignment of charges to atoms. For example, you could
define the QEq fix, perform a zero-timestep run via the :doc:`run <run>`
command without any pair style defined which would set per-atom
charges (based on the current atom configuration), then remove the fix
via the :doc:`unfix <unfix>` command before performing further dynamics.
Because the charge equilibration calculation is effectively independent
of the pair style, these fixes can also be used to perform a one-time
assignment of charges to atoms. For example, you could define the QEq
fix, perform a zero-timestep run via the :doc:`run <run>` command
without any pair style defined which would set per-atom charges (based
on the current atom configuration), then remove the fix via the
:doc:`unfix <unfix>` command before performing further dynamics.
.. note::
@ -87,11 +88,14 @@ via the :doc:`unfix <unfix>` command before performing further dynamics.
.. note::
The :doc:`fix qeq/comb <fix_qeq_comb>` command must still be used
to perform charge equilibration with the :doc:`COMB potential <pair_comb>`. The :doc:`fix qeq/reax <fix_qeq_reax>`
command can be used to perform charge equilibration with the :doc:`ReaxFF force field <pair_reaxc>`, although fix qeq/shielded yields the
same results as fix qeq/reax if *Nevery*\ , *cutoff*\ , and *tolerance*
are the same. Eventually the fix qeq/reax command will be deprecated.
The :doc:`fix qeq/comb <fix_qeq_comb>` command must still be used to
perform charge equilibration with the :doc:`COMB potential
<pair_comb>`. The :doc:`fix qeq/reax <fix_qeq_reax>` command can be
used to perform charge equilibration with the :doc:`ReaxFF force
field <pair_reaxc>`, although fix qeq/shielded yields the same
results as fix qeq/reax if *Nevery*\ , *cutoff*\ , and *tolerance*
are the same. Eventually the fix qeq/reax command will be
deprecated.
The QEq method minimizes the electrostatic energy of the system (or
equalizes the derivative of energy with respect to charge of all the
@ -134,55 +138,57 @@ usually a good number.
The *qeq/shielded* style describes partial charges on atoms also as
point charges, but uses a shielded Coulomb potential to describe the
interaction between a pair of charged particles. Interaction through
the shielded Coulomb is given by equation (13) of the :ref:`ReaxFF force field <vanDuin>` paper. The shielding accounts for charge overlap
the shielded Coulomb is given by equation (13) of the :ref:`ReaxFF force
field <vanDuin>` paper. The shielding accounts for charge overlap
between charged particles at small separation. This style is the same
as :doc:`fix qeq/reax <fix_qeq_reax>`, and can be used with :doc:`pair_style reax/c <pair_reaxc>`. Only the *chi*\ , *eta*\ , and *gamma*
parameters from the *qfile* file are used. When using the string
*reax/c* as filename, these parameters are extracted directly from
an active *reax/c* pair style. This style solves partial
charges on atoms via the matrix inversion method. A tolerance of
1.0e-6 is usually a good number.
as :doc:`fix qeq/reax <fix_qeq_reax>`, and can be used with
:doc:`pair_style reax/c <pair_reaxc>`. Only the *chi*\ , *eta*\ , and
*gamma* parameters from the *qfile* file are used. When using the string
*reax/c* as filename, these parameters are extracted directly from an
active *reax/c* pair style. This style solves partial charges on atoms
via the matrix inversion method. A tolerance of 1.0e-6 is usually a
good number.
The *qeq/slater* style describes partial charges on atoms as spherical
charge densities centered around atoms via the Slater 1\ *s* orbital, so
that the interaction between a pair of charged particles is the
product of two Slater 1\ *s* orbitals. The expression for the Slater
1\ *s* orbital is given under equation (6) of the
:ref:`Streitz-Mintmire <Streitz1>` paper. Only the *chi*\ , *eta*\ , *zeta*\ , and
*qcore* parameters from the *qfile* file are used. When using the string
that the interaction between a pair of charged particles is the product
of two Slater 1\ *s* orbitals. The expression for the Slater 1\ *s*
orbital is given under equation (6) of the :ref:`Streitz-Mintmire
<Streitz1>` paper. Only the *chi*\ , *eta*\ , *zeta*\ , and *qcore*
parameters from the *qfile* file are used. When using the string
*coul/streitz* as filename, these parameters are extracted directly from
an active *coul/streitz* pair style. This style solves
partial charges on atoms via the matrix inversion method. A tolerance
of 1.0e-6 is usually a good number. Keyword *alpha* can be used to
change the Slater type orbital exponent.
an active *coul/streitz* pair style. This style solves partial charges
on atoms via the matrix inversion method. A tolerance of 1.0e-6 is
usually a good number. Keyword *alpha* can be used to change the Slater
type orbital exponent.
The *qeq/dynamic* style describes partial charges on atoms as point
charges that interact through 1/r, but the extended Lagrangian method
is used to solve partial charges on atoms. Only the *chi* and *eta*
charges that interact through 1/r, but the extended Lagrangian method is
used to solve partial charges on atoms. Only the *chi* and *eta*
parameters from the *qfile* file are used. Note that Coulomb
catastrophe can occur if repulsion between the pair of charged
particles is too weak. A tolerance of 1.0e-3 is usually a good
number. Keyword *qdamp* can be used to change the damping factor, while
keyword *qstep* can be used to change the time step size.
catastrophe can occur if repulsion between the pair of charged particles
is too weak. A tolerance of 1.0e-3 is usually a good number. Keyword
*qdamp* can be used to change the damping factor, while keyword *qstep*
can be used to change the time step size.
The :ref:`\ *qeq/fire*\ <Shan>` style describes the same charge model and charge
solver as the *qeq/dynamic* style, but employs a FIRE minimization
algorithm to solve for equilibrium charges.
Keyword *qdamp* can be used to change the damping factor, while
keyword *qstep* can be used to change the time step size.
The :ref:`\ *qeq/fire*\ <Shan>` style describes the same charge model
and charge solver as the *qeq/dynamic* style, but employs a FIRE
minimization algorithm to solve for equilibrium charges. Keyword
*qdamp* can be used to change the damping factor, while keyword *qstep*
can be used to change the time step size.
Note that *qeq/point*\ , *qeq/shielded*\ , and *qeq/slater* describe
different charge models, whereas the matrix inversion method and the
extended Lagrangian method (\ *qeq/dynamic* and *qeq/fire*\ ) are
different solvers.
Note that *qeq/point*\ , *qeq/dynamic* and *qeq/fire* styles all describe
charges as point charges that interact through 1/r relationship, but
solve partial charges on atoms using different solvers. These three
styles should yield comparable results if
the QEq parameters and *Nevery*\ , *cutoff*\ , and *tolerance* are the
same. Style *qeq/point* is typically faster, *qeq/dynamic* scales
better on larger sizes, and *qeq/fire* is faster than *qeq/dynamic*\ .
Note that *qeq/point*\ , *qeq/dynamic* and *qeq/fire* styles all
describe charges as point charges that interact through 1/r
relationship, but solve partial charges on atoms using different
solvers. These three styles should yield comparable results if the QEq
parameters and *Nevery*\ , *cutoff*\ , and *tolerance* are the same.
Style *qeq/point* is typically faster, *qeq/dynamic* scales better on
larger sizes, and *qeq/fire* is faster than *qeq/dynamic*\ .
.. note::
@ -200,9 +206,11 @@ better on larger sizes, and *qeq/fire* is faster than *qeq/dynamic*\ .
Restart, fix_modify, output, run start/stop, minimize info
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
No information about these fixes is written to :doc:`binary restart files <restart>`. No global scalar or vector or per-atom
quantities are stored by these fixes for access by various :doc:`output commands <Howto_output>`. No parameter of these fixes can be used
with the *start/stop* keywords of the :doc:`run <run>` command.
No information about these fixes is written to :doc:`binary restart
files <restart>`. No global scalar or vector or per-atom quantities are
stored by these fixes for access by various :doc:`output commands
<Howto_output>`. No parameter of these fixes can be used with the
*start/stop* keywords of the :doc:`run <run>` command.
Thexe fixes are invoked during :doc:`energy minimization <minimize>`.
@ -210,7 +218,8 @@ Restrictions
""""""""""""
These fixes are part of the QEQ package. They are only enabled if
LAMMPS was built with that package. See the :doc:`Build package <Build_package>` doc page for more info.
LAMMPS was built with that package. See the :doc:`Build package
<Build_package>` doc page for more info.
Related commands
""""""""""""""""

114
doc/src/pair_pace.rst Normal file
View File

@ -0,0 +1,114 @@
.. index:: pair_style pace
pair_style pace command
========================
Syntax
""""""
.. code-block:: LAMMPS
pair_style pace ... keyword values ...
* an optional keyword may be appended
* keyword = *product* or *recursive*
.. parsed-literal::
*product* = use product algorithm for basis functions
*recursive* = use recursive algorithm for basis functions
Examples
""""""""
.. code-block:: LAMMPS
pair_style pace
pair_style pace product
pair_coeff * * Cu-PBE-core-rep.ace Cu
Description
"""""""""""
Pair style *pace* computes interactions using the Atomic Cluster
Expansion (ACE), which is a general expansion of the atomic energy in
multi-body basis functions. :ref:`(Drautz) <Drautz20191>`.
The *pace* pair style
provides an efficient implementation that
is described in this paper :ref:`(Lysogorskiy) <Lysogorskiy20211>`.
In ACE, the total energy is decomposed into a sum over
atomic energies. The energy of atom *i* is expressed as a
linear or non-linear function of one or more density functions.
By projecting the
density onto a local atomic base, the lowest order contributions
to the energy can be expressed as a set of scalar polynomials in
basis function contributions summed over neighbor atoms.
Only a single pair_coeff command is used with the *pace* style which
specifies an ACE coefficient file followed by N additional arguments
specifying the mapping of ACE elements to LAMMPS atom types,
where N is the number of LAMMPS atom types:
* ACE coefficient file
* N element names = mapping of ACE elements to atom types
Only a single pair_coeff command is used with the *pace* style which
specifies an ACE file that fully defines the potential.
Note that unlike for other potentials, cutoffs are
not set in the pair_style or pair_coeff command; they are specified in
the ACE file.
The pair_style *pace* command may be followed by an optional keyword
*product* or *recursive*, which determines which of two algorithms
is used for the calculation of basis functions and derivatives.
The default is *recursive*.
See the :doc:`pair_coeff <pair_coeff>` doc page for alternate ways
to specify the path for the ACE coefficient file.
Mixing, shift, table, tail correction, restart, rRESPA info
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
For atom type pairs I,J and I != J, where types I and J correspond to
two different element types, mixing is performed by LAMMPS with
user-specifiable parameters as described above. You never need to
specify a pair_coeff command with I != J arguments for this style.
This pair style does not support the :doc:`pair_modify <pair_modify>`
shift, table, and tail options.
This pair style does not write its information to :doc:`binary restart files <restart>`, since it is stored in potential files. Thus, you
need to re-specify the pair_style and pair_coeff commands in an input
script that reads a restart file.
This pair style can only be used via the *pair* keyword of the
:doc:`run_style respa <run_style>` command. It does not support the
*inner*\ , *middle*\ , *outer* keywords.
----------
Restrictions
""""""""""""
This pair style is part of the USER-PACE package. It is only enabled if LAMMPS
was built with that package.
See the :doc:`Build package <Build_package>` doc page for more info.
Related commands
""""""""""""""""
:doc:`pair_style snap <pair_snap>`
Default
"""""""
recursive
.. _Drautz20191:
**(Drautz)** Drautz, Phys Rev B, 99, 014104 (2019).
.. _Lysogorskiy20211:
**(Lysogorskiy)** Lysogorskiy, van der Oord, Bochkarev, Menon, Rinaldi, Hammerschmidt, Mrovec, Thompson, Csanyi, Ortner, Drautz, TBD (2021).

5
doc/src/pair_style.rst
View File

@ -99,7 +99,7 @@ accelerated styles exist.
* :doc:`zero <pair_zero>` - neighbor list but no interactions
* :doc:`adp <pair_adp>` - angular dependent potential (ADP) of Mishin
* :doc:`agni <pair_agni>` - machine learned potential mapping atomic environment to forces
* :doc:`agni <pair_agni>` - AGNI machine-learning potential
* :doc:`airebo <pair_airebo>` - AIREBO potential of Stuart
* :doc:`airebo/morse <pair_airebo>` - AIREBO with Morse instead of LJ
* :doc:`atm <pair_atm>` - Axilrod-Teller-Muto potential
@ -280,6 +280,7 @@ accelerated styles exist.
* :doc:`oxrna2/hbond <pair_oxrna2>` -
* :doc:`oxrna2/stk <pair_oxrna2>` -
* :doc:`oxrna2/xstk <pair_oxrna2>` -
* :doc:`pace <pair_pace>` - Atomic Cluster Expansion (ACE) machine-learning potential
* :doc:`peri/eps <pair_peri>` - peridynamic EPS potential
* :doc:`peri/lps <pair_peri>` - peridynamic LPS potential
* :doc:`peri/pmb <pair_peri>` - peridynamic PMB potential
@ -297,7 +298,7 @@ accelerated styles exist.
* :doc:`smd/ulsph <pair_smd_ulsph>` -
* :doc:`smtbq <pair_smtbq>` -
* :doc:`mliap <pair_mliap>` - Multiple styles of machine-learning potential
* :doc:`snap <pair_snap>` - SNAP quantum-accurate potential
* :doc:`snap <pair_snap>` - SNAP machine-learning potential
* :doc:`soft <pair_soft>` - Soft (cosine) potential
* :doc:`sph/heatconduction <pair_sph_heatconduction>` -
* :doc:`sph/idealgas <pair_sph_idealgas>` -

42
doc/utils/sphinx-config/false_positives.txt
View File

@ -261,6 +261,7 @@ bitmask
bitrate
bitrates
Bitzek
Bjerrum
Blaise
blanchedalmond
blocksize
@ -268,6 +269,7 @@ blueviolet
bn
bni
bo
Bochkarev
Bochum
bocs
bodyflag
@ -343,6 +345,7 @@ Cao
Capolungo
Caro
cartesian
Cas
CasP
Caswell
Cates
@ -502,6 +505,8 @@ coulgauss
coulombic
Coulombic
Coulombics
counterion
counterions
Courant
covalent
covalently
@ -730,6 +735,7 @@ DRUDE
dsf
dsmc
dt
dtemp
dtgrow
dtheta
dtshrink
@ -878,6 +884,7 @@ equilibrates
equilibrating
equilibration
Equilibria
equilibria
equilization
equipartitioning
Ercolessi
@ -1069,6 +1076,7 @@ fuer
fx
fy
fz
Gabor
Gahler
gainsboro
Galindo
@ -1193,6 +1201,7 @@ Halperin
Halver
Hamaker
Hamel
Hammerschmidt
haptic
Hara
Harpertown
@ -1212,6 +1221,7 @@ hbnewflag
hbond
hcp
heatconduction
Hebbeker
Hebenstreit
Hecht
Heenen
@ -1279,6 +1289,7 @@ hy
hydrophobicity
hydrostatic
hydrostatically
hydroxyl
Hynninen
Hyoungki
hyperdynamics
@ -1369,6 +1380,7 @@ ints
inv
invariants
inversed
ionizable
ionocovalent
iostreams
iparam
@ -1548,6 +1560,7 @@ Koning
Kooser
Korn
Koskinen
Kosovan
Koster
Kosztin
Kp
@ -1594,6 +1607,7 @@ Lamoureux
Lanczos
Lande
Landron
Landsgesell
langevin
Langevin
Langston
@ -1731,10 +1745,13 @@ lpsapi
lrt
lsfftw
ltbbmalloc
Lua
lubricateU
lucy
Lua
Luding
Luijten
lunit
Lunkad
Lussetti
Lustig
lval
@ -1743,6 +1760,7 @@ lx
ly
Lybrand
lyon
Lysogorskiy
Lyulin
lz
Maaravi
@ -1801,8 +1819,10 @@ Materias
mathbf
mathjax
matlab
Matous
matplotlib
Matsubara
Matteo
Mattice
Mattox
Mattson
@ -1863,6 +1883,7 @@ MEMALIGN
membered
memcheck
Mendelev
Menon
mer
Meremianin
Mersenne
@ -1986,6 +2007,7 @@ mpiio
mpirun
mplayer
mps
Mrovec
Mryglod
mscg
MSCG
@ -2020,6 +2042,7 @@ multiscale
multisectioning
multithreading
Multithreading
multivalent
Mundy
Murdick
Murtola
@ -2065,6 +2088,7 @@ Nanoletters
nanomechanics
nanometer
nanometers
nanoparticle
nanoparticles
Nanotube
nanotube
@ -2174,6 +2198,7 @@ nm
Nm
Nmax
nmax
nmc
Nmin
nmin
Nmols
@ -2308,9 +2333,11 @@ OMP
oneAPI
onelevel
oneway
onlysalt
onn
ons
OO
Oord
opencl
openKIM
openmp
@ -2331,6 +2358,7 @@ Orsi
ortho
orthonormal
orthorhombic
Ortner
oso
Otype
Ouldridge
@ -2390,6 +2418,8 @@ pbc
pc
pchain
Pchain
pcmoves
pmcmoves
Pdamp
pdb
pdf
@ -2434,6 +2464,7 @@ phosphide
Phs
Physica
physik
pI
Piaggi
picocoulomb
picocoulombs
@ -2445,7 +2476,9 @@ pid
piecewise
Pieniazek
Pieter
pIm
pimd
pIp
Piola
Pisarev
Pishevar
@ -2460,6 +2493,9 @@ ploop
PloS
plt
plumedfile
pKa
pKb
pKs
pmb
Pmolrotate
Pmoltrans
@ -2620,6 +2656,7 @@ radians
Rafferty
rahman
Rahman
Ralf
Raman
ramped
ramping
@ -2727,6 +2764,7 @@ Rij
RIj
Rik
Rin
Rinaldi
Rino
RiRj
Risi
@ -2786,6 +2824,7 @@ rst
rstyle
Rubensson
Rubia
Rud
Rudd
Rudra
Rudranarayan
@ -2815,6 +2854,7 @@ Sandia
sandybrown
sanitizer
Sanyal
Sarath
sc
scafacos
SCAFACOS

8
examples/SPIN/test_problems/validation_damped_exchange/run-test-exchange.sh
View File

@ -3,9 +3,15 @@
# clean old res
rm res_*.dat
# compute Lammps
# test standard Lammps
./../../../../src/lmp_serial \
-in test-spin-precession.in
# test spin/kk with Kokkos Lammps
# mpirun -np 1 ../../../../src/lmp_kokkos_mpi_only \
# -k on -sf kk -in test-spin-precession.in
# extract data from Lammps run
in="$(grep -n Step log.lammps | awk -F ':' '{print $1}')"
en="$(grep -n Loop log.lammps | awk -F ':' '{print $1}')"
in="$(echo "$in+1" | bc -l)"

2
examples/SPIN/test_problems/validation_damped_exchange/test-spin-precession.in
View File

@ -2,8 +2,10 @@
units metal
atom_style spin
# atom_style spin/kk
atom_modify map array
boundary f f f
shell echo "test1"
atom_modify map array
lattice sc 3.0

8
examples/SPIN/test_problems/validation_damped_precession/run-test-prec.sh
View File

@ -3,9 +3,15 @@
# clean old res
rm res_*.dat
# compute Lammps
# test standard Lammps
./../../../../src/lmp_serial \
-in test-spin-precession.in
# test spin/kk with Kokkos Lammps
# mpirun -np 1 ../../../../src/lmp_kokkos_mpi_only \
# -k on -sf kk -in test-spin-precession.in
# extract data from Lammps run
in="$(grep -n Step log.lammps | awk -F ':' '{print $1}')"
en="$(grep -n Loop log.lammps | awk -F ':' '{print $1}')"
in="$(echo "$in+1" | bc -l)"

1
examples/SPIN/test_problems/validation_damped_precession/test-spin-precession.in
View File

@ -2,6 +2,7 @@
units metal
atom_style spin
# atom_style spin/kk
atom_modify map array
boundary f f f

7
examples/SPIN/test_problems/validation_langevin_precession/run-test-prec.sh
View File

@ -12,7 +12,14 @@ do
temp="$(echo "$tempi+$i*($tempf-$tempi)/$N" | bc -l)"
sed s/temperature/${temp}/g test-prec-spin.template > \
test-prec-spin.in
# test standard Lammps
./../../../../src/lmp_serial -in test-prec-spin.in
# test spin/kk with Kokkos Lammps
# mpirun -np 1 ../../../../src/lmp_kokkos_mpi_only \
# -k on -sf kk -in test-prec-spin.in
Hz="$(tail -n 1 average_spin | awk -F " " '{print $3}')"
sz="$(tail -n 1 average_spin | awk -F " " '{print $5}')"
en="$(tail -n 1 average_spin | awk -F " " '{print $6}')"

1
examples/SPIN/test_problems/validation_langevin_precession/test-prec-spin.template
View File

@ -2,6 +2,7 @@
units metal
atom_style spin
# atom_style spin/kk
atom_modify map array
boundary p p p

5
examples/SPIN/test_problems/validation_nve/in.spin.iron-nve
View File

@ -3,6 +3,7 @@
clear
units metal
atom_style spin
# atom_style spin/kk
dimension 3
boundary p p p
@ -46,4 +47,8 @@ variable tmag equal c_out_mag[6]
thermo_style custom step time v_tmag temp v_emag ke pe etotal
thermo 200
compute outsp all property/atom spx spy spz sp fmx fmy fmz
dump 1 all custom 10 dump_iron.lammpstrj type x y z c_outsp[1] c_outsp[2] c_outsp[3]
run 100000
# run 1

11
examples/SPIN/test_problems/validation_nve/run-test-nve.sh
View File

@ -3,9 +3,14 @@
# clean old res
rm res_*.dat
# compute Lammps
./../../../../src/lmp_serial \
-in in.spin.iron-nve
# test standard Lammps
../../../../src/lmp_serial -in in.spin.iron-nve
# test spin/kk with Kokkos Lammps
# mpirun -np 1 ../../../../src/lmp_kokkos_mpi_only \
# -k on -sf kk -in in.spin.iron-nve
# extract data from Lammps run
in="$(grep -n Step log.lammps | awk -F ':' '{print $1}')"
en="$(grep -n Loop log.lammps | awk -F ':' '{print $1}')"
in="$(echo "$in+1" | bc -l)"

1
examples/SPIN/test_problems/validation_nvt/in.spin.nvt_lattice
View File

@ -3,6 +3,7 @@
clear
units metal
atom_style spin
# atom_style spin/kk
dimension 3
boundary p p p

1
examples/SPIN/test_problems/validation_nvt/in.spin.nvt_spin
View File

@ -3,6 +3,7 @@
clear
units metal
atom_style spin
# atom_style spin/kk
dimension 3
boundary p p p

20
examples/SPIN/test_problems/validation_nvt/run-test-nvt.sh
View File

@ -3,16 +3,32 @@
# clean old res
rm res_*.dat
# compute NVT Spin -> Lattice
### compute NVT Spin -> Lattice
# test standard Lammps
./../../../../src/lmp_serial -in in.spin.nvt_spin
# test spin/kk with Kokkos Lammps
# mpirun -np 1 ../../../../src/lmp_kokkos_mpi_only \
# -k on -sf kk -in in.spin.nvt_spin
# extract data from Lammps run
in="$(grep -n Step log.lammps | awk -F ':' '{print $1}')"
en="$(grep -n Loop log.lammps | awk -F ':' '{print $1}')"
in="$(echo "$in+1" | bc -l)"
en="$(echo "$en-$in" | bc -l)"
tail -n +$in log.lammps | head -n $en > res_nvt_spin.dat
# compute NVT Lattice -> Spin
### compute NVT Lattice -> Spin
# test standard Lammps
./../../../../src/lmp_serial -in in.spin.nvt_lattice
# test spin/kk with Kokkos Lammps
# mpirun -np 1 ../../../../src/lmp_kokkos_mpi_only \
# -k on -sf kk -in in.spin.nvt_lattice
# extract data from Lammps run
in="$(grep -n Step log.lammps | awk -F ':' '{print $1}')"
en="$(grep -n Loop log.lammps | awk -F ':' '{print $1}')"
in="$(echo "$in+1" | bc -l)"

36
examples/USER/misc/charge_regulation/README Normal file
View File

@ -0,0 +1,36 @@
This directory has two input scripts that illustrates how to use fix
charge_regulation in LAMMPS to perform coarse-grained molecular dynamics
(MD) simulations with incorporation of charge regulation effects. The
charge regulation is implemented via Monte Carlo (MC) sampling following
the reaction ensemble MC approach, producing a MC/MD hybrid tool for
modeling charge regulation in solvated systems.
The script `in.chreg-acid` sets up a simple weak acid electrolyte
(pH=7,pKa=6,pI=3). Four different types of MC moves are implemented:
acid protonation & de-protonation, and monovalent ion pair insertion and
deletion. Note here we have grouped all free monovalent ions into a
single type, a physically natural choice on the level of coarse-grained
primitive electrolyte models, which increases the calculation
performance but has no effects on thermodynamic observables. The
variables such as pH, pKa, pI, and lb at the top of the input script can
be adjusted to play with various simulation parameters. The cumulative
MC attempted moves and cumulative number of accepted moves, as well as,
current number of neutral and charged acid particles, neutral and
charged base particles (in this example always 0), and the current
number of free cations and anions in the system are printed in the
output.
The script `in.chreg-polymer` sets up a weak poly-electrolyte chain of
N=80 beads. Each bead is a weak acid with pKa=5 and solution has pH=7
and monovalent salt chemical potential pI=3. In this example, we choose
to treat salt ions, protons, and hydroxyl ions separately, which results
in 5 types of MC moves: acid [type 1] protonation & de-protonation (with
protons [type 4] insertion & deletion), acid [type 1] protonation &
de-protonation (with salt cation [type 2] insertion & deletion), water
self-ionization (insertion and deletion of proton [type4] and hydroxyl
ion [type 5] pair), insertion and deletion of monovalent salt pair [type
2 and type 3] , insertion and deletion of a proton [type4] and salt
anion [type 3]. The current number of neutral and charged acid
particles, the current number of free salt cations and anions, and the
current number of protons and hydroxyl ions are printed in the output.

235
examples/USER/misc/charge_regulation/data.chreg-acid Normal file
View File

@ -0,0 +1,235 @@
LAMMPS data file generated by get_input.py
219 atoms
3 atom types
-2.5000000000000000e+01 2.5000000000000000e+01 xlo xhi
-2.5000000000000000e+01 2.5000000000000000e+01 ylo yhi
-2.5000000000000000e+01 2.5000000000000000e+01 zlo zhi
Masses
1 1
2 1
3 1
Atoms
1 1 0 2.5983275747497636 -8.368052973860795 20.001288664343484
2 1 -1 -18.182868728594865 -8.079792367885453 8.253737231981816
3 1 -1 -17.437350808966414 8.120411567445771 10.747650340639332
4 1 -1 6.502476583291578 -23.497326620756837 19.948223080086798
5 1 -1 -22.528179279677296 -18.783433570718127 -17.964657736688018
6 1 -1 -9.713496019164342 18.97235576760402 -19.495620818582825
7 1 -1 -12.831976006720659 0.12265736526942561 -21.679396938423718
8 1 -1 20.909063679212295 -2.16535062758771 0.46197866620165584
9 1 -1 23.86211981166997 24.024928465132284 10.534067202515907
10 1 -1 -0.5289298325031275 23.820222457999776 -2.657199543669442
11 1 -1 9.57021229491361 11.973871502198485 3.4206509716759186
12 1 -1 -10.201559985782705 7.557482594092384 12.07004973873643
13 1 -1 4.898458045226889 2.0169997859717945 -20.765285372762087
14 1 -1 -24.086606883730077 4.424991619615298 -4.204294764756856
15 1 -1 3.6837161829600795 -4.763233144818308 -12.75873457519811
16 1 -1 -12.217842496816345 -17.720229208905618 -13.556354139556914
17 1 -1 -21.456229140133704 -7.423996317612119 -6.94398044071275
18 1 -1 13.697298849253912 8.503639732052164 8.085487457359058
19 1 -1 -5.764222710061347 11.49890485049034 -5.1113880296575935
20 1 -1 3.9944161041544426 16.928204188257893 -14.875635895409372
21 1 -1 4.509525276444776 16.63590711792657 -22.21846494992397
22 1 -1 22.115374932704306 -18.97293932558108 -23.982486000144267
23 1 -1 14.169061011408473 -16.69837647199978 13.779039228068108
24 1 -1 17.186846147657228 8.827459489898189 23.055435051390333
25 1 -1 2.9822901981431045 -16.83687718528342 -21.278623587083484
26 1 -1 16.657554689423897 -1.6217275605348647 -11.315859420404218
27 1 -1 19.215533149393543 -15.512634977936068 7.2701088767584565
28 1 -1 -8.886744157248422 -24.09644410100167 4.013016013803799
29 1 -1 20.99918340066754 4.4716257356730225 0.3847245765737597
30 1 -1 1.3442294253060716 5.601341425720583 -14.918594492786674
31 1 -1 -6.962977050326831 20.470183675946515 -16.37885865567279
32 1 -1 -9.98531733187143 9.52233798117566 -24.979630708193724
33 1 -1 -17.327989778292306 5.761352103841766 5.720220488689204
34 1 -1 5.168359673466362 -23.698812306679418 2.6199762372169744
35 1 -1 18.978042448492154 6.41188742965139 6.31975357155018
36 1 -1 -16.38534911663758 -14.8262205163943 4.125239045887575
37 1 -1 7.974455406459249 -18.88332583451115 11.00721254217055
38 1 -1 13.779816416416402 1.8581999350851426 9.104219696003227
39 1 -1 -23.90949397031401 -3.346877828308571 -10.228782973473443
40 1 -1 21.61647622174447 8.443955423089903 -19.12066464239769
41 1 -1 -8.823979405515548 14.461154001848172 16.061704411241706
42 1 -1 -2.4406878944912513 12.5535360118296 20.606764200087852
43 1 -1 -18.459404356124697 15.260951448001258 21.187332685021346
44 1 -1 2.2354003384439878 -23.350013178190736 11.369307324043625
45 1 -1 15.595889705552018 -6.6075680254604805 5.434256329408505
46 1 -1 -17.528243443870238 4.109747707896265 -1.4167331089310942
47 1 -1 2.161977144405782 -16.511059804921263 -12.186191310598671
48 1 -1 -8.685671837367341 -7.0743613044263185 -1.1561844713769105
49 1 -1 15.62258718398045 -6.559293763708908 20.556775995508488
50 1 -1 -6.965207014475155 -14.348784897390543 -14.421447863144754
51 1 -1 -12.099361509567913 -24.62785640990423 -15.839126670614329
52 1 -1 6.673854222058246 7.83575773885061 -9.714128155619994
53 1 -1 -17.413453800948826 12.386754276446203 -16.882300786608994
54 1 -1 21.8966589175091 12.485943283688762 -14.553421680298634
55 1 -1 -8.37629917390651 -24.783875012947064 7.454467809536389
56 1 -1 14.081149297694104 -21.719204113108943 -17.447225564400064
57 1 -1 4.681992702049627 1.9719544892622558 -7.823736613205725
58 1 -1 4.353171917533494 15.86928389762705 24.669680272563014
59 1 -1 23.31502072066573 -4.685724298328946 2.459643890128799
60 1 -1 7.0470920520598455 23.016693234922386 -13.139471333592677
61 1 -1 11.725555941181668 -15.809323171320772 -1.6292879532275037
62 1 -1 -20.36388898925061 -12.084932320023162 -22.816700826388757
63 1 -1 -2.492146614764735 -0.7314052253623018 -15.89959178250266
64 1 -1 -22.45303825831233 -11.27996814407809 -9.553770912146142
65 1 -1 24.76771926037101 20.128947543233757 10.528974830883733
66 1 -1 11.326213670190818 -11.624187194192492 -9.687726413467862
67 1 -1 -5.712764220166093 15.778887306376163 -0.9263244618113831
68 1 -1 -15.073201136996362 -12.372916148178115 -5.461704510273556
69 1 -1 -5.82976670348781 -4.57812040989473 9.0443548565365
70 1 -1 -5.429195387856279 1.4542054472230177 -7.397291151203568
71 1 -1 -23.385555726942343 -11.924588975396505 3.8215294321466153
72 1 -1 -1.0694104826815725 2.999945633116507 3.67092922106918
73 1 -1 12.134312161994352 1.9747455475585376 -14.895893366599623
74 1 -1 21.30950120583112 18.97294626436546 -17.520867878211376
75 1 -1 -24.356703356157063 3.594879254976714 17.172993705171677
76 1 -1 12.634233603338409 24.373499564220822 4.561976273909789
77 1 -1 -10.740243207970495 19.345205140729554 -3.3368424800818097
78 1 -1 -3.027848793907552 10.604939843027267 7.493012332728249
79 1 -1 5.000539296336658 11.770088203844622 17.227492055930185
80 1 -1 1.1585200269400353 -24.45822157176123 -12.515688997756257
81 1 -1 1.9163088584430596 -14.064330279670672 11.302445490552905
82 1 -1 -20.857041355570576 21.292791787236673 17.397470691573346
83 1 -1 -24.50473305235651 -12.741459355708756 -1.9325218065560357
84 1 -1 2.658628688373309 -1.1131226252194608 7.491603553398086
85 1 -1 -18.515435126408363 24.20642384141299 14.466889392835121
86 1 -1 19.63928177206153 9.942655640416291 8.691463646789934
87 1 -1 -7.69626451160762 11.762517043363786 -7.457263991495665
88 1 -1 1.051431093064835 -11.460307039827766 16.90304637479744
89 1 -1 0.9157815447227939 23.656751182559688 -6.538587603918376
90 1 -1 23.330169435555234 -7.293893221439802 -10.739388379883973
91 1 -1 1.3454906653067376 0.3584300740797559 8.837879234629618
92 1 -1 -21.93056639286312 -10.890279576013356 -10.412914392053596
93 1 -1 21.9136101677979 -10.780221720642636 11.543925933359859
94 1 -1 1.213289938136601 -7.171863230861625 20.734527885288102
95 1 -1 23.102370131877777 21.949933206350458 0.29281565885028016
96 1 -1 -18.917780884063298 -0.03244735062602544 23.633906995676227
97 1 -1 7.583004866601307 10.74178675512821 -4.857297835527785
98 1 -1 -7.4910066746799835 -14.168364618485734 -6.426540836249767
99 1 -1 -20.672200987670426 -8.746789722660697 11.011389790610103
100 1 -1 -18.662115132221917 -21.356740361991612 -8.735991534410413
101 2 1 11.900973676882046 6.591531431964558 19.018193594877637
102 2 1 -23.433591822114983 -18.956429005519567 4.8373984358422994
103 2 1 -11.825475204099472 -3.8206287568445134 3.1167558949026173
104 2 1 -17.49780467176259 -23.115560141825554 9.614132296727426
105 2 1 10.88916113281772 4.512200980010334 18.685489050240854
106 2 1 -22.04662313800728 23.973268925992897 -23.417792740205652
107 2 1 -13.57041123540546 17.3687874050987 21.186270978357783
108 2 1 6.586851196789095 16.27860887432974 -3.638909639278946
109 2 1 8.191448685630277 6.828880619305412 -6.347576950950089
110 2 1 -15.723292856220288 -20.484673256634117 -15.14713811293425
111 2 1 18.58081219522701 19.060706710849452 -10.295676869062909
112 2 1 -21.09194001526127 -7.739334786748358 5.417635948058724
113 2 1 -14.10404878784055 -15.769737592448523 -18.881834262561505
114 2 1 -14.644589058195612 8.84169065013063 8.611654925486256
115 2 1 -11.719050253933538 -4.9700119000832 -0.9846728956163453
116 2 1 19.498247505274143 -10.418045613133986 -22.12098182226518
117 2 1 21.857683401772697 20.157098661061575 -13.652393197742995
118 2 1 -17.623414455798407 21.873813778550875 -6.533965802006303
119 2 1 7.231785003326529 -13.925962842972222 5.360080190636602
120 2 1 -7.509430039873415 19.13541714591672 -16.23545960168472
121 2 1 -4.048249209544995 13.126195473202351 -7.156541250053138
122 2 1 -20.26837137264583 21.46366988603839 15.603080527043964
123 2 1 -4.478253524569759 -3.1812369811955783 -18.52918159641348
124 2 1 21.541019047040052 13.514999235394065 -1.8086547561089752
125 2 1 -15.223319907923727 -5.958117989814905 -7.194967640819577
126 2 1 -20.87181173003304 -7.66780336209651 20.518235718821714
127 2 1 -3.7444846073700297 21.014628245718292 7.197818215477007
128 2 1 -5.904222844268787 7.656315546673127 -1.3911802017487425
129 2 1 -21.49072414090769 -23.123923448235523 10.49453669763092
130 2 1 24.90628307456096 7.081046671281136 -14.422530828641655
131 2 1 -12.173002002514222 -23.250366655717176 -5.145802772598103
132 2 1 -19.68809858318764 4.476541650697328 6.249229323733747
133 2 1 16.85550827580734 -0.8462194407221624 18.011901711631936
134 2 1 17.289399533444858 -11.99379336569853 11.875868193611936
135 2 1 19.532020913911126 -23.053375288330326 -4.9162076250112605
136 2 1 -12.432304028989998 5.029488375070969 7.535325299264009
137 2 1 14.934807008644 8.086694342170496 19.68691014849572
138 2 1 -7.088283921093918 -23.094109864922018 16.57088328184242
139 2 1 14.77413976080318 21.343550134324772 13.996489344579572
140 2 1 -14.606423208703657 -6.928316926567433 -22.717483260149475
141 2 1 -17.139771555632173 14.533410346451518 -21.83064865887975
142 2 1 4.261830086466784 15.518968841247663 -17.791505649414617
143 2 1 -9.814793042774223 -5.120956154726329 14.054454130549104
144 2 1 8.313311590434793 3.9666876022475606 -20.677101093823236
145 2 1 10.603190079756637 -2.62347089527481 1.6661989541795634
146 2 1 -17.763718339721695 1.2541370478041287 -21.55649971308305
147 2 1 -8.538066365356812 14.81814356892842 -4.478673557614034
148 2 1 -5.809558827384787 14.611789154829552 13.287687188309562
149 2 1 8.986830839040898 -17.43898584267833 -18.08640526127862
150 2 1 -13.315275244526854 8.890431200255954 -8.708179477452443
151 2 1 -0.5407152591412618 -23.67970550599055 -24.1586910560046
152 2 1 -19.79961109336906 -16.10906604558887 -5.879899717095562
153 2 1 -23.626316306846658 9.337407355717588 -9.640842288307239
154 2 1 -18.847256196659333 -16.303517291166603 -10.786416046984721
155 2 1 13.567770091716845 -24.4927974402177 8.896906985984664
156 2 1 13.652894892068794 -24.87567116574863 21.89026113439551
157 2 1 -8.575912713332162 9.92386172372207 5.029537530028822
158 2 1 20.69339436974964 1.129252448454178 0.3584458063532807
159 2 1 -0.9971941518705947 18.317397852358788 6.795424830570379
160 2 1 23.155704681402298 15.458725773368961 17.01599672991628
161 2 1 22.278634187244123 14.642946508468171 20.543957651530896
162 2 1 9.771629496835963 -21.696904301438853 -5.259678202922196
163 2 1 5.253009955872763 17.911287158418148 15.769047957152992
164 2 1 -20.759038961257414 5.59089552770853 -12.383953925685166
165 2 1 3.2163819108147145 -4.948608591009169 -17.85036103684716
166 2 1 20.637631925250837 9.109955226257064 6.177181979863878
167 2 1 5.306344093540837 12.647347581939556 23.229957406774105
168 2 1 -24.15187998806597 17.263903348029615 -17.141028077545826
169 2 1 -15.705280442832997 -15.655358704303895 -10.488762557871972
170 2 1 -6.601131108664461 -22.50322976595015 -5.672942609306119
171 2 1 22.869179482568555 13.369592422303498 -9.378437532422556
172 2 1 -23.151055417980903 -3.928919101213168 -11.117061489640207
173 2 1 1.3592343286386246 -18.552063924235036 -15.346172149331993
174 2 1 10.23567488314778 -18.14207926130103 -1.6884247085891886
175 2 1 12.595888032974493 -1.7416169207452157 -21.786811832485718
176 2 1 -0.14792438162408672 17.11748549051584 1.2788726677139053
177 2 1 24.349235298880274 -8.664350854740949 12.4309854455257
178 2 1 -18.827147816604253 -18.80258748867273 -1.6980553939283212
179 2 1 -9.048793002383698 -1.788614428205263 -11.841289777017172
180 2 1 -22.49667217853208 -22.112076711777533 10.01393503943838
181 2 1 -16.183333848138453 1.3098533508906556 0.8096413611556166
182 2 1 -4.007575369376703 -24.447854073342157 -19.683971619997376
183 2 1 8.79123015290173 -15.890906503248287 -23.45721570121758
184 2 1 -8.557898021171628 -21.985380426316674 22.626382729361595
185 2 1 7.143974673263372 16.57516065778192 0.5907315164854055
186 2 1 7.05280226857041 6.658154377550723 17.993436860997946
187 2 1 20.98391844656716 -3.7711929542825544 -22.37222924252256
188 2 1 -8.856382807041598 -16.421301042649826 -7.682473719905396
189 2 1 -14.381919492441797 -7.667674808763277 -10.178028203828621
190 2 1 -22.93472549116592 10.072854607637751 3.756868463885592
191 2 1 9.458987867260412 17.23200182595278 -0.03503381482496337
192 2 1 11.013603635791974 19.842184408029837 -5.83598462187852
193 2 1 23.28897987479008 2.835578651649044 -20.512845011389647
194 2 1 -18.86161127148128 8.956542530565656 14.193388541103026
195 2 1 13.688477473034126 -15.973205475346514 10.952445409682397
196 2 1 2.1058159557459497 2.740725960214597 -23.72037436968614
197 2 1 20.982351847235442 7.072739454450108 -24.07322254392252
198 2 1 5.962360707177609 -19.424513569281604 22.469955103109243
199 2 1 -17.13607356062674 20.038457022813326 12.94227215395123
200 2 1 11.592617137491743 22.283887092702138 2.339699650677858
201 2 1 -1.3864952037065237 19.199632510575505 -7.684210221911414
202 2 1 -22.44476570586083 -19.66385674506424 -8.981660607669522
203 2 1 0.36547911522815824 -7.628556098996082 16.326944822668068
204 2 1 -9.766164330974753 24.38435844399602 -14.352553497163
205 2 1 -0.6310792726759544 -5.625399375968325 13.665993163571486
206 2 1 2.6795300975636103 -0.37097710463575595 15.575183407667495
207 2 1 10.68508361399715 24.638181487800373 -17.538711281692827
208 2 1 18.30809729940504 18.39121662193474 18.285926328751984
209 2 1 -11.52561870836783 -11.871004571782223 12.890674390475048
210 3 -1 16.038097437687007 -0.8308290507120688 9.140710202344948
211 3 -1 -12.071581865552927 23.77532123232212 -6.250109721970887
212 3 -1 24.179073767023887 19.6390206210449 22.20321951706368
213 3 -1 22.899159789805424 8.918385700451317 -1.1269016129923664
214 3 -1 -10.48576153865241 5.691510884812594 21.955276995406933
215 3 -1 6.272776670877239 10.035821052072265 22.22030412319301
216 3 -1 14.689947575936934 -7.785907120217196 0.5033983092114553
217 3 -1 23.173937996535116 -21.041572031861037 -21.057283440516468
218 3 -1 -6.015120142466472 6.3962924962024985 21.58241945230285
219 3 -1 -0.77667042466472 0.3962848125024985 1.582473830285

235
examples/USER/misc/charge_regulation/data.chreg-acid-real Normal file
View File

@ -0,0 +1,235 @@
LAMMPS data file generated by get_input.py
219 atoms
3 atom types
-180 180 xlo xhi
-180 180 ylo yhi
-180 180 zlo zhi
Masses
1 20
2 20
3 20
Atoms
1 1 0 18.70795854 -60.24998141 144.0092784
2 1 -1 -130.9166548 -58.17450505 59.42690807
3 1 -1 -125.5489258 58.46696329 77.38308245
4 1 -1 46.8178314 -169.1807517 143.6272062
5 1 -1 -162.2028908 -135.2407217 -129.3455357
6 1 -1 -69.93717134 136.6009615 -140.3684699
7 1 -1 -92.39022725 0.88313303 -156.091658
8 1 -1 150.5452585 -15.59052452 3.326246397
9 1 -1 171.8072626 172.9794849 75.84528386
10 1 -1 -3.808294794 171.5056017 -19.13183671
11 1 -1 68.90552852 86.21187482 24.628687
12 1 -1 -73.4512319 54.41387468 86.90435812
13 1 -1 35.26889793 14.52239846 -149.5100547
14 1 -1 -173.4235696 31.85993966 -30.27092231
15 1 -1 26.52275652 -34.29527864 -91.86288894
16 1 -1 -87.96846598 -127.5856503 -97.6057498
17 1 -1 -154.4848498 -53.45277349 -49.99665917
18 1 -1 98.62055171 61.22620607 58.21550969
19 1 -1 -41.50240351 82.79211492 -36.80199381
20 1 -1 28.75979595 121.8830702 -107.1045784
21 1 -1 32.46858199 119.7785312 -159.9729476
22 1 -1 159.2306995 -136.6051631 -172.6738992
23 1 -1 102.0172393 -120.2283106 99.20908244
24 1 -1 123.7452923 63.55770833 165.9991324
25 1 -1 21.47248943 -121.2255157 -153.2060898
26 1 -1 119.9343938 -11.67643844 -81.47418783
27 1 -1 138.3518387 -111.6909718 52.34478391
28 1 -1 -63.98455793 -173.4943975 28.8937153
29 1 -1 151.1941205 32.1957053 2.770016951
30 1 -1 9.678451862 40.32965827 -107.4138803
31 1 -1 -50.13343476 147.3853225 -117.9277823
32 1 -1 -71.89428479 68.56083346 -179.8533411
33 1 -1 -124.7615264 41.48173515 41.18558752
34 1 -1 37.21218965 -170.6314486 18.86382891
35 1 -1 136.6419056 46.16558949 45.50222572
36 1 -1 -117.9745136 -106.7487877 29.70172113
37 1 -1 57.41607893 -135.959946 79.2519303
38 1 -1 99.2146782 13.37903953 65.55038181
39 1 -1 -172.1483566 -24.09752036 -73.64723741
40 1 -1 155.6386288 60.79647905 -137.6687854
41 1 -1 -63.53265172 104.1203088 115.6442718
42 1 -1 -17.57295284 90.38545929 148.3687022
43 1 -1 -132.9077114 109.8788504 152.5487953
44 1 -1 16.09488244 -168.1200949 81.85901273
45 1 -1 112.2904059 -47.57448978 39.12664557
46 1 -1 -126.2033528 29.5901835 -10.20047838
47 1 -1 15.56623544 -118.8796306 -87.74057744
48 1 -1 -62.53683723 -50.93540139 -8.324528194
49 1 -1 112.4826277 -47.2269151 148.0087872
50 1 -1 -50.1494905 -103.3112513 -103.8344246
51 1 -1 -87.11540287 -177.3205662 -114.041712
52 1 -1 48.0517504 56.41745572 -69.94172272
53 1 -1 -125.3768674 89.18463079 -121.5525657
54 1 -1 157.6559442 89.89879164 -104.7846361
55 1 -1 -60.30935405 -178.4439001 53.67216823
56 1 -1 101.3842749 -156.3782696 -125.6200241
57 1 -1 33.71034745 14.19807232 -56.33090362
58 1 -1 31.34283781 114.2588441 177.621698
59 1 -1 167.8681492 -33.73721495 17.70943601
60 1 -1 50.73906277 165.7201913 -94.6041936
61 1 -1 84.42400278 -113.8271268 -11.73087326
62 1 -1 -146.6200007 -87.0115127 -164.2802459
63 1 -1 -17.94345563 -5.266117623 -114.4770608
64 1 -1 -161.6618755 -81.21577064 -68.78715057
65 1 -1 178.3275787 144.9284223 75.80861878
66 1 -1 81.54873843 -83.6941478 -69.75163018
67 1 -1 -41.13190239 113.6079886 -6.669536125
68 1 -1 -108.5270482 -89.08499627 -39.32427247
69 1 -1 -41.97432027 -32.96246695 65.11935497
70 1 -1 -39.09020679 10.47027922 -53.26049629
71 1 -1 -168.3760012 -85.85704062 27.51501191
72 1 -1 -7.699755475 21.59960856 26.43069039
73 1 -1 87.36704757 14.21816794 -107.2504322
74 1 -1 153.4284087 136.6052131 -126.1502487
75 1 -1 -175.3682642 25.88313064 123.6455547
76 1 -1 90.96648194 175.4891969 32.84622917
77 1 -1 -77.3297511 139.285477 -24.02526586
78 1 -1 -21.80051132 76.35556687 53.9496888
79 1 -1 36.00388293 84.74463507 124.0379428
80 1 -1 8.341344194 -176.0991953 -90.11296078
81 1 -1 13.79742378 -101.263178 81.37760753
82 1 -1 -150.1706978 153.3081009 125.261789
83 1 -1 -176.434078 -91.73850736 -13.91415701
84 1 -1 19.14212656 -8.014482902 53.93954558
85 1 -1 -133.3111329 174.2862517 104.1616036
86 1 -1 141.4028288 71.58712061 62.57853826
87 1 -1 -55.41310448 84.69012271 -53.69230074
88 1 -1 7.57030387 -82.51421069 121.7019339
89 1 -1 6.593627122 170.3286085 -47.07783075
90 1 -1 167.9772199 -52.51603119 -77.32359634
91 1 -1 9.68753279 2.580696533 63.63273049
92 1 -1 -157.900078 -78.41001295 -74.97298362
93 1 -1 157.7779932 -77.61759639 83.11626672
94 1 -1 8.735687555 -51.63741526 149.2886008
95 1 -1 166.3370649 158.0395191 2.108272744
96 1 -1 -136.2080224 -0.233620925 170.1641304
97 1 -1 54.59763504 77.34086464 -34.97254442
98 1 -1 -53.93524806 -102.0122253 -46.27109402
99 1 -1 -148.8398471 -62.976886 79.28200649
100 1 -1 -134.367229 -153.7685306 -62.89913905
101 2 1 85.68701047 47.45902631 136.9309939
102 2 1 -168.7218611 -136.4862888 34.82926874
103 2 1 -85.14342147 -27.50852705 22.44064244
104 2 1 -125.9841936 -166.432033 69.22175254
105 2 1 78.40196016 32.48784706 134.5355212
106 2 1 -158.7356866 172.6075363 -168.6081077
107 2 1 -97.70696089 125.0552693 152.541151
108 2 1 47.42532862 117.2059839 -26.2001494
109 2 1 58.97843054 49.16794046 -45.70255405
110 2 1 -113.2077086 -147.4896474 -109.0593944
111 2 1 133.7818478 137.2370883 -74.12887346
112 2 1 -151.8619681 -55.72321046 39.00697883
113 2 1 -101.5491513 -113.5421107 -135.9492067
114 2 1 -105.4410412 63.66017268 62.00391546
115 2 1 -84.37716183 -35.78408568 -7.089644848
116 2 1 140.387382 -75.00992841 -159.2710691
117 2 1 157.3753205 145.1311104 -98.29723102
118 2 1 -126.8885841 157.4914592 -47.04455377
119 2 1 52.06885202 -100.2669325 38.59257737
120 2 1 -54.06789629 137.7750035 -116.8953091
121 2 1 -29.14739431 94.50860741 -51.527097
122 2 1 -145.9322739 154.5384232 112.3421798
123 2 1 -32.24342538 -22.90490626 -133.4101075
124 2 1 155.0953371 97.30799449 -13.02231424
125 2 1 -109.6079033 -42.89844953 -51.80376701
126 2 1 -150.2770445 -55.20818421 147.7312972
127 2 1 -26.96028917 151.3053234 51.82429115
128 2 1 -42.51040448 55.12547194 -10.01649745
129 2 1 -154.7332138 -166.4922488 75.56066422
130 2 1 179.3252381 50.98353603 -103.842222
131 2 1 -87.64561442 -167.4026399 -37.04977996
132 2 1 -141.7543098 32.23109989 44.99445113
133 2 1 121.3596596 -6.092779973 129.6856923
134 2 1 124.4836766 -86.35531223 85.50625099
135 2 1 140.6305506 -165.9843021 -35.3966949
136 2 1 -89.51258901 36.2123163 54.25434215
137 2 1 107.5306105 58.22419926 141.7457531
138 2 1 -51.03564423 -166.277591 119.3103596
139 2 1 106.3738063 153.673561 100.7747233
140 2 1 -105.1662471 -49.88388187 -163.5658795
141 2 1 -123.4063552 104.6405545 -157.1806703
142 2 1 30.68517662 111.7365757 -128.0988407
143 2 1 -70.66650991 -36.87088431 101.1920697
144 2 1 59.85584345 28.56015074 -148.8751279
145 2 1 76.34296857 -18.88899045 11.99663247
146 2 1 -127.898772 9.029786744 -155.2067979
147 2 1 -61.47407783 106.6906337 -32.24644961
148 2 1 -41.82882356 105.2048819 95.67134776
149 2 1 64.70518204 -125.5606981 -130.2221179
150 2 1 -95.86998176 64.01110464 -62.69889224
151 2 1 -3.893149866 -170.4938796 -173.9425756
152 2 1 -142.5571999 -115.9852755 -42.33527796
153 2 1 -170.1094774 67.22933296 -69.41406448
154 2 1 -135.7002446 -117.3853245 -77.66219554
155 2 1 97.68794466 -176.3481416 64.0577303
156 2 1 98.30084322 -179.1048324 157.6098802
157 2 1 -61.74657154 71.45180441 36.21267022
158 2 1 148.9924395 8.130617629 2.580809806
159 2 1 -7.179797893 131.8852645 48.92705878
160 2 1 166.7210737 111.3028256 122.5151765
161 2 1 160.4061661 105.4292149 147.9164951
162 2 1 70.35573238 -156.217711 -37.86968306
163 2 1 37.82167168 128.9612675 113.5371453
164 2 1 -149.4650805 40.2544478 -89.16446826
165 2 1 23.15794976 -35.62998186 -128.5225995
166 2 1 148.5909499 65.59167763 44.47571026
167 2 1 38.20567747 91.06090259 167.2556933
168 2 1 -173.8935359 124.3001041 -123.4154022
169 2 1 -113.0780192 -112.7185827 -75.51909042
170 2 1 -47.52814398 -162.0232543 -40.84518679
171 2 1 164.6580923 96.26106544 -67.52475023
172 2 1 -166.687599 -28.28821753 -80.04284273
173 2 1 9.786487166 -133.5748603 -110.4924395
174 2 1 73.69685916 -130.6229707 -12.1566579
175 2 1 90.69039384 -12.53964183 -156.8650452
176 2 1 -1.065055548 123.2458955 9.207883208
177 2 1 175.3144942 -62.38332615 89.50309521
178 2 1 -135.5554643 -135.3786299 -12.22599884
179 2 1 -65.15130962 -12.87802388 -85.25728639
180 2 1 -161.9760397 -159.2069523 72.10033228
181 2 1 -116.5200037 9.430944126 5.8294178
182 2 1 -28.85454266 -176.0245493 -141.7245957
183 2 1 63.2968571 -114.4145268 -168.891953
184 2 1 -61.61686575 -158.2947391 162.9099557
185 2 1 51.43661765 119.3411567 4.253266919
186 2 1 50.78017633 47.93871152 129.5527454
187 2 1 151.0842128 -27.15258927 -161.0800505
188 2 1 -63.76595621 -118.2333675 -55.31381078
189 2 1 -103.5498203 -55.20725862 -73.28180307
190 2 1 -165.1300235 72.52455317 27.04945294
191 2 1 68.10471264 124.0704131 -0.252243467
192 2 1 79.29794618 142.8637277 -42.01908928
193 2 1 167.6806551 20.41616629 -147.6924841
194 2 1 -135.8036012 64.48710622 102.1923975
195 2 1 98.55703781 -115.0070794 78.85760695
196 2 1 15.16187488 19.73322691 -170.7866955
197 2 1 151.0729333 50.92372407 -173.3272023
198 2 1 42.92899709 -139.8564977 161.7836767
199 2 1 -123.3797296 144.2768906 93.18435951
200 2 1 83.46684339 160.4439871 16.84583748
201 2 1 -9.982765467 138.2373541 -55.3263136
202 2 1 -161.6023131 -141.5797686 -64.66795638
203 2 1 2.63144963 -54.92560391 117.5540027
204 2 1 -70.31638318 175.5673808 -103.3383852
205 2 1 -4.543770763 -40.50287551 98.39515078
206 2 1 19.2926167 -2.671035153 112.1413205
207 2 1 76.93260202 177.3949067 -126.2787212
208 2 1 131.8183006 132.4167597 131.6586696
209 2 1 -82.9844547 -85.47123292 92.81285561
210 3 -1 115.4743016 -5.981969165 65.81311346
211 3 -1 -86.91538943 171.1823129 -45.00079
212 3 -1 174.0893311 141.4009485 159.8631805
213 3 -1 164.8739505 64.21237704 -8.113691614
214 3 -1 -75.49748308 40.97887837 158.0779944
215 3 -1 45.16399203 72.25791157 159.9861897
216 3 -1 105.7676225 -56.05853127 3.624467826
217 3 -1 166.8523536 -151.4993186 -151.6124408
218 3 -1 -43.30886503 46.05330597 155.3934201
219 3 -1 -5.592027058 2.85325065 11.39381158

264
examples/USER/misc/charge_regulation/data.chreg-polymer Normal file
View File

@ -0,0 +1,264 @@
##A Weak PE Chain of N=80
160 atoms
79 bonds
5 atom types
1 bond types
-50 50 xlo xhi
-50 50 ylo yhi
-50 50 zlo zhi
Masses
1 1.0
2 1.0
3 1.0
4 1.0
5 1.0
Atoms
# atom_id molecule_id atom_type charge x y z
1 1 1 -1 0 0 -48.37753795169063
2 1 1 -1 0 0 -47.255075903381254
3 1 1 -1 0 0 -46.13261385507188
4 1 1 -1 0 0 -45.01015180676251
5 1 1 -1 0 0 -43.887689758453135
6 1 1 -1 0 0 -42.76522771014376
7 1 1 -1 0 0 -41.64276566183439
8 1 1 -1 0 0 -40.520303613525016
9 1 1 -1 0 0 -39.39784156521564
10 1 1 -1 0 0 -38.27537951690627
11 1 1 -1 0 0 -37.1529174685969
12 1 1 -1 0 0 -36.030455420287524
13 1 1 -1 0 0 -34.90799337197815
14 1 1 -1 0 0 -33.78553132366878
15 1 1 -1 0 0 -32.663069275359405
16 1 1 -1 0 0 -31.54060722705003
17 1 1 -1 0 0 -30.41814517874066
18 1 1 -1 0 0 -29.295683130431286
19 1 1 -1 0 0 -28.173221082121913
20 1 1 -1 0 0 -27.05075903381254
21 1 1 -1 0 0 -25.928296985503167
22 1 1 -1 0 0 -24.805834937193794
23 1 1 -1 0 0 -23.68337288888442
24 1 1 -1 0 0 -22.560910840575048
25 1 1 -1 0 0 -21.438448792265675
26 1 1 -1 0 0 -20.3159867439563
27 1 1 -1 0 0 -19.19352469564693
28 1 1 -1 0 0 -18.071062647337556
29 1 1 -1 0 0 -16.948600599028183
30 1 1 -1 0 0 -15.82613855071881
31 1 1 -1 0 0 -14.703676502409436
32 1 1 -1 0 0 -13.581214454100063
33 1 1 -1 0 0 -12.45875240579069
34 1 1 -1 0 0 -11.336290357481317
35 1 1 -1 0 0 -10.213828309171944
36 1 1 -1 0 0 -9.091366260862571
37 1 1 -1 0 0 -7.968904212553198
38 1 1 -1 0 0 -6.846442164243825
39 1 1 -1 0 0 -5.723980115934452
40 1 1 -1 0 0 -4.601518067625079
41 1 1 -1 0 0 -3.4790560193157063
42 1 1 -1 0 0 -2.3565939710063333
43 1 1 -1 0 0 -1.2341319226969603
44 1 1 -1 0 0 -0.11166987438758724
45 1 1 -1 0 0 1.0107921739217858
46 1 1 -1 0 0 2.133254222231159
47 1 1 -1 0 0 3.255716270540532
48 1 1 -1 0 0 4.378178318849905
49 1 1 -1 0 0 5.500640367159278
50 1 1 -1 0 0 6.623102415468651
51 1 1 -1 0 0 7.745564463778024
52 1 1 -1 0 0 8.868026512087397
53 1 1 -1 0 0 9.99048856039677
54 1 1 -1 0 0 11.112950608706143
55 1 1 -1 0 0 12.235412657015516
56 1 1 -1 0 0 13.357874705324889
57 1 1 -1 0 0 14.480336753634262
58 1 1 -1 0 0 15.602798801943635
59 1 1 -1 0 0 16.725260850253008
60 1 1 -1 0 0 17.84772289856238
61 1 1 -1 0 0 18.970184946871754
62 1 1 -1 0 0 20.092646995181127
63 1 1 -1 0 0 21.2151090434905
64 1 1 -1 0 0 22.337571091799873
65 1 1 -1 0 0 23.460033140109246
66 1 1 -1 0 0 24.58249518841862
67 1 1 -1 0 0 25.704957236727992
68 1 1 -1 0 0 26.827419285037365
69 1 1 -1 0 0 27.949881333346738
70 1 1 -1 0 0 29.07234338165611
71 1 1 -1 0 0 30.194805429965484
72 1 1 -1 0 0 31.317267478274857
73 1 1 -1 0 0 32.43972952658423
74 1 1 -1 0 0 33.5621915748936
75 1 1 -1 0 0 34.684653623202976
76 1 1 -1 0 0 35.80711567151235
77 1 1 -1 0 0 36.92957771982172
78 1 1 -1 0 0 38.052039768131095
79 1 1 -1 0 0 39.17450181644047
80 1 1 -1 0 0 40.29696386474984
81 0 2 1 -27.886422274724097 27.72001798427955 38.68169635811057
82 0 2 1 29.812255760623188 17.871838747003693 -29.094648426460257
83 0 2 1 -13.23881351410531 13.28123966828678 -24.422176415560116
84 0 2 1 4.9465650593939685 -37.7521903558826 -15.115417767729575
85 0 2 1 34.82527943387106 29.457664434004897 -25.565595338061254
86 0 2 1 46.35660570786446 -7.161776614070412 -20.2471250527001
87 0 2 1 39.20854546781531 34.96815569014278 13.893531822586723
88 0 2 1 -7.797240698180197 0.07861219105048889 48.686453603015224
89 0 2 1 43.92391845355516 -39.42362941705827 22.448930565867585
90 0 2 1 -40.371744364329984 -17.743039071967246 -15.08153047835009
91 0 2 1 -21.573165497710058 -0.5844447399891948 -45.73596994149077
92 0 2 1 -19.882394451769102 -7.392447895357577 30.733607063808876
93 0 2 1 -17.393031309514107 26.882975097407467 -47.64059480000892
94 0 2 1 25.652222561671735 1.0229206994719107 -14.959030208952043
95 0 2 1 26.075045766879313 19.902341017250052 46.70284805469666
96 0 2 1 39.91980369168496 0.753749460187592 -26.203575929573407
97 0 2 1 13.777613371273958 7.112171629839359 -33.5270487721399
98 0 2 1 18.944534687271826 20.090215089875286 -34.381335468790574
99 0 2 1 -23.801856387842435 -42.275962146864586 -8.322936238250279
100 0 2 1 -31.386991395893826 29.83894468611787 8.937114269513422
101 0 2 1 -41.07090001085809 49.59339931450579 6.666864232174753
102 0 2 1 -46.58911504232167 -32.46068937927039 19.40424197066872
103 0 2 1 -39.94659416571965 -36.28203465180086 5.841020764632312
104 0 2 1 -26.027467090120137 -41.05522015175137 -1.1145958296128313
105 0 2 1 37.09602855959457 23.76087951027276 45.09142423198867
106 0 2 1 -27.78138413517528 -48.97344929918942 45.91491289356401
107 0 2 1 4.468912883622387 -5.217782298407556 6.381420595433383
108 0 2 1 36.758686966564525 48.425582881586166 -25.909273336802997
109 0 2 1 -27.045102667146036 -19.713951008254117 4.339232870380627
110 0 2 1 -5.984280016624311 -49.45311479123866 36.35727783065221
111 0 2 1 27.833389147163018 -47.80144978082761 -47.71458334276804
112 0 2 1 -23.628507668044364 -30.353876765128685 36.174277933133254
113 0 2 1 -40.93360714431151 40.1336490864843 -27.035347797435495
114 0 2 1 6.3523980881104976 -28.636485436097082 -10.671354350535445
115 0 2 1 42.765716958607086 -32.85779663523676 -1.9682360265562124
116 0 2 1 -33.68069757415453 16.800769050458484 -6.273374390373085
117 0 2 1 13.909148568042937 4.921040289518388 12.111069913598996
118 0 2 1 6.728324076730296 -48.44092815223126 -35.92436883370601
119 0 2 1 -18.121173967321912 -15.76903395165283 2.2495451015454933
120 0 2 1 -11.75253233489407 -45.82569982175387 -12.477142440015896
121 0 2 1 1.9713864197144133 17.961034900064007 32.97992150691711
122 0 2 1 -3.993384770632943 -47.63120435620297 27.75490859098018
123 0 2 1 -0.32208279553454844 -47.30616152402566 -22.751109302380367
124 0 2 1 -0.135777029397957 23.88599790464609 -31.87440560354473
125 0 2 1 -6.123924906817393 -2.038519565120424 45.4809181974626
126 0 2 1 -29.622588299895046 42.40404115712096 6.640479709229595
127 0 2 1 -11.694512971272673 19.983258641775762 -38.152427411711145
128 0 2 1 -20.93721440637313 39.46397829322392 -45.52708262202337
129 0 2 1 34.13340147809369 36.14268504987945 -23.978137043267044
130 0 2 1 -37.422309952611485 29.181841318883087 27.55677757161692
131 0 2 1 30.11314373799594 18.721794400471353 1.5553303682670574
132 0 2 1 -7.3563467211571805 46.84253369205935 -39.84708490437832
133 0 2 1 -3.695927445484358 2.494403998274727 -7.634369981832755
134 0 2 1 44.09701173592077 17.717328437831043 31.54108326477207
135 0 2 1 48.070189931616795 10.601166369398662 -28.28574863896286
136 0 2 1 -7.044858382811761 -42.080663380241766 -1.4369925734636553
137 0 2 1 -12.485032488076918 23.87106169116919 6.178803347562642
138 0 2 1 -15.613232443702309 10.103630885941392 -20.447182948810916
139 0 2 1 28.610332347774147 37.08335835592116 -19.90280831362493
140 0 2 1 25.853920233242505 -27.768648181803655 24.971357611943475
141 0 2 1 9.256159541363296 -23.562096053197934 -4.722701100419371
142 0 2 1 39.96929397877305 -11.88228547846326 -28.70638149104603
143 0 2 1 -37.98545134633291 -23.50528193202669 -10.939982626098441
144 0 2 1 25.40017763114089 -47.49220127581256 15.1783064865064
145 0 2 1 28.073596076651768 3.6631266774864386 31.54355751177208
146 0 2 1 -19.596457173068703 46.79824882013442 -12.302655772327597
147 0 2 1 -36.46192411958321 -2.785830672302666 -25.1901381125736
148 0 2 1 -27.377389198969894 11.295792272951147 39.32842550184691
149 0 2 1 32.24967019136358 -20.517755791016402 31.20590722085157
150 0 2 1 47.70698618147787 9.75462874031868 -28.267447889542563
151 0 2 1 17.157803106328345 -27.48141290657965 7.7670687016760525
152 0 2 1 15.089833959419678 5.342811012118396 27.35336620165029
153 0 2 1 9.836963929211372 -11.047378229392443 -20.960811370690678
154 0 2 1 44.66600586278604 14.949733274456321 -29.328965994323575
155 0 2 1 -21.006260382140685 8.492712712433658 -46.31580169190271
156 0 2 1 -29.970979487850748 -36.46250489415931 26.914372830947457
157 0 2 1 -1.0821372755756329 -8.453379951300242 -19.95665062432509
158 0 2 1 -24.033653425909772 -39.51330620205049 20.067656167683793
159 0 2 1 27.747287624384626 -21.904990435351312 -10.819345241055956
160 0 2 1 -40.86737066410612 -25.609300376714796 -21.128139356809783
Bonds
# bond_id bond_type atom1_id atom2_id
1 1 1 2
2 1 2 3
3 1 3 4
4 1 4 5
5 1 5 6
6 1 6 7
7 1 7 8
8 1 8 9
9 1 9 10
10 1 10 11
11 1 11 12
12 1 12 13
13 1 13 14
14 1 14 15
15 1 15 16
16 1 16 17
17 1 17 18
18 1 18 19
19 1 19 20
20 1 20 21
21 1 21 22
22 1 22 23
23 1 23 24
24 1 24 25
25 1 25 26
26 1 26 27
27 1 27 28
28 1 28 29
29 1 29 30
30 1 30 31
31 1 31 32
32 1 32 33
33 1 33 34
34 1 34 35
35 1 35 36
36 1 36 37
37 1 37 38
38 1 38 39
39 1 39 40
40 1 40 41
41 1 41 42
42 1 42 43
43 1 43 44
44 1 44 45
45 1 45 46
46 1 46 47
47 1 47 48
48 1 48 49
49 1 49 50
50 1 50 51
51 1 51 52
52 1 52 53
53 1 53 54
54 1 54 55
55 1 55 56
56 1 56 57
57 1 57 58
58 1 58 59
59 1 59 60
60 1 60 61
61 1 61 62
62 1 62 63
63 1 63 64
64 1 64 65
65 1 65 66
66 1 66 67
67 1 67 68
68 1 68 69
69 1 69 70
70 1 70 71
71 1 71 72
72 1 72 73
73 1 73 74
74 1 74 75
75 1 75 76
76 1 76 77
77 1 77 78
78 1 78 79
79 1 79 80

36
examples/USER/misc/charge_regulation/in.chreg-acid Normal file
View File

@ -0,0 +1,36 @@
# Charge regulation lammps for simple weak electrolyte
units lj
atom_style charge
neighbor 3.0 bin
read_data data.chreg-acid
variable cut_long equal 12.5
variable nevery equal 100
variable nmc equal 100
variable pH equal 7.0
variable pKa equal 6.0
variable pIm equal 3.0
variable pIp equal 3.0
variable cut_lj equal 2^(1.0/6.0)
variable lunit_nm equal 0.72 # in the units of nm
velocity all create 1.0 8008 loop geom
pair_style lj/cut/coul/long ${cut_lj} ${cut_long}
pair_coeff * * 1.0 1.0
kspace_style ewald 1.0e-3
pair_modify shift yes
######### VERLET INTEGRATION WITH LANGEVIN THERMOSTAT ###########
fix fnve all nve
compute dtemp all temp
compute_modify dtemp dynamic yes
fix fT all langevin 1.0 1.0 1.0 123
fix_modify fT temp dtemp
fix chareg all charge/regulation 2 3 acid_type 1 pH ${pH} pKa ${pKa} pIp ${pIp} pIm ${pIm} lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
thermo 100
thermo_style custom step pe c_dtemp f_chareg[1] f_chareg[2] f_chareg[3] f_chareg[4] f_chareg[5] f_chareg[6] f_chareg[7] f_chareg[8]
timestep 0.005
run 2000

44
examples/USER/misc/charge_regulation/in.chreg-acid-real Normal file
View File

@ -0,0 +1,44 @@
# Charge regulation lammps for simple weak electrolyte
units real
atom_style charge
neighbor 10.0 bin
read_data data.chreg-acid-real
#real units
variable sigma equal 7.2 # particle diameter 0.72 nm
variable temperature equal 298 # temperature 298 K
variable kb index 0.0019872067 # kB in Kcal/mol/K
variable epsilon equal ${kb}*${temperature}
variable tunit equal 2000 # time unit is 2000 fs
variable timestep equal 0.005*${tunit}
variable cut_long equal 12.5*${sigma}
variable nevery equal 100
variable nmc equal 100
variable pH equal 7.0
variable pKa equal 6.0
variable pIm equal 3.0
variable pIp equal 3.0
variable cut_lj equal 2^(1.0/6.0)*${sigma}
velocity all create ${temperature} 8008 loop geom
pair_style lj/cut/coul/long ${cut_lj} ${cut_long}
pair_coeff * * ${epsilon} ${sigma}
kspace_style pppm 1.0e-3
dielectric 78
pair_modify shift yes
######### VERLET INTEGRATION WITH LANGEVIN THERMOSTAT ###########
fix fnve all nve
compute dtemp all temp
compute_modify dtemp dynamic yes
fix fT all langevin $(v_temperature) $(v_temperature) $(v_tunit) 123
fix_modify fT temp dtemp
fix chareg all charge/regulation 2 3 acid_type 1 pH ${pH} pKa ${pKa} pIp ${pIp} pIm ${pIm} lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
thermo 100
thermo_style custom step pe c_dtemp f_chareg[1] f_chareg[2] f_chareg[3] f_chareg[4] f_chareg[5] f_chareg[6] f_chareg[7] f_chareg[8]
timestep ${timestep}
run 2000

33
examples/USER/misc/charge_regulation/in.chreg-polymer Normal file
View File

@ -0,0 +1,33 @@
# Charge regulation lammps for a polymer chain
units lj
atom_style full
neighbor 3.0 bin
read_data data.chreg-polymer
bond_style harmonic
bond_coeff 1 100 1.122462 # K R0
velocity all create 1.0 8008 loop geom
pair_style lj/cut/coul/long 1.122462 20
pair_coeff * * 1.0 1.0 1.122462 # charges
kspace_style pppm 1.0e-3
pair_modify shift yes
dielectric 1.0
######### VERLET INTEGRATION WITH LANGEVIN THERMOSTAT ###########
fix fnve all nve
compute dtemp all temp
compute_modify dtemp dynamic yes
fix fT all langevin 1.0 1.0 1.0 123
fix_modify fT temp dtemp
fix chareg1 all charge/regulation 2 3 acid_type 1 pH 7.0 pKa 6.5 pIp 3.0 pIm 3.0 temp 1.0 nmc 40 seed 2345
fix chareg2 all charge/regulation 4 5 acid_type 1 pH 7.0 pKa 6.5 pIp 7.0 pIm 7.0 temp 1.0 nmc 40 seed 2345
fix chareg3 all charge/regulation 4 3 pIp 7.0 pIm 3.0 temp 1.0 nmc 20 seed 2345
thermo 100
# print: step, potential energy, temperature, neutral acids, charged acids, salt cations, salt anions, H+ ions, OH- ions
thermo_style custom step pe c_dtemp f_chareg1[3] f_chareg1[4] f_chareg1[7] f_chareg1[8] f_chareg2[7] f_chareg2[8]
timestep 0.005
run 2000

125
examples/USER/misc/charge_regulation/log.10Feb21.chreg-acid.g++.1 Normal file
View File

@ -0,0 +1,125 @@
LAMMPS (10 Feb 2021)
using 1 OpenMP thread(s) per MPI task
# Charge regulation lammps for simple weak electrolyte
units lj
atom_style charge
neighbor 3.0 bin
read_data data.chreg-acid
Reading data file ...
orthogonal box = (-25.000000 -25.000000 -25.000000) to (25.000000 25.000000 25.000000)
1 by 1 by 1 MPI processor grid
reading atoms ...
219 atoms
read_data CPU = 0.003 seconds
variable cut_long equal 12.5
variable nevery equal 100
variable nmc equal 100
variable pH equal 7.0
variable pKa equal 6.0
variable pIm equal 3.0
variable pIp equal 3.0
variable cut_lj equal 2^(1.0/6.0)
variable lunit_nm equal 0.72 # in the units of nm
velocity all create 1.0 8008 loop geom
pair_style lj/cut/coul/long ${cut_lj} ${cut_long}
pair_style lj/cut/coul/long 1.12246204830937 ${cut_long}
pair_style lj/cut/coul/long 1.12246204830937 12.5
pair_coeff * * 1.0 1.0
kspace_style ewald 1.0e-3
pair_modify shift yes
######### VERLET INTEGRATION WITH LANGEVIN THERMOSTAT ###########
fix fnve all nve
compute dtemp all temp
compute_modify dtemp dynamic yes
fix fT all langevin 1.0 1.0 1.0 123
fix_modify fT temp dtemp
fix chareg all charge/regulation 2 3 acid_type 1 pH ${pH} pKa ${pKa} pIp ${pIp} pIm ${pIm} lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa ${pKa} pIp ${pIp} pIm ${pIm} lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp ${pIp} pIm ${pIm} lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm ${pIm} lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.72 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.72 nevery 100 nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.72 nevery 100 nmc 100 seed 2345 tempfixid fT
thermo 100
thermo_style custom step pe c_dtemp f_chareg[1] f_chareg[2] f_chareg[3] f_chareg[4] f_chareg[5] f_chareg[6] f_chareg[7] f_chareg[8]
timestep 0.005
run 2000
Ewald initialization ...
using 12-bit tables for long-range coulomb (src/kspace.cpp:339)
G vector (1/distance) = 0.14221027
estimated absolute RMS force accuracy = 0.0010128126
estimated relative force accuracy = 0.0010128126
KSpace vectors: actual max1d max3d = 257 5 665
kxmax kymax kzmax = 5 5 5
0 atoms in group FixChargeRegulation:exclusion_group:chareg
WARNING: Neighbor exclusions used with KSpace solver may give inconsistent Coulombic energies (src/neighbor.cpp:486)
Neighbor list info ...
update every 1 steps, delay 10 steps, check yes
max neighbors/atom: 2000, page size: 100000
master list distance cutoff = 15.5
ghost atom cutoff = 15.5
binsize = 7.75, bins = 7 7 7
1 neighbor lists, perpetual/occasional/extra = 1 0 0
(1) pair lj/cut/coul/long, perpetual
attributes: half, newton on
pair build: half/bin/atomonly/newton
stencil: half/bin/3d/newton
bin: standard
Per MPI rank memory allocation (min/avg/max) = 11.91 | 11.91 | 11.91 Mbytes
Step PotEng c_dtemp f_chareg[1] f_chareg[2] f_chareg[3] f_chareg[4] f_chareg[5] f_chareg[6] f_chareg[7] f_chareg[8]
0 -0.049662059 1 0 0 1 99 0 0 109 10
100 -0.053672881 0.99159291 100 71 16 84 0 0 92 8
200 -0.053383027 0.90935145 200 156 26 74 0 0 85 11
300 -0.040471335 0.97937429 300 240 21 79 0 0 87 8
400 -0.036188123 1.0837424 400 319 14 86 0 0 92 6
500 -0.057294925 1.0507526 500 407 10 90 0 0 98 8
600 -0.056009748 1.0669354 600 487 15 85 0 0 92 7
700 -0.069686562 0.99202496 700 567 14 86 0 0 96 10
800 -0.054695624 1.0592933 800 647 25 75 0 0 82 7
900 -0.058693653 0.97870458 900 728 27 73 0 0 83 10
1000 -0.062352957 1.0008923 1000 805 24 76 0 0 84 8
1100 -0.065011926 0.91691048 1100 886 22 78 0 0 87 9
1200 -0.080463686 0.98879304 1200 963 23 77 0 0 88 11
1300 -0.062146141 1.0566033 1300 1047 21 79 0 0 88 9
1400 -0.046980246 1.0847512 1400 1129 17 83 0 0 94 11
1500 -0.042935292 1.0075805 1500 1203 24 76 0 0 86 10
1600 -0.056075891 0.94173489 1600 1277 23 77 0 0 90 13
1700 -0.042279161 1.1126317 1700 1355 28 72 0 0 82 10
1800 -0.036842528 1.0255327 1800 1436 24 76 0 0 83 7
1900 -0.038816022 0.93883373 1900 1511 23 77 0 0 86 9
2000 -0.047008287 0.98904085 2000 1592 26 74 0 0 81 7
Loop time of 11.6365 on 1 procs for 2000 steps with 188 atoms
Performance: 74249.079 tau/day, 171.873 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads
MPI task timing breakdown:
Section | min time | avg time | max time |%varavg| %total
---------------------------------------------------------------
Pair | 0.24337 | 0.24337 | 0.24337 | 0.0 | 2.09
Kspace | 4.6009 | 4.6009 | 4.6009 | 0.0 | 39.54
Neigh | 0.023451 | 0.023451 | 0.023451 | 0.0 | 0.20
Comm | 0.027729 | 0.027729 | 0.027729 | 0.0 | 0.24
Output | 0.0007813 | 0.0007813 | 0.0007813 | 0.0 | 0.01
Modify | 6.7345 | 6.7345 | 6.7345 | 0.0 | 57.87
Other | | 0.005713 | | | 0.05
Nlocal: 188.000 ave 188 max 188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost: 597.000 ave 597 max 597 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs: 2196.00 ave 2196 max 2196 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Total # of neighbors = 2196
Ave neighs/atom = 11.680851
Neighbor list builds = 2059
Dangerous builds = 0
Total wall time: 0:00:11

125
examples/USER/misc/charge_regulation/log.10Feb21.chreg-acid.g++.4 Normal file
View File

@ -0,0 +1,125 @@
LAMMPS (10 Feb 2021)
using 1 OpenMP thread(s) per MPI task
# Charge regulation lammps for simple weak electrolyte
units lj
atom_style charge
neighbor 3.0 bin
read_data data.chreg-acid
Reading data file ...
orthogonal box = (-25.000000 -25.000000 -25.000000) to (25.000000 25.000000 25.000000)
1 by 2 by 2 MPI processor grid
reading atoms ...
219 atoms
read_data CPU = 0.003 seconds
variable cut_long equal 12.5
variable nevery equal 100
variable nmc equal 100
variable pH equal 7.0
variable pKa equal 6.0
variable pIm equal 3.0
variable pIp equal 3.0
variable cut_lj equal 2^(1.0/6.0)
variable lunit_nm equal 0.72 # in the units of nm
velocity all create 1.0 8008 loop geom
pair_style lj/cut/coul/long ${cut_lj} ${cut_long}
pair_style lj/cut/coul/long 1.12246204830937 ${cut_long}
pair_style lj/cut/coul/long 1.12246204830937 12.5
pair_coeff * * 1.0 1.0
kspace_style ewald 1.0e-3
pair_modify shift yes
######### VERLET INTEGRATION WITH LANGEVIN THERMOSTAT ###########
fix fnve all nve
compute dtemp all temp
compute_modify dtemp dynamic yes
fix fT all langevin 1.0 1.0 1.0 123
fix_modify fT temp dtemp
fix chareg all charge/regulation 2 3 acid_type 1 pH ${pH} pKa ${pKa} pIp ${pIp} pIm ${pIm} lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa ${pKa} pIp ${pIp} pIm ${pIm} lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp ${pIp} pIm ${pIm} lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm ${pIm} lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm ${lunit_nm} nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.72 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.72 nevery 100 nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.72 nevery 100 nmc 100 seed 2345 tempfixid fT
thermo 100
thermo_style custom step pe c_dtemp f_chareg[1] f_chareg[2] f_chareg[3] f_chareg[4] f_chareg[5] f_chareg[6] f_chareg[7] f_chareg[8]
timestep 0.005
run 2000
Ewald initialization ...
using 12-bit tables for long-range coulomb (src/kspace.cpp:339)
G vector (1/distance) = 0.14221027
estimated absolute RMS force accuracy = 0.0010128126
estimated relative force accuracy = 0.0010128126
KSpace vectors: actual max1d max3d = 257 5 665
kxmax kymax kzmax = 5 5 5
0 atoms in group FixChargeRegulation:exclusion_group:chareg
WARNING: Neighbor exclusions used with KSpace solver may give inconsistent Coulombic energies (src/neighbor.cpp:486)
Neighbor list info ...
update every 1 steps, delay 10 steps, check yes
max neighbors/atom: 2000, page size: 100000
master list distance cutoff = 15.5
ghost atom cutoff = 15.5
binsize = 7.75, bins = 7 7 7
1 neighbor lists, perpetual/occasional/extra = 1 0 0
(1) pair lj/cut/coul/long, perpetual
attributes: half, newton on
pair build: half/bin/atomonly/newton
stencil: half/bin/3d/newton
bin: standard
Per MPI rank memory allocation (min/avg/max) = 11.89 | 11.89 | 11.89 Mbytes
Step PotEng c_dtemp f_chareg[1] f_chareg[2] f_chareg[3] f_chareg[4] f_chareg[5] f_chareg[6] f_chareg[7] f_chareg[8]
0 -0.049662059 1 0 0 1 99 0 0 109 10
100 -0.06196414 1.0156327 100 72 15 85 0 0 93 8
200 -0.053901683 0.95128403 200 160 24 76 0 0 87 11
300 -0.043852423 0.98035058 300 246 22 78 0 0 85 7
400 -0.048370798 1.0909844 400 324 16 84 0 0 91 7
500 -0.042546472 1.026849 500 410 13 87 0 0 95 8
600 -0.06133022 0.97805065 600 494 14 86 0 0 93 7
700 -0.053815853 1.0641005 700 572 17 83 0 0 91 8
800 -0.059974814 1.0192348 800 650 23 77 0 0 83 6
900 -0.051808132 1.0773288 900 728 25 75 0 0 85 10
1000 -0.050390995 1.0236954 1000 804 28 72 0 0 81 9
1100 -0.069766444 1.030965 1100 890 25 75 0 0 85 10
1200 -0.074580231 1.0490058 1200 963 21 79 0 0 88 9
1300 -0.060169443 0.93456607 1300 1043 22 78 0 0 86 8
1400 -0.05120764 1.0374062 1400 1127 19 81 0 0 92 11
1500 -0.027644416 0.99804782 1500 1204 24 76 0 0 85 9
1600 -0.038599195 0.99015524 1600 1283 22 78 0 0 90 12
1700 -0.050222686 1.1444379 1700 1365 27 73 0 0 84 11
1800 -0.049338003 1.1188048 1800 1449 22 78 0 0 84 6
1900 -0.04533154 0.99894341 1900 1527 22 78 0 0 86 8
2000 -0.058837311 0.95302017 2000 1608 26 74 0 0 81 7
Loop time of 3.98119 on 4 procs for 2000 steps with 188 atoms
Performance: 217020.495 tau/day, 502.362 timesteps/s
96.2% CPU use with 4 MPI tasks x 1 OpenMP threads
MPI task timing breakdown:
Section | min time | avg time | max time |%varavg| %total
---------------------------------------------------------------
Pair | 0.050626 | 0.061127 | 0.071318 | 3.4 | 1.54
Kspace | 1.1987 | 1.2504 | 1.288 | 3.1 | 31.41
Neigh | 0.0056982 | 0.0063858 | 0.0069821 | 0.7 | 0.16
Comm | 0.068302 | 0.11638 | 0.17922 | 12.8 | 2.92
Output | 0.00055408 | 0.00092399 | 0.0020106 | 0.0 | 0.02
Modify | 2.5399 | 2.5406 | 2.5417 | 0.0 | 63.81
Other | | 0.005394 | | | 0.14
Nlocal: 47.0000 ave 55 max 42 min
Histogram: 1 0 1 1 0 0 0 0 0 1
Nghost: 328.250 ave 335 max 317 min
Histogram: 1 0 0 0 0 1 0 0 0 2
Neighs: 547.000 ave 659 max 466 min
Histogram: 2 0 0 0 0 0 1 0 0 1
Total # of neighbors = 2188
Ave neighs/atom = 11.638298
Neighbor list builds = 2057
Dangerous builds = 0
Total wall time: 0:00:04

131
examples/USER/misc/charge_regulation/log.10Feb21.chreg-polymer.g++.1 Normal file
View File

@ -0,0 +1,131 @@
LAMMPS (10 Feb 2021)
using 1 OpenMP thread(s) per MPI task
# Charge regulation lammps for a polymer chain
units lj
atom_style full
neighbor 3.0 bin
read_data data.chreg-polymer
Reading data file ...
orthogonal box = (-50.000000 -50.000000 -50.000000) to (50.000000 50.000000 50.000000)
1 by 1 by 1 MPI processor grid
reading atoms ...
160 atoms
scanning bonds ...
1 = max bonds/atom
reading bonds ...
79 bonds
Finding 1-2 1-3 1-4 neighbors ...
special bond factors lj: 0 0 0
special bond factors coul: 0 0 0
2 = max # of 1-2 neighbors
2 = max # of 1-3 neighbors
4 = max # of 1-4 neighbors
6 = max # of special neighbors
special bonds CPU = 0.001 seconds
read_data CPU = 0.009 seconds
bond_style harmonic
bond_coeff 1 100 1.122462 # K R0
velocity all create 1.0 8008 loop geom
pair_style lj/cut/coul/long 1.122462 20
pair_coeff * * 1.0 1.0 1.122462 # charges
kspace_style pppm 1.0e-3
pair_modify shift yes
dielectric 1.0
######### VERLET INTEGRATION WITH LANGEVIN THERMOSTAT ###########
fix fnve all nve
compute dtemp all temp
compute_modify dtemp dynamic yes
fix fT all langevin 1.0 1.0 1.0 123
fix_modify fT temp dtemp
fix chareg1 all charge/regulation 2 3 acid_type 1 pH 7.0 pKa 6.5 pIp 3.0 pIm 3.0 temp 1.0 nmc 40 seed 2345
fix chareg2 all charge/regulation 4 5 acid_type 1 pH 7.0 pKa 6.5 pIp 7.0 pIm 7.0 temp 1.0 nmc 40 seed 2345
fix chareg3 all charge/regulation 4 3 pIp 7.0 pIm 3.0 temp 1.0 nmc 20 seed 2345
thermo 100
# print: step, potential energy, temperature, neutral acids, charged acids, salt cations, salt anions, H+ ions, OH- ions
thermo_style custom step pe c_dtemp f_chareg1[3] f_chareg1[4] f_chareg1[7] f_chareg1[8] f_chareg2[7] f_chareg2[8]
timestep 0.005
run 2000
PPPM initialization ...
using 12-bit tables for long-range coulomb (src/kspace.cpp:339)
G vector (1/distance) = 0.077106934
grid = 8 8 8
stencil order = 5
estimated absolute RMS force accuracy = 0.00074388331
estimated relative force accuracy = 0.00074388331
using double precision FFTW3
3d grid and FFT values/proc = 2197 512
0 atoms in group FixChargeRegulation:exclusion_group:chareg1
0 atoms in group FixChargeRegulation:exclusion_group:chareg2
0 atoms in group FixChargeRegulation:exclusion_group:chareg3
WARNING: Neighbor exclusions used with KSpace solver may give inconsistent Coulombic energies (src/neighbor.cpp:486)
Neighbor list info ...
update every 1 steps, delay 10 steps, check yes
max neighbors/atom: 2000, page size: 100000
master list distance cutoff = 23
ghost atom cutoff = 23
binsize = 11.5, bins = 9 9 9
1 neighbor lists, perpetual/occasional/extra = 1 0 0
(1) pair lj/cut/coul/long, perpetual
attributes: half, newton on
pair build: half/bin/newton
stencil: half/bin/3d/newton
bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.962 | 6.962 | 6.962 Mbytes
Step PotEng c_dtemp f_chareg1[3] f_chareg1[4] f_chareg1[7] f_chareg1[8] f_chareg2[7] f_chareg2[8]
0 0.50528297 1 0 80 80 0 0 0
100 0.61185377 0.95892928 13 67 74 7 0 0
200 0.54355177 1.1282424 19 61 76 15 0 0
300 0.4519957 1.0764688 20 60 85 26 1 0
400 0.41479389 0.99212685 24 56 92 36 0 0
500 0.37382446 0.99776674 28 52 98 46 0 0
600 0.34785337 1.1115081 28 52 109 57 0 0
700 0.34637618 1.0332262 28 52 120 68 0 0
800 0.21020932 1.1264036 29 51 125 74 0 0
900 0.21246108 1.1168609 30 50 131 81 0 0
1000 0.20997475 1.1201478 32 48 132 84 0 0
1100 0.1984165 1.0209092 31 49 144 95 0 0
1200 0.2061932 0.95880059 35 45 151 106 0 0
1300 0.17220376 0.980077 36 44 156 112 0 0
1400 0.15671143 0.93535342 37 43 161 118 0 0
1500 0.16174665 0.9495928 36 44 168 124 0 0
1600 0.11062965 0.94072924 40 40 164 124 0 0
1700 0.13002563 0.95010828 38 42 167 125 0 0
1800 0.14527814 0.93555342 37 43 172 129 0 0
1900 0.17627465 0.96682495 32 48 176 128 0 0
2000 0.16497265 0.95226954 33 47 180 133 0 0
Loop time of 7.45499 on 1 procs for 2000 steps with 393 atoms
Performance: 115895.577 tau/day, 268.277 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads
MPI task timing breakdown:
Section | min time | avg time | max time |%varavg| %total
---------------------------------------------------------------
Pair | 0.45607 | 0.45607 | 0.45607 | 0.0 | 6.12
Bond | 0.0062385 | 0.0062385 | 0.0062385 | 0.0 | 0.08
Kspace | 2.3257 | 2.3257 | 2.3257 | 0.0 | 31.20
Neigh | 0.067103 | 0.067103 | 0.067103 | 0.0 | 0.90
Comm | 0.02577 | 0.02577 | 0.02577 | 0.0 | 0.35
Output | 0.00087047 | 0.00087047 | 0.00087047 | 0.0 | 0.01
Modify | 4.5664 | 4.5664 | 4.5664 | 0.0 | 61.25
Other | | 0.006848 | | | 0.09
Nlocal: 393.000 ave 393 max 393 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost: 749.000 ave 749 max 749 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs: 5359.00 ave 5359 max 5359 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Total # of neighbors = 5359
Ave neighs/atom = 13.636132
Ave special neighs/atom = 1.1908397
Neighbor list builds = 1489
Dangerous builds = 0
Total wall time: 0:00:07

131
examples/USER/misc/charge_regulation/log.10Feb21.chreg-polymer.g++.4 Normal file
View File

@ -0,0 +1,131 @@
LAMMPS (10 Feb 2021)
using 1 OpenMP thread(s) per MPI task
# Charge regulation lammps for a polymer chain
units lj
atom_style full
neighbor 3.0 bin
read_data data.chreg-polymer
Reading data file ...
orthogonal box = (-50.000000 -50.000000 -50.000000) to (50.000000 50.000000 50.000000)
1 by 2 by 2 MPI processor grid
reading atoms ...
160 atoms
scanning bonds ...
1 = max bonds/atom
reading bonds ...
79 bonds
Finding 1-2 1-3 1-4 neighbors ...
special bond factors lj: 0 0 0
special bond factors coul: 0 0 0
2 = max # of 1-2 neighbors
2 = max # of 1-3 neighbors
4 = max # of 1-4 neighbors
6 = max # of special neighbors
special bonds CPU = 0.001 seconds
read_data CPU = 0.016 seconds
bond_style harmonic
bond_coeff 1 100 1.122462 # K R0
velocity all create 1.0 8008 loop geom
pair_style lj/cut/coul/long 1.122462 20
pair_coeff * * 1.0 1.0 1.122462 # charges
kspace_style pppm 1.0e-3
pair_modify shift yes
dielectric 1.0
######### VERLET INTEGRATION WITH LANGEVIN THERMOSTAT ###########
fix fnve all nve
compute dtemp all temp
compute_modify dtemp dynamic yes
fix fT all langevin 1.0 1.0 1.0 123
fix_modify fT temp dtemp
fix chareg1 all charge/regulation 2 3 acid_type 1 pH 7.0 pKa 6.5 pIp 3.0 pIm 3.0 temp 1.0 nmc 40 seed 2345
fix chareg2 all charge/regulation 4 5 acid_type 1 pH 7.0 pKa 6.5 pIp 7.0 pIm 7.0 temp 1.0 nmc 40 seed 2345
fix chareg3 all charge/regulation 4 3 pIp 7.0 pIm 3.0 temp 1.0 nmc 20 seed 2345
thermo 100
# print: step, potential energy, temperature, neutral acids, charged acids, salt cations, salt anions, H+ ions, OH- ions
thermo_style custom step pe c_dtemp f_chareg1[3] f_chareg1[4] f_chareg1[7] f_chareg1[8] f_chareg2[7] f_chareg2[8]
timestep 0.005
run 2000
PPPM initialization ...
using 12-bit tables for long-range coulomb (src/kspace.cpp:339)
G vector (1/distance) = 0.077106934
grid = 8 8 8
stencil order = 5
estimated absolute RMS force accuracy = 0.00074388331
estimated relative force accuracy = 0.00074388331
using double precision FFTW3
3d grid and FFT values/proc = 1053 128
0 atoms in group FixChargeRegulation:exclusion_group:chareg1
0 atoms in group FixChargeRegulation:exclusion_group:chareg2
0 atoms in group FixChargeRegulation:exclusion_group:chareg3
WARNING: Neighbor exclusions used with KSpace solver may give inconsistent Coulombic energies (src/neighbor.cpp:486)
Neighbor list info ...
update every 1 steps, delay 10 steps, check yes
max neighbors/atom: 2000, page size: 100000
master list distance cutoff = 23
ghost atom cutoff = 23
binsize = 11.5, bins = 9 9 9
1 neighbor lists, perpetual/occasional/extra = 1 0 0
(1) pair lj/cut/coul/long, perpetual
attributes: half, newton on
pair build: half/bin/newton
stencil: half/bin/3d/newton
bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.878 | 6.935 | 6.992 Mbytes
Step PotEng c_dtemp f_chareg1[3] f_chareg1[4] f_chareg1[7] f_chareg1[8] f_chareg2[7] f_chareg2[8]
0 0.50528297 1 0 80 80 0 0 0
100 0.60223729 0.89547569 13 67 75 8 0 0
200 0.65253636 0.87662399 18 62 78 16 0 0
300 0.51550501 1.0542131 22 58 84 27 1 0
400 0.43566766 0.94557633 26 54 90 36 0 0
500 0.36269507 1.0386276 31 49 94 45 0 0
600 0.32430641 0.99903033 27 53 111 58 0 0
700 0.30255299 0.91225991 28 52 121 69 0 0
800 0.27189951 0.9747089 28 52 127 75 0 0
900 0.25495247 1.0747821 28 52 135 83 0 0
1000 0.25950416 0.95256449 32 48 134 86 0 0
1100 0.22561248 1.0102255 32 48 147 99 0 0
1200 0.1734754 0.99475154 33 47 157 110 0 0
1300 0.20081084 0.99873599 36 44 160 116 0 0
1400 0.14240417 0.99442152 36 44 164 121 1 0
1500 0.15314186 0.94559876 39 41 167 126 0 0
1600 0.13574107 1.0484195 43 37 164 127 0 0
1700 0.14477789 1.0105172 42 38 166 128 0 0
1800 0.13493107 1.0349667 41 39 171 132 0 0
1900 0.14849779 0.9994329 33 47 178 131 0 0
2000 0.14485171 0.99739608 34 46 183 137 0 0
Loop time of 3.18871 on 4 procs for 2000 steps with 400 atoms
Performance: 270955.695 tau/day, 627.212 timesteps/s
94.5% CPU use with 4 MPI tasks x 1 OpenMP threads
MPI task timing breakdown:
Section | min time | avg time | max time |%varavg| %total
---------------------------------------------------------------
Pair | 0.086456 | 0.11738 | 0.18562 | 11.8 | 3.68
Bond | 0.00099182 | 0.0018544 | 0.0030079 | 1.8 | 0.06
Kspace | 0.77406 | 0.79354 | 0.80895 | 1.5 | 24.89
Neigh | 0.017894 | 0.017948 | 0.018002 | 0.0 | 0.56
Comm | 0.029044 | 0.07885 | 0.11432 | 11.3 | 2.47
Output | 0.00054932 | 0.0009656 | 0.0021319 | 0.0 | 0.03
Modify | 2.1676 | 2.1706 | 2.1733 | 0.2 | 68.07
Other | | 0.007591 | | | 0.24
Nlocal: 100.000 ave 110 max 89 min
Histogram: 1 1 0 0 0 0 0 0 0 2
Nghost: 415.000 ave 418 max 411 min
Histogram: 1 0 1 0 0 0 0 0 0 2
Neighs: 1360.75 ave 1872 max 1018 min
Histogram: 1 1 0 0 1 0 0 0 0 1
Total # of neighbors = 5443
Ave neighs/atom = 13.607500
Ave special neighs/atom = 1.1700000
Neighbor list builds = 1492
Dangerous builds = 0
Total wall time: 0:00:03

145
examples/USER/misc/charge_regulation/log.11Apr21.chreg-acid-real.g++.1 Normal file
View File

@ -0,0 +1,145 @@
LAMMPS (10 Feb 2021)
# Charge regulation lammps for simple weak electrolyte
units real
atom_style charge
neighbor 10.0 bin
read_data data.chreg-acid-real
Reading data file ...
orthogonal box = (-180.00000 -180.00000 -180.00000) to (180.00000 180.00000 180.00000)
1 by 1 by 1 MPI processor grid
reading atoms ...
219 atoms
read_data CPU = 0.002 seconds
#real units
variable sigma equal 7.2 # particle diameter 0.72 nm
variable temperature equal 298 # temperature 298 K
variable kb index 0.0019872067 # kB in Kcal/mol/K
variable epsilon equal ${kb}*${temperature}
variable epsilon equal 0.0019872067*${temperature}
variable epsilon equal 0.0019872067*298
variable tunit equal 2000 # time unit is 2000 fs
variable timestep equal 0.005*${tunit}
variable timestep equal 0.005*2000
variable cut_long equal 12.5*${sigma}
variable cut_long equal 12.5*7.2
variable nevery equal 100
variable nmc equal 100
variable pH equal 7.0
variable pKa equal 6.0
variable pIm equal 3.0
variable pIp equal 3.0
variable cut_lj equal 2^(1.0/6.0)*${sigma}
variable cut_lj equal 2^(1.0/6.0)*7.2
velocity all create ${temperature} 8008 loop geom
velocity all create 298 8008 loop geom
pair_style lj/cut/coul/long ${cut_lj} ${cut_long}
pair_style lj/cut/coul/long 8.08172674782749 ${cut_long}
pair_style lj/cut/coul/long 8.08172674782749 90
pair_coeff * * ${epsilon} ${sigma}
pair_coeff * * 0.5921875966 ${sigma}
pair_coeff * * 0.5921875966 7.2
kspace_style pppm 1.0e-3
dielectric 78
pair_modify shift yes
######### VERLET INTEGRATION WITH LANGEVIN THERMOSTAT ###########
fix fnve all nve
compute dtemp all temp
compute_modify dtemp dynamic yes
fix fT all langevin $(v_temperature) $(v_temperature) $(v_tunit) 123
fix fT all langevin 298 $(v_temperature) $(v_tunit) 123
fix fT all langevin 298 298 $(v_tunit) 123
fix fT all langevin 298 298 2000 123
fix_modify fT temp dtemp
fix chareg all charge/regulation 2 3 acid_type 1 pH ${pH} pKa ${pKa} pIp ${pIp} pIm ${pIm} lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa ${pKa} pIp ${pIp} pIm ${pIm} lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp ${pIp} pIm ${pIm} lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm ${pIm} lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.1 nevery 100 nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.1 nevery 100 nmc 100 seed 2345 tempfixid fT
thermo 100
thermo_style custom step pe c_dtemp f_chareg[1] f_chareg[2] f_chareg[3] f_chareg[4] f_chareg[5] f_chareg[6] f_chareg[7] f_chareg[8]
timestep ${timestep}
timestep 10
run 2000
PPPM initialization ...
using 12-bit tables for long-range coulomb (../kspace.cpp:339)
G vector (1/distance) = 0.019408615
grid = 8 8 8
stencil order = 5
estimated absolute RMS force accuracy = 0.00012527706
estimated relative force accuracy = 3.7726815e-07
using double precision KISS FFT
3d grid and FFT values/proc = 2197 512
0 atoms in group FixChargeRegulation:exclusion_group:chareg
WARNING: Neighbor exclusions used with KSpace solver may give inconsistent Coulombic energies (../neighbor.cpp:486)
Neighbor list info ...
update every 1 steps, delay 10 steps, check yes
max neighbors/atom: 2000, page size: 100000
master list distance cutoff = 100
ghost atom cutoff = 100
binsize = 50, bins = 8 8 8
1 neighbor lists, perpetual/occasional/extra = 1 0 0
(1) pair lj/cut/coul/long, perpetual
attributes: half, newton on
pair build: half/bin/atomonly/newton
stencil: half/bin/3d/newton
bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.708 | 3.708 | 3.708 Mbytes
Step PotEng c_dtemp f_chareg[1] f_chareg[2] f_chareg[3] f_chareg[4] f_chareg[5] f_chareg[6] f_chareg[7] f_chareg[8]
0 -6.4798431 298 0 0 1 99 0 0 109 10
100 -6.9219668 306.44177 100 77 15 85 0 0 94 9
200 -6.8175255 306.64254 200 164 23 77 0 0 87 10
300 -5.2482381 331.67831 300 248 21 79 0 0 85 6
400 -7.4531538 285.3495 400 326 17 83 0 0 89 6
500 -6.9662528 286.2123 500 408 14 86 0 0 95 9
600 -6.528214 291.41762 600 492 14 86 0 0 95 9
700 -6.290871 271.50948 700 567 14 86 0 0 96 10
800 -6.4944741 300.66261 800 650 23 77 0 0 83 6
900 -8.0414672 305.6179 900 731 25 75 0 0 84 9
1000 -8.5694583 298.73349 1000 810 25 75 0 0 83 8
1100 -8.6677368 269.67435 1100 894 22 78 0 0 87 9
1200 -8.2246183 284.14886 1200 969 22 78 0 0 88 10
1300 -7.7674621 320.04838 1300 1040 23 77 0 0 85 8
1400 -9.5186335 303.48091 1400 1124 18 82 0 0 93 11
1500 -5.8437493 271.40712 1500 1204 25 75 0 0 83 8
1600 -5.9149181 268.24708 1600 1285 23 77 0 0 90 13
1700 -6.5047738 303.79732 1700 1369 27 73 0 0 84 11
1800 -7.3010139 308.98213 1800 1450 22 78 0 0 83 5
1900 -6.3505397 306.94357 1900 1527 22 78 0 0 86 8
2000 -5.7144173 287.06184 2000 1605 27 73 0 0 80 7
Loop time of 1.17189 on 1 procs for 2000 steps with 187 atoms
Performance: 1474.535 ns/day, 0.016 hours/ns, 1706.638 timesteps/s
99.6% CPU use with 1 MPI tasks x no OpenMP threads
MPI task timing breakdown:
Section | min time | avg time | max time |%varavg| %total
---------------------------------------------------------------
Pair | 0.035807 | 0.035807 | 0.035807 | 0.0 | 3.06
Kspace | 0.37689 | 0.37689 | 0.37689 | 0.0 | 32.16
Neigh | 0.008694 | 0.008694 | 0.008694 | 0.0 | 0.74
Comm | 0.004793 | 0.004793 | 0.004793 | 0.0 | 0.41
Output | 0.000746 | 0.000746 | 0.000746 | 0.0 | 0.06
Modify | 0.74292 | 0.74292 | 0.74292 | 0.0 | 63.39
Other | | 0.00205 | | | 0.17
Nlocal: 187.000 ave 187 max 187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost: 437.000 ave 437 max 437 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs: 1500.00 ave 1500 max 1500 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Total # of neighbors = 1500
Ave neighs/atom = 8.0213904
Neighbor list builds = 2080
Dangerous builds = 0
Total wall time: 0:00:01

145
examples/USER/misc/charge_regulation/log.11Apr21.chreg-acid-real.g++.4 Normal file
View File

@ -0,0 +1,145 @@
LAMMPS (10 Feb 2021)
# Charge regulation lammps for simple weak electrolyte
units real
atom_style charge
neighbor 10.0 bin
read_data data.chreg-acid-real
Reading data file ...
orthogonal box = (-180.00000 -180.00000 -180.00000) to (180.00000 180.00000 180.00000)
1 by 2 by 2 MPI processor grid
reading atoms ...
219 atoms
read_data CPU = 0.002 seconds
#real units
variable sigma equal 7.2 # particle diameter 0.72 nm
variable temperature equal 298 # temperature 298 K
variable kb index 0.0019872067 # kB in Kcal/mol/K
variable epsilon equal ${kb}*${temperature}
variable epsilon equal 0.0019872067*${temperature}
variable epsilon equal 0.0019872067*298
variable tunit equal 2000 # time unit is 2000 fs
variable timestep equal 0.005*${tunit}
variable timestep equal 0.005*2000
variable cut_long equal 12.5*${sigma}
variable cut_long equal 12.5*7.2
variable nevery equal 100
variable nmc equal 100
variable pH equal 7.0
variable pKa equal 6.0
variable pIm equal 3.0
variable pIp equal 3.0
variable cut_lj equal 2^(1.0/6.0)*${sigma}
variable cut_lj equal 2^(1.0/6.0)*7.2
velocity all create ${temperature} 8008 loop geom
velocity all create 298 8008 loop geom
pair_style lj/cut/coul/long ${cut_lj} ${cut_long}
pair_style lj/cut/coul/long 8.08172674782749 ${cut_long}
pair_style lj/cut/coul/long 8.08172674782749 90
pair_coeff * * ${epsilon} ${sigma}
pair_coeff * * 0.5921875966 ${sigma}
pair_coeff * * 0.5921875966 7.2
kspace_style pppm 1.0e-3
dielectric 78
pair_modify shift yes
######### VERLET INTEGRATION WITH LANGEVIN THERMOSTAT ###########
fix fnve all nve
compute dtemp all temp
compute_modify dtemp dynamic yes
fix fT all langevin $(v_temperature) $(v_temperature) $(v_tunit) 123
fix fT all langevin 298 $(v_temperature) $(v_tunit) 123
fix fT all langevin 298 298 $(v_tunit) 123
fix fT all langevin 298 298 2000 123
fix_modify fT temp dtemp
fix chareg all charge/regulation 2 3 acid_type 1 pH ${pH} pKa ${pKa} pIp ${pIp} pIm ${pIm} lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa ${pKa} pIp ${pIp} pIm ${pIm} lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp ${pIp} pIm ${pIm} lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm ${pIm} lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.1 nevery ${nevery} nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.1 nevery 100 nmc ${nmc} seed 2345 tempfixid fT
fix chareg all charge/regulation 2 3 acid_type 1 pH 7 pKa 6 pIp 3 pIm 3 lunit_nm 0.1 nevery 100 nmc 100 seed 2345 tempfixid fT
thermo 100
thermo_style custom step pe c_dtemp f_chareg[1] f_chareg[2] f_chareg[3] f_chareg[4] f_chareg[5] f_chareg[6] f_chareg[7] f_chareg[8]
timestep ${timestep}
timestep 10
run 2000
PPPM initialization ...
using 12-bit tables for long-range coulomb (../kspace.cpp:339)
G vector (1/distance) = 0.019408615
grid = 8 8 8
stencil order = 5
estimated absolute RMS force accuracy = 0.00012527706
estimated relative force accuracy = 3.7726815e-07
using double precision KISS FFT
3d grid and FFT values/proc = 1053 128
0 atoms in group FixChargeRegulation:exclusion_group:chareg
WARNING: Neighbor exclusions used with KSpace solver may give inconsistent Coulombic energies (../neighbor.cpp:486)
Neighbor list info ...
update every 1 steps, delay 10 steps, check yes
max neighbors/atom: 2000, page size: 100000
master list distance cutoff = 100
ghost atom cutoff = 100
binsize = 50, bins = 8 8 8
1 neighbor lists, perpetual/occasional/extra = 1 0 0
(1) pair lj/cut/coul/long, perpetual
attributes: half, newton on
pair build: half/bin/atomonly/newton
stencil: half/bin/3d/newton
bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.624 | 3.624 | 3.624 Mbytes
Step PotEng c_dtemp f_chareg[1] f_chareg[2] f_chareg[3] f_chareg[4] f_chareg[5] f_chareg[6] f_chareg[7] f_chareg[8]
0 -6.4798431 298 0 0 1 99 0 0 109 10
100 -7.6327126 304.68909 100 73 15 85 0 0 94 9
200 -6.1699041 272.19597 200 156 24 76 0 0 87 11
300 -7.7876571 288.90801 300 240 20 80 0 0 87 7
400 -6.3239918 274.65708 400 315 16 84 0 0 90 6
500 -5.3978659 257.49208 500 398 15 85 0 0 93 8
600 -5.6433949 322.52048 600 477 18 82 0 0 90 8
700 -6.5351367 269.20244 700 558 18 82 0 0 91 9
800 -6.2093085 315.21326 800 638 24 76 0 0 83 7
900 -7.0795998 311.93228 900 719 28 72 0 0 82 10
1000 -6.4668438 281.72674 1000 796 27 73 0 0 81 8
1100 -6.2377994 318.48594 1100 875 25 75 0 0 84 9
1200 -6.6305072 304.9091 1200 950 23 77 0 0 87 10
1300 -5.9624552 286.05027 1300 1029 22 78 0 0 86 8
1400 -4.4695814 261.81053 1400 1111 20 80 0 0 90 10
1500 -5.6928652 293.72403 1500 1191 24 76 0 0 86 10
1600 -6.8715413 290.47065 1600 1275 22 78 0 0 90 12
1700 -6.5067505 292.74735 1700 1356 25 75 0 0 85 10
1800 -5.3902702 307.79012 1800 1434 22 78 0 0 83 5
1900 -5.1407153 318.48918 1900 1510 21 79 0 0 87 8
2000 -4.9514719 281.87771 2000 1589 25 75 0 0 82 7
Loop time of 0.562889 on 4 procs for 2000 steps with 189 atoms
Performance: 3069.876 ns/day, 0.008 hours/ns, 3553.097 timesteps/s
99.6% CPU use with 4 MPI tasks x no OpenMP threads
MPI task timing breakdown:
Section | min time | avg time | max time |%varavg| %total
---------------------------------------------------------------
Pair | 0.008399 | 0.010383 | 0.011765 | 1.2 | 1.84
Kspace | 0.17501 | 0.17543 | 0.1757 | 0.1 | 31.17
Neigh | 0.001833 | 0.0021325 | 0.002293 | 0.4 | 0.38
Comm | 0.023099 | 0.024255 | 0.026645 | 0.9 | 4.31
Output | 0.000465 | 0.000546 | 0.000783 | 0.0 | 0.10
Modify | 0.3464 | 0.34669 | 0.34698 | 0.0 | 61.59
Other | | 0.003452 | | | 0.61
Nlocal: 47.2500 ave 57 max 41 min
Histogram: 1 1 0 1 0 0 0 0 0 1
Nghost: 285.750 ave 303 max 263 min
Histogram: 1 0 0 0 1 0 0 0 1 1
Neighs: 403.500 ave 548 max 324 min
Histogram: 2 0 0 1 0 0 0 0 0 1
Total # of neighbors = 1614
Ave neighs/atom = 8.5396825
Neighbor list builds = 2081
Dangerous builds = 0
Total wall time: 0:00:00

1
examples/USER/pace/Cu-PBE-core-rep.ace Symbolic link
View File

@ -0,0 +1 @@
../../../potentials/Cu-PBE-core-rep.ace

38
examples/USER/pace/in.pace.product Normal file
View File

@ -0,0 +1,38 @@
# simple test of fcc Cu with ACE product
units metal
atom_style atomic
neighbor 0.3 bin
neigh_modify every 2 delay 10 check yes
variable a equal 3.597
lattice fcc $a
region box block 0 4 0 4 0 4
create_box 1 box
create_atoms 1 box
mass 1 26.98
group Al type 1
pair_style pace product
pair_coeff * * Cu-PBE-core-rep.ace Cu
velocity all create 300 8728 loop geom
timestep 0.0005
fix 1 all nve
compute eatom all pe/atom
compute energy all reduce sum c_eatom
variable delenergy equal c_energy-pe
compute satom all stress/atom NULL
compute str all reduce sum c_satom[1] c_satom[2] c_satom[3]
variable delpress equal -(c_str[1]+c_str[2]+c_str[3])/(3*vol)-press
thermo 10
thermo_style custom step temp epair etotal press v_delenergy v_delpress
run 100

38
examples/USER/pace/in.pace.recursive Normal file
View File

@ -0,0 +1,38 @@
# simple test of fcc Cu with ACE recursive
units metal
atom_style atomic
neighbor 0.3 bin
neigh_modify every 2 delay 10 check yes
variable a equal 3.597
lattice fcc $a
region box block 0 4 0 4 0 4
create_box 1 box
create_atoms 1 box
mass 1 26.98
group Al type 1
pair_style pace recursive
pair_coeff * * Cu-PBE-core-rep.ace Cu
velocity all create 300 8728 loop geom
timestep 0.0005
fix 1 all nve
compute eatom all pe/atom
compute energy all reduce sum c_eatom
variable delenergy equal c_energy-pe
compute satom all stress/atom NULL
compute str all reduce sum c_satom[1] c_satom[2] c_satom[3]
variable delpress equal -(c_str[1]+c_str[2]+c_str[3])/(3*vol)-press
thermo 10
thermo_style custom step temp epair etotal press v_delenergy v_delpress
run 100

108
examples/USER/pace/log.03Feb2021.pace.product.g++.1 Normal file
View File

@ -0,0 +1,108 @@
LAMMPS (24 Dec 2020)
OMP_NUM_THREADS environment is not set. Defaulting to 1 thread. (src/comm.cpp:94)
using 1 OpenMP thread(s) per MPI task
# simple test of fcc Cu with ACE product
units metal
atom_style atomic
neighbor 0.3 bin
neigh_modify every 2 delay 10 check yes
variable a equal 3.597
lattice fcc $a
lattice fcc 3.597
Lattice spacing in x,y,z = 3.5970000 3.5970000 3.5970000
region box block 0 4 0 4 0 4
create_box 1 box
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (14.388000 14.388000 14.388000)
1 by 1 by 1 MPI processor grid
create_atoms 1 box
Created 256 atoms
create_atoms CPU = 0.000 seconds
mass 1 26.98
group Al type 1
256 atoms in group Al
pair_style pace product
ACE version: 2021.2.3
Product evaluator is used
pair_coeff * * Cu-PBE-core-rep.ace Cu
Loading Cu-PBE-core-rep.ace
Total number of basis functions
Cu: 16 (r=1) 726 (r>1)
Mapping LAMMPS atom type #1(Cu) -> ACE species type #0
velocity all create 300 8728 loop geom
timestep 0.0005
fix 1 all nve
compute eatom all pe/atom
compute energy all reduce sum c_eatom
variable delenergy equal c_energy-pe
compute satom all stress/atom NULL
compute str all reduce sum c_satom[1] c_satom[2] c_satom[3]
variable delpress equal -(c_str[1]+c_str[2]+c_str[3])/(3*vol)-press
thermo 10
thermo_style custom step temp epair etotal press v_delenergy v_delpress
run 100
Neighbor list info ...
update every 2 steps, delay 10 steps, check yes
max neighbors/atom: 2000, page size: 100000
master list distance cutoff = 7.7
ghost atom cutoff = 7.7
binsize = 3.85, bins = 4 4 4
1 neighbor lists, perpetual/occasional/extra = 1 0 0
(1) pair pace, perpetual
attributes: full, newton on
pair build: full/bin/atomonly
stencil: full/bin/3d
bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.036 | 4.036 | 4.036 Mbytes
Step Temp E_pair TotEng Press v_delenergy v_delpress
0 300 -945.9873 -936.0989 45359.818 0 2.1827873e-11
10 280.68558 -945.35055 -936.09878 46326.919 0 2.910383e-11
20 228.73618 -943.63789 -936.09844 48903.598 0 -2.910383e-11
30 160.53661 -941.38948 -936.09798 52222.083 0 -2.910383e-11
40 97.732944 -939.31899 -936.09758 55176.875 0 2.1827873e-11
50 59.165961 -938.04759 -936.0974 56850.103 0 2.910383e-11
60 53.124678 -937.84857 -936.09751 56878.948 0 0
70 74.623347 -938.5575 -936.09782 55565.237 0 4.3655746e-11
80 109.4762 -939.70663 -936.09815 53665.652 0 2.910383e-11
90 142.02657 -940.77975 -936.09837 52001.1 0 0
100 161.73598 -941.42945 -936.09842 51114.997 0 1.4551915e-11
Loop time of 11.4718 on 1 procs for 100 steps with 256 atoms
Performance: 0.377 ns/day, 63.732 hours/ns, 8.717 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads
MPI task timing breakdown:
Section | min time | avg time | max time |%varavg| %total
---------------------------------------------------------------
Pair | 11.468 | 11.468 | 11.468 | 0.0 | 99.96
Neigh | 0.001181 | 0.001181 | 0.001181 | 0.0 | 0.01
Comm | 0.001207 | 0.001207 | 0.001207 | 0.0 | 0.01
Output | 0.000876 | 0.000876 | 0.000876 | 0.0 | 0.01
Modify | 0.000455 | 0.000455 | 0.000455 | 0.0 | 0.00
Other | | 0.000397 | | | 0.00
Nlocal: 256.000 ave 256 max 256 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost: 2201.00 ave 2201 max 2201 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs: 0.00000 ave 0 max 0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs: 43118.0 ave 43118 max 43118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Total # of neighbors = 43118
Ave neighs/atom = 168.42969
Neighbor list builds = 1
Dangerous builds = 0
Total wall time: 0:00:11

108
examples/USER/pace/log.03Feb2021.pace.product.g++.4 Normal file
View File

@ -0,0 +1,108 @@
LAMMPS (24 Dec 2020)
OMP_NUM_THREADS environment is not set. Defaulting to 1 thread. (src/comm.cpp:94)
using 1 OpenMP thread(s) per MPI task
# simple test of fcc Cu with ACE product
units metal
atom_style atomic
neighbor 0.3 bin
neigh_modify every 2 delay 10 check yes
variable a equal 3.597
lattice fcc $a
lattice fcc 3.597
Lattice spacing in x,y,z = 3.5970000 3.5970000 3.5970000
region box block 0 4 0 4 0 4
create_box 1 box
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (14.388000 14.388000 14.388000)
1 by 2 by 2 MPI processor grid
create_atoms 1 box
Created 256 atoms
create_atoms CPU = 0.000 seconds
mass 1 26.98
group Al type 1
256 atoms in group Al
pair_style pace product
ACE version: 2021.2.3
Product evaluator is used
pair_coeff * * Cu-PBE-core-rep.ace Cu
Loading Cu-PBE-core-rep.ace
Total number of basis functions
Cu: 16 (r=1) 726 (r>1)
Mapping LAMMPS atom type #1(Cu) -> ACE species type #0
velocity all create 300 8728 loop geom
timestep 0.0005
fix 1 all nve
compute eatom all pe/atom
compute energy all reduce sum c_eatom
variable delenergy equal c_energy-pe
compute satom all stress/atom NULL
compute str all reduce sum c_satom[1] c_satom[2] c_satom[3]
variable delpress equal -(c_str[1]+c_str[2]+c_str[3])/(3*vol)-press
thermo 10
thermo_style custom step temp epair etotal press v_delenergy v_delpress
run 100
Neighbor list info ...
update every 2 steps, delay 10 steps, check yes
max neighbors/atom: 2000, page size: 100000
master list distance cutoff = 7.7
ghost atom cutoff = 7.7
binsize = 3.85, bins = 4 4 4
1 neighbor lists, perpetual/occasional/extra = 1 0 0
(1) pair pace, perpetual
attributes: full, newton on
pair build: full/bin/atomonly
stencil: full/bin/3d
bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.005 | 4.005 | 4.005 Mbytes
Step Temp E_pair TotEng Press v_delenergy v_delpress
0 300 -945.9873 -936.0989 45359.818 0 -1.4551915e-11
10 280.68558 -945.35055 -936.09878 46326.919 0 2.910383e-11
20 228.73618 -943.63789 -936.09844 48903.598 0 0
30 160.53661 -941.38948 -936.09798 52222.083 0 -2.910383e-11
40 97.732944 -939.31899 -936.09758 55176.875 0 2.1827873e-11
50 59.165961 -938.04759 -936.0974 56850.103 0 -1.4551915e-11
60 53.124678 -937.84857 -936.09751 56878.948 0 7.2759576e-12
70 74.623347 -938.5575 -936.09782 55565.237 0 0
80 109.4762 -939.70663 -936.09815 53665.652 0 2.1827873e-11
90 142.02657 -940.77975 -936.09837 52001.1 0 -1.4551915e-11
100 161.73598 -941.42945 -936.09842 51114.997 0 1.4551915e-11
Loop time of 3.54317 on 4 procs for 100 steps with 256 atoms
Performance: 1.219 ns/day, 19.684 hours/ns, 28.223 timesteps/s
98.7% CPU use with 4 MPI tasks x 1 OpenMP threads
MPI task timing breakdown:
Section | min time | avg time | max time |%varavg| %total
---------------------------------------------------------------
Pair | 3.1375 | 3.3058 | 3.469 | 6.5 | 93.30
Neigh | 0.000284 | 0.00031975 | 0.000352 | 0.0 | 0.01
Comm | 0.071607 | 0.23492 | 0.40336 | 24.6 | 6.63
Output | 0.001189 | 0.0012315 | 0.001347 | 0.2 | 0.03
Modify | 0.000311 | 0.00032725 | 0.000351 | 0.0 | 0.01
Other | | 0.0005298 | | | 0.01
Nlocal: 64.0000 ave 71 max 57 min
Histogram: 1 0 0 0 1 1 0 0 0 1
Nghost: 1373.00 ave 1380 max 1366 min
Histogram: 1 0 0 0 1 1 0 0 0 1
Neighs: 0.00000 ave 0 max 0 min
Histogram: 4 0 0 0 0 0 0 0 0 0
FullNghs: 10779.5 ave 11978 max 9604 min
Histogram: 1 0 0 0 1 1 0 0 0 1
Total # of neighbors = 43118
Ave neighs/atom = 168.42969
Neighbor list builds = 1
Dangerous builds = 0
Total wall time: 0:00:03

108
examples/USER/pace/log.03Feb2021.pace.recursive.g++.1 Normal file
View File

@ -0,0 +1,108 @@
LAMMPS (24 Dec 2020)
OMP_NUM_THREADS environment is not set. Defaulting to 1 thread. (src/comm.cpp:94)
using 1 OpenMP thread(s) per MPI task
# simple test of fcc Cu with ACE recursive
units metal
atom_style atomic
neighbor 0.3 bin
neigh_modify every 2 delay 10 check yes
variable a equal 3.597
lattice fcc $a
lattice fcc 3.597
Lattice spacing in x,y,z = 3.5970000 3.5970000 3.5970000
region box block 0 4 0 4 0 4
create_box 1 box
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (14.388000 14.388000 14.388000)
1 by 1 by 1 MPI processor grid
create_atoms 1 box
Created 256 atoms
create_atoms CPU = 0.000 seconds
mass 1 26.98
group Al type 1
256 atoms in group Al
pair_style pace recursive
ACE version: 2021.2.3
Recursive evaluator is used
pair_coeff * * Cu-PBE-core-rep.ace Cu
Loading Cu-PBE-core-rep.ace
Total number of basis functions
Cu: 16 (r=1) 726 (r>1)
Mapping LAMMPS atom type #1(Cu) -> ACE species type #0
velocity all create 300 8728 loop geom
timestep 0.0005
fix 1 all nve
compute eatom all pe/atom
compute energy all reduce sum c_eatom
variable delenergy equal c_energy-pe
compute satom all stress/atom NULL
compute str all reduce sum c_satom[1] c_satom[2] c_satom[3]
variable delpress equal -(c_str[1]+c_str[2]+c_str[3])/(3*vol)-press
thermo 10
thermo_style custom step temp epair etotal press v_delenergy v_delpress
run 100
Neighbor list info ...
update every 2 steps, delay 10 steps, check yes
max neighbors/atom: 2000, page size: 100000
master list distance cutoff = 7.7
ghost atom cutoff = 7.7
binsize = 3.85, bins = 4 4 4
1 neighbor lists, perpetual/occasional/extra = 1 0 0
(1) pair pace, perpetual
attributes: full, newton on
pair build: full/bin/atomonly
stencil: full/bin/3d
bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.036 | 4.036 | 4.036 Mbytes
Step Temp E_pair TotEng Press v_delenergy v_delpress
0 300 -945.9873 -936.0989 45359.818 0 0
10 280.68558 -945.35055 -936.09878 46326.919 0 5.8207661e-11
20 228.73618 -943.63789 -936.09844 48903.598 0 1.4551915e-11
30 160.53661 -941.38948 -936.09798 52222.083 0 7.2759576e-11
40 97.732944 -939.31899 -936.09758 55176.875 0 -5.8207661e-11
50 59.165961 -938.04759 -936.0974 56850.103 0 0
60 53.124678 -937.84857 -936.09751 56878.948 0 8.7311491e-11
70 74.623347 -938.5575 -936.09782 55565.237 0 -1.4551915e-11
80 109.4762 -939.70663 -936.09815 53665.652 0 2.1827873e-11
90 142.02657 -940.77975 -936.09837 52001.1 0 2.910383e-11
100 161.73598 -941.42945 -936.09842 51114.997 0 0
Loop time of 9.31437 on 1 procs for 100 steps with 256 atoms
Performance: 0.464 ns/day, 51.746 hours/ns, 10.736 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads
MPI task timing breakdown:
Section | min time | avg time | max time |%varavg| %total
---------------------------------------------------------------
Pair | 9.3103 | 9.3103 | 9.3103 | 0.0 | 99.96
Neigh | 0.001214 | 0.001214 | 0.001214 | 0.0 | 0.01
Comm | 0.001176 | 0.001176 | 0.001176 | 0.0 | 0.01
Output | 0.000827 | 0.000827 | 0.000827 | 0.0 | 0.01
Modify | 0.000479 | 0.000479 | 0.000479 | 0.0 | 0.01
Other | | 0.000363 | | | 0.00
Nlocal: 256.000 ave 256 max 256 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost: 2201.00 ave 2201 max 2201 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs: 0.00000 ave 0 max 0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs: 43118.0 ave 43118 max 43118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Total # of neighbors = 43118
Ave neighs/atom = 168.42969
Neighbor list builds = 1
Dangerous builds = 0
Total wall time: 0:00:09

108
examples/USER/pace/log.03Feb2021.pace.recursive.g++.4 Normal file
View File

@ -0,0 +1,108 @@
LAMMPS (24 Dec 2020)
OMP_NUM_THREADS environment is not set. Defaulting to 1 thread. (src/comm.cpp:94)
using 1 OpenMP thread(s) per MPI task
# simple test of fcc Cu with ACE recursive
units metal
atom_style atomic
neighbor 0.3 bin
neigh_modify every 2 delay 10 check yes
variable a equal 3.597
lattice fcc $a
lattice fcc 3.597
Lattice spacing in x,y,z = 3.5970000 3.5970000 3.5970000
region box block 0 4 0 4 0 4
create_box 1 box
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (14.388000 14.388000 14.388000)
1 by 2 by 2 MPI processor grid
create_atoms 1 box
Created 256 atoms
create_atoms CPU = 0.000 seconds
mass 1 26.98
group Al type 1
256 atoms in group Al
pair_style pace recursive
ACE version: 2021.2.3
Recursive evaluator is used
pair_coeff * * Cu-PBE-core-rep.ace Cu
Loading Cu-PBE-core-rep.ace
Total number of basis functions
Cu: 16 (r=1) 726 (r>1)
Mapping LAMMPS atom type #1(Cu) -> ACE species type #0
velocity all create 300 8728 loop geom
timestep 0.0005
fix 1 all nve
compute eatom all pe/atom
compute energy all reduce sum c_eatom
variable delenergy equal c_energy-pe
compute satom all stress/atom NULL
compute str all reduce sum c_satom[1] c_satom[2] c_satom[3]
variable delpress equal -(c_str[1]+c_str[2]+c_str[3])/(3*vol)-press
thermo 10
thermo_style custom step temp epair etotal press v_delenergy v_delpress
run 100
Neighbor list info ...
update every 2 steps, delay 10 steps, check yes
max neighbors/atom: 2000, page size: 100000
master list distance cutoff = 7.7
ghost atom cutoff = 7.7
binsize = 3.85, bins = 4 4 4
1 neighbor lists, perpetual/occasional/extra = 1 0 0
(1) pair pace, perpetual
attributes: full, newton on
pair build: full/bin/atomonly
stencil: full/bin/3d
bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.005 | 4.005 | 4.005 Mbytes
Step Temp E_pair TotEng Press v_delenergy v_delpress
0 300 -945.9873 -936.0989 45359.818 0 -5.0931703e-11
10 280.68558 -945.35055 -936.09878 46326.919 0 1.4551915e-11
20 228.73618 -943.63789 -936.09844 48903.598 0 0
30 160.53661 -941.38948 -936.09798 52222.083 0 -2.910383e-11
40 97.732944 -939.31899 -936.09758 55176.875 0 0
50 59.165961 -938.04759 -936.0974 56850.103 0 -2.910383e-11
60 53.124678 -937.84857 -936.09751 56878.948 0 1.4551915e-11
70 74.623347 -938.5575 -936.09782 55565.237 0 3.6379788e-11
80 109.4762 -939.70663 -936.09815 53665.652 0 -7.2759576e-12
90 142.02657 -940.77975 -936.09837 52001.1 0 -2.910383e-11
100 161.73598 -941.42945 -936.09842 51114.997 0 7.2759576e-12
Loop time of 2.91339 on 4 procs for 100 steps with 256 atoms
Performance: 1.483 ns/day, 16.185 hours/ns, 34.324 timesteps/s
98.9% CPU use with 4 MPI tasks x 1 OpenMP threads
MPI task timing breakdown:
Section | min time | avg time | max time |%varavg| %total
---------------------------------------------------------------
Pair | 2.5753 | 2.723 | 2.8656 | 6.3 | 93.46
Neigh | 0.000308 | 0.000365 | 0.00046 | 0.0 | 0.01
Comm | 0.045106 | 0.18792 | 0.33552 | 24.1 | 6.45
Output | 0.001213 | 0.001259 | 0.001388 | 0.2 | 0.04
Modify | 0.000304 | 0.00033 | 0.00037 | 0.0 | 0.01
Other | | 0.0005595 | | | 0.02
Nlocal: 64.0000 ave 71 max 57 min
Histogram: 1 0 0 0 1 1 0 0 0 1
Nghost: 1373.00 ave 1380 max 1366 min
Histogram: 1 0 0 0 1 1 0 0 0 1
Neighs: 0.00000 ave 0 max 0 min
Histogram: 4 0 0 0 0 0 0 0 0 0
FullNghs: 10779.5 ave 11978 max 9604 min
Histogram: 1 0 0 0 1 1 0 0 0 1
Total # of neighbors = 43118
Ave neighs/atom = 168.42969
Neighbor list builds = 1
Dangerous builds = 0
Total wall time: 0:00:03

15
examples/plugins/helloplugin.cpp
View File

@ -2,16 +2,16 @@
#include "lammpsplugin.h"
#include "comm.h"
#include "command.h"
#include "error.h"
#include "pointers.h"
#include "version.h"
#include <cstring>
namespace LAMMPS_NS {
class Hello : protected Pointers {
class Hello : public Command {
public:
Hello(class LAMMPS *lmp) : Pointers(lmp) {};
Hello(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
};
}
@ -25,10 +25,9 @@ void Hello::command(int argc, char **argv)
utils::logmesg(lmp,fmt::format("Hello, {}!\n",argv[0]));
}
static void hellocreator(LAMMPS *lmp, int argc, char **argv)
static Command *hellocreator(LAMMPS *lmp)
{
Hello hello(lmp);
hello.command(argc,argv);
return new Hello(lmp);
}
extern "C" void lammpsplugin_init(void *lmp, void *handle, void *regfunc)
@ -39,9 +38,9 @@ extern "C" void lammpsplugin_init(void *lmp, void *handle, void *regfunc)
plugin.version = LAMMPS_VERSION;
plugin.style = "command";
plugin.name = "hello";
plugin.info = "Hello world command v1.0";
plugin.info = "Hello world command v1.1";
plugin.author = "Axel Kohlmeyer (akohlmey@gmail.com)";
plugin.creator.v3 = (lammpsplugin_factory3 *) &hellocreator;
plugin.creator.v1 = (lammpsplugin_factory1 *) &hellocreator;
plugin.handle = handle;
(*register_plugin)(&plugin,lmp);
}

2
lib/pace/.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
/src
/libpace.a

105
lib/pace/Install.py Normal file
View File

@ -0,0 +1,105 @@
# TODO#!/usr/bin/env python
"""
Install.py tool to download, compile, and setup the pace library
used to automate the steps described in the README file in this dir
"""
from __future__ import print_function
import sys, os, subprocess, shutil
from argparse import ArgumentParser
sys.path.append('..')
from install_helpers import fullpath, geturl, checkmd5sum
# settings
thisdir = fullpath('.')
version = 'v.2021.4.9'
# known checksums for different PACE versions. used to validate the download.
checksums = { \
'v.2021.2.3.upd2' : '8fd1162724d349b930e474927197f20d',
'v.2021.4.9' : '4db54962fbd6adcf8c18d46e1798ceb5',
}
parser = ArgumentParser(prog='Install.py',
description="LAMMPS library build wrapper script")
# help message
HELP = """
Syntax from src dir: make lib-pace args="-b"
or: make lib-pace args="-b -v version"
Syntax from lib dir: python Install.py -b
or: python Install.py -b -v version
Examples:
make lib-pace args="-b" # install default version of PACE lib
make lib-pace args="-b -v version" # install specified version of PACE lib
"""
pgroup = parser.add_mutually_exclusive_group()
pgroup.add_argument("-b", "--build", action="store_true",
help="download and build base PACE library")
parser.add_argument("-v", "--version", default=version, choices=checksums.keys(),
help="set version of PACE library to download and build (default: %s)" % version)
parser.add_argument("-vv", "--verbose", action="store_true",
help="be more verbose about is happening while this script runs")
args = parser.parse_args()
# print help message and exit, if neither build nor path options are given
if not args.build:
parser.print_help()
sys.exit(HELP)
buildflag = args.build
verboseflag = args.verbose
version = args.version
archive_extension = "tar.gz"
url = "https://github.com/ICAMS/lammps-user-pace/archive/refs/tags/%s.%s" % (version, archive_extension)
unarchived_folder_name = "lammps-user-pace-%s"%(version)
# download PACE tarball, unpack, build PACE
if buildflag:
# download entire tarball
print("Downloading pace tarball ...")
archive_filename = "%s.%s" % (version, archive_extension)
download_filename = "%s/%s" % (thisdir, archive_filename)
print("Downloading from ",url," to ",download_filename, end=" ")
geturl(url, download_filename)
print(" done")
# verify downloaded archive integrity via md5 checksum, if known.
if version in checksums:
if not checkmd5sum(checksums[version], archive_filename):
sys.exit("Checksum for pace library does not match")
print("Unpacking pace tarball ...")
src_folder = thisdir+"/src"
cmd = 'cd "%s"; rm -rf "%s"; tar -xvf %s; mv %s %s' % (thisdir, src_folder, archive_filename, unarchived_folder_name, src_folder)
subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)
# build
print("Building libpace ...")
cmd = 'make lib -j2'
txt = subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)
if verboseflag:
print(txt.decode("UTF-8"))
# remove source files
print("Removing pace build files and archive ...")
cmd = 'rm %s; make clean-build' % (download_filename)
subprocess.check_output(cmd, stderr=subprocess.STDOUT, shell=True)

37
lib/pace/Makefile Normal file
View File

@ -0,0 +1,37 @@
SHELL = /bin/sh
# ------ FILES ------
SRC_FILES = $(wildcard src/USER-PACE/*.cpp)
SRC = $(filter-out src/USER-PACE/pair_pace.cpp, $(SRC_FILES))
# ------ DEFINITIONS ------
LIB = libpace.a
OBJ = $(SRC:.cpp=.o)
# ------ SETTINGS ------
CXXFLAGS = -O3 -fPIC -Isrc/USER-PACE
ARCHIVE = ar
ARCHFLAG = -rc
USRLIB =
SYSLIB =
# ------ MAKE PROCEDURE ------
lib: $(OBJ)
$(ARCHIVE) $(ARFLAGS) $(LIB) $(OBJ)
# ------ COMPILE RULES ------
%.o: %.cpp
$(CXX) $(CXXFLAGS) -c $< -o $@
# ------ CLEAN ------
clean-all:
-rm -f *~ $(OBJ) $(LIB)
clean-build:
-rm -f *~ $(OBJ)

3
lib/pace/Makefile.lammps Normal file
View File

@ -0,0 +1,3 @@
pace_SYSINC =-I../../lib/pace/src/USER-PACE
pace_SYSLIB = -L../../lib/pace/ -lpace
pace_SYSPATH =

18
lib/pace/README Normal file
View File

@ -0,0 +1,18 @@
This directory contains files required to use the USER-PACE package,
which provides the pace pair style, an efficient implementation of
the Atomic Cluster Expansion potential (ACE).
ACE is a methodology for deriving a highly accurate classical potential
fit to a large archive of quantum mechanical (DFT) data.
This package was written by Yury Lysogorskiy and others
at ICAMS, the Interdisciplinary Centre for Advanced Materials Simulation,
Ruhr University Bochum, Germany, http://www.icams.de
You can type "make lib-pace" from the src directory to see help on
how to download and build this library via make commands, or you can
do the same thing by typing "python Install.py" from within this
directory.
More information about the USER-PACE implementation of ACE
is available here:
https://github.com/ICAMS/lammps-user-pace

5
lib/plumed/Install.py
View File

@ -17,7 +17,7 @@ parser = ArgumentParser(prog='Install.py',
# settings
version = "2.7.0"
version = "2.7.1"
mode = "static"
# help message
@ -47,9 +47,12 @@ checksums = { \
'2.5.2' : 'bd2f18346c788eb54e1e52f4f6acf41a', \
'2.5.3' : 'de30d6e7c2dcc0973298e24a6da24286', \
'2.5.4' : 'f31b7d16a4be2e30aa7d5c19c3d37853', \
'2.5.7' : '1ca36226fdb8110b1009aa61d615d4e5', \
'2.6.0' : '204d2edae58d9b10ba3ad460cad64191', \
'2.6.1' : '89a9a450fc6025299fe16af235957163', \
'2.6.3' : 'a9f8028fd74528c2024781ea1fdefeee', \
'2.7.0' : '95f29dd0c067577f11972ff90dfc7d12', \
'2.7.1' : '4eac6a462ec84dfe0cec96c82421b8e8', \
}
# parse and process arguments

8982
potentials/Cu-PBE-core-rep.ace Normal file
View File

File diff suppressed because it is too large Load Diff

8
python/install.py
View File

@ -10,7 +10,7 @@ build target in the conventional and CMake based build systems
# copy LAMMPS shared library and lammps package to system dirs
from __future__ import print_function
import sys,os,shutil
import sys,os,shutil,time
from argparse import ArgumentParser
parser = ArgumentParser(prog='install.py',
@ -80,13 +80,15 @@ if args.dir:
sys.exit()
# extract version string from header
# extract LAMMPS version string from header
# and convert to python packaging compatible version
def get_lammps_version(header):
with open(header, 'r') as f:
line = f.readline()
start_pos = line.find('"')+1
end_pos = line.find('"', start_pos)
return "".join(line[start_pos:end_pos].split())
t = time.strptime("".join(line[start_pos:end_pos].split()), "%d%b%Y")
return "{}.{}.{}".format(t.tm_year,t.tm_mon,t.tm_mday)
verstr = get_lammps_version(args.version)

10
python/lammps/__init__.py
View File

@ -13,10 +13,16 @@ from .core import *
from .data import *
from .pylammps import *
# convert module string version to numeric version
# convert installed module string version to numeric version
def get_version_number():
import time
from os.path import join
from sys import version_info
# must report 0 when inside LAMMPS source tree
if __file__.find(join('python', 'lammps', '__init__.py')) > 0:
return 0
vstring = None
if version_info.major == 3 and version_info.minor >= 8:
from importlib.metadata import version
@ -32,7 +38,7 @@ def get_version_number():
if not vstring:
return 0
t = time.strptime(vstring, "%d%b%Y")
t = time.strptime(vstring, "%Y.%m.%d")
return t.tm_year*10000 + t.tm_mon*100 + t.tm_mday
__version__ = get_version_number()

13
python/setup.py
View File

@ -1,7 +1,8 @@
# this only installs the LAMMPS python package
# it assumes the LAMMPS shared library is already installed
from distutils.core import setup
import os
from sys import version_info
import os,time
LAMMPS_PYTHON_DIR = os.path.dirname(os.path.realpath(__file__))
LAMMPS_DIR = os.path.dirname(LAMMPS_PYTHON_DIR)
@ -12,7 +13,13 @@ def get_lammps_version():
line = f.readline()
start_pos = line.find('"')+1
end_pos = line.find('"', start_pos)
return "".join(line[start_pos:end_pos].split())
t = time.strptime("".join(line[start_pos:end_pos].split()), "%d%b%Y")
return "{}.{}.{}".format(t.tm_year,t.tm_mon,t.tm_mday)
if version_info.major >= 3:
pkgs = ['lammps', 'lammps.mliap']
else:
pkgs = ['lammps']
setup(
name = "lammps",
@ -22,5 +29,5 @@ setup(
url = "https://lammps.sandia.gov",
description = "LAMMPS Molecular Dynamics Python package",
license = "GPL",
packages=["lammps","lammps.mliap"],
packages=pkgs,
)

3
src/.gitignore vendored
View File

@ -32,6 +32,9 @@
/pair_kim.cpp
/pair_kim.h
/pair_pace.cpp
/pair_pace.h
/superpose3d.h
/kokkos.cpp

122
src/COMPRESS/dump_atom_gz.cpp
View File

@ -11,24 +11,18 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "dump_atom_gz.h"
#include "domain.h"
#include "dump_atom_gz.h"
#include "error.h"
#include "update.h"
#include <cstring>
using namespace LAMMPS_NS;
DumpAtomGZ::DumpAtomGZ(LAMMPS *lmp, int narg, char **arg) :
DumpAtom(lmp, narg, arg)
{
gzFp = nullptr;
compression_level = Z_BEST_COMPRESSION;
if (!compressed)
error->all(FLERR,"Dump atom/gz only writes compressed files");
}
@ -37,9 +31,6 @@ DumpAtomGZ::DumpAtomGZ(LAMMPS *lmp, int narg, char **arg) :
DumpAtomGZ::~DumpAtomGZ()
{
if (gzFp) gzclose(gzFp);
gzFp = nullptr;
fp = nullptr;
}
/* ----------------------------------------------------------------------
@ -80,7 +71,9 @@ void DumpAtomGZ::openfile()
nameslist[numfiles] = utils::strdup(filecurrent);
++numfiles;
} else {
remove(nameslist[fileidx]);
if (remove(nameslist[fileidx]) != 0) {
error->warning(FLERR, fmt::format("Could not delete {}", nameslist[fileidx]));
}
delete[] nameslist[fileidx];
nameslist[fileidx] = utils::strdup(filecurrent);
fileidx = (fileidx + 1) % maxfiles;
@ -91,17 +84,12 @@ void DumpAtomGZ::openfile()
// each proc with filewriter = 1 opens a file
if (filewriter) {
std::string mode;
if (append_flag) {
mode = fmt::format("ab{}", compression_level);
} else {
mode = fmt::format("wb{}", compression_level);
try {
writer.open(filecurrent, append_flag);
} catch (FileWriterException &e) {
error->one(FLERR, e.what());
}
gzFp = gzopen(filecurrent, mode.c_str());
if (gzFp == nullptr) error->one(FLERR,"Cannot open dump file");
} else gzFp = nullptr;
}
// delete string with timestep replaced
@ -112,29 +100,34 @@ void DumpAtomGZ::openfile()
void DumpAtomGZ::write_header(bigint ndump)
{
std::string header;
if ((multiproc) || (!multiproc && me == 0)) {
if (unit_flag && !unit_count) {
++unit_count;
gzprintf(gzFp,"ITEM: UNITS\n%s\n",update->unit_style);
header = fmt::format("ITEM: UNITS\n{}\n",update->unit_style);
}
if (time_flag) gzprintf(gzFp,"ITEM: TIME\n%.16g\n",compute_time());
gzprintf(gzFp,"ITEM: TIMESTEP\n");
gzprintf(gzFp,BIGINT_FORMAT "\n",update->ntimestep);
gzprintf(gzFp,"ITEM: NUMBER OF ATOMS\n");
gzprintf(gzFp,BIGINT_FORMAT "\n",ndump);
if (domain->triclinic == 0) {
gzprintf(gzFp,"ITEM: BOX BOUNDS %s\n",boundstr);
gzprintf(gzFp,"%-1.16e %-1.16e\n",boxxlo,boxxhi);
gzprintf(gzFp,"%-1.16e %-1.16e\n",boxylo,boxyhi);
gzprintf(gzFp,"%-1.16e %-1.16e\n",boxzlo,boxzhi);
} else {
gzprintf(gzFp,"ITEM: BOX BOUNDS xy xz yz %s\n",boundstr);
gzprintf(gzFp,"%-1.16e %-1.16e %-1.16e\n",boxxlo,boxxhi,boxxy);
gzprintf(gzFp,"%-1.16e %-1.16e %-1.16e\n",boxylo,boxyhi,boxxz);
gzprintf(gzFp,"%-1.16e %-1.16e %-1.16e\n",boxzlo,boxzhi,boxyz);
if (time_flag) {
header += fmt::format("ITEM: TIME\n{0:.16g}\n", compute_time());
}
gzprintf(gzFp,"ITEM: ATOMS %s\n",columns);
header += fmt::format("ITEM: TIMESTEP\n{}\n", update->ntimestep);
header += fmt::format("ITEM: NUMBER OF ATOMS\n{}\n", ndump);
if (domain->triclinic == 0) {
header += fmt::format("ITEM: BOX BOUNDS {}\n", boundstr);
header += fmt::format("{0:-1.16e} {1:-1.16e}\n", boxxlo, boxxhi);
header += fmt::format("{0:-1.16e} {1:-1.16e}\n", boxylo, boxyhi);
header += fmt::format("{0:-1.16e} {1:-1.16e}\n", boxzlo, boxzhi);
} else {
header += fmt::format("ITEM: BOX BOUNDS xy xz yz {}\n", boundstr);
header += fmt::format("{0:-1.16e} {1:-1.16e} {2:-1.16e}\n", boxxlo, boxxhi, boxxy);
header += fmt::format("{0:-1.16e} {1:-1.16e} {2:-1.16e}\n", boxylo, boxyhi, boxxz);
header += fmt::format("{0:-1.16e} {1:-1.16e} {2:-1.16e}\n", boxzlo, boxzhi, boxyz);
}
header += fmt::format("ITEM: ATOMS {}\n", columns);
writer.write(header.c_str(), header.length());
}
}
@ -142,7 +135,33 @@ void DumpAtomGZ::write_header(bigint ndump)
void DumpAtomGZ::write_data(int n, double *mybuf)
{
gzwrite(gzFp,mybuf,sizeof(char)*n);
if (buffer_flag == 1) {
writer.write(mybuf, n);
} else {
constexpr size_t VBUFFER_SIZE = 256;
char vbuffer[VBUFFER_SIZE];
int m = 0;
for (int i = 0; i < n; i++) {
int written = 0;
if (image_flag == 1) {
written = snprintf(vbuffer, VBUFFER_SIZE, format,
static_cast<tagint> (mybuf[m]), static_cast<int> (mybuf[m+1]),
mybuf[m+2],mybuf[m+3],mybuf[m+4], static_cast<int> (mybuf[m+5]),
static_cast<int> (mybuf[m+6]), static_cast<int> (mybuf[m+7]));
} else {
written = snprintf(vbuffer, VBUFFER_SIZE, format,
static_cast<tagint> (mybuf[m]), static_cast<int> (mybuf[m+1]),
mybuf[m+2],mybuf[m+3],mybuf[m+4]);
}
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump atom/gz output");
}
m += size_one;
}
}
}
/* ---------------------------------------------------------------------- */
@ -152,11 +171,11 @@ void DumpAtomGZ::write()
DumpAtom::write();
if (filewriter) {
if (multifile) {
gzclose(gzFp);
gzFp = nullptr;
writer.close();
} else {
if (flush_flag)
gzflush(gzFp,Z_SYNC_FLUSH);
if (flush_flag && writer.isopen()) {
writer.flush();
}
}
}
}
@ -167,14 +186,15 @@ int DumpAtomGZ::modify_param(int narg, char **arg)
{
int consumed = DumpAtom::modify_param(narg, arg);
if (consumed == 0) {
if (strcmp(arg[0],"compression_level") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
int min_level = Z_DEFAULT_COMPRESSION;
int max_level = Z_BEST_COMPRESSION;
compression_level = utils::inumeric(FLERR, arg[1], false, lmp);
if (compression_level < min_level || compression_level > max_level)
error->all(FLERR, fmt::format("Illegal dump_modify command: compression level must in the range of [{}, {}]", min_level, max_level));
return 2;
try {
if (strcmp(arg[0],"compression_level") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
int compression_level = utils::inumeric(FLERR, arg[1], false, lmp);
writer.setCompressionLevel(compression_level);
return 2;
}
} catch (FileWriterException &e) {
error->one(FLERR, fmt::format("Illegal dump_modify command: {}", e.what()));
}
}
return consumed;

5
src/COMPRESS/dump_atom_gz.h
View File

@ -21,7 +21,7 @@ DumpStyle(atom/gz,DumpAtomGZ)
#define LMP_DUMP_ATOM_GZ_H
#include "dump_atom.h"
#include <zlib.h>
#include "gz_file_writer.h"
namespace LAMMPS_NS {
@ -31,8 +31,7 @@ class DumpAtomGZ : public DumpAtom {
virtual ~DumpAtomGZ();
protected:
int compression_level;
gzFile gzFp; // file pointer for the compressed output stream
GzFileWriter writer;
virtual void openfile();
virtual void write_header(bigint);

42
src/COMPRESS/dump_atom_zstd.cpp
View File

@ -43,7 +43,7 @@ DumpAtomZstd::~DumpAtomZstd()
/* ----------------------------------------------------------------------
generic opening of a dump file
ASCII or binary or zstdipped
ASCII or binary or compressed
some derived classes override this function
------------------------------------------------------------------------- */
@ -79,7 +79,9 @@ void DumpAtomZstd::openfile()
nameslist[numfiles] = utils::strdup(filecurrent);
++numfiles;
} else {
remove(nameslist[fileidx]);
if (remove(nameslist[fileidx]) != 0) {
error->warning(FLERR, fmt::format("Could not delete {}", nameslist[fileidx]));
}
delete[] nameslist[fileidx];
nameslist[fileidx] = utils::strdup(filecurrent);
fileidx = (fileidx + 1) % maxfiles;
@ -90,12 +92,8 @@ void DumpAtomZstd::openfile()
// each proc with filewriter = 1 opens a file
if (filewriter) {
if (append_flag) {
error->one(FLERR, "dump/zstd currently doesn't support append");
}
try {
writer.open(filecurrent);
writer.open(filecurrent, append_flag);
} catch (FileWriterException &e) {
error->one(FLERR, e.what());
}
@ -145,7 +143,33 @@ void DumpAtomZstd::write_header(bigint ndump)
void DumpAtomZstd::write_data(int n, double *mybuf)
{
writer.write(mybuf, n);
if (buffer_flag == 1) {
writer.write(mybuf, n);
} else {
constexpr size_t VBUFFER_SIZE = 256;
char vbuffer[VBUFFER_SIZE];
int m = 0;
for (int i = 0; i < n; i++) {
int written = 0;
if (image_flag == 1) {
written = snprintf(vbuffer, VBUFFER_SIZE, format,
static_cast<tagint> (mybuf[m]), static_cast<int> (mybuf[m+1]),
mybuf[m+2],mybuf[m+3],mybuf[m+4], static_cast<int> (mybuf[m+5]),
static_cast<int> (mybuf[m+6]), static_cast<int> (mybuf[m+7]));
} else {
written = snprintf(vbuffer, VBUFFER_SIZE, format,
static_cast<tagint> (mybuf[m]), static_cast<int> (mybuf[m+1]),
mybuf[m+2],mybuf[m+3],mybuf[m+4]);
}
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump atom/gz output");
}
m += size_one;
}
}
}
/* ---------------------------------------------------------------------- */
@ -184,7 +208,7 @@ int DumpAtomZstd::modify_param(int narg, char **arg)
return 2;
}
} catch (FileWriterException &e) {
error->one(FLERR, e.what());
error->one(FLERR, fmt::format("Illegal dump_modify command: {}", e.what()));
}
}
return consumed;

157
src/COMPRESS/dump_cfg_gz.cpp
View File

@ -11,41 +11,30 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "dump_cfg_gz.h"
#include "atom.h"
#include "domain.h"
#include "dump_cfg_gz.h"
#include "error.h"
#include "update.h"
#include <cstring>
using namespace LAMMPS_NS;
#define UNWRAPEXPAND 10.0
DumpCFGGZ::DumpCFGGZ(LAMMPS *lmp, int narg, char **arg) :
DumpCFG(lmp, narg, arg)
{
gzFp = nullptr;
compression_level = Z_BEST_COMPRESSION;
if (!compressed)
error->all(FLERR,"Dump cfg/gz only writes compressed files");
}
/* ---------------------------------------------------------------------- */
DumpCFGGZ::~DumpCFGGZ()
{
if (gzFp) gzclose(gzFp);
gzFp = nullptr;
fp = nullptr;
}
/* ----------------------------------------------------------------------
generic opening of a dump file
ASCII or binary or gzipped
@ -84,7 +73,9 @@ void DumpCFGGZ::openfile()
nameslist[numfiles] = utils::strdup(filecurrent);
++numfiles;
} else {
remove(nameslist[fileidx]);
if (remove(nameslist[fileidx]) != 0) {
error->warning(FLERR, fmt::format("Could not delete {}", nameslist[fileidx]));
}
delete[] nameslist[fileidx];
nameslist[fileidx] = utils::strdup(filecurrent);
fileidx = (fileidx + 1) % maxfiles;
@ -95,17 +86,12 @@ void DumpCFGGZ::openfile()
// each proc with filewriter = 1 opens a file
if (filewriter) {
std::string mode;
if (append_flag) {
mode = fmt::format("ab{}", compression_level);
} else {
mode = fmt::format("wb{}", compression_level);
try {
writer.open(filecurrent, append_flag);
} catch (FileWriterException &e) {
error->one(FLERR, e.what());
}
gzFp = gzopen(filecurrent, mode.c_str());
if (gzFp == nullptr) error->one(FLERR,"Cannot open dump file");
} else gzFp = nullptr;
}
// delete string with timestep replaced
@ -127,30 +113,95 @@ void DumpCFGGZ::write_header(bigint n)
if (atom->peri_flag) scale = atom->pdscale;
else if (unwrapflag == 1) scale = UNWRAPEXPAND;
char str[64];
sprintf(str,"Number of particles = %s\n",BIGINT_FORMAT);
gzprintf(gzFp,str,n);
gzprintf(gzFp,"A = %g Angstrom (basic length-scale)\n",scale);
gzprintf(gzFp,"H0(1,1) = %g A\n",domain->xprd);
gzprintf(gzFp,"H0(1,2) = 0 A \n");
gzprintf(gzFp,"H0(1,3) = 0 A \n");
gzprintf(gzFp,"H0(2,1) = %g A \n",domain->xy);
gzprintf(gzFp,"H0(2,2) = %g A\n",domain->yprd);
gzprintf(gzFp,"H0(2,3) = 0 A \n");
gzprintf(gzFp,"H0(3,1) = %g A \n",domain->xz);
gzprintf(gzFp,"H0(3,2) = %g A \n",domain->yz);
gzprintf(gzFp,"H0(3,3) = %g A\n",domain->zprd);
gzprintf(gzFp,".NO_VELOCITY.\n");
gzprintf(gzFp,"entry_count = %d\n",nfield-2);
std::string header = fmt::format("Number of particles = {}\n", n);
header += fmt::format("A = {0:g} Angstrom (basic length-scale)\n", scale);
header += fmt::format("H0(1,1) = {0:g} A\n",domain->xprd);
header += fmt::format("H0(1,2) = 0 A \n");
header += fmt::format("H0(1,3) = 0 A \n");
header += fmt::format("H0(2,1) = {0:g} A \n",domain->xy);
header += fmt::format("H0(2,2) = {0:g} A\n",domain->yprd);
header += fmt::format("H0(2,3) = 0 A \n");
header += fmt::format("H0(3,1) = {0:g} A \n",domain->xz);
header += fmt::format("H0(3,2) = {0:g} A \n",domain->yz);
header += fmt::format("H0(3,3) = {0:g} A\n",domain->zprd);
header += fmt::format(".NO_VELOCITY.\n");
header += fmt::format("entry_count = {}\n",nfield-2);
for (int i = 0; i < nfield-5; i++)
gzprintf(gzFp,"auxiliary[%d] = %s\n",i,auxname[i]);
header += fmt::format("auxiliary[{}] = {}\n",i,auxname[i]);
writer.write(header.c_str(), header.length());
}
/* ---------------------------------------------------------------------- */
void DumpCFGGZ::write_data(int n, double *mybuf)
{
gzwrite(gzFp,mybuf,sizeof(char)*n);
if (buffer_flag) {
writer.write(mybuf, n);
} else {
constexpr size_t VBUFFER_SIZE = 256;
char vbuffer[VBUFFER_SIZE];
if (unwrapflag == 0) {
int m = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < size_one; j++) {
int written = 0;
if (j == 0) {
written = snprintf(vbuffer, VBUFFER_SIZE, "%f \n", mybuf[m]);
} else if (j == 1) {
written = snprintf(vbuffer, VBUFFER_SIZE, "%s \n", typenames[(int) mybuf[m]]);
} else if (j >= 2) {
if (vtype[j] == Dump::INT)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<int> (mybuf[m]));
else if (vtype[j] == Dump::DOUBLE)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], mybuf[m]);
else if (vtype[j] == Dump::STRING)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], typenames[(int) mybuf[m]]);
else if (vtype[j] == Dump::BIGINT)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<bigint> (mybuf[m]));
}
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump cfg/gz output");
}
m++;
}
writer.write("\n", 1);
}
} else if (unwrapflag == 1) {
int m = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < size_one; j++) {
int written = 0;
if (j == 0) {
written = snprintf(vbuffer, VBUFFER_SIZE, "%f \n", mybuf[m]);
} else if (j == 1) {
written = snprintf(vbuffer, VBUFFER_SIZE, "%s \n", typenames[(int) mybuf[m]]);
} else if (j >= 2 && j <= 4) {
double unwrap_coord = (mybuf[m] - 0.5)/UNWRAPEXPAND + 0.5;
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], unwrap_coord);
} else if (j >= 5) {
if (vtype[j] == Dump::INT)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<int> (mybuf[m]));
else if (vtype[j] == Dump::DOUBLE)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], mybuf[m]);
else if (vtype[j] == Dump::STRING)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], typenames[(int) mybuf[m]]);
else if (vtype[j] == Dump::BIGINT)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<bigint> (mybuf[m]));
}
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump cfg/gz output");
}
m++;
}
writer.write("\n", 1);
}
}
}
}
/* ---------------------------------------------------------------------- */
@ -160,11 +211,11 @@ void DumpCFGGZ::write()
DumpCFG::write();
if (filewriter) {
if (multifile) {
gzclose(gzFp);
gzFp = nullptr;
writer.close();
} else {
if (flush_flag)
gzflush(gzFp,Z_SYNC_FLUSH);
if (flush_flag && writer.isopen()) {
writer.flush();
}
}
}
}
@ -175,16 +226,16 @@ int DumpCFGGZ::modify_param(int narg, char **arg)
{
int consumed = DumpCFG::modify_param(narg, arg);
if (consumed == 0) {
if (strcmp(arg[0],"compression_level") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
int min_level = Z_DEFAULT_COMPRESSION;
int max_level = Z_BEST_COMPRESSION;
compression_level = utils::inumeric(FLERR, arg[1], false, lmp);
if (compression_level < min_level || compression_level > max_level)
error->all(FLERR, fmt::format("Illegal dump_modify command: compression level must in the range of [{}, {}]", min_level, max_level));
return 2;
try {
if (strcmp(arg[0],"compression_level") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
int compression_level = utils::inumeric(FLERR, arg[1], false, lmp);
writer.setCompressionLevel(compression_level);
return 2;
}
} catch (FileWriterException &e) {
error->one(FLERR, fmt::format("Illegal dump_modify command: {}", e.what()));
}
}
return consumed;
}

5
src/COMPRESS/dump_cfg_gz.h
View File

@ -21,7 +21,7 @@ DumpStyle(cfg/gz,DumpCFGGZ)
#define LMP_DUMP_CFG_GZ_H
#include "dump_cfg.h"
#include <zlib.h>
#include "gz_file_writer.h"
namespace LAMMPS_NS {
@ -31,8 +31,7 @@ class DumpCFGGZ : public DumpCFG {
virtual ~DumpCFGGZ();
protected:
int compression_level;
gzFile gzFp; // file pointer for the compressed output stream
GzFileWriter writer;
virtual void openfile();
virtual void write_header(bigint);

74
src/COMPRESS/dump_cfg_zstd.cpp
View File

@ -21,7 +21,6 @@
#include "domain.h"
#include "dump_cfg_zstd.h"
#include "error.h"
#include "file_writer.h"
#include "update.h"
#include <cstring>
@ -46,7 +45,7 @@ DumpCFGZstd::~DumpCFGZstd()
/* ----------------------------------------------------------------------
generic opening of a dump file
ASCII or binary or zstdipped
ASCII or binary or compressed
some derived classes override this function
------------------------------------------------------------------------- */
@ -82,7 +81,9 @@ void DumpCFGZstd::openfile()
nameslist[numfiles] = utils::strdup(filecurrent);
++numfiles;
} else {
remove(nameslist[fileidx]);
if (remove(nameslist[fileidx]) != 0) {
error->warning(FLERR, fmt::format("Could not delete {}", nameslist[fileidx]));
}
delete[] nameslist[fileidx];
nameslist[fileidx] = utils::strdup(filecurrent);
fileidx = (fileidx + 1) % maxfiles;
@ -147,7 +148,72 @@ void DumpCFGZstd::write_header(bigint n)
void DumpCFGZstd::write_data(int n, double *mybuf)
{
writer.write(mybuf, n);
if (buffer_flag) {
writer.write(mybuf, n);
} else {
constexpr size_t VBUFFER_SIZE = 256;
char vbuffer[VBUFFER_SIZE];
if (unwrapflag == 0) {
int m = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < size_one; j++) {
int written = 0;
if (j == 0) {
written = snprintf(vbuffer, VBUFFER_SIZE, "%f \n", mybuf[m]);
} else if (j == 1) {
written = snprintf(vbuffer, VBUFFER_SIZE, "%s \n", typenames[(int) mybuf[m]]);
} else if (j >= 2) {
if (vtype[j] == Dump::INT)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<int> (mybuf[m]));
else if (vtype[j] == Dump::DOUBLE)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], mybuf[m]);
else if (vtype[j] == Dump::STRING)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], typenames[(int) mybuf[m]]);
else if (vtype[j] == Dump::BIGINT)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<bigint> (mybuf[m]));
}
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump cfg/gz output");
}
m++;
}
writer.write("\n", 1);
}
} else if (unwrapflag == 1) {
int m = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < size_one; j++) {
int written = 0;
if (j == 0) {
written = snprintf(vbuffer, VBUFFER_SIZE, "%f \n", mybuf[m]);
} else if (j == 1) {
written = snprintf(vbuffer, VBUFFER_SIZE, "%s \n", typenames[(int) mybuf[m]]);
} else if (j >= 2 && j <= 4) {
double unwrap_coord = (mybuf[m] - 0.5)/UNWRAPEXPAND + 0.5;
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], unwrap_coord);
} else if (j >= 5) {
if (vtype[j] == Dump::INT)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<int> (mybuf[m]));
else if (vtype[j] == Dump::DOUBLE)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], mybuf[m]);
else if (vtype[j] == Dump::STRING)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], typenames[(int) mybuf[m]]);
else if (vtype[j] == Dump::BIGINT)
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<bigint> (mybuf[m]));
}
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump cfg/gz output");
}
m++;
}
writer.write("\n", 1);
}
}
}
}
/* ---------------------------------------------------------------------- */

126
src/COMPRESS/dump_custom_gz.cpp
View File

@ -11,39 +11,28 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "dump_custom_gz.h"
#include "domain.h"
#include "dump_custom_gz.h"
#include "error.h"
#include "update.h"
#include <cstring>
using namespace LAMMPS_NS;
DumpCustomGZ::DumpCustomGZ(LAMMPS *lmp, int narg, char **arg) :
DumpCustom(lmp, narg, arg)
{
gzFp = nullptr;
compression_level = Z_BEST_COMPRESSION;
if (!compressed)
error->all(FLERR,"Dump custom/gz only writes compressed files");
}
/* ---------------------------------------------------------------------- */
DumpCustomGZ::~DumpCustomGZ()
{
if (gzFp) gzclose(gzFp);
gzFp = nullptr;
fp = nullptr;
}
/* ----------------------------------------------------------------------
generic opening of a dump file
ASCII or binary or gzipped
@ -82,7 +71,9 @@ void DumpCustomGZ::openfile()
nameslist[numfiles] = utils::strdup(filecurrent);
++numfiles;
} else {
remove(nameslist[fileidx]);
if (remove(nameslist[fileidx]) != 0) {
error->warning(FLERR, fmt::format("Could not delete {}", nameslist[fileidx]));
}
delete[] nameslist[fileidx];
nameslist[fileidx] = utils::strdup(filecurrent);
fileidx = (fileidx + 1) % maxfiles;
@ -93,17 +84,12 @@ void DumpCustomGZ::openfile()
// each proc with filewriter = 1 opens a file
if (filewriter) {
std::string mode;
if (append_flag) {
mode = fmt::format("ab{}", compression_level);
} else {
mode = fmt::format("wb{}", compression_level);
try {
writer.open(filecurrent, append_flag);
} catch (FileWriterException &e) {
error->one(FLERR, e.what());
}
gzFp = gzopen(filecurrent, mode.c_str());
if (gzFp == nullptr) error->one(FLERR,"Cannot open dump file");
} else gzFp = nullptr;
}
// delete string with timestep replaced
@ -112,29 +98,34 @@ void DumpCustomGZ::openfile()
void DumpCustomGZ::write_header(bigint ndump)
{
std::string header;
if ((multiproc) || (!multiproc && me == 0)) {
if (unit_flag && !unit_count) {
++unit_count;
gzprintf(gzFp,"ITEM: UNITS\n%s\n",update->unit_style);
header = fmt::format("ITEM: UNITS\n{}\n",update->unit_style);
}
if (time_flag) gzprintf(gzFp,"ITEM: TIME\n%.16g\n",compute_time());
gzprintf(gzFp,"ITEM: TIMESTEP\n");
gzprintf(gzFp,BIGINT_FORMAT "\n",update->ntimestep);
gzprintf(gzFp,"ITEM: NUMBER OF ATOMS\n");
gzprintf(gzFp,BIGINT_FORMAT "\n",ndump);
if (domain->triclinic == 0) {
gzprintf(gzFp,"ITEM: BOX BOUNDS %s\n",boundstr);
gzprintf(gzFp,"%-1.16e %-1.16e\n",boxxlo,boxxhi);
gzprintf(gzFp,"%-1.16e %-1.16e\n",boxylo,boxyhi);
gzprintf(gzFp,"%-1.16e %-1.16e\n",boxzlo,boxzhi);
} else {
gzprintf(gzFp,"ITEM: BOX BOUNDS xy xz yz %s\n",boundstr);
gzprintf(gzFp,"%-1.16e %-1.16e %-1.16e\n",boxxlo,boxxhi,boxxy);
gzprintf(gzFp,"%-1.16e %-1.16e %-1.16e\n",boxylo,boxyhi,boxxz);
gzprintf(gzFp,"%-1.16e %-1.16e %-1.16e\n",boxzlo,boxzhi,boxyz);
if (time_flag) {
header += fmt::format("ITEM: TIME\n{0:.16g}\n", compute_time());
}
gzprintf(gzFp,"ITEM: ATOMS %s\n",columns);
header += fmt::format("ITEM: TIMESTEP\n{}\n", update->ntimestep);
header += fmt::format("ITEM: NUMBER OF ATOMS\n{}\n", ndump);
if (domain->triclinic == 0) {
header += fmt::format("ITEM: BOX BOUNDS {}\n", boundstr);
header += fmt::format("{0:-1.16e} {1:-1.16e}\n", boxxlo, boxxhi);
header += fmt::format("{0:-1.16e} {1:-1.16e}\n", boxylo, boxyhi);
header += fmt::format("{0:-1.16e} {1:-1.16e}\n", boxzlo, boxzhi);
} else {
header += fmt::format("ITEM: BOX BOUNDS xy xz yz {}\n", boundstr);
header += fmt::format("{0:-1.16e} {1:-1.16e} {2:-1.16e}\n", boxxlo, boxxhi, boxxy);
header += fmt::format("{0:-1.16e} {1:-1.16e} {2:-1.16e}\n", boxylo, boxyhi, boxxz);
header += fmt::format("{0:-1.16e} {1:-1.16e} {2:-1.16e}\n", boxzlo, boxzhi, boxyz);
}
header += fmt::format("ITEM: ATOMS {}\n", columns);
writer.write(header.c_str(), header.length());
}
}
@ -142,7 +133,35 @@ void DumpCustomGZ::write_header(bigint ndump)
void DumpCustomGZ::write_data(int n, double *mybuf)
{
gzwrite(gzFp,mybuf,sizeof(char)*n);
if (buffer_flag == 1) {
writer.write(mybuf, n);
} else {
constexpr size_t VBUFFER_SIZE = 256;
char vbuffer[VBUFFER_SIZE];
int m = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < nfield; j++) {
int written = 0;
if (vtype[j] == Dump::INT) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<int> (mybuf[m]));
} else if (vtype[j] == Dump::DOUBLE) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], mybuf[m]);
} else if (vtype[j] == Dump::STRING) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], typenames[(int) mybuf[m]]);
} else if (vtype[j] == Dump::BIGINT) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<bigint> (mybuf[m]));
}
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump custom/gz output");
}
m++;
}
writer.write("\n", 1);
}
}
}
/* ---------------------------------------------------------------------- */
@ -152,11 +171,11 @@ void DumpCustomGZ::write()
DumpCustom::write();
if (filewriter) {
if (multifile) {
gzclose(gzFp);
gzFp = nullptr;
writer.close();
} else {
if (flush_flag)
gzflush(gzFp,Z_SYNC_FLUSH);
if (flush_flag && writer.isopen()) {
writer.flush();
}
}
}
}
@ -167,14 +186,15 @@ int DumpCustomGZ::modify_param(int narg, char **arg)
{
int consumed = DumpCustom::modify_param(narg, arg);
if (consumed == 0) {
if (strcmp(arg[0],"compression_level") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
int min_level = Z_DEFAULT_COMPRESSION;
int max_level = Z_BEST_COMPRESSION;
compression_level = utils::inumeric(FLERR, arg[1], false, lmp);
if (compression_level < min_level || compression_level > max_level)
error->all(FLERR, fmt::format("Illegal dump_modify command: compression level must in the range of [{}, {}]", min_level, max_level));
return 2;
try {
if (strcmp(arg[0],"compression_level") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
int compression_level = utils::inumeric(FLERR, arg[1], false, lmp);
writer.setCompressionLevel(compression_level);
return 2;
}
} catch (FileWriterException &e) {
error->one(FLERR, fmt::format("Illegal dump_modify command: {}", e.what()));
}
}
return consumed;

5
src/COMPRESS/dump_custom_gz.h
View File

@ -21,7 +21,7 @@ DumpStyle(custom/gz,DumpCustomGZ)
#define LMP_DUMP_CUSTOM_GZ_H
#include "dump_custom.h"
#include <zlib.h>
#include "gz_file_writer.h"
namespace LAMMPS_NS {
@ -31,8 +31,7 @@ class DumpCustomGZ : public DumpCustom {
virtual ~DumpCustomGZ();
protected:
int compression_level;
gzFile gzFp; // file pointer for the compressed output stream
GzFileWriter writer;
virtual void openfile();
virtual void write_header(bigint);

37
src/COMPRESS/dump_custom_zstd.cpp
View File

@ -20,7 +20,6 @@
#include "domain.h"
#include "dump_custom_zstd.h"
#include "error.h"
#include "file_writer.h"
#include "update.h"
#include <cstring>
@ -79,7 +78,9 @@ void DumpCustomZstd::openfile()
nameslist[numfiles] = utils::strdup(filecurrent);
++numfiles;
} else {
remove(nameslist[fileidx]);
if (remove(nameslist[fileidx]) != 0) {
error->warning(FLERR, fmt::format("Could not delete {}", nameslist[fileidx]));
}
delete[] nameslist[fileidx];
nameslist[fileidx] = utils::strdup(filecurrent);
fileidx = (fileidx + 1) % maxfiles;
@ -145,7 +146,35 @@ void DumpCustomZstd::write_header(bigint ndump)
void DumpCustomZstd::write_data(int n, double *mybuf)
{
writer.write(mybuf, n);
if (buffer_flag == 1) {
writer.write(mybuf, n);
} else {
constexpr size_t VBUFFER_SIZE = 256;
char vbuffer[VBUFFER_SIZE];
int m = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < nfield; j++) {
int written = 0;
if (vtype[j] == Dump::INT) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<int> (mybuf[m]));
} else if (vtype[j] == Dump::DOUBLE) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], mybuf[m]);
} else if (vtype[j] == Dump::STRING) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], typenames[(int) mybuf[m]]);
} else if (vtype[j] == Dump::BIGINT) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<bigint> (mybuf[m]));
}
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump custom/gz output");
}
m++;
}
writer.write("\n", 1);
}
}
}
/* ---------------------------------------------------------------------- */
@ -184,7 +213,7 @@ int DumpCustomZstd::modify_param(int narg, char **arg)
return 2;
}
} catch (FileWriterException &e) {
error->one(FLERR, e.what());
error->one(FLERR, fmt::format("Illegal dump_modify command: {}", e.what()));
}
}
return consumed;

127
src/COMPRESS/dump_local_gz.cpp
View File

@ -11,39 +11,28 @@
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "dump_local_gz.h"
#include "domain.h"
#include "dump_local_gz.h"
#include "error.h"
#include "update.h"
#include <cstring>
using namespace LAMMPS_NS;
DumpLocalGZ::DumpLocalGZ(LAMMPS *lmp, int narg, char **arg) :
DumpLocal(lmp, narg, arg)
{
gzFp = nullptr;
compression_level = Z_BEST_COMPRESSION;
if (!compressed)
error->all(FLERR,"Dump local/gz only writes compressed files");
}
/* ---------------------------------------------------------------------- */
DumpLocalGZ::~DumpLocalGZ()
{
if (gzFp) gzclose(gzFp);
gzFp = nullptr;
fp = nullptr;
}
/* ----------------------------------------------------------------------
generic opening of a dump file
ASCII or binary or gzipped
@ -82,7 +71,9 @@ void DumpLocalGZ::openfile()
nameslist[numfiles] = utils::strdup(filecurrent);
++numfiles;
} else {
remove(nameslist[fileidx]);
if (remove(nameslist[fileidx]) != 0) {
error->warning(FLERR, fmt::format("Could not delete {}", nameslist[fileidx]));
}
delete[] nameslist[fileidx];
nameslist[fileidx] = utils::strdup(filecurrent);
fileidx = (fileidx + 1) % maxfiles;
@ -93,17 +84,12 @@ void DumpLocalGZ::openfile()
// each proc with filewriter = 1 opens a file
if (filewriter) {
std::string mode;
if (append_flag) {
mode = fmt::format("ab{}", compression_level);
} else {
mode = fmt::format("wb{}", compression_level);
try {
writer.open(filecurrent, append_flag);
} catch (FileWriterException &e) {
error->one(FLERR, e.what());
}
gzFp = gzopen(filecurrent, mode.c_str());
if (gzFp == nullptr) error->one(FLERR,"Cannot open dump file");
} else gzFp = nullptr;
}
// delete string with timestep replaced
@ -112,29 +98,34 @@ void DumpLocalGZ::openfile()
void DumpLocalGZ::write_header(bigint ndump)
{
std::string header;
if ((multiproc) || (!multiproc && me == 0)) {
if (unit_flag && !unit_count) {
++unit_count;
gzprintf(gzFp,"ITEM: UNITS\n%s\n",update->unit_style);
header = fmt::format("ITEM: UNITS\n{}\n",update->unit_style);
}
if (time_flag) gzprintf(gzFp,"ITEM: TIME\n%.16g\n",compute_time());
gzprintf(gzFp,"ITEM: TIMESTEP\n");
gzprintf(gzFp,BIGINT_FORMAT "\n",update->ntimestep);
gzprintf(gzFp,"ITEM: NUMBER OF %s\n",label);
gzprintf(gzFp,BIGINT_FORMAT "\n",ndump);
if (domain->triclinic) {
gzprintf(gzFp,"ITEM: BOX BOUNDS xy xz yz %s\n",boundstr);
gzprintf(gzFp,"%-1.16e %-1.16e %-1.16e\n",boxxlo,boxxhi,boxxy);
gzprintf(gzFp,"%-1.16e %-1.16e %-1.16e\n",boxylo,boxyhi,boxxz);
gzprintf(gzFp,"%-1.16e %-1.16e %-1.16e\n",boxzlo,boxzhi,boxyz);
} else {
gzprintf(gzFp,"ITEM: BOX BOUNDS %s\n",boundstr);
gzprintf(gzFp,"%-1.16e %-1.16e\n",boxxlo,boxxhi);
gzprintf(gzFp,"%-1.16e %-1.16e\n",boxylo,boxyhi);
gzprintf(gzFp,"%-1.16e %-1.16e\n",boxzlo,boxzhi);
if (time_flag) {
header += fmt::format("ITEM: TIME\n{0:.16g}\n", compute_time());
}
gzprintf(gzFp,"ITEM: %s %s\n",label,columns);
header += fmt::format("ITEM: TIMESTEP\n{}\n", update->ntimestep);
header += fmt::format("ITEM: NUMBER OF {}\n{}\n", label, ndump);
if (domain->triclinic == 0) {
header += fmt::format("ITEM: BOX BOUNDS {}\n", boundstr);
header += fmt::format("{0:-1.16e} {1:-1.16e}\n", boxxlo, boxxhi);
header += fmt::format("{0:-1.16e} {1:-1.16e}\n", boxylo, boxyhi);
header += fmt::format("{0:-1.16e} {1:-1.16e}\n", boxzlo, boxzhi);
} else {
header += fmt::format("ITEM: BOX BOUNDS xy xz yz {}\n", boundstr);
header += fmt::format("{0:-1.16e} {1:-1.16e} {2:-1.16e}\n", boxxlo, boxxhi, boxxy);
header += fmt::format("{0:-1.16e} {1:-1.16e} {2:-1.16e}\n", boxylo, boxyhi, boxxz);
header += fmt::format("{0:-1.16e} {1:-1.16e} {2:-1.16e}\n", boxzlo, boxzhi, boxyz);
}
header += fmt::format("ITEM: {} {}\n", label, columns);
writer.write(header.c_str(), header.length());
}
}
@ -143,19 +134,32 @@ void DumpLocalGZ::write_header(bigint ndump)
void DumpLocalGZ::write_data(int n, double *mybuf)
{
if (buffer_flag == 1) {
gzwrite(gzFp,mybuf,sizeof(char)*n);
writer.write(mybuf, sizeof(char)*n);
} else {
int i,j;
constexpr size_t VBUFFER_SIZE = 256;
char vbuffer[VBUFFER_SIZE];
int m = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < size_one; j++) {
if (vtype[j] == INT)
gzprintf(gzFp,vformat[j],static_cast<int> (mybuf[m]));
else gzprintf(gzFp,vformat[j],mybuf[m]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < size_one; j++) {
int written = 0;
if (vtype[j] == Dump::INT) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<int> (mybuf[m]));
} else if (vtype[j] == Dump::DOUBLE) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], mybuf[m]);
} else if (vtype[j] == Dump::BIGINT) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<bigint> (mybuf[m]));
} else {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], mybuf[m]);
}
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump local/gz output");
}
m++;
}
gzprintf(gzFp,"\n");
writer.write("\n", 1);
}
}
}
@ -167,11 +171,11 @@ void DumpLocalGZ::write()
DumpLocal::write();
if (filewriter) {
if (multifile) {
gzclose(gzFp);
gzFp = nullptr;
writer.close();
} else {
if (flush_flag)
gzflush(gzFp,Z_SYNC_FLUSH);
if (flush_flag && writer.isopen()) {
writer.flush();
}
}
}
}
@ -182,14 +186,15 @@ int DumpLocalGZ::modify_param(int narg, char **arg)
{
int consumed = DumpLocal::modify_param(narg, arg);
if (consumed == 0) {
if (strcmp(arg[0],"compression_level") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
int min_level = Z_DEFAULT_COMPRESSION;
int max_level = Z_BEST_COMPRESSION;
compression_level = utils::inumeric(FLERR, arg[1], false, lmp);
if (compression_level < min_level || compression_level > max_level)
error->all(FLERR, fmt::format("Illegal dump_modify command: compression level must in the range of [{}, {}]", min_level, max_level));
return 2;
try {
if (strcmp(arg[0],"compression_level") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
int compression_level = utils::inumeric(FLERR, arg[1], false, lmp);
writer.setCompressionLevel(compression_level);
return 2;
}
} catch (FileWriterException &e) {
error->one(FLERR, fmt::format("Illegal dump_modify command: {}", e.what()));
}
}
return consumed;

5
src/COMPRESS/dump_local_gz.h
View File

@ -21,7 +21,7 @@ DumpStyle(local/gz,DumpLocalGZ)
#define LMP_DUMP_LOCAL_GZ_H
#include "dump_local.h"
#include <zlib.h>
#include "gz_file_writer.h"
namespace LAMMPS_NS {
@ -31,8 +31,7 @@ class DumpLocalGZ : public DumpLocal {
virtual ~DumpLocalGZ();
protected:
int compression_level;
gzFile gzFp; // file pointer for the compressed output stream
GzFileWriter writer;
virtual void openfile();
virtual void write_header(bigint);

41
src/COMPRESS/dump_local_zstd.cpp
View File

@ -17,15 +17,13 @@
#ifdef LAMMPS_ZSTD
#include "dump_local_zstd.h"
#include "domain.h"
#include "dump_local_zstd.h"
#include "error.h"
#include "update.h"
#include <cstring>
using namespace LAMMPS_NS;
DumpLocalZstd::DumpLocalZstd(LAMMPS *lmp, int narg, char **arg) :
@ -42,7 +40,6 @@ DumpLocalZstd::~DumpLocalZstd()
{
}
/* ----------------------------------------------------------------------
generic opening of a dump file
ASCII or binary or gzipped
@ -81,7 +78,9 @@ void DumpLocalZstd::openfile()
nameslist[numfiles] = utils::strdup(filecurrent);
++numfiles;
} else {
remove(nameslist[fileidx]);
if (remove(nameslist[fileidx]) != 0) {
error->warning(FLERR, fmt::format("Could not delete {}", nameslist[fileidx]));
}
delete[] nameslist[fileidx];
nameslist[fileidx] = utils::strdup(filecurrent);
fileidx = (fileidx + 1) % maxfiles;
@ -145,7 +144,35 @@ void DumpLocalZstd::write_header(bigint ndump)
void DumpLocalZstd::write_data(int n, double *mybuf)
{
writer.write(mybuf, sizeof(char)*n);
if (buffer_flag == 1) {
writer.write(mybuf, sizeof(char)*n);
} else {
constexpr size_t VBUFFER_SIZE = 256;
char vbuffer[VBUFFER_SIZE];
int m = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < size_one; j++) {
int written = 0;
if (vtype[j] == Dump::INT) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<int> (mybuf[m]));
} else if (vtype[j] == Dump::DOUBLE) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], mybuf[m]);
} else if (vtype[j] == Dump::BIGINT) {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], static_cast<bigint> (mybuf[m]));
} else {
written = snprintf(vbuffer, VBUFFER_SIZE, vformat[j], mybuf[m]);
}
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump local/gz output");
}
m++;
}
writer.write("\n", 1);
}
}
}
/* ---------------------------------------------------------------------- */
@ -184,7 +211,7 @@ int DumpLocalZstd::modify_param(int narg, char **arg)
return 2;
}
} catch (FileWriterException &e) {
error->one(FLERR, e.what());
error->one(FLERR, fmt::format("Illegal dump_modify command: {}", e.what()));
}
}
return consumed;

78
src/COMPRESS/dump_xyz_gz.cpp
View File

@ -15,19 +15,13 @@
#include "error.h"
#include "update.h"
#include <cstring>
using namespace LAMMPS_NS;
DumpXYZGZ::DumpXYZGZ(LAMMPS *lmp, int narg, char **arg) :
DumpXYZ(lmp, narg, arg)
{
gzFp = nullptr;
compression_level = Z_BEST_COMPRESSION;
if (!compressed)
error->all(FLERR,"Dump xyz/gz only writes compressed files");
}
@ -37,12 +31,8 @@ DumpXYZGZ::DumpXYZGZ(LAMMPS *lmp, int narg, char **arg) :
DumpXYZGZ::~DumpXYZGZ()
{
if (gzFp) gzclose(gzFp);
gzFp = nullptr;
fp = nullptr;
}
/* ----------------------------------------------------------------------
generic opening of a dump file
ASCII or binary or gzipped
@ -81,7 +71,9 @@ void DumpXYZGZ::openfile()
nameslist[numfiles] = utils::strdup(filecurrent);
++numfiles;
} else {
remove(nameslist[fileidx]);
if (remove(nameslist[fileidx]) != 0) {
error->warning(FLERR, fmt::format("Could not delete {}", nameslist[fileidx]));
}
delete[] nameslist[fileidx];
nameslist[fileidx] = utils::strdup(filecurrent);
fileidx = (fileidx + 1) % maxfiles;
@ -92,17 +84,12 @@ void DumpXYZGZ::openfile()
// each proc with filewriter = 1 opens a file
if (filewriter) {
std::string mode;
if (append_flag) {
mode = fmt::format("ab{}", compression_level);
} else {
mode = fmt::format("wb{}", compression_level);
try {
writer.open(filecurrent, append_flag);
} catch (FileWriterException &e) {
error->one(FLERR, e.what());
}
gzFp = gzopen(filecurrent, mode.c_str());
if (gzFp == nullptr) error->one(FLERR,"Cannot open dump file");
} else gzFp = nullptr;
}
// delete string with timestep replaced
@ -112,8 +99,9 @@ void DumpXYZGZ::openfile()
void DumpXYZGZ::write_header(bigint ndump)
{
if (me == 0) {
gzprintf(gzFp,BIGINT_FORMAT "\n",ndump);
gzprintf(gzFp,"Atoms. Timestep: " BIGINT_FORMAT "\n",update->ntimestep);
std::string header = fmt::format("{}\n", ndump);
header += fmt::format("Atoms. Timestep: {}\n", update->ntimestep);
writer.write(header.c_str(), header.length());
}
}
@ -121,7 +109,24 @@ void DumpXYZGZ::write_header(bigint ndump)
void DumpXYZGZ::write_data(int n, double *mybuf)
{
gzwrite(gzFp,mybuf,sizeof(char)*n);
if (buffer_flag) {
writer.write(mybuf, n);
} else {
constexpr size_t VBUFFER_SIZE = 256;
char vbuffer[VBUFFER_SIZE];
int m = 0;
for (int i = 0; i < n; i++) {
int written = snprintf(vbuffer, VBUFFER_SIZE, format,
typenames[static_cast<int> (mybuf[m+1])],
mybuf[m+2],mybuf[m+3],mybuf[m+4]);
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump xyz/gz output");
}
m += size_one;
}
}
}
/* ---------------------------------------------------------------------- */
@ -131,11 +136,11 @@ void DumpXYZGZ::write()
DumpXYZ::write();
if (filewriter) {
if (multifile) {
gzclose(gzFp);
gzFp = nullptr;
writer.close();
} else {
if (flush_flag)
gzflush(gzFp,Z_SYNC_FLUSH);
if (flush_flag && writer.isopen()) {
writer.flush();
}
}
}
}
@ -146,14 +151,15 @@ int DumpXYZGZ::modify_param(int narg, char **arg)
{
int consumed = DumpXYZ::modify_param(narg, arg);
if (consumed == 0) {
if (strcmp(arg[0],"compression_level") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
int min_level = Z_DEFAULT_COMPRESSION;
int max_level = Z_BEST_COMPRESSION;
compression_level = utils::inumeric(FLERR, arg[1], false, lmp);
if (compression_level < min_level || compression_level > max_level)
error->all(FLERR, fmt::format("Illegal dump_modify command: compression level must in the range of [{}, {}]", min_level, max_level));
return 2;
try {
if (strcmp(arg[0],"compression_level") == 0) {
if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
int compression_level = utils::inumeric(FLERR, arg[1], false, lmp);
writer.setCompressionLevel(compression_level);
return 2;
}
} catch (FileWriterException &e) {
error->one(FLERR, fmt::format("Illegal dump_modify command: {}", e.what()));
}
}
return consumed;

5
src/COMPRESS/dump_xyz_gz.h
View File

@ -21,7 +21,7 @@ DumpStyle(xyz/gz,DumpXYZGZ)
#define LMP_DUMP_XYZ_GZ_H
#include "dump_xyz.h"
#include <zlib.h>
#include "gz_file_writer.h"
namespace LAMMPS_NS {
@ -31,8 +31,7 @@ class DumpXYZGZ : public DumpXYZ {
virtual ~DumpXYZGZ();
protected:
int compression_level;
gzFile gzFp; // file pointer for the compressed output stream
GzFileWriter writer;
virtual void openfile();
virtual void write_header(bigint);

26
src/COMPRESS/dump_xyz_zstd.cpp
View File

@ -19,7 +19,6 @@
#include "dump_xyz_zstd.h"
#include "error.h"
#include "file_writer.h"
#include "update.h"
#include <cstring>
@ -79,7 +78,9 @@ void DumpXYZZstd::openfile()
nameslist[numfiles] = utils::strdup(filecurrent);
++numfiles;
} else {
remove(nameslist[fileidx]);
if (remove(nameslist[fileidx]) != 0) {
error->warning(FLERR, fmt::format("Could not delete {}", nameslist[fileidx]));
}
delete[] nameslist[fileidx];
nameslist[fileidx] = utils::strdup(filecurrent);
fileidx = (fileidx + 1) % maxfiles;
@ -119,7 +120,24 @@ void DumpXYZZstd::write_header(bigint ndump)
void DumpXYZZstd::write_data(int n, double *mybuf)
{
writer.write(mybuf, n);
if (buffer_flag) {
writer.write(mybuf, n);
} else {
constexpr size_t VBUFFER_SIZE = 256;
char vbuffer[VBUFFER_SIZE];
int m = 0;
for (int i = 0; i < n; i++) {
int written = snprintf(vbuffer, VBUFFER_SIZE, format,
typenames[static_cast<int> (mybuf[m+1])],
mybuf[m+2],mybuf[m+3],mybuf[m+4]);
if (written > 0) {
writer.write(vbuffer, written);
} else if (written < 0) {
error->one(FLERR, "Error while writing dump xyz/gz output");
}
m += size_one;
}
}
}
/* ---------------------------------------------------------------------- */
@ -158,7 +176,7 @@ int DumpXYZZstd::modify_param(int narg, char **arg)
return 2;
}
} catch (FileWriterException &e) {
error->one(FLERR, e.what());
error->one(FLERR, fmt::format("Illegal dump_modify command: {}", e.what()));
}
}
return consumed;

105
src/COMPRESS/gz_file_writer.cpp Normal file
View File

@ -0,0 +1,105 @@
/* -*- c++ -*- ----------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
https://lammps.sandia.gov/, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------
Contributing author: Richard Berger (Temple U)
------------------------------------------------------------------------- */
#include "gz_file_writer.h"
#include <stdio.h>
#include "fmt/format.h"
using namespace LAMMPS_NS;
GzFileWriter::GzFileWriter() : FileWriter(),
compression_level(Z_BEST_COMPRESSION),
gzFp(nullptr)
{
}
/* ---------------------------------------------------------------------- */
GzFileWriter::~GzFileWriter()
{
close();
}
/* ---------------------------------------------------------------------- */
void GzFileWriter::open(const std::string &path, bool append)
{
if (isopen()) return;
std::string mode;
if (append) {
mode = fmt::format("ab{}", mode, compression_level);
} else {
mode = fmt::format("wb{}", mode, compression_level);
}
gzFp = gzopen(path.c_str(), mode.c_str());
if (gzFp == nullptr)
throw FileWriterException(fmt::format("Could not open file '{}'", path));
}
/* ---------------------------------------------------------------------- */
size_t GzFileWriter::write(const void * buffer, size_t length)
{
if (!isopen()) return 0;
return gzwrite(gzFp, buffer, length);
}
/* ---------------------------------------------------------------------- */
void GzFileWriter::flush()
{
if (!isopen()) return;
gzflush(gzFp, Z_SYNC_FLUSH);
}
/* ---------------------------------------------------------------------- */
void GzFileWriter::close()
{
if (!isopen()) return;
gzclose(gzFp);
gzFp = nullptr;
}
/* ---------------------------------------------------------------------- */
bool GzFileWriter::isopen() const
{
return gzFp;
}
/* ---------------------------------------------------------------------- */
void GzFileWriter::setCompressionLevel(int level)
{
if (isopen())
throw FileWriterException("Compression level can not be changed while file is open");
const int min_level = Z_DEFAULT_COMPRESSION;
const int max_level = Z_BEST_COMPRESSION;
if (level < min_level || level > max_level)
throw FileWriterException(fmt::format("Compression level must in the range of [{}, {}]", min_level, max_level));
compression_level = level;
}

47
src/COMPRESS/gz_file_writer.h Normal file
View File

@ -0,0 +1,47 @@
/* -*- c++ -*- ----------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------
Contributing author: Richard Berger (Temple U)
------------------------------------------------------------------------- */
#ifndef LMP_GZ_FILE_WRITER_H
#define LMP_GZ_FILE_WRITER_H
#include "file_writer.h"
#include <string>
#include <zlib.h>
#include <exception>
namespace LAMMPS_NS {
class GzFileWriter : public FileWriter {
int compression_level;
gzFile gzFp; // file pointer for the compressed output stream
public:
GzFileWriter();
virtual ~GzFileWriter();
virtual void open(const std::string &path, bool append = false) override;
virtual void close() override;
virtual void flush() override;
virtual size_t write(const void * buffer, size_t length) override;
virtual bool isopen() const override;
void setCompressionLevel(int level);
};
}
#endif

8
src/COMPRESS/zstd_file_writer.cpp
View File

@ -46,11 +46,15 @@ ZstdFileWriter::~ZstdFileWriter()
/* ---------------------------------------------------------------------- */
void ZstdFileWriter::open(const std::string &path)
void ZstdFileWriter::open(const std::string &path, bool append)
{
if (isopen()) return;
fp = fopen(path.c_str(), "wb");
if (append) {
fp = fopen(path.c_str(), "ab");
} else {
fp = fopen(path.c_str(), "wb");
}
if (!fp) {
throw FileWriterException(fmt::format("Could not open file '{}'", path));

2
src/COMPRESS/zstd_file_writer.h
View File

@ -38,7 +38,7 @@ class ZstdFileWriter : public FileWriter {
public:
ZstdFileWriter();
virtual ~ZstdFileWriter();
virtual void open(const std::string &path) override;
virtual void open(const std::string &path, bool append = false) override;
virtual void close() override;
virtual void flush() override;
virtual size_t write(const void * buffer, size_t length) override;

6
src/KIM/kim_command.h
View File

@ -62,13 +62,13 @@ CommandStyle(kim,KimCommand)
#ifndef LMP_KIM_COMMAND_H
#define LMP_KIM_COMMAND_H
#include "pointers.h"
#include "command.h"
namespace LAMMPS_NS {
class KimCommand : protected Pointers {
class KimCommand : public Command {
public:
KimCommand(class LAMMPS *lmp) : Pointers(lmp) {};
KimCommand(class LAMMPS *lmp) : Command(lmp) {};
void command(int, char **);
};

2
src/KOKKOS/Install.sh
View File

@ -63,6 +63,8 @@ action atom_vec_bond_kokkos.cpp atom_vec_bond.cpp
action atom_vec_bond_kokkos.h atom_vec_bond.h
action atom_vec_charge_kokkos.cpp
action atom_vec_charge_kokkos.h
action atom_vec_spin_kokkos.cpp
action atom_vec_spin_kokkos.h
action atom_vec_dpd_kokkos.cpp atom_vec_dpd.cpp
action atom_vec_dpd_kokkos.h atom_vec_dpd.h
action atom_vec_full_kokkos.cpp atom_vec_full.cpp

6
src/KOKKOS/atom_kokkos.cpp
View File

@ -76,6 +76,12 @@ AtomKokkos::~AtomKokkos()
memoryKK->destroy_kokkos(k_improper_atom3, improper_atom3);
memoryKK->destroy_kokkos(k_improper_atom4, improper_atom4);
// SPIN package
memoryKK->destroy_kokkos(k_sp, sp);
memoryKK->destroy_kokkos(k_fm, fm);
memoryKK->destroy_kokkos(k_fm_long, fm_long);
// USER-DPD package
memoryKK->destroy_kokkos(k_uCond,uCond);
memoryKK->destroy_kokkos(k_uMech,uMech);

5
src/KOKKOS/atom_kokkos.h
View File

@ -54,6 +54,11 @@ class AtomKokkos : public Atom {
DAT::tdual_float_2d k_dvector;
// SPIN package
DAT::tdual_float_1d_4 k_sp;
DAT::tdual_f_array k_fm;
DAT::tdual_f_array k_fm_long;
// USER-DPD package
DAT::tdual_efloat_1d k_uCond, k_uMech, k_uChem, k_uCG, k_uCGnew,

1310
src/KOKKOS/atom_vec_spin_kokkos.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

132
src/KOKKOS/atom_vec_spin_kokkos.h Normal file
View File

@ -0,0 +1,132 @@
/* -*- c++ -*- ----------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#ifdef ATOM_CLASS
AtomStyle(spin/kk,AtomVecSpinKokkos)
AtomStyle(spin/kk/device,AtomVecSpinKokkos)
AtomStyle(spin/kk/host,AtomVecSpinKokkos)
#else
#ifndef LMP_ATOM_VEC_SPIN_KOKKOS_H
#define LMP_ATOM_VEC_SPIN_KOKKOS_H
#include "atom_vec_kokkos.h"
#include "kokkos_type.h"
namespace LAMMPS_NS {
class AtomVecSpinKokkos : public AtomVecKokkos {
public:
AtomVecSpinKokkos(class LAMMPS *);
void grow(int);
void copy(int, int, int);
int pack_border(int, int *, double *, int, int *);
int pack_border_vel(int, int *, double *, int, int *);
int pack_border_hybrid(int, int *, double *);
void unpack_border(int, int, double *);
void unpack_border_vel(int, int, double *);
int unpack_border_hybrid(int, int, double *);
int pack_exchange(int, double *);
int unpack_exchange(double *);
int size_restart();
int pack_restart(int, double *);
int unpack_restart(double *);
void create_atom(int, double *);
void data_atom(double *, imageint, char **);
int data_atom_hybrid(int, char **);
void pack_data(double **);
int pack_data_hybrid(int, double *);
void write_data(FILE *, int, double **);
int write_data_hybrid(FILE *, double *);
double memory_usage();
// clear magnetic and mechanic forces
void force_clear(int, size_t);
void grow_pointers();
// input lists to be checked
int pack_border_kokkos(int n, DAT::tdual_int_2d k_sendlist,
DAT::tdual_xfloat_2d buf,int iswap,
int pbc_flag, int *pbc, ExecutionSpace space);
void unpack_border_kokkos(const int &n, const int &nfirst,
const DAT::tdual_xfloat_2d &buf,
ExecutionSpace space);
int pack_exchange_kokkos(const int &nsend,DAT::tdual_xfloat_2d &buf,
DAT::tdual_int_1d k_sendlist,
DAT::tdual_int_1d k_copylist,
ExecutionSpace space, int dim,
X_FLOAT lo, X_FLOAT hi);
int unpack_exchange_kokkos(DAT::tdual_xfloat_2d &k_buf, int nrecv,
int nlocal, int dim, X_FLOAT lo, X_FLOAT hi,
ExecutionSpace space);
void sync(ExecutionSpace space, unsigned int mask);
void modified(ExecutionSpace space, unsigned int mask);
void sync_overlapping_device(ExecutionSpace space, unsigned int mask);
protected:
tagint *tag;
int *type,*mask;
imageint *image;
double **x,**v,**f; // lattice quantities
// spin quantities
double **sp; // sp[i][0-2] direction of the spin i
// sp[i][3] atomic magnetic moment of the spin i
double **fm; // fm[i][0-2] direction of magnetic precession
double **fm_long; // storage of long-range spin prec. components
DAT::t_tagint_1d d_tag;
HAT::t_tagint_1d h_tag;
DAT::t_int_1d d_type, d_mask;
HAT::t_int_1d h_type, h_mask;
DAT::t_imageint_1d d_image;
HAT::t_imageint_1d h_image;
DAT::t_x_array d_x;
DAT::t_v_array d_v;
DAT::t_f_array d_f;
DAT::t_sp_array d_sp;
DAT::t_fm_array d_fm;
DAT::t_fm_long_array d_fm_long;
HAT::t_sp_array h_sp;
HAT::t_fm_array h_fm;
HAT::t_fm_long_array h_fm_long;
DAT::tdual_int_1d k_count;
};
}
#endif
#endif
/* ERROR/WARNING messages:
E: Per-processor system is too big
The number of owned atoms plus ghost atoms on a single
processor must fit in 32-bit integer.
E: Invalid atom type in Atoms section of data file
Atom types must range from 1 to specified # of types.
*/

52
src/KOKKOS/kokkos_type.h
View File

@ -769,6 +769,36 @@ typedef tdual_virial_array::t_dev_um t_virial_array_um;
typedef tdual_virial_array::t_dev_const_um t_virial_array_const_um;
typedef tdual_virial_array::t_dev_const_randomread t_virial_array_randomread;
// Spin Types
//3d SP_FLOAT array n*4
#ifdef LMP_KOKKOS_NO_LEGACY
typedef Kokkos::DualView<X_FLOAT*[4], Kokkos::LayoutLeft, LMPDeviceType> tdual_float_1d_4;
#else
typedef Kokkos::DualView<X_FLOAT*[4], Kokkos::LayoutRight, LMPDeviceType> tdual_float_1d_4;
#endif
typedef tdual_float_1d_4::t_dev t_sp_array;
typedef tdual_float_1d_4::t_dev_const t_sp_array_const;
typedef tdual_float_1d_4::t_dev_um t_sp_array_um;
typedef tdual_float_1d_4::t_dev_const_um t_sp_array_const_um;
typedef tdual_float_1d_4::t_dev_const_randomread t_sp_array_randomread;
//3d FM_FLOAT array n*3
typedef tdual_f_array::t_dev t_fm_array;
typedef tdual_f_array::t_dev_const t_fm_array_const;
typedef tdual_f_array::t_dev_um t_fm_array_um;
typedef tdual_f_array::t_dev_const_um t_fm_array_const_um;
typedef tdual_f_array::t_dev_const_randomread t_fm_array_randomread;
//3d FML_FLOAT array n*3
typedef tdual_f_array::t_dev t_fm_long_array;
typedef tdual_f_array::t_dev_const t_fm_long_array_const;
typedef tdual_f_array::t_dev_um t_fm_long_array_um;
typedef tdual_f_array::t_dev_const_um t_fm_long_array_const_um;
typedef tdual_f_array::t_dev_const_randomread t_fm_long_array_randomread;
//Energy Types
//1d E_FLOAT array n
@ -1005,6 +1035,28 @@ typedef tdual_virial_array::t_host_um t_virial_array_um;
typedef tdual_virial_array::t_host_const_um t_virial_array_const_um;
typedef tdual_virial_array::t_host_const_randomread t_virial_array_randomread;
// Spin types
//2d X_FLOAT array n*4
typedef tdual_float_1d_4::t_host t_sp_array;
typedef tdual_float_1d_4::t_host_const t_sp_array_const;
typedef tdual_float_1d_4::t_host_um t_sp_array_um;
typedef tdual_float_1d_4::t_host_const_um t_sp_array_const_um;
typedef tdual_float_1d_4::t_host_const_randomread t_sp_array_randomread;
//2d F_FLOAT array n*3
typedef tdual_f_array::t_host t_fm_array;
typedef tdual_f_array::t_host_const t_fm_array_const;
typedef tdual_f_array::t_host_um t_fm_array_um;
typedef tdual_f_array::t_host_const_um t_fm_array_const_um;
typedef tdual_f_array::t_host_const_randomread t_fm_array_randomread;
//2d F_FLOAT array n*3
typedef tdual_f_array::t_host t_fm_long_array;
typedef tdual_f_array::t_host_const t_fm_long_array_const;
typedef tdual_f_array::t_host_um t_fm_long_array_um;
typedef tdual_f_array::t_host_const_um t_fm_long_array_const_um;
typedef tdual_f_array::t_host_const_randomread t_fm_long_array_randomread;
//Energy Types

27
src/KOKKOS/verlet_kokkos.cpp
View File

@ -595,6 +595,15 @@ void VerletKokkos::force_clear()
atomKK->modified(Device,TORQUE_MASK);
}
// reset SPIN forces
if (extraflag) {
Kokkos::parallel_for(nall, Zero<typename ArrayTypes<LMPDeviceType>::t_fm_array>(atomKK->k_fm.view<LMPDeviceType>()));
atomKK->modified(Device,FM_MASK);
Kokkos::parallel_for(nall, Zero<typename ArrayTypes<LMPDeviceType>::t_fm_array>(atomKK->k_fm_long.view<LMPDeviceType>()));
atomKK->modified(Device,FML_MASK);
}
// neighbor includegroup flag is set
// clear force only on initial nfirst particles
// if either newton flag is set, also include ghosts
@ -608,6 +617,15 @@ void VerletKokkos::force_clear()
atomKK->modified(Device,TORQUE_MASK);
}
// reset SPIN forces
if (extraflag) {
Kokkos::parallel_for(atomKK->nfirst, Zero<typename ArrayTypes<LMPDeviceType>::t_fm_array>(atomKK->k_fm.view<LMPDeviceType>()));
atomKK->modified(Device,FM_MASK);
Kokkos::parallel_for(atomKK->nfirst, Zero<typename ArrayTypes<LMPDeviceType>::t_fm_array>(atomKK->k_fm_long.view<LMPDeviceType>()));
atomKK->modified(Device,FML_MASK);
}
if (force->newton) {
auto range = Kokkos::RangePolicy<LMPDeviceType>(atomKK->nlocal, atomKK->nlocal + atomKK->nghost);
Kokkos::parallel_for(range, Zero<typename ArrayTypes<LMPDeviceType>::t_f_array>(atomKK->k_f.view<LMPDeviceType>()));
@ -617,6 +635,15 @@ void VerletKokkos::force_clear()
Kokkos::parallel_for(range, Zero<typename ArrayTypes<LMPDeviceType>::t_f_array>(atomKK->k_torque.view<LMPDeviceType>()));
atomKK->modified(Device,TORQUE_MASK);
}
// reset SPIN forces
if (extraflag) {
Kokkos::parallel_for(range, Zero<typename ArrayTypes<LMPDeviceType>::t_fm_array>(atomKK->k_fm.view<LMPDeviceType>()));
atomKK->modified(Device,FM_MASK);
Kokkos::parallel_for(range, Zero<typename ArrayTypes<LMPDeviceType>::t_fm_array>(atomKK->k_fm_long.view<LMPDeviceType>()));
atomKK->modified(Device,FML_MASK);
}
}
}
}

32
src/MANYBODY/fix_qeq_comb.cpp
View File

@ -17,21 +17,21 @@
#include "fix_qeq_comb.h"
#include <cmath>
#include <cstring>
#include "pair_comb.h"
#include "pair_comb3.h"
#include "neigh_list.h"
#include "atom.h"
#include "comm.h"
#include "error.h"
#include "force.h"
#include "group.h"
#include "memory.h"
#include "neigh_list.h"
#include "respa.h"
#include "update.h"
#include "memory.h"
#include "error.h"
#include <cmath>
#include <cstring>
#include "pair_comb.h"
#include "pair_comb3.h"
using namespace LAMMPS_NS;
using namespace FixConst;
@ -85,9 +85,6 @@ FixQEQComb::FixQEQComb(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg),
int nlocal = atom->nlocal;
for (int i = 0; i < nlocal; i++) qf[i] = 0.0;
comb = nullptr;
comb3 = nullptr;
comm_forward = 1;
}
@ -119,8 +116,9 @@ void FixQEQComb::init()
if (!atom->q_flag)
error->all(FLERR,"Fix qeq/comb requires atom attribute q");
comb = (PairComb *) force->pair_match("^comb",0);
comb3 = (PairComb3 *) force->pair_match("^comb3",0);
if (!comb3) comb = (PairComb *) force->pair_match("^comb",0);
if (comb == nullptr && comb3 == nullptr)
error->all(FLERR,"Must use pair_style comb or comb3 with fix qeq/comb");
@ -204,14 +202,17 @@ void FixQEQComb::post_force(int /*vflag*/)
double *q = atom->q;
int *mask = atom->mask;
if (comb) {
if (comb) {
inum = comb->list->inum;
ilist = comb->list->ilist;
}
if (comb3) {
} else if (comb3) {
inum = comb3->list->inum;
ilist = comb3->list->ilist;
} else {
inum = 0;
ilist = nullptr;
}
for (ii = 0; ii < inum; ii++) {
i = ilist[ii];
q1[i] = q2[i] = qf[i] = 0.0;
@ -227,8 +228,9 @@ void FixQEQComb::post_force(int /*vflag*/)
}
comm->forward_comm_fix(this);
enegtot = 0.0;
if (comb) enegtot = comb->yasu_char(qf,igroup);
if (comb3) enegtot = comb3->combqeq(qf,igroup);
else if (comb3) enegtot = comb3->combqeq(qf,igroup);
enegtot /= ngroup;
enegchk = enegmax = 0.0;

1372
src/MC/fix_charge_regulation.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

118
src/MC/fix_charge_regulation.h Normal file
View File

@ -0,0 +1,118 @@
/* -*- c++ -*- ----------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------
Contributing author: Tine Curk (tcurk5@gmail.com) and Jiaxing Yuan (yuanjiaxing123@hotmail.com)
------------------------------------------------------------------------- */
#ifdef FIX_CLASS
FixStyle(charge/regulation,FixChargeRegulation)
#else
#ifndef LMP_FIX_CHARGE_REGULATION_H
#define LMP_FIX_CHARGE_REGULATION_H
#include "fix.h"
namespace LAMMPS_NS {
class FixChargeRegulation : public Fix {
public:
FixChargeRegulation(class LAMMPS *, int, char **);
~FixChargeRegulation();
int setmask();
void init();
void pre_exchange();
void forward_acid();
void backward_acid();
void forward_base();
void backward_base();
void forward_ions();
void forward_ions_multival();
void backward_ions();
void backward_ions_multival();
int get_random_particle(int, double, double, double *);
int insert_particle(int, double, double, double *);
double energy_full();
int particle_number(int, double);
int particle_number_xrd(int, double, double, double *);
double compute_vector(int n);
void assign_tags();
void options(int, char **);
void setThermoTemperaturePointer();
double memory_usage();
private:
int exclusion_group, exclusion_group_bit;
int nevery, seed; // begin MC cycle every nevery MD timesteps, random seed
int nmc; // MC move attempts per cycle
double llength_unit_in_nm ; // LAMMPS unit of length in nm, needed since chemical potentials are in units of mol/l
double pH, pKa, pKb, pKs, pI_plus, pI_minus; // chemical potentials and equilibrium constant in log10 base
double c10pH, c10pKa, c10pKb, c10pOH, c10pI_plus, c10pI_minus; // 10 raised to chemical potential value, in units of concentration [mol/liter]
double pmcmoves[3]; // mc move attempt probability: acid, base, ion pair exchange
double pmcc; // mc move cumulative attempt probability
int npart_xrd; // # of particles (ions) within xrd
int npart_xrd2; // # of particles (ions) within xrd
double vlocal_xrd; // # local volume within xrd
bool only_salt_flag; // true if performing only salt insertion/deletion, no acid/base dissociation.
bool add_tags_flag; // true if each inserted atom gets its unique atom tag
int groupbitall; // group bitmask for inserted atoms
int ngroups; // number of group-ids for inserted atoms
char **groupstrings; // list of group-ids for inserted atoms
// counters
unsigned long int nacid_attempts, nacid_successes, nbase_attempts, nbase_successes, nsalt_attempts, nsalt_successes;
int nacid_neutral, nacid_charged, nbase_neutral, nbase_charged, ncation, nanion; // particle type counts
int cr_nmax; // max number of local particles
double reservoir_temperature;
double beta, sigma, volume, volume_rx; // inverse temperature, speed, total volume, reacting volume
int salt_charge[2]; // charge of salt ions: [0] - cation, [1] - anion
int salt_charge_ratio; // charge ratio when using multivalent ion exchange
double xlo, xhi, ylo, yhi, zlo, zhi; // box size
double energy_stored; // full energy of old/current configuration
int triclinic; // 0 = orthog box, 1 = triclinic
double *sublo, *subhi; // triclinic size
int *ptype_ID; // particle ID array
double overlap_cutoffsq; // square distance cutoff for overlap
int overlap_flag;
int acid_type, cation_type, base_type, anion_type; // reacting atom types
int reaction_distance_flag; // radial reaction restriction flag
double reaction_distance; // max radial distance from acid/base for ion insertion
class Pair *pair;
class Compute *c_pe; // energy compute pointer
class RanPark *random_equal; // random number generator
class RanPark *random_unequal; // random number generator
char *idftemp; // pointer to the temperature fix
double *target_temperature_tcp; // current temperature of the thermostat
};
}
#endif
#endif
/* ERROR/WARNING messages:
E: Illegal ... command
Self-explanatory. Check the input script syntax and compare to the
documentation for the command. You can use -echo screen as a
command-line option when running LAMMPS to see the offending line.
Self-explanatory.
*/

9
src/MC/fix_gcmc.cpp
View File

@ -580,14 +580,7 @@ void FixGCMC::init()
// neighbor list exclusion setup
// turn off interactions between group all and the exclusion group
int narg = 4;
char **arg = new char*[narg];;
arg[0] = (char *) "exclude";
arg[1] = (char *) "group";
arg[2] = (char *) group_id.c_str();
arg[3] = (char *) "all";
neighbor->modify_params(narg,arg);
delete [] arg;
neighbor->modify_params(fmt::format("exclude group {} all",group_id));
}
// create a new group for temporary use with selected molecules

9
src/MC/fix_widom.cpp
View File

@ -342,14 +342,7 @@ void FixWidom::init()
// neighbor list exclusion setup
// turn off interactions between group all and the exclusion group
int narg = 4;
char **arg = new char*[narg];;
arg[0] = (char *) "exclude";
arg[1] = (char *) "group";
arg[2] = (char *) group_id.c_str();
arg[3] = (char *) "all";
neighbor->modify_params(narg,arg);
delete [] arg;
neighbor->modify_params(fmt::format("exclude group {} all",group_id));
}
// create a new group for temporary use with selected molecules

Some files were not shown because too many files have changed in this diff Show More