iedZddlZddlZddlZddlZddlZddlmZddl m Z dZ dZ dZ d ZGd d ejZdS) aK========================================================================= Reading trajectories from memory --- :mod:`MDAnalysis.coordinates.memory` ========================================================================= :Author: Wouter Boomsma :Year: 2016 :Copyright: Lesser GNU Public License v2.1+ :Maintainer: Wouter Boomsma , wouterboomsma on github .. versionadded:: 0.16.0 The module contains a trajectory reader that operates on an array in memory, rather than reading from file. This makes it possible to operate on raw coordinates using existing MDAnalysis tools. In addition, it allows the user to make changes to the coordinates in a trajectory (e.g. through :attr:`MDAnalysis.core.groups.AtomGroup.positions`) without having to write the entire state to file. How to use the :class:`MemoryReader` ==================================== The :class:`MemoryReader` can be used to either directly generate a trajectory as a numpy array or by transferring an existing trajectory to memory. In-memory representation of arbitrary trajectories ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ If sufficient memory is available to hold a whole trajectory in memory then analysis can be sped up substantially by transferring the trajectory to memory. The most straightforward use of the :class:`MemoryReader` is to simply use the ``in_memory=True`` flag for the :class:`~MDAnalysis.core.universe.Universe` class, which automatically transfers a trajectory to memory:: import MDAnalysis as mda from MDAnalysisTests.datafiles import TPR, XTC universe = mda.Universe(TPR, XTC, in_memory=True) Of course, sufficient memory has to be available to hold the whole trajectory. Switching a trajectory to an in-memory representation ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The decision to transfer the trajectory to memory can be made at any time with the :meth:`~MDAnalysis.core.universe.Universe.transfer_to_memory` method of a :class:`~MDAnalysis.core.universe.Universe`:: universe = mda.Universe(TPR, XTC) universe.transfer_to_memory() This operation may take a while (with `verbose=True` a progress bar is displayed) but then subsequent operations on the trajectory directly operate on the in-memory array and will be very fast. Constructing a Reader from a numpy array ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The :class:`MemoryReader` provides great flexibility because it becomes possible to create a :class:`~MDAnalysis.core.universe.Universe` directly from a numpy array. A simple example consists of a new universe created from the array extracted from a DCD :meth:`~MDAnalysis.coordinates.DCD.DCDReader.timeseries`:: import MDAnalysis as mda from MDAnalysisTests.datafiles import DCD, PSF from MDAnalysis.coordinates.memory import MemoryReader universe = mda.Universe(PSF, DCD) coordinates = universe.trajectory.timeseries(universe.atoms) universe2 = mda.Universe(PSF, coordinates, format=MemoryReader, order='afc') .. _create-in-memory-trajectory-with-AnalysisFromFunction: .. rubric:: Creating an in-memory trajectory with :func:`~MDAnalysis.analysis.base.AnalysisFromFunction` The :meth:`~MDAnalysis.coordinates.DCD.DCDReader.timeseries` is currently only implemented for the :class:`~MDAnalysis.coordinates.DCD.DCDReader`. However, the :func:`MDAnalysis.analysis.base.AnalysisFromFunction` can provide the same functionality for any supported trajectory format:: import MDAnalysis as mda from MDAnalysis.tests.datafiles import PDB, XTC from MDAnalysis.coordinates.memory import MemoryReader from MDAnalysis.analysis.base import AnalysisFromFunction u = mda.Universe(PDB, XTC) coordinates = AnalysisFromFunction(lambda ag: ag.positions.copy(), u.atoms).run().results['timeseries'] u2 = mda.Universe(PDB, coordinates, format=MemoryReader) .. _creating-in-memory-trajectory-label: Creating an in-memory trajectory of a sub-system ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Creating a trajectory for just a selection of an existing trajectory requires the transfer of the appropriate coordinates as well as creation of a topology of the sub-system. For the latter one can use the :func:`~MDAnalysis.core.universe.Merge` function, for the former the :meth:`~MDAnalysis.core.universe.Universe.load_new` method of a :class:`~MDAnalysis.core.universe.Universe` together with the :class:`MemoryReader`. In the following, an in-memory trajectory of only the protein is created:: import MDAnalysis as mda from MDAnalysis.tests.datafiles import PDB, XTC from MDAnalysis.coordinates.memory import MemoryReader from MDAnalysis.analysis.base import AnalysisFromFunction u = mda.Universe(PDB, XTC) protein = u.select_atoms("protein") coordinates = AnalysisFromFunction(lambda ag: ag.positions.copy(), protein).run().results['timeseries'] u2 = mda.Merge(protein) # create the protein-only Universe u2.load_new(coordinates, format=MemoryReader) The protein coordinates are extracted into ``coordinates`` and then the in-memory trajectory is loaded from these coordinates. In principle, this could have all be done in one line:: u2 = mda.Merge(protein).load_new( AnalysisFromFunction(lambda ag: ag.positions.copy(), protein).run().results['timeseries'], format=MemoryReader) The new :class:`~MDAnalysis.core.universe.Universe` ``u2`` can be used to, for instance, write out a new trajectory or perform fast analysis on the sub-system. Classes ======= .. autoclass:: MemoryReader :members: :inherited-members: N)base)Timestepc"d|_||_dS)aReplace the array of positions Replaces the array of positions by another array. Note ---- The behavior of :meth:`_replace_positions_array` is different from the behavior of the :attr:`position` property that replaces the **content** of the array. The :meth:`_replace_positions_array` method should only be used to set the positions to a different frame in :meth:`MemoryReader._read_next_timestep`; there, the memory reader sets the positions to a view of the correct frame. Modifying the positions for a given frame should be done with the :attr:`positions` attribute that does not break the link between the array of positions in the time step and the :attr:`MemoryReader.coordinate_array`. .. versionadded:: 0.19.0 .. versionchanged:: 2.0.0 This function, and the _repalace helper functions for velocities, forces, and dimensions, have been moved out of the now removed custom timestep object for :class:`MemoryReader`. TN) has_positions_postsnews g/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/MDAnalysis/coordinates/memory.py_replace_positions_arrayr s2BBGGGc"d|_||_dSNT)has_velocities _velocitiesr s r _replace_velocities_arrayrsBBNNNrc"d|_||_dSr) has_forces_forcesr s r _replace_forces_arrayrsBMBJJJrc||_dSN) _unitcellr s r _replace_dimensionsrs BLLLrceZdZdZdZ dfd ZedZeddZd Z dd Z d Z d Z ddZ ddZdZdZfdZdZxZS) MemoryReadera MemoryReader works with trajectories represented as numpy arrays. A trajectory reader interface to a numpy array of the coordinates. For compatibility with the timeseries interface, support is provided for specifying the order of columns through the `order` keyword. .. versionadded:: 0.16.0 .. versionchanged:: 1.0.0 Support for the deprecated `format` keyword for :meth:`MemoryReader.timeseries` has now been removed. MEMORYfacNrc tt|||_||_||_ |jdkr*|jddkr|tj ddddf}n #t$rd} t| dwxYw| |||j j|jd|_|j j|jd|_| tj|tj}n0#t&$r#d t)|} t| dwxYw|jdkr|tj ddddf}|j|j jks2t'd |j|j j|tjd |_nd|_| tj|tj}n0#t&$r#d t)|} t| dwxYw|jdkr|tj ddddf}|j|j jks2t'd|j|j j|tjd |_nd|_|dd} | 3| |jkr(t'd| |j|j|jfi||_||j_|-tj|jdftj|_n tj|tj}n0#t&$r#dt)|} t| dwxYw|jdkrtj||jdf}n9|j|jdfkr't'd|j||_d|j_ d|j_!|"dS)u Parameters ---------- coordinate_array : numpy.ndarray The underlying array of coordinates. The MemoryReader now necessarily requires a np.ndarray order : {"afc", "acf", "caf", "fac", "fca", "cfa"} (optional) the order/shape of the return data array, corresponding to (a)tom, (f)rame, (c)oordinates all six combinations of 'a', 'f', 'c' are allowed ie "fac" - return array where the shape is (frame, number of atoms, coordinates). dimensions: [A, B, C, alpha, beta, gamma] (optional) unitcell dimensions (*A*, *B*, *C*, *alpha*, *beta*, *gamma*) lengths *A*, *B*, *C* are in the MDAnalysis length unit (Å), and angles are in degrees. An array of dimensions can be given, which must then be shape (nframes, 6) dt: float (optional) The time difference between frames (ps). If :attr:`time` is set, then `dt` will be ignored. filename: string (optional) The name of the file from which this instance is created. Set to ``None`` when created from an array velocities : numpy.ndarray (optional) Atom velocities. Must match shape of coordinate_array. Will share order with coordinates. forces : numpy.ndarray (optional) Atom forces. Must match shape of coordinate_array Will share order with coordinates Raises ------ TypeError if the coordinate array passed is not a np.ndarray Note ---- At the moment, only a fixed `dimension` is supported, i.e., the same unit cell for all frames in `coordinate_array`. See issue `#1041`_. .. _`#1041`: https://github.com/MDAnalysis/mdanalysis/issues/1041 .. versionchanged:: 0.19.0 The input to the MemoryReader now must be a np.ndarray Added optional velocities and forces .. versionchanged:: 2.2.0 Input kwargs are now stored under the :attr:`_kwargs` attribute, and are passed on class creation in :meth:`copy`. rNzdThe input has to be a numpy.ndarray that corresponds to the layout specified by the 'order' keyword.fa)dtypez$'velocities' must be array-like got z5Velocities has wrong shape {} to match coordinates {}Fcopyz 'forces' must be array like got z1Forces has wrong shape {} to match coordinates {}n_atomszYThe provided value for n_atoms ({}) does not match the shape of the coordinate array ({})z$'dimensions' must be array-like got )r)z[Provided dimensions array has shape {}. This must be a array of shape (6,) or (n_frames, 6))#superr__init__filename stored_order_kwargsndimshapenpnewaxisAttributeError TypeError set_arraycoordinate_arrayfindn_framesr(asarrayfloat32 ValueErrortypeformatastypevelocity_array force_arraypop _Timestepr dtzerosdimensions_arraytileframetime_read_next_timestep) selfr7order dimensionsrDr- velocitiesforceskwargserrmsgprovided_n_atoms __class__s r r,zMemoryReader.__init__sz lD!!**,,,  !  .$)).>.DQ.G1.L.L#3BJ1114D#E  . . .B F## -  . '///-3   " "3 ' '  ,243D3I3I#3N3NO  ! 2Z "*EEE  2 2 2*J''** ''T1  2!##' AAAqqq(89 #t'<'BBB vj.0E0KLL #-"3"3BJU"3"K"KD  "&D    2F"*=== 2 2 2JDLLJJ''T1 2{a AAAqqq 01<4#8#>>> vflD,A,GHH &}}RZe}DDD  #D !::i66  ',< ,L,L#V$4dlCC  !$.8888  $&H""*%%%D ! ! 2Z "*EEE  2 2 2*J''** ''T1  2 4'' WZ$-1CDD !dmQ%777 $$*F:+;$<$< %/D !     """""s/5A55B D---E9 H-I N##-Oc6t|tjS)zhFor internal use: Check if MemoryReader can operate on *thing* .. versionadded:: 1.0.0 ) isinstancer2ndarray)things r _format_hintzMemoryReader._format_hints %,,,rc B|j|dS)azDeduce number of atoms in a given array of coordinates Parameters ---------- filename : numpy.ndarray data which will be used later in MemoryReader order : {"afc", "acf", "caf", "fac", "fca", "cfa"} (optional) the order/shape of the return data array, corresponding to (a)tom, (f)rame, (c)oordinates all six combinations of 'a', 'f', 'c' are allowed ie "fac" - return array where the shape is (frame, number of atoms, coordinates). Returns ------- n_atoms : int number of atoms in system r$)r1r8)r-rLrPs r parse_n_atomszMemoryReader.parse_n_atomss*~ejjoo..rc |j|jnd}|j|jnd}|j}|j|jf|j||||jj|j d|j }||jj |j D]-\}}|||.|j|_|S)z#Return a copy of this Memory ReaderN)rLrMrNrOrDr-)r@r'rArFrSr7r.r rDr-r/rH_auxsitems add_auxiliarytransformations)rKvelsforsdimsr auxnameauxreads r r'zMemoryReader.copys$".   $ $ & & & (,'7'CD  ! ! # # # $))++dn  ! & & ( (  #wz]   l    DGM $ 0 0 2 2 7 7 GW   gw||~~ 6 6 6 6#2 rcL|dd|_||_dS)a0 Set underlying array in desired column order. Parameters ---------- coordinate_array : :class:`~numpy.ndarray` object The underlying array of coordinates order : {"afc", "acf", "caf", "fac", "fca", "cfa"} (optional) the order/shape of the return data array, corresponding to (a)tom, (f)rame, (c)oordinates all six combinations of 'a', 'f', 'c' are allowed ie "fac" - return array where the shape is (frame, number of atoms, coordinates). r;Fr&N)r?r7 stored_format)rKr7rLs r r6zMemoryReader.set_arrays- !1 7 7  7 N N"rc|jS)z* Return underlying array. )r7rKs r get_arrayzMemoryReader.get_arrays $$rc6d|j_d|j_dS)zReset iteration to first framer*N)r rHrIrhs r _reopenzMemoryReader._reopens  rrr*afcc|.tjdt|rtd|}|dkrtjdt|}||jkrn|d|jdkrt j|dd }n|d|jdkrt j|dd }n|d |jd krt j|dd}n|d|jdkr-t j|dd}t j|dd }nC|d|jd kr,t j|d d}t j|dd }|d }|d } |dz} | dkrd} tdg| zt|| |gztdgd | z zz} |t| }|||j j ur|St|dkrtd ||j|S) aReturn a subset of coordinate data for an AtomGroup in desired column order. If no selection is given, it will return a view of the underlying array, while a copy is returned otherwise. Parameters --------- asel : AtomGroup (optional) Atom selection. Defaults to ``None``, in which case the full set of coordinate data is returned. Note that in this case, a view of the underlying numpy array is returned, while a copy of the data is returned whenever `asel` is different from ``None``. .. deprecated:: 2.7.0 asel argument will be renamed to atomgroup in 3.0.0 atomgroup: AtomGroup (optional) Same as `asel`, will replace `asel` in 3.0.0 start : int (optional) the start trajectory frame stop : int (optional) the end trajectory frame .. deprecated:: 2.4.0 Note that `stop` is currently *inclusive* but will be changed in favour of being *exclusive* in version 3.0. step : int (optional) the number of trajectory frames to skip order : {"afc", "acf", "caf", "fac", "fca", "cfa"} (optional) the order/shape of the return data array, corresponding to (a)tom, (f)rame, (c)oordinates all six combinations of 'a', 'f', 'c' are allowed ie "fac" - return array where the shape is (frame, number of atoms, coordinates). .. versionchanged:: 1.0.0 Deprecated `format` keyword has been removed. Use `order` instead. .. versionchanged:: 2.4.0 ValueError now raised instead of NoDataError for empty input AtomGroup NzKasel argument to timeseries will be renamed to'atomgroup' in 3.0, see #3911)categoryz-Cannot provide both asel and atomgroup kwargsr*zhMemoryReader.timeseries inclusive `stop` indexing will be removed in 3.0 in favour of exclusive indexingrrr!r$r#z0Timeseries requires at least one atom to analyze)warningswarnDeprecationWarningr<rir.r2swapaxesr8slicetupleuniverseatomslentakeindices) rKasel atomgroupstartstopsteprLarraya_indexf_index stop_index basic_slices r timeserieszMemoryReader.timeseriessZ   M0+       CI 2:: M,        D% % %  1X*1- - -Kq!,,EE 1X*1- - -Kq!,,EE 1X*1- - -Kq!,,EE 1X*1- - -Kq!,,EKq!,,EE 1X*1- - -Kq!,,EKq!,,E**S//**S//AX ??J 4[[MG #UJ--. /T{{mq7{+ , eK(()   Y-?-E E EL9~~"" I::dlG44 4rc|jj|jdz krttjd||j}|xjdz c_|jd}tdg|z|jjgztdgd|z zz}t||j t|t||j |jj|j(t||jt||j(t#||jt||jj|jz|_|S)zcopy next frame into timesteprz"trying to go over trajectory limitNr#r!)r rHr9IOErrorerrnoEIOr.r8rsr r7rtrrFr@rrArrDrI)rKr rrs r rJz MemoryReader._read_next_timestepjsJ 7=DMA- - -%)%IJJ J :B A #((-- 4[[MW %w}o T{{mq7{+ ,  !T%:5;M;M%NOOOB 5dgm DEEE   * %D'k(:(:;      ' !"d&6u[7I7I&J K K K'-$') rcH|dz |j_|S)z read frame ir)r rHrJ)rKis r _read_framezMemoryReader._read_frames#A '')))rcZd|jj|j|jS)zString representationz/<{cls} with {nframes} frames of {natoms} atoms>)clsnframesnatoms)r>rS__name__r9r(rhs r __repr__zMemoryReader.__repr__s2CJJ'M<K   rctt|j|t|D]\}}|jD] }||}dS)a$Add all transformations to be applied to the trajectory. This function take as list of transformations as an argument. These transformations are functions that will be called by the Reader and given a :class:`Timestep` object as argument, which will be transformed and returned to the Reader. The transformations can be part of the :mod:`~MDAnalysis.transformations` module, or created by the user, and are stored as a list `transformations`. This list can only be modified once, and further calls of this function will raise an exception. .. code-block:: python u = MDAnalysis.Universe(topology, coordinates) workflow = [some_transform, another_transform, this_transform] u.trajectory.add_transformations(*workflow) Parameters ---------- transform_list : list list of all the transformations that will be applied to the coordinates See Also -------- :mod:`MDAnalysis.transformations` N)r+radd_transformations enumerater_)rKr_rr transformrSs r rz MemoryReader.add_transformationssi@ 6lD!!5GGt__ # #EAr!1 # # Yr]] # # #rc|S)z,Applies the transformations to the timestep.)rKr s r _apply_transformationsz#MemoryReader._apply_transformationss  r)rNrNNN)r)NNrr*rrlr)r __module__ __qualname____doc__r>r, staticmethodrXrZr'r6rirkrrJrrrr __classcell__)rSs@r rrsa  F  c#c#c#c#c#c#J--\-///\/,@####&%%%  JOh5h5h5h5T4***    ##########Jrr)rloggingrnumpyr2ror'rtimesteprr rrr ProtoReaderrrrr rs.``B  :  NNNNN4#NNNNNr