Section_start.html
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, Jul 28, 02:47

Section_start.html
View Options

	<HTML>
	<CENTER><A HREF = "Section_intro.html">Previous Section</A> - <A HREF = "http://lammps.sandia.gov">LAMMPS WWW Site</A> - <A HREF = "Manual.html">LAMMPS Documentation</A> - <A HREF = "Section_commands.html#comm">LAMMPS Commands</A> - <A HREF = "Section_commands.html">Next Section</A>
	</CENTER>






	<HR>

	<H3>2. Getting Started
	</H3>
	<P>This section describes how to build and run LAMMPS, for both new and
	experienced users.
	</P>
	2.1 <A HREF = "#start_1">What's in the LAMMPS distribution</A><BR>
	2.2 <A HREF = "#start_2">Making LAMMPS</A><BR>
	2.3 <A HREF = "#start_3">Making LAMMPS with optional packages</A><BR>
	2.4 <A HREF = "#start_4">Building LAMMPS via the Make.py script</A><BR>
	2.5 <A HREF = "#start_5">Building LAMMPS as a library</A><BR>
	2.6 <A HREF = "#start_6">Running LAMMPS</A><BR>
	2.7 <A HREF = "#start_7">Command-line options</A><BR>
	2.8 <A HREF = "#start_8">Screen output</A><BR>
	2.9 <A HREF = "#start_9">Tips for users of previous versions</A> <BR>

	<HR>

	<HR>

	<H4><A NAME = "start_1"></A>2.1 What's in the LAMMPS distribution
	</H4>
	<P>When you download LAMMPS you will need to unzip and untar the
	downloaded file with the following commands, after placing the file in
	an appropriate directory.
	</P>
	<PRE>gunzip lammps*.tar.gz
	tar xvf lammps*.tar
	</PRE>
	<P>This will create a LAMMPS directory containing two files and several
	sub-directories:
	</P>
	<DIV ALIGN=center><TABLE BORDER=1 >
	<TR><TD >README</TD><TD > text file</TD></TR>
	<TR><TD >LICENSE</TD><TD > the GNU General Public License (GPL)</TD></TR>
	<TR><TD >bench</TD><TD > benchmark problems</TD></TR>
	<TR><TD >doc</TD><TD > documentation</TD></TR>
	<TR><TD >examples</TD><TD > simple test problems</TD></TR>
	<TR><TD >potentials</TD><TD > embedded atom method (EAM) potential files</TD></TR>
	<TR><TD >src</TD><TD > source files</TD></TR>
	<TR><TD >tools</TD><TD > pre- and post-processing tools
	</TD></TR></TABLE></DIV>

	<P>If you download one of the Windows executables from the download page,
	then you just get a single file:
	</P>
	<PRE>lmp_windows.exe
	</PRE>
	<P>Skip to the <A HREF = "#start_6">Running LAMMPS</A> sections for info on how to
	launch these executables on a Windows box.
	</P>
	<P>The Windows executables for serial or parallel only include certain
	packages and bug-fixes/upgrades listed on <A HREF = "http://lammps.sandia.gov/bug.html">this
	page</A> up to a certain date, as
	stated on the download page. If you want something with more packages
	or that is more current, you'll have to download the source tarball
	and build it yourself from source code using Microsoft Visual Studio,
	as described in the next section.
	</P>
	<HR>

	<H4><A NAME = "start_2"></A>2.2 Making LAMMPS
	</H4>
	<P>This section has the following sub-sections:
	</P>
	<UL><LI><A HREF = "#start_2_1">Read this first</A>
	<LI><A HREF = "#start_2_2">Steps to build a LAMMPS executable</A>
	<LI><A HREF = "#start_2_3">Common errors that can occur when making LAMMPS</A>
	<LI><A HREF = "#start_2_4">Additional build tips</A>
	<LI><A HREF = "#start_2_5">Building for a Mac</A>
	<LI><A HREF = "#start_2_6">Building for Windows</A>
	</UL>
	<HR>

	<A NAME = "start_2_1"></A><B><I>Read this first:</I></B>

	<P>Building LAMMPS can be non-trivial. You may need to edit a makefile,
	there are compiler options to consider, additional libraries can be
	used (MPI, FFT, JPEG), LAMMPS packages may be included or excluded,
	some of these packages use auxiliary libraries which need to be
	pre-built, etc.
	</P>
	<P>Please read this section carefully. If you are not comfortable with
	makefiles, or building codes on a Unix platform, or running an MPI job
	on your machine, please find a local expert to help you. Many
	compiling, linking, and run problems that users have are often not
	LAMMPS issues - they are peculiar to the user's system, compilers,
	libraries, etc. Such questions are better answered by a local expert.
	</P>
	<P>If you have a build problem that you are convinced is a LAMMPS issue
	(e.g. the compiler complains about a line of LAMMPS source code), then
	please post a question to the <A HREF = "http://lammps.sandia.gov/mail.html">LAMMPS mail
	list</A>.
	</P>
	<P>If you succeed in building LAMMPS on a new kind of machine, for which
	there isn't a similar Makefile for in the src/MAKE directory, send it
	to the developers and we can include it in the LAMMPS distribution.
	</P>
	<HR>

	<A NAME = "start_2_2"></A><B><I>Steps to build a LAMMPS executable:</I></B>

	<P><B>Step 0</B>
	</P>
	<P>The src directory contains the C++ source and header files for LAMMPS.
	It also contains a top-level Makefile and a MAKE sub-directory with
	low-level Makefile.* files for many machines. From within the src
	directory, type "make" or "gmake". You should see a list of available
	choices. If one of those is the machine and options you want, you can
	type a command like:
	</P>
	<PRE>make linux
	or
	gmake mac
	</PRE>
	<P>Note that on a multi-processor or multi-core platform you can launch a
	parallel make, by using the "-j" switch with the make command, which
	will build LAMMPS more quickly.
	</P>
	<P>If you get no errors and an executable like lmp_linux or lmp_mac is
	produced, you're done; it's your lucky day.
	</P>
	<P>Note that by default only a few of LAMMPS optional packages are
	installed. To build LAMMPS with optional packages, see <A HREF = "#start_3">this
	section</A> below.
	</P>
	<P><B>Step 1</B>
	</P>
	<P>If Step 0 did not work, you will need to create a low-level Makefile
	for your machine, like Makefile.foo. You should make a copy of an
	existing src/MAKE/Makefile.* as a starting point. The only portions
	of the file you need to edit are the first line, the "compiler/linker
	settings" section, and the "LAMMPS-specific settings" section.
	</P>
	<P><B>Step 2</B>
	</P>
	<P>Change the first line of src/MAKE/Makefile.foo to list the word "foo"
	after the "#", and whatever other options it will set. This is the
	line you will see if you just type "make".
	</P>
	<P><B>Step 3</B>
	</P>
	<P>The "compiler/linker settings" section lists compiler and linker
	settings for your C++ compiler, including optimization flags. You can
	use g++, the open-source GNU compiler, which is available on all Unix
	systems. You can also use mpicc which will typically be available if
	MPI is installed on your system, though you should check which actual
	compiler it wraps. Vendor compilers often produce faster code. On
	boxes with Intel CPUs, we suggest using the commercial Intel icc
	compiler, which can be downloaded from <A HREF = "http://www.intel.com/software/products/noncom">Intel's compiler site</A>.
	</P>


	<P>If building a C++ code on your machine requires additional libraries,
	then you should list them as part of the LIB variable.
	</P>
	<P>The DEPFLAGS setting is what triggers the C++ compiler to create a
	dependency list for a source file. This speeds re-compilation when
	source (.cpp) or header (.h) files are edited. Some compilers do
	not support dependency file creation, or may use a different switch
	than -D. GNU g++ works with -D. If your compiler can't create
	dependency files, then you'll need to create a Makefile.foo patterned
	after Makefile.storm, which uses different rules that do not involve
	dependency files. Note that when you build LAMMPS for the first time
	on a new platform, a long list of *.d files will be printed out
	rapidly. This is not an error; it is the Makefile doing its normal
	creation of dependencies.
	</P>
	<P><B>Step 4</B>
	</P>
	<P>The "system-specific settings" section has several parts. Note that
	if you change any -D setting in this section, you should do a full
	re-compile, after typing "make clean" (which will describe different
	clean options).
	</P>
	<P>The LMP_INC variable is used to include options that turn on ifdefs
	within the LAMMPS code. The options that are currently recogized are:
	</P>
	<UL><LI>-DLAMMPS_GZIP
	<LI>-DLAMMPS_JPEG
	<LI>-DLAMMPS_MEMALIGN
	<LI>-DLAMMPS_XDR
	<LI>-DLAMMPS_SMALLBIG
	<LI>-DLAMMPS_BIGBIG
	<LI>-DLAMMPS_SMALLSMALL
	<LI>-DLAMMPS_LONGLONG_TO_LONG
	<LI>-DPACK_ARRAY
	<LI>-DPACK_POINTER
	<LI>-DPACK_MEMCPY
	</UL>
	<P>The read_data and dump commands will read/write gzipped files if you
	compile with -DLAMMPS_GZIP. It requires that your Unix support the
	"popen" command.
	</P>
	<P>If you use -DLAMMPS_JPEG, the <A HREF = "dump.html">dump image</A> command will be
	able to write out JPEG image files. If not, it will only be able to
	write out text-based PPM image files. For JPEG files, you must also
	link LAMMPS with a JPEG library, as described below.
	</P>
	<P>Using -DLAMMPS_MEMALIGN=<bytes> enables the use of the
	posix_memalign() call instead of malloc() when large chunks or memory
	are allocated by LAMMPS. This can help to make more efficient use of
	vector instructions of modern CPUS, since dynamically allocated memory
	has to be aligned on larger than default byte boundaries (e.g. 16
	bytes instead of 8 bytes on x86 type platforms) for optimal
	performance.
	</P>
	<P>If you use -DLAMMPS_XDR, the build will include XDR compatibility
	files for doing particle dumps in XTC format. This is only necessary
	if your platform does have its own XDR files available. See the
	Restrictions section of the <A HREF = "dump.html">dump</A> command for details.
	</P>
	<P>Use at most one of the -DLAMMPS_SMALLBIG, -DLAMMPS_BIGBIG,
	-D-DLAMMPS_SMALLSMALL settings. The default is -DLAMMPS_SMALLBIG.
	These settings refer to use of 4-byte (small) vs 8-byte (big) integers
	within LAMMPS, as specified in src/lmptype.h. The only reason to use
	the BIGBIG setting is to enable simulation of huge molecular systems
	with more than 2 billion atoms or to allow moving atoms to wrap back
	through a periodic box more than 512 times. The only reason to use
	the SMALLSMALL setting is if your machine does not support 64-bit
	integers. See the <A HREF = "#start_2_4">Additional build tips</A> section below
	for more details.
	</P>
	<P>The -DLAMMPS_LONGLONG_TO_LONG setting may be needed if your system or
	MPI version does not recognize "long long" data types. In this case a
	"long" data type is likely already 64-bits, in which case this setting
	will convert to that data type.
	</P>
	<P>Using one of the -DPACK_ARRAY, -DPACK_POINTER, and -DPACK_MEMCPY
	options can make for faster parallel FFTs (in the PPPM solver) on some
	platforms. The -DPACK_ARRAY setting is the default. See the
	<A HREF = "kspace_style.html">kspace_style</A> command for info about PPPM. See
	Step 6 below for info about building LAMMPS with an FFT library.
	</P>
	<P><B>Step 5</B>
	</P>
	<P>The 3 MPI variables are used to specify an MPI library to build LAMMPS
	with.
	</P>
	<P>If you want LAMMPS to run in parallel, you must have an MPI library
	installed on your platform. If you use an MPI-wrapped compiler, such
	as "mpicc" to build LAMMPS, you should be able to leave these 3
	variables blank; the MPI wrapper knows where to find the needed files.
	If not, and MPI is installed on your system in the usual place (under
	/usr/local), you also may not need to specify these 3 variables. On
	some large parallel machines which use "modules" for their
	compile/link environements, you may simply need to include the correct
	module in your build environment. Or the parallel machine may have a
	vendor-provided MPI which the compiler has no trouble finding.
	</P>
	<P>Failing this, with these 3 variables you can specify where the mpi.h
	file (MPI_INC) and the MPI library file (MPI_PATH) are found and the
	name of the library file (MPI_LIB).
	</P>
	<P>If you are installing MPI yourself, we recommend Argonne's MPICH2
	or OpenMPI. MPICH can be downloaded from the <A HREF = "http://www.mcs.anl.gov/research/projects/mpich2/">Argonne MPI
	site</A>. OpenMPI can
	be downloaded from the <A HREF = "http://www.open-mpi.org">OpenMPI site</A>.
	Other MPI packages should also work. If you are running on a big
	parallel platform, your system people or the vendor should have
	already installed a version of MPI, which is likely to be faster
	than a self-installed MPICH or OpenMPI, so find out how to build
	and link with it. If you use MPICH or OpenMPI, you will have to
	configure and build it for your platform. The MPI configure script
	should have compiler options to enable you to use the same compiler
	you are using for the LAMMPS build, which can avoid problems that can
	arise when linking LAMMPS to the MPI library.
	</P>
	<P>If you just want to run LAMMPS on a single processor, you can use the
	dummy MPI library provided in src/STUBS, since you don't need a true
	MPI library installed on your system. See the
	src/MAKE/Makefile.serial file for how to specify the 3 MPI variables
	in this case. You will also need to build the STUBS library for your
	platform before making LAMMPS itself. To build from the src
	directory, type "make stubs", or from the STUBS dir, type "make".
	This should create a libmpi_stubs.a file suitable for linking to
	LAMMPS. If the build fails, you will need to edit the STUBS/Makefile
	for your platform.
	</P>
	<P>The file STUBS/mpi.c provides a CPU timer function called
	MPI_Wtime() that calls gettimeofday() . If your system doesn't
	support gettimeofday() , you'll need to insert code to call another
	timer. Note that the ANSI-standard function clock() rolls over after
	an hour or so, and is therefore insufficient for timing long LAMMPS
	simulations.
	</P>
	<P><B>Step 6</B>
	</P>
	<P>The 3 FFT variables allow you to specify an FFT library which LAMMPS
	uses (for performing 1d FFTs) when running the particle-particle
	particle-mesh (PPPM) option for long-range Coulombics via the
	<A HREF = "kspace_style.html">kspace_style</A> command.
	</P>
	<P>LAMMPS supports various open-source or vendor-supplied FFT libraries
	for this purpose. If you leave these 3 variables blank, LAMMPS will
	use the open-source <A HREF = "http://kissfft.sf.net">KISS FFT library</A>, which is
	included in the LAMMPS distribution. This library is portable to all
	platforms and for typical LAMMPS simulations is almost as fast as FFTW
	or vendor optimized libraries. If you are not including the KSPACE
	package in your build, you can also leave the 3 variables blank.
	</P>
	<P>Otherwise, select which kinds of FFTs to use as part of the FFT_INC
	setting by a switch of the form -DFFT_XXX. Recommended values for XXX
	are: MKL, SCSL, FFTW2, and FFTW3. Legacy options are: INTEL, SGI,
	ACML, and T3E. For backward compatability, using -DFFT_FFTW will use
	the FFTW2 library. Using -DFFT_NONE will use the KISS library
	described above.
	</P>
	<P>You may also need to set the FFT_INC, FFT_PATH, and FFT_LIB variables,
	so the compiler and linker can find the needed FFT header and library
	files. Note that on some large parallel machines which use "modules"
	for their compile/link environements, you may simply need to include
	the correct module in your build environment. Or the parallel machine
	may have a vendor-provided FFT library which the compiler has no
	trouble finding.
	</P>
	<P>FFTW is a fast, portable library that should also work on any
	platform. You can download it from
	<A HREF = "http://www.fftw.org">www.fftw.org</A>. Both the legacy version 2.1.X and
	the newer 3.X versions are supported as -DFFT_FFTW2 or -DFFT_FFTW3.
	Building FFTW for your box should be as simple as ./configure; make.
	Note that on some platforms FFTW2 has been pre-installed, and uses
	renamed files indicating the precision it was compiled with,
	e.g. sfftw.h, or dfftw.h instead of fftw.h. In this case, you can
	specify an additional define variable for FFT_INC called -DFFTW_SIZE,
	which will select the correct include file. In this case, for FFT_LIB
	you must also manually specify the correct library, namely -lsfftw or
	-ldfftw.
	</P>
	<P>The FFT_INC variable also allows for a -DFFT_SINGLE setting that will
	use single-precision FFTs with PPPM, which can speed-up long-range
	calulations, particularly in parallel or on GPUs. Fourier transform
	and related PPPM operations are somewhat insensitive to floating point
	truncation errors and thus do not always need to be performed in
	double precision. Using the -DFFT_SINGLE setting trades off a little
	accuracy for reduced memory use and parallel communication costs for
	transposing 3d FFT data. Note that single precision FFTs have only
	been tested with the FFTW3, FFTW2, MKL, and KISS FFT options.
	</P>
	<P><B>Step 7</B>
	</P>
	<P>The 3 JPG variables allow you to specify a JPEG library which LAMMPS
	uses when writing out JPEG files via the <A HREF = "dump_image.html">dump image</A>
	command. These can be left blank if you do not use the -DLAMMPS_JPEG
	switch discussed above in Step 4, since in that case JPEG output will
	be disabled.
	</P>
	<P>A standard JPEG library usually goes by the name libjpeg.a and has an
	associated header file jpeglib.h. Whichever JPEG library you have on
	your platform, you'll need to set the appropriate JPG_INC, JPG_PATH,
	and JPG_LIB variables, so that the compiler and linker can find it.
	</P>
	<P>As before, if these header and library files are in the usual place on
	your machine, you may not need to set these variables.
	</P>
	<P><B>Step 8</B>
	</P>
	<P>Note that by default only a few of LAMMPS optional packages are
	installed. To build LAMMPS with optional packages, see <A HREF = "#start_3">this
	section</A> below, before proceeding to Step 9.
	</P>
	<P><B>Step 9</B>
	</P>
	<P>That's it. Once you have a correct Makefile.foo, you have installed
	the optional LAMMPS packages you want to include in your build, and
	you have pre-built any other needed libraries (e.g. MPI, FFT, package
	libraries), all you need to do from the src directory is type
	something like this:
	</P>
	<PRE>make foo
	or
	gmake foo
	</PRE>
	<P>You should get the executable lmp_foo when the build is complete.
	</P>
	<HR>

	<A NAME = "start_2_3"></A><B><I>Errors that can occur when making LAMMPS:</I></B>

	<P>IMPORTANT NOTE: If an error occurs when building LAMMPS, the compiler
	or linker will state very explicitly what the problem is. The error
	message should give you a hint as to which of the steps above has
	failed, and what you need to do in order to fix it. Building a code
	with a Makefile is a very logical process. The compiler and linker
	need to find the appropriate files and those files need to be
	compatible with LAMMPS source files. When a make fails, there is
	usually a very simple reason, which you or a local expert will need to
	fix.
	</P>
	<P>Here are two non-obvious errors that can occur:
	</P>
	<P>(1) If the make command breaks immediately with errors that indicate
	it can't find files with a "*" in their names, this can be because
	your machine's native make doesn't support wildcard expansion in a
	makefile. Try gmake instead of make. If that doesn't work, try using
	a -f switch with your make command to use a pre-generated
	Makefile.list which explicitly lists all the needed files, e.g.
	</P>
	<PRE>make makelist
	make -f Makefile.list linux
	gmake -f Makefile.list mac
	</PRE>
	<P>The first "make" command will create a current Makefile.list with all
	the file names in your src dir. The 2nd "make" command (make or
	gmake) will use it to build LAMMPS. Note that you should
	include/exclude any desired optional packages before using the "make
	makelist" command.
	</P>
	<P>(2) If you get an error that says something like 'identifier "atoll"
	is undefined', then your machine does not support "long long"
	integers. Try using the -DLAMMPS_LONGLONG_TO_LONG setting described
	above in Step 4.
	</P>
	<HR>

	<A NAME = "start_2_4"></A><B><I>Additional build tips:</I></B>

	<P>(1) Building LAMMPS for multiple platforms.
	</P>
	<P>You can make LAMMPS for multiple platforms from the same src
	directory. Each target creates its own object sub-directory called
	Obj_target where it stores the system-specific *.o files.
	</P>
	<P>(2) Cleaning up.
	</P>
	<P>Typing "make clean-all" or "make clean-machine" will delete *.o object
	files created when LAMMPS is built, for either all builds or for a
	particular machine.
	</P>
	<P>(3) Changing the LAMMPS size limits via -DLAMMPS_SMALLBIG or
	-DLAMMPS_BIBIG or -DLAMMPS_SMALLSMALL
	</P>
	<P>As explained above, any of these 3 settings can be specified on the
	LMP_INC line in your low-level src/MAKE/Makefile.foo.
	</P>
	<P>The default is -DLAMMPS_SMALLBIG which allows for systems with up to
	2^63 atoms and timesteps (about 9 billion billion). The atom limit is
	for atomic systems that do not require atom IDs. For molecular
	models, which require atom IDs, the limit is 2^31 atoms (about 2
	billion). With this setting, image flags are stored in 32-bit
	integers, which means for 3 dimensions that atoms can only wrap around
	a periodic box at most 512 times. If atoms move through the periodic
	box more than this limit, the image flags will "roll over", e.g. from
	511 to -512, which can cause diagnostics like the mean-squared
	displacement, as calculated by the <A HREF = "compute_msd.html">compute msd</A>
	command, to be faulty.
	</P>
	<P>To allow for larger molecular systems or larger image flags, compile
	with -DLAMMPS_BIGBIG. This enables molecular systems with up to 2^63
	atoms (about 9 billion billion). And image flags will not "roll over"
	until they reach 2^20 = 1048576.
	</P>
	<P>IMPORTANT NOTE: As of 6/2012, the BIGBIG setting does not yet enable
	molecular systems to grow as large as 2^63. Only the image flag roll
	over is currently affected by this compile option.
	</P>
	<P>If your system does not support 8-byte integers, you will need to
	compile with the -DLAMMPS_SMALLSMALL setting. This will restrict your
	total number of atoms (for atomic or molecular models) and timesteps
	to 2^31 (about 2 billion). Image flags will roll over at 2^9 = 512.
	</P>
	<P>Note that in src/lmptype.h there are also settings for the MPI data
	types associated with the integers that store atom IDs and total
	system sizes. These need to be consistent with the associated C data
	types, or else LAMMPS will generate a run-time error.
	</P>
	<P>In all cases, the size of problem that can be run on a per-processor
	basis is limited by 4-byte integer storage to 2^31 atoms per processor
	(about 2 billion). This should not normally be a restriction since
	such a problem would have a huge per-processor memory footprint due to
	neighbor lists and would run very slowly in terms of CPU
	secs/timestep.
	</P>
	<HR>

	<A NAME = "start_2_5"></A><B><I>Building for a Mac:</I></B>

	<P>OS X is BSD Unix, so it should just work. See the
	src/MAKE/Makefile.mac file.
	</P>
	<HR>

	<A NAME = "start_2_6"></A><B><I>Building for Windows:</I></B>

	<P>The LAMMPS download page has an option to download both a serial and
	parallel pre-built Windows exeutable. See the <A HREF = "#start_6">Running
	LAMMPS</A> section for instructions for running these
	executables on a Windows box.
	</P>
	<P>The pre-built executables are built with a subset of the available
	pacakges; see the download page for the list. If you want
	a Windows version with specific packages included and excluded,
	you can build it yourself.
	</P>
	<P>One way to do this is install and use cygwin to build LAMMPS with a
	standard Linus make, just as you would on any Linux box; see
	src/MAKE/Makefile.cygwin.
	</P>
	<P>The other way to do this is using Visual Studio and project files.
	See the src/WINDOWS directory and its README.txt file for instructions
	on both a basic build and a customized build with pacakges you select.
	</P>
	<HR>

	<H4><A NAME = "start_3"></A>2.3 Making LAMMPS with optional packages
	</H4>
	<P>This section has the following sub-sections:
	</P>
	<UL><LI><A HREF = "#start_3_1">Package basics</A>
	<LI><A HREF = "#start_3_2">Including/excluding packages</A>
	<LI><A HREF = "#start_3_3">Packages that require extra libraries</A>
	<LI><A HREF = "#start_3_4">Additional Makefile settings for extra libraries</A>
	</UL>
	<HR>

	<A NAME = "start_3_1"></A><B><I>Package basics:</I></B>

	<P>The source code for LAMMPS is structured as a set of core files which
	are always included, plus optional packages. Packages are groups of
	files that enable a specific set of features. For example, force
	fields for molecular systems or granular systems are in packages. You
	can see the list of all packages by typing "make package" from within
	the src directory of the LAMMPS distribution.
	</P>
	<P>If you use a command in a LAMMPS input script that is specific to a
	particular package, you must have built LAMMPS with that package, else
	you will get an error that the style is invalid or the command is
	unknown. Every command's doc page specfies if it is part of a
	package. You can also type
	</P>
	<PRE>lmp_machine -h
	</PRE>
	<P>to run your executable with the optional <A HREF = "#start_7">-h command-line
	switch</A> for "help", which will list the styles and commands
	known to your executable.
	</P>
	<P>There are two kinds of packages in LAMMPS, standard and user packages.
	More information about the contents of standard and user packages is
	given in <A HREF = "Section_packages.html">Section_packages</A> of the manual. The
	difference between standard and user packages is as follows:
	</P>
	<P>Standard packages are supported by the LAMMPS developers and are
	written in a syntax and style consistent with the rest of LAMMPS.
	This means we will answer questions about them, debug and fix them if
	necessary, and keep them compatible with future changes to LAMMPS.
	</P>
	<P>User packages have been contributed by users, and always begin with
	the user prefix. If they are a single command (single file), they are
	typically in the user-misc package. Otherwise, they are a a set of
	files grouped together which add a specific functionality to the code.
	</P>
	<P>User packages don't necessarily meet the requirements of the standard
	packages. If you have problems using a feature provided in a user
	package, you will likely need to contact the contributor directly to
	get help. Information on how to submit additions you make to LAMMPS
	as a user-contributed package is given in <A HREF = "Section_modify.html#mod_15">this
	section</A> of the documentation.
	</P>
	<P>Some packages (both standard and user) require additional libraries.
	See more details below.
	</P>
	<HR>

	<A NAME = "start_3_2"></A><B><I>Including/excluding packages:</I></B>

	<P>To use or not use a package you must include or exclude it before
	building LAMMPS. From the src directory, this is typically as simple
	as:
	</P>
	<PRE>make yes-colloid
	make g++
	</PRE>
	<P>or
	</P>
	<PRE>make no-manybody
	make g++
	</PRE>
	<P>Some packages have individual files that depend on other packages
	being included. LAMMPS checks for this and does the right thing.
	I.e. individual files are only included if their dependencies are
	already included. Likewise, if a package is excluded, other files
	dependent on that package are also excluded.
	</P>
	<P>The reason to exclude packages is if you will never run certain kinds
	of simulations. For some packages, this will keep you from having to
	build auxiliary libraries (see below), and will also produce a smaller
	executable which may run a bit faster.
	</P>
	<P>When you download a LAMMPS tarball, these packages are pre-installed
	in the src directory: KSPACE, MANYBODY,MOLECULE. When you download
	LAMMPS source files from the SVN or Git repositories, no packages are
	pre-installed.
	</P>
	<P>Packages are included or excluded by typing "make yes-name" or "make
	no-name", where "name" is the name of the package in lower-case, e.g.
	name = kspace for the KSPACE package or name = user-atc for the
	USER-ATC package. You can also type "make yes-standard", "make
	no-standard", "make yes-user", "make no-user", "make yes-all" or "make
	no-all" to include/exclude various sets of packages. Type "make
	package" to see the all of the package-related make options.
	</P>
	<P>IMPORTANT NOTE: Inclusion/exclusion of a package works by simply
	moving files back and forth between the main src directory and
	sub-directories with the package name (e.g. src/KSPACE, src/USER-ATC),
	so that the files are seen or not seen when LAMMPS is built. After
	you have included or excluded a package, you must re-build LAMMPS.
	</P>
	<P>Additional package-related make options exist to help manage LAMMPS
	files that exist in both the src directory and in package
	sub-directories. You do not normally need to use these commands
	unless you are editing LAMMPS files or have downloaded a patch from
	the LAMMPS WWW site.
	</P>
	<P>Typing "make package-update" will overwrite src files with files from
	the package sub-directories if the package has been included. It
	should be used after a patch is installed, since patches only update
	the files in the package sub-directory, but not the src files. Typing
	"make package-overwrite" will overwrite files in the package
	sub-directories with src files.
	</P>
	<P>Typing "make package-status" will show which packages are currently
	included. Of those that are included, it will list files that are
	different in the src directory and package sub-directory. Typing
	"make package-diff" lists all differences between these files. Again,
	type "make package" to see all of the package-related make options.
	</P>
	<HR>

	<A NAME = "start_3_3"></A><B><I>Packages that require extra libraries:</I></B>

	<P>A few of the standard and user packages require additional auxiliary
	libraries. They must be compiled first, before LAMMPS is built. If
	you get a LAMMPS build error about a missing library, this is likely
	the reason. See the <A HREF = "Section_packages.html">Section_packages</A> doc page
	for a list of packages that have auxiliary libraries.
	</P>
	<P>Code for some of these auxiliary libraries is included in the LAMMPS
	distribution under the lib directory. Examples are the USER-ATC and
	MEAM packages. Some auxiliary libraries are not included with LAMMPS;
	to use the associated package you must download and install the
	auxiliary library yourself. Examples are the KIM and VORONOI and
	USER-MOLFILE packages.
	</P>
	<P>For libraries with provided source code, each lib directory has a
	README file (e.g. lib/reax/README) with instructions on how to build
	that library. Typically this is done by typing something like:
	</P>
	<PRE>make -f Makefile.g++
	</PRE>
	<P>If one of the provided Makefiles is not
	appropriate for your system you will need to edit or add one.
	Note that all the Makefiles have a setting for EXTRAMAKE at
	the top that names a Makefile.lammps.* file.
	</P>
	<P>If successful, this will produce 2 files in the lib directory:
	</P>
	<PRE>libpackage.a
	Makefile.lammps
	</PRE>
	<P>The Makefile.lammps file is a copy of the EXTRAMAKE file specified
	in the Makefile you used.
	</P>
	<P>You MUST insure that the settings in Makefile.lammps are appropriate
	for your system. If they are not, the LAMMPS build will fail.
	</P>
	<P>As explained in the lib/package/README files, they are used to specify
	additional system libraries and their locations so that LAMMPS can
	build with the auxiliary library. For example, if the MEAM or REAX
	packages are used, the auxiliary libraries consist of F90 code, build
	with a F90 complier. To link that library with LAMMPS (a C++ code)
	via whatever C++ compiler LAMMPS is built with, typically requires
	additional Fortran-to-C libraries be included in the link. Another
	example are the BLAS and LAPACK libraries needed to use the USER-ATC
	or USER-AWPMD packages.
	</P>
	<P>For libraries without provided source code, see the
	src/package/Makefile.lammps file for information on where to find the
	library and how to build it. E.g. the file src/KIM/Makefile.lammps.
	This file serves the same purpose as the lib/package/Makefile.lammps
	file described above. It has settings needed when LAMMPS is built to
	link with the auxiliary library. Again, you MUST insure that the
	settings in src/package/Makefile.lammps are appropriate for your
	system and where you installed the auxiliary library. If they are
	not, the LAMMPS build will fail.
	</P>
	<HR>

	<H4><A NAME = "start_4"></A>2.4 Building LAMMPS via the Make.py script
	</H4>
	<P>The src directory includes a Make.py script, written
	in Python, which can be used to automate various steps
	of the build process.
	</P>
	<P>You can run the script from the src directory by typing either:
	</P>
	<PRE>Make.py
	python Make.py
	</PRE>
	<P>which will give you info about the tool. For the former to work, you
	may need to edit the 1st line of the script to point to your local
	Python. And you may need to insure the script is executable:
	</P>
	<PRE>chmod +x Make.py
	</PRE>
	<P>The following options are supported as switches:
	</P>
	<UL><LI>-i file1 file2 ...
	<LI>-p package1 package2 ...
	<LI>-u package1 package2 ...
	<LI>-e package1 arg1 arg2 package2 ...
	<LI>-o dir
	<LI>-b machine
	<LI>-s suffix1 suffix2 ...
	<LI>-l dir
	<LI>-j N
	<LI>-h switch1 switch2 ...
	</UL>
	<P>Help on any switch can be listed by using -h, e.g.
	</P>
	<PRE>Make.py -h -i -p
	</PRE>
	<P>At a hi-level, these are the kinds of package management
	and build tasks that can be performed easily, using
	the Make.py tool:
	</P>
	<UL><LI>install/uninstall packages and build the associated external libs (use -p and -u and -e)
	<LI>install packages needed for one or more input scripts (use -i and -p)
	<LI>build LAMMPS, either in the src dir or new dir (use -b)
	<LI>create a new dir with only the source code needed for one or more input scripts (use -i and -o)
	</UL>
	<P>The last bullet can be useful when you wish to build a stripped-down
	version of LAMMPS to run a specific script(s). Or when you wish to
	move the minimal amount of files to another platform for a remote
	LAMMPS build.
	</P>
	<P>Note that using Make.py is not a substitute for insuring you have a
	valid src/MAKE/Makefile.foo for your system, or that external library
	Makefiles in any lib/* directories you use are also valid for your
	system. But once you have done that, you can use Make.py to quickly
	include/exclude the packages and external libraries needed by your
	input scripts.
	</P>
	<HR>

	<H4><A NAME = "start_5"></A>2.5 Building LAMMPS as a library
	</H4>
	<P>LAMMPS can be built as either a static or shared library, which can
	then be called from another application or a scripting language. See
	<A HREF = "Section_howto.html#howto_10">this section</A> for more info on coupling
	LAMMPS to other codes. See <A HREF = "Section_python.html">this section</A> for
	more info on wrapping and running LAMMPS from Python.
	</P>
	<H5><B>Static library:</B>
	</H5>
	<P>To build LAMMPS as a static library (*.a file on Linux), type
	</P>
	<PRE>make makelib
	make -f Makefile.lib foo
	</PRE>
	<P>where foo is the machine name. This kind of library is typically used
	to statically link a driver application to LAMMPS, so that you can
	insure all dependencies are satisfied at compile time. Note that
	inclusion or exclusion of any desired optional packages should be done
	before typing "make makelib". The first "make" command will create a
	current Makefile.lib with all the file names in your src dir. The
	second "make" command will use it to build LAMMPS as a static library,
	using the ARCHIVE and ARFLAGS settings in src/MAKE/Makefile.foo. The
	build will create the file liblammps_foo.a which another application can
	link to.
	</P>
	<H5><B>Shared library:</B>
	</H5>
	<P>To build LAMMPS as a shared library (*.so file on Linux), which can be
	dynamically loaded, e.g. from Python, type
	</P>
	<PRE>make makeshlib
	make -f Makefile.shlib foo
	</PRE>
	<P>where foo is the machine name. This kind of library is required when
	wrapping LAMMPS with Python; see <A HREF = "Section_python.html">Section_python</A>
	for details. Again, note that inclusion or exclusion of any desired
	optional packages should be done before typing "make makelib". The
	first "make" command will create a current Makefile.shlib with all the
	file names in your src dir. The second "make" command will use it to
	build LAMMPS as a shared library, using the SHFLAGS and SHLIBFLAGS
	settings in src/MAKE/Makefile.foo. The build will create the file
	liblammps_foo.so which another application can link to dyamically. It
	will also create a soft link liblammps.so, which the Python wrapper uses
	by default.
	</P>
	<P>Note that for a shared library to be usable by a calling program, all
	the auxiliary libraries it depends on must also exist as shared
	libraries. This will be the case for libraries included with LAMMPS,
	such as the dummy MPI library in src/STUBS or any package libraries in
	lib/packges, since they are always built as shared libraries with the
	-fPIC switch. However, if a library like MPI or FFTW does not exist
	as a shared library, the second make command will generate an error.
	This means you will need to install a shared library version of the
	package. The build instructions for the library should tell you how
	to do this.
	</P>
	<P>As an example, here is how to build and install the <A HREF = "http://www-unix.mcs.anl.gov/mpi">MPICH
	library</A>, a popular open-source version of MPI, distributed by
	Argonne National Labs, as a shared library in the default
	/usr/local/lib location:
	</P>


	<PRE>./configure --enable-shared
	make
	make install
	</PRE>
	<P>You may need to use "sudo make install" in place of the last line if
	you do not have write privileges for /usr/local/lib. The end result
	should be the file /usr/local/lib/libmpich.so.
	</P>
	<H5><B>Additional requirement for using a shared library:</B>
	</H5>
	<P>The operating system finds shared libraries to load at run-time using
	the environment variable LD_LIBRARY_PATH. So you may wish to copy the
	file src/liblammps.so or src/liblammps_g++.so (for example) to a place
	the system can find it by default, such as /usr/local/lib, or you may
	wish to add the LAMMPS src directory to LD_LIBRARY_PATH, so that the
	current version of the shared library is always available to programs
	that use it.
	</P>
	<P>For the csh or tcsh shells, you would add something like this to your
	~/.cshrc file:
	</P>
	<PRE>setenv LD_LIBRARY_PATH $<I>LD_LIBRARY_PATH</I>:/home/sjplimp/lammps/src
	</PRE>
	<H5><B>Calling the LAMMPS library:</B>
	</H5>
	<P>Either flavor of library (static or shared0 allows one or more LAMMPS
	objects to be instantiated from the calling program.
	</P>
	<P>When used from a C++ program, all of LAMMPS is wrapped in a LAMMPS_NS
	namespace; you can safely use any of its classes and methods from
	within the calling code, as needed.
	</P>
	<P>When used from a C or Fortran program or a scripting language like
	Python, the library has a simple function-style interface, provided in
	src/library.cpp and src/library.h.
	</P>
	<P>See the sample codes in examples/COUPLE/simple for examples of C++ and
	C and Fortran codes that invoke LAMMPS thru its library interface.
	There are other examples as well in the COUPLE directory which are
	discussed in <A HREF = "Section_howto.html#howto_10">Section_howto 10</A> of the
	manual. See <A HREF = "Section_python.html">Section_python</A> of the manual for a
	description of the Python wrapper provided with LAMMPS that operates
	through the LAMMPS library interface.
	</P>
	<P>The files src/library.cpp and library.h define the C-style API for
	using LAMMPS as a library. See <A HREF = "Section_howto.html#howto_19">Section_howto
	19</A> of the manual for a description of the
	interface and how to extend it for your needs.
	</P>
	<HR>

	<H4><A NAME = "start_6"></A>2.6 Running LAMMPS
	</H4>
	<P>By default, LAMMPS runs by reading commands from stdin; e.g. lmp_linux
	< in.file. This means you first create an input script (e.g. in.file)
	containing the desired commands. <A HREF = "Section_commands.html">This section</A>
	describes how input scripts are structured and what commands they
	contain.
	</P>
	<P>You can test LAMMPS on any of the sample inputs provided in the
	examples or bench directory. Input scripts are named in.* and sample
	outputs are named log.*.name.P where name is a machine and P is the
	number of processors it was run on.
	</P>
	<P>Here is how you might run a standard Lennard-Jones benchmark on a
	Linux box, using mpirun to launch a parallel job:
	</P>
	<PRE>cd src
	make linux
	cp lmp_linux ../bench
	cd ../bench
	mpirun -np 4 lmp_linux < in.lj
	</PRE>
	<P>See <A HREF = "http://lammps.sandia.gov/bench.html">this page</A> for timings for this and the other benchmarks
	on various platforms.
	</P>


	<HR>

	<P>On a Windows box, you can skip making LAMMPS and simply download an
	executable, as described above, though the pre-packaged executables
	include only certain packages.
	</P>
	<P>To run a LAMMPS executable on a Windows machine, first decide whether
	you want to download the non-MPI (serial) or the MPI (parallel)
	version of the executable. Download and save the version you have
	chosen.
	</P>
	<P>For the non-MPI version, follow these steps:
	</P>
	<UL><LI>Get a command prompt by going to Start->Run... ,
	then typing "cmd".

	<LI>Move to the directory where you have saved lmp_win_no-mpi.exe
	(e.g. by typing: cd "Documents").

	<LI>At the command prompt, type "lmp_win_no-mpi -in in.lj", replacing in.lj
	with the name of your LAMMPS input script.
	</UL>
	<P>For the MPI version, which allows you to run LAMMPS under Windows on
	multiple processors, follow these steps:
	</P>
	<UL><LI>Download and install
	<A HREF = "http://www.mcs.anl.gov/research/projects/mpich2/downloads/index.php?s=downloads">MPICH2</A>
	for Windows.

	<LI>You'll need to use the mpiexec.exe and smpd.exe files from the MPICH2 package. Put them in
	same directory (or path) as the LAMMPS Windows executable.

	<LI>Get a command prompt by going to Start->Run... ,
	then typing "cmd".

	<LI>Move to the directory where you have saved lmp_win_mpi.exe
	(e.g. by typing: cd "Documents").

	<LI>Then type something like this: "mpiexec -np 4 -localonly lmp_win_mpi -in in.lj",
	replacing in.lj with the name of your LAMMPS input script.

	<LI>Note that you may need to provide smpd with a passphrase --- it doesn't matter what you
	type.

	<LI>In this mode, output may not immediately show up on the screen, so
	if your input script takes a long time to execute, you may need to be
	patient before the output shows up.

	<LI>Alternatively, you can still use this executable to run on a single processor by
	typing something like: "lmp_win_mpi -in in.lj".
	</UL>
	<HR>

	<P>The screen output from LAMMPS is described in the next section. As it
	runs, LAMMPS also writes a log.lammps file with the same information.
	</P>
	<P>Note that this sequence of commands copies the LAMMPS executable
	(lmp_linux) to the directory with the input files. This may not be
	necessary, but some versions of MPI reset the working directory to
	where the executable is, rather than leave it as the directory where
	you launch mpirun from (if you launch lmp_linux on its own and not
	under mpirun). If that happens, LAMMPS will look for additional input
	files and write its output files to the executable directory, rather
	than your working directory, which is probably not what you want.
	</P>
	<P>If LAMMPS encounters errors in the input script or while running a
	simulation it will print an ERROR message and stop or a WARNING
	message and continue. See <A HREF = "Section_errors.html">Section_errors</A> for a
	discussion of the various kinds of errors LAMMPS can or can't detect,
	a list of all ERROR and WARNING messages, and what to do about them.
	</P>
	<P>LAMMPS can run a problem on any number of processors, including a
	single processor. In theory you should get identical answers on any
	number of processors and on any machine. In practice, numerical
	round-off can cause slight differences and eventual divergence of
	molecular dynamics phase space trajectories.
	</P>
	<P>LAMMPS can run as large a problem as will fit in the physical memory
	of one or more processors. If you run out of memory, you must run on
	more processors or setup a smaller problem.
	</P>
	<HR>

	<H4><A NAME = "start_7"></A>2.7 Command-line options
	</H4>
	<P>At run time, LAMMPS recognizes several optional command-line switches
	which may be used in any order. Either the full word or a one-or-two
	letter abbreviation can be used:
	</P>
	<UL><LI>-c or -cuda
	<LI>-e or -echo
	<LI>-i or -in
	<LI>-h or -help
	<LI>-l or -log
	<LI>-p or -partition
	<LI>-pl or -plog
	<LI>-ps or -pscreen
	<LI>-r or -reorder
	<LI>-sc or -screen
	<LI>-sf or -suffix
	<LI>-v or -var
	</UL>
	<P>For example, lmp_ibm might be launched as follows:
	</P>
	<PRE>mpirun -np 16 lmp_ibm -v f tmp.out -l my.log -sc none < in.alloy
	mpirun -np 16 lmp_ibm -var f tmp.out -log my.log -screen none < in.alloy
	</PRE>
	<P>Here are the details on the options:
	</P>
	<PRE>-cuda on/off
	</PRE>
	<P>Explicitly enable or disable CUDA support, as provided by the
	USER-CUDA package. If LAMMPS is built with this package, as described
	above in <A HREF = "#start_3">Section 2.3</A>, then by default LAMMPS will run in
	CUDA mode. If this switch is set to "off", then it will not, even if
	it was built with the USER-CUDA package, which means you can run
	standard LAMMPS or with the GPU package for testing or benchmarking
	purposes. The only reason to set the switch to "on", is to check if
	LAMMPS was built with the USER-CUDA package, since an error will be
	generated if it was not.
	</P>
	<PRE>-echo style
	</PRE>
	<P>Set the style of command echoing. The style can be <I>none</I> or <I>screen</I>
	or <I>log</I> or <I>both</I>. Depending on the style, each command read from
	the input script will be echoed to the screen and/or logfile. This
	can be useful to figure out which line of your script is causing an
	input error. The default value is <I>log</I>. The echo style can also be
	set by using the <A HREF = "echo.html">echo</A> command in the input script itself.
	</P>
	<PRE>-in file
	</PRE>
	<P>Specify a file to use as an input script. This is an optional switch
	when running LAMMPS in one-partition mode. If it is not specified,
	LAMMPS reads its input script from stdin - e.g. lmp_linux < in.run.
	This is a required switch when running LAMMPS in multi-partition mode,
	since multiple processors cannot all read from stdin.
	</P>
	<PRE>-help
	</PRE>
	<P>Print a list of options compiled into this executable for each LAMMPS
	style (atom_style, fix, compute, pair_style, bond_style, etc). This
	can help you know if the command you want to use was included via the
	appropriate package. LAMMPS will print the info and immediately exit
	if this switch is used.
	</P>
	<PRE>-log file
	</PRE>
	<P>Specify a log file for LAMMPS to write status information to. In
	one-partition mode, if the switch is not used, LAMMPS writes to the
	file log.lammps. If this switch is used, LAMMPS writes to the
	specified file. In multi-partition mode, if the switch is not used, a
	log.lammps file is created with hi-level status information. Each
	partition also writes to a log.lammps.N file where N is the partition
	ID. If the switch is specified in multi-partition mode, the hi-level
	logfile is named "file" and each partition also logs information to a
	file.N. For both one-partition and multi-partition mode, if the
	specified file is "none", then no log files are created. Using a
	<A HREF = "log.html">log</A> command in the input script will override this setting.
	Option -plog will override the name of the partition log files file.N.
	</P>
	<PRE>-partition 8x2 4 5 ...
	</PRE>
	<P>Invoke LAMMPS in multi-partition mode. When LAMMPS is run on P
	processors and this switch is not used, LAMMPS runs in one partition,
	i.e. all P processors run a single simulation. If this switch is
	used, the P processors are split into separate partitions and each
	partition runs its own simulation. The arguments to the switch
	specify the number of processors in each partition. Arguments of the
	form MxN mean M partitions, each with N processors. Arguments of the
	form N mean a single partition with N processors. The sum of
	processors in all partitions must equal P. Thus the command
	"-partition 8x2 4 5" has 10 partitions and runs on a total of 25
	processors.
	</P>
	<P>Running with multiple partitions can e useful for running
	<A HREF = "Section_howto.html#howto_5">multi-replica simulations</A>, where each
	replica runs on on one or a few processors. Note that with MPI
	installed on a machine (e.g. your desktop), you can run on more
	(virtual) processors than you have physical processors.
	</P>
	<P>To run multiple independent simulatoins from one input script, using
	multiple partitions, see <A HREF = "Section_howto.html#howto_4">Section_howto 4</A>
	of the manual. World- and universe-style <A HREF = "variable.html">variables</A>
	are useful in this context.
	</P>
	<PRE>-plog file
	</PRE>
	<P>Specify the base name for the partition log files, so partition N
	writes log information to file.N. If file is none, then no partition
	log files are created. This overrides the filename specified in the
	-log command-line option. This option is useful when working with
	large numbers of partitions, allowing the partition log files to be
	suppressed (-plog none) or placed in a sub-directory (-plog
	replica_files/log.lammps) If this option is not used the log file for
	partition N is log.lammps.N or whatever is specified by the -log
	command-line option.
	</P>
	<PRE>-pscreen file
	</PRE>
	<P>Specify the base name for the partition screen file, so partition N
	writes screen information to file.N. If file is none, then no
	partition screen files are created. This overrides the filename
	specified in the -screen command-line option. This option is useful
	when working with large numbers of partitions, allowing the partition
	screen files to be suppressed (-pscreen none) or placed in a
	sub-directory (-pscreen replica_files/screen). If this option is not
	used the screen file for partition N is screen.N or whatever is
	specified by the -screen command-line option.
	</P>
	<PRE>-reorder nth N
	-reorder custom filename
	</PRE>
	<P>Reorder the processors in the MPI communicator used to instantiate
	LAMMPS, in one of several ways. The original MPI communicator ranks
	all P processors from 0 to P-1. The mapping of these ranks to
	physical processors is done by MPI before LAMMPS begins. It may be
	useful in some cases to alter the rank order. E.g. to insure that
	cores within each node are ranked in a desired order. Or when using
	the <A HREF = "run_style.html">run_style verlet/split</A> command with 2 partitions
	to insure that a specific Kspace processor (in the 2nd partition) is
	matched up with a specific set of processors in the 1st partition.
	See the <A HREF = "Section_accelerate.html">Section_accelerate</A> doc pages for
	more details.
	</P>
	<P>If the keyword <I>nth</I> is used with a setting <I>N</I>, then it means every
	Nth processor will be moved to the end of the ranking. This is useful
	when using the <A HREF = "run_style.html">run_style verlet/split</A> command with 2
	partitions via the -partition command-line switch. The first set of
	processors will be in the first partition, the 2nd set in the 2nd
	partition. The -reorder command-line switch can alter this so that
	the 1st N procs in the 1st partition and one proc in the 2nd partition
	will be ordered consecutively, e.g. as the cores on one physical node.
	This can boost performance. For example, if you use "-reorder nth 4"
	and "-partition 9 3" and you are running on 12 processors, the
	processors will be reordered from
	</P>
	<PRE>0 1 2 3 4 5 6 7 8 9 10 11
	</PRE>
	<P>to
	</P>
	<PRE>0 1 2 4 5 6 8 9 10 3 7 11
	</PRE>
	<P>so that the processors in each partition will be
	</P>
	<PRE>0 1 2 4 5 6 8 9 10
	3 7 11
	</PRE>
	<P>See the "processors" command for how to insure processors from each
	partition could then be grouped optimally for quad-core nodes.
	</P>
	<P>If the keyword is <I>custom</I>, then a file that specifies a permutation
	of the processor ranks is also specified. The format of the reorder
	file is as follows. Any number of initial blank or comment lines
	(starting with a "#" character) can be present. These should be
	followed by P lines of the form:
	</P>
	<PRE>I J
	</PRE>
	<P>where P is the number of processors LAMMPS was launched with. Note
	that if running in multi-partition mode (see the -partition switch
	above) P is the total number of processors in all partitions. The I
	and J values describe a permutation of the P processors. Every I and
	J should be values from 0 to P-1 inclusive. In the set of P I values,
	every proc ID should appear exactly once. Ditto for the set of P J
	values. A single I,J pairing means that the physical processor with
	rank I in the original MPI communicator will have rank J in the
	reordered communicator.
	</P>
	<P>Note that rank ordering can also be specified by many MPI
	implementations, either by environment variables that specify how to
	order physical processors, or by config files that specify what
	physical processors to assign to each MPI rank. The -reorder switch
	simply gives you a portable way to do this without relying on MPI
	itself. See the <A HREF = "processors">processors out</A> command for how to output
	info on the final assignment of physical processors to the LAMMPS
	simulation domain.
	</P>
	<PRE>-screen file
	</PRE>
	<P>Specify a file for LAMMPS to write its screen information to. In
	one-partition mode, if the switch is not used, LAMMPS writes to the
	screen. If this switch is used, LAMMPS writes to the specified file
	instead and you will see no screen output. In multi-partition mode,
	if the switch is not used, hi-level status information is written to
	the screen. Each partition also writes to a screen.N file where N is
	the partition ID. If the switch is specified in multi-partition mode,
	the hi-level screen dump is named "file" and each partition also
	writes screen information to a file.N. For both one-partition and
	multi-partition mode, if the specified file is "none", then no screen
	output is performed. Option -pscreen will override the name of the
	partition screen files file.N.
	</P>
	<PRE>-suffix style
	</PRE>
	<P>Use variants of various styles if they exist. The specified style can
	be <I>opt</I>, <I>omp</I>, <I>gpu</I>, or <I>cuda</I>. These refer to optional packages that
	LAMMPS can be built with, as described above in <A HREF = "#start_3">Section
	2.3</A>. The "opt" style corrsponds to the OPT package, the
	"omp" style to the USER-OMP package, the "gpu" style to the GPU
	package, and the "cuda" style to the USER-CUDA package.
	</P>
	<P>As an example, all of the packages provide a <A HREF = "pair_lj.html">pair_style
	lj/cut</A> variant, with style names lj/cut/opt, lj/cut/omp,
	lj/cut/gpu, or lj/cut/cuda. A variant styles can be specified
	explicitly in your input script, e.g. pair_style lj/cut/gpu. If the
	-suffix switch is used, you do not need to modify your input script.
	The specified suffix (opt,omp,gpu,cuda) is automatically appended
	whenever your input script command creates a new
	<A HREF = "atom_style.html">atom</A>, <A HREF = "pair_style.html">pair</A>, <A HREF = "fix.html">fix</A>,
	<A HREF = "compute.html">compute</A>, or <A HREF = "run_style.html">run</A> style. If the variant
	version does not exist, the standard version is created.
	</P>
	<P>For the GPU package, using this command-line switch also invokes the
	default GPU settings, as if the command "package gpu force/neigh 0 0
	1" were used at the top of your input script. These settings can be
	changed by using the <A HREF = "package.html">package gpu</A> command in your script
	if desired.
	</P>
	<P>For the OMP package, using this command-line switch also invokes the
	default OMP settings, as if the command "package omp *" were used at
	the top of your input script. These settings can be changed by using
	the <A HREF = "package.html">package omp</A> command in your script if desired.
	</P>
	<P>The <A HREF = "suffix.html">suffix</A> command can also set a suffix and it can also
	turn off/on any suffix setting made via the command line.
	</P>
	<PRE>-var name value1 value2 ...
	</PRE>
	<P>Specify a variable that will be defined for substitution purposes when
	the input script is read. "Name" is the variable name which can be a
	single character (referenced as $x in the input script) or a full
	string (referenced as ${abc}). An <A HREF = "variable.html">index-style
	variable</A> will be created and populated with the
	subsequent values, e.g. a set of filenames. Using this command-line
	option is equivalent to putting the line "variable name index value1
	value2 ..." at the beginning of the input script. Defining an index
	variable as a command-line argument overrides any setting for the same
	index variable in the input script, since index variables cannot be
	re-defined. See the <A HREF = "variable.html">variable</A> command for more info on
	defining index and other kinds of variables and <A HREF = "Section_commands.html#cmd_2">this
	section</A> for more info on using variables
	in input scripts.
	</P>
	<P>NOTE: Currently, the command-line parser looks for arguments that
	start with "-" to indicate new switches. Thus you cannot specify
	multiple variable values if any of they start with a "-", e.g. a
	negative numeric value. It is OK if the first value1 starts with a
	"-", since it is automatically skipped.
	</P>
	<HR>

	<H4><A NAME = "start_8"></A>2.8 LAMMPS screen output
	</H4>
	<P>As LAMMPS reads an input script, it prints information to both the
	screen and a log file about significant actions it takes to setup a
	simulation. When the simulation is ready to begin, LAMMPS performs
	various initializations and prints the amount of memory (in MBytes per
	processor) that the simulation requires. It also prints details of
	the initial thermodynamic state of the system. During the run itself,
	thermodynamic information is printed periodically, every few
	timesteps. When the run concludes, LAMMPS prints the final
	thermodynamic state and a total run time for the simulation. It then
	appends statistics about the CPU time and storage requirements for the
	simulation. An example set of statistics is shown here:
	</P>
	<PRE>Loop time of 49.002 on 2 procs for 2004 atoms
	</PRE>
	<PRE>Pair time (%) = 35.0495 (71.5267)
	Bond time (%) = 0.092046 (0.187841)
	Kspce time (%) = 6.42073 (13.103)
	Neigh time (%) = 2.73485 (5.5811)
	Comm time (%) = 1.50291 (3.06703)
	Outpt time (%) = 0.013799 (0.0281601)
	Other time (%) = 2.13669 (4.36041)
	</PRE>
	<PRE>Nlocal: 1002 ave, 1015 max, 989 min
	Histogram: 1 0 0 0 0 0 0 0 0 1
	Nghost: 8720 ave, 8724 max, 8716 min
	Histogram: 1 0 0 0 0 0 0 0 0 1
	Neighs: 354141 ave, 361422 max, 346860 min
	Histogram: 1 0 0 0 0 0 0 0 0 1
	</PRE>
	<PRE>Total # of neighbors = 708282
	Ave neighs/atom = 353.434
	Ave special neighs/atom = 2.34032
	Number of reneighborings = 42
	Dangerous reneighborings = 2
	</PRE>
	<P>The first section gives the breakdown of the CPU run time (in seconds)
	into major categories. The second section lists the number of owned
	atoms (Nlocal), ghost atoms (Nghost), and pair-wise neighbors stored
	per processor. The max and min values give the spread of these values
	across processors with a 10-bin histogram showing the distribution.
	The total number of histogram counts is equal to the number of
	processors.
	</P>
	<P>The last section gives aggregate statistics for pair-wise neighbors
	and special neighbors that LAMMPS keeps track of (see the
	<A HREF = "special_bonds.html">special_bonds</A> command). The number of times
	neighbor lists were rebuilt during the run is given as well as the
	number of potentially "dangerous" rebuilds. If atom movement
	triggered neighbor list rebuilding (see the
	<A HREF = "neigh_modify.html">neigh_modify</A> command), then dangerous
	reneighborings are those that were triggered on the first timestep
	atom movement was checked for. If this count is non-zero you may wish
	to reduce the delay factor to insure no force interactions are missed
	by atoms moving beyond the neighbor skin distance before a rebuild
	takes place.
	</P>
	<P>If an energy minimization was performed via the
	<A HREF = "minimize.html">minimize</A> command, additional information is printed,
	e.g.
	</P>
	<PRE>Minimization stats:
	E initial, next-to-last, final = -0.895962 -2.94193 -2.94342
	Gradient 2-norm init/final= 1920.78 20.9992
	Gradient inf-norm init/final= 304.283 9.61216
	Iterations = 36
	Force evaluations = 177
	</PRE>
	<P>The first line lists the initial and final energy, as well as the
	energy on the next-to-last iteration. The next 2 lines give a measure
	of the gradient of the energy (force on all atoms). The 2-norm is the
	"length" of this force vector; the inf-norm is the largest component.
	The last 2 lines are statistics on how many iterations and
	force-evaluations the minimizer required. Multiple force evaluations
	are typically done at each iteration to perform a 1d line minimization
	in the search direction.
	</P>
	<P>If a <A HREF = "kspace_style.html">kspace_style</A> long-range Coulombics solve was
	performed during the run (PPPM, Ewald), then additional information is
	printed, e.g.
	</P>
	<PRE>FFT time (% of Kspce) = 0.200313 (8.34477)
	FFT Gflps 3d 1d-only = 2.31074 9.19989
	</PRE>
	<P>The first line gives the time spent doing 3d FFTs (4 per timestep) and
	the fraction it represents of the total KSpace time (listed above).
	Each 3d FFT requires computation (3 sets of 1d FFTs) and communication
	(transposes). The total flops performed is 5Nlog_2(N), where N is the
	number of points in the 3d grid. The FFTs are timed with and without
	the communication and a Gflop rate is computed. The 3d rate is with
	communication; the 1d rate is without (just the 1d FFTs). Thus you
	can estimate what fraction of your FFT time was spent in
	communication, roughly 75% in the example above.
	</P>
	<HR>

	<H4><A NAME = "start_9"></A>2.9 Tips for users of previous LAMMPS versions
	</H4>
	<P>The current C++ began with a complete rewrite of LAMMPS 2001, which
	was written in F90. Features of earlier versions of LAMMPS are listed
	in <A HREF = "Section_history.html">Section_history</A>. The F90 and F77 versions
	(2001 and 99) are also freely distributed as open-source codes; check
	the <A HREF = "http://lammps.sandia.gov">LAMMPS WWW Site</A> for distribution information if you prefer
	those versions. The 99 and 2001 versions are no longer under active
	development; they do not have all the features of C++ LAMMPS.
	</P>
	<P>If you are a previous user of LAMMPS 2001, these are the most
	significant changes you will notice in C++ LAMMPS:
	</P>
	<P>(1) The names and arguments of many input script commands have
	changed. All commands are now a single word (e.g. read_data instead
	of read data).
	</P>
	<P>(2) All the functionality of LAMMPS 2001 is included in C++ LAMMPS,
	but you may need to specify the relevant commands in different ways.
	</P>
	<P>(3) The format of the data file can be streamlined for some problems.
	See the <A HREF = "read_data.html">read_data</A> command for details. The data file
	section "Nonbond Coeff" has been renamed to "Pair Coeff" in C++ LAMMPS.
	</P>
	<P>(4) Binary restart files written by LAMMPS 2001 cannot be read by C++
	LAMMPS with a <A HREF = "read_restart.html">read_restart</A> command. This is
	because they were output by F90 which writes in a different binary
	format than C or C++ writes or reads. Use the <I>restart2data</I> tool
	provided with LAMMPS 2001 to convert the 2001 restart file to a text
	data file. Then edit the data file as necessary before using the C++
	LAMMPS <A HREF = "read_data.html">read_data</A> command to read it in.
	</P>
	<P>(5) There are numerous small numerical changes in C++ LAMMPS that mean
	you will not get identical answers when comparing to a 2001 run.
	However, your initial thermodynamic energy and MD trajectory should be
	close if you have setup the problem for both codes the same.
	</P>
	</HTML>

Section_start.htmlNo OneTemporaryActions

File Metadata

Section_start.htmlView Options

Event Timeline

Section_start.html
No OneTemporary
Actions

Section_start.html
View Options