idZddlZddlZddlZddlZddlmZddlmZm Z ddl Z ddl m Z ddlmZddlmZd d lmZmZmZmZd d lmZmZejeZGd d eZGddeZdZ dZ!dS)uVAnalysis building blocks --- :mod:`MDAnalysis.analysis.base` ============================================================ MDAnalysis provides building blocks for creating analysis classes. One can think of each analysis class as a "tool" that performs a specific analysis over the trajectory frames and stores the results in the tool. Analysis classes are derived from :class:`AnalysisBase` by subclassing. This inheritance provides a common workflow and API for users and makes many additional features automatically available (such as frame selections and a verbose progressbar). The important points for analysis classes are: #. Analysis tools are Python classes derived from :class:`AnalysisBase`. #. When instantiating an analysis, the :class:`Universe` or :class:`AtomGroup` that the analysis operates on is provided together with any other parameters that are kept fixed for the specific analysis. #. The analysis is performed with :meth:`~AnalysisBase.run` method. It has a common set of arguments such as being able to select the frames the analysis is performed on. The `verbose` keyword argument enables additional output. A progressbar is shown by default that also shows an estimate for the remaining time until the end of the analysis. #. Results are always stored in the attribute :attr:`AnalysisBase.results`, which is an instance of :class:`Results`, a kind of dictionary that allows allows item access via attributes. Each analysis class decides what and how to store in :class:`Results` and needs to document it. For time series, the :attr:`AnalysisBase.times` contains the time stamps of the analyzed frames. Example of using a standard analysis tool ----------------------------------------- For example, the :class:`MDAnalysis.analysis.rms.RMSD` performs a root-mean-square distance analysis in the following way: .. code-block:: python import MDAnalysis as mda from MDAnalysisTests.datafiles import TPR, XTC from MDAnalysis.analysis import rms u = mda.Universe(TPR, XTC) # (2) instantiate analysis rmsd = rms.RMSD(u, select='name CA') # (3) the run() method can select frames in different ways # run on all frames (with progressbar) rmsd.run(verbose=True) # or start, stop, and step can be used rmsd.run(start=2, stop=8, step=2) # a list of frames to run the analysis on can be passed rmsd.run(frames=[0,2,3,6,9]) # a list of booleans the same length of the trajectory can be used rmsd.run(frames=[True, False, True, True, False, False, True, False, False, True]) # (4) analyze the results, e.g., plot t = rmsd.times y = rmsd.results.rmsd[:, 2] # RMSD at column index 2, see docs import matplotlib.pyplot as plt plt.plot(t, y) plt.xlabel("time (ps)") plt.ylabel("RMSD (Å)") Writing new analysis tools -------------------------- In order to write new analysis tools, derive a class from :class:`AnalysisBase` and define at least the :meth:`_single_frame` method, as described in :class:`AnalysisBase`. .. SeeAlso:: The chapter `Writing your own trajectory analysis`_ in the *User Guide* contains a step-by-step example for writing analysis tools with :class:`AnalysisBase`. .. _`Writing your own trajectory analysis`: https://userguide.mdanalysis.org/stable/examples/analysis/custom_trajectory_analysis.html If your analysis is operating independently on each frame, you might consider making it **parallelizable** via adding a :meth:`get_supported_backends` method, and appropriate aggregation function for each of its results. For example, if you have your :meth:`_single_frame` method storing important values under :attr:`self.results.timeseries`, you will write: .. code-block:: python class MyAnalysis(AnalysisBase): _analysis_algorithm_is_parallelizable = True @classmethod def get_supported_backends(cls): return ('serial', 'multiprocessing', 'dask',) def _get_aggregator(self): return ResultsGroup(lookup={'timeseries': ResultsGroup.ndarray_vstack}) See :mod:`MDAnalysis.analysis.results` for more on aggregating results. .. SeeAlso:: :ref:`parallel-analysis` Classes ------- The :class:`MDAnalysis.results.Results` and :class:`AnalysisBase` classes are the essential building blocks for almost all MDAnalysis tools in the :mod:`MDAnalysis.analysis` module. They aim to be easily useable and extendable. :class:`AnalysisFromFunction` and the :func:`analysis_class` functions are simple wrappers that make it even easier to create fully-featured analysis tools if only the single-frame analysis function needs to be written. N)partial)IterableUnion) coordinates) AtomGroup) ProgressBar) BackendDaskBackendMultiprocessing BackendSerial BackendBase)Results ResultsGroupceZdZdZedZdZedZd dZ d!de e e j ffdZd e e e j ffd Z d!d Zd Zd ZdZ d"ddde j deddfdZ d!dedededede e e j fdee j f dZ d de eefdededefdZ d#ddddededededededede eefdefdZdefdZdS)$ AnalysisBaseaBase class for defining multi-frame analysis The class is designed as a template for creating multi-frame analyses. This class will automatically take care of setting up the trajectory reader for iterating, and it offers to show a progress meter. Computed results are stored inside the :attr:`results` attribute. To define a new Analysis, :class:`AnalysisBase` needs to be subclassed and :meth:`_single_frame` must be defined. It is also possible to define :meth:`_prepare` and :meth:`_conclude` for pre- and post-processing. All results should be stored as attributes of the :class:`MDAnalysis.analysis.results.Results` container. .. Note:: The instance attributes are created during and on conclusion of calling the :meth:`AnalysisBase.run` method. Accessing an attribute before it has been created will raise an :exc:`AttributeError`. Parameters ---------- trajectory : MDAnalysis.coordinates.base.ReaderBase A trajectory Reader verbose : bool, optional Turn on more logging and debugging Attributes ---------- times: numpy.ndarray Array of times of the Timesteps that were analyzed. Only exists after calling :meth:`AnalysisBase.run`. frames: numpy.ndarray Array of frame indices that were analyzed. Only exists after calling :meth:`AnalysisBase.run`. results: :class:`Results` Results of calculation are stored here, after call to :meth:`AnalysisBase.run`. n_frames: int number of *analyzed* frames, i.e., after taking into account the `start`, `stop`, and `step` values from :meth:`AnalysisBase.run`. Only exists after calling :meth:`AnalysisBase.run`. start: int Frame index of the first trajectory frame that was analyzed. Only exists after calling :meth:`AnalysisBase.run`. stop: int Frame index of the last trajectory frame that was analyzed. Only exists after calling :meth:`AnalysisBase.run`. step: int Every `step` frame was analyzed, as ``trajectory[start:stop:step]``. Only exists after calling :meth:`AnalysisBase.run`. Example ------- .. code-block:: python from MDAnalysis.analysis.base import AnalysisBase class NewAnalysis(AnalysisBase): def __init__(self, atomgroup, parameter, **kwargs): super(NewAnalysis, self).__init__(atomgroup.universe.trajectory, **kwargs) self._parameter = parameter self._ag = atomgroup def _prepare(self): # OPTIONAL # Called before iteration on the trajectory has begun. # Data structures can be set up at this time self.results.example_result = [] def _single_frame(self): # REQUIRED # Called after the trajectory is moved onto each new frame. # store an example_result of `some_function` for a single frame self.results.example_result.append(some_function(self._ag, self._parameter)) def _conclude(self): # OPTIONAL # Called once iteration on the trajectory is finished. # Apply normalisation and averaging to results here. self.results.example_result = np.asarray(self.example_result) self.results.example_result /= np.sum(self.result) Afterwards the new analysis can be run like this .. code-block:: python import MDAnalysis as mda from MDAnalysisTests.datafiles import PSF, DCD u = mda.Universe(PSF, DCD) na = NewAnalysis(u.select_atoms('name CA'), 35) na.run(start=10, stop=20) print(na.results.example_result) # results can also be accessed by key print(na.results["example_result"]) .. versionchanged:: 1.0.0 Support for setting `start`, `stop`, and `step` has been removed. These should now be directly passed to :meth:`AnalysisBase.run`. .. versionchanged:: 2.0.0 Added :attr:`results` .. versionchanged:: 2.8.0 Added ability to run analysis in parallel using either a built-in backend (`multiprocessing` or `dask`) or a custom `backends.BackendBase` instance with an implemented `apply` method that is used to run the computations. cdS)aTuple with backends supported by the core library for a given class. User can pass either one of these values as ``backend=...`` to :meth:`run()` method, or a custom object that has ``apply`` method (see documentation for :meth:`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 :class:`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 :meth:`run(backend=...)` .. versionadded:: 2.8.0 )serialclss b/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/MDAnalysis/analysis/base.pyget_supported_backendsz#AnalysisBase.get_supported_backends"s 0{Fc|jS)aBoolean mark showing that a given class can be parallelizable with split-apply-combine procedure. Namely, if we can safely distribute :meth:`_single_frame` to multiple workers and then combine them with a proper :meth:`_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 :attr:`_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 .. versionadded:: 2.8.0 )%_analysis_algorithm_is_parallelizableselfs rparallelizablezAnalysisBase.parallelizableBs 099rc H||_||_t|_dSN) _trajectory_verboserresults)r trajectoryverbosekwargss r__init__zAnalysisBase.__init__\s % yy rNreturnc||_|.td|||fDstd|}n,||||\}}}t |||}|||c|_|_|_|S)a Defines limits for the whole run, as passed by self.run() arguments Parameters ---------- trajectory : mda.Reader a trajectory Reader start : int, optional start frame of analysis, by default None stop : int, optional stop frame of analysis, by default None step : int, optional number of frames to skip between each analysed frame, by default None frames : array_like, optional array of integers or booleans to slice trajectory; cannot be combined with ``start``, ``stop``, ``step``; by default None Returns ------- Union[slice, np.ndarray] Appropriate slicer for the trajectory that would give correct iteraction order via trajectory[slicer] Raises ------ ValueError if *both* `frames` and at least one of ``start``, ``stop``, or ``step`` is provided (i.e. set to not ``None`` value). .. versionadded:: 2.8.0 Nc3K|]}|duV dSr!r.0opts r z2AnalysisBase._define_run_frames..s&BBssd{BBBBBBr.start/stop/step cannot be combined with frames)r"all ValueErrorcheck_slice_indicesslicestartstopsteprr%r5r6r7framesslicers r_define_run_frameszAnalysisBase._define_run_framesasD&  BBudD.ABBBBB  DFF * > >tT!! E45$--F+0$( DIty rr:c|j||_t|j|_t j|jt |_t j|j|_dS)axPrepares sliced trajectory for use in subsequent parallel computations: namely, assigns self._sliced_trajectory and its appropriate attributes, self.n_frames, self.frames and self.times. Parameters ---------- slicer : Union[slice, np.ndarray] appropriate slicer for the trajectory .. versionadded:: 2.8.0 dtypeN) r"_sliced_trajectorylenn_framesnpzerosintr9times)rr:s r_prepare_sliced_trajectoryz'AnalysisBase._prepare_sliced_trajectorysU#'"26":D344 ht}C888 Xdm,, rcb||||||}||dS)agPass a Reader object and define the desired iteration pattern through the trajectory Parameters ---------- trajectory : mda.Reader A trajectory Reader start : int, optional start frame of analysis stop : int, optional stop frame of analysis step : int, optional number of frames to skip between each analysed frame frames : array_like, optional array of integers or booleans to slice trajectory; cannot be combined with ``start``, ``stop``, ``step`` .. versionadded:: 2.2.0 Raises ------ ValueError if *both* `frames` and at least one of ``start``, ``stop``, or ``frames`` is provided (i.e., set to another value than ``None``) .. versionchanged:: 1.0.0 Added .frames and .times arrays as attributes .. versionchanged:: 2.2.0 Added ability to iterate through trajectory by passing a list of frame indices in the `frames` keyword argument .. versionchanged:: 2.8.0 Split function into two: :meth:`_define_run_frames` and :meth:`_prepare_sliced_trajectory`: first one defines the limits for the whole run and is executed once during :meth:`run` in :meth:`_setup_frames`, second one prepares sliced trajectory for each of the workers and gets executed twice: one time in :meth:`_setup_frames` for the whole trajectory, second time in :meth:`_compute` for each of the computation groups. N)r;rFr8s r _setup_frameszAnalysisBase._setup_framess:Z((UD$OO ''/////rc td)aCalculate data from a single frame of trajectory Don't worry about normalising, just deal with a single frame. Attributes accessible during your calculations: - ``self._frame_index``: index of the frame in results array - ``self._ts`` -- Timestep instance - ``self._sliced_trajectory`` -- trajectory that you're iterating over - ``self.results`` -- :class:`MDAnalysis.analysis.results.Results` instance holding run results initialized in :meth:`_prepare`. z!Only implemented in child classes)NotImplementedErrorrs r _single_framezAnalysisBase._single_frames""EFFFrcdS)a Set things up before the analysis loop begins. Notes ----- ``self.results`` is initialized already in :meth:`self.__init__` with an empty instance of :class:`MDAnalysis.analysis.results.Results` object. You can still call your attributes as if they were usual ones, ``Results`` just keeps track of that to be able to run a proper aggregation after a parallel run, if necessary. Nrrs r_preparezAnalysisBase._prepares  rcdS)aFinalize the results you've gathered. Called at the end of the :meth:`run` method to finish everything up. Notes ----- Aggregation of results from individual workers happens in :meth:`self.run()`, so here you have to implement everything as if you had a non-parallel run. If you want to enable proper aggregation for parallel runs for you analysis class, implement ``self._get_aggregator`` and check :mod:`MDAnalysis.analysis.results` for how to use it. Nrrs r _concludezAnalysisBase._concludes  r)progressbar_kwargsindexed_framesr&c8|i}td|t|ddn|}|dddf}td|||t |dkr|St t|jfd |i|D]E\}}||_ ||_ |j |j |<|j |j|<|Ftd |S) aPerform the calculation on a balanced slice of frames that have been setup prior to that using _setup_computation_groups() Parameters ---------- indexed_frames : np.ndarray np.ndarray of (n, 2) shape, where first column is frame iteration indices and second is frame numbers verbose : bool, optional Turn on verbosity progressbar_kwargs : dict, optional ProgressBar keywords with custom parameters regarding progress bar position, etc; see :class:`MDAnalysis.lib.log.ProgressBar` for full list. .. versionadded:: 2.8.0 NzChoosing frames to analyzer#Fr zStarting preparation)r:rr&z Finishing up)loggerinfogetattrrFrMr@ enumerater r? _frame_index_tsframer9timerErK)rrQr&rPr9idxtss r_computezAnalysisBase._computes@6  %!#  011118GD*e , , ,W  1% *+++ ''v'666  v;;!  K '  18 .fs&@@SSD[@@@@@@rr0c3@K|]}t|tVdSr!) isinstanceboolr-objs rr/z9AnalysisBase._setup_computation_groups..ks,<<z#t$$<<<<< $ 0 D DtT!! E4)E466KK@@UD$,?@@@@@ !MNN N K << <<< < < .Ys;//00F -KI Ys;'' ( (+ 6     ! !Q & &HV284445 5 " # #g - -+,,G M2G222    ~/999rbackend n_workersunsupported_backendctttd||}fd|D}|js |turt d|j|s%|jr||vrt d|d|j|tur2td|j j Drt dt|tr ||St|tr8|6t|d r&|j|krt d |jd |d t|trt|dst d|d|S)aMatches a passed backend string value with class attributes :attr:`parallelizable` and :meth:`get_supported_backends()` to check if downstream calculations can be performed. Parameters ---------- backend : Union[str, BackendBase] backend to be used: - ``str`` is matched to a builtin backend (one of "serial", "multiprocessing" and "dask") - ``BackendBase`` subclass is checked for the presence of an :meth:`apply` method n_workers : int positive integer with number of workers (processes, in case of built-in backends) to split the work between unsupported_backend : bool, optional if you want to run your custom backend on a parallelizable class that has not been tested by developers, by default ``False`` Returns ------- BackendBase instance of a ``BackendBase`` class that will be used for computations Raises ------ ValueError if :attr:`parallelizable` is set to ``False`` but backend is not ``serial`` ValueError if :attr:`parallelizable` is ``True`` and custom backend instance is used without specifying ``unsupported_backend=True`` ValueError if your trajectory has associated parallelizable transformations but backend is not serial ValueError if ``n_workers`` was specified twice -- in the run() method and durin ``__init__`` of a custom backend ValueError if your backend object instance doesn't have an ``apply`` method .. versionadded:: 2.8.0 rmultiprocessingdaskc:g|]}|Sr)get)r-bbuiltin_backendss r z3AnalysisBase._configure_backend..s5% % % ()   # #% % % rzCan not parallelize class zQMust specify 'unsupported_backend=True'if you want to use a custom backend_class=z for c3&K|] }|j V dSr!)r)r-ts rr/z2AnalysisBase._configure_backend..s96 6 %& 6 6 6 6 6 6 rzFTrajectory should not have associated unparallelizable transformations)rrNrrz0n_workers specified twice: in backend.n_workers=zand in run(n_workers=z). Remove it from run()applyzbackend=zc is invalid: should have 'apply' method and be instance of MDAnalysis.analysis.backends.BackendBase)r r r ryrrr2 __class__anyr"transformationsrbstrrhasattrrr)rrqrrrs backend_classsupported_backend_classesr{s @r_configure_backendzAnalysisBase._configure_backendsJf$5   ),,Wg>> % % % % -1-H-H-J-J% % % ! " L}M'I'IJ$.JJKK K$ # %>>>Y3@YYHLYY   - -#6 6 *.*:*J6 6 6 3 3 -B  gs # # 6 =9555 5 w , , %--&!Y..FW5FFF"+FFF ';// w W8 8  RwRRR  r)rsrPc ~|dn|}| in| } | s|r*|dks$t|tstd|.t|trt |dr|jnd}||n|}|||| } t | dr*|| jkrtjd| jd|t|j | | } | |j |||| | ||||| } | | | }tjd |D|_tjd |D|_d|D}|}|||_||S)a Perform the calculation Parameters ---------- start : int, optional start frame of analysis stop : int, optional stop frame of analysis step : int, optional number of frames to skip between each analysed frame frames : array_like, optional array of integers or booleans to slice trajectory; ``frames`` can only be used *instead* of ``start``, ``stop``, and ``step``. Setting *both* ``frames`` and at least one of ``start``, ``stop``, ``step`` to a non-default value will raise a :exc:`ValueError`. .. versionadded:: 2.2.0 verbose : bool, optional Turn on verbosity progressbar_kwargs : dict, optional ProgressBar keywords with custom parameters regarding progress bar position, etc; see :class:`MDAnalysis.lib.log.ProgressBar` for full list. Available only for ``backend='serial'`` backend : Union[str, BackendBase], optional By default, performs calculations in a serial fashion. Otherwise, user can choose a backend: ``str`` is matched to a builtin backend (one of ``serial``, ``multiprocessing`` and ``dask``), or a :class:`MDAnalysis.analysis.results.BackendBase` subclass. .. versionadded:: 2.8.0 n_workers : int positive integer with number of workers (processes, in case of built-in backends) to split the work between .. versionadded:: 2.8.0 n_parts : int, optional number of parts to split computations across. Can be more than number of workers. .. versionadded:: 2.8.0 unsupported_backend : bool, optional if you want to run your custom backend on a parallelizable class that has not been tested by developers, by default False .. versionadded:: 2.8.0 .. versionchanged:: 2.2.0 Added ability to analyze arbitrary frames by passing a list of frame indices in the `frames` keyword argument. .. versionchanged:: 2.5.0 Add `progressbar_kwargs` parameter, allowing to modify description, position etc of tqdm progressbars .. versionchanged:: 2.8.0 Introduced ``backend``, ``n_workers``, ``n_parts`` and ``unsupported_backend`` keywords, and refactored the method logic to support parallelizable execution. Nrz3Can not display progressbar with non-serial backendrrr )rqrrrsz;Analysis not making use of all workers: executor.n_workers=z is greater than n_parts=)rPr&)r%r5r6r7r9)r5r6r7r9r^cg|] }|j Sr)r9rds rr|z$AnalysisBase.run..s F F F F F Frcg|] }|j Sr)rErds rr|z$AnalysisBase.run..sDDDc DDDrcg|] }|j Sr)r$rds rr|z$AnalysisBase.run..s@@@##+@@@r)rbr r2rrrrrrkrlrr]rHr"rprrBhstackr9rE_get_aggregatormerger$rO)rr5r6r7r9r&rrr^rqrsrPexecutor worker_funccomputation_groupsremote_objectsremote_resultsresults_aggregators rrunzAnalysisBase.runs`Z&o((7%,BB2D   '  x  :g}#E#E E   g{33G[11!!  '))G** 3+   Hk * * /69K/K/K MH)HH=DHH    M1   '    ";;dfg<  08~~ +0 0 i F F~ F F FGG YDD^DDDEE A@@@@!1133)//??   rc"tdS)zReturns a default aggregator that takes entire results if there is a single object, and raises ValueError otherwise Returns ------- ResultsGroup aggregating object .. versionadded:: 2.8.0 N)lookup)rrs rrzAnalysisBase._get_aggregators4((((r)F)NNNNr!)NNNNNNNN) __name__ __module__ __qualname____doc__ classmethodrrpropertyrr(rr4rBndarrayr;rFrHrKrMrOrcr]rDlistrprrrrrrrrrrrrsrrh[:-2) ::X:2!!!! DH// ubj !////b-ubj7H1I----&DH.0.0.0.0` G G G        $6  666 66  6666v+/ F:F:F:F: F:  F: eRZ'( F: bj F:F:F:F:X%* vvsK'(vv" v  vvvvt+/W%*WWWWW W  W  WWWsK'(W"WWWWr ) ) ) ) ) ) )rrcVeZdZdZdZedZd fd ZdZdZ dZ d Z xZ S) AnalysisFromFunctionaCreate an :class:`AnalysisBase` from a function working on AtomGroups Parameters ---------- function : callable function to evaluate at each frame trajectory : MDAnalysis.coordinates.Reader, optional trajectory to iterate over. If ``None`` the first AtomGroup found in args and kwargs is used as a source for the trajectory. *args : list arguments for `function` **kwargs : dict arguments for `function` and :class:`AnalysisBase` Attributes ---------- results.frames : numpy.ndarray simulation frames used in analysis results.times : numpy.ndarray simulation times used in analysis results.timeseries : numpy.ndarray Results for each frame of the wrapped function, stored after call to :meth:`AnalysisFromFunction.run`. Raises ------ ValueError if `function` has the same `kwargs` as :class:`AnalysisBase` Example ------- .. code-block:: python def rotation_matrix(mobile, ref): return mda.analysis.align.rotation_matrix(mobile, ref)[0] rot = AnalysisFromFunction(rotation_matrix, trajectory, mobile, ref).run() print(rot.results.timeseries) .. versionchanged:: 1.0.0 Support for directly passing the `start`, `stop`, and `step` arguments has been removed. These should instead be passed to :meth:`AnalysisFromFunction.run`. .. versionchanged:: 2.0.0 Former :attr:`results` are now stored as :attr:`results.timeseries` .. versionchanged:: 2.8.0 Added :meth:`get_supported_backends()`, introducing 'serial', 'multiprocessing' and 'dask' backends. TcdS)Nrurrs rrz+AnalysisFromFunction.get_supported_backendss44rNc|'t|tjjs|f|z}d}|Mt j||D]%}t|tr|jj }n&|td||_ ||_ ||_ tt||dS)NzCouldn't find a trajectory)rbrbase ProtoReader itertoolschainvaluesruniverser%r2functionargsr'superrr()rrr%rr'argrs rr(zAnalysisFromFunction.__init__s  ":{'7'CDD #=4'DJ   tV]]__==  c9--!$!8JE  9:: :     "D))22:>>>>>rcg|j_dSr!)r$ timeseriesrs rrMzAnalysisFromFunction._prepares"$ rc8tdtjiS)Nr)rflatten_sequencers rrz$AnalysisFromFunction._get_aggregators\<+HIJJJrcn|jj|j|ji|jdSr!)r$rappendrrr'rs rrKz"AnalysisFromFunction._single_framesA && DM49 4 4 4     rc|j|j_|j|j_tj|jj|j_dSr!)r9r$rErBasarrayrrs rrOzAnalysisFromFunction._concludes9"k !Z "$*T\-D"E"E rr!) rrrrrrrr(rMrrKrO __classcell__)rs@rrrs44l-1)55[5??????0%%%KKK   FFFFFFFrrc6GfddtS)aPTransform a function operating on a single frame to an :class:`AnalysisBase` class. Parameters ---------- function : callable function to evaluate at each frame Attributes ---------- results.frames : numpy.ndarray simulation frames used in analysis results.times : numpy.ndarray simulation times used in analysis results.timeseries : numpy.ndarray Results for each frame of the wrapped function, stored after call to :meth:`AnalysisFromFunction.run`. Raises ------ ValueError if `function` has the same `kwargs` as :class:`AnalysisBase` Examples -------- For use in a library, we recommend the following style .. code-block:: python def rotation_matrix(mobile, ref): return mda.analysis.align.rotation_matrix(mobile, ref)[0] RotationMatrix = analysis_class(rotation_matrix) It can also be used as a decorator .. code-block:: python @analysis_class def RotationMatrix(mobile, ref): return mda.analysis.align.rotation_matrix(mobile, ref)[0] rot = RotationMatrix(u.trajectory, mobile, ref).run(step=2) print(rot.results.timeseries) .. versionchanged:: 2.0.0 Former :attr:`results` are now stored as :attr:`results.timeseries` c<eZdZdfd ZedZxZS)$analysis_class..WrapperClassNcHt|j|g|Ri|dSr!)rr()rr%rr' WrapperClassrrs rr(z-analysis_class..WrapperClass.__init__9sM .E, % % .* '+   /5     rcdS)N)rrwrrs rrz;analysis_class..WrapperClass.get_supported_backends>s%%rr!)rrrr(rrr)rrrs@rrr8sc          & &  & & & & &rr)r)rrs`@ranalysis_classrsGf&&&&&&&&+&&& rc tjtj}n.#t$r!tjtj}YnwxYwt |j}dt|j | d|jD} tj|}n$#t$rtj|}YnwxYw| D]@}||j vr5td || Ai}| D]\}} ||| ||<||fS)a Create two dictionaries with `kwargs` separated for `function` and :class:`AnalysisBase` Parameters ---------- function : callable function to be called kwargs : dict keyword argument dictionary Returns ------- base_args : dict dictionary of AnalysisBase kwargs kwargs : dict kwargs without AnalysisBase kwargs Raises ------ ValueError if `function` has the same `kwargs` as :class:`AnalysisBase` ci|]\}}|| Srr)r-namevals r z/_filter_baseanalysis_kwargs..fs. D# crNzIargument name '{}' clashes with AnalysisBase argument.Now allowed are: {})inspectgetfullargspecrr(AttributeError getargspecr@defaultsziprkeysr2formatitemspop) rr' base_argspecn_base_defaults base_kwargsargspecbase_kw base_argsargnamedefaults r_filter_baseanalysis_kwargsrEs2A-l.CDD AAA),*?@@ A,/00O  .// 0,2G  K/(22 ///$X../##%% gl " "&&,fWk6F6F6H6H&I&I  # I'--//::#ZZ99 ' f s!!(A  A B&&CC)"rrrloggingrk functoolsrtypingrrnumpyrBr core.groupsrlib.logr backendsr r r rr$rr getLoggerrrSobjectrrrrrrrrs.~~~""""""""######!!!!!! +*******  8 $ $o )o )o )o )o )6o )o )o )dcFcFcFcFcF<cFcFcFL===@:::::r