These are examples that work the MDI package in LAMMPS which uses the MolSSI MDI library for coupling codes together and communicating between them with MDI messages. In MDI lingo, one code is the driver and another code is the engine. The 2 codes can be written in any language; C++ (LAMMPS) and Python are illustrated here. The 2 codes can each be stand-alone codes, in which case they can be run on different numbers of processors. The 2 codes can communicate either via TCP (sockets) or via MPI. For the TCP case, the driver and engine need to be launched separately, e.g. in 2 windows on your desktop machine. For the MPI case, a single mpirun command launches both codes. Alternatively the engine code can be a plugin library which the driver code loads, in which case the driver and engine run on the same processors. LAMMPS supports operating in all these MDI modes. It can be an engine operating either as a stand-alone code or as a plugin. It can also be a driver and couple to an engine that is either a stand-alone code or a plugin. Examples for all these use cases are in this directory. The example commands below illustrate how to run all the variants. To use LAMMPS as a plugin engine, you must build it as a shared library. Something like this with make, which also builds the normal LAMMPS executable lmp_mpi: cd src make yes-mdi make mode=shlib mpi To use the serial_driver.py example you will need Python 3 with Numpy and mpi4py available in your Python. Make sure LAMMPS and Python are using same the same version of MPI. 5 use-case examples are explained below. See the Run.sh file for commands to run each of the examples in all the different modes. Type "sh Run.sh" to run them all. In the first 3 examples, results running with MDI should be identical to running without MDI (alone log files). Example #4 has no non-MDI run. Example #5 results should match the non-MDI run of example #1. ------------------------------------------------- ------------------------------------------------- * Example #1 = run ab initio MD (AIMD) See the log aimd files. Two instances of LAMMPS operate as a driver and engine. As an engine, LAMMPS is a surrogate for a quantum code. Note that the 2 input scripts in.aimd.alone and in.aimd.driver have an option for running in NVE vs NPT mode. Comment in/out the appropriate line to change modes. Nothing needs to be changed in the in.aimd.engine or in.aimd.engine.plugin scripts. ------------------------------------------------- ------------------------------------------------- * Example #2 = run LAMMPS, compute QM forces on snapshots from a long run See the log snapshot and dump snapshot files. Two instances of LAMMPS operate as a driver and engine. As an engine, LAMMPS is a surrogate for a quantum code ------------------------------------------------- ------------------------------------------------- * Example #3 = run LAMMPS, compute QM forces on series of independent systems files See the log series and dump series files. Two instances of LAMMPS operate as a driver and engine. As an engine, LAMMPS is a surrogate for a quantum code ------------------------------------------------- ------------------------------------------------- * Example #4 = Python driver runs a sequence of unrelated LAMMPS calculations See the log sequence files. Each calculation can be a single-point evaluation, MD run, or minimization The sequence_driver.py code allows for optional switches in addition to -mdi (required) and the -plugin and -plugin_args switches which are used to link to an engine as a plugin library. The example run commands below just use the default values of the optional switches. The switches are also explained at the top of the file; the info is copied here: # -n 3 # number of calculations to perform, default = 3 # -mode eval/run/min # style of calculations: single snapshot evals, dynamics, minimization # default = run # -size Nx Ny Nz # cubic lattice, default = 2 2 2 # -rho 0.75 0.1 # reduced density and random variation thereof, default = 0.75 0.1 # -delta 0.1 # randomly perturb atoms initially by this distance, default 0.1 # -nsteps 100 # number of timesteps in dynamics runs, default = 100 # -temp 1.0 # initial temperature in dynamics runs, default = 1.0 # -tol 0.001 # tolerance for minimizations, default = 0.001 # -seed 12345 # random number seed > 0, default = 12345 ------------------------------------------------- ------------------------------------------------- * Example #5 = run AIMD with Python driver code and 2 LAMMPS instances as engines See the log aimdpy files. First LAMMPS instance performs the MD timestepping. Second LAMMPS instance is surrogate QM to compute forces. The aimd_driver.py code allows for an optional switch in addition to -mdi (required) and the -plugin and -plugin_args swiches which are used to link to the 2 engines as a plugin libraries. The example run commands below use the default values of the optional switch. The switch is also explained the top of the file; the info is copied here: # -nsteps 10 # number of timesteps in dynamics runs, default = 10