Gyradius¶

class mdcraft.analysis.polymer.Gyradius(groups: AtomGroup | tuple[AtomGroup], groupings: str | tuple[str] = 'atoms', n_chains: int | tuple[int] = None, n_monomers: int | tuple[int] = None, *, components: bool = False, unwrap: bool = False, parallel: bool = False, verbose: bool = True, **kwargs)[source]¶

Bases: _PolymerAnalysisBase

Serial and parallel implementations to calculate the radius of gyration \(R_\mathrm{g}\) of a polymer.

The radius of gyration is used to describe the dimensions of a polymer chain, and is defined as

\[R_\mathrm{g}=\sqrt{ \frac{\sum_i^N m_i\|\mathbf{r}_i -\mathbf{R}_\mathrm{com}\|^2}{\sum_i^N m_i}}\]

where \(m_i\) and \(\mathbf{r}_i\) are the mass and position, respectively, of particle \(i\), and \(\mathbf{R}_\mathrm{com}\) is the center of mass.

Parameters:

groupsMDAnalysis.AtomGroup or array-like

Groups of polymers to be analyzed.

Note

All polymers in each group must have the same chain length.

groupingsstr or array-like, default: "atoms"

Determines whether the centers of mass are used in lieu of individual atom positions. If groupings is a str, the same value is used for all groups.

Note

In a standard trajectory file, segments (or chains) contain residues (or molecules), and residues contain atoms. This heirarchy must be adhered to for this analysis module to function correctly. If your trajectory file does not contain the correct residue or segment information, provide the number of chains and chain lengths in n_chains and n_monomers, respectively.

Valid values:

"atoms": Atom positions (generally or for coarse-grained simulations).
"residues": Residues’ centers of mass (for atomistic simulations).

n_chainsint or array-like, optional

Number of chains \(M\) in each polymer group. Must be provided if the trajectory does not adhere to the standard container heirarchy. If an int is provided, the same value is used for all groups.

Shape: \((N_\mathrm{groups},)\).

n_monomersint or array-like, optional

Number of monomers \(N\) in each chain in each polymer group. Must be provided if the trajectory does not adhere to the standard container heirarchy. If an int is provided, the same value is used for all groups.

Shape: \((N_\mathrm{groups},)\).

componentsbool, keyword-only, default: False

Specifies whether the components of the radii of gyration are calculated and returned instead.

unwrapbool, keyword-only, default: False

Determines whether atom positions are unwrapped.

parallelbool, keyword-only, default: False

Determines whether the analysis is performed in parallel.

verbosebool, keyword-only, default: True

Determines whether detailed progress is shown.

**kwargs

Additional keyword arguments to pass to MDAnalysis.analysis.base.AnalysisBase.

Attributes:

universeMDAnalysis.Universe

MDAnalysis.core.universe.Universe object containing all information describing the system.

results.unitsdict

Reference units for the results. For example, to get the reference units for results.gyradii, call results.units["gyradii"].

results.gyradiinumpy.ndarray

Radii of gyration.

Shape: \((N_\mathrm{groups},\,N_\mathrm{frames})\) or \((N_\mathrm{groups},\,N_\mathrm{frames},\,3)\).

Reference unit: \(\mathrm{Å}\).

Methods

`get_supported_backends`	Tuple with backends supported by the core library for a given class.
`run`	Performs the calculation.
`save`	Saves results to a binary or archive file in NumPy format.

classmethod get_supported_backends()¶

Tuple with backends supported by the core library for a given class. User can pass either one of these values as backend=... to run() method, or a custom object that has apply method (see documentation for run()):

‘serial’: no parallelization

‘multiprocessing’: parallelization using multiprocessing.Pool

‘dask’: parallelization using dask.delayed.compute(). Requires installation of mdanalysis[dask]

If you want to add your own backend to an existing class, pass a backends.BackendBase subclass (see its documentation to learn how to implement it properly), and specify unsupported_backend=True.

Returns:

tuple: names of built-in backends that can be used in run(backend=...)()

Added in version 2.8.0: ..

property parallelizable¶

Boolean mark showing that a given class can be parallelizable with split-apply-combine procedure. Namely, if we can safely distribute _single_frame() to multiple workers and then combine them with a proper _conclude() call. If set to False, no backends except for serial are supported.

Note

If you want to check parallelizability of the whole class, without explicitly creating an instance of the class, see _analysis_algorithm_is_parallelizable. Note that you setting it to other value will break things if the algorithm behind the analysis is not trivially parallelizable.

Returns:

bool: if a given AnalysisBase subclass instance is parallelizable with split-apply-combine, or not

Added in version 2.8.0: ..

run(start: int = None, stop: int = None, step: int = None, frames: slice | ndarray[int] = None, verbose: bool = None, **kwargs) → SerialAnalysisBase | ParallelAnalysisBase¶

Performs the calculation.