# System properties

Similar to what is described in [Library_properties]{.title-ref}, the
instances of `lammps <lammps.lammps>`{.interpreted-text
role="py:class"}\_\_, `PyLammps <lammps.PyLammps>`{.interpreted-text
role="py:class"}\_\_, or
`IPyLammps <lammps.IPyLammps>`{.interpreted-text role="py:class"}\_\_
can be used to extract different kinds of information about the active
LAMMPS instance and also to modify some of it. The main difference
between the interfaces is how the information is exposed.

While the `lammps <lammps.lammps>`{.interpreted-text
role="py:class"}\_\_ is just a thin layer that wraps C API calls,
`PyLammps <lammps.PyLammps>`{.interpreted-text role="py:class"}\_\_ and
`IPyLammps <lammps.IPyLammps>`{.interpreted-text role="py:class"}\_\_
expose information as objects and properties.

In some cases the data returned is a direct reference to the original
data inside LAMMPS cast to `ctypes` pointers. Where possible, the
wrappers will determine the `ctypes` data type and cast pointers
accordingly. If `numpy` is installed arrays can also be extracted as
numpy arrays, which will access the C arrays directly and have the
correct dimensions to protect against invalid accesses.

:::: warning
::: title
Warning
:::

When accessing per-atom data, please note that this data is the
per-processor local data and indexed accordingly. These arrays can
change sizes and order at every neighbor list rebuild and atom sort
event as atoms are migrating between subdomains.
::::

::::: tabs
::: tab
lammps API

``` python
from lammps import lammps

lmp = lammps()
lmp.file("in.sysinit")

natoms = lmp.get_natoms()
print(f"running simulation with {natoms} atoms")

lmp.command("run 1000 post no");

for i in range(10):
   lmp.command("run 100 pre no post no")
   pe = lmp.get_thermo("pe")
   ke = lmp.get_thermo("ke")
   print(f"PE = {pe}\nKE = {ke}")

lmp.close()
```

**Methods**:

-   `version() <lammps.lammps.version()>`{.interpreted-text
    role="py:meth"}\_\_: return the numerical version id, e.g. LAMMPS 2
    Sep 2015 -\> 20150902
-   `get_thermo() <lammps.lammps.get_thermo()>`{.interpreted-text
    role="py:meth"}\_\_: return current value of a thermo keyword
-   `last_thermo() <lammps.lammps.last_thermo()>`{.interpreted-text
    role="py:meth"}\_\_: return a dictionary of the last thermodynamic
    output
-   `get_natoms() <lammps.lammps.get_natoms()>`{.interpreted-text
    role="py:meth"}\_\_: total \# of atoms as int
-   `reset_box() <lammps.lammps.reset_box()>`{.interpreted-text
    role="py:meth"}\_\_: reset the simulation box size
-   `extract_setting() <lammps.lammps.extract_setting()>`{.interpreted-text
    role="py:meth"}\_\_: return a global setting
-   `extract_global() <lammps.lammps.extract_global()>`{.interpreted-text
    role="py:meth"}\_\_: extract a global quantity
-   `extract_box() <lammps.lammps.extract_box()>`{.interpreted-text
    role="py:meth"}\_\_: extract box info
-   `create_atoms() <lammps.lammps.create_atoms()>`{.interpreted-text
    role="py:meth"}\_\_: create N atoms with IDs, types, x, v, and image
    flags

**Properties**:

-   `last_thermo_step <lammps.lammps.last_thermo_step>`{.interpreted-text
    role="py:attr"}\_\_: the last timestep thermodynamic output was
    computed
:::

::: tab
PyLammps/IPyLammps API

In addition to the functions provided by
`lammps <lammps.lammps>`{.interpreted-text role="py:class"}\_\_,
`PyLammps <lammps.PyLammps>`{.interpreted-text role="py:class"}\_\_
objects have several properties which allow you to query the system
state:

L.system

:   Is a dictionary describing the system such as the bounding box or
    number of atoms

L.system.xlo, L.system.xhi

:   bounding box limits along x-axis

L.system.ylo, L.system.yhi

:   bounding box limits along y-axis

L.system.zlo, L.system.zhi

:   bounding box limits along z-axis

L.communication

:   configuration of communication subsystem, such as the number of
    threads or processors

L.communication.nthreads

:   number of threads used by each LAMMPS process

L.communication.nprocs

:   number of MPI processes used by LAMMPS

L.fixes

:   List of fixes in the current system

L.computes

:   List of active computes in the current system

L.dump

:   List of active dumps in the current system

L.groups

:   List of groups present in the current system

**Retrieving the value of an arbitrary LAMMPS expressions**

LAMMPS expressions can be immediately evaluated by using the `eval`
method. The passed string parameter can be any expression containing
global [thermo]{.title-ref} values, variables, compute or fix data (see
[Howto_output]{.title-ref}):

``` python
result = L.eval("ke") # kinetic energy
result = L.eval("pe") # potential energy

result = L.eval("v_t/2.0")
```

**Example**

``` python
from lammps import PyLammps

L = PyLammps()
L.file("in.sysinit")

print(f"running simulation with {L.system.natoms} atoms")

L.run(1000, "post no");

for i in range(10):
   L.run(100, "pre no post no")
   pe = L.eval("pe")
   ke = L.eval("ke")
   print(f"PE = {pe}\nKE = {ke}")
```
:::
:::::