diff --git a/cmake/Modules/Packages/GPU.cmake b/cmake/Modules/Packages/GPU.cmake
index 043d41e0ef..9aa917144b 100644
--- a/cmake/Modules/Packages/GPU.cmake
+++ b/cmake/Modules/Packages/GPU.cmake
@@ -35,7 +35,7 @@ if(GPU_API STREQUAL "CUDA")
   if(NOT BIN2C)
     message(FATAL_ERROR "Could not find bin2c, use -DBIN2C=/path/to/bin2c to help cmake finding it.")
   endif()
-  option(CUDPP_OPT "Enable CUDPP_OPT" ON)
+  option(CUDPP_OPT "Enable GPU binning via CUDAPP (should be off for modern GPUs)" OFF)
   option(CUDA_MPS_SUPPORT "Enable tweaks to support CUDA Multi-process service (MPS)" OFF)
   if(CUDA_MPS_SUPPORT)
     if(CUDPP_OPT)
diff --git a/cmake/Modules/Packages/KOKKOS.cmake b/cmake/Modules/Packages/KOKKOS.cmake
index 63895a5a9c..1dfb0bf389 100644
--- a/cmake/Modules/Packages/KOKKOS.cmake
+++ b/cmake/Modules/Packages/KOKKOS.cmake
@@ -51,10 +51,12 @@ if(DOWNLOAD_KOKKOS)
     INTERFACE_INCLUDE_DIRECTORIES "${INSTALL_DIR}/include"
     INTERFACE_LINK_LIBRARIES ${CMAKE_DL_LIBS})
   target_link_libraries(lammps PRIVATE LAMMPS::KOKKOS)
+  target_link_libraries(lmp PRIVATE LAMMPS::KOKKOS)
   add_dependencies(LAMMPS::KOKKOS kokkos_build)
 elseif(EXTERNAL_KOKKOS)
   find_package(Kokkos 3.3.01 REQUIRED CONFIG)
   target_link_libraries(lammps PRIVATE Kokkos::kokkos)
+  target_link_libraries(lmp PRIVATE Kokkos::kokkos)
 else()
   set(LAMMPS_LIB_KOKKOS_SRC_DIR ${LAMMPS_LIB_SOURCE_DIR}/kokkos)
   set(LAMMPS_LIB_KOKKOS_BIN_DIR ${LAMMPS_LIB_BINARY_DIR}/kokkos)
@@ -66,6 +68,7 @@ else()
                           ${LAMMPS_LIB_KOKKOS_BIN_DIR})
   target_include_directories(lammps PRIVATE ${Kokkos_INCLUDE_DIRS})
   target_link_libraries(lammps PRIVATE kokkos)
+  target_link_libraries(lmp PRIVATE kokkos)
 endif()
 target_compile_definitions(lammps PRIVATE -DLMP_KOKKOS)
 
diff --git a/cmake/presets/oneapi.cmake b/cmake/presets/oneapi.cmake
new file mode 100644
index 0000000000..ef04167305
--- /dev/null
+++ b/cmake/presets/oneapi.cmake
@@ -0,0 +1,18 @@
+# preset that will enable the LLVM based Intel compilers with support for MPI and OpenMP (on Linux boxes)
+
+set(CMAKE_CXX_COMPILER "icpx" CACHE STRING "" FORCE)
+set(CMAKE_C_COMPILER "icx" CACHE STRING "" FORCE)
+set(CMAKE_Fortran_COMPILER "ifx" CACHE STRING "" FORCE)
+set(MPI_CXX "icpx" CACHE STRING "" FORCE)
+set(MPI_CXX_COMPILER "mpicxx" CACHE STRING "" FORCE)
+unset(HAVE_OMP_H_INCLUDE CACHE)
+
+set(OpenMP_C "icx" CACHE STRING "" FORCE)
+set(OpenMP_C_FLAGS "-qopenmp" CACHE STRING "" FORCE)
+set(OpenMP_C_LIB_NAMES "omp" CACHE STRING "" FORCE)
+set(OpenMP_CXX "icpx" CACHE STRING "" FORCE)
+set(OpenMP_CXX_FLAGS "-qopenmp" CACHE STRING "" FORCE)
+set(OpenMP_CXX_LIB_NAMES "omp" CACHE STRING "" FORCE)
+set(OpenMP_Fortran_FLAGS "-qopenmp" CACHE STRING "" FORCE)
+set(OpenMP_omp_LIBRARY "libiomp5.so" CACHE PATH "" FORCE)
+
diff --git a/doc/src/Build_basics.rst b/doc/src/Build_basics.rst
index 5e2235e29b..af6120630d 100644
--- a/doc/src/Build_basics.rst
+++ b/doc/src/Build_basics.rst
@@ -234,6 +234,8 @@ LAMMPS.
          cmake ../cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_Fortran_COMPILER=gfortran
          # Building with Intel Compilers:
          cmake ../cmake -DCMAKE_C_COMPILER=icc -DCMAKE_CXX_COMPILER=icpc -DCMAKE_Fortran_COMPILER=ifort
+         # Building with Intel oneAPI Compilers:
+         cmake ../cmake -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx -DCMAKE_Fortran_COMPILER=ifx
          # Building with LLVM/Clang Compilers:
          cmake ../cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_Fortran_COMPILER=flang
          # Building with PGI/Nvidia Compilers:
@@ -243,8 +245,10 @@ LAMMPS.
       provided that can be loaded with
       `-C ../cmake/presets/clang.cmake`.  Similarly,
       `-C ../cmake/presets/intel.cmake` should switch the compiler
-      toolchain to the Intel compilers and `-C ../cmake/presets/pgi.cmake`
-      should switch the compiler to the PGI compilers.
+      toolchain to the legacy Intel compilers, `-C ../cmake/presets/oneapi.cmake`
+      will switch to the LLVM based oneAPI Intel compilers,
+      and `-C ../cmake/presets/pgi.cmake`
+      will switch the compiler to the PGI compilers.
 
       In addition you can set ``CMAKE_TUNE_FLAGS`` to specifically add
       compiler flags to tune for optimal performance on given hosts. By
diff --git a/doc/src/Build_extras.rst b/doc/src/Build_extras.rst
index 9180933007..2081dc4bcd 100644
--- a/doc/src/Build_extras.rst
+++ b/doc/src/Build_extras.rst
@@ -128,9 +128,9 @@ CMake build
                                 # default is 'gfx906' for HIP_PLATFORM=hcc and 'sm_50' for HIP_PLATFORM=nvcc
    -D HIP_USE_DEVICE_SORT=value # enables GPU sorting
                                 # value = yes (default) or no
-   -D CUDPP_OPT=value           # optimization setting for GPU_API=cuda
-                                # enables CUDA Performance Primitives Optimizations, must be "no" for CUDA_MPS_SUPPORT=yes
-                                # value = yes (default) or no
+   -D CUDPP_OPT=value           # use GPU binning on with CUDA (should be off for modern GPUs)
+                                # enables CUDA Performance Primitives, must be "no" for CUDA_MPS_SUPPORT=yes
+                                # value = yes or no (default)
    -D CUDA_MPS_SUPPORT=value    # enables some tweaks required to run with active nvidia-cuda-mps daemon
                                 # value = yes or no (default)
    -D USE_STATIC_OPENCL_LOADER=value  # downloads/includes OpenCL ICD loader library, no local OpenCL headers/libs needed
@@ -230,11 +230,12 @@ GPU architectures as supported by the CUDA toolkit in use. This is done
 through using the "--gencode " flag, which can be used multiple times and
 thus support all GPU architectures supported by your CUDA compiler.
 
-To include CUDA performance primitives set the Makefile variable
-``CUDPP_OPT = -DUSE_CUDPP -Icudpp_mini``.
+To enable GPU binning via CUDA performance primitives set the Makefile variable
+``CUDPP_OPT = -DUSE_CUDPP -Icudpp_mini``.  This should **not** be used with
+most modern GPUs.
 
 To support the CUDA multiprocessor server you can set the define
-``-DCUDA_PROXY``.  Please note that in this case you should **not** use
+``-DCUDA_PROXY``.  Please note that in this case you must **not** use
 the CUDA performance primitives and thus set the variable ``CUDPP_OPT``
 to empty.
 
diff --git a/doc/src/Howto_cmake.rst b/doc/src/Howto_cmake.rst
index c23113b0a5..655c90bfd9 100644
--- a/doc/src/Howto_cmake.rst
+++ b/doc/src/Howto_cmake.rst
@@ -411,10 +411,10 @@ interface (``ccmake`` or ``cmake-gui``).
 .. note::
 
    Using a preset to select a compiler package (``clang.cmake``,
-   ``gcc.cmake``, or ``intel.cmake``) are an exception to the option
-   of updating the configuration incrementally, as they will trigger
-   a reset of cached internal CMake settings and thus reset them to
-   their default values.
+   ``gcc.cmake``, ``intel.cmake``, ``oneapi.cmake``, or ``pgi.cmake``)
+   are an exception to the mechanism of updating the configuration incrementally,
+   as they will trigger a reset of cached internal CMake settings and thus
+   reset settings to their default values.
 
 Compilation and build targets
 -----------------------------
diff --git a/doc/src/Tools.rst b/doc/src/Tools.rst
index abab37b080..376489dcce 100644
--- a/doc/src/Tools.rst
+++ b/doc/src/Tools.rst
@@ -93,6 +93,7 @@ Miscellaneous tools
    * :ref:`i-pi <ipi>`
    * :ref:`kate <kate>`
    * :ref:`LAMMPS shell <lammps_shell>`
+   * :ref:`LAMMPS magic patterns for file(1) <magic>`
    * :ref:`singularity <singularity_tool>`
    * :ref:`SWIG interface <swig>`
    * :ref:`vim <vim>`
@@ -641,6 +642,39 @@ This tool was written by Ara Kooser at Sandia (askoose at sandia.gov).
 
 ----------
 
+.. _magic:
+
+Magic patterns for the "file" command
+-------------------------------------
+
+.. versionadded:: 10Mar2021
+
+The file ``magic`` contains patterns that are used by the
+`file program <https://en.wikipedia.org/wiki/File_(command)>`_
+available on most Unix-like operating systems which enables it
+to detect various LAMMPS files and print some useful information
+about them.  To enable these patterns, append or copy the contents
+of the file to either the file ``.magic`` in your home directory
+or (as administrator) to ``/etc/magic`` (for a system-wide
+installation).  Afterwards the ``file`` command should be able to
+detect most LAMMPS restarts, dump, data and log files. Examples:
+
+.. code-block:: bash
+
+   $ file *.*
+   dihedral-quadratic.restart:   LAMMPS binary restart file (rev 2), Version 10 Mar 2021, Little Endian
+   mol-pair-wf_cut.restart:      LAMMPS binary restart file (rev 2), Version 24 Dec 2020, Little Endian
+   atom.bin:                     LAMMPS atom style binary dump (rev 2), Little Endian, First time step: 445570
+   custom.bin:                   LAMMPS custom style binary dump (rev 2), Little Endian, First time step: 100
+   bn1.lammpstrj:                LAMMPS text mode dump, First time step: 5000
+   data.fourmol:                 LAMMPS data file written by LAMMPS
+   pnc.data:                     LAMMPS data file written by msi2lmp
+   data.spce:                    LAMMPS data file written by TopoTools
+   B.data:                       LAMMPS data file written by OVITO
+   log.lammps:                   LAMMPS log file written by version 10 Feb 2021
+
+----------
+
 .. _matlab:
 
 matlab tool
diff --git a/doc/utils/sphinx-config/false_positives.txt b/doc/utils/sphinx-config/false_positives.txt
index 1b2c98ee73..1d66028621 100644
--- a/doc/utils/sphinx-config/false_positives.txt
+++ b/doc/utils/sphinx-config/false_positives.txt
@@ -160,6 +160,7 @@ atwt
 augt
 AuO
 automagically
+Auvergne
 Avalos
 avalue
 aveforce
@@ -1740,6 +1741,7 @@ lwsock
 lx
 ly
 Lybrand
+lyon
 Lyulin
 lz
 Maaravi
@@ -3256,6 +3258,7 @@ Tz
 Tzou
 ub
 Uberuaga
+uca
 uChem
 uCond
 uef
diff --git a/examples/ELASTIC_T/displace.mod b/examples/ELASTIC_T/displace.mod
index b121f2f694..4f300b6326 100644
--- a/examples/ELASTIC_T/displace.mod
+++ b/examples/ELASTIC_T/displace.mod
@@ -100,22 +100,12 @@ run ${nrun}
 
 # Obtain new stress tensor
  
-variable tmp equal pe
-variable e1 equal ${tmp}
-variable tmp equal press
-variable p1 equal ${tmp}
-variable tmp equal pxx
-variable pxx1 equal ${tmp}
-variable tmp equal pyy
-variable pyy1 equal ${tmp}
-variable tmp equal pzz
-variable pzz1 equal ${tmp}
-variable tmp equal pxy
-variable pxy1 equal ${tmp}
-variable tmp equal pxz
-variable pxz1 equal ${tmp}
-variable tmp equal pyz
-variable pyz1 equal ${tmp}
+variable pxx1 equal f_avp[1]
+variable pyy1 equal f_avp[2]
+variable pzz1 equal f_avp[3]
+variable pxy1 equal f_avp[4]
+variable pxz1 equal f_avp[5]
+variable pyz1 equal f_avp[6]
 
 # Compute elastic constant from pressure tensor
 
diff --git a/lib/gpu/Makefile.cuda b/lib/gpu/Makefile.cuda
index e03b59979a..7020f18cf3 100644
--- a/lib/gpu/Makefile.cuda
+++ b/lib/gpu/Makefile.cuda
@@ -29,7 +29,8 @@ LIB_DIR = ./
 AR = ar
 BSH = /bin/sh
 
-CUDPP_OPT = -DUSE_CUDPP -Icudpp_mini
+# GPU binning not recommended for modern GPUs
+CUDPP_OPT = # -DUSE_CUDPP -Icudpp_mini
 CUDA_MPS  =
 
 # device code compiler and settings
diff --git a/lib/gpu/Makefile.linux b/lib/gpu/Makefile.linux
index 5fff81072b..0b3084cbe9 100644
--- a/lib/gpu/Makefile.linux
+++ b/lib/gpu/Makefile.linux
@@ -70,7 +70,8 @@ LIB_DIR = ./
 AR = ar
 BSH = /bin/sh
 
-CUDPP_OPT = -DUSE_CUDPP -Icudpp_mini
+# GPU binning not recommended with modern GPUs
+CUDPP_OPT = #-DUSE_CUDPP -Icudpp_mini
 
 include Nvidia.makefile
 
diff --git a/lib/gpu/Makefile.linux_multi b/lib/gpu/Makefile.linux_multi
index aa7d92572d..05b869879e 100644
--- a/lib/gpu/Makefile.linux_multi
+++ b/lib/gpu/Makefile.linux_multi
@@ -77,7 +77,8 @@ LIB_DIR = ./
 AR = ar
 BSH = /bin/sh
 
-CUDPP_OPT = -DUSE_CUDPP -Icudpp_mini
+# GPU binning not recommended with modern GPUs
+CUDPP_OPT = #-DUSE_CUDPP -Icudpp_mini
 
 include Nvidia.makefile_multi
 
diff --git a/lib/gpu/Makefile.serial b/lib/gpu/Makefile.serial
index 82d10deea2..d24b03f8d6 100644
--- a/lib/gpu/Makefile.serial
+++ b/lib/gpu/Makefile.serial
@@ -66,7 +66,8 @@ LIB_DIR = ./
 AR = ar
 BSH = /bin/sh
 
-CUDPP_OPT = -DUSE_CUDPP -Icudpp_mini
+# GPU binning not recommended for most modern GPUs
+CUDPP_OPT = #-DUSE_CUDPP -Icudpp_mini
 
 include Nvidia.makefile
 
diff --git a/lib/gpu/Makefile.turing b/lib/gpu/Makefile.turing
index abc9657219..390de9c558 100644
--- a/lib/gpu/Makefile.turing
+++ b/lib/gpu/Makefile.turing
@@ -16,6 +16,7 @@ LIB_DIR = .
 AR = ar
 BSH = /bin/sh
 
+# GPU binning not recommended with most modern GPUs
 CUDPP_OPT = #-DUSE_CUDPP -Icudpp_mini
 
 include Nvidia.makefile
diff --git a/lib/gpu/geryon/nvd_device.h b/lib/gpu/geryon/nvd_device.h
index 52b2ed478e..87d5faaf48 100644
--- a/lib/gpu/geryon/nvd_device.h
+++ b/lib/gpu/geryon/nvd_device.h
@@ -24,6 +24,10 @@
 #ifndef NVD_DEVICE
 #define NVD_DEVICE
 
+// workaround after GPU package Feb2021 update
+// todo: make new neighbor code work with CUDA
+#define LAL_USE_OLD_NEIGHBOR
+
 #include <string>
 #include <vector>
 #include <iostream>
diff --git a/python/examples/pylammps/README b/python/examples/pylammps/README
deleted file mode 100644
index ac69622287..0000000000
--- a/python/examples/pylammps/README
+++ /dev/null
@@ -1,28 +0,0 @@
-# Compile LAMMPS as shared library
-
-git clone https://github.com/lammps/lammps.git
-cd lammps/src
-python Make.py -m mpi -png -s ffmpeg exceptions -a file
-
-make -j 4 mode=shlib auto
-cd ../..
-
-# Install Python package
-
-virtualenv testing
-source testing/bin/activate
-
-(testing) cd lammps/python
-(testing) python install.py
-(testing) pip install jupyter matplotlib mpi4py
-
-(testing) cd ../../examples
-
-# Launch jupter and work inside browser
-
-(testing) jupyter notebook
-
-# Use Ctrl+c to stop jupyter
-
-# finally exit the virtualenv
-(testing) deactivate
diff --git a/python/examples/pylammps/README.md b/python/examples/pylammps/README.md
new file mode 100644
index 0000000000..a0f60b52f1
--- /dev/null
+++ b/python/examples/pylammps/README.md
@@ -0,0 +1,89 @@
+# PyLammps and Jupyter Notebooks
+
+This folder contains examples showcasing the usage of the PyLammps Python
+interface and Jupyter notebooks. To use this you will need LAMMPS compiled as
+a shared library and the LAMMPS Python package installed.
+
+An extensive guide on how to achieve this is documented in the [LAMMPS manual](https://lammps.sandia.gov/doc/Python_install.html). There is also a [PyLammps tutorial](https://lammps.sandia.gov/doc/Howto_pylammps.html).
+
+The following will show one way of creating a Python virtual environment
+which has both LAMMPS and its Python package installed:
+
+1. Clone the LAMMPS source code
+
+   ```shell
+   $ git clone -b stable https://github.com/lammps/lammps.git
+   $ cd lammps
+   ```
+
+2. Create a build folder
+
+   ```shell
+   $ mkdir build
+   $ cd build
+   ```
+
+3. Create a virtual environment for Python
+
+   ```shell
+   $ python3 -m venv myenv
+   ```
+
+4. Extend `LD_LIBRARY_PATH` (Unix/Linux) or `DYLD_LIBRARY_PATH` (MacOS)
+
+   On Unix/Linux:
+   ```shell
+   $ echo 'export LD_LIBRARY_PATH=$VIRTUAL_ENV/lib:$LD_LIBRARY_PATH' >> myenv/bin/activate
+   ```
+
+   On MacOS:
+   ```shell
+   echo 'export DYLD_LIBRARY_PATH=$VIRTUAL_ENV/lib:$DYLD_LIBRARY_PATH' >> myenv/bin/activate
+   ```
+
+5. Activate the virtual environment
+
+   ```shell
+   $ source myenv/bin/activate
+   (myenv)$
+   ```
+
+6. Configure LAMMPS compilation (CMake)
+
+   ```shell
+   (myenv)$ cmake -C ../cmake/presets/minimal.cmake \
+                  -D BUILD_SHARED_LIBS=on \
+                  -D LAMMPS_EXCEPTIONS=on -D PKG_PYTHON=on \
+                  -D CMAKE_INSTALL_PREFIX=$VIRTUAL_ENV \
+                  ../cmake
+   ```
+
+7. Compile LAMMPS
+
+   ```shell
+   (myenv)$ cmake --build .
+   ```
+
+8. Install LAMMPS and Python package into virtual environment
+
+   ```shell
+   (myenv)$ cmake --install .
+   ```
+
+9. Install other Python packages into virtual environment
+
+   ```shell
+   (myenv)$ pip install jupyter matplotlib mpi4py
+   ```
+
+10. Navigate to pylammps examples folder
+
+    ```shell
+    (myenv)$ cd ../python/examples/pylammmps
+    ```
+
+11. Launch Jupyter and work inside browser
+
+    ```shell
+    (myenv)$ jupyter notebook
+    ```
diff --git a/python/examples/pylammps/dihedrals/dihedral.ipynb b/python/examples/pylammps/dihedrals/dihedral.ipynb
index 6b919816d7..240e3e8bd6 100644
--- a/python/examples/pylammps/dihedrals/dihedral.ipynb
+++ b/python/examples/pylammps/dihedrals/dihedral.ipynb
@@ -19,9 +19,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt"
@@ -30,9 +28,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "from lammps import IPyLammps"
@@ -194,9 +190,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "K = 80.0\n",
@@ -232,9 +226,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": []
   }
@@ -255,7 +247,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.2"
+   "version": "3.9.2"
   }
  },
  "nbformat": 4,
diff --git a/python/examples/pylammps/interface_usage.ipynb b/python/examples/pylammps/interface_usage.ipynb
index dbaae5a209..36cc7c77db 100644
--- a/python/examples/pylammps/interface_usage.ipynb
+++ b/python/examples/pylammps/interface_usage.ipynb
@@ -4,71 +4,29 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Using LAMMPS with iPython and Jupyter"
+    "# Example 2: Using the PyLammps interface"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "LAMMPS can be run interactively using iPython easily. This tutorial shows how to set this up."
+    "## Prerequisites\n",
+    "\n",
+    "Before running this example, make sure your Python environment can find the LAMMPS shared library (`liblammps.so`) and the LAMMPS Python package is installed. If you followed the [README](README.md) in this folder, this should already be the case. You can also find more information about how to compile LAMMPS and install the LAMMPS Python package in the [LAMMPS manual](https://lammps.sandia.gov/doc/Python_install.html). There is also a dedicated [PyLammps HowTo](https://lammps.sandia.gov/doc/Howto_pylammps.html)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Installation"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. Download the latest version of LAMMPS into a folder (we will calls this `$LAMMPS_DIR` from now on)\n",
-    "2. Compile LAMMPS as a shared library and enable exceptions and PNG support\n",
-    "   ```bash\n",
-    "   cd $LAMMPS_DIR/src\n",
-    "   make mpi mode=shlib LMP_INC=\"-DLAMMPS_PNG -DLAMMPS_EXCEPTIONS\" JPG_LIB=\"-lpng\"\n",
-    "   ```\n",
-    "\n",
-    "3. Create a python virtualenv\n",
-    "   ```bash\n",
-    "   virtualenv testing\n",
-    "   source testing/bin/activate\n",
-    "   ```\n",
-    "\n",
-    "4. Inside the virtualenv install the lammps package\n",
-    "   ```\n",
-    "   (testing) cd $LAMMPS_DIR/python\n",
-    "   (testing) python install.py\n",
-    "   (testing) cd   # move to your working directory\n",
-    "   ```\n",
-    "\n",
-    "5. Install jupyter and ipython in the virtualenv\n",
-    "   ```bash\n",
-    "   (testing) pip install ipython jupyter\n",
-    "   ```\n",
-    "\n",
-    "6. Run jupyter notebook\n",
-    "   ```bash\n",
-    "   (testing) jupyter notebook\n",
-    "   ```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Example"
+    "## Setup system"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "from lammps import IPyLammps"
@@ -90,7 +48,6 @@
    "outputs": [],
    "source": [
     "# 3d Lennard-Jones melt\n",
-    "\n",
     "L.units(\"lj\")\n",
     "L.atom_style(\"atomic\")\n",
     "L.atom_modify(\"map array\")\n",
@@ -116,6 +73,13 @@
     "L.run(10)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualize the initial state"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -205,9 +169,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "L.variable(\"a index 2\")"
@@ -225,9 +187,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "L.variable(\"t equal temp\")"
@@ -283,9 +243,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "L.variable(\"b index a b c\")"
@@ -321,9 +279,16 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L.lmp.command('variable i loop 10')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "L.variable(\"i loop 10\")"
@@ -379,7 +344,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "[x for x in dir(L.atoms[0]) if not x.startswith('__')]"
+    "dir(L.atoms[0])"
    ]
   },
   {
@@ -479,6 +444,15 @@
     "L.runs[0].thermo"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dir(L.runs[0].thermo)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -486,14 +460,48 @@
     "## Saving session to as LAMMPS input file"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "PyLammps can keep track of all LAMMPS commands that are executed. This allows you to prototype a script and then later on save it as a regular input script:"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
+    "L = IPyLammps()\n",
+    "\n",
+    "# enable command history\n",
+    "L.enable_cmd_history = True\n",
+    "\n",
+    "# 3d Lennard-Jones melt\n",
+    "L.units(\"lj\")\n",
+    "L.atom_style(\"atomic\")\n",
+    "L.atom_modify(\"map array\")\n",
+    "\n",
+    "L.lattice(\"fcc\", 0.8442)\n",
+    "L.region(\"box block\", 0, 4, 0, 4, 0, 4)\n",
+    "L.create_box(1, \"box\")\n",
+    "L.create_atoms(1, \"box\")\n",
+    "L.mass(1, 1.0)\n",
+    "\n",
+    "L.velocity(\"all create\", 1.44, 87287, \"loop geom\")\n",
+    "\n",
+    "L.pair_style(\"lj/cut\", 2.5)\n",
+    "L.pair_coeff(1, 1, 1.0, 1.0, 2.5)\n",
+    "\n",
+    "L.neighbor(0.3, \"bin\")\n",
+    "L.neigh_modify(\"delay 0 every 20 check no\")\n",
+    "\n",
+    "L.fix(\"1 all nve\")\n",
+    "\n",
+    "L.run(10)\n",
+    "\n",
+    "# write LAMMPS input script with all commands executed so far (including implicit ones)\n",
     "L.write_script(\"in.output\")"
    ]
   },
@@ -503,7 +511,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dir(L.runs[0].thermo)"
+    "!cat in.output"
    ]
   },
   {
@@ -530,7 +538,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.2"
+   "version": "3.9.2"
   }
  },
  "nbformat": 4,
diff --git a/python/examples/pylammps/interface_usage_bonds.ipynb b/python/examples/pylammps/interface_usage_bonds.ipynb
index 2ee9899b80..54df488de9 100644
--- a/python/examples/pylammps/interface_usage_bonds.ipynb
+++ b/python/examples/pylammps/interface_usage_bonds.ipynb
@@ -4,72 +4,29 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Using LAMMPS with iPython and Jupyter"
+    "# Example 3: 2D circle of particles inside of box with LJ walls"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "LAMMPS can be run interactively using iPython easily. This tutorial shows how to set this up."
+    "## Prerequisites\n",
+    "\n",
+    "Before running this example, make sure your Python environment can find the LAMMPS shared library (`liblammps.so`) and the LAMMPS Python package is installed. If you followed the [README](README.md) in this folder, this should already be the case. You can also find more information about how to compile LAMMPS and install the LAMMPS Python package in the [LAMMPS manual](https://lammps.sandia.gov/doc/Python_install.html). There is also a dedicated [PyLammps HowTo](https://lammps.sandia.gov/doc/Howto_pylammps.html)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Installation"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "1. Download the latest version of LAMMPS into a folder (we will calls this `$LAMMPS_DIR` from now on)\n",
-    "2. Compile LAMMPS as a shared library and enable exceptions and PNG support\n",
-    "   ```bash\n",
-    "   cd $LAMMPS_DIR/src\n",
-    "   make yes-molecule\n",
-    "   make mpi mode=shlib LMP_INC=\"-DLAMMPS_PNG -DLAMMPS_EXCEPTIONS\" JPG_LIB=\"-lpng\"\n",
-    "   ```\n",
-    "\n",
-    "3. Create a python virtualenv\n",
-    "   ```bash\n",
-    "   virtualenv testing\n",
-    "   source testing/bin/activate\n",
-    "   ```\n",
-    "\n",
-    "4. Inside the virtualenv install the lammps package\n",
-    "   ```\n",
-    "   (testing) cd $LAMMPS_DIR/python\n",
-    "   (testing) python install.py\n",
-    "   (testing) cd   # move to your working directory\n",
-    "   ```\n",
-    "\n",
-    "5. Install jupyter and ipython in the virtualenv\n",
-    "   ```bash\n",
-    "   (testing) pip install ipython jupyter\n",
-    "   ```\n",
-    "\n",
-    "6. Run jupyter notebook\n",
-    "   ```bash\n",
-    "   (testing) jupyter notebook\n",
-    "   ```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Example"
+    "## Setup system"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "from lammps import IPyLammps"
@@ -135,6 +92,13 @@
     "L.fix(3, \"all wall/lj93 ylo 0.0 1 1 2.5 yhi\", y, \"1 1 2.5\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualize initial state"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -144,6 +108,13 @@
     "L.image(zoom=1.8)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run simulation and visualize new state"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -254,9 +225,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "L.variable(\"a index 2\")"
@@ -274,9 +243,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "L.variable(\"t equal temp\")"
@@ -332,9 +299,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "L.variable(\"b index a b c\")"
@@ -370,9 +335,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "L.variable(\"i loop 10\")"
@@ -428,7 +391,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "[x for x in dir(L.atoms[0]) if not x.startswith('__')]"
+    "dir(L.atoms[0])"
    ]
   },
   {
@@ -479,9 +442,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": []
   }
@@ -502,7 +463,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.2"
+   "version": "3.9.2"
   }
  },
  "nbformat": 4,
diff --git a/python/examples/pylammps/montecarlo/mc.ipynb b/python/examples/pylammps/montecarlo/mc.ipynb
index 0275171bdd..8058a9eb41 100644
--- a/python/examples/pylammps/montecarlo/mc.ipynb
+++ b/python/examples/pylammps/montecarlo/mc.ipynb
@@ -9,10 +9,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "from __future__ import print_function"
@@ -20,22 +18,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "%matplotlib notebook\n",
+    "%matplotlib inline\n",
     "import matplotlib.pyplot as plt"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "import random, math"
@@ -50,10 +44,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "from lammps import IPyLammps"
@@ -61,27 +53,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "LAMMPS output is captured by PyLammps wrapper\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "L = IPyLammps()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "L.units(\"lj\")\n",
@@ -107,28 +89,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAIAAAB7GkOtAAAAGnRFWHRTb2Z0d2FyZQBMQU1NUFMg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\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "L.image(zoom=1.6)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -137,7 +107,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -146,10 +116,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "L.dump(\"3 all movie 25 movie.mp4 type type zoom 1.6 adiam 1.0\")"
@@ -164,10 +132,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "random.seed(27848)\n",
@@ -176,7 +142,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -189,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -198,21 +164,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAIAAAB7GkOtAAAAGnRFWHRTb2Z0d2FyZQBMQU1NUFMg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\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "L.image(zoom=1.6)"
    ]
@@ -226,10 +180,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "estart = L.eval(\"pe\")\n",
@@ -238,10 +190,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "naccept = 0"
@@ -249,10 +199,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "energies = [estart]"
@@ -260,10 +208,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "niterations = 3000\n",
@@ -273,7 +219,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -307,809 +253,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/javascript": [
-       "/* Put everything inside the global mpl namespace */\n",
-       "window.mpl = {};\n",
-       "\n",
-       "\n",
-       "mpl.get_websocket_type = function() {\n",
-       "    if (typeof(WebSocket) !== 'undefined') {\n",
-       "        return WebSocket;\n",
-       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
-       "        return MozWebSocket;\n",
-       "    } else {\n",
-       "        alert('Your browser does not have WebSocket support.' +\n",
-       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
-       "              'Firefox 4 and 5 are also supported but you ' +\n",
-       "              'have to enable WebSockets in about:config.');\n",
-       "    };\n",
-       "}\n",
-       "\n",
-       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
-       "    this.id = figure_id;\n",
-       "\n",
-       "    this.ws = websocket;\n",
-       "\n",
-       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
-       "\n",
-       "    if (!this.supports_binary) {\n",
-       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
-       "        if (warnings) {\n",
-       "            warnings.style.display = 'block';\n",
-       "            warnings.textContent = (\n",
-       "                \"This browser does not support binary websocket messages. \" +\n",
-       "                    \"Performance may be slow.\");\n",
-       "        }\n",
-       "    }\n",
-       "\n",
-       "    this.imageObj = new Image();\n",
-       "\n",
-       "    this.context = undefined;\n",
-       "    this.message = undefined;\n",
-       "    this.canvas = undefined;\n",
-       "    this.rubberband_canvas = undefined;\n",
-       "    this.rubberband_context = undefined;\n",
-       "    this.format_dropdown = undefined;\n",
-       "\n",
-       "    this.image_mode = 'full';\n",
-       "\n",
-       "    this.root = $('<div/>');\n",
-       "    this._root_extra_style(this.root)\n",
-       "    this.root.attr('style', 'display: inline-block');\n",
-       "\n",
-       "    $(parent_element).append(this.root);\n",
-       "\n",
-       "    this._init_header(this);\n",
-       "    this._init_canvas(this);\n",
-       "    this._init_toolbar(this);\n",
-       "\n",
-       "    var fig = this;\n",
-       "\n",
-       "    this.waiting = false;\n",
-       "\n",
-       "    this.ws.onopen =  function () {\n",
-       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
-       "            fig.send_message(\"send_image_mode\", {});\n",
-       "            if (mpl.ratio != 1) {\n",
-       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
-       "            }\n",
-       "            fig.send_message(\"refresh\", {});\n",
-       "        }\n",
-       "\n",
-       "    this.imageObj.onload = function() {\n",
-       "            if (fig.image_mode == 'full') {\n",
-       "                // Full images could contain transparency (where diff images\n",
-       "                // almost always do), so we need to clear the canvas so that\n",
-       "                // there is no ghosting.\n",
-       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
-       "            }\n",
-       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
-       "        };\n",
-       "\n",
-       "    this.imageObj.onunload = function() {\n",
-       "        this.ws.close();\n",
-       "    }\n",
-       "\n",
-       "    this.ws.onmessage = this._make_on_message_function(this);\n",
-       "\n",
-       "    this.ondownload = ondownload;\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype._init_header = function() {\n",
-       "    var titlebar = $(\n",
-       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
-       "        'ui-helper-clearfix\"/>');\n",
-       "    var titletext = $(\n",
-       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
-       "        'text-align: center; padding: 3px;\"/>');\n",
-       "    titlebar.append(titletext)\n",
-       "    this.root.append(titlebar);\n",
-       "    this.header = titletext[0];\n",
-       "}\n",
-       "\n",
-       "\n",
-       "\n",
-       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
-       "\n",
-       "}\n",
-       "\n",
-       "\n",
-       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
-       "\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype._init_canvas = function() {\n",
-       "    var fig = this;\n",
-       "\n",
-       "    var canvas_div = $('<div/>');\n",
-       "\n",
-       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
-       "\n",
-       "    function canvas_keyboard_event(event) {\n",
-       "        return fig.key_event(event, event['data']);\n",
-       "    }\n",
-       "\n",
-       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
-       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
-       "    this.canvas_div = canvas_div\n",
-       "    this._canvas_extra_style(canvas_div)\n",
-       "    this.root.append(canvas_div);\n",
-       "\n",
-       "    var canvas = $('<canvas/>');\n",
-       "    canvas.addClass('mpl-canvas');\n",
-       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
-       "\n",
-       "    this.canvas = canvas[0];\n",
-       "    this.context = canvas[0].getContext(\"2d\");\n",
-       "\n",
-       "    var backingStore = this.context.backingStorePixelRatio ||\n",
-       "\tthis.context.webkitBackingStorePixelRatio ||\n",
-       "\tthis.context.mozBackingStorePixelRatio ||\n",
-       "\tthis.context.msBackingStorePixelRatio ||\n",
-       "\tthis.context.oBackingStorePixelRatio ||\n",
-       "\tthis.context.backingStorePixelRatio || 1;\n",
-       "\n",
-       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
-       "\n",
-       "    var rubberband = $('<canvas/>');\n",
-       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
-       "\n",
-       "    var pass_mouse_events = true;\n",
-       "\n",
-       "    canvas_div.resizable({\n",
-       "        start: function(event, ui) {\n",
-       "            pass_mouse_events = false;\n",
-       "        },\n",
-       "        resize: function(event, ui) {\n",
-       "            fig.request_resize(ui.size.width, ui.size.height);\n",
-       "        },\n",
-       "        stop: function(event, ui) {\n",
-       "            pass_mouse_events = true;\n",
-       "            fig.request_resize(ui.size.width, ui.size.height);\n",
-       "        },\n",
-       "    });\n",
-       "\n",
-       "    function mouse_event_fn(event) {\n",
-       "        if (pass_mouse_events)\n",
-       "            return fig.mouse_event(event, event['data']);\n",
-       "    }\n",
-       "\n",
-       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
-       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
-       "    // Throttle sequential mouse events to 1 every 20ms.\n",
-       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
-       "\n",
-       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
-       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
-       "\n",
-       "    canvas_div.on(\"wheel\", function (event) {\n",
-       "        event = event.originalEvent;\n",
-       "        event['data'] = 'scroll'\n",
-       "        if (event.deltaY < 0) {\n",
-       "            event.step = 1;\n",
-       "        } else {\n",
-       "            event.step = -1;\n",
-       "        }\n",
-       "        mouse_event_fn(event);\n",
-       "    });\n",
-       "\n",
-       "    canvas_div.append(canvas);\n",
-       "    canvas_div.append(rubberband);\n",
-       "\n",
-       "    this.rubberband = rubberband;\n",
-       "    this.rubberband_canvas = rubberband[0];\n",
-       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
-       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
-       "\n",
-       "    this._resize_canvas = function(width, height) {\n",
-       "        // Keep the size of the canvas, canvas container, and rubber band\n",
-       "        // canvas in synch.\n",
-       "        canvas_div.css('width', width)\n",
-       "        canvas_div.css('height', height)\n",
-       "\n",
-       "        canvas.attr('width', width * mpl.ratio);\n",
-       "        canvas.attr('height', height * mpl.ratio);\n",
-       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
-       "\n",
-       "        rubberband.attr('width', width);\n",
-       "        rubberband.attr('height', height);\n",
-       "    }\n",
-       "\n",
-       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
-       "    // upon first draw.\n",
-       "    this._resize_canvas(600, 600);\n",
-       "\n",
-       "    // Disable right mouse context menu.\n",
-       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
-       "        return false;\n",
-       "    });\n",
-       "\n",
-       "    function set_focus () {\n",
-       "        canvas.focus();\n",
-       "        canvas_div.focus();\n",
-       "    }\n",
-       "\n",
-       "    window.setTimeout(set_focus, 100);\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype._init_toolbar = function() {\n",
-       "    var fig = this;\n",
-       "\n",
-       "    var nav_element = $('<div/>')\n",
-       "    nav_element.attr('style', 'width: 100%');\n",
-       "    this.root.append(nav_element);\n",
-       "\n",
-       "    // Define a callback function for later on.\n",
-       "    function toolbar_event(event) {\n",
-       "        return fig.toolbar_button_onclick(event['data']);\n",
-       "    }\n",
-       "    function toolbar_mouse_event(event) {\n",
-       "        return fig.toolbar_button_onmouseover(event['data']);\n",
-       "    }\n",
-       "\n",
-       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
-       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
-       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
-       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
-       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
-       "\n",
-       "        if (!name) {\n",
-       "            // put a spacer in here.\n",
-       "            continue;\n",
-       "        }\n",
-       "        var button = $('<button/>');\n",
-       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
-       "                        'ui-button-icon-only');\n",
-       "        button.attr('role', 'button');\n",
-       "        button.attr('aria-disabled', 'false');\n",
-       "        button.click(method_name, toolbar_event);\n",
-       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
-       "\n",
-       "        var icon_img = $('<span/>');\n",
-       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
-       "        icon_img.addClass(image);\n",
-       "        icon_img.addClass('ui-corner-all');\n",
-       "\n",
-       "        var tooltip_span = $('<span/>');\n",
-       "        tooltip_span.addClass('ui-button-text');\n",
-       "        tooltip_span.html(tooltip);\n",
-       "\n",
-       "        button.append(icon_img);\n",
-       "        button.append(tooltip_span);\n",
-       "\n",
-       "        nav_element.append(button);\n",
-       "    }\n",
-       "\n",
-       "    var fmt_picker_span = $('<span/>');\n",
-       "\n",
-       "    var fmt_picker = $('<select/>');\n",
-       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
-       "    fmt_picker_span.append(fmt_picker);\n",
-       "    nav_element.append(fmt_picker_span);\n",
-       "    this.format_dropdown = fmt_picker[0];\n",
-       "\n",
-       "    for (var ind in mpl.extensions) {\n",
-       "        var fmt = mpl.extensions[ind];\n",
-       "        var option = $(\n",
-       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
-       "        fmt_picker.append(option)\n",
-       "    }\n",
-       "\n",
-       "    // Add hover states to the ui-buttons\n",
-       "    $( \".ui-button\" ).hover(\n",
-       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
-       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
-       "    );\n",
-       "\n",
-       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
-       "    nav_element.append(status_bar);\n",
-       "    this.message = status_bar[0];\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
-       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
-       "    // which will in turn request a refresh of the image.\n",
-       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.send_message = function(type, properties) {\n",
-       "    properties['type'] = type;\n",
-       "    properties['figure_id'] = this.id;\n",
-       "    this.ws.send(JSON.stringify(properties));\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.send_draw_message = function() {\n",
-       "    if (!this.waiting) {\n",
-       "        this.waiting = true;\n",
-       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
-       "    }\n",
-       "}\n",
-       "\n",
-       "\n",
-       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
-       "    var format_dropdown = fig.format_dropdown;\n",
-       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
-       "    fig.ondownload(fig, format);\n",
-       "}\n",
-       "\n",
-       "\n",
-       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
-       "    var size = msg['size'];\n",
-       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
-       "        fig._resize_canvas(size[0], size[1]);\n",
-       "        fig.send_message(\"refresh\", {});\n",
-       "    };\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
-       "    var x0 = msg['x0'] / mpl.ratio;\n",
-       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
-       "    var x1 = msg['x1'] / mpl.ratio;\n",
-       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
-       "    x0 = Math.floor(x0) + 0.5;\n",
-       "    y0 = Math.floor(y0) + 0.5;\n",
-       "    x1 = Math.floor(x1) + 0.5;\n",
-       "    y1 = Math.floor(y1) + 0.5;\n",
-       "    var min_x = Math.min(x0, x1);\n",
-       "    var min_y = Math.min(y0, y1);\n",
-       "    var width = Math.abs(x1 - x0);\n",
-       "    var height = Math.abs(y1 - y0);\n",
-       "\n",
-       "    fig.rubberband_context.clearRect(\n",
-       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
-       "\n",
-       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
-       "    // Updates the figure title.\n",
-       "    fig.header.textContent = msg['label'];\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
-       "    var cursor = msg['cursor'];\n",
-       "    switch(cursor)\n",
-       "    {\n",
-       "    case 0:\n",
-       "        cursor = 'pointer';\n",
-       "        break;\n",
-       "    case 1:\n",
-       "        cursor = 'default';\n",
-       "        break;\n",
-       "    case 2:\n",
-       "        cursor = 'crosshair';\n",
-       "        break;\n",
-       "    case 3:\n",
-       "        cursor = 'move';\n",
-       "        break;\n",
-       "    }\n",
-       "    fig.rubberband_canvas.style.cursor = cursor;\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
-       "    fig.message.textContent = msg['message'];\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
-       "    // Request the server to send over a new figure.\n",
-       "    fig.send_draw_message();\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
-       "    fig.image_mode = msg['mode'];\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.updated_canvas_event = function() {\n",
-       "    // Called whenever the canvas gets updated.\n",
-       "    this.send_message(\"ack\", {});\n",
-       "}\n",
-       "\n",
-       "// A function to construct a web socket function for onmessage handling.\n",
-       "// Called in the figure constructor.\n",
-       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
-       "    return function socket_on_message(evt) {\n",
-       "        if (evt.data instanceof Blob) {\n",
-       "            /* FIXME: We get \"Resource interpreted as Image but\n",
-       "             * transferred with MIME type text/plain:\" errors on\n",
-       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
-       "             * to be part of the websocket stream */\n",
-       "            evt.data.type = \"image/png\";\n",
-       "\n",
-       "            /* Free the memory for the previous frames */\n",
-       "            if (fig.imageObj.src) {\n",
-       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
-       "                    fig.imageObj.src);\n",
-       "            }\n",
-       "\n",
-       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
-       "                evt.data);\n",
-       "            fig.updated_canvas_event();\n",
-       "            fig.waiting = false;\n",
-       "            return;\n",
-       "        }\n",
-       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
-       "            fig.imageObj.src = evt.data;\n",
-       "            fig.updated_canvas_event();\n",
-       "            fig.waiting = false;\n",
-       "            return;\n",
-       "        }\n",
-       "\n",
-       "        var msg = JSON.parse(evt.data);\n",
-       "        var msg_type = msg['type'];\n",
-       "\n",
-       "        // Call the  \"handle_{type}\" callback, which takes\n",
-       "        // the figure and JSON message as its only arguments.\n",
-       "        try {\n",
-       "            var callback = fig[\"handle_\" + msg_type];\n",
-       "        } catch (e) {\n",
-       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
-       "            return;\n",
-       "        }\n",
-       "\n",
-       "        if (callback) {\n",
-       "            try {\n",
-       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
-       "                callback(fig, msg);\n",
-       "            } catch (e) {\n",
-       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
-       "            }\n",
-       "        }\n",
-       "    };\n",
-       "}\n",
-       "\n",
-       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
-       "mpl.findpos = function(e) {\n",
-       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
-       "    var targ;\n",
-       "    if (!e)\n",
-       "        e = window.event;\n",
-       "    if (e.target)\n",
-       "        targ = e.target;\n",
-       "    else if (e.srcElement)\n",
-       "        targ = e.srcElement;\n",
-       "    if (targ.nodeType == 3) // defeat Safari bug\n",
-       "        targ = targ.parentNode;\n",
-       "\n",
-       "    // jQuery normalizes the pageX and pageY\n",
-       "    // pageX,Y are the mouse positions relative to the document\n",
-       "    // offset() returns the position of the element relative to the document\n",
-       "    var x = e.pageX - $(targ).offset().left;\n",
-       "    var y = e.pageY - $(targ).offset().top;\n",
-       "\n",
-       "    return {\"x\": x, \"y\": y};\n",
-       "};\n",
-       "\n",
-       "/*\n",
-       " * return a copy of an object with only non-object keys\n",
-       " * we need this to avoid circular references\n",
-       " * http://stackoverflow.com/a/24161582/3208463\n",
-       " */\n",
-       "function simpleKeys (original) {\n",
-       "  return Object.keys(original).reduce(function (obj, key) {\n",
-       "    if (typeof original[key] !== 'object')\n",
-       "        obj[key] = original[key]\n",
-       "    return obj;\n",
-       "  }, {});\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
-       "    var canvas_pos = mpl.findpos(event)\n",
-       "\n",
-       "    if (name === 'button_press')\n",
-       "    {\n",
-       "        this.canvas.focus();\n",
-       "        this.canvas_div.focus();\n",
-       "    }\n",
-       "\n",
-       "    var x = canvas_pos.x * mpl.ratio;\n",
-       "    var y = canvas_pos.y * mpl.ratio;\n",
-       "\n",
-       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
-       "                             step: event.step,\n",
-       "                             guiEvent: simpleKeys(event)});\n",
-       "\n",
-       "    /* This prevents the web browser from automatically changing to\n",
-       "     * the text insertion cursor when the button is pressed.  We want\n",
-       "     * to control all of the cursor setting manually through the\n",
-       "     * 'cursor' event from matplotlib */\n",
-       "    event.preventDefault();\n",
-       "    return false;\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
-       "    // Handle any extra behavior associated with a key event\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.key_event = function(event, name) {\n",
-       "\n",
-       "    // Prevent repeat events\n",
-       "    if (name == 'key_press')\n",
-       "    {\n",
-       "        if (event.which === this._key)\n",
-       "            return;\n",
-       "        else\n",
-       "            this._key = event.which;\n",
-       "    }\n",
-       "    if (name == 'key_release')\n",
-       "        this._key = null;\n",
-       "\n",
-       "    var value = '';\n",
-       "    if (event.ctrlKey && event.which != 17)\n",
-       "        value += \"ctrl+\";\n",
-       "    if (event.altKey && event.which != 18)\n",
-       "        value += \"alt+\";\n",
-       "    if (event.shiftKey && event.which != 16)\n",
-       "        value += \"shift+\";\n",
-       "\n",
-       "    value += 'k';\n",
-       "    value += event.which.toString();\n",
-       "\n",
-       "    this._key_event_extra(event, name);\n",
-       "\n",
-       "    this.send_message(name, {key: value,\n",
-       "                             guiEvent: simpleKeys(event)});\n",
-       "    return false;\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
-       "    if (name == 'download') {\n",
-       "        this.handle_save(this, null);\n",
-       "    } else {\n",
-       "        this.send_message(\"toolbar_button\", {name: name});\n",
-       "    }\n",
-       "};\n",
-       "\n",
-       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
-       "    this.message.textContent = tooltip;\n",
-       "};\n",
-       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
-       "\n",
-       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
-       "\n",
-       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
-       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
-       "    // object with the appropriate methods. Currently this is a non binary\n",
-       "    // socket, so there is still some room for performance tuning.\n",
-       "    var ws = {};\n",
-       "\n",
-       "    ws.close = function() {\n",
-       "        comm.close()\n",
-       "    };\n",
-       "    ws.send = function(m) {\n",
-       "        //console.log('sending', m);\n",
-       "        comm.send(m);\n",
-       "    };\n",
-       "    // Register the callback with on_msg.\n",
-       "    comm.on_msg(function(msg) {\n",
-       "        //console.log('receiving', msg['content']['data'], msg);\n",
-       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
-       "        ws.onmessage(msg['content']['data'])\n",
-       "    });\n",
-       "    return ws;\n",
-       "}\n",
-       "\n",
-       "mpl.mpl_figure_comm = function(comm, msg) {\n",
-       "    // This is the function which gets called when the mpl process\n",
-       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
-       "\n",
-       "    var id = msg.content.data.id;\n",
-       "    // Get hold of the div created by the display call when the Comm\n",
-       "    // socket was opened in Python.\n",
-       "    var element = $(\"#\" + id);\n",
-       "    var ws_proxy = comm_websocket_adapter(comm)\n",
-       "\n",
-       "    function ondownload(figure, format) {\n",
-       "        window.open(figure.imageObj.src);\n",
-       "    }\n",
-       "\n",
-       "    var fig = new mpl.figure(id, ws_proxy,\n",
-       "                           ondownload,\n",
-       "                           element.get(0));\n",
-       "\n",
-       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
-       "    // web socket which is closed, not our websocket->open comm proxy.\n",
-       "    ws_proxy.onopen();\n",
-       "\n",
-       "    fig.parent_element = element.get(0);\n",
-       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
-       "    if (!fig.cell_info) {\n",
-       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
-       "        return;\n",
-       "    }\n",
-       "\n",
-       "    var output_index = fig.cell_info[2]\n",
-       "    var cell = fig.cell_info[0];\n",
-       "\n",
-       "};\n",
-       "\n",
-       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
-       "    var width = fig.canvas.width/mpl.ratio\n",
-       "    fig.root.unbind('remove')\n",
-       "\n",
-       "    // Update the output cell to use the data from the current canvas.\n",
-       "    fig.push_to_output();\n",
-       "    var dataURL = fig.canvas.toDataURL();\n",
-       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
-       "    // the notebook keyboard shortcuts fail.\n",
-       "    IPython.keyboard_manager.enable()\n",
-       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
-       "    fig.close_ws(fig, msg);\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
-       "    fig.send_message('closing', msg);\n",
-       "    // fig.ws.close()\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
-       "    // Turn the data on the canvas into data in the output cell.\n",
-       "    var width = this.canvas.width/mpl.ratio\n",
-       "    var dataURL = this.canvas.toDataURL();\n",
-       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.updated_canvas_event = function() {\n",
-       "    // Tell IPython that the notebook contents must change.\n",
-       "    IPython.notebook.set_dirty(true);\n",
-       "    this.send_message(\"ack\", {});\n",
-       "    var fig = this;\n",
-       "    // Wait a second, then push the new image to the DOM so\n",
-       "    // that it is saved nicely (might be nice to debounce this).\n",
-       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype._init_toolbar = function() {\n",
-       "    var fig = this;\n",
-       "\n",
-       "    var nav_element = $('<div/>')\n",
-       "    nav_element.attr('style', 'width: 100%');\n",
-       "    this.root.append(nav_element);\n",
-       "\n",
-       "    // Define a callback function for later on.\n",
-       "    function toolbar_event(event) {\n",
-       "        return fig.toolbar_button_onclick(event['data']);\n",
-       "    }\n",
-       "    function toolbar_mouse_event(event) {\n",
-       "        return fig.toolbar_button_onmouseover(event['data']);\n",
-       "    }\n",
-       "\n",
-       "    for(var toolbar_ind in mpl.toolbar_items){\n",
-       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
-       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
-       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
-       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
-       "\n",
-       "        if (!name) { continue; };\n",
-       "\n",
-       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
-       "        button.click(method_name, toolbar_event);\n",
-       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
-       "        nav_element.append(button);\n",
-       "    }\n",
-       "\n",
-       "    // Add the status bar.\n",
-       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
-       "    nav_element.append(status_bar);\n",
-       "    this.message = status_bar[0];\n",
-       "\n",
-       "    // Add the close button to the window.\n",
-       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
-       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
-       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
-       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
-       "    buttongrp.append(button);\n",
-       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
-       "    titlebar.prepend(buttongrp);\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype._root_extra_style = function(el){\n",
-       "    var fig = this\n",
-       "    el.on(\"remove\", function(){\n",
-       "\tfig.close_ws(fig, {});\n",
-       "    });\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
-       "    // this is important to make the div 'focusable\n",
-       "    el.attr('tabindex', 0)\n",
-       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
-       "    // off when our div gets focus\n",
-       "\n",
-       "    // location in version 3\n",
-       "    if (IPython.notebook.keyboard_manager) {\n",
-       "        IPython.notebook.keyboard_manager.register_events(el);\n",
-       "    }\n",
-       "    else {\n",
-       "        // location in version 2\n",
-       "        IPython.keyboard_manager.register_events(el);\n",
-       "    }\n",
-       "\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
-       "    var manager = IPython.notebook.keyboard_manager;\n",
-       "    if (!manager)\n",
-       "        manager = IPython.keyboard_manager;\n",
-       "\n",
-       "    // Check for shift+enter\n",
-       "    if (event.shiftKey && event.which == 13) {\n",
-       "        this.canvas_div.blur();\n",
-       "        // select the cell after this one\n",
-       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
-       "        IPython.notebook.select(index + 1);\n",
-       "    }\n",
-       "}\n",
-       "\n",
-       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
-       "    fig.ondownload(fig, null);\n",
-       "}\n",
-       "\n",
-       "\n",
-       "mpl.find_output_cell = function(html_output) {\n",
-       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
-       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
-       "    // IPython event is triggered only after the cells have been serialized, which for\n",
-       "    // our purposes (turning an active figure into a static one), is too late.\n",
-       "    var cells = IPython.notebook.get_cells();\n",
-       "    var ncells = cells.length;\n",
-       "    for (var i=0; i<ncells; i++) {\n",
-       "        var cell = cells[i];\n",
-       "        if (cell.cell_type === 'code'){\n",
-       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
-       "                var data = cell.output_area.outputs[j];\n",
-       "                if (data.data) {\n",
-       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
-       "                    data = data.data;\n",
-       "                }\n",
-       "                if (data['text/html'] == html_output) {\n",
-       "                    return [cell, data, j];\n",
-       "                }\n",
-       "            }\n",
-       "        }\n",
-       "    }\n",
-       "}\n",
-       "\n",
-       "// Register the function which deals with the matplotlib target/channel.\n",
-       "// The kernel may be null if the page has been refreshed.\n",
-       "if (IPython.notebook.kernel != null) {\n",
-       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
-       "}\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.Javascript object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<img src=\"data:image/png;base64,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\" width=\"640\">"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f27841c6668>]"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "plt.xlabel('iteration')\n",
     "plt.ylabel('potential energy')\n",
@@ -1118,111 +264,53 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "-2.7617330706844485"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "L.eval(\"pe\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "-2.9871561644794546"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "emin"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "23.597375873270526"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "estart"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "534"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "naccept"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAIAAAB7GkOtAAAAGnRFWHRTb2Z0d2FyZQBMQU1NUFMg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\nYZwZyQAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "L.image(zoom=1.6)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# close dump file to access it\n",
@@ -1231,23 +319,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<video controls><source src=\"movie.mp4\"></video>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "L.video(\"movie.mp4\")"
    ]
@@ -1255,9 +329,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": []
   }
@@ -1278,7 +350,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.2"
+   "version": "3.9.2"
   }
  },
  "nbformat": 4,
diff --git a/python/examples/pylammps/simple.ipynb b/python/examples/pylammps/simple.ipynb
index d305aaa7e6..aecf89d3d9 100644
--- a/python/examples/pylammps/simple.ipynb
+++ b/python/examples/pylammps/simple.ipynb
@@ -4,74 +4,32 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Using LAMMPS with iPython and Jupyter"
+    "# Example 1: Using LAMMPS with PyLammps"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "LAMMPS can be run interactively using iPython easily. This tutorial shows how to set this up."
+    "The LAMMPS Python package provides multiple interfaces. The `PyLammps` interface is a high-level abstration of the low-level `lammps` interface. `IPyLammps` further extends this interface with functions that are useful for Jupyter notebooks to enable embedding generated graphics and videos."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Installation"
+    "## Prerequisites\n",
+    "\n",
+    "Before Running this example, make sure your Python environment can find the LAMMPS shared library (`liblammps.so`) and the LAMMPS Python package is installed. If you followed the [README](README.md) in this folder, this should already be the case. You can also find more information about how to compile LAMMPS and install the LAMMPS Python package in the [LAMMPS manual](https://lammps.sandia.gov/doc/Python_install.html). There is also a dedicated [PyLammps HowTo](https://lammps.sandia.gov/doc/Howto_pylammps.html)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "1. Download the latest version of LAMMPS into a folder (we will calls this `$LAMMPS_DIR` from now on)\n",
-    "2. Compile LAMMPS as a shared library and enable exceptions and PNG support\n",
-    "   ```bash\n",
-    "   cd $LAMMPS_DIR/src\n",
-    "   make mpi mode=shlib LMP_INC=\"-DLAMMPS_PNG -DLAMMPS_EXCEPTIONS\" JPG_LIB=\"-lpng\"\n",
-    "   ```\n",
+    "## Creating a new simulation\n",
     "\n",
-    "3. Create a python virtualenv\n",
-    "   ```bash\n",
-    "   virtualenv testing\n",
-    "   source testing/bin/activate\n",
-    "   ```\n",
-    "\n",
-    "4. Inside the virtualenv install the lammps package\n",
-    "   ```\n",
-    "   (testing) cd $LAMMPS_DIR/python\n",
-    "   (testing) python install.py\n",
-    "   (testing) cd   # move to your working directory\n",
-    "   ```\n",
-    "\n",
-    "5. Install jupyter and ipython in the virtualenv\n",
-    "   ```bash\n",
-    "   (testing) pip install ipython jupyter\n",
-    "   ```\n",
-    "\n",
-    "6. Run jupyter notebook\n",
-    "   ```bash\n",
-    "   (testing) jupyter notebook\n",
-    "   ```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Example"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "from lammps import IPyLammps"
+    "Once the LAMMPS shared library and the LAMMPS Python package are installed, you can create a new LAMMMPS instance in your Python interpreter as follows:"
    ]
   },
   {
@@ -80,22 +38,53 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from lammps import IPyLammps\n",
     "L = IPyLammps()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "With `PyLammps`/`IPyLammps` you can write LAMMPS simulations similar to the input script language. Take the following LAMMPS input script:\n",
+    "\n",
+    "```bash\n",
+    "# 3d Lennard-Jones melt\n",
+    "\n",
+    "units        lj\n",
+    "atom_style   atomic\n",
+    "\n",
+    "lattice      fcc 0.8442\n",
+    "region       box block 0 4 0 4 0 4\n",
+    "create_box   1 box\n",
+    "create_atoms 1 box\n",
+    "mass         1 1.0\n",
+    "\n",
+    "velocity     all create 1.44 87287 loop geom\n",
+    "\n",
+    "pair_style   lj/cut 2.5\n",
+    "pair_coeff   1 1 1.0 1.0 2.5\n",
+    "\n",
+    "neighbor     0.3 bin\n",
+    "neigh_modify delay 0 every 20 check no\n",
+    "\n",
+    "fix          1 all nve\n",
+    "\n",
+    "thermo       50\n",
+    "```\n",
+    "The equivalent can be written with `PyLammps`/`IPyLammps`:"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import math\n",
-    "\n",
     "# 3d Lennard-Jones melt\n",
     "\n",
     "L.units(\"lj\")\n",
     "L.atom_style(\"atomic\")\n",
-    "L.atom_modify(\"map array\")\n",
     "\n",
     "L.lattice(\"fcc\", 0.8442)\n",
     "L.region(\"box\", \"block\", 0, 4, 0, 4, 0, 4)\n",
@@ -111,13 +100,18 @@
     "L.neighbor(0.3, \"bin\")\n",
     "L.neigh_modify(\"delay\", 0, \"every\", 20, \"check no\")\n",
     "\n",
-    "L.fix(\"1 all nve\")\n",
+    "L.fix(\"1\", \"all\", \"nve\")\n",
     "\n",
-    "L.variable(\"fx atom fx\")\n",
+    "L.thermo(50)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualizing the initial state\n",
     "\n",
-    "L.info(\"all\")\n",
-    "\n",
-    "L.run(10)"
+    "`IPyLammps` allows you to visualize the current simulation state with the [image](https://lammps.sandia.gov/doc/Python_module.html#lammps.IPyLammps.image) command. Here we use it to create an image of the initial state of the system."
    ]
   },
   {
@@ -128,6 +122,170 @@
    "source": [
     "L.image(zoom=1.0)"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Running simulations\n",
+    "\n",
+    "Use the `run` command to start the simulation. In Jupyter the return value of the last command will be displayed. The `run` command will return the output of the simulation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L.run(150)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can suppress it by adding a semicolon `;`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L.run(100);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Visualizing the system will now show us how the atoms have moved."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L.image(zoom=1.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Post-processing thermo output\n",
+    "\n",
+    "Independent of whether or not you suppress or show the output of the `run` command, `PyLammps` will record the output. Each `run` command creates a new entry in the `L.runs` list. So far our PyLammps instance `L` executed two `run` commands:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(L.runs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Each entry contains information about the simulation run, including the thermo output for the printed out time steps.\n",
+    "\n",
+    "```bash\n",
+    "# thermo output of a LAMMPS simulation run\n",
+    "Step Temp E_pair E_mol TotEng Press\n",
+    "       0         1.44   -6.7733681            0   -4.6218056   -5.0244179\n",
+    "      50   0.70303849   -5.6796164            0    -4.629178   0.50453907\n",
+    "     100   0.72628044   -5.7150774            0   -4.6299123   0.29765862\n",
+    "     150   0.78441711    -5.805142            0   -4.6331125 -0.086709661\n",
+    "```\n",
+    "\n",
+    "`PyLammps` already parses this information and makes it available as dictionaries and arrays."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L.runs[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L.runs[1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For example, the first run was 150 time steps, with printing out a line every 50 steps. You can access the list of time steps using `{entry}.thermo.Step`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L.runs[0].thermo.Step"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The corresponding values of each thermo quantity are also accessed this way:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L.runs[0].thermo.TotEng"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Together you can use this information to run post-processing on these values or even plot it using `matplotlib`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.xlabel('time step')\n",
+    "plt.ylabel('Total Energy')\n",
+    "plt.plot(L.runs[0].thermo.Step, L.runs[0].thermo.TotEng)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -146,7 +304,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.2"
+   "version": "3.9.2"
   }
  },
  "nbformat": 4,
diff --git a/python/lammps/pylammps.py b/python/lammps/pylammps.py
index 4bba9f5e94..d3af62a588 100644
--- a/python/lammps/pylammps.py
+++ b/python/lammps/pylammps.py
@@ -132,6 +132,9 @@ class Atom(object):
     self._pylmp = pylammps_instance
     self.index = index
 
+  def __dir__(self):
+    return [k for k in super().__dir__() if not k.startswith('_')]
+
   @property
   def id(self):
     """
@@ -298,6 +301,9 @@ class variable_set:
     def __str__(self):
         return "{}({})".format(self._name, ','.join(["{}={}".format(k, self.__dict__[k]) for k in self.__dict__.keys() if not k.startswith('_')]))
 
+    def __dir__(self):
+        return [k for k in self.__dict__.keys() if not k.startswith('_')]
+
     def __repr__(self):
         return self.__str__()
 
diff --git a/src/GPU/pair_beck_gpu.cpp b/src/GPU/pair_beck_gpu.cpp
index ff9537a33e..463123b0a3 100644
--- a/src/GPU/pair_beck_gpu.cpp
+++ b/src/GPU/pair_beck_gpu.cpp
@@ -158,7 +158,7 @@ void PairBeckGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = beck_gpu_init(atom->ntypes+1, cutsq, aa, alpha, beta,
diff --git a/src/GPU/pair_born_coul_long_cs_gpu.cpp b/src/GPU/pair_born_coul_long_cs_gpu.cpp
index db0faab0ab..95c3df7b09 100644
--- a/src/GPU/pair_born_coul_long_cs_gpu.cpp
+++ b/src/GPU/pair_born_coul_long_cs_gpu.cpp
@@ -194,7 +194,7 @@ void PairBornCoulLongCSGPU::init_style()
   g_ewald = force->kspace->g_ewald;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = bornclcs_gpu_init(atom->ntypes+1, cutsq,  rhoinv,
diff --git a/src/GPU/pair_born_coul_long_gpu.cpp b/src/GPU/pair_born_coul_long_gpu.cpp
index cad174c0de..dbd55ef041 100644
--- a/src/GPU/pair_born_coul_long_gpu.cpp
+++ b/src/GPU/pair_born_coul_long_gpu.cpp
@@ -193,7 +193,7 @@ void PairBornCoulLongGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,cut_respa);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = borncl_gpu_init(atom->ntypes+1, cutsq,  rhoinv,
diff --git a/src/GPU/pair_born_coul_wolf_cs_gpu.cpp b/src/GPU/pair_born_coul_wolf_cs_gpu.cpp
index 5c8cac0ec2..9663c4be51 100644
--- a/src/GPU/pair_born_coul_wolf_cs_gpu.cpp
+++ b/src/GPU/pair_born_coul_wolf_cs_gpu.cpp
@@ -179,7 +179,7 @@ void PairBornCoulWolfCSGPU::init_style()
     cut_coul;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = borncwcs_gpu_init(atom->ntypes+1, cutsq, rhoinv,
diff --git a/src/GPU/pair_born_coul_wolf_gpu.cpp b/src/GPU/pair_born_coul_wolf_gpu.cpp
index 73e58b0a1f..8db3761f1f 100644
--- a/src/GPU/pair_born_coul_wolf_gpu.cpp
+++ b/src/GPU/pair_born_coul_wolf_gpu.cpp
@@ -177,7 +177,7 @@ void PairBornCoulWolfGPU::init_style()
     cut_coul;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = borncw_gpu_init(atom->ntypes+1, cutsq, rhoinv,
diff --git a/src/GPU/pair_born_gpu.cpp b/src/GPU/pair_born_gpu.cpp
index 770dad8346..3454adda18 100644
--- a/src/GPU/pair_born_gpu.cpp
+++ b/src/GPU/pair_born_gpu.cpp
@@ -161,7 +161,7 @@ void PairBornGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = born_gpu_init(atom->ntypes+1, cutsq, rhoinv,
diff --git a/src/GPU/pair_buck_coul_cut_gpu.cpp b/src/GPU/pair_buck_coul_cut_gpu.cpp
index 2c9e71bc83..ec002289f2 100644
--- a/src/GPU/pair_buck_coul_cut_gpu.cpp
+++ b/src/GPU/pair_buck_coul_cut_gpu.cpp
@@ -165,7 +165,7 @@ void PairBuckCoulCutGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = buckc_gpu_init(atom->ntypes+1, cutsq, rhoinv, buck1, buck2,
diff --git a/src/GPU/pair_buck_coul_long_gpu.cpp b/src/GPU/pair_buck_coul_long_gpu.cpp
index 3d48862c6a..913f68f4c4 100644
--- a/src/GPU/pair_buck_coul_long_gpu.cpp
+++ b/src/GPU/pair_buck_coul_long_gpu.cpp
@@ -189,7 +189,7 @@ void PairBuckCoulLongGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,cut_respa);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = buckcl_gpu_init(atom->ntypes+1, cutsq,  rhoinv, buck1, buck2,
diff --git a/src/GPU/pair_buck_gpu.cpp b/src/GPU/pair_buck_gpu.cpp
index d17f9d2072..4f091eede5 100644
--- a/src/GPU/pair_buck_gpu.cpp
+++ b/src/GPU/pair_buck_gpu.cpp
@@ -159,7 +159,7 @@ void PairBuckGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = buck_gpu_init(atom->ntypes+1, cutsq, rhoinv, buck1, buck2,
diff --git a/src/GPU/pair_colloid_gpu.cpp b/src/GPU/pair_colloid_gpu.cpp
index 8b7870575a..070b103ddf 100644
--- a/src/GPU/pair_colloid_gpu.cpp
+++ b/src/GPU/pair_colloid_gpu.cpp
@@ -169,7 +169,7 @@ void PairColloidGPU::init_style()
     }
   }
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = colloid_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_coul_cut_gpu.cpp b/src/GPU/pair_coul_cut_gpu.cpp
index 9098f86737..fc4a44adc4 100644
--- a/src/GPU/pair_coul_cut_gpu.cpp
+++ b/src/GPU/pair_coul_cut_gpu.cpp
@@ -164,7 +164,7 @@ void PairCoulCutGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = coul_gpu_init(atom->ntypes+1, scale, cutsq,
diff --git a/src/GPU/pair_coul_debye_gpu.cpp b/src/GPU/pair_coul_debye_gpu.cpp
index 1db2995810..1104175046 100644
--- a/src/GPU/pair_coul_debye_gpu.cpp
+++ b/src/GPU/pair_coul_debye_gpu.cpp
@@ -165,7 +165,7 @@ void PairCoulDebyeGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = cdebye_gpu_init(atom->ntypes+1, scale, cutsq,
diff --git a/src/GPU/pair_coul_dsf_gpu.cpp b/src/GPU/pair_coul_dsf_gpu.cpp
index 830ad057e6..85cd978f33 100644
--- a/src/GPU/pair_coul_dsf_gpu.cpp
+++ b/src/GPU/pair_coul_dsf_gpu.cpp
@@ -182,7 +182,7 @@ void PairCoulDSFGPU::init_style()
   e_shift = erfcc/cut_coul - f_shift*cut_coul;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = cdsf_gpu_init(atom->ntypes+1, atom->nlocal,
diff --git a/src/GPU/pair_coul_long_cs_gpu.cpp b/src/GPU/pair_coul_long_cs_gpu.cpp
index 5b1fcd9c8f..84b6a665db 100644
--- a/src/GPU/pair_coul_long_cs_gpu.cpp
+++ b/src/GPU/pair_coul_long_cs_gpu.cpp
@@ -184,7 +184,7 @@ void PairCoulLongCSGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,cut_respa);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = clcs_gpu_init(atom->ntypes+1, scale,
diff --git a/src/GPU/pair_coul_long_gpu.cpp b/src/GPU/pair_coul_long_gpu.cpp
index af6a66fa34..d27b4650ba 100644
--- a/src/GPU/pair_coul_long_gpu.cpp
+++ b/src/GPU/pair_coul_long_gpu.cpp
@@ -179,7 +179,7 @@ void PairCoulLongGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,cut_respa);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = cl_gpu_init(atom->ntypes+1, scale,
diff --git a/src/GPU/pair_dpd_gpu.cpp b/src/GPU/pair_dpd_gpu.cpp
index d77d83e953..884834d94a 100644
--- a/src/GPU/pair_dpd_gpu.cpp
+++ b/src/GPU/pair_dpd_gpu.cpp
@@ -306,7 +306,7 @@ void PairDPDGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = dpd_gpu_init(atom->ntypes+1, cutsq, a0, gamma, sigma,
diff --git a/src/GPU/pair_dpd_tstat_gpu.cpp b/src/GPU/pair_dpd_tstat_gpu.cpp
index a5ae3e3001..507461fd23 100644
--- a/src/GPU/pair_dpd_tstat_gpu.cpp
+++ b/src/GPU/pair_dpd_tstat_gpu.cpp
@@ -325,7 +325,7 @@ void PairDPDTstatGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = dpd_tstat_gpu_init(atom->ntypes+1, cutsq, a0, gamma, sigma,
diff --git a/src/GPU/pair_eam_alloy_gpu.cpp b/src/GPU/pair_eam_alloy_gpu.cpp
index 4678a6f669..add3a3ca7a 100644
--- a/src/GPU/pair_eam_alloy_gpu.cpp
+++ b/src/GPU/pair_eam_alloy_gpu.cpp
@@ -181,7 +181,7 @@ void PairEAMAlloyGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int fp_size;
   int mnf = 5e-2 * neighbor->oneatom;
diff --git a/src/GPU/pair_eam_fs_gpu.cpp b/src/GPU/pair_eam_fs_gpu.cpp
index 390bb93987..394b520a73 100644
--- a/src/GPU/pair_eam_fs_gpu.cpp
+++ b/src/GPU/pair_eam_fs_gpu.cpp
@@ -180,7 +180,7 @@ void PairEAMFSGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int fp_size;
   int mnf = 5e-2 * neighbor->oneatom;
diff --git a/src/GPU/pair_eam_gpu.cpp b/src/GPU/pair_eam_gpu.cpp
index e458ea2020..fada4febb5 100644
--- a/src/GPU/pair_eam_gpu.cpp
+++ b/src/GPU/pair_eam_gpu.cpp
@@ -182,7 +182,7 @@ void PairEAMGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int fp_size;
   int mnf = 5e-2 * neighbor->oneatom;
diff --git a/src/GPU/pair_gauss_gpu.cpp b/src/GPU/pair_gauss_gpu.cpp
index fe9dd9ba96..04fc65dd06 100644
--- a/src/GPU/pair_gauss_gpu.cpp
+++ b/src/GPU/pair_gauss_gpu.cpp
@@ -157,7 +157,7 @@ void PairGaussGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = gauss_gpu_init(atom->ntypes+1, cutsq, a, b,
diff --git a/src/GPU/pair_gayberne_gpu.cpp b/src/GPU/pair_gayberne_gpu.cpp
index 81966824ba..c5e0a1afb5 100644
--- a/src/GPU/pair_gayberne_gpu.cpp
+++ b/src/GPU/pair_gayberne_gpu.cpp
@@ -205,7 +205,7 @@ void PairGayBerneGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = gb_gpu_init(atom->ntypes+1, gamma, upsilon, mu,
diff --git a/src/GPU/pair_lj96_cut_gpu.cpp b/src/GPU/pair_lj96_cut_gpu.cpp
index 84d1a1a10d..33774078d5 100644
--- a/src/GPU/pair_lj96_cut_gpu.cpp
+++ b/src/GPU/pair_lj96_cut_gpu.cpp
@@ -158,7 +158,7 @@ void PairLJ96CutGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = lj96_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_charmm_coul_charmm_gpu.cpp b/src/GPU/pair_lj_charmm_coul_charmm_gpu.cpp
index 4f8679a8a8..4d8d67cdca 100644
--- a/src/GPU/pair_lj_charmm_coul_charmm_gpu.cpp
+++ b/src/GPU/pair_lj_charmm_coul_charmm_gpu.cpp
@@ -165,7 +165,7 @@ void PairLJCharmmCoulCharmmGPU::init_style()
   double cell_size = sqrt(cut_bothsq) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
 
   bool arithmetic = true;
diff --git a/src/GPU/pair_lj_charmm_coul_long_gpu.cpp b/src/GPU/pair_lj_charmm_coul_long_gpu.cpp
index 9753404d5e..42e869207e 100644
--- a/src/GPU/pair_lj_charmm_coul_long_gpu.cpp
+++ b/src/GPU/pair_lj_charmm_coul_long_gpu.cpp
@@ -191,7 +191,7 @@ void PairLJCharmmCoulLongGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,cut_respa);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
 
   bool arithmetic = true;
diff --git a/src/GPU/pair_lj_class2_coul_long_gpu.cpp b/src/GPU/pair_lj_class2_coul_long_gpu.cpp
index 3fc6195fa8..ae5321bc4f 100644
--- a/src/GPU/pair_lj_class2_coul_long_gpu.cpp
+++ b/src/GPU/pair_lj_class2_coul_long_gpu.cpp
@@ -186,7 +186,7 @@ void PairLJClass2CoulLongGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,cut_respa);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = c2cl_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_class2_gpu.cpp b/src/GPU/pair_lj_class2_gpu.cpp
index cf8158ce5f..06ab116a7e 100644
--- a/src/GPU/pair_lj_class2_gpu.cpp
+++ b/src/GPU/pair_lj_class2_gpu.cpp
@@ -155,7 +155,7 @@ void PairLJClass2GPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = lj96_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_cubic_gpu.cpp b/src/GPU/pair_lj_cubic_gpu.cpp
index a0dd9498c6..2c6231ca89 100644
--- a/src/GPU/pair_lj_cubic_gpu.cpp
+++ b/src/GPU/pair_lj_cubic_gpu.cpp
@@ -163,7 +163,7 @@ void PairLJCubicGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = ljcb_gpu_init(atom->ntypes+1, cutsq, cut_inner_sq,
diff --git a/src/GPU/pair_lj_cut_coul_cut_gpu.cpp b/src/GPU/pair_lj_cut_coul_cut_gpu.cpp
index 7932a352b3..1583395f82 100644
--- a/src/GPU/pair_lj_cut_coul_cut_gpu.cpp
+++ b/src/GPU/pair_lj_cut_coul_cut_gpu.cpp
@@ -166,7 +166,7 @@ void PairLJCutCoulCutGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = ljc_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_cut_coul_debye_gpu.cpp b/src/GPU/pair_lj_cut_coul_debye_gpu.cpp
index eb8e2c9c7f..d83678bd9f 100644
--- a/src/GPU/pair_lj_cut_coul_debye_gpu.cpp
+++ b/src/GPU/pair_lj_cut_coul_debye_gpu.cpp
@@ -168,7 +168,7 @@ void PairLJCutCoulDebyeGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = ljcd_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_cut_coul_dsf_gpu.cpp b/src/GPU/pair_lj_cut_coul_dsf_gpu.cpp
index e071245a56..3a29d7e5a2 100644
--- a/src/GPU/pair_lj_cut_coul_dsf_gpu.cpp
+++ b/src/GPU/pair_lj_cut_coul_dsf_gpu.cpp
@@ -183,7 +183,7 @@ void PairLJCutCoulDSFGPU::init_style()
   e_shift = erfcc/cut_coul - f_shift*cut_coul;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = ljd_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_cut_coul_long_gpu.cpp b/src/GPU/pair_lj_cut_coul_long_gpu.cpp
index cff48afd1e..34e31fc044 100644
--- a/src/GPU/pair_lj_cut_coul_long_gpu.cpp
+++ b/src/GPU/pair_lj_cut_coul_long_gpu.cpp
@@ -191,7 +191,7 @@ void PairLJCutCoulLongGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,cut_respa);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = ljcl_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_cut_coul_msm_gpu.cpp b/src/GPU/pair_lj_cut_coul_msm_gpu.cpp
index d686ea4d88..2fd1d55b54 100644
--- a/src/GPU/pair_lj_cut_coul_msm_gpu.cpp
+++ b/src/GPU/pair_lj_cut_coul_msm_gpu.cpp
@@ -177,7 +177,7 @@ void PairLJCutCoulMSMGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,cut_respa);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = ljcm_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_cut_dipole_cut_gpu.cpp b/src/GPU/pair_lj_cut_dipole_cut_gpu.cpp
index 16eef6e8e8..93af562ed0 100644
--- a/src/GPU/pair_lj_cut_dipole_cut_gpu.cpp
+++ b/src/GPU/pair_lj_cut_dipole_cut_gpu.cpp
@@ -171,7 +171,7 @@ void PairLJCutDipoleCutGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = dpl_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_cut_dipole_long_gpu.cpp b/src/GPU/pair_lj_cut_dipole_long_gpu.cpp
index b7c29cedb8..9ec2bec258 100644
--- a/src/GPU/pair_lj_cut_dipole_long_gpu.cpp
+++ b/src/GPU/pair_lj_cut_dipole_long_gpu.cpp
@@ -195,7 +195,7 @@ void PairLJCutDipoleLongGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,nullptr);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = dplj_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_cut_gpu.cpp b/src/GPU/pair_lj_cut_gpu.cpp
index edd2a7feb0..1de70701f0 100644
--- a/src/GPU/pair_lj_cut_gpu.cpp
+++ b/src/GPU/pair_lj_cut_gpu.cpp
@@ -162,7 +162,7 @@ void PairLJCutGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = ljl_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_cut_tip4p_long_gpu.cpp b/src/GPU/pair_lj_cut_tip4p_long_gpu.cpp
index 9584c6f68a..c63d1a4e91 100644
--- a/src/GPU/pair_lj_cut_tip4p_long_gpu.cpp
+++ b/src/GPU/pair_lj_cut_tip4p_long_gpu.cpp
@@ -210,7 +210,7 @@ void PairLJCutTIP4PLongGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,cut_respa);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
 
   // set alpha parameter
diff --git a/src/GPU/pair_lj_expand_coul_long_gpu.cpp b/src/GPU/pair_lj_expand_coul_long_gpu.cpp
index da0c720c74..af042bef42 100644
--- a/src/GPU/pair_lj_expand_coul_long_gpu.cpp
+++ b/src/GPU/pair_lj_expand_coul_long_gpu.cpp
@@ -191,7 +191,7 @@ void PairLJExpandCoulLongGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,cut_respa);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = ljecl_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_expand_gpu.cpp b/src/GPU/pair_lj_expand_gpu.cpp
index 0e86e41255..87605af1a4 100644
--- a/src/GPU/pair_lj_expand_gpu.cpp
+++ b/src/GPU/pair_lj_expand_gpu.cpp
@@ -159,7 +159,7 @@ void PairLJExpandGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = lje_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_lj_gromacs_gpu.cpp b/src/GPU/pair_lj_gromacs_gpu.cpp
index a605ebd6c4..b45d757ef4 100644
--- a/src/GPU/pair_lj_gromacs_gpu.cpp
+++ b/src/GPU/pair_lj_gromacs_gpu.cpp
@@ -162,7 +162,7 @@ void PairLJGromacsGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
 
   int mnf = 5e-2 * neighbor->oneatom;
diff --git a/src/GPU/pair_lj_sdk_coul_long_gpu.cpp b/src/GPU/pair_lj_sdk_coul_long_gpu.cpp
index df2310e904..97b53fec33 100644
--- a/src/GPU/pair_lj_sdk_coul_long_gpu.cpp
+++ b/src/GPU/pair_lj_sdk_coul_long_gpu.cpp
@@ -195,7 +195,7 @@ void PairLJSDKCoulLongGPU::init_style()
   if (ncoultablebits) init_tables(cut_coul,nullptr);
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = sdkl_gpu_init(atom->ntypes+1, cutsq, lj_type, lj1, lj2, lj3,
diff --git a/src/GPU/pair_lj_sdk_gpu.cpp b/src/GPU/pair_lj_sdk_gpu.cpp
index 5a1960e4c8..cd6f4bc544 100644
--- a/src/GPU/pair_lj_sdk_gpu.cpp
+++ b/src/GPU/pair_lj_sdk_gpu.cpp
@@ -164,7 +164,7 @@ void PairLJSDKGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = sdk_gpu_init(atom->ntypes+1,cutsq,lj_type,lj1,lj2,lj3,lj4,
diff --git a/src/GPU/pair_lj_sf_dipole_sf_gpu.cpp b/src/GPU/pair_lj_sf_dipole_sf_gpu.cpp
index 470c2f049e..cb7a889ed5 100644
--- a/src/GPU/pair_lj_sf_dipole_sf_gpu.cpp
+++ b/src/GPU/pair_lj_sf_dipole_sf_gpu.cpp
@@ -170,7 +170,7 @@ void PairLJSFDipoleSFGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = dplsf_gpu_init(atom->ntypes+1, cutsq, lj1, lj2, lj3, lj4,
diff --git a/src/GPU/pair_mie_cut_gpu.cpp b/src/GPU/pair_mie_cut_gpu.cpp
index 05e92909da..e72c12da79 100644
--- a/src/GPU/pair_mie_cut_gpu.cpp
+++ b/src/GPU/pair_mie_cut_gpu.cpp
@@ -159,7 +159,7 @@ void PairMIECutGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = mie_gpu_init(atom->ntypes+1, cutsq, mie1, mie2, mie3, mie4,
diff --git a/src/GPU/pair_morse_gpu.cpp b/src/GPU/pair_morse_gpu.cpp
index d929c76930..507edd33f4 100644
--- a/src/GPU/pair_morse_gpu.cpp
+++ b/src/GPU/pair_morse_gpu.cpp
@@ -155,7 +155,7 @@ void PairMorseGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = mor_gpu_init(atom->ntypes+1, cutsq, morse1, r0, alpha, d0,
diff --git a/src/GPU/pair_resquared_gpu.cpp b/src/GPU/pair_resquared_gpu.cpp
index c816ad9166..90a7af1d0e 100644
--- a/src/GPU/pair_resquared_gpu.cpp
+++ b/src/GPU/pair_resquared_gpu.cpp
@@ -203,7 +203,7 @@ void PairRESquaredGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = re_gpu_init(atom->ntypes+1, shape1, well, cutsq, sigma,
diff --git a/src/GPU/pair_soft_gpu.cpp b/src/GPU/pair_soft_gpu.cpp
index 5a3ad0c577..66bd6deb8f 100644
--- a/src/GPU/pair_soft_gpu.cpp
+++ b/src/GPU/pair_soft_gpu.cpp
@@ -160,7 +160,7 @@ void PairSoftGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = soft_gpu_init(atom->ntypes+1, cutsq, prefactor, cut,
diff --git a/src/GPU/pair_table_gpu.cpp b/src/GPU/pair_table_gpu.cpp
index 05b76d9adb..6c5bb48e26 100644
--- a/src/GPU/pair_table_gpu.cpp
+++ b/src/GPU/pair_table_gpu.cpp
@@ -229,7 +229,7 @@ void PairTableGPU::init_style()
   }
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = table_gpu_init(atom->ntypes+1, cutsq, table_coeffs, table_data,
diff --git a/src/GPU/pair_ufm_gpu.cpp b/src/GPU/pair_ufm_gpu.cpp
index f950bf11c3..47a32f7fc2 100644
--- a/src/GPU/pair_ufm_gpu.cpp
+++ b/src/GPU/pair_ufm_gpu.cpp
@@ -163,7 +163,7 @@ void PairUFMGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = ufml_gpu_init(atom->ntypes+1, cutsq, uf1, uf2, uf3,
diff --git a/src/GPU/pair_yukawa_colloid_gpu.cpp b/src/GPU/pair_yukawa_colloid_gpu.cpp
index 9322f95f44..3ac5f6c693 100644
--- a/src/GPU/pair_yukawa_colloid_gpu.cpp
+++ b/src/GPU/pair_yukawa_colloid_gpu.cpp
@@ -168,7 +168,7 @@ void PairYukawaColloidGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = ykcolloid_gpu_init(atom->ntypes+1, cutsq, a,
diff --git a/src/GPU/pair_yukawa_gpu.cpp b/src/GPU/pair_yukawa_gpu.cpp
index 81304159a0..8558b57cd8 100644
--- a/src/GPU/pair_yukawa_gpu.cpp
+++ b/src/GPU/pair_yukawa_gpu.cpp
@@ -157,7 +157,7 @@ void PairYukawaGPU::init_style()
   double cell_size = sqrt(maxcut) + neighbor->skin;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = yukawa_gpu_init(atom->ntypes+1, cutsq, kappa, a,
diff --git a/src/GPU/pair_zbl_gpu.cpp b/src/GPU/pair_zbl_gpu.cpp
index 93e0588285..97a859a5bf 100644
--- a/src/GPU/pair_zbl_gpu.cpp
+++ b/src/GPU/pair_zbl_gpu.cpp
@@ -163,7 +163,7 @@ void PairZBLGPU::init_style()
   cut_globalsq = cut_global * cut_global;
 
   int maxspecial=0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     maxspecial=atom->maxspecial;
   int mnf = 5e-2 * neighbor->oneatom;
   int success = zbl_gpu_init(atom->ntypes+1, cutsq, sw1, sw2, sw3, sw4,
diff --git a/src/KOKKOS/min_kokkos.cpp b/src/KOKKOS/min_kokkos.cpp
index 1fcf1a3c48..383b94f67c 100644
--- a/src/KOKKOS/min_kokkos.cpp
+++ b/src/KOKKOS/min_kokkos.cpp
@@ -462,7 +462,7 @@ double MinKokkos::energy_force(int resetflag)
     timer->stamp(Timer::PAIR);
   }
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) {
       atomKK->sync(force->bond->execution_space,force->bond->datamask_read);
       force->bond->compute(eflag,vflag);
diff --git a/src/KOKKOS/npair_kokkos.cpp b/src/KOKKOS/npair_kokkos.cpp
index 20e819deaf..ca00b84ae4 100644
--- a/src/KOKKOS/npair_kokkos.cpp
+++ b/src/KOKKOS/npair_kokkos.cpp
@@ -189,7 +189,7 @@ void NPairKokkos<DeviceType,HALF_NEIGH,GHOST,TRI,SIZE>::build(NeighList *list_)
   k_bins.sync<DeviceType>();
   k_atom2bin.sync<DeviceType>();
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (exclude)
       atomKK->sync(Device,X_MASK|RADIUS_MASK|TYPE_MASK|MASK_MASK|MOLECULE_MASK|TAG_MASK|SPECIAL_MASK);
     else
@@ -545,14 +545,14 @@ __device__ __forceinline__ int __syncthreads_count(int predicate) {
 
 #ifdef LMP_KOKKOS_GPU
 template<class DeviceType> template<int HalfNeigh,int Newton,int Tri>
-__device__ inline
-void NeighborKokkosExecute<DeviceType>::build_ItemCuda(typename Kokkos::TeamPolicy<DeviceType>::member_type dev) const
-{
-#ifdef KOKKOS_ENABLE_HIP
-  HIP_DYNAMIC_SHARED(X_FLOAT, sharedmem);
-#else
-  extern __shared__ X_FLOAT sharedmem[];
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+__device__
 #endif
+inline
+void NeighborKokkosExecute<DeviceType>::build_ItemGPU(typename Kokkos::TeamPolicy<DeviceType>::member_type dev,
+                                                      size_t sharedsize) const
+{
+  auto* sharedmem = static_cast<X_FLOAT *>(dev.team_shmem().get_shmem(sharedsize));
   /* loop over atoms in i's bin,
   */
   const int atoms_per_bin = c_bins.extent(1);
@@ -657,7 +657,7 @@ void NeighborKokkosExecute<DeviceType>::build_ItemCuda(typename Kokkos::TeamPoli
 
     }
   }
-  __syncthreads();
+  dev.team_barrier();
 
   const typename ArrayTypes<DeviceType>::t_int_1d_const_um stencil
     = d_stencil;
@@ -678,7 +678,7 @@ void NeighborKokkosExecute<DeviceType>::build_ItemCuda(typename Kokkos::TeamPoli
 
     other_id[MY_II] = j;
 
-    __syncthreads();
+    dev.team_barrier();
 
     if (i >= 0 && i < nlocal) {
       #pragma unroll 8
@@ -735,7 +735,7 @@ void NeighborKokkosExecute<DeviceType>::build_ItemCuda(typename Kokkos::TeamPoli
 
       }
     }
-    __syncthreads();
+    dev.team_barrier();
   }
 
   if (i >= 0 && i < nlocal) {
@@ -988,14 +988,14 @@ void NeighborKokkosExecute<DeviceType>::
 
 #ifdef LMP_KOKKOS_GPU
 template<class DeviceType> template<int HalfNeigh,int Newton,int Tri>
-__device__ inline
-void NeighborKokkosExecute<DeviceType>::build_ItemSizeCuda(typename Kokkos::TeamPolicy<DeviceType>::member_type dev) const
-{
-#ifdef KOKKOS_ENABLE_HIP
-  HIP_DYNAMIC_SHARED(X_FLOAT, sharedmem);
-#else
-  extern __shared__ X_FLOAT sharedmem[];
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+__device__
 #endif
+inline
+void NeighborKokkosExecute<DeviceType>::build_ItemSizeGPU(typename Kokkos::TeamPolicy<DeviceType>::member_type dev,
+                                                          size_t sharedsize) const
+{
+  auto* sharedmem = static_cast<X_FLOAT *>(dev.team_shmem().get_shmem(sharedsize));
   /* loop over atoms in i's bin,
    */
   const int atoms_per_bin = c_bins.extent(1);
@@ -1086,7 +1086,7 @@ void NeighborKokkosExecute<DeviceType>::build_ItemSizeCuda(typename Kokkos::Team
         }
       }
     }
-    __syncthreads();
+    dev.team_barrier();
 
     const typename ArrayTypes<DeviceType>::t_int_1d_const_um stencil
       = d_stencil;
@@ -1108,7 +1108,7 @@ void NeighborKokkosExecute<DeviceType>::build_ItemSizeCuda(typename Kokkos::Team
 
       other_id[MY_II] = j;
 
-      __syncthreads();
+      dev.team_barrier();
 
       if (i >= 0 && i < nlocal) {
         #pragma unroll 8
@@ -1147,7 +1147,7 @@ void NeighborKokkosExecute<DeviceType>::build_ItemSizeCuda(typename Kokkos::Team
           }
         }
       }
-      __syncthreads();
+      dev.team_barrier();
     }
 
     if (i >= 0 && i < nlocal) {
diff --git a/src/KOKKOS/npair_kokkos.h b/src/KOKKOS/npair_kokkos.h
index be50fd6275..c1abc15b3b 100644
--- a/src/KOKKOS/npair_kokkos.h
+++ b/src/KOKKOS/npair_kokkos.h
@@ -312,12 +312,20 @@ class NeighborKokkosExecute
 
 #ifdef LMP_KOKKOS_GPU
   template<int HalfNeigh, int Newton, int Tri>
-  __device__ inline
-  void build_ItemCuda(typename Kokkos::TeamPolicy<DeviceType>::member_type dev) const;
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+  __device__
+#endif
+  inline
+  void build_ItemGPU(typename Kokkos::TeamPolicy<DeviceType>::member_type dev,
+                     size_t sharedsize) const;
 
   template<int HalfNeigh, int Newton, int Tri>
-  __device__ inline
-  void build_ItemSizeCuda(typename Kokkos::TeamPolicy<DeviceType>::member_type dev) const;
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+  __device__
+#endif
+  inline
+  void build_ItemSizeGPU(typename Kokkos::TeamPolicy<DeviceType>::member_type dev,
+                         size_t sharedsize) const;
 #endif
 
   KOKKOS_INLINE_FUNCTION
@@ -388,10 +396,12 @@ struct NPairKokkosBuildFunctor {
     c.template build_Item<HALF_NEIGH,GHOST_NEWTON,TRI>(i);
   }
 #ifdef LMP_KOKKOS_GPU
-  __device__ inline
-
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+  __device__
+#endif
+  inline
   void operator() (typename Kokkos::TeamPolicy<DeviceType>::member_type dev) const {
-    c.template build_ItemCuda<HALF_NEIGH,GHOST_NEWTON,TRI>(dev);
+    c.template build_ItemGPU<HALF_NEIGH,GHOST_NEWTON,TRI>(dev, sharedsize);
   }
   size_t team_shmem_size(const int team_size) const { (void) team_size; return sharedsize; }
 #endif
@@ -446,9 +456,12 @@ struct NPairKokkosBuildFunctorSize {
   }
 
 #ifdef LMP_KOKKOS_GPU
-  __device__ inline
+  #if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+  __device__
+#endif
+  inline
   void operator() (typename Kokkos::TeamPolicy<DeviceType>::member_type dev) const {
-    c.template build_ItemSizeCuda<HALF_NEIGH,GHOST_NEWTON,TRI>(dev);
+    c.template build_ItemSizeGPU<HALF_NEIGH,GHOST_NEWTON,TRI>(dev, sharedsize);
   }
   size_t team_shmem_size(const int team_size) const { (void) team_size; return sharedsize; }
 #endif
diff --git a/src/MC/fix_atom_swap.cpp b/src/MC/fix_atom_swap.cpp
index 16bb8b1aeb..92671fb637 100644
--- a/src/MC/fix_atom_swap.cpp
+++ b/src/MC/fix_atom_swap.cpp
@@ -504,7 +504,7 @@ double FixAtomSwap::energy_full()
 
   if (force->pair) force->pair->compute(eflag,vflag);
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) force->bond->compute(eflag,vflag);
     if (force->angle) force->angle->compute(eflag,vflag);
     if (force->dihedral) force->dihedral->compute(eflag,vflag);
diff --git a/src/MC/fix_bond_break.cpp b/src/MC/fix_bond_break.cpp
index ba19cfaf69..56da69a7bc 100644
--- a/src/MC/fix_bond_break.cpp
+++ b/src/MC/fix_bond_break.cpp
@@ -80,7 +80,7 @@ FixBondBreak::FixBondBreak(LAMMPS *lmp, int narg, char **arg) :
 
   // error check
 
-  if (atom->molecular != 1)
+  if (atom->molecular != Atom::MOLECULAR)
     error->all(FLERR,"Cannot use fix bond/break with non-molecular systems");
 
   // initialize Marsaglia RNG with processor-unique seed
diff --git a/src/MC/fix_bond_create.cpp b/src/MC/fix_bond_create.cpp
index bcf7a7a843..c8c0af3a3e 100644
--- a/src/MC/fix_bond_create.cpp
+++ b/src/MC/fix_bond_create.cpp
@@ -148,7 +148,7 @@ FixBondCreate::FixBondCreate(LAMMPS *lmp, int narg, char **arg) :
 
   // error check
 
-  if (atom->molecular != 1)
+  if (atom->molecular != Atom::MOLECULAR)
     error->all(FLERR,"Cannot use fix bond/create with non-molecular systems");
   if (iatomtype == jatomtype &&
       ((imaxbond != jmaxbond) || (inewtype != jnewtype)))
diff --git a/src/MC/fix_bond_swap.cpp b/src/MC/fix_bond_swap.cpp
index 51334d6149..119c95d842 100644
--- a/src/MC/fix_bond_swap.cpp
+++ b/src/MC/fix_bond_swap.cpp
@@ -80,7 +80,7 @@ FixBondSwap::FixBondSwap(LAMMPS *lmp, int narg, char **arg) :
 
   // error check
 
-  if (atom->molecular != 1)
+  if (atom->molecular != Atom::MOLECULAR)
     error->all(FLERR,"Cannot use fix bond/swap with non-molecular systems");
 
   // create a new compute temp style
diff --git a/src/MC/fix_gcmc.cpp b/src/MC/fix_gcmc.cpp
index 1e607c9752..e8087f1344 100644
--- a/src/MC/fix_gcmc.cpp
+++ b/src/MC/fix_gcmc.cpp
@@ -2318,7 +2318,7 @@ double FixGCMC::energy_full()
 
   if (force->pair) force->pair->compute(eflag,vflag);
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) force->bond->compute(eflag,vflag);
     if (force->angle) force->angle->compute(eflag,vflag);
     if (force->dihedral) force->dihedral->compute(eflag,vflag);
diff --git a/src/MC/fix_widom.cpp b/src/MC/fix_widom.cpp
index 45f3ee5823..4a06dbafbd 100644
--- a/src/MC/fix_widom.cpp
+++ b/src/MC/fix_widom.cpp
@@ -1045,7 +1045,7 @@ double FixWidom::energy_full()
 
   if (force->pair) force->pair->compute(eflag,vflag);
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) force->bond->compute(eflag,vflag);
     if (force->angle) force->angle->compute(eflag,vflag);
     if (force->dihedral) force->dihedral->compute(eflag,vflag);
diff --git a/src/MLIAP/mliap_model_nn.cpp b/src/MLIAP/mliap_model_nn.cpp
index 158d2240c2..2bf75385b4 100644
--- a/src/MLIAP/mliap_model_nn.cpp
+++ b/src/MLIAP/mliap_model_nn.cpp
@@ -378,7 +378,7 @@ void MLIAPModelNN::compute_gradients(MLIAPData* data)
    egradient is derivative of energy w.r.t. parameters
    ---------------------------------------------------------------------- */
 
-void MLIAPModelNN::compute_gradgrads(class MLIAPData* data)
+void MLIAPModelNN::compute_gradgrads(class MLIAPData * /*data*/)
 {
   error->all(FLERR,"compute_gradgrads not implemented");
 }
@@ -388,7 +388,7 @@ void MLIAPModelNN::compute_gradgrads(class MLIAPData* data)
    egradient is derivative of energy w.r.t. parameters
    ---------------------------------------------------------------------- */
 
-void MLIAPModelNN::compute_force_gradients(class MLIAPData* data)
+void MLIAPModelNN::compute_force_gradients(class MLIAPData * /*data*/)
 {
   error->all(FLERR,"compute_force_gradients not implemented");
 }
@@ -397,7 +397,7 @@ void MLIAPModelNN::compute_force_gradients(class MLIAPData* data)
    count the number of non-zero entries in gamma matrix
    ---------------------------------------------------------------------- */
 
-int MLIAPModelNN::get_gamma_nnz(class MLIAPData* data)
+int MLIAPModelNN::get_gamma_nnz(class MLIAPData * /*data*/)
 {
   // todo: get_gamma_nnz
   return 0;
diff --git a/src/REPLICA/verlet_split.cpp b/src/REPLICA/verlet_split.cpp
index 506d074eca..d3cda94ef1 100644
--- a/src/REPLICA/verlet_split.cpp
+++ b/src/REPLICA/verlet_split.cpp
@@ -367,7 +367,7 @@ void VerletSplit::run(int n)
         timer->stamp(Timer::PAIR);
       }
 
-      if (atom->molecular) {
+      if (atom->molecular != Atom::ATOMIC) {
         if (force->bond) force->bond->compute(eflag,vflag);
         if (force->angle) force->angle->compute(eflag,vflag);
         if (force->dihedral) force->dihedral->compute(eflag,vflag);
diff --git a/src/USER-INTEL/npair_full_bin_intel.cpp b/src/USER-INTEL/npair_full_bin_intel.cpp
index 2ef9924a9e..7d16955493 100644
--- a/src/USER-INTEL/npair_full_bin_intel.cpp
+++ b/src/USER-INTEL/npair_full_bin_intel.cpp
@@ -74,7 +74,7 @@ fbi(NeighList *list, IntelBuffers<flt_t,acc_t> *buffers) {
                      _fix->nbor_pack_width());
 
   int need_ic = 0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     dminimum_image_check(need_ic, neighbor->cutneighmax, neighbor->cutneighmax,
                          neighbor->cutneighmax);
 
diff --git a/src/USER-INTEL/npair_half_bin_newton_intel.cpp b/src/USER-INTEL/npair_half_bin_newton_intel.cpp
index 0d2e6178ea..5b886d3de3 100644
--- a/src/USER-INTEL/npair_half_bin_newton_intel.cpp
+++ b/src/USER-INTEL/npair_half_bin_newton_intel.cpp
@@ -73,7 +73,7 @@ hbni(NeighList *list, IntelBuffers<flt_t,acc_t> *buffers) {
   buffers->grow_list(list, atom->nlocal, comm->nthreads, 0, off_end);
 
   int need_ic = 0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     dminimum_image_check(need_ic, neighbor->cutneighmax, neighbor->cutneighmax,
                          neighbor->cutneighmax);
 
diff --git a/src/USER-INTEL/npair_half_bin_newton_tri_intel.cpp b/src/USER-INTEL/npair_half_bin_newton_tri_intel.cpp
index 15d4766126..3c3680af03 100644
--- a/src/USER-INTEL/npair_half_bin_newton_tri_intel.cpp
+++ b/src/USER-INTEL/npair_half_bin_newton_tri_intel.cpp
@@ -73,7 +73,7 @@ hbnti(NeighList *list, IntelBuffers<flt_t,acc_t> *buffers) {
   buffers->grow_list(list, atom->nlocal, comm->nthreads, 0, off_end);
 
   int need_ic = 0;
-  if (atom->molecular)
+  if (atom->molecular != Atom::ATOMIC)
     dminimum_image_check(need_ic, neighbor->cutneighmax, neighbor->cutneighmax,
                          neighbor->cutneighmax);
 
diff --git a/src/USER-INTEL/verlet_lrt_intel.cpp b/src/USER-INTEL/verlet_lrt_intel.cpp
index aef5ad5b45..4fe1cf7f92 100644
--- a/src/USER-INTEL/verlet_lrt_intel.cpp
+++ b/src/USER-INTEL/verlet_lrt_intel.cpp
@@ -316,7 +316,7 @@ void VerletLRTIntel::run(int n)
       timer->stamp(Timer::PAIR);
     }
 
-    if (atom->molecular) {
+    if (atom->molecular != Atom::ATOMIC) {
       if (force->bond) force->bond->compute(eflag,vflag);
       if (force->angle) force->angle->compute(eflag,vflag);
       if (force->dihedral) force->dihedral->compute(eflag,vflag);
diff --git a/src/USER-MEAMC/meam.h b/src/USER-MEAMC/meam.h
index b974ce5bc8..e44e044d6e 100644
--- a/src/USER-MEAMC/meam.h
+++ b/src/USER-MEAMC/meam.h
@@ -17,7 +17,7 @@
 #include "math_const.h"         // IWYU pragma: export
 
 #include <cmath>
-#include <cstring>
+#include <string>
 
 #define maxelt 5
 
@@ -242,29 +242,29 @@ public:
   // only use single-element lattices if single=true
   // return false on failure
   // return true and set lat on success
-  static bool str_to_lat(const char* str, bool single, lattice_t& lat)
+  static bool str_to_lat(const std::string & str, bool single, lattice_t& lat)
   {
-    if (strcmp(str,"fcc") == 0) lat = FCC;
-    else if (strcmp(str,"bcc") == 0) lat = BCC;
-    else if (strcmp(str,"hcp") == 0) lat = HCP;
-    else if (strcmp(str,"dim") == 0) lat = DIM;
-    else if (strcmp(str,"dia") == 0) lat = DIA;
-    else if (strcmp(str,"dia3") == 0) lat = DIA3;
-    else if (strcmp(str,"lin") == 0) lat = LIN;
-    else if (strcmp(str,"zig") == 0) lat = ZIG;
-    else if (strcmp(str,"tri") == 0) lat = TRI;
+    if (str == "fcc") lat = FCC;
+    else if (str == "bcc") lat = BCC;
+    else if (str == "hcp") lat = HCP;
+    else if (str == "dim") lat = DIM;
+    else if (str == "dia") lat = DIA;
+    else if (str == "dia3") lat = DIA3;
+    else if (str == "lin") lat = LIN;
+    else if (str == "zig") lat = ZIG;
+    else if (str == "tri") lat = TRI;
     else {
       if (single)
         return false;
 
-      if (strcmp(str,"b1")  == 0) lat = B1;
-      else if (strcmp(str,"c11") == 0) lat = C11;
-      else if (strcmp(str,"l12") == 0) lat = L12;
-      else if (strcmp(str,"b2")  == 0) lat = B2;
-      else if (strcmp(str,"ch4")  == 0) lat = CH4;
-      else if (strcmp(str,"lin")  == 0) lat =LIN;
-      else if (strcmp(str,"zig")  == 0) lat = ZIG;
-      else if (strcmp(str,"tri")  == 0) lat = TRI;
+      if (str == "b1") lat = B1;
+      else if (str == "c11") lat = C11;
+      else if (str == "l12") lat = L12;
+      else if (str == "b2") lat = B2;
+      else if (str == "ch4") lat = CH4;
+      else if (str == "lin") lat =LIN;
+      else if (str == "zig") lat = ZIG;
+      else if (str == "tri") lat = TRI;
       else return false;
     }
     return true;
diff --git a/src/USER-MEAMC/pair_meamc.cpp b/src/USER-MEAMC/pair_meamc.cpp
index b9738f779d..29d81e9516 100644
--- a/src/USER-MEAMC/pair_meamc.cpp
+++ b/src/USER-MEAMC/pair_meamc.cpp
@@ -17,7 +17,7 @@
 
 #include "pair_meamc.h"
 
-#include <cstring>
+#include <memory>
 
 #include "meam.h"
 #include "atom.h"
@@ -28,6 +28,8 @@
 #include "neigh_request.h"
 #include "memory.h"
 #include "error.h"
+#include "potential_file_reader.h"
+#include "tokenizer.h"
 
 using namespace LAMMPS_NS;
 
@@ -54,8 +56,6 @@ PairMEAMC::PairMEAMC(LAMMPS *lmp) : Pair(lmp)
   allocated = 0;
 
   nelements = 0;
-  elements = nullptr;
-  mass = nullptr;
   meam_inst = new MEAM(memory);
   scale = nullptr;
 
@@ -74,10 +74,6 @@ PairMEAMC::~PairMEAMC()
 {
   delete meam_inst;
 
-  for (int i = 0; i < nelements; i++) delete [] elements[i];
-  delete [] elements;
-  delete [] mass;
-
   if (allocated) {
     memory->destroy(setflag);
     memory->destroy(cutsq);
@@ -192,7 +188,7 @@ void PairMEAMC::allocate()
    global settings
 ------------------------------------------------------------------------- */
 
-void PairMEAMC::settings(int narg, char **/*arg*/)
+void PairMEAMC::settings(int narg, char ** /*arg*/)
 {
   if (narg != 0) error->all(FLERR,"Illegal pair_style command");
 }
@@ -247,9 +243,8 @@ void PairMEAMC::coeff(int narg, char **arg)
   // elements = list of unique element names
 
   if (nelements) {
-    for (int i = 0; i < nelements; i++) delete [] elements[i];
-    delete [] elements;
-    delete [] mass;
+    elements.clear();
+    mass.clear();
   }
 
   nelements = paridx - 3;
@@ -258,13 +253,10 @@ void PairMEAMC::coeff(int narg, char **arg)
     error->all(FLERR,fmt::format("Too many elements extracted from MEAM "
                                  "library (current limit: {}). Increase "
                                  "'maxelt' in meam.h and recompile.", maxelt));
-  elements = new char*[nelements];
-  mass = new double[nelements];
 
   for (int i = 0; i < nelements; i++) {
-    n = strlen(arg[i+3]) + 1;
-    elements[i] = new char[n];
-    strcpy(elements[i],arg[i+3]);
+    elements.push_back(arg[i+3]);
+    mass.push_back(0.0);
   }
 
   // read MEAM library and parameter files
@@ -281,7 +273,7 @@ void PairMEAMC::coeff(int narg, char **arg)
     m = i - (4+nelements) + 1;
     int j;
     for (j = 0; j < nelements; j++)
-      if (strcmp(arg[i],elements[j]) == 0) break;
+      if (elements[j] == arg[i]) break;
     if (j < nelements) map[m] = j;
     else if (strcmp(arg[i],"NULL") == 0) map[m] = -1;
     else error->all(FLERR,"Incorrect args for pair coefficients");
@@ -358,272 +350,214 @@ double PairMEAMC::init_one(int i, int j)
 void PairMEAMC::read_files(const std::string &globalfile,
                            const std::string &userfile)
 {
+  read_global_meamc_file(globalfile);
+  read_user_meamc_file(userfile);
+}
+
+/* ---------------------------------------------------------------------- */
+
+void PairMEAMC::read_global_meamc_file(const std::string &globalfile)
+{
+  // allocate parameter arrays
+  std::vector<lattice_t> lat(nelements);
+  std::vector<int> ielement(nelements);
+  std::vector<int> ibar(nelements);
+  std::vector<double> z(nelements);
+  std::vector<double> atwt(nelements);
+  std::vector<double> alpha(nelements);
+  std::vector<double> b0(nelements);
+  std::vector<double> b1(nelements);
+  std::vector<double> b2(nelements);
+  std::vector<double> b3(nelements);
+  std::vector<double> alat(nelements);
+  std::vector<double> esub(nelements);
+  std::vector<double> asub(nelements);
+  std::vector<double> t0(nelements);
+  std::vector<double> t1(nelements);
+  std::vector<double> t2(nelements);
+  std::vector<double> t3(nelements);
+  std::vector<double> rozero(nelements);
+  std::vector<bool> found(nelements, false);
+
   // open global meamf file on proc 0
 
-  FILE *fp;
   if (comm->me == 0) {
-    fp = utils::open_potential(globalfile,lmp,nullptr);
-    if (fp == nullptr)
-      error->one(FLERR,fmt::format("Cannot open MEAM potential file {}",
-                                   globalfile));
-  }
+    PotentialFileReader reader(lmp, globalfile, "MEAM", " library");
+    char * line;
 
-  // allocate parameter arrays
-
-  int params_per_line = 19;
-
-  lattice_t *lat = new lattice_t[nelements];
-  int *ielement = new int[nelements];
-  int *ibar = new int[nelements];
-  double *z = new double[nelements];
-  double *atwt = new double[nelements];
-  double *alpha = new double[nelements];
-  double *b0 = new double[nelements];
-  double *b1 = new double[nelements];
-  double *b2 = new double[nelements];
-  double *b3 = new double[nelements];
-  double *alat = new double[nelements];
-  double *esub = new double[nelements];
-  double *asub = new double[nelements];
-  double *t0 = new double[nelements];
-  double *t1 = new double[nelements];
-  double *t2 = new double[nelements];
-  double *t3 = new double[nelements];
-  double *rozero = new double[nelements];
-
-  bool *found = new bool[nelements];
-  for (int i = 0; i < nelements; i++) found[i] = false;
-
-  // read each set of params from global MEAM file
-  // one set of params can span multiple lines
-  // store params if element name is in element list
-  // if element name appears multiple times, only store 1st entry
-
-  if (comm->me == 0) {
+    const int params_per_line = 19;
     int nset = 0;
-    char **words = new char*[params_per_line+1];
-    char line[MAXLINE];
-    while (1) {
-      char *ptr;
-      ptr = fgets(line,MAXLINE,fp);
-      if (ptr == nullptr) {
-        fclose(fp);
-        break;
+
+    while ((line = reader.next_line(params_per_line))) {
+      try {
+        ValueTokenizer values(line, "' \t\n\r\f");
+
+        // read each set of params from global MEAM file
+        // one set of params can span multiple lines
+        // store params if element name is in element list
+        // if element name appears multiple times, only store 1st entry
+        std::string element = values.next_string();
+
+        // skip if element name isn't in element list
+
+        int index;
+        for (index = 0; index < nelements; index++)
+          if (elements[index] == element) break;
+        if (index == nelements) continue;
+
+        // skip if element already appeared (technically error in library file, but always ignored)
+
+        if (found[index]) continue;
+        found[index] = true;
+
+        // map lat string to an integer
+        std::string lattice_type = values.next_string();
+
+        if (!MEAM::str_to_lat(lattice_type.c_str(), true, lat[index]))
+          error->one(FLERR,fmt::format("Unrecognized lattice type in MEAM "
+                                       "library file: {}", lattice_type));
+
+        // store parameters
+
+        z[index] = values.next_double();
+        ielement[index] = values.next_int();
+        atwt[index] = values.next_double();
+        alpha[index] = values.next_double();
+        b0[index] = values.next_double();
+        b1[index] = values.next_double();
+        b2[index] = values.next_double();
+        b3[index] = values.next_double();
+        alat[index] = values.next_double();
+        esub[index] = values.next_double();
+        asub[index] = values.next_double();
+        t0[index] = values.next_double();
+        t1[index] = values.next_double();
+        t2[index] = values.next_double();
+        t3[index] = values.next_double();
+        rozero[index] = values.next_double();
+        ibar[index] = values.next_int();
+
+        if (!isone(t0[index]))
+          error->one(FLERR,"Unsupported parameter in MEAM library file: t0!=1");
+
+        // z given is ignored: if this is mismatched, we definitely won't do what the user said -> fatal error
+        if (z[index] != MEAM::get_Zij(lat[index]))
+          error->one(FLERR,"Mismatched parameter in MEAM library file: z!=lat");
+
+        nset++;
+      } catch (TokenizerException &e) {
+        error->one(FLERR, e.what());
       }
-
-      // strip comment, skip line if blank
-
-      if ((ptr = strchr(line,'#'))) *ptr = '\0';
-      int nwords = utils::count_words(line);
-      if (nwords == 0) continue;
-
-      // concatenate additional lines until have params_per_line words
-
-      while (nwords < params_per_line) {
-        int n = strlen(line);
-        ptr = fgets(&line[n],MAXLINE-n,fp);
-        if (ptr == nullptr) {
-          fclose(fp);
-          break;
-        }
-        if ((ptr = strchr(line,'#'))) *ptr = '\0';
-        nwords = utils::count_words(line);
-      }
-
-      if (nwords != params_per_line)
-        error->one(FLERR,"Incorrect format in MEAM library file");
-
-      // words = ptrs to all words in line
-      // strip single and double quotes from words
-
-      nwords = 0;
-      words[nwords++] = strtok(line,"' \t\n\r\f");
-      while ((words[nwords++] = strtok(nullptr,"' \t\n\r\f"))) continue;
-
-      // skip if element name isn't in element list
-
-      int index;
-      for (index = 0; index < nelements; index++)
-        if (strcmp(words[0],elements[index]) == 0) break;
-      if (index == nelements) continue;
-
-      // skip if element already appeared (technically error in library file, but always ignored)
-
-      if (found[index] == true) continue;
-      found[index] = true;
-
-      // map lat string to an integer
-
-      if (!MEAM::str_to_lat(words[1], true, lat[index]))
-        error->one(FLERR,fmt::format("Unrecognized lattice type in MEAM "
-                                     "library file: {}", words[1]));
-
-      // store parameters
-
-      z[index] = atof(words[2]);
-      ielement[index] = atoi(words[3]);
-      atwt[index] = atof(words[4]);
-      alpha[index] = atof(words[5]);
-      b0[index] = atof(words[6]);
-      b1[index] = atof(words[7]);
-      b2[index] = atof(words[8]);
-      b3[index] = atof(words[9]);
-      alat[index] = atof(words[10]);
-      esub[index] = atof(words[11]);
-      asub[index] = atof(words[12]);
-      t0[index] = atof(words[13]);
-      t1[index] = atof(words[14]);
-      t2[index] = atof(words[15]);
-      t3[index] = atof(words[16]);
-      rozero[index] = atof(words[17]);
-      ibar[index] = atoi(words[18]);
-
-      if (!isone(t0[index]))
-        error->one(FLERR,"Unsupported parameter in MEAM library file: t0!=1");
-
-      // z given is ignored: if this is mismatched, we definitely won't do what the user said -> fatal error
-      if (z[index] != MEAM::get_Zij(lat[index]))
-        error->one(FLERR,"Mismatched parameter in MEAM library file: z!=lat");
-
-      nset++;
     }
 
     // error if didn't find all elements in file
 
     if (nset != nelements) {
-      char str[128] = "Did not find all elements in MEAM library file, missing:";
+      std::string msg = "Did not find all elements in MEAM library file, missing:";
       for (int i = 0; i < nelements; i++)
         if (!found[i]) {
-          strcat(str," ");
-          strcat(str,elements[i]);
+          msg += " ";
+          msg += elements[i];
         }
-      error->one(FLERR,str);
+      error->one(FLERR,msg);
     }
-
-    delete [] words;
   }
 
   // distribute complete parameter sets
-  MPI_Bcast(lat, nelements, MPI_INT, 0, world);
-  MPI_Bcast(ielement, nelements, MPI_INT, 0, world);
-  MPI_Bcast(ibar, nelements, MPI_INT, 0, world);
-  MPI_Bcast(z, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(atwt, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(alpha, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(b0, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(b1, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(b2, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(b3, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(alat, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(esub, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(asub, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(t0, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(t1, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(t2, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(t3, nelements, MPI_DOUBLE, 0, world);
-  MPI_Bcast(rozero, nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(lat.data(), nelements, MPI_INT, 0, world);
+  MPI_Bcast(ielement.data(), nelements, MPI_INT, 0, world);
+  MPI_Bcast(ibar.data(), nelements, MPI_INT, 0, world);
+  MPI_Bcast(z.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(atwt.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(alpha.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(b0.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(b1.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(b2.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(b3.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(alat.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(esub.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(asub.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(t0.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(t1.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(t2.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(t3.data(), nelements, MPI_DOUBLE, 0, world);
+  MPI_Bcast(rozero.data(), nelements, MPI_DOUBLE, 0, world);
 
   // pass element parameters to MEAM package
 
-  meam_inst->meam_setup_global(nelements,lat,ielement,atwt,alpha,b0,b1,b2,b3,
-                       alat,esub,asub,t0,t1,t2,t3,rozero,ibar);
+  meam_inst->meam_setup_global(nelements, lat.data(), ielement.data(), atwt.data(),
+                               alpha.data(), b0.data(), b1.data(), b2.data(), b3.data(),
+                               alat.data(), esub.data(), asub.data(), t0.data(), t1.data(),
+                               t2.data(), t3.data(), rozero.data(), ibar.data());
 
   // set element masses
 
   for (int i = 0; i < nelements; i++) mass[i] = atwt[i];
+}
 
-  // clean-up memory
-
-  delete [] lat;
-  delete [] ielement;
-  delete [] ibar;
-  delete [] z;
-  delete [] atwt;
-  delete [] alpha;
-  delete [] b0;
-  delete [] b1;
-  delete [] b2;
-  delete [] b3;
-  delete [] alat;
-  delete [] esub;
-  delete [] asub;
-  delete [] t0;
-  delete [] t1;
-  delete [] t2;
-  delete [] t3;
-  delete [] rozero;
-  delete [] found;
+/* ---------------------------------------------------------------------- */
 
+void PairMEAMC::read_user_meamc_file(const std::string &userfile)
+{
   // done if user param file is "NULL"
 
   if (userfile == "NULL") return;
 
   // open user param file on proc 0
 
+  std::shared_ptr<PotentialFileReader> reader;
+
   if (comm->me == 0) {
-    fp = utils::open_potential(userfile,lmp,nullptr);
-    if (fp == nullptr)
-      error->one(FLERR,fmt::format("Cannot open MEAM potential file {}",
-                                   userfile));
+    reader = std::make_shared<PotentialFileReader>(lmp, userfile, "MEAM");
   }
 
   // read settings
   // pass them one at a time to MEAM package
   // match strings to list of corresponding ints
+  char * line = nullptr;
+  char buffer[MAXLINE];
 
-  int maxparams = 6;
-  char **params = new char*[maxparams];
   while (1) {
     int which;
     int nindex, index[3];
     double value;
-    char line[MAXLINE];
     int nline;
-    char *ptr;
     if (comm->me == 0) {
-      ptr = fgets(line,MAXLINE,fp);
-      if (ptr == nullptr) {
-        fclose(fp);
+      line = reader->next_line();
+      if (line == nullptr) {
         nline = -1;
       } else nline = strlen(line) + 1;
+    } else {
+      line = buffer;
     }
+
     MPI_Bcast(&nline,1,MPI_INT,0,world);
     if (nline<0) break;
     MPI_Bcast(line,nline,MPI_CHAR,0,world);
 
-    // strip comment, skip line if blank
-
-    if ((ptr = strchr(line,'#'))) *ptr = '\0';
-    if (utils::count_words(line) == 0) continue;
-
-    // params = ptrs to all fields in line
-
-    int nparams = 0;
-    params[nparams++] = strtok(line,"=(), '\t\n\r\f");
-    while (nparams < maxparams &&
-           (params[nparams++] = strtok(nullptr,"=(), '\t\n\r\f")))
-      continue;
-    nparams--;
+    ValueTokenizer values(line, "=(), '\t\n\r\f");
+    int nparams = values.count();
+    std::string keyword = values.next_string();
 
     for (which = 0; which < nkeywords; which++)
-      if (strcmp(params[0],keywords[which]) == 0) break;
+      if (keyword == keywords[which]) break;
     if (which == nkeywords)
       error->all(FLERR,fmt::format("Keyword {} in MEAM parameter file not "
-                                   "recognized", params[0]));
+                                   "recognized", keyword));
 
     nindex = nparams - 2;
-    for (int i = 0; i < nindex; i++) index[i] = atoi(params[i+1]) - 1;
+    for (int i = 0; i < nindex; i++) index[i] = values.next_int() - 1;
 
     // map lattce_meam value to an integer
-
     if (which == 4) {
+      std::string lattice_type = values.next_string();
       lattice_t latt;
-      if (!MEAM::str_to_lat(params[nparams-1], false, latt))
+      if (!MEAM::str_to_lat(lattice_type, false, latt))
         error->all(FLERR, fmt::format("Unrecognized lattice type in MEAM "
-                                      "parameter file: {}", params[nparams-1]));
+                                      "parameter file: {}", lattice_type));
       value = latt;
     }
-    else value = atof(params[nparams-1]);
+    else value = values.next_double();
 
     // pass single setting to MEAM package
 
@@ -634,13 +568,10 @@ void PairMEAMC::read_files(const std::string &globalfile,
               "is out of range (please report a bug)",
               "expected more indices",
               "has out of range element index"};
-      char str[256];
       if ((errorflag < 0) || (errorflag > 3)) errorflag = 0;
-      snprintf(str,256,"Error in MEAM parameter file: keyword %s %s",params[0],descr[errorflag]);
-      error->all(FLERR,str);
+      error->all(FLERR, fmt::format("Error in MEAM parameter file: keyword {} {}", keyword, descr[errorflag]));
     }
   }
-  delete [] params;
 }
 
 /* ---------------------------------------------------------------------- */
diff --git a/src/USER-MEAMC/pair_meamc.h b/src/USER-MEAMC/pair_meamc.h
index 9cbda8f6ad..6bf6923869 100644
--- a/src/USER-MEAMC/pair_meamc.h
+++ b/src/USER-MEAMC/pair_meamc.h
@@ -22,7 +22,8 @@ PairStyle(meam,PairMEAMC)
 #define LMP_PAIR_MEAMC_H
 
 #include "pair.h"
-
+#include <vector>
+#include <string>
 
 namespace LAMMPS_NS {
 
@@ -48,14 +49,16 @@ class PairMEAMC : public Pair {
   class MEAM *meam_inst;
   double cutmax;                // max cutoff for all elements
   int nelements;                // # of unique elements
-  char **elements;              // names of unique elements
-  double *mass;                 // mass of each element
+  std::vector<std::string> elements; // names of unique elements
+  std::vector<double> mass;          // mass of each element
 
   int *map;                     // mapping from atom types (1-indexed) to elements (1-indexed)
   double **scale;               // scaling factor for adapt
 
   void allocate();
   void read_files(const std::string &, const std::string &);
+  void read_global_meamc_file(const std::string &);
+  void read_user_meamc_file(const std::string &);
   void neigh_strip(int, int *, int *, int **);
 };
 
diff --git a/src/USER-OMP/thr_data.cpp b/src/USER-OMP/thr_data.cpp
index 2935e87d04..951b9b2311 100644
--- a/src/USER-OMP/thr_data.cpp
+++ b/src/USER-OMP/thr_data.cpp
@@ -139,20 +139,6 @@ void ThrData::init_adp(int nall, double *rho, double **mu, double **lambda)
 
 /* ---------------------------------------------------------------------- */
 
-void ThrData::init_cdeam(int nall, double *rho, double *rhoB, double *D_values)
-{
-  init_eam(nall, rho);
-
-  if (nall >= 0 && rhoB && D_values) {
-    _rhoB = rhoB + _tid*nall;
-    _D_values = D_values + _tid*nall;
-    memset(_rhoB, 0, nall*sizeof(double));
-    memset(_D_values, 0, nall*sizeof(double));
-  }
-}
-
-/* ---------------------------------------------------------------------- */
-
 void ThrData::init_eim(int nall, double *rho, double *fp)
 {
   init_eam(nall, rho);
diff --git a/src/USER-OMP/thr_data.h b/src/USER-OMP/thr_data.h
index c942083ef5..685040f0b8 100644
--- a/src/USER-OMP/thr_data.h
+++ b/src/USER-OMP/thr_data.h
@@ -52,7 +52,6 @@ class ThrData {
 
   // setup and erase per atom arrays
   void init_adp(int, double *, double **, double **); // ADP (+ EAM)
-  void init_cdeam(int, double *, double *, double *); // CDEAM (+ EAM)
   void init_eam(int, double *);                       // EAM
   void init_eim(int, double *, double *);             // EIM (+ EAM)
 
diff --git a/src/arg_info.h b/src/arg_info.h
index 1a1114f6de..f1328985a5 100644
--- a/src/arg_info.h
+++ b/src/arg_info.h
@@ -67,14 +67,14 @@ namespace LAMMPS_NS {
     /*! get dimension of reference
      *
      * This will return either 0, 1, 2 depending on whether the
-     * reference has no, one or two "[<number>]" postfixes.
+     * reference has no, one or two "[{number}]" postfixes.
      *
      * \return  integer with the dimensionality of the reference */
     int  get_dim()  const { return dim; }
 
     /*! get index of first dimension
      *
-     * This will return the <number> in the first "[<number>]"
+     * This will return the number in the first "[{number}]"
      * postfix or 0 if there is no postfix.
      *
      * \return  integer with index or the postfix or 0 */
@@ -82,7 +82,7 @@ namespace LAMMPS_NS {
 
     /*! get index of second dimension
      *
-     * This will return the <number> in the second "[<number>]"
+     * This will return the number in the second "[{number}]"
      * postfix or -1 if there is no second postfix.
      *
      * \return  integer with index of the postfix or -1 */
diff --git a/src/atom.cpp b/src/atom.cpp
index fe260309e2..ecb82993ce 100644
--- a/src/atom.cpp
+++ b/src/atom.cpp
@@ -341,11 +341,8 @@ void Atom::settings(Atom *old)
   map_style = old->map_style;
   sortfreq = old->sortfreq;
   userbinsize = old->userbinsize;
-  if (old->firstgroupname) {
-    int n = strlen(old->firstgroupname) + 1;
-    firstgroupname = new char[n];
-    strcpy(firstgroupname,old->firstgroupname);
-  }
+  if (old->firstgroupname)
+    firstgroupname = utils::strdup(old->firstgroupname);
 }
 
 /* ----------------------------------------------------------------------
@@ -532,9 +529,7 @@ void Atom::add_peratom(const char *name, void *address,
       memory->srealloc(peratom,maxperatom*sizeof(PerAtom),"atom:peratom");
   }
 
-  int n = strlen(name) + 1;
-  peratom[nperatom].name = new char[n];
-  strcpy(peratom[nperatom].name,name);
+  peratom[nperatom].name = utils::strdup(name);
   peratom[nperatom].address = address;
   peratom[nperatom].datatype = datatype;
   peratom[nperatom].cols = cols;
@@ -582,9 +577,7 @@ void Atom::add_peratom_vary(const char *name, void *address,
       memory->srealloc(peratom,maxperatom*sizeof(PerAtom),"atom:peratom");
   }
 
-  int n = strlen(name) + 1;
-  peratom[nperatom].name = new char[n];
-  strcpy(peratom[nperatom].name,name);
+  peratom[nperatom].name = utils::strdup(name);
   peratom[nperatom].address = address;
   peratom[nperatom].datatype = datatype;
   peratom[nperatom].cols = -1;
@@ -670,7 +663,7 @@ void Atom::create_avec(const std::string &style, int narg, char **arg, int trysu
   // map style will be reset to array vs hash to by map_init()
 
   molecular = avec->molecular;
-  if (molecular && tag_enable == 0)
+  if ((molecular != Atom::ATOMIC) && (tag_enable == 0))
     error->all(FLERR,"Atom IDs must be used for molecular systems");
   if (molecular != Atom::ATOMIC) map_style = MAP_YES;
 }
@@ -815,9 +808,7 @@ void Atom::modify_params(int narg, char **arg)
         delete [] firstgroupname;
         firstgroupname = nullptr;
       } else {
-        int n = strlen(arg[iarg+1]) + 1;
-        firstgroupname = new char[n];
-        strcpy(firstgroupname,arg[iarg+1]);
+        firstgroupname = utils::strdup(arg[iarg+1]);
         sortfreq = 0;
       }
       iarg += 2;
@@ -1114,13 +1105,13 @@ void Atom::data_atoms(int n, char *buf, tagint id_offset, tagint mol_offset,
   for (int i = 0; i < n; i++) {
     next = strchr(buf,'\n');
 
-    values[0] = strtok(buf," \t\n\r\f");
-    if (values[0] == nullptr)
-      error->all(FLERR,"Incorrect atom format in data file");
-    for (m = 1; m < nwords; m++) {
-      values[m] = strtok(nullptr," \t\n\r\f");
-      if (values[m] == nullptr)
+    for (m = 0; m < nwords; m++) {
+      buf += strspn(buf," \t\n\r\f");
+      buf[strcspn(buf," \t\n\r\f")] = '\0';
+      if (strlen(buf) == 0)
         error->all(FLERR,"Incorrect atom format in data file");
+      values[m] = buf;
+      buf += strlen(buf)+1;
     }
 
     int imx = 0, imy = 0, imz = 0;
@@ -1217,9 +1208,12 @@ void Atom::data_vels(int n, char *buf, tagint id_offset)
   for (int i = 0; i < n; i++) {
     next = strchr(buf,'\n');
 
-    values[0] = strtok(buf," \t\n\r\f");
-    for (j = 1; j < nwords; j++)
-      values[j] = strtok(nullptr," \t\n\r\f");
+    for (j = 0; j < nwords; j++) {
+      buf += strspn(buf," \t\n\r\f");
+      buf[strcspn(buf," \t\n\r\f")] = '\0';
+      values[j] = buf;
+      buf += strlen(buf)+1;
+    }
 
     tagdata = ATOTAGINT(values[0]) + id_offset;
     if (tagdata <= 0 || tagdata > map_tag_max)
@@ -1569,9 +1563,12 @@ void Atom::data_bonus(int n, char *buf, AtomVec *avec_bonus, tagint id_offset)
   for (int i = 0; i < n; i++) {
     next = strchr(buf,'\n');
 
-    values[0] = strtok(buf," \t\n\r\f");
-    for (j = 1; j < nwords; j++)
-      values[j] = strtok(nullptr," \t\n\r\f");
+    for (j = 0; j < nwords; j++) {
+      buf += strspn(buf," \t\n\r\f");
+      buf[strcspn(buf," \t\n\r\f")] = '\0';
+      values[j] = buf;
+      buf += strlen(buf)+1;
+    }
 
     tagdata = ATOTAGINT(values[0]) + id_offset;
     if (tagdata <= 0 || tagdata > map_tag_max)
@@ -1611,8 +1608,10 @@ void Atom::data_bodies(int n, char *buf, AtomVec *avec_body, tagint id_offset)
   // else skip values
 
   for (int i = 0; i < n; i++) {
-    if (i == 0) tagdata = ATOTAGINT(strtok(buf," \t\n\r\f")) + id_offset;
-    else tagdata = ATOTAGINT(strtok(nullptr," \t\n\r\f")) + id_offset;
+    buf += strspn(buf," \t\n\r\f");
+    buf[strcspn(buf," \t\n\r\f")] = '\0';
+    tagdata = utils::tnumeric(FLERR,buf,false,lmp) + id_offset;
+    buf += strlen(buf)+1;
 
     if (tagdata <= 0 || tagdata > map_tag_max)
       error->one(FLERR,"Invalid atom ID in Bodies section of data file");
@@ -1622,8 +1621,15 @@ void Atom::data_bodies(int n, char *buf, AtomVec *avec_body, tagint id_offset)
     else
       error->one(FLERR,"Duplicate atom ID in Bodies section of data file");
 
-    ninteger = utils::inumeric(FLERR,strtok(nullptr," \t\n\r\f"),false,lmp);
-    ndouble = utils::inumeric(FLERR,strtok(nullptr," \t\n\r\f"),false,lmp);
+    buf += strspn(buf," \t\n\r\f");
+    buf[strcspn(buf," \t\n\r\f")] = '\0';
+    ninteger = utils::inumeric(FLERR,buf,false,lmp);
+    buf += strlen(buf)+1;
+
+    buf += strspn(buf," \t\n\r\f");
+    buf[strcspn(buf," \t\n\r\f")] = '\0';
+    ndouble = utils::inumeric(FLERR,buf,false,lmp);
+    buf += strlen(buf)+1;
 
     if ((m = map(tagdata)) >= 0) {
       if (ninteger > maxint) {
@@ -1637,17 +1643,29 @@ void Atom::data_bodies(int n, char *buf, AtomVec *avec_body, tagint id_offset)
         dvalues = new double[maxdouble];
       }
 
-      for (j = 0; j < ninteger; j++)
-        ivalues[j] = utils::inumeric(FLERR,strtok(nullptr," \t\n\r\f"),false,lmp);
-      for (j = 0; j < ndouble; j++)
-        dvalues[j] = utils::numeric(FLERR,strtok(nullptr," \t\n\r\f"),false,lmp);
+      for (j = 0; j < ninteger; j++) {
+        buf += strspn(buf," \t\n\r\f");
+        buf[strcspn(buf," \t\n\r\f")] = '\0';
+        ivalues[j] = utils::inumeric(FLERR,buf,false,lmp);
+        buf += strlen(buf)+1;
+      }
+
+      for (j = 0; j < ndouble; j++) {
+        buf += strspn(buf," \t\n\r\f");
+        buf[strcspn(buf," \t\n\r\f")] = '\0';
+        dvalues[j] = utils::numeric(FLERR,buf,false,lmp);
+        buf += strlen(buf)+1;
+      }
 
       avec_body->data_body(m,ninteger,ndouble,ivalues,dvalues);
 
     } else {
       nvalues = ninteger + ndouble;    // number of values to skip
-      for (j = 0; j < nvalues; j++)
-        strtok(nullptr," \t\n\r\f");
+      for (j = 0; j < nvalues; j++) {
+        buf += strspn(buf," \t\n\r\f");
+        buf[strcspn(buf," \t\n\r\f")] = '\0';
+        buf += strlen(buf)+1;
+      }
     }
   }
 
@@ -2400,9 +2418,7 @@ int Atom::add_custom(const char *name, int flag)
     nivector++;
     iname = (char **) memory->srealloc(iname,nivector*sizeof(char *),
                                        "atom:iname");
-    int n = strlen(name) + 1;
-    iname[index] = new char[n];
-    strcpy(iname[index],name);
+    iname[index] = utils::strdup(name);
     ivector = (int **) memory->srealloc(ivector,nivector*sizeof(int *),
                                         "atom:ivector");
     memory->create(ivector[index],nmax,"atom:ivector");
@@ -2411,9 +2427,7 @@ int Atom::add_custom(const char *name, int flag)
     ndvector++;
     dname = (char **) memory->srealloc(dname,ndvector*sizeof(char *),
                                        "atom:dname");
-    int n = strlen(name) + 1;
-    dname[index] = new char[n];
-    strcpy(dname[index],name);
+    dname[index] = utils::strdup(name);
     dvector = (double **) memory->srealloc(dvector,ndvector*sizeof(double *),
                                            "atom:dvector");
     memory->create(dvector[index],nmax,"atom:dvector");
diff --git a/src/atom_vec.cpp b/src/atom_vec.cpp
index 4406ac5f23..7d7cfa4878 100644
--- a/src/atom_vec.cpp
+++ b/src/atom_vec.cpp
@@ -154,11 +154,8 @@ void AtomVec::store_args(int narg, char **arg)
   nargcopy = narg;
   if (nargcopy) argcopy = new char*[nargcopy];
   else argcopy = nullptr;
-  for (int i = 0; i < nargcopy; i++) {
-    int n = strlen(arg[i]) + 1;
-    argcopy[i] = new char[n];
-    strcpy(argcopy[i],arg[i]);
-  }
+  for (int i = 0; i < nargcopy; i++)
+    argcopy[i] = utils::strdup(arg[i]);
 }
 
 /* ----------------------------------------------------------------------
diff --git a/src/atom_vec_hybrid.cpp b/src/atom_vec_hybrid.cpp
index 8679b7383d..6ddb72a1bf 100644
--- a/src/atom_vec_hybrid.cpp
+++ b/src/atom_vec_hybrid.cpp
@@ -109,8 +109,7 @@ void AtomVecHybrid::process_args(int narg, char **arg)
       if (strcmp(arg[iarg],keywords[i]) == 0)
         error->all(FLERR,"Atom style hybrid cannot use same atom style twice");
     styles[nstyles] = atom->new_avec(arg[iarg],1,dummy);
-    keywords[nstyles] = new char[strlen(arg[iarg])+1];
-    strcpy(keywords[nstyles],arg[iarg]);
+    keywords[nstyles] = utils::strdup(arg[iarg]);
     jarg = iarg + 1;
     while (jarg < narg && !known_style(arg[jarg])) jarg++;
     styles[nstyles]->process_args(jarg-iarg-1,&arg[iarg+1]);
@@ -601,13 +600,10 @@ void AtomVecHybrid::build_styles()
 
   allstyles = new char*[nallstyles];
 
-  int n;
   nallstyles = 0;
 #define ATOM_CLASS
-#define AtomStyle(key,Class)                \
-  n = strlen(#key) + 1;                     \
-  allstyles[nallstyles] = new char[n];      \
-  strcpy(allstyles[nallstyles],#key);       \
+#define AtomStyle(key,Class)                   \
+  allstyles[nallstyles] = utils::strdup(#key); \
   nallstyles++;
 #include "style_atom.h"  // IWYU pragma: keep
 #undef AtomStyle
diff --git a/src/body.cpp b/src/body.cpp
index 35d6e53753..89bb2fc1d9 100644
--- a/src/body.cpp
+++ b/src/body.cpp
@@ -20,9 +20,7 @@ using namespace LAMMPS_NS;
 
 Body::Body(LAMMPS *lmp, int /*narg*/, char **arg) : Pointers(lmp)
 {
-  int n = strlen(arg[0]) + 1;
-  style = new char[n];
-  strcpy(style,arg[0]);
+  style = utils::strdup(arg[0]);
   icp = nullptr;
   dcp = nullptr;
 }
diff --git a/src/comm.cpp b/src/comm.cpp
index 8e119744fc..6d3f72d9c0 100644
--- a/src/comm.cpp
+++ b/src/comm.cpp
@@ -149,16 +149,11 @@ void Comm::copy_arrays(Comm *oldcomm)
     memcpy(cutusermulti,oldcomm->cutusermulti,atom->ntypes+1);
   }
 
-  if (customfile) {
-    int n = strlen(oldcomm->customfile) + 1;
-    customfile = new char[n];
-    strcpy(customfile,oldcomm->customfile);
-  }
-  if (outfile) {
-    int n = strlen(oldcomm->outfile) + 1;
-    outfile = new char[n];
-    strcpy(outfile,oldcomm->outfile);
-  }
+  if (customfile)
+    customfile = utils::strdup(oldcomm->customfile);
+
+  if (outfile)
+    outfile = utils::strdup(oldcomm->outfile);
 }
 
 /* ----------------------------------------------------------------------
@@ -391,9 +386,7 @@ void Comm::set_processors(int narg, char **arg)
         if (iarg+3 > narg) error->all(FLERR,"Illegal processors command");
         gridflag = CUSTOM;
         delete [] customfile;
-        int n = strlen(arg[iarg+2]) + 1;
-        customfile = new char[n];
-        strcpy(customfile,arg[iarg+2]);
+        customfile = utils::strdup(arg[iarg+2]);
         iarg += 1;
 
       } else error->all(FLERR,"Illegal processors command");
@@ -453,9 +446,7 @@ void Comm::set_processors(int narg, char **arg)
     } else if (strcmp(arg[iarg],"file") == 0) {
       if (iarg+2 > narg) error->all(FLERR,"Illegal processors command");
       delete [] outfile;
-      int n = strlen(arg[iarg+1]) + 1;
-      outfile = new char[n];
-      strcpy(outfile,arg[iarg+1]);
+      outfile = utils::strdup(arg[iarg+1]);
       iarg += 2;
 
     } else error->all(FLERR,"Illegal processors command");
diff --git a/src/compute_fragment_atom.cpp b/src/compute_fragment_atom.cpp
index b0ad8e5e60..5e4f6e92d3 100644
--- a/src/compute_fragment_atom.cpp
+++ b/src/compute_fragment_atom.cpp
@@ -82,7 +82,7 @@ void ComputeFragmentAtom::init()
 {
   if (atom->tag_enable == 0)
     error->all(FLERR,"Cannot use compute fragment/atom unless atoms have IDs");
-  if (!atom->molecular)
+  if (atom->molecular != Atom::MOLECULAR)
     error->all(FLERR,"Compute fragment/atom requires a molecular system");
 
   int count = 0;
diff --git a/src/compute_pe.cpp b/src/compute_pe.cpp
index b7078675e5..db9ed97455 100644
--- a/src/compute_pe.cpp
+++ b/src/compute_pe.cpp
@@ -83,7 +83,7 @@ double ComputePE::compute_scalar()
   if (pairflag && force->pair)
     one += force->pair->eng_vdwl + force->pair->eng_coul;
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (bondflag && force->bond) one += force->bond->energy;
     if (angleflag && force->angle) one += force->angle->energy;
     if (dihedralflag && force->dihedral) one += force->dihedral->energy;
diff --git a/src/create_bonds.cpp b/src/create_bonds.cpp
index e5274d2cf8..494e743c05 100644
--- a/src/create_bonds.cpp
+++ b/src/create_bonds.cpp
@@ -48,7 +48,7 @@ void CreateBonds::command(int narg, char **arg)
     error->all(FLERR,"Create_bonds command before simulation box is defined");
   if (atom->tag_enable == 0)
     error->all(FLERR,"Cannot use create_bonds unless atoms have IDs");
-  if (atom->molecular != 1)
+  if (atom->molecular != Atom::MOLECULAR)
     error->all(FLERR,"Cannot use create_bonds with non-molecular system");
 
   if (narg < 4) error->all(FLERR,"Illegal create_bonds command");
diff --git a/src/create_box.cpp b/src/create_box.cpp
index 080483b6a1..000fb42495 100644
--- a/src/create_box.cpp
+++ b/src/create_box.cpp
@@ -83,7 +83,7 @@ void CreateBox::command(int narg, char **arg)
 
   // if molecular, zero out topology info
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     atom->bond_per_atom = 0;
     atom->angle_per_atom = 0;
     atom->dihedral_per_atom = 0;
diff --git a/src/delete_bonds.cpp b/src/delete_bonds.cpp
index d77e9e5f43..5a487743e1 100644
--- a/src/delete_bonds.cpp
+++ b/src/delete_bonds.cpp
@@ -40,7 +40,7 @@ void DeleteBonds::command(int narg, char **arg)
     error->all(FLERR,"Delete_bonds command before simulation box is defined");
   if (atom->natoms == 0)
     error->all(FLERR,"Delete_bonds command with no atoms existing");
-  if (atom->molecular != 1)
+  if (atom->molecular != Atom::MOLECULAR)
     error->all(FLERR,"Cannot use delete_bonds with non-molecular system");
 
   if (narg < 2) error->all(FLERR,"Illegal delete_bonds command");
diff --git a/src/deprecated.cpp b/src/deprecated.cpp
index 8523cf353a..40974e202b 100644
--- a/src/deprecated.cpp
+++ b/src/deprecated.cpp
@@ -25,7 +25,7 @@ using namespace LAMMPS_NS;
 
 /* ---------------------------------------------------------------------- */
 
-void Deprecated::command(int /* narg */, char ** /* arg */)
+void Deprecated::command(int narg, char **arg)
 {
   const std::string cmd = input->command;
 
@@ -38,7 +38,15 @@ void Deprecated::command(int /* narg */, char ** /* arg */)
       utils::logmesg(lmp,"\n'reset_ids' has been renamed to 'reset_atom_ids'\n\n");
   } else if (utils::strmatch(cmd,"^kim_")) {
     if (lmp->comm->me == 0)
-      utils::logmesg(lmp,"\n'kim_<command>' has been renamed to 'kim <command>'\n\n");
+      utils::logmesg(lmp,"\nWARNING: 'kim_<command>' has been renamed to "
+                      "'kim <command>'. Please update your input.\n\n");
+    std::string newcmd("kim");
+    newcmd += " " + cmd.substr(4);
+    for (int i=0; i < narg; ++i) {
+       newcmd.append(1,' ');
+       newcmd.append(arg[i]);
+    }
+    input->one(newcmd);
   }
   error->all(FLERR,"This command is no longer available");
 }
diff --git a/src/domain.cpp b/src/domain.cpp
index 1becba5e0b..c6dee63221 100644
--- a/src/domain.cpp
+++ b/src/domain.cpp
@@ -1826,10 +1826,10 @@ void Domain::delete_region(int narg, char **arg)
    return -1 if no such region
 ------------------------------------------------------------------------- */
 
-int Domain::find_region(char *name)
+int Domain::find_region(const std::string &name)
 {
   for (int iregion = 0; iregion < nregion; iregion++)
-    if (strcmp(name,regions[iregion]->id) == 0) return iregion;
+    if (name == regions[iregion]->id) return iregion;
   return -1;
 }
 
diff --git a/src/domain.h b/src/domain.h
index c3ea9e2bea..99349edb5d 100644
--- a/src/domain.h
+++ b/src/domain.h
@@ -130,7 +130,7 @@ class Domain : protected Pointers {
   void set_lattice(int, char **);
   void add_region(int, char **);
   void delete_region(int, char **);
-  int find_region(char *);
+  int find_region(const std::string &);
   void set_boundary(int, char **, int);
   void set_box(int, char **);
   void print_box(const std::string &);
diff --git a/src/dump_atom.cpp b/src/dump_atom.cpp
index effb7c7ed3..ab043e67c8 100644
--- a/src/dump_atom.cpp
+++ b/src/dump_atom.cpp
@@ -47,20 +47,12 @@ void DumpAtom::init_style()
   // format = copy of default or user-specified line format
   // default depends on image flags
 
-  delete [] format;
+  delete[] format;
   if (format_line_user) {
-    int n = strlen(format_line_user) + 2;
-    format = new char[n];
-    strcpy(format,format_line_user);
-    strcat(format,"\n");
+    format = utils::strdup(std::string(format_line_user) + "\n");
   } else {
-    char *str;
-    if (image_flag == 0) str = (char *) TAGINT_FORMAT " %d %g %g %g";
-    else str = (char *) TAGINT_FORMAT " %d %g %g %g %d %d %d";
-    int n = strlen(str) + 2;
-    format = new char[n];
-    strcpy(format,str);
-    strcat(format,"\n");
+    if (image_flag == 0) format = utils::strdup(TAGINT_FORMAT " %d %g %g %g\n");
+    else format = utils::strdup(TAGINT_FORMAT " %d %g %g %g %d %d %d\n");
   }
 
   // setup boundary string
diff --git a/src/dump_custom.cpp b/src/dump_custom.cpp
index 07e51ce54a..53bc9449a0 100644
--- a/src/dump_custom.cpp
+++ b/src/dump_custom.cpp
@@ -150,39 +150,38 @@ DumpCustom::DumpCustom(LAMMPS *lmp, int narg, char **arg) :
 
   ntypes = atom->ntypes;
   typenames = new char*[ntypes+1];
-  for (int itype = 1; itype <= ntypes; itype++) {
-    typenames[itype] = new char[2];
-    strcpy(typenames[itype],"C");
-  }
+  for (int itype = 1; itype <= ntypes; itype++)
+    typenames[itype] = utils::strdup("C");
 
   // setup format strings
 
   vformat = new char*[nfield];
+  std::string cols;
 
-  format_default = new char[4*nfield+1];
-  format_default[0] = '\0';
-
+  cols.clear();
   for (int i = 0; i < nfield; i++) {
-    if (vtype[i] == Dump::INT) strcat(format_default,"%d ");
-    else if (vtype[i] == Dump::DOUBLE) strcat(format_default,"%g ");
-    else if (vtype[i] == Dump::STRING) strcat(format_default,"%s ");
-    else if (vtype[i] == Dump::BIGINT) strcat(format_default,BIGINT_FORMAT " ");
+    if (vtype[i] == Dump::INT) cols += "%d ";
+    else if (vtype[i] == Dump::DOUBLE) cols += "%g ";
+    else if (vtype[i] == Dump::STRING) cols += "%s ";
+    else if (vtype[i] == Dump::BIGINT) cols += BIGINT_FORMAT " ";
     vformat[i] = nullptr;
   }
+  cols.resize(cols.size()-1);
+  format_default = utils::strdup(cols);
 
   format_column_user = new char*[nfield];
   for (int i = 0; i < nfield; i++) format_column_user[i] = nullptr;
 
   // setup column string
 
-  int n = 0;
-  for (int iarg = 0; iarg < nfield; iarg++) n += strlen(earg[iarg]) + 2;
-  columns = new char[n];
-  columns[0] = '\0';
+  cols.clear();
   for (int iarg = 0; iarg < nfield; iarg++) {
-    strcat(columns,earg[iarg]);
-    if (iarg+1 < nfield) strcat(columns," ");
+    cols += earg[iarg];
+    cols += " ";
   }
+  // remove trailing blank and copy
+  cols.resize(cols.size()-1);
+  columns = utils::strdup(cols);
 }
 
 /* ---------------------------------------------------------------------- */
@@ -263,44 +262,36 @@ void DumpCustom::init_style()
   // format = copy of default or user-specified line format
 
   delete [] format;
-  char *str;
-  if (format_line_user) str = format_line_user;
-  else str = format_default;
-
-  int n = strlen(str) + 1;
-  format = new char[n];
-  strcpy(format,str);
+  if (format_line_user) format = utils::strdup(format_line_user);
+  else format = utils::strdup(format_default);
 
   // tokenize the format string and add space at end of each format element
   // if user-specified int/float format exists, use it instead
   // if user-specified column format exists, use it instead
   // lo priority = line, medium priority = int/float, hi priority = column
 
-  char *ptr;
-  for (int i = 0; i < nfield; i++) {
-    if (i == 0) ptr = strtok(format," \0");
-    else ptr = strtok(nullptr," \0");
-    if (ptr == nullptr) error->all(FLERR,"Dump_modify format line is too short");
+  auto words = utils::split_words(format);
+  if ((int) words.size() < nfield)
+    error->all(FLERR,"Dump_modify format line is too short");
+
+  int i=0;
+  for (auto word : words) {
     delete [] vformat[i];
 
-    if (format_column_user[i]) {
-      vformat[i] = new char[strlen(format_column_user[i]) + 2];
-      strcpy(vformat[i],format_column_user[i]);
-    } else if (vtype[i] == Dump::INT && format_int_user) {
-      vformat[i] = new char[strlen(format_int_user) + 2];
-      strcpy(vformat[i],format_int_user);
-    } else if (vtype[i] == Dump::DOUBLE && format_float_user) {
-      vformat[i] = new char[strlen(format_float_user) + 2];
-      strcpy(vformat[i],format_float_user);
-    } else if (vtype[i] == Dump::BIGINT && format_bigint_user) {
-      vformat[i] = new char[strlen(format_bigint_user) + 2];
-      strcpy(vformat[i],format_bigint_user);
-    } else {
-      vformat[i] = new char[strlen(ptr) + 2];
-      strcpy(vformat[i],ptr);
-    }
+    if (format_column_user[i])
+      vformat[i] = utils::strdup(std::string(format_column_user[i]) + " ");
+    else if (vtype[i] == Dump::INT && format_int_user)
+      vformat[i] = utils::strdup(std::string(format_int_user) + " ");
+    else if (vtype[i] == Dump::DOUBLE && format_float_user)
+      vformat[i] = utils::strdup(std::string(format_float_user) + " ");
+    else if (vtype[i] == Dump::BIGINT && format_bigint_user)
+      vformat[i] = utils::strdup(std::string(format_int_user) + " ");
+    else vformat[i] = utils::strdup(word + " ");
 
-    if (i+1 < nfield) vformat[i] = strcat(vformat[i]," ");
+    // remove trailing blank on last column's format
+    if (i == nfield-1) vformat[i][strlen(vformat[i])-1] = '\0';
+
+    ++i;
   }
 
   // setup boundary string
diff --git a/src/dump_image.cpp b/src/dump_image.cpp
index 9fc05aaf71..69ebad9c52 100644
--- a/src/dump_image.cpp
+++ b/src/dump_image.cpp
@@ -31,6 +31,7 @@
 #include "memory.h"
 #include "modify.h"
 #include "molecule.h"
+#include "tokenizer.h"
 #include "variable.h"
 
 #include <cmath>
@@ -1207,32 +1208,19 @@ int DumpImage::modify_param(int narg, char **arg)
     int nlo,nhi;
     utils::bounds(FLERR,arg[1],1,atom->ntypes,nlo,nhi,error);
 
-    // ptrs = list of ncount colornames separated by '/'
+    // get list of colors
+    auto colors = Tokenizer(arg[2],"/").as_vector();
+    const int ncolors = colors.size();
 
-    int ncount = 1;
-    char *nextptr;
-    char *ptr = arg[2];
-    while ((nextptr = strchr(ptr,'/'))) {
-      ptr = nextptr + 1;
-      ncount++;
-    }
-    char **ptrs = new char*[ncount+1];
-    ncount = 0;
-    ptrs[ncount++] = strtok(arg[2],"/");
-    while ((ptrs[ncount++] = strtok(nullptr,"/")));
-    ncount--;
-
-    // assign each of ncount colors in round-robin fashion to types
+    // assign colors in round-robin fashion to types
 
     int m = 0;
     for (int i = nlo; i <= nhi; i++) {
-      colortype[i] = image->color2rgb(ptrs[m%ncount]);
+      colortype[i] = image->color2rgb(colors[m%ncolors].c_str());
       if (colortype[i] == nullptr)
         error->all(FLERR,"Invalid color in dump_modify command");
       m++;
     }
-
-    delete [] ptrs;
     return 3;
   }
 
diff --git a/src/dump_local.cpp b/src/dump_local.cpp
index 58a047cf97..beb9236d63 100644
--- a/src/dump_local.cpp
+++ b/src/dump_local.cpp
@@ -26,8 +26,6 @@
 
 using namespace LAMMPS_NS;
 
-enum{INT,DOUBLE};
-
 #define ONEFIELD 32
 #define DELTA 1048576
 
@@ -93,8 +91,8 @@ DumpLocal::DumpLocal(LAMMPS *lmp, int narg, char **arg) :
   format_default[0] = '\0';
 
   for (int i = 0; i < size_one; i++) {
-    if (vtype[i] == INT) strcat(format_default,"%d ");
-    else if (vtype[i] == DOUBLE) strcat(format_default,"%g ");
+    if (vtype[i] == Dump::INT) strcat(format_default,"%d ");
+    else if (vtype[i] == Dump::DOUBLE) strcat(format_default,"%g ");
     vformat[i] = nullptr;
   }
 
@@ -103,21 +101,16 @@ DumpLocal::DumpLocal(LAMMPS *lmp, int narg, char **arg) :
 
   // setup column string
 
-  int n = 0;
-  for (int iarg = 0; iarg < nfield; iarg++) n += strlen(earg[iarg]) + 2;
-  columns = new char[n];
-  columns[0] = '\0';
+  std::string cols;
   for (int iarg = 0; iarg < nfield; iarg++) {
-    strcat(columns,earg[iarg]);
-    strcat(columns," ");
+    cols += earg[iarg];
+    cols += " ";
   }
+  columns = utils::strdup(cols);
 
   // setup default label string
 
-  char *str = (char *) "ENTRIES";
-  n = strlen(str) + 1;
-  label = new char[n];
-  strcpy(label,str);
+  label = utils::strdup("ENTRIES");
 
   // if wildcard expansion occurred, free earg memory from exapnd_args()
 
@@ -164,41 +157,30 @@ void DumpLocal::init_style()
   // format = copy of default or user-specified line format
 
   delete [] format;
-  char *str;
-  if (format_line_user) str = format_line_user;
-  else str = format_default;
-
-  int n = strlen(str) + 1;
-  format = new char[n];
-  strcpy(format,str);
+  if (format_line_user) format = utils::strdup(format_line_user);
+  else format = utils::strdup(format_default);
 
   // tokenize the format string and add space at end of each format element
   // if user-specified int/float format exists, use it instead
   // if user-specified column format exists, use it instead
   // lo priority = line, medium priority = int/float, hi priority = column
 
-  char *ptr;
-  for (int i = 0; i < size_one; i++) {
-    if (i == 0) ptr = strtok(format," \0");
-    else ptr = strtok(nullptr," \0");
-    if (ptr == nullptr) error->all(FLERR,"Dump_modify format line is too short");
+  auto words = utils::split_words(format);
+  if ((int) words.size() <  size_one)
+    error->all(FLERR,"Dump_modify format line is too short");
+
+  int i=0;
+  for (auto word : words) {
     delete [] vformat[i];
 
-    if (format_column_user[i]) {
-      vformat[i] = new char[strlen(format_column_user[i]) + 2];
-      strcpy(vformat[i],format_column_user[i]);
-    } else if (vtype[i] == INT && format_int_user) {
-      vformat[i] = new char[strlen(format_int_user) + 2];
-      strcpy(vformat[i],format_int_user);
-    } else if (vtype[i] == DOUBLE && format_float_user) {
-      vformat[i] = new char[strlen(format_float_user) + 2];
-      strcpy(vformat[i],format_float_user);
-    } else {
-      vformat[i] = new char[strlen(ptr) + 2];
-      strcpy(vformat[i],ptr);
-    }
-
-    vformat[i] = strcat(vformat[i]," ");
+    if (format_column_user[i])
+      vformat[i] = utils::strdup(std::string(format_column_user[i]) + " ");
+    else if (vtype[i] == Dump::INT && format_int_user)
+      vformat[i] = utils::strdup(std::string(format_int_user) + " ");
+    else if (vtype[i] == Dump::DOUBLE && format_float_user)
+      vformat[i] = utils::strdup(std::string(format_float_user) + " ");
+    else vformat[i] = utils::strdup(word + " ");
+    ++i;
   }
 
   // setup boundary string
@@ -241,9 +223,7 @@ int DumpLocal::modify_param(int narg, char **arg)
   if (strcmp(arg[0],"label") == 0) {
     if (narg < 2) error->all(FLERR,"Illegal dump_modify command");
     delete [] label;
-    int n = strlen(arg[1]) + 1;
-    label = new char[n];
-    strcpy(label,arg[1]);
+    label = utils::strdup(arg[1]);
     return 2;
   }
   return 0;
@@ -353,7 +333,7 @@ int DumpLocal::convert_string(int n, double *mybuf)
     }
 
     for (j = 0; j < size_one; j++) {
-      if (vtype[j] == INT)
+      if (vtype[j] == Dump::INT)
         offset += sprintf(&sbuf[offset],vformat[j],static_cast<int> (mybuf[m]));
       else
         offset += sprintf(&sbuf[offset],vformat[j],mybuf[m]);
@@ -388,7 +368,7 @@ void DumpLocal::write_lines(int n, double *mybuf)
   int m = 0;
   for (i = 0; i < n; i++) {
     for (j = 0; j < size_one; j++) {
-      if (vtype[j] == INT) fprintf(fp,vformat[j],static_cast<int> (mybuf[m]));
+      if (vtype[j] == Dump::INT) fprintf(fp,vformat[j],static_cast<int> (mybuf[m]));
       else fprintf(fp,vformat[j],mybuf[m]);
       m++;
     }
@@ -408,13 +388,13 @@ void DumpLocal::parse_fields(int narg, char **arg)
 
     if (strcmp(arg[iarg],"index") == 0) {
       pack_choice[iarg] = &DumpLocal::pack_index;
-      vtype[iarg] = INT;
+      vtype[iarg] = Dump::INT;
 
     } else {
       int n;
       ArgInfo argi(arg[iarg],ArgInfo::COMPUTE|ArgInfo::FIX);
       computefixflag = 1;
-      vtype[iarg] = DOUBLE;
+      vtype[iarg] = Dump::DOUBLE;
       argindex[iarg] = argi.get_index1();
 
       switch (argi.get_type()) {
diff --git a/src/fix_numdiff.cpp b/src/fix_numdiff.cpp
index 4be6d07d3d..10926ec440 100644
--- a/src/fix_numdiff.cpp
+++ b/src/fix_numdiff.cpp
@@ -292,7 +292,7 @@ double FixNumDiff::update_energy()
 
   if (pair_compute_flag) force->pair->compute(eflag,0);
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) force->bond->compute(eflag,0);
     if (force->angle) force->angle->compute(eflag,0);
     if (force->dihedral) force->dihedral->compute(eflag,0);
diff --git a/src/fix_property_atom.cpp b/src/fix_property_atom.cpp
index f18888bbfc..56add7a0d1 100644
--- a/src/fix_property_atom.cpp
+++ b/src/fix_property_atom.cpp
@@ -17,6 +17,7 @@
 #include "comm.h"
 #include "error.h"
 #include "memory.h"
+#include "tokenizer.h"
 
 #include <cstring>
 
@@ -214,67 +215,51 @@ void FixPropertyAtom::read_data_section(char *keyword, int n, char *buf,
     atom->map_set();
   }
 
-  next = strchr(buf,'\n');
-  *next = '\0';
-  int nwords = utils::trim_and_count_words(buf);
-  *next = '\n';
-
-  if (nwords != nvalue+1)
-    error->all(FLERR,fmt::format("Incorrect {} format in data file",keyword));
-
-  char **values = new char*[nwords];
-
   // loop over lines of atom info
   // tokenize the line into values
-  // if I own atom tag, unpack its values
+  // if I own atom tag, assign its values
 
   tagint map_tag_max = atom->map_tag_max;
 
   for (int i = 0; i < n; i++) {
     next = strchr(buf,'\n');
+    *next = '\0';
 
-    values[0] = strtok(buf," \t\n\r\f");
-    if (values[0] == nullptr)
-      error->all(FLERR,fmt::format("Too few lines in {} section of data file",keyword));
+    try {
+      ValueTokenizer values(buf);
+      if (values.count() != nvalue+1)
+        error->all(FLERR,fmt::format("Incorrect format in {} section "
+                                     "of data file: {}",keyword,buf));
 
-    int format_ok = 1;
-    for (j = 1; j < nwords; j++) {
-      values[j] = strtok(nullptr," \t\n\r\f");
-      if (values[j] == nullptr) format_ok = 0;
-    }
-    if (!format_ok)
-      error->all(FLERR,fmt::format("Incorrect {} format in data file",keyword));
+      itag = values.next_tagint() + id_offset;
+      if (itag <= 0 || itag > map_tag_max)
+        error->all(FLERR,fmt::format("Invalid atom ID {} in {} section of "
+                                     "data file",itag, keyword));
 
-    itag = ATOTAGINT(values[0]) + id_offset;
-    if (itag <= 0 || itag > map_tag_max)
-      error->all(FLERR,fmt::format("Invalid atom ID {} in {} section of "
-                                   "data file",itag, keyword));
+      // assign words in line to per-atom vectors
 
-    // assign words in line to per-atom vectors
-
-    if ((m = atom->map(itag)) >= 0) {
-      for (j = 0; j < nvalue; j++) {
-        if (style[j] == MOLECULE) {
-          atom->molecule[m] = utils::tnumeric(FLERR,values[j+1],false,lmp);
-        } else if (style[j] == CHARGE) {
-          atom->q[m] = utils::numeric(FLERR,values[j+1],false,lmp);
-        } else if (style[j] == RMASS) {
-          atom->rmass[m] = utils::numeric(FLERR,values[j+1],false,lmp);
-        } else if (style[j] == INTEGER) {
-          atom->ivector[index[j]][m] = utils::inumeric(FLERR,values[j+1],
-                                                       false,lmp);
-        } else if (style[j] == DOUBLE) {
-          atom->dvector[index[j]][m] = utils::numeric(FLERR,values[j+1],
-                                                      true,lmp);
+      if ((m = atom->map(itag)) >= 0) {
+        for (j = 0; j < nvalue; j++) {
+          if (style[j] == MOLECULE) {
+            atom->molecule[m] = values.next_tagint();
+          } else if (style[j] == CHARGE) {
+            atom->q[m] = values.next_double();
+          } else if (style[j] == RMASS) {
+            atom->rmass[m] = values.next_double();
+          } else if (style[j] == INTEGER) {
+            atom->ivector[index[j]][m] = values.next_int();
+          } else if (style[j] == DOUBLE) {
+            atom->dvector[index[j]][m] = values.next_double();
+          }
         }
       }
+    } catch (TokenizerException &e) {
+      error->all(FLERR,fmt::format("Invalid format in {} section of data "
+                                   "file '{}': {}",keyword, buf,e.what()));
     }
-
     buf = next + 1;
   }
 
-  delete [] values;
-
   if (mapflag) {
     atom->map_delete();
     atom->map_style = 0;
@@ -342,8 +327,9 @@ void FixPropertyAtom::write_data_section_pack(int /*mth*/, double **buf)
 }
 
 /* ----------------------------------------------------------------------
-   write section keyword for Mth data section to file
-   use Molecules or Charges if that is only field, else use fix ID
+   write a Molecules or Charges section if that is only field
+   manages by this fix instance. Otherwise write everything
+   to the section labeled by the fix ID
    only called by proc 0
 ------------------------------------------------------------------------- */
 
@@ -351,7 +337,18 @@ void FixPropertyAtom::write_data_section_keyword(int /*mth*/, FILE *fp)
 {
   if (nvalue == 1 && style[0] == MOLECULE) fprintf(fp,"\nMolecules\n\n");
   else if (nvalue == 1 && style[0] == CHARGE) fprintf(fp,"\nCharges\n\n");
-  else fprintf(fp,"\n%s\n\n",id);
+  else {
+    fprintf(fp,"\n%s #",id);
+    // write column hint as comment
+    for (int i = 0; i < nvalue; ++i) {
+      if (style[i] == MOLECULE) fputs(" mol",fp);
+      else if (style[i] == CHARGE) fputs(" q",fp);
+      else if (style[i] == RMASS) fputs(" rmass",fp);
+      else if (style[i] == INTEGER) fprintf(fp," i_%s", atom->iname[index[i]]);
+      else if (style[i] == DOUBLE) fprintf(fp, " d_%s", atom->dname[index[i]]);
+    }
+    fputs("\n\n",fp);
+  }
 }
 
 /* ----------------------------------------------------------------------
diff --git a/src/fmt/os.h b/src/fmt/os.h
index 823173c8e3..e28738041a 100644
--- a/src/fmt/os.h
+++ b/src/fmt/os.h
@@ -375,11 +375,7 @@ struct ostream_params {
 };
 }  // namespace detail
 
-#if defined(__PGI)
 static detail::buffer_size buffer_size;
-#else
-static constexpr detail::buffer_size buffer_size;
-#endif
 
 // A fast output stream which is not thread-safe.
 class ostream final : private detail::buffer<char> {
diff --git a/src/group.cpp b/src/group.cpp
index e523fd9cf2..aa05ca6951 100644
--- a/src/group.cpp
+++ b/src/group.cpp
@@ -28,6 +28,7 @@
 #include "modify.h"
 #include "output.h"
 #include "region.h"
+#include "tokenizer.h"
 #include "variable.h"
 
 #include <cmath>
@@ -66,10 +67,7 @@ Group::Group(LAMMPS *lmp) : Pointers(lmp)
 
   // create "all" group
 
-  char *str = (char *) "all";
-  int n = strlen(str) + 1;
-  names[0] = new char[n];
-  strcpy(names[0],str);
+  names[0] = utils::strdup("all");
   ngroup = 1;
 }
 
@@ -102,6 +100,7 @@ void Group::assign(int narg, char **arg)
   // clear mask of each atom assigned to this group
 
   if (strcmp(arg[1],"delete") == 0) {
+    if (narg != 2) error->all(FLERR,"Illegal group command");
     int igroup = find(arg[0]);
     if (igroup == -1) error->all(FLERR,"Could not find group delete group ID");
     if (igroup == 0) error->all(FLERR,"Cannot delete group all");
@@ -157,9 +156,7 @@ void Group::assign(int narg, char **arg)
   if (igroup == -1) {
     if (ngroup == MAX_GROUP) error->all(FLERR,"Too many groups");
     igroup = find_unused();
-    int n = strlen(arg[0]) + 1;
-    names[igroup] = new char[n];
-    strcpy(names[igroup],arg[0]);
+    names[igroup] = utils::strdup(arg[0]);
     ngroup++;
   }
 
@@ -188,7 +185,8 @@ void Group::assign(int narg, char **arg)
 
   } else if (strcmp(arg[1],"empty") == 0) {
 
-    ; // nothing to do here
+    if (narg != 2) error->all(FLERR,"Illegal group command");
+    // nothing else to do here
 
   // style = type, molecule, id
   // add to group if atom matches type/molecule/id or condition
@@ -203,7 +201,7 @@ void Group::assign(int narg, char **arg)
     else if (strcmp(arg[1],"molecule") == 0) category = MOLECULE;
     else if (strcmp(arg[1],"id") == 0) category = ID;
 
-    if ((category == MOLECULE) && (!atom->molecular))
+    if ((category == MOLECULE) && (!atom->molecule_flag))
       error->all(FLERR,"Group command requires atom attribute molecule");
 
     if ((category == ID) && (!atom->tag_enable))
@@ -303,20 +301,24 @@ void Group::assign(int narg, char **arg)
       else if (category == MOLECULE) tattribute = atom->molecule;
       else if (category == ID) tattribute = atom->tag;
 
-      char *ptr;
       tagint start,stop,delta;
 
       for (int iarg = 2; iarg < narg; iarg++) {
         delta = 1;
-        if (strchr(arg[iarg],':')) {
-          ptr = strtok(arg[iarg],":");
-          start = utils::tnumeric(FLERR,ptr,false,lmp);
-          ptr = strtok(nullptr,":");
-          stop = utils::tnumeric(FLERR,ptr,false,lmp);
-          ptr = strtok(nullptr,":");
-          if (ptr) delta = utils::tnumeric(FLERR,ptr,false,lmp);
-        } else {
-          start = stop = utils::tnumeric(FLERR,arg[iarg],false,lmp);
+        try {
+          ValueTokenizer values(arg[iarg],":");
+          start = values.next_tagint();
+          if (utils::strmatch(arg[iarg],"^-?\\d+$")) {
+            stop = start;
+          } else if (utils::strmatch(arg[iarg],"^-?\\d+:-?\\d+$")) {
+            stop = values.next_tagint();
+          } else if (utils::strmatch(arg[iarg],"^-?\\d+:-?\\d+:\\d+$")) {
+            stop = values.next_tagint();
+            delta = values.next_tagint();
+          } else throw TokenizerException("Syntax error","");
+        } catch (TokenizerException &e) {
+          error->all(FLERR,fmt::format("Incorrect range string "
+                                       "'{}': {}",arg[iarg],e.what()));
         }
         if (delta < 1)
           error->all(FLERR,"Illegal range increment value");
@@ -365,7 +367,7 @@ void Group::assign(int narg, char **arg)
 
     if (narg != 3) error->all(FLERR,"Illegal group command");
     if (strcmp(arg[2],"molecule") == 0) {
-      if (!atom->molecular)
+      if (!atom->molecule_flag)
         error->all(FLERR,"Group command requires atom attribute molecule");
 
       add_molecules(igroup,bit);
@@ -551,7 +553,7 @@ void Group::assign(const std::string &groupcmd)
    add flagged atoms to a new or existing group
 ------------------------------------------------------------------------- */
 
-void Group::create(char *name, int *flag)
+void Group::create(const char *name, int *flag)
 {
   int i;
 
@@ -563,9 +565,7 @@ void Group::create(char *name, int *flag)
   if (igroup == -1) {
     if (ngroup == MAX_GROUP) error->all(FLERR,"Too many groups");
     igroup = find_unused();
-    int n = strlen(name) + 1;
-    names[igroup] = new char[n];
-    strcpy(names[igroup],name);
+    names[igroup] = utils::strdup(name);
     ngroup++;
   }
 
@@ -602,9 +602,7 @@ int Group::find_or_create(const char *name)
 
   if (ngroup == MAX_GROUP) error->all(FLERR,"Too many groups");
   igroup = find_unused();
-  int n = strlen(name) + 1;
-  names[igroup] = new char[n];
-  strcpy(names[igroup],name);
+  names[igroup] = utils::strdup(name);
   ngroup++;
 
   return igroup;
diff --git a/src/group.h b/src/group.h
index 39c446d119..0c5a18384c 100644
--- a/src/group.h
+++ b/src/group.h
@@ -32,7 +32,7 @@ class Group : protected Pointers {
   ~Group();
   void assign(int, char **);         // assign atoms to a group
   void assign(const std::string &);  // convenience function
-  void create(char *, int *);        // add flagged atoms to a group
+  void create(const char *, int *);  // add flagged atoms to a group
   int find(const std::string &);     // lookup name in list of groups
   int find_or_create(const char *);  // lookup name or create new group
   void write_restart(FILE *);
diff --git a/src/info.cpp b/src/info.cpp
index f1dc96645b..fadf87292a 100644
--- a/src/info.cpp
+++ b/src/info.cpp
@@ -432,7 +432,7 @@ void Info::command(int narg, char **arg)
     fmt::print(out,"Units         = {}\n", update->unit_style);
     fmt::print(out,"Atom style    = {}\n", atom->atom_style);
     fmt::print(out,"Atom map      = {}\n", mapstyles[atom->map_style]);
-    if (atom->molecular > 0) {
+    if (atom->molecular != Atom::ATOMIC) {
       const char *msg;
       msg = (atom->molecular == Atom::TEMPLATE) ? "template" : "standard";
       fmt::print(out,"Molecule type = {}\n",msg);
@@ -447,7 +447,7 @@ void Info::command(int narg, char **arg)
         fmt::print(out," {}", hybrid->keywords[i]);
       fputc('\n',out);
     }
-    if (atom->molecular > 0) {
+    if (atom->molecular != Atom::ATOMIC) {
       const char *msg;
       msg = force->bond_style ? force->bond_style : "none";
       fmt::print(out,"Bonds     = {:12},  types = {:8},  style = {}\n",
@@ -655,7 +655,7 @@ void Info::command(int narg, char **arg)
       if ((style[i] != LOOP) && (style[i] != ULOOP))
         ndata = input->variable->num[i];
       for (int j=0; j < ndata; ++j)
-        fmt::print(out," {}",data[i][j]);
+        if (data[i][j]) fmt::print(out," {}",data[i][j]);
       fputs("\n",out);
     }
   }
@@ -1316,13 +1316,16 @@ std::string Info::get_os_info()
 std::string Info::get_compiler_info()
 {
   std::string buf;
-#if __clang__
+#if __INTEL_LLVM_COMPILER
+  double version = static_cast<double>(__INTEL_LLVM_COMPILER)*0.01;
+  buf = fmt::format("Intel LLVM C++ {:.1f} / {}", version, __VERSION__);
+#elif __clang__
   buf = fmt::format("Clang C++ {}", __VERSION__);
 #elif __PGI
   buf = fmt::format("PGI C++ {}.{}",__PGIC__,__PGIC_MINOR__);
 #elif __INTEL_COMPILER
   double version = static_cast<double>(__INTEL_COMPILER)*0.01;
-  buf = fmt::format("Intel C++ {:.2f}.{} / {}", version,
+  buf = fmt::format("Intel Classic C++ {:.2f}.{} / {}", version,
                     __INTEL_COMPILER_UPDATE, __VERSION__);
 #elif __GNUC__
   buf = fmt::format("GNU C++ {}",   __VERSION__);
diff --git a/src/input.cpp b/src/input.cpp
index 1df60f5298..9979bb7705 100644
--- a/src/input.cpp
+++ b/src/input.cpp
@@ -1078,22 +1078,20 @@ void Input::partition()
   int ilo,ihi;
   utils::bounds(FLERR,arg[1],1,universe->nworlds,ilo,ihi,error);
 
-  // copy original line to copy, since will use strtok() on it
-  // ptr = start of 4th word
+  // new command starts at the 3rd argument,
+  // which must not be another partition command
 
-  strcpy(copy,line);
-  char *ptr = strtok(copy," \t\n\r\f");
-  ptr = strtok(nullptr," \t\n\r\f");
-  ptr = strtok(nullptr," \t\n\r\f");
-  ptr += strlen(ptr) + 1;
-  ptr += strspn(ptr," \t\n\r\f");
+  if (strcmp(arg[2],"partition") == 0)
+    error->all(FLERR,"Illegal partition command");
+
+  char *cmd = strstr(line,arg[2]);
 
   // execute the remaining command line on requested partitions
 
   if (yesflag) {
-    if (universe->iworld+1 >= ilo && universe->iworld+1 <= ihi) one(ptr);
+    if (universe->iworld+1 >= ilo && universe->iworld+1 <= ihi) one(cmd);
   } else {
-    if (universe->iworld+1 < ilo || universe->iworld+1 > ihi) one(ptr);
+    if (universe->iworld+1 < ilo || universe->iworld+1 > ihi) one(cmd);
   }
 }
 
diff --git a/src/library.cpp b/src/library.cpp
index 3fed6ba8cd..68ce180107 100644
--- a/src/library.cpp
+++ b/src/library.cpp
@@ -446,26 +446,14 @@ is passed to :cpp:func:`lammps_commands_string` for processing.
 void lammps_commands_list(void *handle, int ncmd, const char **cmds)
 {
   LAMMPS *lmp = (LAMMPS *) handle;
-
-  int n = ncmd+1;
-  for (int i = 0; i < ncmd; i++) n += strlen(cmds[i]);
-
-  char *str = (char *) lmp->memory->smalloc(n,"lib/commands/list:str");
-  str[0] = '\0';
-  n = 0;
+  std::string allcmds;
 
   for (int i = 0; i < ncmd; i++) {
-    strcpy(&str[n],cmds[i]);
-    n += strlen(cmds[i]);
-    if (str[n-1] != '\n') {
-      str[n] = '\n';
-      str[n+1] = '\0';
-      n++;
-    }
+    allcmds.append(cmds[i]);
+    if (allcmds.back() != '\n') allcmds.append(1,'\n');
   }
 
-  lammps_commands_string(handle,str);
-  lmp->memory->sfree(str);
+  lammps_commands_string(handle,allcmds.c_str());
 }
 
 /* ---------------------------------------------------------------------- */
@@ -496,11 +484,15 @@ void lammps_commands_string(void *handle, const char *str)
 {
   LAMMPS *lmp = (LAMMPS *) handle;
 
-  // make copy of str so can strtok() it
+  // copy str and convert from CR-LF (DOS-style) to LF (Unix style) line
+  int n = strlen(str);
+  char *ptr, *copy = new char[n+1];
 
-  int n = strlen(str) + 1;
-  char *copy = new char[n];
-  strcpy(copy,str);
+  for (ptr = copy; *str != '\0'; ++str) {
+    if ((str[0] == '\r') && (str[1] == '\n')) continue;
+    *ptr++ = *str;
+  }
+  *ptr = '\0';
 
   BEGIN_CAPTURE
   {
@@ -508,8 +500,9 @@ void lammps_commands_string(void *handle, const char *str)
       lmp->error->all(FLERR,"Library error: issuing LAMMPS command during run");
     }
 
-    char *ptr = copy;
-    for (int i=0; i < n-1; ++i) {
+    n = strlen(copy);
+    ptr = copy;
+    for (int i=0; i < n; ++i) {
 
       // handle continuation character as last character in line or string
       if ((copy[i] == '&') && (copy[i+1] == '\n'))
diff --git a/src/lmptype.h b/src/lmptype.h
index 264b93a329..3e6f90f58e 100644
--- a/src/lmptype.h
+++ b/src/lmptype.h
@@ -242,7 +242,7 @@ The typecasts prevent compiler warnings about possible truncation issues.
 
 // define stack variable alignment
 
-#if defined(__INTEL_COMPILER)
+#if defined(__INTEL_LLVM_COMPILER) || defined(__INTEL_COMPILER)
 #define _alignvar(expr,val) __declspec(align(val)) expr
 #elif defined(__GNUC__)
 #define _alignvar(expr,val) expr __attribute((aligned(val)))
@@ -252,7 +252,7 @@ The typecasts prevent compiler warnings about possible truncation issues.
 
 // declaration to lift aliasing restrictions
 
-#if defined(__INTEL_COMPILER)
+#if defined(__INTEL_LLVM_COMPILER) || defined(__INTEL_COMPILER)
 #define _noalias restrict
 #elif defined(__GNUC__)
 #define _noalias __restrict
diff --git a/src/min.cpp b/src/min.cpp
index ca0d508e95..80400f538c 100644
--- a/src/min.cpp
+++ b/src/min.cpp
@@ -304,7 +304,7 @@ void Min::setup(int flag)
   if (pair_compute_flag) force->pair->compute(eflag,vflag);
   else if (force->pair) force->pair->compute_dummy(eflag,vflag);
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) force->bond->compute(eflag,vflag);
     if (force->angle) force->angle->compute(eflag,vflag);
     if (force->dihedral) force->dihedral->compute(eflag,vflag);
@@ -386,7 +386,7 @@ void Min::setup_minimal(int flag)
   if (pair_compute_flag) force->pair->compute(eflag,vflag);
   else if (force->pair) force->pair->compute_dummy(eflag,vflag);
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) force->bond->compute(eflag,vflag);
     if (force->angle) force->angle->compute(eflag,vflag);
     if (force->dihedral) force->dihedral->compute(eflag,vflag);
@@ -558,7 +558,7 @@ double Min::energy_force(int resetflag)
     timer->stamp(Timer::PAIR);
   }
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) force->bond->compute(eflag,vflag);
     if (force->angle) force->angle->compute(eflag,vflag);
     if (force->dihedral) force->dihedral->compute(eflag,vflag);
diff --git a/src/modify.cpp b/src/modify.cpp
index 0b6a6ca823..2c0fd434d6 100644
--- a/src/modify.cpp
+++ b/src/modify.cpp
@@ -995,18 +995,14 @@ void Modify::replace_fix(const char *replaceID,
   if (jfix >= 0) error->all(FLERR,"Replace_fix ID is already in use");
 
   delete [] fix[ifix]->id;
-  int n = strlen(arg[0]) + 1;
-  fix[ifix]->id = new char[n];
-  strcpy(fix[ifix]->id,arg[0]);
+  fix[ifix]->id = utils::strdup(arg[0]);
 
   int jgroup = group->find(arg[1]);
   if (jgroup == -1) error->all(FLERR,"Could not find replace_fix group ID");
   fix[ifix]->igroup = jgroup;
 
   delete [] fix[ifix]->style;
-  n = strlen(arg[2]) + 1;
-  fix[ifix]->style = new char[n];
-  strcpy(fix[ifix]->style,arg[2]);
+  fix[ifix]->style = utils::strdup(arg[2]);
 
   // invoke add_fix
   // it will find and overwrite the replaceID fix
diff --git a/src/omp_compat.h b/src/omp_compat.h
index 366dd9371c..8587548615 100644
--- a/src/omp_compat.h
+++ b/src/omp_compat.h
@@ -29,7 +29,9 @@
 // autodetect OpenMP compatibility if not explicitly set
 
 #ifndef LAMMPS_OMP_COMPAT
-#  if defined(__INTEL_COMPILER)
+#  if defined(__INTEL_LLVM_COMPILER)
+#      define LAMMPS_OMP_COMPAT 4
+#  elif defined(__INTEL_COMPILER)
 #    if __INTEL_COMPILER > 18
 #      define LAMMPS_OMP_COMPAT 4
 #    endif
diff --git a/src/output.cpp b/src/output.cpp
index 828796b873..988ef04409 100644
--- a/src/output.cpp
+++ b/src/output.cpp
@@ -766,12 +766,8 @@ void Output::create_restart(int narg, char **arg)
     delete [] restart2a;
     delete [] restart2b;
     restart_toggle = 0;
-    int n = strlen(arg[1]) + 3;
-    restart2a = new char[n];
-    strcpy(restart2a,arg[1]);
-    n = strlen(arg[2]) + 1;
-    restart2b = new char[n];
-    strcpy(restart2b,arg[2]);
+    restart2a = utils::strdup(arg[1]);
+    restart2b = utils::strdup(arg[2]);
   }
 
   // check for multiproc output and an MPI-IO filename
diff --git a/src/pair.cpp b/src/pair.cpp
index 739d364e57..27a8831eb1 100644
--- a/src/pair.cpp
+++ b/src/pair.cpp
@@ -221,7 +221,7 @@ void Pair::init()
   // for manybody potentials
   // check if bonded exclusions could invalidate the neighbor list
 
-  if (manybody_flag && atom->molecular) {
+  if (manybody_flag && (atom->molecular != Atom::ATOMIC)) {
     int flag = 0;
     if (atom->nbonds > 0 && force->special_lj[1] == 0.0 &&
         force->special_coul[1] == 0.0) flag = 1;
diff --git a/src/pair_coul_streitz.cpp b/src/pair_coul_streitz.cpp
index 0b6e6513a3..68790c0f03 100644
--- a/src/pair_coul_streitz.cpp
+++ b/src/pair_coul_streitz.cpp
@@ -164,9 +164,7 @@ void PairCoulStreitz::coeff(int narg, char **arg)
       if (strcmp(arg[i],elements[j]) == 0) break;
     map[i-2] = j;
     if (j == nelements) {
-      n = strlen(arg[i]) + 1;
-      elements[j] = new char[n];
-      strcpy(elements[j],arg[i]);
+      elements[j] = utils::strdup(arg[i]);
       nelements++;
     }
   }
diff --git a/src/potential_file_reader.cpp b/src/potential_file_reader.cpp
index 2ad8bbb764..2730a3d109 100644
--- a/src/potential_file_reader.cpp
+++ b/src/potential_file_reader.cpp
@@ -40,16 +40,19 @@ using namespace LAMMPS_NS;
  * \param  lmp             Pointer to LAMMPS instance
  * \param  filename        Name of file to be read
  * \param  potential_name  Name of potential style for error messages
- * \param  auto_convert    Bitmask of supported unit conversions */
+ * \param  name_suffix     Suffix added to potential name in error messages
+ * \param  auto_convert    Bitmask of supported unit conversions
+ */
 
 PotentialFileReader::PotentialFileReader(LAMMPS *lmp,
                                          const std::string &filename,
                                          const std::string &potential_name,
+                                         const std::string &name_suffix,
                                          const int auto_convert) :
   Pointers(lmp),
   reader(nullptr),
   filename(filename),
-  filetype(potential_name + " potential"),
+  filetype(potential_name + name_suffix),
   unit_convert(auto_convert)
 {
   if (comm->me != 0) {
@@ -66,6 +69,20 @@ PotentialFileReader::PotentialFileReader(LAMMPS *lmp,
   }
 }
 
+/*
+ * \param  lmp             Pointer to LAMMPS instance
+ * \param  filename        Name of file to be read
+ * \param  potential_name  Name of potential style for error messages
+ * \param  auto_convert    Bitmask of supported unit conversions
+ */
+PotentialFileReader::PotentialFileReader(LAMMPS *lmp,
+                                         const std::string &filename,
+                                         const std::string &potential_name,
+                                         const int auto_convert) :
+  PotentialFileReader(lmp, filename, potential_name, " potential", auto_convert)
+{
+}
+
 /** Closes the file */
 
 PotentialFileReader::~PotentialFileReader() {
diff --git a/src/potential_file_reader.h b/src/potential_file_reader.h
index d3befca282..4f69b8f757 100644
--- a/src/potential_file_reader.h
+++ b/src/potential_file_reader.h
@@ -38,6 +38,10 @@ namespace LAMMPS_NS
     PotentialFileReader(class LAMMPS *lmp, const std::string &filename,
                         const std::string &potential_name,
                         const int auto_convert = 0);
+    PotentialFileReader(class LAMMPS *lmp, const std::string &filename,
+                        const std::string &potential_name,
+                        const std::string &name_suffix,
+                        const int auto_convert = 0);
     virtual ~PotentialFileReader();
 
     void ignore_comments(bool value);
diff --git a/src/procmap.cpp b/src/procmap.cpp
index b8e6e02ed5..87ab415e5e 100644
--- a/src/procmap.cpp
+++ b/src/procmap.cpp
@@ -22,6 +22,7 @@
 #include "error.h"
 #include "math_extra.h"
 #include "memory.h"
+#include "tokenizer.h"
 #include "universe.h"
 
 #include <cmath>
@@ -300,12 +301,16 @@ void ProcMap::custom_grid(char *cfile, int nprocs,
     }
   }
 
-  int n = strlen(line) + 1;
-  MPI_Bcast(&n,1,MPI_INT,0,world);
-  MPI_Bcast(line,n,MPI_CHAR,0,world);
-
-  int rv = sscanf(line,"%d %d %d",&procgrid[0],&procgrid[1],&procgrid[2]);
-  if (rv != 3) error->all(FLERR,"Processors custom grid file is inconsistent");
+  MPI_Bcast(line,MAXLINE,MPI_CHAR,0,world);
+  try {
+    ValueTokenizer procs(line);
+    procgrid[0] = procs.next_int();
+    procgrid[1] = procs.next_int();
+    procgrid[2] = procs.next_int();
+  } catch (TokenizerException &e) {
+    error->all(FLERR,fmt::format("Processors custom grid file "
+                                 "is inconsistent: {}", e.what()));
+  }
 
   int flag = 0;
   if (procgrid[0]*procgrid[1]*procgrid[2] != nprocs) flag = 1;
@@ -324,10 +329,17 @@ void ProcMap::custom_grid(char *cfile, int nprocs,
     for (int i = 0; i < nprocs; i++) {
       if (!fgets(line,MAXLINE,fp))
         error->one(FLERR,"Unexpected end of custom file");
-      rv = sscanf(line,"%d %d %d %d",
-                  &cmap[i][0],&cmap[i][1],&cmap[i][2],&cmap[i][3]);
-      if (rv != 4)
-        error->one(FLERR,"Processors custom grid file is inconsistent");
+
+      try {
+        ValueTokenizer pmap(line);
+        cmap[i][0] = pmap.next_int();
+        cmap[i][1] = pmap.next_int();
+        cmap[i][2] = pmap.next_int();
+        cmap[i][3] = pmap.next_int();
+      } catch (TokenizerException &e) {
+        error->one(FLERR,fmt::format("Processors custom grid file is "
+                                     "inconsistent: {}", e.what()));
+      }
     }
     fclose(fp);
   }
diff --git a/src/read_data.cpp b/src/read_data.cpp
index e8eb90dcb1..1d8b7a516a 100644
--- a/src/read_data.cpp
+++ b/src/read_data.cpp
@@ -73,8 +73,8 @@ ReadData::ReadData(LAMMPS *lmp) : Pointers(lmp)
   keyword = new char[MAXLINE];
   style = new char[MAXLINE];
   buffer = new char[CHUNK*MAXLINE];
-  narg = maxarg = 0;
-  arg = nullptr;
+  ncoeffarg = maxcoeffarg = 0;
+  coeffarg = nullptr;
   fp = nullptr;
 
   // customize for new sections
@@ -98,7 +98,7 @@ ReadData::~ReadData()
   delete [] keyword;
   delete [] style;
   delete [] buffer;
-  memory->sfree(arg);
+  memory->sfree(coeffarg);
 
   for (int i = 0; i < nfix; i++) {
     delete [] fix_header[i];
@@ -221,7 +221,7 @@ void ReadData::command(int narg, char **arg)
       iarg += 2;
     } else if (strcmp(arg[iarg],"extra/bond/per/atom") == 0) {
       if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
-      if (! atom->molecular)
+      if (atom->molecular == Atom::ATOMIC)
         error->all(FLERR,"No bonds allowed with this atom style");
       atom->extra_bond_per_atom = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
       if (atom->extra_bond_per_atom < 0)
@@ -229,7 +229,7 @@ void ReadData::command(int narg, char **arg)
       iarg += 2;
     } else if (strcmp(arg[iarg],"extra/angle/per/atom") == 0) {
       if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
-      if (! atom->molecular)
+      if (atom->molecular == Atom::ATOMIC)
         error->all(FLERR,"No angles allowed with this atom style");
       atom->extra_angle_per_atom = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
       if (atom->extra_angle_per_atom < 0)
@@ -237,7 +237,7 @@ void ReadData::command(int narg, char **arg)
       iarg += 2;
     } else if (strcmp(arg[iarg],"extra/dihedral/per/atom") == 0) {
       if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
-      if (! atom->molecular)
+      if (atom->molecular == Atom::ATOMIC)
         error->all(FLERR,"No dihedrals allowed with this atom style");
       atom->extra_dihedral_per_atom = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
       if (atom->extra_dihedral_per_atom < 0)
@@ -245,7 +245,7 @@ void ReadData::command(int narg, char **arg)
       iarg += 2;
     } else if (strcmp(arg[iarg],"extra/improper/per/atom") == 0) {
       if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
-      if (! atom->molecular)
+      if (atom->molecular == Atom::ATOMIC)
         error->all(FLERR,"No impropers allowed with this atom style");
       atom->extra_improper_per_atom = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
       if (atom->extra_improper_per_atom < 0)
@@ -253,7 +253,7 @@ void ReadData::command(int narg, char **arg)
       iarg += 2;
     } else if (strcmp(arg[iarg],"extra/special/per/atom") == 0) {
       if (iarg+2 > narg) error->all(FLERR,"Illegal read_data command");
-      if (! atom->molecular)
+      if (atom->molecular == Atom::ATOMIC)
         error->all(FLERR,"No bonded interactions allowed with this atom style");
       force->special_extra = utils::inumeric(FLERR,arg[iarg+1],false,lmp);
       if (force->special_extra < 0)
@@ -278,14 +278,8 @@ void ReadData::command(int narg, char **arg)
       if (fix_index[nfix] < 0)
         error->all(FLERR,"Fix ID for read_data does not exist");
       if (strcmp(arg[iarg+2],"NULL") == 0) fix_header[nfix] = nullptr;
-      else {
-        int n = strlen(arg[iarg+2]) + 1;
-        fix_header[nfix] = new char[n];
-        strcpy(fix_header[nfix],arg[iarg+2]);
-      }
-      int n = strlen(arg[iarg+3]) + 1;
-      fix_section[nfix] = new char[n];
-      strcpy(fix_section[nfix],arg[iarg+3]);
+      else fix_header[nfix] = utils::strdup(arg[iarg+2]);
+      fix_section[nfix] = utils::strdup(arg[iarg+3]);
       nfix++;
       iarg += 4;
 
@@ -1760,9 +1754,9 @@ void ReadData::paircoeffs()
     next = strchr(buf,'\n');
     *next = '\0';
     parse_coeffs(buf,nullptr,1,2,toffset);
-    if (narg == 0)
+    if (ncoeffarg == 0)
       error->all(FLERR,"Unexpected empty line in PairCoeffs section");
-    force->pair->coeff(narg,arg);
+    force->pair->coeff(ncoeffarg,coeffarg);
     buf = next + 1;
   }
   delete [] original;
@@ -1787,9 +1781,9 @@ void ReadData::pairIJcoeffs()
       next = strchr(buf,'\n');
       *next = '\0';
       parse_coeffs(buf,nullptr,0,2,toffset);
-      if (narg == 0)
+      if (ncoeffarg == 0)
         error->all(FLERR,"Unexpected empty line in PairCoeffs section");
-      force->pair->coeff(narg,arg);
+      force->pair->coeff(ncoeffarg,coeffarg);
       buf = next + 1;
     }
   delete [] original;
@@ -1812,9 +1806,9 @@ void ReadData::bondcoeffs()
     next = strchr(buf,'\n');
     *next = '\0';
     parse_coeffs(buf,nullptr,0,1,boffset);
-    if (narg == 0)
+    if (ncoeffarg == 0)
       error->all(FLERR,"Unexpected empty line in BondCoeffs section");
-    force->bond->coeff(narg,arg);
+    force->bond->coeff(ncoeffarg,coeffarg);
     buf = next + 1;
   }
   delete [] original;
@@ -1839,8 +1833,8 @@ void ReadData::anglecoeffs(int which)
     if (which == 0) parse_coeffs(buf,nullptr,0,1,aoffset);
     else if (which == 1) parse_coeffs(buf,"bb",0,1,aoffset);
     else if (which == 2) parse_coeffs(buf,"ba",0,1,aoffset);
-    if (narg == 0) error->all(FLERR,"Unexpected empty line in AngleCoeffs section");
-    force->angle->coeff(narg,arg);
+    if (ncoeffarg == 0) error->all(FLERR,"Unexpected empty line in AngleCoeffs section");
+    force->angle->coeff(ncoeffarg,coeffarg);
     buf = next + 1;
   }
   delete [] original;
@@ -1868,9 +1862,9 @@ void ReadData::dihedralcoeffs(int which)
     else if (which == 3) parse_coeffs(buf,"at",0,1,doffset);
     else if (which == 4) parse_coeffs(buf,"aat",0,1,doffset);
     else if (which == 5) parse_coeffs(buf,"bb13",0,1,doffset);
-    if (narg == 0)
+    if (ncoeffarg == 0)
       error->all(FLERR,"Unexpected empty line in DihedralCoeffs section");
-    force->dihedral->coeff(narg,arg);
+    force->dihedral->coeff(ncoeffarg,coeffarg);
     buf = next + 1;
   }
   delete [] original;
@@ -1894,8 +1888,8 @@ void ReadData::impropercoeffs(int which)
     *next = '\0';
     if (which == 0) parse_coeffs(buf,nullptr,0,1,ioffset);
     else if (which == 1) parse_coeffs(buf,"aa",0,1,ioffset);
-    if (narg == 0) error->all(FLERR,"Unexpected empty line in ImproperCoeffs section");
-    force->improper->coeff(narg,arg);
+    if (ncoeffarg == 0) error->all(FLERR,"Unexpected empty line in ImproperCoeffs section");
+    force->improper->coeff(ncoeffarg,coeffarg);
     buf = next + 1;
   }
   delete [] original;
@@ -2053,7 +2047,7 @@ void ReadData::skip_lines(bigint n)
 }
 
 /* ----------------------------------------------------------------------
-   parse a line of coeffs into words, storing them in narg,arg
+   parse a line of coeffs into words, storing them in ncoeffarg,coeffarg
    trim anything from '#' onward
    word strings remain in line, are not copied
    if addstr != nullptr, add addstr as extra arg for class2 angle/dihedral/improper
@@ -2069,33 +2063,38 @@ void ReadData::parse_coeffs(char *line, const char *addstr,
   char *ptr;
   if ((ptr = strchr(line,'#'))) *ptr = '\0';
 
-  narg = 0;
-  char *word = strtok(line," \t\n\r\f");
-  while (word) {
-    if (narg == maxarg) {
-      maxarg += DELTA;
-      arg = (char **)
-        memory->srealloc(arg,maxarg*sizeof(char *),"read_data:arg");
+  ncoeffarg = 0;
+  char *word = line;
+  char *end = line + strlen(line)+1;
+
+  while (word < end) {
+    word += strspn(word," \t\r\n\f");
+    word[strcspn(word," \t\r\n\f")] = '\0';
+    if (strlen(word) == 0) break;
+    if (ncoeffarg == maxcoeffarg) {
+      maxcoeffarg += DELTA;
+      coeffarg = (char **)
+        memory->srealloc(coeffarg,maxcoeffarg*sizeof(char *),"read_data:coeffarg");
     }
-    if (addstr && narg == 1 && !islower(word[0])) arg[narg++] = (char *) addstr;
-    arg[narg++] = word;
-    if (addstr && narg == 2 && islower(word[0])) arg[narg++] = (char *) addstr;
-    if (dupflag && narg == 1) arg[narg++] = word;
-    word = strtok(nullptr," \t\n\r\f");
+    if (addstr && ncoeffarg == 1 && !islower(word[0])) coeffarg[ncoeffarg++] = (char *) addstr;
+    coeffarg[ncoeffarg++] = word;
+    if (addstr && ncoeffarg == 2 && islower(word[0])) coeffarg[ncoeffarg++] = (char *) addstr;
+    if (dupflag && ncoeffarg == 1) coeffarg[ncoeffarg++] = word;
+    word += strlen(word)+1;
   }
 
   // to avoid segfaults on empty lines
 
-  if (narg == 0) return;
+  if (ncoeffarg == 0) return;
 
   if (noffset) {
-    int value = utils::inumeric(FLERR,arg[0],false,lmp);
+    int value = utils::inumeric(FLERR,coeffarg[0],false,lmp);
     sprintf(argoffset1,"%d",value+offset);
-    arg[0] = argoffset1;
+    coeffarg[0] = argoffset1;
     if (noffset == 2) {
-      value = utils::inumeric(FLERR,arg[1],false,lmp);
+      value = utils::inumeric(FLERR,coeffarg[1],false,lmp);
       sprintf(argoffset2,"%d",value+offset);
-      arg[1] = argoffset2;
+      coeffarg[1] = argoffset2;
     }
   }
 }
diff --git a/src/read_data.h b/src/read_data.h
index 84c098635a..68b40fc529 100644
--- a/src/read_data.h
+++ b/src/read_data.h
@@ -34,8 +34,8 @@ class ReadData : protected Pointers {
   int me,compressed;
   char *line,*keyword,*buffer,*style;
   FILE *fp;
-  char **arg;
-  int narg,maxarg;
+  char **coeffarg;
+  int ncoeffarg,maxcoeffarg;
   char argoffset1[8],argoffset2[8];
 
   bigint id_offset, mol_offset;
diff --git a/src/read_dump.cpp b/src/read_dump.cpp
index 925760da6a..0282e2d039 100644
--- a/src/read_dump.cpp
+++ b/src/read_dump.cpp
@@ -64,9 +64,7 @@ ReadDump::ReadDump(LAMMPS *lmp) : Pointers(lmp)
   fields = nullptr;
   buf = nullptr;
 
-  int n = strlen("native") + 1;
-  readerstyle = new char[n];
-  strcpy(readerstyle,"native");
+  readerstyle = utils::strdup("native");
 
   nreader = 0;
   readers = nullptr;
@@ -182,9 +180,7 @@ void ReadDump::store_files(int nstr, char **str)
   // either all or none of files must have '%' wild-card
 
   for (int i = 0; i < nfile; i++) {
-    int n = strlen(str[i]) + 1;
-    files[i] = new char[n];
-    strcpy(files[i],str[i]);
+    files[i] = utils::strdup(str[i]);
 
     if (i == 0) {
       if (strchr(files[i],'%')) multiproc = 1;
@@ -1258,9 +1254,7 @@ int ReadDump::fields_and_keywords(int narg, char **arg)
       for (i = 0; i < nfield; i++)
         if (type == fieldtype[i]) break;
       if (i == nfield) error->all(FLERR,"Illegal read_dump command");
-      int n = strlen(arg[iarg+2]) + 1;
-      fieldlabel[i] = new char[n];
-      strcpy(fieldlabel[i],arg[iarg+2]);
+      fieldlabel[i] = utils::strdup(arg[iarg+2]);
       iarg += 3;
     } else if (strcmp(arg[iarg],"scaled") == 0) {
       if (iarg+2 > narg) error->all(FLERR,"Illegal read_dump command");
@@ -1277,9 +1271,7 @@ int ReadDump::fields_and_keywords(int narg, char **arg)
     } else if (strcmp(arg[iarg],"format") == 0) {
       if (iarg+2 > narg) error->all(FLERR,"Illegal read_dump command");
       delete [] readerstyle;
-      int n = strlen(arg[iarg+1]) + 1;
-      readerstyle = new char[n];
-      strcpy(readerstyle,arg[iarg+1]);
+      readerstyle = utils::strdup(arg[iarg+1]);
       iarg += 2;
       break;
     } else error->all(FLERR,"Illegal read_dump command");
diff --git a/src/region.cpp b/src/region.cpp
index 2fe2d88cef..c442463d4f 100644
--- a/src/region.cpp
+++ b/src/region.cpp
@@ -33,13 +33,8 @@ Region::Region(LAMMPS *lmp, int /*narg*/, char **arg) :
   id(nullptr), style(nullptr), contact(nullptr), list(nullptr),
   xstr(nullptr), ystr(nullptr), zstr(nullptr), tstr(nullptr)
 {
-  int n = strlen(arg[0]) + 1;
-  id = new char[n];
-  strcpy(id,arg[0]);
-
-  n = strlen(arg[1]) + 1;
-  style = new char[n];
-  strcpy(style,arg[1]);
+  id = utils::strdup(arg[0]);
+  style = utils::strdup(arg[1]);
 
   varshape = 0;
   xstr = ystr = zstr = tstr = nullptr;
@@ -338,23 +333,17 @@ void Region::options(int narg, char **arg)
       if (strcmp(arg[iarg+1],"NULL") != 0) {
         if (strstr(arg[iarg+1],"v_") != arg[iarg+1])
           error->all(FLERR,"Illegal region command");
-        int n = strlen(&arg[iarg+1][2]) + 1;
-        xstr = new char[n];
-        strcpy(xstr,&arg[iarg+1][2]);
+        xstr = utils::strdup(&arg[iarg+1][2]);
       }
       if (strcmp(arg[iarg+2],"NULL") != 0) {
         if (strstr(arg[iarg+2],"v_") != arg[iarg+2])
           error->all(FLERR,"Illegal region command");
-        int n = strlen(&arg[iarg+2][2]) + 1;
-        ystr = new char[n];
-        strcpy(ystr,&arg[iarg+2][2]);
+        ystr = utils::strdup(&arg[iarg+2][2]);
       }
       if (strcmp(arg[iarg+3],"NULL") != 0) {
         if (strstr(arg[iarg+3],"v_") != arg[iarg+3])
           error->all(FLERR,"Illegal region command");
-        int n = strlen(&arg[iarg+3][2]) + 1;
-        zstr = new char[n];
-        strcpy(zstr,&arg[iarg+3][2]);
+        zstr = utils::strdup(&arg[iarg+3][2]);
       }
       moveflag = 1;
       iarg += 4;
@@ -363,9 +352,7 @@ void Region::options(int narg, char **arg)
       if (iarg+8 > narg) error->all(FLERR,"Illegal region command");
       if (strstr(arg[iarg+1],"v_") != arg[iarg+1])
         error->all(FLERR,"Illegal region command");
-      int n = strlen(&arg[iarg+1][2]) + 1;
-      tstr = new char[n];
-      strcpy(tstr,&arg[iarg+1][2]);
+      tstr = utils::strdup(&arg[iarg+1][2]);
       point[0] = utils::numeric(FLERR,arg[iarg+2],false,lmp);
       point[1] = utils::numeric(FLERR,arg[iarg+3],false,lmp);
       point[2] = utils::numeric(FLERR,arg[iarg+4],false,lmp);
diff --git a/src/region_intersect.cpp b/src/region_intersect.cpp
index fb2b6239b1..ad67dd1fe5 100644
--- a/src/region_intersect.cpp
+++ b/src/region_intersect.cpp
@@ -39,12 +39,9 @@ RegIntersect::RegIntersect(LAMMPS *lmp, int narg, char **arg) :
   list = new int[n];
   nregion = 0;
 
-  int m,iregion;
   for (int iarg = 0; iarg < n; iarg++) {
-    m = strlen(arg[iarg+3]) + 1;
-    idsub[nregion] = new char[m];
-    strcpy(idsub[nregion],arg[iarg+3]);
-    iregion = domain->find_region(idsub[nregion]);
+    idsub[nregion] = utils::strdup(arg[iarg+3]);
+    int iregion = domain->find_region(idsub[nregion]);
     if (iregion == -1)
       error->all(FLERR,"Region intersect region ID does not exist");
     list[nregion++] = iregion;
@@ -123,9 +120,8 @@ void RegIntersect::init()
   // re-build list of sub-regions in case other regions were deleted
   // error if a sub-region was deleted
 
-  int iregion;
   for (int ilist = 0; ilist < nregion; ilist++) {
-    iregion = domain->find_region(idsub[ilist]);
+    int iregion = domain->find_region(idsub[ilist]);
     if (iregion == -1)
       error->all(FLERR,"Region union region ID does not exist");
     list[ilist] = iregion;
diff --git a/src/region_union.cpp b/src/region_union.cpp
index c4d38413db..144bc4828c 100644
--- a/src/region_union.cpp
+++ b/src/region_union.cpp
@@ -40,12 +40,9 @@ RegUnion::RegUnion(LAMMPS *lmp, int narg, char **arg) : Region(lmp, narg, arg),
   list = new int[n];
   nregion = 0;
 
-  int m,iregion;
   for (int iarg = 0; iarg < n; iarg++) {
-    m = strlen(arg[iarg+3]) + 1;
-    idsub[nregion] = new char[m];
-    strcpy(idsub[nregion],arg[iarg+3]);
-    iregion = domain->find_region(idsub[nregion]);
+    idsub[nregion] = utils::strdup(arg[iarg+3]);
+    int iregion = domain->find_region(idsub[nregion]);
     if (iregion == -1)
       error->all(FLERR,"Region union region ID does not exist");
     list[nregion++] = iregion;
@@ -117,9 +114,8 @@ void RegUnion::init()
   // re-build list of sub-regions in case other regions were deleted
   // error if a sub-region was deleted
 
-  int iregion;
   for (int ilist = 0; ilist < nregion; ilist++) {
-    iregion = domain->find_region(idsub[ilist]);
+    int iregion = domain->find_region(idsub[ilist]);
     if (iregion == -1)
       error->all(FLERR,"Region union region ID does not exist");
     list[ilist] = iregion;
diff --git a/src/replicate.cpp b/src/replicate.cpp
index 9e91c30612..6877ec091c 100644
--- a/src/replicate.cpp
+++ b/src/replicate.cpp
@@ -602,7 +602,7 @@ void Replicate::command(int narg, char **arg)
                 atom->tag[i] += atom_offset;
                 atom->image[i] = image;
 
-                if (atom->molecular) {
+                if (atom->molecular != Atom::ATOMIC) {
                   if (atom->molecule[i] > 0)
                     atom->molecule[i] += mol_offset;
                   if (atom->molecular == Atom::MOLECULAR) {
@@ -704,7 +704,7 @@ void Replicate::command(int narg, char **arg)
                 atom->tag[i] += atom_offset;
                 atom->image[i] = image;
 
-                if (atom->molecular) {
+                if (atom->molecular != Atom::ATOMIC) {
                   if (atom->molecule[i] > 0)
                     atom->molecule[i] += mol_offset;
                   if (atom->molecular == Atom::MOLECULAR) {
diff --git a/src/run.cpp b/src/run.cpp
index 29e42fa6bf..fedf020d9d 100644
--- a/src/run.cpp
+++ b/src/run.cpp
@@ -145,9 +145,7 @@ void Run::command(int narg, char **arg)
     commands = new char*[ncommands];
     ncommands = 0;
     for (int i = first; i <= last; i++) {
-      int n = strlen(arg[i]) + 1;
-      commands[ncommands] = new char[n];
-      strcpy(commands[ncommands],arg[i]);
+      commands[ncommands] = utils::strdup(arg[i]);
       ncommands++;
     }
   }
diff --git a/src/text_file_reader.cpp b/src/text_file_reader.cpp
index 19f15d8522..af27bfb16d 100644
--- a/src/text_file_reader.cpp
+++ b/src/text_file_reader.cpp
@@ -96,10 +96,7 @@ char *TextFileReader::next_line(int nparams) {
   if (ignore_comments && (ptr = strchr(line, '#'))) *ptr = '\0';
 
   nwords = utils::count_words(line);
-
-  if (nwords > 0) {
-    n = strlen(line);
-  }
+  if (nwords > 0) n = strlen(line);
 
   while (nwords == 0 || nwords < nparams) {
     char *ptr = fgets(&line[n], MAXLINE - n, fp);
diff --git a/src/thermo.cpp b/src/thermo.cpp
index 7e14fe37c0..6cd5abd9de 100644
--- a/src/thermo.cpp
+++ b/src/thermo.cpp
@@ -84,9 +84,7 @@ Thermo::Thermo(LAMMPS *lmp, int narg, char **arg) : Pointers(lmp)
 {
   MPI_Comm_rank(world,&me);
 
-  int n = strlen(arg[0]) + 1;
-  style = new char[n];
-  strcpy(style,arg[0]);
+  style = utils::strdup(arg[0]);
 
   // set thermo_modify defaults
 
@@ -456,9 +454,7 @@ void Thermo::modify_params(int narg, char **arg)
       if (iarg+2 > narg) error->all(FLERR,"Illegal thermo_modify command");
       if (index_temp < 0) error->all(FLERR,"Thermo style does not use temp");
       delete [] id_compute[index_temp];
-      int n = strlen(arg[iarg+1]) + 1;
-      id_compute[index_temp] = new char[n];
-      strcpy(id_compute[index_temp],arg[iarg+1]);
+      id_compute[index_temp] = utils::strdup(arg[iarg+1]);
 
       int icompute = modify->find_compute(arg[iarg+1]);
       if (icompute < 0)
@@ -496,15 +492,11 @@ void Thermo::modify_params(int narg, char **arg)
 
       if (index_press_scalar >= 0) {
         delete [] id_compute[index_press_scalar];
-        int n = strlen(arg[iarg+1]) + 1;
-        id_compute[index_press_scalar] = new char[n];
-        strcpy(id_compute[index_press_scalar],arg[iarg+1]);
+        id_compute[index_press_scalar] = utils::strdup(arg[iarg+1]);
       }
       if (index_press_vector >= 0) {
         delete [] id_compute[index_press_vector];
-        int n = strlen(arg[iarg+1]) + 1;
-        id_compute[index_press_vector] = new char[n];
-        strcpy(id_compute[index_press_vector],arg[iarg+1]);
+        id_compute[index_press_vector] = utils::strdup(arg[iarg+1]);
       }
 
       int icompute = modify->find_compute(arg[iarg+1]);
@@ -579,41 +571,32 @@ void Thermo::modify_params(int narg, char **arg)
 
       if (strcmp(arg[iarg+1],"line") == 0) {
         delete [] format_line_user;
-        int n = strlen(arg[iarg+2]) + 1;
-        format_line_user = new char[n];
-        strcpy(format_line_user,arg[iarg+2]);
+        format_line_user = utils::strdup(arg[iarg+2]);
       } else if (strcmp(arg[iarg+1],"int") == 0) {
         if (format_int_user) delete [] format_int_user;
-        int n = strlen(arg[iarg+2]) + 1;
-        format_int_user = new char[n];
-        strcpy(format_int_user,arg[iarg+2]);
+        format_int_user = utils::strdup(arg[iarg+2]);
         if (format_bigint_user) delete [] format_bigint_user;
-        n = strlen(format_int_user) + 8;
-        format_bigint_user = new char[n];
         // replace "d" in format_int_user with bigint format specifier
-        // use of &str[1] removes leading '%' from BIGINT_FORMAT string
         char *ptr = strchr(format_int_user,'d');
         if (ptr == nullptr)
           error->all(FLERR,
                      "Thermo_modify int format does not contain d character");
-        char str[8];
-        sprintf(str,"%s",BIGINT_FORMAT);
+
         *ptr = '\0';
-        sprintf(format_bigint_user,"%s%s%s",format_int_user,&str[1],ptr+1);
+        std::string fnew = fmt::format("{}{}{}",format_int_user,
+                                       std::string(BIGINT_FORMAT).substr(1),
+                                       ptr+1);
+        format_bigint_user = utils::strdup(fnew);
         *ptr = 'd';
       } else if (strcmp(arg[iarg+1],"float") == 0) {
         if (format_float_user) delete [] format_float_user;
-        int n = strlen(arg[iarg+2]) + 1;
-        format_float_user = new char[n];
-        strcpy(format_float_user,arg[iarg+2]);
+        format_float_user = utils::strdup(arg[iarg+2]);
       } else {
         int i = utils::inumeric(FLERR,arg[iarg+1],false,lmp) - 1;
         if (i < 0 || i >= nfield_initial+1)
           error->all(FLERR,"Illegal thermo_modify command");
         if (format_column_user[i]) delete [] format_column_user[i];
-        int n = strlen(arg[iarg+2]) + 1;
-        format_column_user[i] = new char[n];
-        strcpy(format_column_user[i],arg[iarg+2]);
+        format_column_user[i] = utils::strdup(arg[iarg+2]);
       }
       iarg += 3;
 
@@ -985,10 +968,8 @@ void Thermo::parse_fields(char *str)
 
 void Thermo::addfield(const char *key, FnPtr func, int typeflag)
 {
-  int n = strlen(key) + 1;
   delete[] keyword[nfield];
-  keyword[nfield] = new char[n];
-  strcpy(keyword[nfield],key);
+  keyword[nfield] = utils::strdup(key);
   vfunc[nfield] = func;
   vtype[nfield] = typeflag;
   nfield++;
@@ -1008,9 +989,7 @@ int Thermo::add_compute(const char *id, int which)
         which == compute_which[icompute]) break;
   if (icompute < ncompute) return icompute;
 
-  int n = strlen(id) + 1;
-  id_compute[ncompute] = new char[n];
-  strcpy(id_compute[ncompute],id);
+  id_compute[ncompute] = utils::strdup(id);
   compute_which[ncompute] = which;
   ncompute++;
   return ncompute-1;
@@ -1022,9 +1001,7 @@ int Thermo::add_compute(const char *id, int which)
 
 int Thermo::add_fix(const char *id)
 {
-  int n = strlen(id) + 1;
-  id_fix[nfix] = new char[n];
-  strcpy(id_fix[nfix],id);
+  id_fix[nfix] = utils::strdup(id);
   nfix++;
   return nfix-1;
 }
@@ -1035,9 +1012,7 @@ int Thermo::add_fix(const char *id)
 
 int Thermo::add_variable(const char *id)
 {
-  int n = strlen(id) + 1;
-  id_variable[nvariable] = new char[n];
-  strcpy(id_variable[nvariable],id);
+  id_variable[nvariable] = utils::strdup(id);
   nvariable++;
   return nvariable-1;
 }
@@ -1856,7 +1831,7 @@ void Thermo::compute_eimp()
 void Thermo::compute_emol()
 {
   double tmp = 0.0;
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) tmp += force->bond->energy;
     if (force->angle) tmp += force->angle->energy;
     if (force->dihedral) tmp += force->dihedral->energy;
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index 2cc0de72e1..18ed64e0ac 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -200,7 +200,7 @@ std::string ValueTokenizer::next_string() {
     if (has_next()) {
         std::string value = tokens.next();
         return value;
-    }
+    } throw TokenizerException("Not enough tokens","");
     return "";
 }
 
@@ -216,7 +216,7 @@ int ValueTokenizer::next_int() {
         }
         int value = atoi(current.c_str());
         return value;
-    }
+    } throw TokenizerException("Not enough tokens","");
     return 0;
 }
 
@@ -232,7 +232,7 @@ bigint ValueTokenizer::next_bigint() {
         }
         bigint value = ATOBIGINT(current.c_str());
         return value;
-    }
+    } throw TokenizerException("Not enough tokens","");
     return 0;
 }
 
@@ -248,7 +248,7 @@ tagint ValueTokenizer::next_tagint() {
         }
         tagint value = ATOTAGINT(current.c_str());
         return value;
-    }
+    } throw TokenizerException("Not enough tokens","");
     return 0;
 }
 
@@ -264,7 +264,7 @@ double ValueTokenizer::next_double() {
         }
         double value = atof(current.c_str());
         return value;
-    }
+    } throw TokenizerException("Not enough tokens","");
     return 0.0;
 }
 
diff --git a/src/update.cpp b/src/update.cpp
index 7c4b6b888e..1f78e48bb3 100644
--- a/src/update.cpp
+++ b/src/update.cpp
@@ -301,9 +301,7 @@ void Update::set_units(const char *style)
   } else error->all(FLERR,"Illegal units command");
 
   delete [] unit_style;
-  int n = strlen(style) + 1;
-  unit_style = new char[n];
-  strcpy(unit_style,style);
+  unit_style = utils::strdup(style);
 
   // check if timestep was changed from default value
   if (!dt_default && (comm->me == 0)) {
diff --git a/src/utils.cpp b/src/utils.cpp
index 4b9cc8a5f6..3754a9886f 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -394,9 +394,16 @@ template<typename TYPE>
 void utils::bounds(const char *file, int line, const std::string &str,
                    bigint nmin, bigint nmax, TYPE &nlo, TYPE &nhi, Error *error)
 {
-  size_t found = str.find_first_of("*");
-
   nlo = nhi = -1;
+
+  // check for illegal charcters
+  size_t found = str.find_first_not_of("*-0123456789");
+  if (found != std::string::npos) {
+    if (error) error->all(file,line,fmt::format("Invalid range string: {}",str));
+    return;
+  }
+
+  found = str.find_first_of("*");
   if (found == std::string::npos) {    // contains no '*'
     nlo = nhi = strtol(str.c_str(),nullptr,10);
   } else if (str.size() == 1) {        // is only '*'
@@ -418,13 +425,13 @@ void utils::bounds(const char *file, int line, const std::string &str,
       error->all(file,line,fmt::format("Invalid range string: {}",str));
 
     if (nlo < nmin)
-      error->all(file,line,fmt::format("Numeric index {} is out of bounds"
+      error->all(file,line,fmt::format("Numeric index {} is out of bounds "
                                        "({}-{})",nlo,nmin,nmax));
     else if (nhi > nmax)
-      error->all(file,line,fmt::format("Numeric index {} is out of bounds"
+      error->all(file,line,fmt::format("Numeric index {} is out of bounds "
                                        "({}-{})",nhi,nmin,nmax));
     else if (nlo > nhi)
-      error->all(file,line,fmt::format("Numeric index {} is out of bounds"
+      error->all(file,line,fmt::format("Numeric index {} is out of bounds "
                                        "({}-{})",nlo,nmin,nhi));
   }
 }
@@ -443,16 +450,15 @@ template void utils::bounds<>(const char *, int, const std::string &,
 int utils::expand_args(const char *file, int line, int narg, char **arg,
                        int mode, char **&earg, LAMMPS *lmp)
 {
-  int n,iarg,index,nlo,nhi,nmax,expandflag,icompute,ifix;
-  char *ptr1,*ptr2,*str;
+  int iarg;
 
-  ptr1 = nullptr;
+  char *ptr = nullptr;
   for (iarg = 0; iarg < narg; iarg++) {
-    ptr1 = strchr(arg[iarg],'*');
-    if (ptr1) break;
+    ptr = strchr(arg[iarg],'*');
+    if (ptr) break;
   }
 
-  if (!ptr1) {
+  if (!ptr) {
     earg = arg;
     return narg;
   }
@@ -462,101 +468,96 @@ int utils::expand_args(const char *file, int line, int narg, char **arg,
   int maxarg = narg-iarg;
   earg = (char **) lmp->memory->smalloc(maxarg*sizeof(char *),"input:earg");
 
-  int newarg = 0;
+  int newarg = 0, expandflag, nlo, nhi, nmax;
+  std::string id, wc, tail;
+
   for (iarg = 0; iarg < narg; iarg++) {
-    expandflag = 0;
+    std::string word(arg[iarg]);
 
-    if (strncmp(arg[iarg],"c_",2) == 0 ||
-        strncmp(arg[iarg],"f_",2) == 0) {
+    // only match compute/fix reference with a '*' wildcard
+    // number range in the first pair of square brackets
 
-      ptr1 = strchr(&arg[iarg][2],'[');
-      if (ptr1) {
-        ptr2 = strchr(ptr1,']');
-        if (ptr2) {
-          *ptr2 = '\0';
-          if (strchr(ptr1,'*')) {
-            if (arg[iarg][0] == 'c') {
-              *ptr1 = '\0';
-              icompute = lmp->modify->find_compute(&arg[iarg][2]);
-              *ptr1 = '[';
+    if (strmatch(word,"^[cf]_\\w+\\[\\d*\\*\\d*\\]")) {
 
-              // check for global vector/array, peratom array, local array
+      // split off the compute/fix ID, the wildcard and trailing text
+      size_t first = word.find("[");
+      size_t second = word.find("]",first+1);
+      id = word.substr(2,first-2);
+      wc = word.substr(first+1,second-first-1);
+      tail = word.substr(second+1);
 
-              if (icompute >= 0) {
-                if (mode == 0 && lmp->modify->compute[icompute]->vector_flag) {
-                  nmax = lmp->modify->compute[icompute]->size_vector;
-                  expandflag = 1;
-                } else if (mode == 1 && lmp->modify->compute[icompute]->array_flag) {
-                  nmax = lmp->modify->compute[icompute]->size_array_cols;
-                  expandflag = 1;
-                } else if (lmp->modify->compute[icompute]->peratom_flag &&
-                           lmp->modify->compute[icompute]->size_peratom_cols) {
-                  nmax = lmp->modify->compute[icompute]->size_peratom_cols;
-                  expandflag = 1;
-                } else if (lmp->modify->compute[icompute]->local_flag &&
-                           lmp->modify->compute[icompute]->size_local_cols) {
-                  nmax = lmp->modify->compute[icompute]->size_local_cols;
-                  expandflag = 1;
-                }
-              }
-            } else if (arg[iarg][0] == 'f') {
-              *ptr1 = '\0';
-              ifix = lmp->modify->find_fix(&arg[iarg][2]);
-              *ptr1 = '[';
+      if (word[0] == 'c') {
+        int icompute = lmp->modify->find_compute(id);
 
-              // check for global vector/array, peratom array, local array
+        // check for global vector/array, peratom array, local array
 
-              if (ifix >= 0) {
-                if (mode == 0 && lmp->modify->fix[ifix]->vector_flag) {
-                  nmax = lmp->modify->fix[ifix]->size_vector;
-                  expandflag = 1;
-                } else if (mode == 1 && lmp->modify->fix[ifix]->array_flag) {
-                  nmax = lmp->modify->fix[ifix]->size_array_cols;
-                  expandflag = 1;
-                } else if (lmp->modify->fix[ifix]->peratom_flag &&
-                           lmp->modify->fix[ifix]->size_peratom_cols) {
-                  nmax = lmp->modify->fix[ifix]->size_peratom_cols;
-                  expandflag = 1;
-                } else if (lmp->modify->fix[ifix]->local_flag &&
-                           lmp->modify->fix[ifix]->size_local_cols) {
-                  nmax = lmp->modify->fix[ifix]->size_local_cols;
-                  expandflag = 1;
-                }
-              }
-            }
+        if (icompute >= 0) {
+          Compute *compute = lmp->modify->compute[icompute];
+          if (mode == 0 && compute->vector_flag) {
+            nmax = compute->size_vector;
+            expandflag = 1;
+          } else if (mode == 1 && compute->array_flag) {
+            nmax = compute->size_array_cols;
+            expandflag = 1;
+          } else if (compute->peratom_flag && compute->size_peratom_cols) {
+            nmax = compute->size_peratom_cols;
+            expandflag = 1;
+          } else if (compute->local_flag && compute->size_local_cols) {
+            nmax = compute->size_local_cols;
+            expandflag = 1;
+          }
+        }
+      } else if (word[0] == 'f') {
+        int ifix = lmp->modify->find_fix(id);
+
+        // check for global vector/array, peratom array, local array
+
+        if (ifix >= 0) {
+          Fix *fix = lmp->modify->fix[ifix];
+
+          if (mode == 0 && fix->vector_flag) {
+            nmax = fix->size_vector;
+            expandflag = 1;
+          } else if (mode == 1 && fix->array_flag) {
+            nmax = fix->size_array_cols;
+            expandflag = 1;
+          } else if (fix->peratom_flag && fix->size_peratom_cols) {
+            nmax = fix->size_peratom_cols;
+            expandflag = 1;
+          } else if (fix->local_flag && fix->size_local_cols) {
+            nmax = fix->size_local_cols;
+            expandflag = 1;
           }
-          *ptr2 = ']';
         }
       }
     }
 
     if (expandflag) {
-      *ptr2 = '\0';
-      bounds(file,line,ptr1+1,1,nmax,nlo,nhi,lmp->error);
-      *ptr2 = ']';
+
+      // expand wild card string to nlo/nhi numbers
+      utils::bounds(file,line,wc,1,nmax,nlo,nhi,lmp->error);
+
       if (newarg+nhi-nlo+1 > maxarg) {
         maxarg += nhi-nlo+1;
         earg = (char **)
           lmp->memory->srealloc(earg,maxarg*sizeof(char *),"input:earg");
       }
-      for (index = nlo; index <= nhi; index++) {
-        n = strlen(arg[iarg]) + 16;   // 16 = space for large inserted integer
-        str = earg[newarg] = new char[n];
-        strncpy(str,arg[iarg],ptr1+1-arg[iarg]);
-        sprintf(&str[ptr1+1-arg[iarg]],"%d",index);
-        strcat(str,ptr2);
+
+      for (int index = nlo; index <= nhi; index++) {
+        // assemble and duplicate expanded string
+        earg[newarg] = utils::strdup(fmt::format("{}_{}[{}]{}",word[0],
+                                                 id,index,tail));
         newarg++;
       }
 
     } else {
+      // no expansion: duplicate original string
       if (newarg == maxarg) {
         maxarg++;
         earg = (char **)
           lmp->memory->srealloc(earg,maxarg*sizeof(char *),"input:earg");
       }
-      n = strlen(arg[iarg]) + 1;
-      earg[newarg] = new char[n];
-      strcpy(earg[newarg],arg[iarg]);
+      earg[newarg] = utils::strdup(word);
       newarg++;
     }
   }
diff --git a/src/variable.cpp b/src/variable.cpp
index 556633c4e0..1af4a4728a 100644
--- a/src/variable.cpp
+++ b/src/variable.cpp
@@ -31,6 +31,7 @@
 #include "random_mars.h"
 #include "region.h"
 #include "thermo.h"
+#include "tokenizer.h"
 #include "universe.h"
 #include "update.h"
 
@@ -185,9 +186,7 @@ void Variable::set(int narg, char **arg)
       nlast = utils::inumeric(FLERR,arg[2],false,lmp);
       if (nlast <= 0) error->all(FLERR,"Illegal variable command");
       if (narg == 4 && strcmp(arg[3],"pad") == 0) {
-        char digits[12];
-        sprintf(digits,"%d",nlast);
-        pad[nvar] = strlen(digits);
+        pad[nvar] = fmt::format("{}",nlast).size();
       } else pad[nvar] = 0;
     } else if (narg == 4 || (narg == 5 && strcmp(arg[4],"pad") == 0)) {
       nfirst = utils::inumeric(FLERR,arg[2],false,lmp);
@@ -195,9 +194,7 @@ void Variable::set(int narg, char **arg)
       if (nfirst > nlast || nlast < 0)
         error->all(FLERR,"Illegal variable command");
       if (narg == 5 && strcmp(arg[4],"pad") == 0) {
-        char digits[12];
-        sprintf(digits,"%d",nlast);
-        pad[nvar] = strlen(digits);
+        pad[nvar] = fmt::format("{}",nlast).size();
       } else pad[nvar] = 0;
     } else error->all(FLERR,"Illegal variable command");
     num[nvar] = nlast;
@@ -5112,17 +5109,17 @@ int VarReader::read_scalar(char *str)
 
   if (me == 0) {
     while (1) {
-      if (fgets(str,MAXLINE,fp) == nullptr) n = 0;
-      else n = strlen(str);
-      if (n == 0) break;                                 // end of file
-      str[n-1] = '\0';                                   // strip newline
-      if ((ptr = strchr(str,'#'))) *ptr = '\0';          // strip comment
-      if (strtok(str," \t\n\r\f") == nullptr) continue;     // skip if blank
-      n = strlen(str) + 1;
+      ptr = fgets(str,MAXLINE,fp);
+      if (!ptr) { n=0; break; }             // end of file
+      ptr[strcspn(ptr,"#")] = '\0';         // strip comment
+      ptr += strspn(ptr," \t\n\r\f");       // strip leading whitespace
+      ptr[strcspn(ptr," \t\n\r\f")] = '\0'; // strip trailing whitespace
+      n = strlen(ptr) + 1;
+      if (n == 1) continue;                 // skip if blank line
       break;
     }
+    memmove(str,ptr,n);                       // move trimmed string back
   }
-
   MPI_Bcast(&n,1,MPI_INT,0,world);
   if (n == 0) return 1;
   MPI_Bcast(str,n,MPI_CHAR,0,world);
@@ -5155,20 +5152,20 @@ int VarReader::read_peratom()
   char str[MAXLINE];
   if (me == 0) {
     while (1) {
-      if (fgets(str,MAXLINE,fp) == nullptr) n = 0;
-      else n = strlen(str);
-      if (n == 0) break;                                 // end of file
-      str[n-1] = '\0';                                   // strip newline
-      if ((ptr = strchr(str,'#'))) *ptr = '\0';          // strip comment
-      if (strtok(str," \t\n\r\f") == nullptr) continue;     // skip if blank
-      n = strlen(str) + 1;
+      ptr = fgets(str,MAXLINE,fp);
+      if (!ptr) { n=0; break; }             // end of file
+      ptr[strcspn(ptr,"#")] = '\0';         // strip comment
+      ptr += strspn(ptr," \t\n\r\f");       // strip leading whitespace
+      ptr[strcspn(ptr," \t\n\r\f")] = '\0'; // strip trailing whitespace
+      n = strlen(ptr) + 1;
+      if (n == 1) continue;                 // skip if blank line
       break;
     }
+    memmove(str,ptr,n);                     // move trimmed string back
   }
 
   MPI_Bcast(&n,1,MPI_INT,0,world);
   if (n == 0) return 1;
-
   MPI_Bcast(str,n,MPI_CHAR,0,world);
   bigint nlines = utils::bnumeric(FLERR,str,false,lmp);
   tagint map_tag_max = atom->map_tag_max;
@@ -5183,9 +5180,17 @@ int VarReader::read_peratom()
     for (i = 0; i < nchunk; i++) {
       next = strchr(buf,'\n');
       *next = '\0';
-      int rv = sscanf(buf,TAGINT_FORMAT " %lg",&tag,&value);
-      if (tag <= 0 || tag > map_tag_max || rv != 2)
-        error->one(FLERR,"Invalid atom ID in variable file");
+      try {
+        ValueTokenizer words(buf);
+        tag = words.next_bigint();
+        value = words.next_double();
+      } catch (TokenizerException &e) {
+        error->all(FLERR,fmt::format("Invalid atomfile line '{}': {}",
+                                     buf,e.what()));
+      }
+      if ((tag <= 0) || (tag > map_tag_max))
+        error->all(FLERR,fmt::format("Invalid atom ID {} in variable "
+                                     "file", tag));
       if ((m = atom->map(tag)) >= 0) vstore[m] = value;
       buf = next + 1;
     }
diff --git a/src/verlet.cpp b/src/verlet.cpp
index 5e53daafbb..8d744275d2 100644
--- a/src/verlet.cpp
+++ b/src/verlet.cpp
@@ -135,7 +135,7 @@ void Verlet::setup(int flag)
   if (pair_compute_flag) force->pair->compute(eflag,vflag);
   else if (force->pair) force->pair->compute_dummy(eflag,vflag);
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) force->bond->compute(eflag,vflag);
     if (force->angle) force->angle->compute(eflag,vflag);
     if (force->dihedral) force->dihedral->compute(eflag,vflag);
@@ -197,7 +197,7 @@ void Verlet::setup_minimal(int flag)
   if (pair_compute_flag) force->pair->compute(eflag,vflag);
   else if (force->pair) force->pair->compute_dummy(eflag,vflag);
 
-  if (atom->molecular) {
+  if (atom->molecular != Atom::ATOMIC) {
     if (force->bond) force->bond->compute(eflag,vflag);
     if (force->angle) force->angle->compute(eflag,vflag);
     if (force->dihedral) force->dihedral->compute(eflag,vflag);
@@ -312,7 +312,7 @@ void Verlet::run(int n)
       timer->stamp(Timer::PAIR);
     }
 
-    if (atom->molecular) {
+    if (atom->molecular != Atom::ATOMIC) {
       if (force->bond) force->bond->compute(eflag,vflag);
       if (force->angle) force->angle->compute(eflag,vflag);
       if (force->dihedral) force->dihedral->compute(eflag,vflag);
diff --git a/src/write_coeff.cpp b/src/write_coeff.cpp
index 8f1f6140ed..485bc3b29b 100644
--- a/src/write_coeff.cpp
+++ b/src/write_coeff.cpp
@@ -43,11 +43,7 @@ void WriteCoeff::command(int narg, char **arg)
 
   if (narg != 1) error->all(FLERR,"Illegal write_coeff command");
 
-  int n = strlen(arg[0]) + 5;
-  char *file = new char[n];
-
-  strcpy(file,"tmp.");
-  strcat(file,arg[0]);
+  char *file = utils::strdup(fmt::format("tmp.{}",arg[0]));
 
   // initialize relevant styles
   lmp->init();
@@ -114,7 +110,7 @@ void WriteCoeff::command(int narg, char **arg)
       const char *section = (const char *)"";
       fputs(str,two);      // style
       utils::sfgets(FLERR,str,256,one,file,error);  // coeff
-      n = strlen(str);
+      int n = strlen(str);
       strcpy(coeff,str);
       coeff[n-1] = '\0';
       utils::sfgets(FLERR,str,256,one,file,error);
diff --git a/tools/README b/tools/README
index 9be8877b96..9b73f1012d 100644
--- a/tools/README
+++ b/tools/README
@@ -32,6 +32,7 @@ kate                   add-ons to Kate editor for editing LAMMPS input scripts
 lammps-shell           LAMMPS executable enhanced for interactive use
 lmp2arc                convert LAMMPS output to Accelrys Insight format
 lmp2cfg                convert LAMMPS output to CFG files for AtomEye viz
+magic                  patterns to detect LAMMPS files with the file(1) command
 matlab                 MatLab scripts for post-processing LAMMPS output
 mesont                 Tools for use with the USER-MESONT package
 micelle2d              create a data file of small lipid chains in solvent
diff --git a/tools/magic b/tools/magic
new file mode 100644
index 0000000000..ae20fa1c39
--- /dev/null
+++ b/tools/magic
@@ -0,0 +1,73 @@
+# Add the contents of this file to either $HOME/.magic
+# or /etc/magic so that the file(1) command can recognize
+# your LAMMPS files and print some useful information.
+# Last change: 2021-03-15 by akohlmey@gmail.com
+
+# Binary restart file for the LAMMPS MD code, https://lammps.sandia.gov
+
+# written on a little endian machine
+0            string  LammpS\ RestartT  LAMMPS binary restart file
+>16          lelong  0x0001
+>>20         lelong  x                 (rev %d),
+>>>32        string  x                 Version %s,
+>>>>&41      string  x                 Units %s,
+>>>>>&5      lequad  x                 Timestep %lld,
+>>>>>>0x10   lelong  0x0001            Little Endian
+
+# written on a big endian machine
+0            string  LammpS\ RestartT  LAMMPS binary restart file
+>16          lelong  0x1000            Big Endian
+>>20         belong  x                 (rev %d),
+>>>32        string  x                 Version %s,
+>>>>&41      string  x                 Units %s,
+>>>>>&5      bequad  x                 Timestep %lld,
+>>>>>>0x10   lelong  0x1000            Big Endian
+
+# Atom style binary dump file for the LAMMPS MD code, https://lammps.sandia.gov
+
+# written on a little endian machine
+0         lequad  -8
+>0x08     string  DUMPATOM     LAMMPS atom style binary dump
+>>0x14    long    x            (rev %d),
+>>>0x10   lelong  0x0001       Little Endian,
+>>>>0x18  lequad  x            First time step: %lld
+
+# written on a big endian machine
+0         bequad  -8
+>0x08     string  DUMPATOM     LAMMPS atom style binary dump
+>>0x14    belong  x            (rev %d),
+>>>0x10   lelong  0x1000       Big Endian,
+>>>>0x18  bequad  x            First time step: %lld
+
+# Atom style binary dump file for the LAMMPS MD code, https://lammps.sandia.gov
+# written on a little endian machine
+0         lequad  -10
+>0x08     string  DUMPCUSTOM   LAMMPS custom style binary dump
+>>0x16    lelong  x            (rev %d),
+>>>0x12   lelong  0x0001       Little Endian,
+>>>>0x1a  lequad  x            First time step: %lld
+
+# written on a big endian machine
+0         bequad  -10
+>0x08     string  DUMPCUSTOM   LAMMPS custom style binary dump
+>>0x16    belong  x            (rev %d),
+>>>0x12   lelong  0x1000       Big Endian,
+>>>>0x1a  bequad  x            First time step: %lld
+
+# LAMMPS log file
+0         string LAMMPS\ (                    LAMMPS log file
+>8        regex/16 [0-9]+\ [A-Za-z]+\ [0-9]+  written by version %s
+
+# Data file written either by LAMMPS, msi2lmp or VMD/TopoTools
+0      string LAMMPS\ data\ file  LAMMPS data file
+>0x12  string CGCMM\ style        written by TopoTools
+>0x12  string msi2lmp             written by msi2lmp
+>0x11  string via\ write_data     written by LAMMPS
+
+# Data file written by OVITO
+0      string #\ LAMMPS\ data\ file   LAMMPS data file
+>0x13  string written\ by\ OVITO      written by OVITO
+
+# LAMMPS text mode dump file
+0      string    ITEM:\ TIMESTEP      LAMMPS text mode dump,
+>15    regex/16  [0-9]+               First time step: %s
diff --git a/unittest/c-library/test_library_commands.cpp b/unittest/c-library/test_library_commands.cpp
index d9c750975d..6c52232a8e 100644
--- a/unittest/c-library/test_library_commands.cpp
+++ b/unittest/c-library/test_library_commands.cpp
@@ -118,4 +118,24 @@ TEST_F(LibraryCommands, from_string)
     lammps_commands_string(lmp, cmds.c_str());
     if (!verbose) ::testing::internal::GetCapturedStdout();
     EXPECT_EQ(lammps_get_natoms(lmp), 2);
+
+    // repeat test with DOS/Windows style CR-LF line endings
+    if (!verbose) ::testing::internal::CaptureStdout();
+    lammps_command(lmp, "clear");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+
+    cmds.clear();
+    for (unsigned int i = 0; i < sizeof(demo_input) / sizeof(char *); ++i) {
+        cmds += demo_input[i];
+        cmds += "\r\n";
+    }
+    for (unsigned int i = 0; i < sizeof(cont_input) / sizeof(char *); ++i) {
+        cmds += cont_input[i];
+        cmds += "\r\n";
+    }
+    EXPECT_EQ(lammps_get_natoms(lmp), 0);
+    if (!verbose) ::testing::internal::CaptureStdout();
+    lammps_commands_string(lmp, cmds.c_str());
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    EXPECT_EQ(lammps_get_natoms(lmp), 2);
 };
diff --git a/unittest/c-library/test_library_properties.cpp b/unittest/c-library/test_library_properties.cpp
index 71da22efaa..182beee7d0 100644
--- a/unittest/c-library/test_library_properties.cpp
+++ b/unittest/c-library/test_library_properties.cpp
@@ -65,7 +65,9 @@ TEST_F(LibraryProperties, memory_usage)
 #if defined(__linux__) || defined(_WIN32)
     EXPECT_GE(meminfo[1], 0.0);
 #endif
+#if !defined(__INTEL_LLVM_COMPILER)
     EXPECT_GT(meminfo[2], 0.0);
+#endif
 };
 
 TEST_F(LibraryProperties, get_mpi_comm)
diff --git a/unittest/commands/CMakeLists.txt b/unittest/commands/CMakeLists.txt
index 6c68bfb274..50f85475d3 100644
--- a/unittest/commands/CMakeLists.txt
+++ b/unittest/commands/CMakeLists.txt
@@ -31,6 +31,10 @@ add_executable(test_lattice_region test_lattice_region.cpp)
 target_link_libraries(test_lattice_region PRIVATE lammps GTest::GMock GTest::GTest)
 add_test(NAME LatticeRegion COMMAND test_lattice_region WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
+add_executable(test_groups test_groups.cpp)
+target_link_libraries(test_groups PRIVATE lammps GTest::GMock GTest::GTest)
+add_test(NAME Groups COMMAND test_groups WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
 add_executable(test_kim_commands test_kim_commands.cpp)
 if(KIM_EXTRA_UNITTESTS)
   if(CURL_FOUND)
diff --git a/unittest/commands/test_groups.cpp b/unittest/commands/test_groups.cpp
new file mode 100644
index 0000000000..7fa7ee721f
--- /dev/null
+++ b/unittest/commands/test_groups.cpp
@@ -0,0 +1,373 @@
+/* ----------------------------------------------------------------------
+   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.
+------------------------------------------------------------------------- */
+
+#include "lammps.h"
+
+#include "atom.h"
+#include "domain.h"
+#include "group.h"
+#include "info.h"
+#include "input.h"
+#include "region.h"
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include <cstring>
+#include <vector>
+
+// whether to print verbose output (i.e. not capturing LAMMPS screen output).
+bool verbose = false;
+
+#if defined(OMPI_MAJOR_VERSION)
+const bool have_openmpi = true;
+#else
+const bool have_openmpi = false;
+#endif
+
+using LAMMPS_NS::utils::split_words;
+
+namespace LAMMPS_NS {
+using ::testing::ExitedWithCode;
+using ::testing::MatchesRegex;
+using ::testing::StrEq;
+
+#define TEST_FAILURE(errmsg, ...)                                 \
+    if (Info::has_exceptions()) {                                 \
+        ::testing::internal::CaptureStdout();                     \
+        ASSERT_ANY_THROW({__VA_ARGS__});                          \
+        auto mesg = ::testing::internal::GetCapturedStdout();     \
+        if (verbose) std::cout << mesg;                           \
+        ASSERT_THAT(mesg, MatchesRegex(errmsg));                  \
+    } else {                                                      \
+        if (!have_openmpi) {                                      \
+            ::testing::internal::CaptureStdout();                 \
+            ASSERT_DEATH({__VA_ARGS__}, "");                      \
+            auto mesg = ::testing::internal::GetCapturedStdout(); \
+            if (verbose) std::cout << mesg;                       \
+            ASSERT_THAT(mesg, MatchesRegex(errmsg));              \
+        }                                                         \
+    }
+
+class GroupTest : public ::testing::Test {
+protected:
+    LAMMPS *lmp;
+    Group *group;
+    Domain *domain;
+
+    void SetUp() override
+    {
+        const char *args[] = {"GroupTest", "-log", "none", "-echo", "screen", "-nocite"};
+        char **argv        = (char **)args;
+        int argc           = sizeof(args) / sizeof(char *);
+        if (!verbose) ::testing::internal::CaptureStdout();
+        lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
+        if (!verbose) ::testing::internal::GetCapturedStdout();
+        group = lmp->group;
+        domain = lmp->domain;
+    }
+
+    void TearDown() override
+    {
+        if (!verbose) ::testing::internal::CaptureStdout();
+        delete lmp;
+        if (!verbose) ::testing::internal::GetCapturedStdout();
+        std::cout.flush();
+    }
+
+    void command(const std::string &cmd) { lmp->input->one(cmd); }
+
+    void atomic_system()
+    {
+        if (!verbose) ::testing::internal::CaptureStdout();
+        command("units real");
+        command("lattice sc 1.0 origin 0.125 0.125 0.125");
+        command("region box block -2 2 -2 2 -2 2");
+        command("create_box 8 box");
+        command("create_atoms 1 box");
+        command("mass * 1.0");
+        command("region left block -2.0 -1.0 INF INF INF INF");
+        command("region right block 0.5  2.0 INF INF INF INF");
+        command("region top block INF INF -2.0 -1.0 INF INF");
+        command("set region left type 2");
+        command("set region right type 3");
+        if (!verbose) ::testing::internal::GetCapturedStdout();
+    }
+
+    void molecular_system()
+    {
+        if (!verbose) ::testing::internal::CaptureStdout();
+        command("fix props all property/atom mol rmass q");
+        if (!verbose) ::testing::internal::GetCapturedStdout();
+        atomic_system();
+        if (!verbose) ::testing::internal::CaptureStdout();
+        command("variable molid atom floor(id/4)+1");
+        command("variable charge atom 2.0*sin(PI/32*id)");
+        command("set atom * mol v_molid");
+        command("set atom * charge v_charge");
+        command("set type 1 mass 0.5");
+        command("set type 2*4 mass 2.0");
+        if (!verbose) ::testing::internal::GetCapturedStdout();
+    }
+};
+
+TEST_F(GroupTest, NoBox)
+{
+    ASSERT_EQ(group->ngroup, 1);
+    TEST_FAILURE(".*ERROR: Group command before simulation box.*", command("group none empty"););
+}
+
+TEST_F(GroupTest, EmptyDelete)
+{
+    atomic_system();
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("group new1 empty");
+    command("group new2 empty");
+    command("group new2 empty");
+    command("group new3 empty");
+    command("group new4 empty");
+    command("group new5 empty");
+    command("group new6 empty");
+    command("fix 1 new2 nve");
+    command("compute 1 new3 ke");
+    command("dump 1 new4 atom 50 dump.melt");
+    command("atom_modify first new5");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->ngroup, 7);
+    TEST_FAILURE(".*ERROR: Illegal group command.*", command("group new3 xxx"););
+    TEST_FAILURE(".*ERROR: Illegal group command.*", command("group new3 empty xxx"););
+    TEST_FAILURE(".*ERROR: Group command requires atom attribute molecule.*",
+                 command("group new2 include molecule"););
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    group->assign("new1 delete");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->ngroup, 6);
+
+    TEST_FAILURE(".*ERROR: Illegal group command.*", command("group new2 delete xxx"););
+    TEST_FAILURE(".*ERROR: Cannot delete group all.*", command("group all delete"););
+    TEST_FAILURE(".*ERROR: Could not find group delete.*", command("group new0 delete"););
+    TEST_FAILURE(".*ERROR: Cannot delete group currently used by a fix.*",
+                 command("group new2 delete"););
+    TEST_FAILURE(".*ERROR: Cannot delete group currently used by a compute.*",
+                 command("group new3 delete"););
+    TEST_FAILURE(".*ERROR: Cannot delete group currently used by a dump.*",
+                 command("group new4 delete"););
+    TEST_FAILURE(".*ERROR: Cannot delete group currently used by atom_modify.*",
+                 command("group new5 delete"););
+}
+
+TEST_F(GroupTest, RegionClear)
+{
+    atomic_system();
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("group one region left");
+    command("group two region right");
+    command("group three empty");
+    command("group four region left");
+    command("group four region right");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->count(group->find("one")), 16);
+    ASSERT_EQ(group->count(group->find("two")), 16);
+    ASSERT_EQ(group->count(group->find("three")), 0);
+    ASSERT_EQ(group->count(group->find("four")), 32);
+    ASSERT_EQ(group->count(group->find("all")), lmp->atom->natoms);
+    ASSERT_EQ(group->count_all(), lmp->atom->natoms);
+
+    TEST_FAILURE(".*ERROR: Illegal group command.*", command("group three region left xxx"););
+    TEST_FAILURE(".*ERROR: Group region ID does not exist.*", command("group four region dummy"););
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("group one clear");
+    command("group two clear");
+    command("group three clear");
+    command("group four clear");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->count(group->find("one")), 0);
+    ASSERT_EQ(group->count(group->find("two")), 0);
+    ASSERT_EQ(group->count(group->find("three")), 0);
+    ASSERT_EQ(group->count(group->find("four")), 0);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("delete_atoms region box");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->count(group->find("all")), 0);
+}
+
+TEST_F(GroupTest, SelectRestart)
+{
+    atomic_system();
+
+    int *flags = new int[lmp->atom->natoms];
+    for (int i = 0; i < lmp->atom->natoms; ++i)
+        flags[i] = i & 1;
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("group one region left");
+    command("group two region right");
+    group->create("half", flags);
+    group->find_or_create("three");
+    group->find_or_create("one");
+    command("group four union one two");
+    command("group five subtract all half four");
+    command("group top region top");
+    command("group six intersect half top");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->count(group->find("one")), 16);
+    ASSERT_EQ(group->count(group->find("two")), 16);
+    ASSERT_EQ(group->count(group->find("three")), 0);
+    ASSERT_EQ(group->count(group->find("half")), 32);
+    ASSERT_EQ(group->count(group->find("four")), 32);
+    ASSERT_EQ(group->count(group->find("five")), 16);
+    ASSERT_EQ(group->count(group->find("six")), 8);
+    ASSERT_EQ(group->count(group->find("half"), domain->find_region("top")), 8);
+    ASSERT_DOUBLE_EQ(group->mass(group->find("half"), domain->find_region("top")), 8.0);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("write_restart group.restart");
+    command("clear");
+    command("read_restart group.restart");
+    unlink("group.restart");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    group = lmp->group;
+    ASSERT_EQ(group->count(group->find("one")), 16);
+    ASSERT_EQ(group->count(group->find("two")), 16);
+    ASSERT_EQ(group->count(group->find("three")), 0);
+    ASSERT_EQ(group->count(group->find("half")), 32);
+    ASSERT_EQ(group->count(group->find("four")), 32);
+    ASSERT_EQ(group->count(group->find("five")), 16);
+    ASSERT_DOUBLE_EQ(group->mass(group->find("six")), 8.0);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("group four clear");
+    command("group five clear");
+    command("group six clear");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+
+    TEST_FAILURE(".*ERROR: Group ID does not exist.*", command("group four union one two xxx"););
+    TEST_FAILURE(".*ERROR: Group ID does not exist.*",
+                 command("group five subtract all half xxx"););
+    TEST_FAILURE(".*ERROR: Group ID does not exist.*",
+                 command("group five intersect half top xxx"););
+}
+
+TEST_F(GroupTest, Molecular)
+{
+    molecular_system();
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("group one region left");
+    command("group two region right");
+    command("group half id 1:1000:2");
+    command("group top region top");
+    command("group three intersect half top");
+    command("group three include molecule");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->count(group->find("one")), 16);
+    ASSERT_EQ(group->count(group->find("two")), 16);
+    ASSERT_EQ(group->count(group->find("three")), 15);
+    ASSERT_DOUBLE_EQ(group->mass(group->find("half")), 40);
+    ASSERT_DOUBLE_EQ(group->mass(group->find("half"), domain->find_region("top")), 10);
+    ASSERT_DOUBLE_EQ(group->charge(group->find("top")), 0);
+    ASSERT_DOUBLE_EQ(group->charge(group->find("right"), domain->find_region("top")), 0);
+
+    TEST_FAILURE(".*ERROR: Illegal group command.*", command("group three include xxx"););
+}
+
+TEST_F(GroupTest, Dynamic)
+{
+    atomic_system();
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("variable step atom id<=step");
+    command("group half id 1:1000:2");
+    command("group grow dynamic half var step every 1");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->count(group->find("grow")), 0);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("run 10 post no");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->count(group->find("grow")), 5);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("group grow dynamic half var step every 1");
+    command("run 10 post no");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->count(group->find("grow")), 10);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("group grow static");
+    command("run 10 post no");
+    command("group part variable step");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->count(group->find("grow")), 10);
+    ASSERT_EQ(group->count(group->find("part")), 30);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("group grow dynamic half var step every 1");
+    command("run 10 post no");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->count(group->find("grow")), 20);
+    TEST_FAILURE(".*ERROR: Cannot subtract groups using a dynamic group.*",
+                 command("group chunk subtract half grow"););
+    TEST_FAILURE(".*ERROR: Cannot union groups using a dynamic group.*",
+                 command("group chunk union half grow"););
+    TEST_FAILURE(".*ERROR: Cannot intersect groups using a dynamic group.*",
+                 command("group chunk intersect half grow"););
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("group grow delete");
+    command("variable ramp equal step");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(group->ngroup, 4);
+
+    TEST_FAILURE(".*ERROR: Group dynamic cannot reference itself.*",
+                 command("group half dynamic half region top"););
+    TEST_FAILURE(".*ERROR: Group dynamic parent group does not exist.*",
+                 command("group half dynamic dummy region top"););
+
+    TEST_FAILURE(".*ERROR: Variable for group is invalid style.*",
+                 command("group ramp variable ramp"););
+    TEST_FAILURE(".*ERROR: Variable name for group does not exist.*",
+                 command("group ramp variable grow"););
+}
+} // namespace LAMMPS_NS
+
+int main(int argc, char **argv)
+{
+    MPI_Init(&argc, &argv);
+    ::testing::InitGoogleMock(&argc, argv);
+
+    if (have_openmpi && !LAMMPS_NS::Info::has_exceptions())
+        std::cout << "Warning: using OpenMPI without exceptions. "
+                     "Death tests will be skipped\n";
+
+    // handle arguments passed via environment variable
+    if (const char *var = getenv("TEST_ARGS")) {
+        std::vector<std::string> env = split_words(var);
+        for (auto arg : env) {
+            if (arg == "-v") {
+                verbose = true;
+            }
+        }
+    }
+
+    if ((argc > 1) && (strcmp(argv[1], "-v") == 0)) verbose = true;
+
+    int rv = RUN_ALL_TESTS();
+    MPI_Finalize();
+    return rv;
+}
diff --git a/unittest/commands/test_simple_commands.cpp b/unittest/commands/test_simple_commands.cpp
index 0e26734dfb..448224f730 100644
--- a/unittest/commands/test_simple_commands.cpp
+++ b/unittest/commands/test_simple_commands.cpp
@@ -192,6 +192,29 @@ TEST_F(SimpleCommandsTest, Newton)
     ASSERT_EQ(lmp->force->newton_bond, 1);
 }
 
+TEST_F(SimpleCommandsTest, Partition)
+{
+    if (!verbose) ::testing::internal::CaptureStdout();
+    lmp->input->one("echo none");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    TEST_FAILURE(".*ERROR: Illegal partition command .*",
+                 lmp->input->one("partition xxx 1 echo none"););
+    TEST_FAILURE(".*ERROR: Numeric index 2 is out of bounds.*",
+                 lmp->input->one("partition yes 2 echo none"););
+
+    ::testing::internal::CaptureStdout();
+    lmp->input->one("partition yes 1 print 'test'");
+    auto text = ::testing::internal::GetCapturedStdout();
+    if (verbose) std::cout << text;
+    ASSERT_THAT(text, StrEq("test\n"));
+
+    ::testing::internal::CaptureStdout();
+    lmp->input->one("partition no 1 print 'test'");
+    text = ::testing::internal::GetCapturedStdout();
+    if (verbose) std::cout << text;
+    ASSERT_THAT(text, StrEq(""));
+}
+
 TEST_F(SimpleCommandsTest, Quit)
 {
     ::testing::internal::CaptureStdout();
diff --git a/unittest/force-styles/tests/atomic-pair-reax_c.yaml b/unittest/force-styles/tests/atomic-pair-reax_c.yaml
index b88eb7235b..a0dabff323 100644
--- a/unittest/force-styles/tests/atomic-pair-reax_c.yaml
+++ b/unittest/force-styles/tests/atomic-pair-reax_c.yaml
@@ -1,7 +1,7 @@
 ---
 lammps_version: 24 Aug 2020
 date_generated: Tue Sep 15 09:44:24 202
-epsilon: 2.5e-11
+epsilon: 5e-11
 prerequisites: ! |
   pair reax/c
   fix qeq/reax
diff --git a/unittest/force-styles/tests/improper-cvff.yaml b/unittest/force-styles/tests/improper-cvff.yaml
index 462b7e4427..8047efa9f4 100644
--- a/unittest/force-styles/tests/improper-cvff.yaml
+++ b/unittest/force-styles/tests/improper-cvff.yaml
@@ -1,7 +1,7 @@
 ---
 lammps_version: 10 Feb 2021
 date_generated: Wed Feb 24 19:35:14 202
-epsilon: 2.5e-13
+epsilon: 1e-11
 prerequisites: ! |
   atom full
   improper cvff
diff --git a/unittest/force-styles/tests/improper-harmonic.yaml b/unittest/force-styles/tests/improper-harmonic.yaml
index 5daaa0c509..bd5c1bb534 100644
--- a/unittest/force-styles/tests/improper-harmonic.yaml
+++ b/unittest/force-styles/tests/improper-harmonic.yaml
@@ -1,7 +1,7 @@
 ---
 lammps_version: 10 Feb 2021
 date_generated: Wed Feb 24 19:35:15 202
-epsilon: 2.5e-13
+epsilon: 1e-11
 prerequisites: ! |
   atom full
   improper harmonic
diff --git a/unittest/force-styles/tests/improper-hybrid.yaml b/unittest/force-styles/tests/improper-hybrid.yaml
index 0f00d56909..e86dcc329c 100644
--- a/unittest/force-styles/tests/improper-hybrid.yaml
+++ b/unittest/force-styles/tests/improper-hybrid.yaml
@@ -1,7 +1,7 @@
 ---
 lammps_version: 10 Feb 2021
 date_generated: Wed Feb 24 20:50:39 202
-epsilon: 2.5e-13
+epsilon: 2e-12
 prerequisites: ! |
   atom full
   improper harmonic
diff --git a/unittest/force-styles/tests/mol-pair-lj_cubic.yaml b/unittest/force-styles/tests/mol-pair-lj_cubic.yaml
index 6d23998ad5..b0253a8fb0 100644
--- a/unittest/force-styles/tests/mol-pair-lj_cubic.yaml
+++ b/unittest/force-styles/tests/mol-pair-lj_cubic.yaml
@@ -1,7 +1,7 @@
 ---
 lammps_version: 30 Nov 2020
 date_generated: Fri Dec 18 22:30:42 202
-epsilon: 1e-13
+epsilon: 2e-13
 prerequisites: ! |
   atom full
   pair lj/cubic
diff --git a/unittest/formats/test_atom_styles.cpp b/unittest/formats/test_atom_styles.cpp
index b9957c6732..37d436a7a2 100644
--- a/unittest/formats/test_atom_styles.cpp
+++ b/unittest/formats/test_atom_styles.cpp
@@ -102,6 +102,9 @@ class AtomStyleTest : public ::testing::Test {
 protected:
     LAMMPS *lmp;
 
+    // convenience...
+    void command(const std::string cmd) { lmp->input->one(cmd); }
+
     void SetUp() override
     {
         const char *args[] = {"SimpleCommandsTest", "-log", "none", "-echo", "screen", "-nocite"};
@@ -112,10 +115,10 @@ protected:
         if (!verbose) ::testing::internal::GetCapturedStdout();
         ASSERT_NE(lmp, nullptr);
         if (!verbose) ::testing::internal::CaptureStdout();
-        lmp->input->one("units real");
-        lmp->input->one("dimension 3");
-        lmp->input->one("pair_style zero 4.0");
-        lmp->input->one("region box block -4 4 -4 4 -4 4");
+        command("units real");
+        command("dimension 3");
+        command("pair_style zero 4.0");
+        command("region box block -4 4 -4 4 -4 4");
         if (!verbose) ::testing::internal::GetCapturedStdout();
     }
 
@@ -248,6 +251,12 @@ struct AtomState {
 
     bool has_nspecial = false;
     bool has_special  = false;
+
+    bool has_extra_grow    = false;
+    bool has_extra_restart = false;
+    bool has_extra_border  = false;
+    bool has_extra         = false;
+    bool has_sametag       = false;
 };
 
 #define ASSERT_ARRAY_ALLOCATED(ptr, enabled) \
@@ -265,7 +274,7 @@ void ASSERT_ATOM_STATE_EQ(Atom *atom, const AtomState &expected)
     ASSERT_EQ(atom->natoms, expected.natoms);
     ASSERT_EQ(atom->nlocal, expected.nlocal);
     ASSERT_EQ(atom->nghost, expected.nghost);
-    ASSERT_EQ(atom->nmax, expected.nmax);
+    ASSERT_EQ(atom->nmax == 1, expected.nmax == 1);
     ASSERT_EQ(atom->tag_enable, expected.tag_enable);
     ASSERT_EQ(atom->molecular, expected.molecular);
     ASSERT_EQ(atom->nellipsoids, expected.nellipsoids);
@@ -455,11 +464,11 @@ void ASSERT_ATOM_STATE_EQ(Atom *atom, const AtomState &expected)
     ASSERT_EQ(atom->nextra_border_max, expected.nextra_border_max);
     ASSERT_EQ(atom->nextra_store, expected.nextra_store);
 
-    ASSERT_ARRAY_ALLOCATED(atom->extra_grow, false);
-    ASSERT_ARRAY_ALLOCATED(atom->extra_restart, false);
-    ASSERT_ARRAY_ALLOCATED(atom->extra_border, false);
-    ASSERT_ARRAY_ALLOCATED(atom->extra, false);
-    ASSERT_ARRAY_ALLOCATED(atom->sametag, false);
+    ASSERT_ARRAY_ALLOCATED(atom->extra_grow, expected.has_extra_grow);
+    ASSERT_ARRAY_ALLOCATED(atom->extra_restart, expected.has_extra_restart);
+    ASSERT_ARRAY_ALLOCATED(atom->extra_border, expected.has_extra_border);
+    ASSERT_ARRAY_ALLOCATED(atom->extra, expected.has_extra);
+    ASSERT_ARRAY_ALLOCATED(atom->sametag, expected.has_sametag);
 
     ASSERT_EQ(atom->map_style, expected.map_style);
     ASSERT_EQ(atom->map_user, expected.map_user);
@@ -496,8 +505,8 @@ TEST_F(AtomStyleTest, atomic_after_charge)
     expected.has_f      = true;
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_style charge");
-    lmp->input->one("atom_style atomic");
+    command("atom_style charge");
+    command("atom_style atomic");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
@@ -506,15 +515,15 @@ TEST_F(AtomStyleTest, atomic_after_charge)
 TEST_F(AtomStyleTest, atomic)
 {
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_modify map hash");
-    lmp->input->one("create_box 2 box");
-    lmp->input->one("create_atoms 1 single -2.0  2.0  0.1");
-    lmp->input->one("create_atoms 1 single -2.0 -2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0  2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0 -2.0  0.1");
-    lmp->input->one("mass 1 4.0");
-    lmp->input->one("mass 2 2.4");
-    lmp->input->one("pair_coeff * *");
+    command("atom_modify map hash");
+    command("create_box 2 box");
+    command("create_atoms 1 single -2.0  2.0  0.1");
+    command("create_atoms 1 single -2.0 -2.0 -0.1");
+    command("create_atoms 2 single  2.0  2.0 -0.1");
+    command("create_atoms 2 single  2.0 -2.0  0.1");
+    command("mass 1 4.0");
+    command("mass 2 2.4");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("atomic"));
@@ -534,14 +543,14 @@ TEST_F(AtomStyleTest, atomic)
     ASSERT_EQ(lmp->atom->map_user, 2);
     ASSERT_EQ(lmp->atom->map_tag_max, 4);
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("write_data test_atom_styles.data nocoeff");
-    lmp->input->one("clear");
-    lmp->input->one("atom_style atomic");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("units real");
-    lmp->input->one("read_data test_atom_styles.data");
+    command("pair_coeff * *");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("atom_style atomic");
+    command("pair_style zero 4.0");
+    command("atom_modify map array");
+    command("units real");
+    command("read_data test_atom_styles.data");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("atomic"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -591,12 +600,12 @@ TEST_F(AtomStyleTest, atomic)
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("group two id 2:4:2");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
-    lmp->input->one("read_restart test_atom_styles.restart");
+    command("pair_coeff * *");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    command("read_restart test_atom_styles.restart");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("atomic"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -632,14 +641,14 @@ TEST_F(AtomStyleTest, atomic)
     ASSERT_EQ(lmp->atom->map_user, 1);
     ASSERT_EQ(lmp->atom->map_tag_max, 3);
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("reset_atom_ids");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->map_tag_max, 2);
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("comm_style tiled");
-    lmp->input->one("change_box all triclinic");
-    lmp->input->one("replicate 2 2 2");
+    command("comm_style tiled");
+    command("change_box all triclinic");
+    command("replicate 2 2 2");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->map_tag_max, 16);
     x   = lmp->atom->x;
@@ -697,7 +706,7 @@ TEST_F(AtomStyleTest, atomic)
 TEST_F(AtomStyleTest, charge)
 {
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_style charge");
+    command("atom_style charge");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -714,18 +723,18 @@ TEST_F(AtomStyleTest, charge)
     ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("create_box 2 box");
-    lmp->input->one("create_atoms 1 single -2.0  2.0  0.1");
-    lmp->input->one("create_atoms 1 single -2.0 -2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0  2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0 -2.0  0.1");
-    lmp->input->one("mass 1 4.0");
-    lmp->input->one("mass 2 2.4");
-    lmp->input->one("set atom 1 charge -0.5");
-    lmp->input->one("set atom 2 charge  0.5");
-    lmp->input->one("set atom 3 charge -1.0");
-    lmp->input->one("set atom 4 charge  1.0");
-    lmp->input->one("pair_coeff * *");
+    command("create_box 2 box");
+    command("create_atoms 1 single -2.0  2.0  0.1");
+    command("create_atoms 1 single -2.0 -2.0 -0.1");
+    command("create_atoms 2 single  2.0  2.0 -0.1");
+    command("create_atoms 2 single  2.0 -2.0  0.1");
+    command("mass 1 4.0");
+    command("mass 2 2.4");
+    command("set atom 1 charge -0.5");
+    command("set atom 2 charge  0.5");
+    command("set atom 3 charge -1.0");
+    command("set atom 4 charge  1.0");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("charge"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -740,14 +749,14 @@ TEST_F(AtomStyleTest, charge)
     ASSERT_NE(lmp->atom->mass, nullptr);
     ASSERT_NE(lmp->atom->mass_setflag, nullptr);
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("write_data test_atom_styles.data nocoeff");
-    lmp->input->one("clear");
-    lmp->input->one("atom_style charge");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("units real");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
+    command("pair_coeff * *");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("atom_style charge");
+    command("pair_style zero 4.0");
+    command("units real");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("charge"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -803,13 +812,13 @@ TEST_F(AtomStyleTest, charge)
     ASSERT_EQ(lmp->atom->mass_setflag[2], 1);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("group two id 2:4:2");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
+    command("pair_coeff * *");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("atomic"));
-    lmp->input->one("read_restart test_atom_styles.restart");
+    command("read_restart test_atom_styles.restart");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("charge"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -847,9 +856,9 @@ TEST_F(AtomStyleTest, charge)
     ASSERT_EQ(lmp->atom->mass_setflag[2], 1);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("reset_atom_ids");
-    lmp->input->one("change_box all triclinic");
-    lmp->input->one("replicate 2 2 2 bbox");
+    command("reset_atom_ids");
+    command("change_box all triclinic");
+    command("replicate 2 2 2 bbox");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->map_tag_max, 16);
     q = lmp->atom->q;
@@ -874,7 +883,7 @@ TEST_F(AtomStyleTest, charge)
 TEST_F(AtomStyleTest, sphere)
 {
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_style sphere");
+    command("atom_style sphere");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -896,20 +905,20 @@ TEST_F(AtomStyleTest, sphere)
     ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("create_box 2 box");
-    lmp->input->one("create_atoms 1 single -2.0  2.0  0.1");
-    lmp->input->one("create_atoms 1 single -2.0 -2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0  2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0 -2.0  0.1");
-    lmp->input->one("set atom 1 mass 4.0");
-    lmp->input->one("set atom 2 mass 4.0");
-    lmp->input->one("set atom 3 mass 2.4");
-    lmp->input->one("set atom 4 mass 2.4");
-    lmp->input->one("set atom 1 omega -0.5  0.1  0.1");
-    lmp->input->one("set atom 2 omega  0.5 -0.1 -0.1");
-    lmp->input->one("set atom 3 omega -1.0  0.0  0.0");
-    lmp->input->one("set atom 4 omega  0.0  1.0  0.0");
-    lmp->input->one("pair_coeff * *");
+    command("create_box 2 box");
+    command("create_atoms 1 single -2.0  2.0  0.1");
+    command("create_atoms 1 single -2.0 -2.0 -0.1");
+    command("create_atoms 2 single  2.0  2.0 -0.1");
+    command("create_atoms 2 single  2.0 -2.0  0.1");
+    command("set atom 1 mass 4.0");
+    command("set atom 2 mass 4.0");
+    command("set atom 3 mass 2.4");
+    command("set atom 4 mass 2.4");
+    command("set atom 1 omega -0.5  0.1  0.1");
+    command("set atom 2 omega  0.5 -0.1 -0.1");
+    command("set atom 3 omega -1.0  0.0  0.0");
+    command("set atom 4 omega  0.0  1.0  0.0");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("sphere"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -925,14 +934,14 @@ TEST_F(AtomStyleTest, sphere)
     ASSERT_EQ(lmp->atom->mass_setflag, nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("write_data test_atom_styles.data nocoeff");
-    lmp->input->one("clear");
-    lmp->input->one("atom_style sphere");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("units real");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
+    command("pair_coeff * *");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("atom_style sphere");
+    command("pair_style zero 4.0");
+    command("units real");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("sphere"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -998,15 +1007,15 @@ TEST_F(AtomStyleTest, sphere)
     EXPECT_NEAR(omega[GETIDX(4)][2], 0.0, EPSILON);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("group two id 2:4:2");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
+    command("pair_coeff * *");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("atomic"));
-    lmp->input->one("read_restart test_atom_styles.restart");
-    lmp->input->one("replicate 1 1 2");
-    lmp->input->one("reset_atom_ids");
+    command("read_restart test_atom_styles.restart");
+    command("replicate 1 1 2");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("sphere"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -1045,7 +1054,7 @@ TEST_F(AtomStyleTest, ellipsoid)
     if (!LAMMPS::is_installed_pkg("ASPHERE")) GTEST_SKIP();
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_style ellipsoid");
+    command("atom_style ellipsoid");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -1066,23 +1075,23 @@ TEST_F(AtomStyleTest, ellipsoid)
     ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("create_box 3 box");
-    lmp->input->one("create_atoms 1 single -2.0  2.0  0.1");
-    lmp->input->one("create_atoms 1 single -2.0 -2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0  2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0 -2.0  0.1");
-    lmp->input->one("create_atoms 3 single  2.0  2.0 -2.1");
-    lmp->input->one("create_atoms 3 single  2.0 -2.0  2.1");
-    lmp->input->one("set type 1 mass 4.0");
-    lmp->input->one("set type 2 mass 2.4");
-    lmp->input->one("set type 3 mass 4.4");
-    lmp->input->one("set type 1 shape 1.0 1.0 1.0");
-    lmp->input->one("set type 2 shape 3.0 0.8 1.1");
-    lmp->input->one("set atom 1 quat 1.0 0.0 0.0  0.0");
-    lmp->input->one("set atom 2 quat 0.0 1.0 0.0 90.0");
-    lmp->input->one("set atom 3 quat 1.0 0.0 1.0 30.0");
-    lmp->input->one("set atom 4 quat 1.0 1.0 1.0 60.0");
-    lmp->input->one("pair_coeff * *");
+    command("create_box 3 box");
+    command("create_atoms 1 single -2.0  2.0  0.1");
+    command("create_atoms 1 single -2.0 -2.0 -0.1");
+    command("create_atoms 2 single  2.0  2.0 -0.1");
+    command("create_atoms 2 single  2.0 -2.0  0.1");
+    command("create_atoms 3 single  2.0  2.0 -2.1");
+    command("create_atoms 3 single  2.0 -2.0  2.1");
+    command("set type 1 mass 4.0");
+    command("set type 2 mass 2.4");
+    command("set type 3 mass 4.4");
+    command("set type 1 shape 1.0 1.0 1.0");
+    command("set type 2 shape 3.0 0.8 1.1");
+    command("set atom 1 quat 1.0 0.0 0.0  0.0");
+    command("set atom 2 quat 0.0 1.0 0.0 90.0");
+    command("set atom 3 quat 1.0 0.0 1.0 30.0");
+    command("set atom 4 quat 1.0 1.0 1.0 60.0");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("ellipsoid"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -1112,14 +1121,14 @@ TEST_F(AtomStyleTest, ellipsoid)
     ASSERT_EQ(lmp->atom->mass_setflag, nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("write_data test_atom_styles.data nocoeff");
-    lmp->input->one("clear");
-    lmp->input->one("atom_style ellipsoid");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("units real");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
-    lmp->input->one("pair_coeff * *");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("atom_style ellipsoid");
+    command("pair_style zero 4.0");
+    command("units real");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("ellipsoid"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -1231,13 +1240,13 @@ TEST_F(AtomStyleTest, ellipsoid)
     EXPECT_NEAR(bonus[3].quat[3], sqrt(5.0 / 30.0), EPSILON);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("group two id 2:4:2");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
-    lmp->input->one("read_restart test_atom_styles.restart");
-    lmp->input->one("comm_style tiled");
-    lmp->input->one("replicate 1 1 2 bbox");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    command("read_restart test_atom_styles.restart");
+    command("comm_style tiled");
+    command("replicate 1 1 2 bbox");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("ellipsoid"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -1312,7 +1321,7 @@ TEST_F(AtomStyleTest, ellipsoid)
     EXPECT_NEAR(bonus[3].quat[3], 0.25056280708573159, EPSILON);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("reset_atom_ids");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->nellipsoids, 4);
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
@@ -1382,8 +1391,8 @@ TEST_F(AtomStyleTest, line)
     if (!LAMMPS::is_installed_pkg("ASPHERE")) GTEST_SKIP();
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("dimension 2");
-    lmp->input->one("atom_style line");
+    command("dimension 2");
+    command("atom_style line");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -1407,23 +1416,23 @@ TEST_F(AtomStyleTest, line)
     ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("create_box 3 box");
-    lmp->input->one("create_atoms 1 single -2.0  2.0  0.0");
-    lmp->input->one("create_atoms 1 single -2.0 -2.0  0.0");
-    lmp->input->one("create_atoms 2 single  2.0  2.0  0.0");
-    lmp->input->one("create_atoms 2 single  2.0 -2.0  0.0");
-    lmp->input->one("create_atoms 3 single  3.0  0.0  0.0");
-    lmp->input->one("create_atoms 3 single  0.0 -3.0  0.0");
-    lmp->input->one("set type 1 mass 4.0");
-    lmp->input->one("set type 2 mass 2.4");
-    lmp->input->one("set type 3 mass 4.4");
-    lmp->input->one("set type 1 length 2.0");
-    lmp->input->one("set type 2 length 3.0");
-    lmp->input->one("set atom 1 theta 0.0");
-    lmp->input->one("set atom 2 theta 90.0");
-    lmp->input->one("set atom 3 theta 30.0");
-    lmp->input->one("set atom 4 theta 60.0");
-    lmp->input->one("pair_coeff * *");
+    command("create_box 3 box");
+    command("create_atoms 1 single -2.0  2.0  0.0");
+    command("create_atoms 1 single -2.0 -2.0  0.0");
+    command("create_atoms 2 single  2.0  2.0  0.0");
+    command("create_atoms 2 single  2.0 -2.0  0.0");
+    command("create_atoms 3 single  3.0  0.0  0.0");
+    command("create_atoms 3 single  0.0 -3.0  0.0");
+    command("set type 1 mass 4.0");
+    command("set type 2 mass 2.4");
+    command("set type 3 mass 4.4");
+    command("set type 1 length 2.0");
+    command("set type 2 length 3.0");
+    command("set atom 1 theta 0.0");
+    command("set atom 2 theta 90.0");
+    command("set atom 3 theta 30.0");
+    command("set atom 4 theta 60.0");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("line"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -1441,14 +1450,14 @@ TEST_F(AtomStyleTest, line)
     ASSERT_EQ(lmp->atom->mass_setflag, nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("write_data test_atom_styles.data nocoeff");
-    lmp->input->one("clear");
-    lmp->input->one("dimension 2");
-    lmp->input->one("atom_style line");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("units real");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("dimension 2");
+    command("atom_style line");
+    command("pair_style zero 4.0");
+    command("units real");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("line"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -1540,15 +1549,15 @@ TEST_F(AtomStyleTest, line)
     EXPECT_NEAR(bonus[3].theta, MathConst::MY_PI / 3.0, EPSILON);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("group two id 2:4:2");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
-    lmp->input->one("read_restart test_atom_styles.restart");
-    lmp->input->one("comm_style tiled");
-    lmp->input->one("change_box all triclinic");
-    lmp->input->one("replicate 1 2 1 bbox");
+    command("pair_coeff * *");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    command("read_restart test_atom_styles.restart");
+    command("comm_style tiled");
+    command("change_box all triclinic");
+    command("replicate 1 2 1 bbox");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("line"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -1603,7 +1612,7 @@ TEST_F(AtomStyleTest, line)
     EXPECT_NEAR(bonus[3].theta, MathConst::MY_PI / 6.0, EPSILON);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("reset_atom_ids");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->nlines, 4);
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
@@ -1653,7 +1662,7 @@ TEST_F(AtomStyleTest, tri)
     if (!LAMMPS::is_installed_pkg("ASPHERE")) GTEST_SKIP();
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_style tri");
+    command("atom_style tri");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -1678,23 +1687,23 @@ TEST_F(AtomStyleTest, tri)
     ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("create_box 3 box");
-    lmp->input->one("create_atoms 1 single -2.0  2.0  0.1");
-    lmp->input->one("create_atoms 1 single -2.0 -2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0  2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0 -2.0  0.1");
-    lmp->input->one("create_atoms 3 single  2.0  2.0 -2.1");
-    lmp->input->one("create_atoms 3 single  2.0 -2.0  2.1");
-    lmp->input->one("set type 1 mass 4.0");
-    lmp->input->one("set type 2 mass 2.4");
-    lmp->input->one("set type 3 mass 4.4");
-    lmp->input->one("set type 1 tri 1.0");
-    lmp->input->one("set type 2 tri 1.5");
-    lmp->input->one("set atom 1 quat 1.0 0.0 0.0  0.0");
-    lmp->input->one("set atom 2 quat 0.0 1.0 0.0 90.0");
-    lmp->input->one("set atom 3 quat 1.0 0.0 1.0 30.0");
-    lmp->input->one("set atom 4 quat 1.0 1.0 1.0 60.0");
-    lmp->input->one("pair_coeff * *");
+    command("create_box 3 box");
+    command("create_atoms 1 single -2.0  2.0  0.1");
+    command("create_atoms 1 single -2.0 -2.0 -0.1");
+    command("create_atoms 2 single  2.0  2.0 -0.1");
+    command("create_atoms 2 single  2.0 -2.0  0.1");
+    command("create_atoms 3 single  2.0  2.0 -2.1");
+    command("create_atoms 3 single  2.0 -2.0  2.1");
+    command("set type 1 mass 4.0");
+    command("set type 2 mass 2.4");
+    command("set type 3 mass 4.4");
+    command("set type 1 tri 1.0");
+    command("set type 2 tri 1.5");
+    command("set atom 1 quat 1.0 0.0 0.0  0.0");
+    command("set atom 2 quat 0.0 1.0 0.0 90.0");
+    command("set atom 3 quat 1.0 0.0 1.0 30.0");
+    command("set atom 4 quat 1.0 1.0 1.0 60.0");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("tri"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -1724,14 +1733,14 @@ TEST_F(AtomStyleTest, tri)
     ASSERT_EQ(lmp->atom->mass_setflag, nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("write_data test_atom_styles.data nocoeff");
-    lmp->input->one("clear");
-    lmp->input->one("atom_style tri");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("units real");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
-    lmp->input->one("pair_coeff * *");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("atom_style tri");
+    command("pair_style zero 4.0");
+    command("units real");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("tri"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -1886,13 +1895,13 @@ TEST_F(AtomStyleTest, tri)
     EXPECT_NEAR(bonus[3].c3[2], -0.32808266428854477, EPSILON);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("group two id 2:4:2");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
-    lmp->input->one("read_restart test_atom_styles.restart");
-    lmp->input->one("change_box all triclinic");
-    lmp->input->one("replicate 1 1 2");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    command("read_restart test_atom_styles.restart");
+    command("change_box all triclinic");
+    command("replicate 1 1 2");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("tri"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -2012,7 +2021,7 @@ TEST_F(AtomStyleTest, tri)
     EXPECT_NEAR(bonus[3].c3[2], -0.15731490073748589, EPSILON);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("reset_atom_ids");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->ntris, 4);
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
@@ -2057,7 +2066,7 @@ TEST_F(AtomStyleTest, body_nparticle)
     if (!LAMMPS::is_installed_pkg("BODY")) GTEST_SKIP();
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_style body nparticle 2 4");
+    command("atom_style body nparticle 2 4");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -2122,16 +2131,16 @@ TEST_F(AtomStyleTest, body_nparticle)
     fputs(data_file, fp);
     fclose(fp);
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data input_atom_styles.data");
-    lmp->input->one("create_atoms 3 single  2.0  2.0 -2.1");
-    lmp->input->one("create_atoms 3 single  2.0 -2.0  2.1");
-    lmp->input->one("set type 3 mass 4.4");
-    lmp->input->one("set atom 1 quat 1.0 0.0 0.0  0.0");
-    lmp->input->one("set atom 2 quat 0.0 1.0 0.0 90.0");
-    lmp->input->one("set atom 3 quat 1.0 0.0 1.0 30.0");
-    lmp->input->one("set atom 4 quat 1.0 1.0 1.0 60.0");
-    lmp->input->one("pair_coeff * *");
+    command("atom_modify map array");
+    command("read_data input_atom_styles.data");
+    command("create_atoms 3 single  2.0  2.0 -2.1");
+    command("create_atoms 3 single  2.0 -2.0  2.1");
+    command("set type 3 mass 4.4");
+    command("set atom 1 quat 1.0 0.0 0.0  0.0");
+    command("set atom 2 quat 0.0 1.0 0.0 90.0");
+    command("set atom 3 quat 1.0 0.0 1.0 30.0");
+    command("set atom 4 quat 1.0 1.0 1.0 60.0");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("body"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -2299,14 +2308,14 @@ TEST_F(AtomStyleTest, body_nparticle)
     ASSERT_NE(bonus[3].dvalue, nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("write_data test_atom_styles.data nocoeff");
-    lmp->input->one("clear");
-    lmp->input->one("atom_style body nparticle 2 4");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("units real");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
-    lmp->input->one("pair_coeff * *");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("atom_style body nparticle 2 4");
+    command("pair_style zero 4.0");
+    command("units real");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("body"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -2472,13 +2481,13 @@ TEST_F(AtomStyleTest, body_nparticle)
     ASSERT_NE(bonus[3].dvalue, nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("group two id 2:4:2");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
-    lmp->input->one("read_restart test_atom_styles.restart");
-    lmp->input->one("comm_style tiled");
-    lmp->input->one("replicate 1 1 2");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    command("read_restart test_atom_styles.restart");
+    command("comm_style tiled");
+    command("replicate 1 1 2");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("body"));
     avec = (AtomVecBody *)lmp->atom->avec;
@@ -2587,7 +2596,7 @@ TEST_F(AtomStyleTest, body_nparticle)
     ASSERT_NE(bonus[3].dvalue, nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("reset_atom_ids");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->nbodies, 4);
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
@@ -2625,9 +2634,9 @@ TEST_F(AtomStyleTest, template)
     if (!LAMMPS::is_installed_pkg("MOLECULE")) GTEST_SKIP();
     create_molecule_files();
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
-    lmp->input->one("atom_style template twomols");
-    lmp->input->one("newton on");
+    command("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
+    command("atom_style template twomols");
+    command("newton on");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -2651,23 +2660,23 @@ TEST_F(AtomStyleTest, template)
     ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("create_box 4 box bond/types 2 angle/types 2 ");
-    lmp->input->one("create_atoms 0 single -2.0  2.0  0.1 mol twomols 65234");
-    lmp->input->one("create_atoms 0 single -2.0 -2.0 -0.1 mol twomols 62346");
-    lmp->input->one("create_atoms 0 single  2.0  2.0 -0.1 mol twomols 61354");
-    lmp->input->one("create_atoms 3 single  2.0 -2.0  0.1");
-    lmp->input->one("create_atoms 3 single  2.0  2.0 -2.1");
-    lmp->input->one("create_atoms 4 single  2.0 -2.0  2.1");
-    lmp->input->one("mass 1 16.0");
-    lmp->input->one("mass 2 1.0");
-    lmp->input->one("mass 3 12.0");
-    lmp->input->one("mass 4 16.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("bond_coeff 1 1.0");
-    lmp->input->one("bond_coeff 2 1.16");
-    lmp->input->one("angle_style zero");
-    lmp->input->one("angle_coeff * 109.0");
-    lmp->input->one("pair_coeff * *");
+    command("create_box 4 box bond/types 2 angle/types 2 ");
+    command("create_atoms 0 single -2.0  2.0  0.1 mol twomols 65234");
+    command("create_atoms 0 single -2.0 -2.0 -0.1 mol twomols 62346");
+    command("create_atoms 0 single  2.0  2.0 -0.1 mol twomols 61354");
+    command("create_atoms 3 single  2.0 -2.0  0.1");
+    command("create_atoms 3 single  2.0  2.0 -2.1");
+    command("create_atoms 4 single  2.0 -2.0  2.1");
+    command("mass 1 16.0");
+    command("mass 2 1.0");
+    command("mass 3 12.0");
+    command("mass 4 16.0");
+    command("bond_style zero");
+    command("bond_coeff 1 1.0");
+    command("bond_coeff 2 1.16");
+    command("angle_style zero");
+    command("angle_coeff * 109.0");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("template"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -2699,17 +2708,17 @@ TEST_F(AtomStyleTest, template)
     ASSERT_NE(lmp->atom->mass_setflag, nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("write_data test_atom_styles.data");
-    lmp->input->one("clear");
-    lmp->input->one("units real");
-    lmp->input->one("newton off");
-    lmp->input->one("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
-    lmp->input->one("atom_style template twomols");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("angle_style zero");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
+    command("write_data test_atom_styles.data");
+    command("clear");
+    command("units real");
+    command("newton off");
+    command("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
+    command("atom_style template twomols");
+    command("pair_style zero 4.0");
+    command("bond_style zero");
+    command("angle_style zero");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("template"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -2773,15 +2782,15 @@ TEST_F(AtomStyleTest, template)
     ASSERT_EQ(molatom[GETIDX(12)], -1);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("clear");
-    lmp->input->one("units real");
-    lmp->input->one("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
-    lmp->input->one("atom_style template twomols");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("angle_style zero");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
+    command("clear");
+    command("units real");
+    command("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
+    command("atom_style template twomols");
+    command("pair_style zero 4.0");
+    command("bond_style zero");
+    command("angle_style zero");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("template"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -2895,13 +2904,13 @@ TEST_F(AtomStyleTest, template)
     ASSERT_EQ(type[GETIDX(12)], 4);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("group two id 7:10");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
-    lmp->input->one("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
-    lmp->input->one("read_restart test_atom_styles.restart");
-    lmp->input->one("replicate 1 1 2 bbox");
+    command("group two id 7:10");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    command("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
+    command("read_restart test_atom_styles.restart");
+    command("replicate 1 1 2 bbox");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("template"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -2973,7 +2982,7 @@ TEST_F(AtomStyleTest, template)
     ASSERT_EQ(molatom[GETIDX(24)], -1);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("reset_atom_ids");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
     ASSERT_EQ(lmp->atom->map_tag_max, 16);
@@ -3021,9 +3030,9 @@ TEST_F(AtomStyleTest, template_charge)
     if (!LAMMPS::is_installed_pkg("MOLECULE")) GTEST_SKIP();
     create_molecule_files();
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
-    lmp->input->one("atom_style hybrid template twomols charge");
-    lmp->input->one("newton on");
+    command("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
+    command("atom_style hybrid template twomols charge");
+    command("newton on");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -3056,26 +3065,26 @@ TEST_F(AtomStyleTest, template_charge)
     ASSERT_NE(hybrid->styles[1], nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("create_box 4 box bond/types 2 angle/types 2 ");
-    lmp->input->one("create_atoms 0 single -2.0  2.0  0.1 mol twomols 65234");
-    lmp->input->one("create_atoms 0 single -2.0 -2.0 -0.1 mol twomols 62346");
-    lmp->input->one("create_atoms 0 single  2.0  2.0 -0.1 mol twomols 61354");
-    lmp->input->one("create_atoms 3 single  2.0 -2.0  0.1");
-    lmp->input->one("create_atoms 3 single  2.0  2.0 -2.1");
-    lmp->input->one("create_atoms 4 single  2.0 -2.0  2.1");
-    lmp->input->one("mass 1 16.0");
-    lmp->input->one("mass 2 1.0");
-    lmp->input->one("mass 3 12.0");
-    lmp->input->one("mass 4 16.0");
-    lmp->input->one("set atom 10 charge 0.7");
-    lmp->input->one("set atom 11 charge -0.35");
-    lmp->input->one("set atom 12 charge -0.35");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("bond_coeff 1 1.0");
-    lmp->input->one("bond_coeff 2 1.16");
-    lmp->input->one("angle_style zero");
-    lmp->input->one("angle_coeff * 109.0");
-    lmp->input->one("pair_coeff * *");
+    command("create_box 4 box bond/types 2 angle/types 2 ");
+    command("create_atoms 0 single -2.0  2.0  0.1 mol twomols 65234");
+    command("create_atoms 0 single -2.0 -2.0 -0.1 mol twomols 62346");
+    command("create_atoms 0 single  2.0  2.0 -0.1 mol twomols 61354");
+    command("create_atoms 3 single  2.0 -2.0  0.1");
+    command("create_atoms 3 single  2.0  2.0 -2.1");
+    command("create_atoms 4 single  2.0 -2.0  2.1");
+    command("mass 1 16.0");
+    command("mass 2 1.0");
+    command("mass 3 12.0");
+    command("mass 4 16.0");
+    command("set atom 10 charge 0.7");
+    command("set atom 11 charge -0.35");
+    command("set atom 12 charge -0.35");
+    command("bond_style zero");
+    command("bond_coeff 1 1.0");
+    command("bond_coeff 2 1.16");
+    command("angle_style zero");
+    command("angle_coeff * 109.0");
+    command("pair_coeff * *");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_NE(lmp->atom->avec, nullptr);
     hybrid = (AtomVecHybrid *)lmp->atom->avec;
@@ -3115,17 +3124,17 @@ TEST_F(AtomStyleTest, template_charge)
     ASSERT_NE(lmp->atom->mass_setflag, nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("write_data test_atom_styles.data");
-    lmp->input->one("clear");
-    lmp->input->one("units real");
-    lmp->input->one("newton off");
-    lmp->input->one("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
-    lmp->input->one("atom_style hybrid template twomols charge");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("angle_style zero");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
+    command("write_data test_atom_styles.data");
+    command("clear");
+    command("units real");
+    command("newton off");
+    command("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
+    command("atom_style hybrid template twomols charge");
+    command("pair_style zero 4.0");
+    command("bond_style zero");
+    command("angle_style zero");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("hybrid"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -3189,15 +3198,15 @@ TEST_F(AtomStyleTest, template_charge)
     ASSERT_EQ(molatom[GETIDX(12)], -1);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("clear");
-    lmp->input->one("units real");
-    lmp->input->one("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
-    lmp->input->one("atom_style hybrid template twomols charge");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("angle_style zero");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
+    command("clear");
+    command("units real");
+    command("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
+    command("atom_style hybrid template twomols charge");
+    command("pair_style zero 4.0");
+    command("bond_style zero");
+    command("angle_style zero");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("hybrid"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -3324,13 +3333,13 @@ TEST_F(AtomStyleTest, template_charge)
     ASSERT_EQ(type[GETIDX(12)], 4);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("group two id 7:10");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
-    lmp->input->one("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
-    lmp->input->one("read_restart test_atom_styles.restart");
-    lmp->input->one("replicate 1 1 2 bbox");
+    command("group two id 7:10");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    command("molecule twomols h2o.mol co2.mol offset 2 1 1 0 0");
+    command("read_restart test_atom_styles.restart");
+    command("replicate 1 1 2 bbox");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("hybrid"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -3402,7 +3411,7 @@ TEST_F(AtomStyleTest, template_charge)
     ASSERT_EQ(molatom[GETIDX(24)], -1);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("reset_atom_ids");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
     ASSERT_EQ(lmp->atom->map_tag_max, 16);
@@ -3450,8 +3459,8 @@ TEST_F(AtomStyleTest, bond)
     if (!LAMMPS::is_installed_pkg("MOLECULE")) GTEST_SKIP();
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_style bond");
-    lmp->input->one("newton on");
+    command("atom_style bond");
+    command("newton on");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -3473,25 +3482,25 @@ TEST_F(AtomStyleTest, bond)
     ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("create_box 3 box bond/types 2 "
-                    "extra/bond/per/atom 2 extra/special/per/atom 4");
-    lmp->input->one("create_atoms 1 single -2.0  2.0  0.1");
-    lmp->input->one("create_atoms 1 single -2.0 -2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0  2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0 -2.0  0.1");
-    lmp->input->one("create_atoms 3 single  2.0  2.0 -2.1");
-    lmp->input->one("create_atoms 3 single  2.0 -2.0  2.1");
-    lmp->input->one("mass 1 4.0");
-    lmp->input->one("mass 2 2.4");
-    lmp->input->one("mass 3 4.4");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("bond_coeff * 4.0");
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("create_bonds single/bond 1 1 5");
-    lmp->input->one("create_bonds single/bond 1 1 3");
-    lmp->input->one("create_bonds single/bond 2 3 5");
-    lmp->input->one("create_bonds single/bond 2 3 6");
-    lmp->input->one("create_bonds single/bond 2 5 6");
+    command("create_box 3 box bond/types 2 "
+            "extra/bond/per/atom 2 extra/special/per/atom 4");
+    command("create_atoms 1 single -2.0  2.0  0.1");
+    command("create_atoms 1 single -2.0 -2.0 -0.1");
+    command("create_atoms 2 single  2.0  2.0 -0.1");
+    command("create_atoms 2 single  2.0 -2.0  0.1");
+    command("create_atoms 3 single  2.0  2.0 -2.1");
+    command("create_atoms 3 single  2.0 -2.0  2.1");
+    command("mass 1 4.0");
+    command("mass 2 2.4");
+    command("mass 3 4.4");
+    command("bond_style zero");
+    command("bond_coeff * 4.0");
+    command("pair_coeff * *");
+    command("create_bonds single/bond 1 1 5");
+    command("create_bonds single/bond 1 1 3");
+    command("create_bonds single/bond 2 3 5");
+    command("create_bonds single/bond 2 3 6");
+    command("create_bonds single/bond 2 5 6");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("bond"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -3526,17 +3535,17 @@ TEST_F(AtomStyleTest, bond)
     lmp->atom->bond_type[GETIDX(5)][0] *= -1;
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("write_data test_atom_styles.data nocoeff");
-    lmp->input->one("clear");
-    lmp->input->one("units real");
-    lmp->input->one("newton off");
-    lmp->input->one("atom_style bond");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("bond_coeff * 4.0");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("units real");
+    command("newton off");
+    command("atom_style bond");
+    command("pair_style zero 4.0");
+    command("bond_style zero");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
+    command("pair_coeff * *");
+    command("bond_coeff * 4.0");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("bond"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -3587,15 +3596,15 @@ TEST_F(AtomStyleTest, bond)
     ASSERT_EQ(bond_atom[GETIDX(6)][1], 5);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("clear");
-    lmp->input->one("units real");
-    lmp->input->one("atom_style bond");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("bond_coeff * 4.0");
+    command("clear");
+    command("units real");
+    command("atom_style bond");
+    command("pair_style zero 4.0");
+    command("bond_style zero");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
+    command("pair_coeff * *");
+    command("bond_coeff * 4.0");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("bond"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -3685,13 +3694,13 @@ TEST_F(AtomStyleTest, bond)
     lmp->atom->bond_type[GETIDX(5)][0] *= -1;
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("group two id 2:4:2");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
-    lmp->input->one("read_restart test_atom_styles.restart");
-    lmp->input->one("replicate 1 1 2 bbox");
+    command("pair_coeff * *");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    command("read_restart test_atom_styles.restart");
+    command("replicate 1 1 2 bbox");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("bond"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -3747,8 +3756,8 @@ TEST_F(AtomStyleTest, bond)
     ASSERT_EQ(bond_type[GETIDX(11)][0], 2);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("delete_bonds all bond 2");
-    lmp->input->one("reset_atom_ids");
+    command("delete_bonds all bond 2");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
     ASSERT_EQ(lmp->atom->map_tag_max, 8);
@@ -3798,8 +3807,8 @@ TEST_F(AtomStyleTest, angle)
     if (!LAMMPS::is_installed_pkg("MOLECULE")) GTEST_SKIP();
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_style angle");
-    lmp->input->one("newton on");
+    command("atom_style angle");
+    command("newton on");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -3822,30 +3831,30 @@ TEST_F(AtomStyleTest, angle)
     ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("create_box 3 box bond/types 2 angle/types 2 "
-                    "extra/bond/per/atom 2 extra/angle/per/atom 1 "
-                    "extra/special/per/atom 4");
-    lmp->input->one("create_atoms 1 single -2.0  2.0  0.1");
-    lmp->input->one("create_atoms 1 single -2.0 -2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0  2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0 -2.0  0.1");
-    lmp->input->one("create_atoms 3 single  2.0  2.0 -2.1");
-    lmp->input->one("create_atoms 3 single  2.0 -2.0  2.1");
-    lmp->input->one("mass 1 4.0");
-    lmp->input->one("mass 2 2.4");
-    lmp->input->one("mass 3 4.4");
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("bond_coeff * 4.0");
-    lmp->input->one("angle_style zero");
-    lmp->input->one("angle_coeff * 90.0");
-    lmp->input->one("create_bonds single/bond 1 1 3");
-    lmp->input->one("create_bonds single/bond 1 1 5");
-    lmp->input->one("create_bonds single/bond 2 3 5");
-    lmp->input->one("create_bonds single/bond 2 3 6");
-    lmp->input->one("create_bonds single/bond 2 5 6");
-    lmp->input->one("create_bonds single/angle 1 1 3 5");
-    lmp->input->one("create_bonds single/angle 2 3 5 6");
+    command("create_box 3 box bond/types 2 angle/types 2 "
+            "extra/bond/per/atom 2 extra/angle/per/atom 1 "
+            "extra/special/per/atom 4");
+    command("create_atoms 1 single -2.0  2.0  0.1");
+    command("create_atoms 1 single -2.0 -2.0 -0.1");
+    command("create_atoms 2 single  2.0  2.0 -0.1");
+    command("create_atoms 2 single  2.0 -2.0  0.1");
+    command("create_atoms 3 single  2.0  2.0 -2.1");
+    command("create_atoms 3 single  2.0 -2.0  2.1");
+    command("mass 1 4.0");
+    command("mass 2 2.4");
+    command("mass 3 4.4");
+    command("pair_coeff * *");
+    command("bond_style zero");
+    command("bond_coeff * 4.0");
+    command("angle_style zero");
+    command("angle_coeff * 90.0");
+    command("create_bonds single/bond 1 1 3");
+    command("create_bonds single/bond 1 1 5");
+    command("create_bonds single/bond 2 3 5");
+    command("create_bonds single/bond 2 3 6");
+    command("create_bonds single/bond 2 5 6");
+    command("create_bonds single/angle 1 1 3 5");
+    command("create_bonds single/angle 2 3 5 6");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("angle"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -3882,19 +3891,19 @@ TEST_F(AtomStyleTest, angle)
     lmp->atom->angle_type[GETIDX(5)][0] *= -1;
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("write_data test_atom_styles.data nocoeff");
-    lmp->input->one("clear");
-    lmp->input->one("units real");
-    lmp->input->one("newton off");
-    lmp->input->one("atom_style angle");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("angle_style zero");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("bond_coeff * 4.0");
-    lmp->input->one("angle_coeff * 90.0");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("units real");
+    command("newton off");
+    command("atom_style angle");
+    command("pair_style zero 4.0");
+    command("bond_style zero");
+    command("angle_style zero");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
+    command("pair_coeff * *");
+    command("bond_coeff * 4.0");
+    command("angle_coeff * 90.0");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("angle"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -3980,15 +3989,15 @@ TEST_F(AtomStyleTest, angle)
     ASSERT_EQ(angle_atom3[GETIDX(6)][0], 6);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("clear");
-    lmp->input->one("units real");
-    lmp->input->one("atom_style angle");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("bond_coeff * 4.0");
+    command("clear");
+    command("units real");
+    command("atom_style angle");
+    command("pair_style zero 4.0");
+    command("bond_style zero");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
+    command("pair_coeff * *");
+    command("bond_coeff * 4.0");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("angle"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -4079,13 +4088,13 @@ TEST_F(AtomStyleTest, angle)
     ASSERT_EQ(angle_type[GETIDX(5)][0], 2);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("group two id 2:4:2");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
-    lmp->input->one("read_restart test_atom_styles.restart");
-    lmp->input->one("replicate 1 1 2");
+    command("pair_coeff * *");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    command("read_restart test_atom_styles.restart");
+    command("replicate 1 1 2");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("angle"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -4124,8 +4133,8 @@ TEST_F(AtomStyleTest, angle)
     ASSERT_EQ(angle_type[GETIDX(11)][0], 2);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("delete_bonds all angle 2");
-    lmp->input->one("reset_atom_ids");
+    command("delete_bonds all angle 2");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
     ASSERT_EQ(lmp->atom->map_tag_max, 8);
@@ -4159,7 +4168,7 @@ TEST_F(AtomStyleTest, full_ellipsoid)
     if (!LAMMPS::is_installed_pkg("MOLECULE")) GTEST_SKIP();
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("atom_style hybrid full ellipsoid");
+    command("atom_style hybrid full ellipsoid");
     if (!verbose) ::testing::internal::GetCapturedStdout();
 
     AtomState expected;
@@ -4197,40 +4206,40 @@ TEST_F(AtomStyleTest, full_ellipsoid)
     ASSERT_NE(hybrid->styles[1], nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("create_box 3 box bond/types 2 "
-                    "extra/bond/per/atom 2 extra/special/per/atom 4");
-    lmp->input->one("create_atoms 1 single -2.0  2.0  0.1");
-    lmp->input->one("create_atoms 1 single -2.0 -2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0  2.0 -0.1");
-    lmp->input->one("create_atoms 2 single  2.0 -2.0  0.1");
-    lmp->input->one("create_atoms 3 single  2.0  2.0 -2.1");
-    lmp->input->one("create_atoms 3 single  2.0 -2.0  2.1");
-    lmp->input->one("set type 1 mass 4.0");
-    lmp->input->one("set type 2 mass 2.4");
-    lmp->input->one("set type 3 mass 4.4");
-    lmp->input->one("mass 1 4.0");
-    lmp->input->one("mass 2 2.4");
-    lmp->input->one("mass 3 4.4");
-    lmp->input->one("set type 1 shape 1.0 1.0 1.0");
-    lmp->input->one("set type 2 shape 3.0 0.8 1.1");
-    lmp->input->one("set atom 1 quat 1.0 0.0 0.0  0.0");
-    lmp->input->one("set atom 2 quat 0.0 1.0 0.0 90.0");
-    lmp->input->one("set atom 3 quat 1.0 0.0 1.0 30.0");
-    lmp->input->one("set atom 4 quat 1.0 1.0 1.0 60.0");
-    lmp->input->one("set atom 1 charge -0.5");
-    lmp->input->one("set atom 2 charge  0.5");
-    lmp->input->one("set atom 3 charge -1.0");
-    lmp->input->one("set atom 4 charge  1.0");
-    lmp->input->one("set atom 5 charge  2.0");
-    lmp->input->one("set atom 6 charge -2.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("bond_coeff * 4.0");
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("create_bonds single/bond 1 1 5");
-    lmp->input->one("create_bonds single/bond 1 1 3");
-    lmp->input->one("create_bonds single/bond 2 3 5");
-    lmp->input->one("create_bonds single/bond 2 3 6");
-    lmp->input->one("create_bonds single/bond 2 5 6");
+    command("create_box 3 box bond/types 2 "
+            "extra/bond/per/atom 2 extra/special/per/atom 4");
+    command("create_atoms 1 single -2.0  2.0  0.1");
+    command("create_atoms 1 single -2.0 -2.0 -0.1");
+    command("create_atoms 2 single  2.0  2.0 -0.1");
+    command("create_atoms 2 single  2.0 -2.0  0.1");
+    command("create_atoms 3 single  2.0  2.0 -2.1");
+    command("create_atoms 3 single  2.0 -2.0  2.1");
+    command("set type 1 mass 4.0");
+    command("set type 2 mass 2.4");
+    command("set type 3 mass 4.4");
+    command("mass 1 4.0");
+    command("mass 2 2.4");
+    command("mass 3 4.4");
+    command("set type 1 shape 1.0 1.0 1.0");
+    command("set type 2 shape 3.0 0.8 1.1");
+    command("set atom 1 quat 1.0 0.0 0.0  0.0");
+    command("set atom 2 quat 0.0 1.0 0.0 90.0");
+    command("set atom 3 quat 1.0 0.0 1.0 30.0");
+    command("set atom 4 quat 1.0 1.0 1.0 60.0");
+    command("set atom 1 charge -0.5");
+    command("set atom 2 charge  0.5");
+    command("set atom 3 charge -1.0");
+    command("set atom 4 charge  1.0");
+    command("set atom 5 charge  2.0");
+    command("set atom 6 charge -2.0");
+    command("bond_style zero");
+    command("bond_coeff * 4.0");
+    command("pair_coeff * *");
+    command("create_bonds single/bond 1 1 5");
+    command("create_bonds single/bond 1 1 3");
+    command("create_bonds single/bond 2 3 5");
+    command("create_bonds single/bond 2 3 6");
+    command("create_bonds single/bond 2 5 6");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("hybrid"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -4262,16 +4271,16 @@ TEST_F(AtomStyleTest, full_ellipsoid)
     ASSERT_NE(lmp->atom->mass_setflag, nullptr);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("write_data test_atom_styles.data nocoeff");
-    lmp->input->one("clear");
-    lmp->input->one("units real");
-    lmp->input->one("atom_style hybrid full ellipsoid");
-    lmp->input->one("pair_style zero 4.0");
-    lmp->input->one("bond_style zero");
-    lmp->input->one("atom_modify map array");
-    lmp->input->one("read_data test_atom_styles.data");
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("bond_coeff * 4.0");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("units real");
+    command("atom_style hybrid full ellipsoid");
+    command("pair_style zero 4.0");
+    command("bond_style zero");
+    command("atom_modify map array");
+    command("read_data test_atom_styles.data");
+    command("pair_coeff * *");
+    command("bond_coeff * 4.0");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("hybrid"));
     ASSERT_NE(lmp->atom->avec, nullptr);
@@ -4398,13 +4407,13 @@ TEST_F(AtomStyleTest, full_ellipsoid)
     EXPECT_NEAR(bonus[3].quat[3], sqrt(5.0 / 30.0), EPSILON);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("pair_coeff * *");
-    lmp->input->one("group two id 2:4:2");
-    lmp->input->one("delete_atoms group two compress no");
-    lmp->input->one("write_restart test_atom_styles.restart");
-    lmp->input->one("clear");
-    lmp->input->one("read_restart test_atom_styles.restart");
-    lmp->input->one("replicate 1 1 2 bbox");
+    command("pair_coeff * *");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    command("read_restart test_atom_styles.restart");
+    command("replicate 1 1 2 bbox");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("hybrid"));
     hybrid = (AtomVecHybrid *)lmp->atom->avec;
@@ -4485,7 +4494,7 @@ TEST_F(AtomStyleTest, full_ellipsoid)
     EXPECT_NEAR(bonus[3].quat[3], 0.25056280708573159, EPSILON);
 
     if (!verbose) ::testing::internal::CaptureStdout();
-    lmp->input->one("reset_atom_ids");
+    command("reset_atom_ids");
     if (!verbose) ::testing::internal::GetCapturedStdout();
     ASSERT_EQ(lmp->atom->nellipsoids, 4);
     ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
@@ -4551,6 +4560,247 @@ TEST_F(AtomStyleTest, full_ellipsoid)
     EXPECT_NEAR(bonus[3].quat[3], 0.25056280708573159, EPSILON);
 }
 
+TEST_F(AtomStyleTest, property_atom)
+{
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("atom_modify map array");
+    command("fix Properties all property/atom i_one d_two mol d_three q rmass ghost yes");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+
+    AtomState expected;
+    expected.atom_style         = "atomic";
+    expected.molecular          = Atom::ATOMIC;
+    expected.tag_enable         = 1;
+    expected.map_style          = 1;
+    expected.map_user           = 1;
+    expected.has_type           = true;
+    expected.has_image          = true;
+    expected.has_mask           = true;
+    expected.has_x              = true;
+    expected.has_v              = true;
+    expected.has_f              = true;
+    expected.has_iname          = true;
+    expected.has_dname          = true;
+    expected.has_extra_grow     = true;
+    expected.has_extra_restart  = true;
+    expected.has_extra_border   = true;
+    expected.molecule_flag      = 1;
+    expected.q_flag             = 1;
+    expected.rmass_flag         = 1;
+    expected.nivector           = 1;
+    expected.ndvector           = 2;
+    expected.nextra_grow        = 1;
+    expected.nextra_grow_max    = 1;
+    expected.nextra_restart     = 1;
+    expected.nextra_restart_max = 1;
+    expected.nextra_border      = 1;
+    expected.nextra_border_max  = 1;
+    ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("create_box 2 box");
+    command("create_atoms 1 single -2.0  2.0  0.1");
+    command("create_atoms 1 single -2.0 -2.0 -0.1");
+    command("create_atoms 2 single  2.0  2.0 -0.1");
+    command("create_atoms 2 single  2.0 -2.0  0.1");
+    command("mass 1 4.0");
+    command("mass 2 2.4");
+    command("set atom 1 charge -0.5");
+    command("set atom 2 charge  0.5");
+    command("set atom 3 charge -1.0");
+    command("set atom 4 charge  1.0");
+    command("set type 1 mass 4.0");
+    command("set type 2 mass 2.4");
+    command("set atom 1 mol 1");
+    command("set atom 2 mol 2");
+    command("set atom 3 mol 2");
+    command("set atom 4 mol 1");
+    command("set atom * i_one -5");
+    command("set atom 3* i_one 5");
+    command("set type 1 d_two 2.0");
+    command("set type 2 d_two 1.0");
+    command("set atom 1 d_three -2.5");
+    command("set atom 2 d_three -1.0");
+    command("set atom 3 d_three 0.5");
+    command("set atom 4 d_three 2.0");
+
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    expected.natoms           = 4;
+    expected.nlocal           = 4;
+    expected.map_tag_max      = 4;
+    expected.nmax             = 16384;
+    expected.ntypes           = 2;
+    expected.has_mass         = true;
+    expected.has_mass_setflag = true;
+    expected.has_sametag      = true;
+    ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
+    ASSERT_NE(lmp->atom->avec, nullptr);
+    ASSERT_NE(lmp->atom->nmax, -1);
+    ASSERT_NE(lmp->atom->rmass, nullptr);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("pair_coeff * *");
+    command("write_data test_atom_styles.data nocoeff");
+    command("clear");
+    command("atom_style atomic");
+    command("pair_style zero 4.0");
+    command("units real");
+    command("atom_modify map array");
+    command("fix props all property/atom i_one d_two mol d_three q rmass ghost yes");
+    command("read_data test_atom_styles.data fix props NULL Properties");
+    command("pair_coeff * *");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("atomic"));
+    ASSERT_NE(lmp->atom->avec, nullptr);
+    ASSERT_EQ(lmp->atom->natoms, 4);
+    ASSERT_EQ(lmp->atom->nlocal, 4);
+    ASSERT_EQ(lmp->atom->nghost, 0);
+    ASSERT_NE(lmp->atom->nmax, -1);
+    ASSERT_EQ(lmp->atom->tag_enable, 1);
+    ASSERT_EQ(lmp->atom->molecular, Atom::ATOMIC);
+    ASSERT_EQ(lmp->atom->ntypes, 2);
+    ASSERT_EQ(lmp->atom->q_flag, 1);
+    ASSERT_EQ(lmp->atom->molecule_flag, 1);
+    ASSERT_EQ(lmp->atom->rmass_flag, 1);
+    ASSERT_NE(lmp->atom->sametag, nullptr);
+    ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
+    ASSERT_EQ(lmp->atom->map_style, Atom::MAP_ARRAY);
+    ASSERT_EQ(lmp->atom->map_user, 1);
+    ASSERT_EQ(lmp->atom->map_tag_max, 4);
+
+    auto x = lmp->atom->x;
+    auto v = lmp->atom->v;
+    auto q = lmp->atom->q;
+    EXPECT_NEAR(x[GETIDX(1)][0], -2.0, EPSILON);
+    EXPECT_NEAR(x[GETIDX(1)][1], 2.0, EPSILON);
+    EXPECT_NEAR(x[GETIDX(1)][2], 0.1, EPSILON);
+    EXPECT_NEAR(x[GETIDX(2)][0], -2.0, EPSILON);
+    EXPECT_NEAR(x[GETIDX(2)][1], -2.0, EPSILON);
+    EXPECT_NEAR(x[GETIDX(2)][2], -0.1, EPSILON);
+    EXPECT_NEAR(x[GETIDX(3)][0], 2.0, EPSILON);
+    EXPECT_NEAR(x[GETIDX(3)][1], 2.0, EPSILON);
+    EXPECT_NEAR(x[GETIDX(3)][2], -0.1, EPSILON);
+    EXPECT_NEAR(x[GETIDX(4)][0], 2.0, EPSILON);
+    EXPECT_NEAR(x[GETIDX(4)][1], -2.0, EPSILON);
+    EXPECT_NEAR(x[GETIDX(4)][2], 0.1, EPSILON);
+    EXPECT_NEAR(v[GETIDX(1)][0], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(1)][1], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(1)][2], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(2)][0], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(2)][1], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(2)][2], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(3)][0], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(3)][1], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(3)][2], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(4)][0], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(4)][1], 0.0, EPSILON);
+    EXPECT_NEAR(v[GETIDX(4)][2], 0.0, EPSILON);
+    EXPECT_NEAR(q[GETIDX(1)], -0.5, EPSILON);
+    EXPECT_NEAR(q[GETIDX(2)], 0.5, EPSILON);
+    EXPECT_NEAR(q[GETIDX(3)], -1.0, EPSILON);
+    EXPECT_NEAR(q[GETIDX(4)], 1.0, EPSILON);
+
+    EXPECT_NEAR(lmp->atom->mass[1], 4.0, EPSILON);
+    EXPECT_NEAR(lmp->atom->mass[2], 2.4, EPSILON);
+    ASSERT_EQ(lmp->atom->mass_setflag[1], 1);
+    ASSERT_EQ(lmp->atom->mass_setflag[2], 1);
+
+    auto rmass = lmp->atom->rmass;
+    auto one   = lmp->atom->ivector[0];
+    auto two   = lmp->atom->dvector[0];
+    auto three = lmp->atom->dvector[1];
+
+    EXPECT_NEAR(rmass[GETIDX(1)], 4.0, EPSILON);
+    EXPECT_NEAR(rmass[GETIDX(2)], 4.0, EPSILON);
+    EXPECT_NEAR(rmass[GETIDX(3)], 2.4, EPSILON);
+    EXPECT_NEAR(rmass[GETIDX(4)], 2.4, EPSILON);
+    EXPECT_EQ(one[GETIDX(1)], -5);
+    EXPECT_EQ(one[GETIDX(2)], -5);
+    EXPECT_EQ(one[GETIDX(3)], 5);
+    EXPECT_EQ(one[GETIDX(4)], 5);
+    EXPECT_NEAR(two[GETIDX(1)], 2.0, EPSILON);
+    EXPECT_NEAR(two[GETIDX(2)], 2.0, EPSILON);
+    EXPECT_NEAR(two[GETIDX(3)], 1.0, EPSILON);
+    EXPECT_NEAR(two[GETIDX(4)], 1.0, EPSILON);
+    EXPECT_NEAR(three[GETIDX(1)], -2.5, EPSILON);
+    EXPECT_NEAR(three[GETIDX(2)], -1.0, EPSILON);
+    EXPECT_NEAR(three[GETIDX(3)], 0.5, EPSILON);
+    EXPECT_NEAR(three[GETIDX(4)], 2.0, EPSILON);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("pair_coeff * *");
+    command("group two id 2:4:2");
+    command("delete_atoms group two compress no");
+    command("write_restart test_atom_styles.restart");
+    command("clear");
+    ASSERT_THAT(std::string(lmp->atom->atom_style), Eq("atomic"));
+    command("read_restart test_atom_styles.restart");
+    command("fix props all property/atom i_one d_two mol d_three q rmass ghost yes");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    expected.natoms           = 2;
+    expected.nlocal           = 2;
+    expected.nghost           = 0;
+    expected.map_tag_max      = 3;
+    expected.nmax             = 16384;
+    expected.ntypes           = 2;
+    expected.has_mass         = true;
+    expected.has_mass_setflag = true;
+    expected.has_sametag      = true;
+    expected.has_extra        = true;
+    expected.nextra_store     = 7;
+
+    ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
+    ASSERT_NE(lmp->atom->avec, nullptr);
+    ASSERT_EQ(lmp->atom->tag_consecutive(), 0);
+
+    q = lmp->atom->q;
+    EXPECT_NEAR(q[GETIDX(1)], -0.5, EPSILON);
+    EXPECT_NEAR(q[GETIDX(3)], -1.0, EPSILON);
+
+    rmass = lmp->atom->rmass;
+    one   = lmp->atom->ivector[0];
+    two   = lmp->atom->dvector[0];
+    three = lmp->atom->dvector[1];
+    EXPECT_NEAR(lmp->atom->mass[1], 4.0, EPSILON);
+    EXPECT_NEAR(lmp->atom->mass[2], 2.4, EPSILON);
+    ASSERT_EQ(lmp->atom->mass_setflag[1], 1);
+    ASSERT_EQ(lmp->atom->mass_setflag[2], 1);
+    EXPECT_NEAR(rmass[GETIDX(1)], 4.0, EPSILON);
+    EXPECT_NEAR(rmass[GETIDX(3)], 2.4, EPSILON);
+    EXPECT_EQ(one[GETIDX(1)], -5);
+    EXPECT_EQ(one[GETIDX(3)], 5);
+    EXPECT_NEAR(two[GETIDX(1)], 2.0, EPSILON);
+    EXPECT_NEAR(two[GETIDX(3)], 1.0, EPSILON);
+    EXPECT_NEAR(three[GETIDX(1)], -2.5, EPSILON);
+    EXPECT_NEAR(three[GETIDX(3)], 0.5, EPSILON);
+
+    if (!verbose) ::testing::internal::CaptureStdout();
+    command("reset_atom_ids");
+    command("change_box all triclinic");
+    if (!verbose) ::testing::internal::GetCapturedStdout();
+    ASSERT_EQ(lmp->atom->map_tag_max, 2);
+    q = lmp->atom->q;
+    EXPECT_NEAR(q[GETIDX(1)], -0.5, EPSILON);
+    EXPECT_NEAR(q[GETIDX(2)], -1.0, EPSILON);
+
+    rmass = lmp->atom->rmass;
+    one   = lmp->atom->ivector[0];
+    two   = lmp->atom->dvector[0];
+    three = lmp->atom->dvector[1];
+    EXPECT_NEAR(lmp->atom->mass[1], 4.0, EPSILON);
+    EXPECT_NEAR(lmp->atom->mass[2], 2.4, EPSILON);
+    ASSERT_EQ(lmp->atom->mass_setflag[1], 1);
+    ASSERT_EQ(lmp->atom->mass_setflag[2], 1);
+    EXPECT_NEAR(rmass[GETIDX(1)], 4.0, EPSILON);
+    EXPECT_NEAR(rmass[GETIDX(2)], 2.4, EPSILON);
+    EXPECT_EQ(one[GETIDX(1)], -5);
+    EXPECT_EQ(one[GETIDX(2)], 5);
+    EXPECT_NEAR(two[GETIDX(1)], 2.0, EPSILON);
+    EXPECT_NEAR(two[GETIDX(2)], 1.0, EPSILON);
+    EXPECT_NEAR(three[GETIDX(1)], -2.5, EPSILON);
+    EXPECT_NEAR(three[GETIDX(2)], 0.5, EPSILON);
+}
+
 } // namespace LAMMPS_NS
 
 int main(int argc, char **argv)
diff --git a/unittest/utils/test_tokenizer.cpp b/unittest/utils/test_tokenizer.cpp
index 74eeaac832..de7472599c 100644
--- a/unittest/utils/test_tokenizer.cpp
+++ b/unittest/utils/test_tokenizer.cpp
@@ -102,7 +102,7 @@ TEST(Tokenizer, default_separators)
     ASSERT_EQ(t.count(), 2);
 }
 
-TEST(Tokenizer, as_vector)
+TEST(Tokenizer, as_vector1)
 {
     Tokenizer t(" \r\n test \t word \f");
     std::vector<std::string> list = t.as_vector();
@@ -110,6 +110,29 @@ TEST(Tokenizer, as_vector)
     ASSERT_THAT(list[1], Eq("word"));
 }
 
+TEST(Tokenizer, as_vector2)
+{
+    auto list = Tokenizer("a\\b\\c","\\").as_vector();
+    ASSERT_THAT(list[0], Eq("a"));
+    ASSERT_THAT(list[1], Eq("b"));
+    ASSERT_THAT(list[2], Eq("c"));
+    ASSERT_EQ(list.size(), 3);
+}
+
+TEST(Tokenizer, as_vector3)
+{
+    auto list = Tokenizer ("a\\","\\").as_vector();
+    ASSERT_THAT(list[0], Eq("a"));
+    ASSERT_EQ(list.size(), 1);
+}
+
+TEST(Tokenizer, as_vector4)
+{
+    auto list = Tokenizer ("\\a","\\").as_vector();
+    ASSERT_THAT(list[0], Eq("a"));
+    ASSERT_EQ(list.size(), 1);
+}
+
 TEST(ValueTokenizer, empty_string)
 {
     ValueTokenizer values("");
@@ -170,3 +193,31 @@ TEST(ValueTokenizer, not_contains)
     ValueTokenizer values("test word");
     ASSERT_FALSE(values.contains("test2"));
 }
+
+TEST(ValueTokenizer, missing_int)
+{
+    ValueTokenizer values("10");
+    ASSERT_EQ(values.next_int(), 10);
+    ASSERT_THROW(values.next_int(), TokenizerException);
+}
+
+TEST(ValueTokenizer, missing_tagint)
+{
+    ValueTokenizer values("42");
+    ASSERT_EQ(values.next_tagint(), 42);
+    ASSERT_THROW(values.next_tagint(), TokenizerException);
+}
+
+TEST(ValueTokenizer, missing_bigint)
+{
+    ValueTokenizer values("42");
+    ASSERT_EQ(values.next_bigint(), 42);
+    ASSERT_THROW(values.next_bigint(), TokenizerException);
+}
+
+TEST(ValueTokenizer, missing_double)
+{
+    ValueTokenizer values("3.14");
+    ASSERT_DOUBLE_EQ(values.next_double(), 3.14);
+    ASSERT_THROW(values.next_double(), TokenizerException);
+}
diff --git a/unittest/utils/test_utils.cpp b/unittest/utils/test_utils.cpp
index 5b509318c9..2fa17a5e5a 100644
--- a/unittest/utils/test_utils.cpp
+++ b/unittest/utils/test_utils.cpp
@@ -550,6 +550,18 @@ TEST(Utils, bounds_case1)
     utils::bounds(FLERR, "1", 1, 10, nlo, nhi, nullptr);
     ASSERT_EQ(nlo, 1);
     ASSERT_EQ(nhi, 1);
+    utils::bounds(FLERR, "1x", 1, 10, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
+    utils::bounds(FLERR, "-1", 1, 10, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
+    utils::bounds(FLERR, "+1", 1, 10, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
+    utils::bounds(FLERR, "1:3", 1, 10, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
 }
 
 TEST(Utils, bounds_case2)
@@ -563,6 +575,9 @@ TEST(Utils, bounds_case2)
     utils::bounds(FLERR, "*", -10, 5, nlo, nhi, nullptr);
     ASSERT_EQ(nlo, -10);
     ASSERT_EQ(nhi, 5);
+    utils::bounds(FLERR, "?", -10, 5, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
 }
 
 TEST(Utils, bounds_case3)
@@ -576,32 +591,9 @@ TEST(Utils, bounds_case3)
     utils::bounds(FLERR, "3*", -10, 5, nlo, nhi, nullptr);
     ASSERT_EQ(nlo, 3);
     ASSERT_EQ(nhi, 5);
-}
-
-TEST(Utils, bounds_case4)
-{
-    int nlo, nhi;
-
-    nlo = nhi = -1;
-    utils::bounds(FLERR, "*2", 0, 10, nlo, nhi, nullptr);
-    ASSERT_EQ(nlo, 0);
-    ASSERT_EQ(nhi, 2);
-    utils::bounds(FLERR, "*3", -10, 5, nlo, nhi, nullptr);
-    ASSERT_EQ(nlo, -10);
-    ASSERT_EQ(nhi, 3);
-}
-
-TEST(Utils, bounds_case5)
-{
-    int nlo, nhi;
-
-    nlo = nhi = -1;
-    utils::bounds(FLERR, "2*5", 0, 10, nlo, nhi, nullptr);
-    ASSERT_EQ(nlo, 2);
-    ASSERT_EQ(nhi, 5);
-    utils::bounds(FLERR, "-2*3", -10, 5, nlo, nhi, nullptr);
-    ASSERT_EQ(nlo, -2);
-    ASSERT_EQ(nhi, 3);
+    utils::bounds(FLERR, "3*:2", -10, 5, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
 }
 
 TEST(Utils, boundsbig_case1)
@@ -615,6 +607,18 @@ TEST(Utils, boundsbig_case1)
     utils::bounds(FLERR, "1", 1, 10, nlo, nhi, nullptr);
     ASSERT_EQ(nlo, 1);
     ASSERT_EQ(nhi, 1);
+    utils::bounds(FLERR, "1x", 1, 10, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
+    utils::bounds(FLERR, "-1", 1, 10, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
+    utils::bounds(FLERR, "+1", 1, 10, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
+    utils::bounds(FLERR, "1:3", 1, 10, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
 }
 
 TEST(Utils, boundsbig_case2)
@@ -628,6 +632,9 @@ TEST(Utils, boundsbig_case2)
     utils::bounds(FLERR, "*", -10, 5, nlo, nhi, nullptr);
     ASSERT_EQ(nlo, -10);
     ASSERT_EQ(nhi, 5);
+    utils::bounds(FLERR, "?", -10, 5, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
 }
 
 TEST(Utils, boundsbig_case3)
@@ -641,32 +648,9 @@ TEST(Utils, boundsbig_case3)
     utils::bounds(FLERR, "3*", -10, 5, nlo, nhi, nullptr);
     ASSERT_EQ(nlo, 3);
     ASSERT_EQ(nhi, 5);
-}
-
-TEST(Utils, boundsbig_case4)
-{
-    bigint nlo, nhi;
-
-    nlo = nhi = -1;
-    utils::bounds(FLERR, "*2", 0, 10, nlo, nhi, nullptr);
-    ASSERT_EQ(nlo, 0);
-    ASSERT_EQ(nhi, 2);
-    utils::bounds(FLERR, "*3", -10, 5, nlo, nhi, nullptr);
-    ASSERT_EQ(nlo, -10);
-    ASSERT_EQ(nhi, 3);
-}
-
-TEST(Utils, boundsbig_case5)
-{
-    bigint nlo, nhi;
-
-    nlo = nhi = -1;
-    utils::bounds(FLERR, "2*5", 0, 10, nlo, nhi, nullptr);
-    ASSERT_EQ(nlo, 2);
-    ASSERT_EQ(nhi, 5);
-    utils::bounds(FLERR, "-2*3", -10, 5, nlo, nhi, nullptr);
-    ASSERT_EQ(nlo, -2);
-    ASSERT_EQ(nhi, 3);
+    utils::bounds(FLERR, "3*:2", -10, 5, nlo, nhi, nullptr);
+    ASSERT_EQ(nlo, -1);
+    ASSERT_EQ(nhi, -1);
 }
 
 TEST(Utils, guesspath)