obs
Module defining a class for storing, calculating and reading in observables from molecular dynamics trajectories.
- class MDMC.trajectory_analysis.observables.obs.Observable[source]
Abstract class that defines methods common to all observable data containers
Observable data can either be from a file or calculated from MD and stored in the data property, along with the associated uncertainty. The bool property
from_MDstates the source of the information.- reader
The file reader for reading experimental data
- Type:
- abstract calculate_from_MD(MD_input: CompactTrajectory | list[CompactTrajectory], verbose: int = 0, **parameters: dict) None[source]
Calculates the observable using input from an MD simulation
- Parameters:
MD_input (Object) – Some input from an MD simulation, commonly a
CompactTrajectoryverbose (int) – Enables verbose printing of the calculation
**parameters – Additional parameters required for calculation specific
Observableobjects
- property data: dict
Get the independent, dependent and error data
- Returns:
The independent, dependent and error data
- Return type:
- abstract property dependent_variables: dict
The dependent variables
- Returns:
The dependent variables
- Return type:
- abstract property dependent_variables_structure: dict
The structure of the dependent variables with respect to the independent variables. Specifically, the order in which the dependent variables are indexed with regards to the independent variables. Example: if dep_var1[indep_var1_index, indep_var2_index, …] = data point for values of the independent_variables with the stated indices then the relevant entry in the returned dict should be: {‘dependent_variable1’: [independent_variable1, independent_variable2, …]} Note that this would also correspond to numpy.shape of the dependent variable being: np.shape(dependent_variable1)=(np.size(independent_variable1), np.size(independent_variable2), …)
The purpose of this method is to ensure that all ``Observable``s of a particular type are created with ‘dependent_variables’ that are consistent regardless of how they were created (e.g. by different ``Reader``s).
- Returns:
The np.shape of the dependent variables
- Return type:
- abstract property errors: dict
The errors on the dependent variables
- Returns:
The errors on the
dependent_variables- Return type:
- abstract property independent_variables: dict
The independent variables
- Returns:
The independent variables
- Return type:
- abstract maximum_frames() int[source]
The maximum number of
CompactTrajectoryframes that can be used to calculate thedependent_variables- Returns:
The maximum number of frames
- Return type:
- abstract minimum_frames(dt: float = None) int[source]
The minimum number of
CompactTrajectoryframes needed to calculate thedependent_variables
- property name: str
Get or set the module name that used for factory instantiation
- Returns:
The name of the module in which the
Observableis located- Return type:
- property origin: str
Get or set the origin of the observable
- Returns:
The origin of the
Observable, either'experiment'or'MD'- Return type:
- read_from_file(reader: str, file_name: str) None[source]
Reads in experimental data from a file using a specified reader
- abstract property uniformity_requirements: dict[str, dict[str, bool]]
Represents the current limitations on
independent_variablesof theObservable. It captures if theindependent_variablesare required to be uniform or to start at zero The keys of the returned dictionary should be the variables that have such a restriction, with the associated values being a dictionary with booleans if the variables are ‘uniform’ or ‘zeroed’. Variables without any requirements do not need to be included, but can be included. If there are no uniformity requirements it is okay to return ‘None’.