<liclass="toctree-l1"><aclass="reference internal"href="Section_modify.html">10. Modifying & extending LAMMPS</a></li>
<liclass="toctree-l1 current"><aclass="current reference internal"href="#">11. Python interface to LAMMPS</a><ul>
<liclass="toctree-l2"><aclass="reference internal"href="#overview-of-running-lammps-from-python">11.1. Overview of running LAMMPS from Python</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="#overview-of-using-python-from-a-lammps-script">11.2. Overview of using Python from a LAMMPS script</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="#building-lammps-as-a-shared-library">11.3. Building LAMMPS as a shared library</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="#installing-the-python-wrapper-into-python">11.4. Installing the Python wrapper into Python</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="#extending-python-with-mpi-to-run-in-parallel">11.5. Extending Python with MPI to run in parallel</a></li>
<liclass="toctree-l2"><aclass="reference internal"href="#testing-the-python-lammps-interface">11.6. Testing the Python-LAMMPS interface</a><ul>
<liclass="toctree-l3"><aclass="reference internal"href="#test-lammps-and-python-in-serial">11.6.1. <strong>Test LAMMPS and Python in serial:</strong></a></li>
<liclass="toctree-l3"><aclass="reference internal"href="#test-lammps-and-python-in-parallel">11.6.2. <strong>Test LAMMPS and Python in parallel:</strong></a></li>
<p>LAMMPS can work together with Python in two ways. First, Python can
wrap LAMMPS through the <aclass="reference internal"href="Section_howto.html#howto-19"><spanclass="std std-ref">LAMMPS library interface</span></a>, so that a Python script can
create one or more instances of LAMMPS and launch one or more
simulations. In Python lingo, this is “extending” Python with LAMMPS.</p>
<p>Second, LAMMPS can use the Python interpreter, so that a LAMMPS input
script can invoke Python code, and pass information back-and-forth
between the input script and Python functions you write. The Python
code can also callback to LAMMPS to query or change its attributes.
In Python lingo, this is “embedding” Python in LAMMPS.</p>
<p>This section describes how to do both.</p>
<ulclass="simple">
<li>11.1 <aclass="reference internal"href="#py-1"><spanclass="std std-ref">Overview of running LAMMPS from Python</span></a></li>
<li>11.2 <aclass="reference internal"href="#py-2"><spanclass="std std-ref">Overview of using Python from a LAMMPS script</span></a></li>
<li>11.3 <aclass="reference internal"href="#py-3"><spanclass="std std-ref">Building LAMMPS as a shared library</span></a></li>
<li>11.4 <aclass="reference internal"href="#py-4"><spanclass="std std-ref">Installing the Python wrapper into Python</span></a></li>
<li>11.5 <aclass="reference internal"href="#py-5"><spanclass="std std-ref">Extending Python with MPI to run in parallel</span></a></li>
<li>11.6 <aclass="reference internal"href="#py-6"><spanclass="std std-ref">Testing the Python-LAMMPS interface</span></a></li>
<li>11.7 <aclass="reference internal"href="#py-7"><spanclass="std std-ref">Using LAMMPS from Python</span></a></li>
<li>11.8 <aclass="reference internal"href="#py-8"><spanclass="std std-ref">Example Python scripts that use LAMMPS</span></a></li>
</ul>
<p>If you are not familiar with it, <aclass="reference external"href="http://www.python.org">Python</a> is a
powerful scripting and programming language which can essentially do
anything that faster, lower-level languages like C or C++ can do, but
typically with much fewer lines of code. When used in embedded mode,
Python can perform operations that the simplistic LAMMPS input script
syntax cannot. Python can be also be used as a “glue” language to
drive a program through its library interface, or to hook multiple
pieces of software together, such as a simulation package plus a
visualization package, or to run a coupled multiscale or multiphysics
model.</p>
<p>See <aclass="reference internal"href="Section_howto.html#howto-10"><spanclass="std std-ref">Section_howto 10</span></a> of the manual and
the couple directory of the distribution for more ideas about coupling
LAMMPS to other codes. See <aclass="reference internal"href="Section_howto.html#howto-19"><spanclass="std std-ref">Section_howto 19</span></a> for a description of the LAMMPS
library interface provided in src/library.cpp and src/library.h, and
how to extend it for your needs. As described below, that interface
is what is exposed to Python either when calling LAMMPS from Python or
when calling Python from a LAMMPS input script and then calling back
to LAMMPS from Python code. The library interface is designed to be
easy to add functions to. Thus the Python interface to LAMMPS is also
easy to extend as well.</p>
<p>If you create interesting Python scripts that run LAMMPS or
interesting Python functions that can be called from a LAMMPS input
script, that you think would be useful to other users, please <aclass="reference external"href="http://lammps.sandia.gov/authors.html">email them to the developers</a>. We can
<spanid="py-2"></span><h2>11.2. Overview of using Python from a LAMMPS script</h2>
<divclass="admonition note">
<pclass="first admonition-title">Note</p>
<pclass="last">It is not currently possible to use the <aclass="reference internal"href="python.html"><spanclass="doc">python</span></a>
command described in this section with Python 3, only with Python 2.
The C API changed from Python 2 to 3 and the LAMMPS code is not
compatible with both.</p>
</div>
<p>LAMMPS has a <aclass="reference internal"href="python.html"><spanclass="doc">python</span></a> command which can be used in an
input script to define and execute a Python function that you write
the code for. The Python function can also be assigned to a LAMMPS
python-style variable via the <aclass="reference internal"href="variable.html"><spanclass="doc">variable</span></a> command. Each
time the variable is evaluated, either in the LAMMPS input script
itself, or by another LAMMPS command that uses the variable, this will
trigger the Python function to be invoked.</p>
<p>The Python code for the function can be included directly in the input
script or in an auxiliary file. The function can have arguments which
are mapped to LAMMPS variables (also defined in the input script) and
it can return a value to a LAMMPS variable. This is thus a mechanism
for your input script to pass information to a piece of Python code,
ask Python to execute the code, and return information to your input
script.</p>
<p>Note that a Python function can be arbitrarily complex. It can import
other Python modules, instantiate Python classes, call other Python
functions, etc. The Python code that you provide can contain more
code than the single function. It can contain other functions or
Python classes, as well as global variables or other mechanisms for
storing state between calls from LAMMPS to the function.</p>
<p>The Python function you provide can consist of “pure” Python code that
only performs operations provided by standard Python. However, the
Python function can also “call back” to LAMMPS through its
Python-wrapped library interface, in the manner described in the
previous section 11.1. This means it can issue LAMMPS input script
commands or query and set internal LAMMPS state. As an example, this
can be useful in an input script to create a more complex loop with
branching logic, than can be created using the simple looping and
branching logic enabled by the <aclass="reference internal"href="next.html"><spanclass="doc">next</span></a> and <aclass="reference internal"href="if.html"><spanclass="doc">if</span></a>
commands.</p>
<p>See the <aclass="reference internal"href="python.html"><spanclass="doc">python</span></a> doc page and the <aclass="reference internal"href="variable.html"><spanclass="doc">variable</span></a>
doc page for its python-style variables for more info, including
examples of Python code you can write for both pure Python operations
and callbacks to LAMMPS.</p>
<p>To run pure Python code from LAMMPS, you only need to build LAMMPS
<spanclass="nb">print</span><spanclass="s2">"Proc </span><spanclass="si">%d</span><spanclass="s2"> out of </span><spanclass="si">%d</span><spanclass="s2"> procs"</span><spanclass="o">%</span><spanclass="p">(</span><spanclass="n">pypar</span><spanclass="o">.</span><spanclass="n">rank</span><spanclass="p">(),</span><spanclass="n">pypar</span><spanclass="o">.</span><spanclass="n">size</span><spanclass="p">())</span>
</pre></div>
</div>
<p>and see one line of output for each processor you run on.</p>
<divclass="admonition note">
<pclass="first admonition-title">Note</p>
<pclass="last">To use Pypar and LAMMPS in parallel from Python, you must insure
both are using the same version of MPI. If you only have one MPI
installed on your system, this is not an issue, but it can be if you
have multiple MPIs. Your LAMMPS build is explicit about which MPI it
is using, since you specify the details in your lo-level
src/MAKE/Makefile.foo file. Pypar uses the “mpicc” command to find
information about the MPI it uses to build against. And it tries to
load “libmpi.so” from the LD_LIBRARY_PATH. This may or may not find
the MPI library that LAMMPS is using. If you have problems running
both Pypar and LAMMPS together, this is an issue you may need to
address, e.g. by moving other MPI installations so that Pypar finds
the right one.</p>
</div>
<hrclass="docutils"/>
<p>To install mpi4py (version mpi4py-2.0.0 as of Oct 2015), unpack it
<spanclass="nb">print</span><spanclass="s2">"Proc </span><spanclass="si">%d</span><spanclass="s2"> out of </span><spanclass="si">%d</span><spanclass="s2"> procs"</span><spanclass="o">%</span><spanclass="p">(</span><spanclass="n">comm</span><spanclass="o">.</span><spanclass="n">Get_rank</span><spanclass="p">(),</span><spanclass="n">comm</span><spanclass="o">.</span><spanclass="n">Get_size</span><spanclass="p">())</span>
</pre></div>
</div>
<p>and see one line of output for each processor you run on.</p>
<divclass="admonition note">
<pclass="first admonition-title">Note</p>
<pclass="last">To use mpi4py and LAMMPS in parallel from Python, you must
insure both are using the same version of MPI. If you only have one
MPI installed on your system, this is not an issue, but it can be if
you have multiple MPIs. Your LAMMPS build is explicit about which MPI
it is using, since you specify the details in your lo-level
src/MAKE/Makefile.foo file. Mpi4py uses the “mpicc” command to find
information about the MPI it uses to build against. And it tries to
load “libmpi.so” from the LD_LIBRARY_PATH. This may or may not find
the MPI library that LAMMPS is using. If you have problems running
both mpi4py and LAMMPS together, this is an issue you may need to
address, e.g. by moving other MPI installations so that mpi4py finds
<p>If an error occurs, carefully go thru the steps in <aclass="reference internal"href="Section_start.html#start-5"><spanclass="std std-ref">Section_start 5</span></a> and above about building a shared
library and about insuring Python can find the necessary two files
<spanclass="nb">print</span><spanclass="s2">"Proc </span><spanclass="si">%d</span><spanclass="s2"> out of </span><spanclass="si">%d</span><spanclass="s2"> procs has"</span><spanclass="o">%</span><spanclass="p">(</span><spanclass="n">pypar</span><spanclass="o">.</span><spanclass="n">rank</span><spanclass="p">(),</span><spanclass="n">pypar</span><spanclass="o">.</span><spanclass="n">size</span><spanclass="p">()),</span><spanclass="n">lmp</span>
<spanclass="nb">print</span><spanclass="s2">"Proc </span><spanclass="si">%d</span><spanclass="s2"> out of </span><spanclass="si">%d</span><spanclass="s2"> procs has"</span><spanclass="o">%</span><spanclass="p">(</span><spanclass="n">me</span><spanclass="p">,</span><spanclass="n">nprocs</span><spanclass="p">),</span><spanclass="n">lmp</span>
<p>These are the methods defined by the lammps module. If you look at
the files src/library.cpp and src/library.h you will see that they
correspond one-to-one with calls you can make to the LAMMPS library
from a C++ or C or Fortran program.</p>
<divclass="highlight-default"><divclass="highlight"><pre><span></span><spanclass="n">lmp</span><spanclass="o">=</span><spanclass="n">lammps</span><spanclass="p">()</span><spanclass="c1"># create a LAMMPS object using the default liblammps.so library</span>
<spanclass="n">lmp</span><spanclass="o">=</span><spanclass="n">lammps</span><spanclass="p">(</span><spanclass="n">ptr</span><spanclass="o">=</span><spanclass="n">lmpptr</span><spanclass="p">)</span><spanclass="c1"># use lmpptr as previously created LAMMPS object</span>
<spanclass="n">lmp</span><spanclass="o">=</span><spanclass="n">lammps</span><spanclass="p">(</span><spanclass="n">comm</span><spanclass="o">=</span><spanclass="n">split</span><spanclass="p">)</span><spanclass="c1"># create a LAMMPS object with a custom communicator, requires mpi4py 2.0.0 or later</span>
<spanclass="n">lmp</span><spanclass="o">=</span><spanclass="n">lammps</span><spanclass="p">(</span><spanclass="n">name</span><spanclass="o">=</span><spanclass="s2">"g++"</span><spanclass="p">)</span><spanclass="c1"># create a LAMMPS object using the liblammps_g++.so library</span>
<spanclass="n">lmp</span><spanclass="o">=</span><spanclass="n">lammps</span><spanclass="p">(</span><spanclass="n">name</span><spanclass="o">=</span><spanclass="s2">"g++"</span><spanclass="p">,</span><spanclass="n">cmdargs</span><spanclass="o">=</span><spanclass="nb">list</span><spanclass="p">)</span><spanclass="c1"># add LAMMPS command-line args, e.g. list = ["-echo","screen"]</span>
</pre></div>
</div>
<divclass="highlight-default"><divclass="highlight"><pre><span></span><spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">close</span><spanclass="p">()</span><spanclass="c1"># destroy a LAMMPS object</span>
</pre></div>
</div>
<p>version = lmp.version() # return the numerical version id, e.g. LAMMPS 2 Sep 2015 -> 20150902</p>
<divclass="highlight-default"><divclass="highlight"><pre><span></span><spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">file</span><spanclass="p">(</span><spanclass="n">file</span><spanclass="p">)</span><spanclass="c1"># run an entire input script, file = "in.lj"</span>
<spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">command</span><spanclass="p">(</span><spanclass="n">cmd</span><spanclass="p">)</span><spanclass="c1"># invoke a single LAMMPS command, cmd = "run 100"</span>
</pre></div>
</div>
<divclass="highlight-default"><divclass="highlight"><pre><span></span><spanclass="n">xlo</span><spanclass="o">=</span><spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">extract_global</span><spanclass="p">(</span><spanclass="n">name</span><spanclass="p">,</span><spanclass="nb">type</span><spanclass="p">)</span><spanclass="c1"># extract a global quantity</span>
<spanclass="c1"># name = "boxxlo", "nlocal", etc</span>
<spanclass="c1"># type = 0 = int</span>
<spanclass="c1"># 1 = double</span>
</pre></div>
</div>
<divclass="highlight-default"><divclass="highlight"><pre><span></span><spanclass="n">coords</span><spanclass="o">=</span><spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">extract_atom</span><spanclass="p">(</span><spanclass="n">name</span><spanclass="p">,</span><spanclass="nb">type</span><spanclass="p">)</span><spanclass="c1"># extract a per-atom quantity</span>
<spanclass="c1"># name = "x", "type", etc</span>
<spanclass="c1"># type = 0 = vector of ints</span>
<spanclass="c1"># 1 = array of ints</span>
<spanclass="c1"># 2 = vector of doubles</span>
<spanclass="c1"># 3 = array of doubles</span>
</pre></div>
</div>
<divclass="highlight-default"><divclass="highlight"><pre><span></span><spanclass="n">eng</span><spanclass="o">=</span><spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">extract_compute</span><spanclass="p">(</span><spanclass="nb">id</span><spanclass="p">,</span><spanclass="n">style</span><spanclass="p">,</span><spanclass="nb">type</span><spanclass="p">)</span><spanclass="c1"># extract value(s) from a compute</span>
<spanclass="n">v3</span><spanclass="o">=</span><spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">extract_fix</span><spanclass="p">(</span><spanclass="nb">id</span><spanclass="p">,</span><spanclass="n">style</span><spanclass="p">,</span><spanclass="nb">type</span><spanclass="p">,</span><spanclass="n">i</span><spanclass="p">,</span><spanclass="n">j</span><spanclass="p">)</span><spanclass="c1"># extract value(s) from a fix</span>
<spanclass="c1"># id = ID of compute or fix</span>
<spanclass="c1"># style = 0 = global data</span>
<spanclass="c1"># 1 = per-atom data</span>
<spanclass="c1"># 2 = local data</span>
<spanclass="c1"># type = 0 = scalar</span>
<spanclass="c1"># 1 = vector</span>
<spanclass="c1"># 2 = array</span>
<spanclass="c1"># i,j = indices of value in global vector or array</span>
</pre></div>
</div>
<divclass="highlight-default"><divclass="highlight"><pre><span></span><spanclass="n">var</span><spanclass="o">=</span><spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">extract_variable</span><spanclass="p">(</span><spanclass="n">name</span><spanclass="p">,</span><spanclass="n">group</span><spanclass="p">,</span><spanclass="n">flag</span><spanclass="p">)</span><spanclass="c1"># extract value(s) from a variable</span>
<spanclass="c1"># name = name of variable</span>
<spanclass="c1"># group = group ID (ignored for equal-style variables)</span>
<spanclass="c1"># flag = 0 = equal-style variable</span>
<spanclass="c1"># 1 = atom-style variable</span>
</pre></div>
</div>
<divclass="highlight-default"><divclass="highlight"><pre><span></span><spanclass="n">flag</span><spanclass="o">=</span><spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">set_variable</span><spanclass="p">(</span><spanclass="n">name</span><spanclass="p">,</span><spanclass="n">value</span><spanclass="p">)</span><spanclass="c1"># set existing named string-style variable to value, flag = 0 if successful</span>
<spanclass="n">natoms</span><spanclass="o">=</span><spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">get_natoms</span><spanclass="p">()</span><spanclass="c1"># total # of atoms as int</span>
<spanclass="n">data</span><spanclass="o">=</span><spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">gather_atoms</span><spanclass="p">(</span><spanclass="n">name</span><spanclass="p">,</span><spanclass="nb">type</span><spanclass="p">,</span><spanclass="n">count</span><spanclass="p">)</span><spanclass="c1"># return atom attribute of all atoms gathered into data, ordered by atom ID</span>
<spanclass="c1"># name = "x", "charge", "type", etc</span>
<spanclass="c1"># count = # of per-atom values, 1 or 3, etc</span>
<spanclass="n">lmp</span><spanclass="o">.</span><spanclass="n">scatter_atoms</span><spanclass="p">(</span><spanclass="n">name</span><spanclass="p">,</span><spanclass="nb">type</span><spanclass="p">,</span><spanclass="n">count</span><spanclass="p">,</span><spanclass="n">data</span><spanclass="p">)</span><spanclass="c1"># scatter atom attribute of all atoms from data, ordered by atom ID</span>
<spanclass="c1"># name = "x", "charge", "type", etc</span>
<spanclass="c1"># count = # of per-atom values, 1 or 3, etc</span>
extract_fix(), and extract_variable() methods return values or
pointers to data structures internal to LAMMPS.</p>
<p>For extract_global() see the src/library.cpp file for the list of
valid names. New names could easily be added. A double or integer is
returned. You need to specify the appropriate data type via the type
argument.</p>
<p>For extract_atom(), a pointer to internal LAMMPS atom-based data is
returned, which you can use via normal Python subscripting. See the
extract() method in the src/atom.cpp file for a list of valid names.
Again, new names could easily be added. A pointer to a vector of
doubles or integers, or a pointer to an array of doubles (double <ahref="#id3"><spanclass="problematic"id="id4">**</span></a>)
or integers (int <ahref="#id5"><spanclass="problematic"id="id6">**</span></a>) is returned. You need to specify the appropriate
data type via the type argument.</p>
<p>For extract_compute() and extract_fix(), the global, per-atom, or
local data calulated by the compute or fix can be accessed. What is
returned depends on whether the compute or fix calculates a scalar or
vector or array. For a scalar, a single double value is returned. If
the compute or fix calculates a vector or array, a pointer to the
internal LAMMPS data is returned, which you can use via normal Python
subscripting. The one exception is that for a fix that calculates a
global vector or array, a single double value from the vector or array
is returned, indexed by I (vector) or I and J (array). I,J are
zero-based indices. The I,J arguments can be left out if not needed.
See <aclass="reference internal"href="Section_howto.html#howto-15"><spanclass="std std-ref">Section_howto 15</span></a> of the manual for a
discussion of global, per-atom, and local data, and of scalar, vector,
and array data types. See the doc pages for individual
<aclass="reference internal"href="compute.html"><spanclass="doc">computes</span></a> and <aclass="reference internal"href="fix.html"><spanclass="doc">fixes</span></a> for a description of what
they calculate and store.</p>
<p>For extract_variable(), an <aclass="reference internal"href="variable.html"><spanclass="doc">equal-style or atom-style variable</span></a> is evaluated and its result returned.</p>
<p>For equal-style variables a single double value is returned and the
group argument is ignored. For atom-style variables, a vector of
doubles is returned, one value per atom, which you can use via normal
Python subscripting. The values will be zero for atoms not in the
specified group.</p>
<p>The get_natoms() method returns the total number of atoms in the
simulation, as an int.</p>
<p>The gather_atoms() method returns a ctypes vector of ints or doubles
as specified by type, of length count*natoms, for the property of all
the atoms in the simulation specified by name, ordered by count and
then by atom ID. The vector can be used via normal Python
subscripting. If atom IDs are not consecutively ordered within
LAMMPS, a None is returned as indication of an error.</p>
<p>Note that the data structure gather_atoms(“x”) returns is different
from the data structure returned by extract_atom(“x”) in four ways.
(1) Gather_atoms() returns a vector which you index as x[i];
extract_atom() returns an array which you index as x[i][j]. (2)
Gather_atoms() orders the atoms by atom ID while extract_atom() does
not. (3) Gathert_atoms() returns a list of all atoms in the
simulation; extract_atoms() returns just the atoms local to each
processor. (4) Finally, the gather_atoms() data structure is a copy
of the atom coords stored internally in LAMMPS, whereas extract_atom()
returns an array that effectively points directly to the internal
data. This means you can change values inside LAMMPS from Python by
assigning a new values to the extract_atom() array. To do this with
the gather_atoms() vector, you need to change values in the vector,
then invoke the scatter_atoms() method.</p>
<p>The scatter_atoms() method takes a vector of ints or doubles as
specified by type, of length count*natoms, for the property of all the
atoms in the simulation specified by name, ordered by bount and then
by atom ID. It uses the vector of data to overwrite the corresponding
properties for each atom inside LAMMPS. This requires LAMMPS to have
its “map” option enabled; see the <aclass="reference internal"href="atom_modify.html"><spanclass="doc">atom_modify</span></a>
command for details. If it is not, or if atom IDs are not
consecutively ordered, no coordinates are reset.</p>
<p>The array of coordinates passed to scatter_atoms() must be a ctypes
vector of ints or doubles, allocated and initialized something like
<spanid="py-8"></span><h2>11.8. Example Python scripts that use LAMMPS</h2>
<p>These are the Python scripts included as demos in the python/examples
directory of the LAMMPS distribution, to illustrate the kinds of
things that are possible when Python wraps LAMMPS. If you create your
own scripts, send them to us and we can include them in the LAMMPS
distribution.</p>
<tableborder="1"class="docutils">
<colgroup>
<colwidth="56%"/>
<colwidth="44%"/>
</colgroup>
<tbodyvalign="top">
<trclass="row-odd"><td>trivial.py</td>
<td>read/run a LAMMPS input script thru Python</td>
</tr>
<trclass="row-even"><td>demo.py</td>
<td>invoke various LAMMPS library interface routines</td>
</tr>
<trclass="row-odd"><td>simple.py</td>
<td>run in parallel</td>
</tr>
<trclass="row-even"><td>similar to examples/COUPLE/simple/simple.cpp</td>
<td>split.py</td>
</tr>
<trclass="row-odd"><td>same as simple.py but running in parallel on a subset of procs</td>
<td>gui.py</td>
</tr>
<trclass="row-even"><td>GUI go/stop/temperature-slider to control LAMMPS</td>
<td>plot.py</td>
</tr>
<trclass="row-odd"><td>real-time temeperature plot with GnuPlot via Pizza.py</td>
<td>viz_tool.py</td>
</tr>
<trclass="row-even"><td>real-time viz via some viz package</td>
<td>vizplotgui_tool.py</td>
</tr>
<trclass="row-odd"><td>combination of viz_tool.py and plot.py and gui.py</td>
<td> </td>
</tr>
</tbody>
</table>
<hrclass="docutils"/>
<p>For the viz_tool.py and vizplotgui_tool.py commands, replace “tool”
with “gl” or “atomeye” or “pymol” or “vmd”, depending on what
visualization package you have installed.</p>
<p>Note that for GL, you need to be able to run the Pizza.py GL tool,
which is included in the pizza sub-directory. See the <aclass="reference external"href="http://www.sandia.gov/~sjplimp/pizza.html">Pizza.py doc pages</a> for more info:</p>
<p>Note that for AtomEye, you need version 3, and there is a line in the
scripts that specifies the path and name of the executable. See the
AtomEye WWW pages <aclass="reference external"href="http://mt.seas.upenn.edu/Archive/Graphics/A">here</a> or <aclass="reference external"href="http://mt.seas.upenn.edu/Archive/Graphics/A3/A3.html">here</a> for more details:</p>
Built with <ahref="http://sphinx-doc.org/">Sphinx</a> using a <ahref="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <ahref="https://readthedocs.org">Read the Docs</a>.