Homec4science
Diffusion lammps (lammm-master-deprecated) Browse

lammps/doc/src/Section_tools.txt
429d56e3a380lammm-master-deprecated

Last Change
Raw File

Section_tools.txt
View Options

"Previous Section"_Section_perf.html - "LAMMPS WWW Site"_lws - "LAMMPS
Documentation"_ld - "LAMMPS Commands"_lc - "Next
Section"_Section_modify.html :c
:link(lws,http://lammps.sandia.gov)
:link(ld,Manual.html)
:link(lc,Section_commands.html#comm)
:line
9. Additional tools :h3
LAMMPS is designed to be a computational kernel for performing
molecular dynamics computations. Additional pre- and post-processing
steps are often necessary to setup and analyze a simulation. A few
additional tools are provided with the LAMMPS distribution and are
described in this section.
Our group has also written and released a separate toolkit called
"Pizza.py"_pizza which provides tools for doing setup, analysis,
plotting, and visualization for LAMMPS simulations. Pizza.py is
written in "Python"_python and is available for download from "the
Pizza.py WWW site"_pizza.
:link(pizza,http://www.sandia.gov/~sjplimp/pizza.html)
:link(python,http://www.python.org)
Note that many users write their own setup or analysis tools or use
other existing codes and convert their output to a LAMMPS input format
or vice versa. The tools listed here are included in the LAMMPS
distribution as examples of auxiliary tools. Some of them are not
actively supported by Sandia, as they were contributed by LAMMPS
users. If you have problems using them, we can direct you to the
authors.
The source code for each of these codes is in the tools sub-directory
of the LAMMPS distribution. There is a Makefile (which you may need
to edit for your platform) which will build several of the tools which
reside in that directory. Some of them are larger packages in their
own sub-directories with their own Makefiles.
"amber2lmp"_#amber
"binary2txt"_#binary
"ch2lmp"_#charmm
"chain"_#chain
"colvars"_#colvars
"createatoms"_#create
"data2xmovie"_#data
"eam database"_#eamdb
"eam generate"_#eamgn
"eff"_#eff
"emacs"_#emacs
"fep"_#fep
"i-pi"_#ipi
"ipp"_#ipp
"kate"_#kate
"lmp2arc"_#arc
"lmp2cfg"_#cfg
"lmp2vmd"_#vmd
"matlab"_#matlab
"micelle2d"_#micelle
"moltemplate"_#moltemplate
"msi2lmp"_#msi
"phonon"_#phonon
"polymer bonding"_#polybond
"pymol_asphere"_#pymol
"python"_#pythontools
"reax"_#reax_tool
"restart2data"_#restart
"vim"_#vim
"xmgrace"_#xmgrace
"xmovie"_#xmovie :ul
:line
amber2lmp tool :h4,link(amber)
The amber2lmp sub-directory contains two Python scripts for converting
files back-and-forth between the AMBER MD code and LAMMPS. See the
README file in amber2lmp for more information.
These tools were written by Keir Novik while he was at Queen Mary
University of London. Keir is no longer there and cannot support
these tools which are out-of-date with respect to the current LAMMPS
version (and maybe with respect to AMBER as well). Since we don't use
these tools at Sandia, you'll need to experiment with them and make
necessary modifications yourself.
:line
binary2txt tool :h4,link(binary)
The file binary2txt.cpp converts one or more binary LAMMPS dump file
into ASCII text files. The syntax for running the tool is
binary2txt file1 file2 ... :pre
which creates file1.txt, file2.txt, etc. This tool must be compiled
on a platform that can read the binary file created by a LAMMPS run,
since binary files are not compatible across all platforms.
:line
ch2lmp tool :h4,link(charmm)
The ch2lmp sub-directory contains tools for converting files
back-and-forth between the CHARMM MD code and LAMMPS.
They are intended to make it easy to use CHARMM as a builder and as a
post-processor for LAMMPS. Using charmm2lammps.pl, you can convert an
ensemble built in CHARMM into its LAMMPS equivalent. Using
lammps2pdb.pl you can convert LAMMPS atom dumps into pdb files.
See the README file in the ch2lmp sub-directory for more information.
These tools were created by Pieter in't Veld (pjintve at sandia.gov)
and Paul Crozier (pscrozi at sandia.gov) at Sandia.
:line
chain tool :h4,link(chain)
The file chain.f creates a LAMMPS data file containing bead-spring
polymer chains and/or monomer solvent atoms. It uses a text file
containing chain definition parameters as an input. The created
chains and solvent atoms can strongly overlap, so LAMMPS needs to run
the system initially with a "soft" pair potential to un-overlap it.
The syntax for running the tool is
chain < def.chain > data.file :pre
See the def.chain or def.chain.ab files in the tools directory for
examples of definition files. This tool was used to create the
system for the "chain benchmark"_Section_perf.html.
:line
colvars tools :h4,link(colvars)
The colvars directory contains a collection of tools for postprocessing
data produced by the colvars collective variable library.
To compile the tools, edit the makefile for your system and run "make".
Please report problems and issues the colvars library and its tools
at: https://github.com/colvars/colvars/issues
abf_integrate:
MC-based integration of multidimensional free energy gradient
Version 20110511
Syntax: ./abf_integrate < filename > \[-n < nsteps >\] \[-t < temp >\] \[-m \[0|1\] (metadynamics)\] \[-h < hill_height >\] \[-f < variable_hill_factor >\] :pre
The LAMMPS interface to the colvars collective variable library, as
well as these tools, were created by Axel Kohlmeyer (akohlmey at
gmail.com) at ICTP, Italy.
:line
createatoms tool :h4,link(create)
The tools/createatoms directory contains a Fortran program called
createAtoms.f which can generate a variety of interesting crystal
structures and geometries and output the resulting list of atom
coordinates in LAMMPS or other formats.
See the included Manual.pdf for details.
The tool is authored by Xiaowang Zhou (Sandia), xzhou at sandia.gov.
:line
data2xmovie tool :h4,link(data)
The file data2xmovie.c converts a LAMMPS data file into a snapshot
suitable for visualizing with the "xmovie"_#xmovie tool, as if it had
been output with a dump command from LAMMPS itself. The syntax for
running the tool is
data2xmovie \[options\] < infile > outfile :pre
See the top of the data2xmovie.c file for a discussion of the options.
:line
eam database tool :h4,link(eamdb)
The tools/eam_database directory contains a Fortran program that will
generate EAM alloy setfl potential files for any combination of 16
elements: Cu, Ag, Au, Ni, Pd, Pt, Al, Pb, Fe, Mo, Ta, W, Mg, Co, Ti,
Zr. The files can then be used with the "pair_style
eam/alloy"_pair_eam.html command.
The tool is authored by Xiaowang Zhou (Sandia), xzhou at sandia.gov,
and is based on his paper:
X. W. Zhou, R. A. Johnson, and H. N. G. Wadley, Phys. Rev. B, 69,
144113 (2004).
:line
eam generate tool :h4,link(eamgn)
The tools/eam_generate directory contains several one-file C programs
that convert an analytic formula into a tabulated "embedded atom
method (EAM)"_pair_eam.html setfl potential file. The potentials they
produce are in the potentials directory, and can be used with the
"pair_style eam/alloy"_pair_eam.html command.
The source files and potentials were provided by Gerolf Ziegenhain
(gerolf at ziegenhain.com).
:line
eff tool :h4,link(eff)
The tools/eff directory contains various scripts for generating
structures and post-processing output for simulations using the
electron force field (eFF).
These tools were provided by Andres Jaramillo-Botero at CalTech
(ajaramil at wag.caltech.edu).
:line
emacs tool :h4,link(emacs)
The tools/emacs directory contains a Lips add-on file for Emacs that
enables a lammps-mode for editing of input scripts when using Emacs,
with various highlighting options setup.
These tools were provided by Aidan Thompson at Sandia
(athomps at sandia.gov).
:line
fep tool :h4,link(fep)
The tools/fep directory contains Python scripts useful for
post-processing results from performing free-energy perturbation
simulations using the USER-FEP package.
The scripts were contributed by Agilio Padua (Universite Blaise
Pascal Clermont-Ferrand), agilio.padua at univ-bpclermont.fr.
See README file in the tools/fep directory.
:line
i-pi tool :h4,link(ipi)
The tools/i-pi directory contains a version of the i-PI package, with
all the LAMMPS-unrelated files removed. It is provided so that it can
be used with the "fix ipi"_fix_ipi.html command to perform
path-integral molecular dynamics (PIMD).
The i-PI package was created and is maintained by Michele Ceriotti,
michele.ceriotti at gmail.com, to interface to a variety of molecular
dynamics codes.
See the tools/i-pi/manual.pdf file for an overview of i-PI, and the
"fix ipi"_fix_ipi.html doc page for further details on running PIMD
calculations with LAMMPS.
:line
ipp tool :h4,link(ipp)
The tools/ipp directory contains a Perl script ipp which can be used
to facilitate the creation of a complicated file (say, a lammps input
script or tools/createatoms input file) using a template file.
ipp was created and is maintained by Reese Jones (Sandia), rjones at
sandia.gov.
See two examples in the tools/ipp directory. One of them is for the
tools/createatoms tool's input file.
:line
kate tool :h4,link(kate)
The file in the tools/kate directory is an add-on to the Kate editor
in the KDE suite that allow syntax highlighting of LAMMPS input
scripts. See the README.txt file for details.
The file was provided by Alessandro Luigi Sellerio
(alessandro.sellerio at ieni.cnr.it).
:line
lmp2arc tool :h4,link(arc)
The lmp2arc sub-directory contains a tool for converting LAMMPS output
files to the format for Accelrys' Insight MD code (formerly
MSI/Biosym and its Discover MD code). See the README file for more
information.
This tool was written by John Carpenter (Cray), Michael Peachey
(Cray), and Steve Lustig (Dupont). John is now at the Mayo Clinic
(jec at mayo.edu), but still fields questions about the tool.
This tool was updated for the current LAMMPS C++ version by Jeff
Greathouse at Sandia (jagreat at sandia.gov).
:line
lmp2cfg tool :h4,link(cfg)
The lmp2cfg sub-directory contains a tool for converting LAMMPS output
files into a series of *.cfg files which can be read into the
"AtomEye"_http://mt.seas.upenn.edu/Archive/Graphics/A visualizer. See
the README file for more information.
This tool was written by Ara Kooser at Sandia (askoose at sandia.gov).
:line
lmp2vmd tool :h4,link(vmd)
The lmp2vmd sub-directory contains a README.txt file that describes
details of scripts and plugin support within the "VMD
package"_http://www.ks.uiuc.edu/Research/vmd for visualizing LAMMPS
dump files.
The VMD plugins and other supporting scripts were written by Axel
Kohlmeyer (akohlmey at cmm.chem.upenn.edu) at U Penn.
:line
matlab tool :h4,link(matlab)
The matlab sub-directory contains several "MATLAB"_matlab scripts for
post-processing LAMMPS output. The scripts include readers for log
and dump files, a reader for EAM potential files, and a converter that
reads LAMMPS dump files and produces CFG files that can be visualized
with the "AtomEye"_http://mt.seas.upenn.edu/Archive/Graphics/A
visualizer.
See the README.pdf file for more information.
These scripts were written by Arun Subramaniyan at Purdue Univ
(asubrama at purdue.edu).
:link(matlab,http://www.mathworks.com)
:line
micelle2d tool :h4,link(micelle)
The file micelle2d.f creates a LAMMPS data file containing short lipid
chains in a monomer solution. It uses a text file containing lipid
definition parameters as an input. The created molecules and solvent
atoms can strongly overlap, so LAMMPS needs to run the system
initially with a "soft" pair potential to un-overlap it. The syntax
for running the tool is
micelle2d < def.micelle2d > data.file :pre
See the def.micelle2d file in the tools directory for an example of a
definition file. This tool was used to create the system for the
"micelle example"_Section_example.html.
:line
moltemplate tool :h4,link(moltemplate)
The moltemplate sub-directory contains a Python-based tool for
building molecular systems based on a text-file description, and
creating LAMMPS data files that encode their molecular topology as
lists of bonds, angles, dihedrals, etc. See the README.TXT file for
more information.
This tool was written by Andrew Jewett (jewett.aij at gmail.com), who
supports it. It has its own WWW page at
"http://moltemplate.org"_http://moltemplate.org.
:line
msi2lmp tool :h4,link(msi)
The msi2lmp sub-directory contains a tool for creating LAMMPS input
data files from Accelrys' Insight MD code (formerly MSI/Biosym and
its Discover MD code). See the README file for more information.
This tool was written by John Carpenter (Cray), Michael Peachey
(Cray), and Steve Lustig (Dupont). John is now at the Mayo Clinic
(jec at mayo.edu), but still fields questions about the tool.
This tool may be out-of-date with respect to the current LAMMPS and
Insight versions. Since we don't use it at Sandia, you'll need to
experiment with it yourself.
:line
phonon tool :h4,link(phonon)
The phonon sub-directory contains a post-processing tool useful for
analyzing the output of the "fix phonon"_fix_phonon.html command in
the USER-PHONON package.
See the README file for instruction on building the tool and what
library it needs. And see the examples/USER/phonon directory
for example problems that can be post-processed with this tool.
This tool was written by Ling-Ti Kong at Shanghai Jiao Tong
University.
:line
polymer bonding tool :h4,link(polybond)
The polybond sub-directory contains a Python-based tool useful for
performing "programmable polymer bonding". The Python file
lmpsdata.py provides a "Lmpsdata" class with various methods which can
be invoked by a user-written Python script to create data files with
complex bonding topologies.
See the Manual.pdf for details and example scripts.
This tool was written by Zachary Kraus at Georgia Tech.
:line
pymol_asphere tool :h4,link(pymol)
The pymol_asphere sub-directory contains a tool for converting a
LAMMPS dump file that contains orientation info for ellipsoidal
particles into an input file for the "PyMol visualization
package"_pymol.
:link(pymol,http://pymol.sourceforge.net)
Specifically, the tool triangulates the ellipsoids so they can be
viewed as true ellipsoidal particles within PyMol. See the README and
examples directory within pymol_asphere for more information.
This tool was written by Mike Brown at Sandia.
:line
python tool :h4,link(pythontools)
The python sub-directory contains several Python scripts
that perform common LAMMPS post-processing tasks, such as:
extract thermodynamic info from a log file as columns of numbers
plot two columns of thermodynamic info from a log file using GnuPlot
sort the snapshots in a dump file by atom ID
convert multiple "NEB"_neb.html dump files into one dump file for viz
convert dump files into XYZ, CFG, or PDB format for viz by other packages :ul
These are simple scripts built on "Pizza.py"_pizza modules. See the
README for more info on Pizza.py and how to use these scripts.
:line
reax tool :h4,link(reax_tool)
The reax sub-directory contains stand-alond codes that can
post-process the output of the "fix reax/bonds"_fix_reax_bonds.html
command from a LAMMPS simulation using "ReaxFF"_pair_reax.html. See
the README.txt file for more info.
These tools were written by Aidan Thompson at Sandia.
:line
restart2data tool :h4,link(restart)
NOTE: This tool is now obsolete and is not included in the current
LAMMPS distribution. This is becaues there is now a
"write_data"_write_data.html command, which can create a data file
from within an input script. Running LAMMPS with the "-r"
"command-line switch"_Section_start.html#start_7 as follows:
lmp_g++ -r restartfile datafile
is the same as running a 2-line input script:
read_restart restartfile
write_data datafile
which will produce the same data file that the restart2data tool used
to create. The following information is included in case you have an
older version of LAMMPS which still includes the restart2data tool.
The file restart2data.cpp converts a binary LAMMPS restart file into
an ASCII data file. The syntax for running the tool is
restart2data restart-file data-file (input-file) :pre
Input-file is optional and if specified will contain LAMMPS input
commands for the masses and force field parameters, instead of putting
those in the data-file. Only a few force field styles currently
support this option.
This tool must be compiled on a platform that can read the binary file
created by a LAMMPS run, since binary files are not compatible across
all platforms.
Note that a text data file has less precision than a binary restart
file. Hence, continuing a run from a converted data file will
typically not conform as closely to a previous run as will restarting
from a binary restart file.
If a "%" appears in the specified restart-file, the tool expects a set
of multiple files to exist. See the "restart"_restart.html and
"write_restart"_write_restart.html commands for info on how such sets
of files are written by LAMMPS, and how the files are named.
:line
vim tool :h4,link(vim)
The files in the tools/vim directory are add-ons to the VIM editor
that allow easier editing of LAMMPS input scripts. See the README.txt
file for details.
These files were provided by Gerolf Ziegenhain (gerolf at
ziegenhain.com)
:line
xmgrace tool :h4,link(xmgrace)
The files in the tools/xmgrace directory can be used to plot the
thermodynamic data in LAMMPS log files via the xmgrace plotting
package. There are several tools in the directory that can be used in
post-processing mode. The lammpsplot.cpp file can be compiled and
used to create plots from the current state of a running LAMMPS
simulation.
See the README file for details.
These files were provided by Vikas Varshney (vv0210 at gmail.com)
:line
xmovie tool :h4,link(xmovie)
The xmovie tool is an X-based visualization package that can read
LAMMPS dump files and animate them. It is in its own sub-directory
with the tools directory. You may need to modify its Makefile so that
it can find the appropriate X libraries to link against.
The syntax for running xmovie is
xmovie \[options\] dump.file1 dump.file2 ... :pre
If you just type "xmovie" you will see a list of options. Note that
by default, LAMMPS dump files are in scaled coordinates, so you
typically need to use the -scale option with xmovie. When xmovie runs
it opens a visualization window and a control window. The control
options are straightforward to use.
Xmovie was mostly written by Mike Uttormark (U Wisconsin) while he
spent a summer at Sandia. It displays 2d projections of a 3d domain.
While simple in design, it is an amazingly fast program that can
render large numbers of atoms very quickly. It's a useful tool for
debugging LAMMPS input and output and making sure your simulation is
doing what you think it should. The animations on the Examples page
of the "LAMMPS WWW site"_lws were created with xmovie.
I've lost contact with Mike, so I hope he's comfortable with us
distributing his great tool!
c4science · Help