# Source code for espressomd.analyze

```
#
# Copyright (C) 2013-2022 The ESPResSo project
#
# This file is part of ESPResSo.
#
# ESPResSo is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# ESPResSo is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
import numpy as np
from . import utils
from .code_features import assert_features, has_features
from .script_interface import script_interface_register, ScriptInterfaceHelper
[docs]def autocorrelation(time_series):
"""
Calculate the unnormalized autocorrelation function :math:`R_{XX}`
of an observable :math:`X` measured at time :math:`t` with constant
time step for lag times :math:`\\tau` such that:
:math:`\\displaystyle R_{XX}(\\tau) = \\frac{1}{N - \\tau} \\sum_{t=0}^{N - \\tau} X_{t} \\cdot X_{t + \\tau}`
This is a scipy implementation of the algorithm described
in :cite:`debuyl18a` that uses FFT. This implementation:
- doesn't subtract the mean of the time series before calculating the ACF,
- doesn't normalize the ACF by the variance of the time series,
- assumes the time series is aperiodic (i.e. uses zero-padding).
Parameters
----------
time_series : (N,) or (N, M) array_like of :obj:`float`
Time series to correlate. For multi-dimensional data, M is the
number of columns.
Returns
-------
(N,) array_like of :obj:`float`
The time series autocorrelation function.
"""
import scipy.signal
def acf_1d(signal, n_with_padding, n):
acf = scipy.signal.correlate(signal, signal, mode="full", method="fft")
acf = acf[-n_with_padding:][:n] / (n - np.arange(n))
return acf
if not isinstance(time_series, np.ndarray):
time_series = np.array(time_series)
n = time_series.shape[0]
if n == 0:
return np.array([], dtype=float)
n_with_padding = 2**int(np.ceil(np.log2(n)) + 1)
signal_padded = np.zeros(n_with_padding)
if time_series.ndim == 1:
signal_padded[:n] = time_series
return acf_1d(signal_padded, n_with_padding, n)
elif time_series.ndim == 2:
signal_acf = np.zeros(n)
for i in range(time_series.shape[1]):
signal_padded[:n] = time_series[:, i]
signal_acf += acf_1d(signal_padded, n_with_padding, n)
return signal_acf
else:
raise ValueError(f"Only 1-dimensional and 2-dimensional time series "
f"are supported, got shape {time_series.shape}")
@script_interface_register
class _ObservableStat(ScriptInterfaceHelper):
_so_name = "ScriptInterface::Analysis::ObservableStat"
_so_creation_policy = "GLOBAL"
def _generate_summary(self, obj, dim, calc_sp):
"""
Compute derived quantities and reshape pressure tensors as 3x3 matrices.
"""
def zero():
if dim == 1 or calc_sp:
return 0.
return np.zeros(9, dtype=float)
def reduction(obj, key):
total = zero()
for k in obj.keys():
if isinstance(k, tuple) and k[0] == key:
total += obj[k]
obj[key] = total
out = {}
out["bonded"] = zero()
out["non_bonded_intra"] = zero()
out["non_bonded_inter"] = zero()
for k, v in obj.items():
if "," not in k:
out[k] = v
else:
k = k.split(",")
k = (k[0], *map(int, k[1:]))
out[k] = v
if k[0] == "bonded":
out["bonded"] += v
elif k[0].startswith("non_bonded_"):
if k[0] == "non_bonded_intra":
out["non_bonded_intra"] += v
else:
out["non_bonded_inter"] += v
k = ("non_bonded", *k[1:])
if k not in out:
out[k] = zero()
out[k] += v
out["non_bonded"] = out["non_bonded_intra"] + out["non_bonded_inter"]
if has_features("ELECTROSTATICS"):
reduction(out, "coulomb")
if has_features("DIPOLES"):
reduction(out, "dipolar")
if has_features("VIRTUAL_SITES"):
reduction(out, "virtual_sites")
if dim == 1 or calc_sp:
return out
return {k: np.reshape(v, (3, 3)) for k, v in out.items()}
[docs]@script_interface_register
class Analysis(ScriptInterfaceHelper):
"""
Methods
-------
linear_momentum()
Calculates the system's linear momentum.
Parameters
----------
include_particles : :obj:`bool`, optional
Whether to include the particles contribution to the linear
momentum. True by default.
include_lbfluid : :obj:`bool`, optional
whether to include the lattice-Boltzmann fluid contribution
to the linear momentum. True by default.
Returns
-------
(3,) array_like of :obj:`float`
The linear momentum of the system.
center_of_mass()
Calculate the center of mass of particles of a given type.
Note that virtual sites are not included, as they do not have a
meaningful mass.
Parameters
----------
p_type : :obj:`int`
Particle :attr:`~espressomd.particle_data.ParticleHandle.type`
for which to calculate the center of mass.
Returns
-------
(3,) array_like of :obj:`float`
The center of mass of the particles.
nbhood()
Get all particles in a defined neighborhood.
Parameters
----------
pos : array of :obj:`float`
Reference position for the neighborhood.
r_catch : :obj:`float`
Radius of the region.
Returns
-------
(N,) array_like of :obj:`int`
The neighbouring particle ids.
calc_re()
Calculate the mean end-to-end distance of chains and its
standard deviation, as well as mean square end-to-end distance of
chains and its standard deviation.
This requires that a set of chains of equal length which start
with the particle number ``chain_start`` and are consecutively
numbered, the last particle in that topology having id number
``chain_start + number_of_chains * chain_length - 1``.
Parameters
----------
chain_start : :obj:`int`
The id of the first monomer of the first chain.
number_of_chains : :obj:`int`
Number of chains contained in the range.
chain_length : :obj:`int`
The length of every chain.
Returns
-------
(4,) array_like of :obj:`float`
Where [0] is the mean end-to-end distance of chains and [1] its
standard deviation, [2] the mean square end-to-end distance and
[3] its standard deviation.
calc_rg()
Calculate the mean radius of gyration of chains and its standard
deviation, as well as the mean square radius of gyration of chains
and its standard deviation.
This requires that a set of chains of equal length which start
with the particle number ``chain_start`` and are consecutively
numbered, the last particle in that topology having id number
``chain_start + number_of_chains * chain_length - 1``.
Parameters
----------
chain_start : :obj:`int`
The id of the first monomer of the first chain.
number_of_chains : :obj:`int`
Number of chains contained in the range.
chain_length : :obj:`int`
The length of every chain.
Returns
-------
(4,) array_like of :obj:`float`
Where [0] is the mean radius of gyration of the chains and [1] its
standard deviation, [2] the mean square radius of gyration and [3]
its standard deviation.
calc_rh()
Calculate the hydrodynamic mean radius of chains and its standard
deviation.
This requires that a set of chains of equal length which start
with the particle number ``chain_start`` and are consecutively
numbered, the last particle in that topology having id number
``chain_start + number_of_chains * chain_length - 1``.
Parameters
----------
chain_start : :obj:`int`
The id of the first monomer of the first chain
number_of_chains : :obj:`int`
Number of chains contained in the range.
chain_length : :obj:`int`
The length of every chain.
Returns
-------
(2,) array_like of :obj:`float`:
Where [0] is the mean hydrodynamic radius of the chains
and [1] its standard deviation.
angular_momentum()
Calculate the system's angular momentum with respect to the origin.
Note that virtual sites are not included, as they do not have a
meaningful mass.
Parameters
----------
p_type : :obj:`int`
Particle :attr:`~espressomd.particle_data.ParticleHandle.type` for
which to calculate the center of mass, or ``-1`` for all particles.
Returns
-------
(3,) array_like of :obj:`float`
The center of mass of the system.
structure_factor()
Calculate the structure factor for given types. Returns the
spherically averaged structure factor of particles specified in
``sf_types``. The structure factor is calculated for all possible wave
vectors q up to ``sf_order``. Do not choose parameter ``sf_order`` too
large because the number of calculations grows as ``sf_order`` to the
third power.
Parameters
----------
sf_types : list of :obj:`int`
Particle :attr:`~espressomd.particle_data.ParticleHandle.type`
which should be considered.
sf_order : :obj:`int`
Specifies the maximum wavevector.
Returns
-------
:obj:`ndarray`
Where [0] contains the wave vectors q
and [1] contains the structure factors S(q)
distribution()
Calculates the distance distribution of particles (probability of
finding a particle of type A at a certain distance around a particle of
type B, disregarding the fact that a spherical shell of a larger radius
covers a larger volume). The distance is defined as the minimal distance
between a particle of group ``type_list_a`` to any of the group
``type_list_b``. Returns two arrays, the bins and the (normalized)
distribution.
Parameters
----------
type_list_a : list of :obj:`int`
List of particle :attr:`~espressomd.particle_data.ParticleHandle.type`,
only consider distances from these types.
type_list_b : list of :obj:`int`
List of particle :attr:`~espressomd.particle_data.ParticleHandle.type`,
only consider distances to these types.
r_min : :obj:`float`
Minimum distance. Default is 0.
r_max : :obj:`float`
Maximum distance. By default, it is half the box size.
A value larger than half the box size is allowed for systems
with :ref:`open boundary conditions <Open boundaries>`.
r_bins : :obj:`int`
Number of bins. Default is 100.
log_flag : :obj:`bool`
When set to ``False``, the bins are linearly equidistant; when set
to ``True``, the bins are logarithmically equidistant.
int_flag : :obj:`bool`
When set to ``True``, the result is an integrated distribution.
Returns
-------
:obj:`ndarray`
Where [0] contains the midpoints of the bins,
and [1] contains the values of the rdf.
"""
_so_name = "ScriptInterface::Analysis::Analysis"
_so_creation_policy = "GLOBAL"
_so_bind_methods = (
"linear_momentum",
"center_of_mass",
"nbhood",
"calc_re",
"calc_rg",
"calc_rh",
"angular_momentum",
"structure_factor",
"distribution")
[docs] def min_dist(self, p1='default', p2='default'):
"""
Minimal distance between two sets of particle types.
Parameters
----------
p1, p2 : lists of :obj:`int`
Particle :attr:`~espressomd.particle_data.ParticleHandle.type` in
both sets. If both are set to ``'default'``, the minimum distance
of all pairs is returned.
Returns
-------
:obj:`float`
Minimal distance.
"""
if p1 == 'default' and p2 == 'default':
p1 = []
p2 = []
elif p1 == 'default' or p2 == 'default':
raise ValueError("Both p1 and p2 have to be specified")
return self.call_method("min_dist", p_types1=p1, p_types2=p2)
[docs] def pressure(self):
"""
Calculate the instantaneous scalar pressure in parallel. This is only
sensible in an isotropic system which is homogeneous (on average)! Do
not use this in an anisotropic or inhomogeneous system. In order to
obtain the pressure, the ensemble average needs to be calculated.
Returns
-------
:obj:`dict`
A dictionary with the following keys:
* ``"total"``: total pressure
* ``"kinetic"``: kinetic pressure
* ``"bonded"``: total bonded pressure
* ``"bonded", <bond_id>``: bonded pressure from the bond
identified by ``bond_id``
* ``"non_bonded"``: total non-bonded pressure
* ``"non_bonded", <type_i>, <type_j>``: non-bonded pressure which
arises from the interactions between ``type_i`` and ``type_j``
* ``"non_bonded_intra", <type_i>, <type_j>``: non-bonded pressure
from short-range forces between ``type_i`` and ``type_j``
with the same ``mol_id``
* ``"non_bonded_inter", <type_i>, <type_j>``: non-bonded pressure
from short-range forces between ``type_i`` and ``type_j``
with different ``mol_id``
* ``"coulomb"``: Coulomb pressure, how it is calculated depends on
the method. It is equivalent to 1/3 of the trace of the Coulomb
pressure tensor. For how the pressure tensor is calculated,
see :ref:`Pressure Tensor`. The averaged value in an isotropic
NVT simulation is equivalent to the average of
:math:`E^{\\mathrm{coulomb}}/(3V)`, see :cite:`brown95a`.
* ``"coulomb", <i>``: Coulomb pressure from particle pairs
(``i=0``), electrostatics solvers (``i=1``)
* ``"dipolar"``: not implemented
* ``"virtual_sites"``: Pressure contribution from virtual sites
* ``"external_fields"``: external fields contribution
"""
obs_stat = _ObservableStat()
observable = obs_stat.call_method("calculate_scalar_pressure")
utils.handle_errors("calculate_pressure() failed")
return obs_stat._generate_summary(observable, 9, True)
[docs] def pressure_tensor(self):
"""
Calculate the instantaneous pressure tensor in parallel. This is
sensible in an anisotropic system. Still it assumes that the system is
homogeneous since the volume-averaged pressure tensor is used. Do not use
this pressure tensor in an (on average) inhomogeneous system. If the
system is (on average inhomogeneous) then use a local pressure tensor.
In order to obtain the pressure tensor, the ensemble average needs to be
calculated.
Returns
-------
:obj:`dict`
A dictionary with the following keys:
* ``"total"``: total pressure tensor
* ``"kinetic"``: kinetic pressure tensor
* ``"bonded"``: total bonded pressure tensor
* ``"bonded", <bond_id>``: bonded pressure tensor from the bond
identified by ``bond_id``
* ``"non_bonded"``: total non-bonded pressure tensor
* ``"non_bonded", <type_i>, <type_j>``: non-bonded pressure tensor
from short-range forces between ``type_i`` and ``type_j``
* ``"non_bonded_intra", <type_i>, <type_j>``: non-bonded pressure
tensor from short-range forces between ``type_i`` and ``type_j``
with the same ``mol_id``
* ``"non_bonded_inter", <type_i>, <type_j>``: non-bonded pressure
tensor from short-range forces between ``type_i`` and ``type_j``
with different ``mol_id``
* ``"coulomb"``: Maxwell pressure tensor, how it is calculated
depends on the method
* ``"coulomb", <i>``: Maxwell pressure tensor from particle pairs
(``i=0``), electrostatics solvers (``i=1``)
* ``"dipolar"``: not implemented
* ``"virtual_sites"``: pressure tensor contribution from virtual sites
* ``"external_fields"``: external fields contribution
"""
obs_stat = _ObservableStat()
observable = obs_stat.call_method("calculate_pressure_tensor")
utils.handle_errors("calculate_pressure() failed")
return obs_stat._generate_summary(observable, 9, False)
[docs] def energy(self):
"""
Calculate the system energy in parallel.
Returns
-------
:obj:`dict`
A dictionary with the following keys:
* ``"total"``: total energy
* ``"kinetic"``: linear and rotational kinetic energy
* ``"bonded"``: total bonded energy
* ``"bonded", <bond_id>``: bonded energy from the bond
identified by ``bond_id``
* ``"non_bonded"``: total non-bonded energy
* ``"non_bonded", <type_i>, <type_j>``: non-bonded energy
from short-range interactions between ``type_i`` and ``type_j``
* ``"non_bonded_intra", <type_i>, <type_j>``: non-bonded energy
from short-range interactions between ``type_i`` and ``type_j``
with the same ``mol_id``
* ``"non_bonded_inter", <type_i>, <type_j>``: non-bonded energy
from short-range interactions between ``type_i`` and ``type_j``
with different ``mol_id``
* ``"coulomb"``: Coulomb energy, how it is calculated depends
on the method
* ``"coulomb", <i>``: Coulomb energy from particle pairs
(``i=0``), electrostatics solvers (``i=1``)
* ``"dipolar"``: dipolar energy
* ``"dipolar", <i>``: dipolar energy from particle pairs and
magnetic field constraints (``i=0``), magnetostatics solvers
(``i=1``)
* ``"external_fields"``: external fields contribution
Examples
--------
>>> energy = system.analysis.energy()
>>> print(energy["total"])
>>> print(energy["kinetic"])
>>> print(energy["bonded"])
>>> print(energy["non_bonded"])
>>> print(energy["external_fields"])
"""
obs_stat = _ObservableStat()
observable = obs_stat.call_method("calculate_energy")
utils.handle_errors("calculate_energy() failed")
return obs_stat._generate_summary(observable, 1, False)
[docs] def particle_energy(self, particle):
"""
Calculate the non-bonded energy of a single given particle.
Parameters
----------
particle : :class:`~espressomd.particle_data.ParticleHandle`
Returns
-------
:obj: `float`
Non-bonded energy of that particle
"""
return self.call_method("particle_energy", pid=particle.id)
[docs] def dpd_stress(self):
assert_features("DPD")
return np.reshape(self.call_method("dpd_stress"), (3, 3))
[docs] def gyration_tensor(self, p_type=None):
"""
Analyze the gyration tensor of particles of a given type.
Parameters
----------
p_type : list of :obj:`int`
A particle :attr:`~espressomd.particle_data.ParticleHandle.type`,
or list of particle types to be considered.
Returns
-------
:obj:`dict`
A dictionary with the following keys:
* ``"Rg^2"``: squared radius of gyration
* ``"shape"``: three shape descriptors (asphericity, acylindricity, and relative shape anisotropy)
* ``"eva0"``: eigenvalue 0 of the gyration tensor and its corresponding eigenvector.
* ``"eva1"``: eigenvalue 1 of the gyration tensor and its corresponding eigenvector.
* ``"eva2"``: eigenvalue 2 of the gyration tensor and its corresponding eigenvector.
The eigenvalues are sorted in descending order.
"""
if p_type is None:
raise ValueError(
"The p_type keyword argument must be provided (particle type)")
if not hasattr(p_type, '__iter__'):
p_type = [p_type]
vec = self.call_method("gyration_tensor", p_types=p_type)
mat = np.reshape(vec, (3, 3))
w, v = np.linalg.eig(mat)
# return eigenvalue/vector tuples in order of increasing eigenvalues
order = np.argsort(np.abs(w))[::-1]
rad_gyr_sqr = np.trace(mat)
aspheric = w[order[0]] - 0.5 * (w[order[1]] + w[order[2]])
acylindric = w[order[1]] - w[order[2]]
rel_shape_anis = (aspheric**2 + 0.75 * acylindric**2) / rad_gyr_sqr**2
return {
"Rg^2": rad_gyr_sqr,
"shape": [aspheric, acylindric, rel_shape_anis],
"eva0": (w[order[0]], v[:, order[0]]),
"eva1": (w[order[1]], v[:, order[1]]),
"eva2": (w[order[2]], v[:, order[2]])}
[docs] def moment_of_inertia_matrix(self, p_type=None):
"""
Returns the 3x3 moment of inertia matrix for particles of a given type.
Parameters
----------
p_type : :obj:`int`
A particle :attr:`~espressomd.particle_data.ParticleHandle.type`.
Returns
-------
(3,3) array_like of :obj:`float`
Moment of inertia matrix.
"""
vec = self.call_method("moment_of_inertia_matrix", p_type=p_type)
return np.reshape(vec, (3, 3))
```