iLbdZddlmZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZmZddlmZddlmZmZmZmZmZddlmZdd lmZdd lmZd d lmZmZdd lmZ d dl m!Z!ddl"m#Z#d dl m$Z$d dl%m&Z&m'Z'dZ(dZ)dZ*dZ+Gdde,Z-Gdde,Z.Gdde,Z/dZ0dZ1dZ2Gdd e.Z3Gd!d"e3Z4Gd#d$e3Z5Gd%d&e3Z6ej7Gd'd(e.Z8Gd)d*e8Z9Gd+d,e8Z:Gd-d.e8Z;hd/Z<Gd0d1e4Z=ed2gd3Z>e>d4e9e4Z?e>d5e:e5Z@e>d6e;e6ZAe?e9_Be?e4_Be@e:_Be@e5_BeAe;_BeAe6_Bd7ZCdS)8a========================================================== Core objects: Containers --- :mod:`MDAnalysis.core.groups` ========================================================== The :class:`~MDAnalysis.core.universe.Universe` instance contains all the particles in the system (which MDAnalysis calls :class:`Atom`). Groups of :class:`atoms` are handled as :class:`AtomGroup` instances. The :class:`AtomGroup` is probably the most important object in MDAnalysis because virtually everything can be accessed through it. :class:`AtomGroup` instances can be easily created (e.g., from an :meth:`AtomGroup.select_atoms` selection or simply by slicing). For convenience, chemically meaningful groups of :class:`Atoms` such as a :class:`Residue` or a :class:`Segment` (typically a whole molecule or all of the solvent) also exist as containers, as well as groups of these units (:class:`ResidueGroup`, :class:`SegmentGroup`). Classes ======= Collections ----------- .. autoclass:: AtomGroup :members: :inherited-members: .. autoclass:: ResidueGroup :members: :inherited-members: .. autoclass:: SegmentGroup :members: :inherited-members: .. autoclass:: UpdatingAtomGroup :members: Chemical units -------------- .. autoclass:: Atom :members: :inherited-members: .. autoclass:: Residue :members: :inherited-members: .. autoclass:: Segment :members: :inherited-members: Levels ------ Each of the above classes has a *level* attribute. This can be used to verify that two objects are of the same level, or to access a particular class .. code-block:: python u = mda.Universe() ag = u.atoms[:10] at = u.atoms[11] ag.level == at.level # Returns True ag.level.singular # Returns Atom class at.level.plural # Returns AtomGroup class ) namedtupleN) _CONVERTERS_TOPOLOGY_ATTRS_TOPOLOGY_TRANSPLANTS_TOPOLOGY_ATTRNAMES)util)cachedwarn_if_not_unique unique_int_1dunique_int_1d_unsortedint_array_is_sorted) distances)transformations)mdamath)AccessorConverterWrapper) get_writer) selection) NoDataError)topologyobjects)get_writer_forget_converter_forc|j|SN)atoms)uixs `/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/MDAnalysis/core/groups.py _unpickler!s 72;c|||Sr)rrclss r _unpickle2r&s 3r1::r"c^|d|ddd}}||}t|||S)Nrr)UpdatingAtomGroup) basepickle selectionsselstrsbfuncbargs basegroups r _unpickle_uagr/s9a=*QRR."35Eu I Y G < <r"czeZdZdZedZedZedZedZfdZ xZ S)r8aClass factory for receiving sets of :class:`TopologyAttr` objects. :class:`_TopologyAttrContainer` is a convenience class to encapsulate the functions that deal with: * the import and namespace transplant of :class:`~MDAnalysis.core.topologyattrs.TopologyAttr` objects; * the copying (subclassing) of itself to create distinct bases for the different container classes (:class:`AtomGroup`, :class:`ResidueGroup`, :class:`SegmentGroup`, :class:`Atom`, :class:`Residue`, :class:`Segment`, and subclasses thereof); * the mixing (subclassing and co-inheritance) with the container classes. The mixed subclasses become the final container classes specific to each :class:`~MDAnalysis.core.universe.Universe`. c|t|j|fdt|i}|r hd|_n hd|_|S)aFactory method returning :class:`_TopologyAttrContainer` subclasses. Parameters ---------- is_group : bool The :attr:`_is_group` of the returned class will be set to `is_group`. This is used to distinguish between Groups (:class:`AtomGroup` etc.) and Components (:class:`Atom` etc.) in internal methods when considering actions such as addition of objects or adding :class:`TopologyAttributes` to them. Returns ------- type A subclass of :class:`_TopologyAttrContainer`, with the same name. _is_group> rforcesresiduesegmentresiduessegments positions dimensions velocities>rforcerHrIpositionrJvelocityrM)type__name__bool_SETATTR_WHITELIST)r%r1newclss r r9z _TopologyAttrContainer._subclasss^(clSF[$x..,IJJ   ) ) )F % % ) ) )F % r"cPt|jt||fi}||_|S)aCreates a subclass with ourselves and another class as parents. Classes mixed at this point override :meth:`__new__`, causing further instantiations to shortcut to :meth:`~object.__new__` (skipping the cache-fetch process for :class:`_MutableBase` subclasses). The new class will have an attribute `_derived_class` added, pointing to itself. This pointer instructs which class to use when slicing/adding instances of the new class. At initialization time, the new class may choose to point `_derived_class` to another class (as is done in the initialization of :class:`UpdatingAtomGroup`). Parameters ---------- other : type The class to mix with ourselves. Returns ------- type A class of parents :class:`_ImmutableBase`, *other* and this class. Its name is the same as *other*'s. )rRrS_ImmutableBase_derived_class)r%otherrVs r r<z_TopologyAttrContainer._mixs+2en~sE&BBGG & r"c Vfd}fd}|jrLt|jt||dj|jjdSt|jt||dj|jjdS)zAdd `attr` into the namespace for this class Parameters ---------- attr : A :class:`TopologyAttr` object c.|Sr) __getitem__)selfattrs r getterz0_TopologyAttrContainer._add_prop..getters##D)) )r"c0||Sr) __setitem__)r^valuesr_s r setterz0_TopologyAttrContainer._add_prop..setters##D&11 1r"N) rFsetattrattrnamepropertygroupdocrUaddsingular singledoc)r%r_r`rds ` r _add_propz _TopologyAttrContainer._add_prop s * * * * * 2 2 2 2 2 = 6  t}==     " & &t} 5 5 5 5 5  t~>>     " & &t} 5 5 5 5 5r"ctjt5t||jdddn #1swxYwYtjt5t||jdddn #1swxYwY|j|j|j|jdS)zRemove `attr` from the namespace for this class. Parameters ---------- attr : A :class:`TopologyAttr` object N) contextlibsuppressAttributeErrordelattrrfrjrUdiscard)r%r_s r _del_propz _TopologyAttrContainer._del_prop*s.  0 0 ( ( C ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( (   0 0 ( ( C ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( &&t}555 &&t}55555s!<AA BB Bc |dsD||jvs;t||s+td|jrdndt t|||dS)N_z'Cannot set arbitrary attributes to a {}Group Component) startswithrUhasattrrpformatrFsuperr8 __setattr__)r^r_value __class__s r r|z"_TopologyAttrContainer.__setattr__:s OOC  t...tT""/!9@@#~>GG;  $d++77eDDDDDr") rS __module__ __qualname____doc__ classmethodr9r<rlrsr| __classcell__r~s@r r8r8s  ,,[,\[866[6: 6 6[ 6EEEEEEEEEr"r8c&eZdZdZdZdZddZdS) _MutableBasea Base class that merges appropriate :class:`_TopologyAttrContainer` classes. Implements :meth:`__new__`. In it the instantiating class is fetched from :attr:`~MDAnalysis.core.universe.Universe._classes`. If there is a cache miss, a merged class is made with a base from :attr:`~MDAnalysis.core.universe.Universe._class_bases` and cached. The classes themselves are used as the cache dictionary keys for simplcity in cache retrieval. c  |djn#ttf$r |ddjn#tttf$rpddlm}|t |zD](}t||ttfr |jn)d|j }t|dYnwxYwYnwxYw t j |S#t$r tfd|D}n\#t"$rOd|j dt%t'j}t|dwxYw||x}j |<t |cYSwxYw) Nrr)UniversezKNo universe, or universe-containing object passed to the initialization of c3DK|]}|jv j|VdSr) _class_bases).0parentrs r z'_MutableBase.__new__..zsC""//N6*////""r"z Attempted to instantiate class 'z\' but none of its parents are known to the universe. Currently possible parent classes are: )universe IndexErrorrp TypeErrorrtuplerc isinstancer:r;rSobject__new___classesKeyErrornextmro StopIterationstrsortedrkeysr<) r%argskwargsrargerrmsg parent_clsrVrs @r rz_MutableBase.__new__Zs.  6R!AAN+ 6 6 6 6GAJ'z>: 6 6 6......  % "8"88 6 6C!#)]'KLLL J;><JJ$F++5  6  6( *>>!*S/22 2 * * * 2!"""""%''))""" ! 2 2 2>&)) ) ) )# *s[ C7CBB>;C=B>>CC$C-- F>8-D&%F>&AE??=F>ct|j}|tvrt|\}}}t|tr|}d}n|dz}d}t||sSt|trdnd}d} |j} | dkr|dz} t | ||| |d} t| ||| | d d } d || } | tvr&t| } | d| z } t | )Nrgz()methodz0{attr} is a {method} of {clstype}, not {selfcls}r:rv)r_rclstypeselfclsz;{selfcls}.{attrname} not available; this requires {topattr})rrftopattrruz#{selfcls} has no attribute {attr}. )rr_zDid you mean {match}?)match) rRrSrrrgrprzrlowerreplacer) r^r_rrmethrrfattrtypemnameerrclsnamecleanrs r __getattr__z_MutableBase.__getattr__st**% ( ( (%:4%@ "GT7$)) $%$;#dG,, &0x&@&@N hH!*k))%/G$JJ%' ' ' ."JJ '(GJJLL((b11E7>>d?C++++E2.55E5BBB %% %r"Tct|jj|}|s|S|r tjn tj} |jjn#t$r |jYnwxYwfd|jj D}||d}||S)a Get bonded connections between atoms as a :class:`~MDAnalysis.core.topologyobjects.TopologyGroup`. Parameters ---------- typename : str group name. One of {"bonds", "angles", "dihedrals", "impropers", "ureybradleys", "cmaps"} outside : bool (optional) Whether to include connections involving atoms outside this group. Returns ------- TopologyGroup containing the bonded group of choice, i.e. bonds, angles, dihedrals, impropers, ureybradleys or cmaps. .. versionadded:: 1.1.0 c:g|]}tj|Sr$)npisin)rcolindicess r z0_MutableBase.get_connections..s%???#W%%???r"raxis) getattrrrranyallix_arrayrp_bixT)r^typenameoutsideugroupfuncseenmaskrs @r get_connectionsz_MutableBase.get_connectionss.,h77 M ,rvvbf $j)GG $ $ $mGGG $???????tDq!!!d|s AAAN)T)rSrrrrrrr$r"r rrKsR  .*.*.*`/&/&/&b!!!!!!r"rc eZdZdZejZdS)rXzAClass used to shortcut :meth:`__new__` to :meth:`object.__new__`.N)rSrrrrrr$r"r rXrXsKK nGGGr"rXcFtjfd}|S)zFRaises deprecation warning if 'pbc' is set and assigns value to 'wrap'c|dd2tjdt|d|d<|g|Ri|S)NpbczbThe 'pbc' kwarg has been deprecated and will be removed in version 3.0., please use 'wrap' insteadwrap)getwarningswarnDeprecationWarningpopgrouprrfunctions r wrappedz_pbc_to_wrap..wrappedsl ::eT " " . M,#     $ZZ..F6Nx///////r" functoolswrapsrrs` r _pbc_to_wraprs:_X 0 0 0 0 0 Nr"cFtjfd}|S)z?Raises ValueError when both 'wrap' and 'unwrap' are set to Truec|dr$|drtd|g|Ri|S)Nrunwrapz/both 'wrap' and 'unwrap' can not be set to true)r ValueErrorrs r rz&check_wrap_and_unwrap..wrappeds[ ::f   P&**X"6"6 PNOO Ox///////r"rrs` r check_wrap_and_unwraprs:_X00000 Nr"cFtjfd}|S)Nc t|ttfsMtdjt |jt |j|j|jkr'tdj|j|jurtd||S)Nz1Can't perform '{}' between objects: '{}' and '{}'z-Can't perform '{}' on different level objectsz1Can't operate on objects from different Universes) rr;r:rrzrSrRlevelrr)r^rZrs r rz!_only_same_level..wrappeds%-!;<< !!'%JJ'KK(""  : $ $6(+,,  = . .C xe$$$r"rrs` r _only_same_levelrs8_X%%%%%* Nr"ceZdZdZdZdZdZdZfdZdZ dZ d Z d Z d Z ed Zd ZdZdZdZedZedZedZedZejdZeeddZeeddZeeddZeeddZdCdZd Z dDd!Z!e"e#e$dEd#Z%e"e#e$dEd$Z&e&Z'e"e(j)d"fd%Z*e#dDd&Z+e#dDd'Z,d(Z-d)Z.dFd+Z/dGd-Z0dHd/Z1dId2Z2dJd4Z3d5Z4d6Z5d7Z6ed8Z7ed9Z8ed:Z9ed;Z:ed<Z;ed=ZZ=ed?Z>d@Z?edAZ@dBZAxZBS)Kr:aBase class from which a :class:`<~MDAnalysis.core.universe.Universe`\ 's Group class is built. Instances of :class:`GroupBase` provide the following operations that conserve element repetitions and order: +-------------------------------+------------+----------------------------+ | Operation | Equivalent | Result | +===============================+============+============================+ | ``len(s)`` | | number of elements (atoms, | | | | residues or segment) in | | | | the group | +-------------------------------+------------+----------------------------+ | ``s == t`` | | test if ``s`` and ``t`` | | | | contain the same elements | | | | in the same order | +-------------------------------+------------+----------------------------+ | ``x in s`` | | test if component ``x`` is | | | | part of group ``s`` | +-------------------------------+------------+----------------------------+ | ``s.concatenate(t)`` | ``s + t`` | new Group with elements | | | | from ``s`` and from ``t`` | +-------------------------------+------------+----------------------------+ | ``s.subtract(t)`` | | new Group with elements | | | | from ``s`` that are not | | | | in ``t`` | +-------------------------------+------------+----------------------------+ The following operations treat the Group as set. Any result will have any duplicate entries removed and the Group will be sorted. +-------------------------------+------------+----------------------------+ | Operation | Equivalent | Result | +===============================+============+============================+ | ``s.isdisjoint(t)`` | | ``True`` if ``s`` and | | | | ``t`` do not share | | | | elements | +-------------------------------+------------+----------------------------+ | ``s.issubset(t)`` | | test if all elements of | | | | ``s`` are part of ``t`` | +-------------------------------+------------+----------------------------+ | ``s.is_strict_subset(t)`` | | test if all elements of | | | | ``s`` are part of ``t``, | | | | and ``s != t`` | +-------------------------------+------------+----------------------------+ | ``s.issuperset(t)`` | | test if all elements of | | | | ``t`` are part of ``s`` | +-------------------------------+------------+----------------------------+ | ``s.is_strict_superset(t)`` | | test if all elements of | | | | ``t`` are part of ``s``, | | | | and ``s != t`` | +-------------------------------+------------+----------------------------+ | ``s.union(t)`` | ``s | t`` | new Group with elements | | | | from both ``s`` and ``t`` | +-------------------------------+------------+----------------------------+ | ``s.intersection(t)`` | ``s & t`` | new Group with elements | | | | common to ``s`` and ``t`` | +-------------------------------+------------+----------------------------+ | ``s.difference(t)`` | ``s - t`` | new Group with elements of | | | | ``s`` that are not in ``t``| +-------------------------------+------------+----------------------------+ | ``s.symmetric_difference(t)`` | ``s ^ t`` | new Group with elements | | | | that are part of ``s`` or | | | | ``t`` but not both | +-------------------------------+------------+----------------------------+ c t|dkr&d|dD}|ddj}n|\}}n'#ttf$rd}t|dwxYwt j|tj}|jdkrtd||_ ||_ t|_ dS)Nrcg|] }|j Sr$)r)rats r rz&GroupBase.__init__..is...be...r"rzCan only initialise a Group from an iterable of Atom/Residue/Segment objects eg: AtomGroup([Atom1, Atom2, Atom3]) or an iterable of indices and a Universe reference eg: AtomGroup([0, 5, 7, 8], u).dtypezGroup index must be 1d) lenrrprrasarrayintpndimr_ix_udict_cache)r^rrrrs r __init__zGroupBase.__init__es .4yyA~~..d1g...GAJ'A   . . . 2  F## - .Z"' * * * 7Q;;566 6ff s >A$A%ct|j|jt|jfSr)hashrr~rrtolistr^s r __hash__zGroupBase.__hash__s/TWdneDGNN4D4D.E.EFGGGr"c*t|jSr)rrrs r __len__zGroupBase.__len__s47||r"cP|tdt|tjr+|j|j||jSt|tr|rtj |}| |j||jS)Nz%None cannot be used to index a group.) rrnumbersIntegralrrjrrlistrarrayrY)r^items r r]zGroupBase.__getitem__s <CDD D g. / / E:&&twt}dmDD D$%% &$ &x~~ &&twt}dmDD Dr"ct|j}|tvryt|}||jkr7||jkr,d}t ||||jd}t||jtt| |S)Nz8{selfcls} has no attribute {attr}. Do you mean {plural}?)rr_plural5This Universe does not contain {singular} informationrj) rRrSrrjrfrprzrr{r:rr^r_rr%rr~s r rzGroupBase.__getattr__st**% ? " "!$'Cs|## (<(<,%JJwT#,JOON!#**cl*"C"CDDDD))55d;; ;r"c |jj}d|t ||dt |dkdS)Nz<{}Group with {} {}{}>sr)rnamerz capitalizerr^rs r __repr__zGroupBase.__repr__sQz*11 OO  s4yy$CIIN4D4D0E   r"c |jj}t|dkrBd|t t |Sd|t t |ddddt t |ddddS)N z <{}Group {}>z<{}Group {}, ..., {}>rr)rrrrzr reprrr s r __str__zGroupBase.__str__sz t99??!(():):Dd> >!!'JJ'e)="" r"c,||Sr) differencers r __sub__zGroupBase.__sub__su%%%r"cD|j}tj|j|S)aTest group equality. Two groups are equal if they contain the same indices in the same order. Groups that are not at the same level or that belong to different :class:`Universes` cannot be compared. )rr array_equalr^rZo_ixs r __eq__zGroupBase.__eq__sx~dgt,,,r"cB|j|jksdS|j|jvS)NF)rrrs r __contains__zGroupBase.__contains__s'{dj((5x47""r"c,||Sr)unionrs r __or__zGroupBase.__or__szz%   r"c,||Sr) intersectionrs r __and__zGroupBase.__and__s  '''r"c,||Sr)symmetric_differencers r __xor__zGroupBase.__xor__s((///r"c|jS)zaThe underlying :class:`~MDAnalysis.core.universe.Universe` the group belongs to. rrs r rzGroupBase.universe s wr"c|jS)aUnique indices of the components in the Group. - If this Group is an :class:`AtomGroup`, these are the indices of the :class:`Atom` instances. - If it is a :class:`ResidueGroup`, these are the indices of the :class:`Residue` instances. - If it is a :class:`SegmentGroup`, these are the indices of the :class:`Segment` instances. rrs r rz GroupBase.ixs xr"c|jS)zUnique indices of the components in the Group. For a Group, :attr:`ix_array` is the same as :attr:`ix`. This method gives a consistent API between components and groups. See Also -------- :attr:`ix` r/rs r rzGroupBase.ix_array s xr"c^|jjjj}||S|S)z@Obtain a copy of the dimensions of the currently loaded Timestep)r trajectorytsrMcopy)r^dimss r rMzGroupBase.dimensions-s,}'*5 <K99;; r"c2||jjj_dSr)rr2r3rM)r^rMs r rMzGroupBase.dimensions6s1;  #...r" sorted_uniquec.|dS)NTrasuniquers r r7zGroupBase.sorted_unique:s}}D})))r"unsorted_uniquec.|dS)NFr9r:rs r r<zGroupBase.unsorted_unique?s}}E}***r"issortedc*t|jSr)rrrs r r>zGroupBase.issortedDs#47+++r"isuniquect|dkrdSt|jjd|jjdkS)aBoolean indicating whether all components of the group are unique, i.e., the group contains no duplicates. Examples -------- .. testsetup:: GroupBase.isunique from MDAnalysis.tests.datafiles import PDB, XTC import MDAnalysis as mda u = mda.Universe(PDB, XTC) .. doctest:: GroupBase.isunique >>> ag = u.atoms[[2, 1, 2, 2, 1, 0]] >>> ag >>> ag.isunique False >>> ag2 = ag.unique >>> ag2 >>> ag2.isunique True See Also -------- asunique .. versionadded:: 0.19.0 rTr)rr rshapers r r@zGroupBase.isuniqueIs?F t99>>4TW%%+A.$'-2BBBr"Fcx |rdnd}|j|S#t$rYnwxYw|jr+|s ||jd<|S|jr||jd<||jd<|S|rx|r&t j|jd\}}||_nt|j}||}d|jd<d|jd<||jd<||jd<||jd<|St|j}|r]t j |j} t|D]-\} } t j |j| kd} | | | <.| |_t|} | rd|jvr|j|jd<|jS||}d|jd<| |jd<||jd<||jd<| r||jd<||jd<|S)Nr7r<T)return_inverser@r>r)rrr@r>runiquer_unique_restore_maskr r zeros_like enumeratewhererr7)r^rrset_maskr unique_ix restore_mask_uniquerrixrcr>s r _asuniquezGroupBase._asuniqueps5 &,C??2CD;t$ $    D  =  15 -. } 15 -./3 O,   3*,)GD+++' <-9)))$'22 I&G)-GN: &)-GN: &.5GN? +07GN, -+2DK (N(11  -=))D!'** ! !1$'Q,//2 V (,D %&w//  &4;66-1-?DK) *% %.%)z"%-z",3())0 %&  6+2DK (.5GN? +s  ""c|dkr |jj}n|dkr |jj}n|dkr. |jj}n#t$rd}t |dwxYw|dkr. |jj}nW#t $rd}t |dwxYw|dkrtdtd ||S) NrJrK moleculeszECannot use compound='molecules': No molecule information in topology. fragmentszACannot use compound='fragments': No bond information in topology.rz,This method does not accept compound='group'zkUnrecognized compound definition: {} Please use one of 'residues', 'segments', 'molecules', or 'fragments'.) r resindices segindicesmolnumsrpr fragindicesrrz)r^compoundcompound_indicesrs r _get_compound_indiceszGroupBase._get_compound_indicess( z ! !#z4    # ##z4    $ $ 4#':#5  ! 4 4 4/"&))t3  4  $ $ 4#':#9   4 4 4/"&))t3  4  KLL L##)6(#3#3   s ;A" A//B c||}tj|}||}||dk}t|}tjtj|dk}|r5|rtj|d}ntj|}||}g} g} |D]} | || k|r4| ||| kd| Q| tj || kdd| | | t|fS)apSplits a group's compounds into groups of equal compound size. Grouping equal sizes together facilitates subsequent vectorization. For a 10-atom molecule with atoms organized into compounds C0 through C2:: at.id: 0 1 2 3 4 5 6 7 8 9 compound: C0 C0 C0 C0 C1 C1 C2 C2 C2 C2 this function will yield an `atom_masks` list with two submasks: one for compounds of size 2 and one for compounds of size 4: [array([[4, 5]]), array([[1, 2, 3, 0], [8, 7, 6, 9]])] (Note that atom order within component submasks may be lost unless a `stable_sort` is requested) These submasks can be used directly to fancy-index arrays of the same length as self (including :class:`AtomGroups`). This function also returns `compound_masks`, the boolean mapping of each of the `atom_masks` submask into the original compound order:: [array([False, True, False]), array([ True, False, True])] Parameters ---------- compound : {'segments', 'residues', 'molecules', 'fragments'} The compound type to base splitting on. stable_sort : bool, optional Whether to ensure that, when needed, sorting does not affect an atom's order within a compound (at a cost to performance). E.g., for an unwrap operation it is important that the first atom of a compound is always the same, whereas a center-of-geometry computation wouldn't care. Returns ------- atom_masks : list of numpy.ndarray Integer masks for fancy-indexing atoms/weights lists; masks are already shaped as ``(number of compounds of a given size, compound_size)``. compound_masks : list of numpy.ndarray 1D boolean masks for fancy-indexing lists of compounds. Translate the distribution of the compounds in each mask of `atom_masks` into their original order. n_compounds : int The number of individual compounds. rstablekindr) rZrbincountr rdiffargsortappendreshaperIr) r^rX stable_sortrYcompound_sizes size_per_atomunique_compound_sizes needs_sorting sort_indicescompound_masks atom_masks compound_sizes r _split_by_compound_indicesz$GroupBase._split_by_compound_indicesst 55h??%566&'78 '!(;< -n = =rw'7881<==  8 <!z*:JJJ  "z*:;; ),7M 2  M  ! !.M"A B B B !! -!?@HHM !!H]m;<3~+>+>>>r"rc J|j}tj}|}|dkr|r|d}n"|r||dd}n|j}t|dkr|S|-||d}| dS||d}tj d ||dddf| z S| |\} } } |r||dd}n|j}|||d}n||d}tj | d f| } t| | D]y\} }||}|| d }nN||}tj d ||dddddf}|| d dddfz}|| | <z|rtj| |j} | S)aWeighted center of (compounds of) the group Computes the weighted center of :class:`Atoms` in the group. Weighted centers per :class:`Residue`, :class:`Segment`, molecule, or fragment can be obtained by setting the `compound` parameter accordingly. If the weights of a compound sum up to zero, the coordinates of that compound's weighted center will be ``nan`` (not a number). Parameters ---------- weights : array_like or None Weights to be used. Setting `weights=None` is equivalent to passing identical weights for all atoms of the group. wrap : bool, optional If ``True`` and `compound` is ``'group'``, move all atoms to the primary unit cell before calculation. If ``True`` and `compound` is not ``'group'`` the center of each compound will be calculated without moving any :class:`Atoms` to keep the compounds intact. Instead, the resulting position vectors will be moved to the primary unit cell after calculation. Default [``False``]. unwrap : bool, optional If ``True``, compounds will be unwrapped before computing their centers. compound : {'group', 'segments', 'residues', 'molecules', 'fragments'}, optional If ``'group'``, the weighted center of all atoms in the group will be returned as a single position vector. Else, the weighted centers of each :class:`Segment`, :class:`Residue`, molecule, or fragment will be returned as an array of position vectors, i.e. a 2d array. Note that, in any case, *only* the positions of :class:`Atoms` *belonging to the group* will be taken into account. Returns ------- center : numpy.ndarray Position vector(s) of the weighted center(s) of the group. If `compound` was set to ``'group'``, the output will be a single position vector. If `compound` was set to ``'segments'``, ``'residues'``, ``'molecules'``, or ``'fragments'``, the output will be a 2d array of shape ``(n, 3)`` where ``n`` is the number of compounds. Raises ------ ValueError If `compound` is not one of ``'group'``, ``'segments'``, ``'residues'``, ``'molecules'``, or ``'fragments'``. ValueError If both 'wrap' and 'unwrap' set to true. ~MDAnalysis.exceptions.NoDataError If `compound` is ``'molecule'`` but the topology doesn't contain molecule information (molnums) or if `compound` is ``'fragments'`` but the topology doesn't contain bonds. Examples -------- To find the center of charge of a given :class:`AtomGroup`: .. testsetup:: GroupBase.center from MDAnalysis.tests.datafiles import PDB, XTC import MDAnalysis as mda u = mda.Universe(PSF, DCD) .. doctest:: GroupBase.center >>> sel = u.select_atoms('prop mass > 4.0') >>> sel.center(sel.charges) array([-0.22925091, -0.04771193, -0.16728489]) To find the centers of mass per residue of all CA :class:`Atoms`: .. doctest:: GroupBase.center :options: +NORMALIZE_WHITESPACE >>> sel = u.select_atoms('name CA') >>> sel.center(sel.masses, compound='residues') array([[ 11.66462231, 8.39347267, -8.98323059], [ 11.41483879, 5.43442154, -6.51348448], [ 8.95975494, 5.61292315, -3.61323047], [ 8.29006767, 3.07599092, -0.79665166], [ 5.01112604, 3.76389837, 1.130355 ], ... .. versionchanged:: 0.19.0 Added `compound` parameter .. versionchanged:: 0.20.0 Added ``'molecules'`` and ``'fragments'`` compounds .. versionchanged:: 0.20.0 Added `unwrap` parameter .. versionchanged:: 1.0.0 Removed flags affecting default behaviour .. versionchanged:: 2.1.0 Renamed `pbc` kwarg to `wrap`. `pbc` is still accepted but is deprecated and will be removed in version 3.0. rFinplaceN)rX referencerprr4rij,ij->jrrr ijk,ijk->ik)rrfloat64r pack_into_boxrrLrastypemeaneinsumsumrmemptyzipr apply_PBCrM)r^weightsrrrXrrcompcoordsrkrj n_compoundscenters compound_mask atom_mask_coords_centers_weightss r centerzGroupBase.center*shH  ~~ 7?? ),,U,;; )!T5&5zzQ u599{{{***nnUn77G *fgaaag.>??'++--O   + +D 1 1 2^[  %\\44\OOFF_F ?]]5u]55FFnnUn77G(K+5999(+NJ(G(G . . $M9Y'G"<` :math:`i`. Centers of geometry per :class:`Residue` or per :class:`Segment` can be obtained by setting the `compound` parameter accordingly. Parameters ---------- wrap : bool, optional If ``True`` and `compound` is ``'group'``, move all atoms to the primary unit cell before calculation. If ``True`` and `compound` is ``'segments'`` or ``'residues'``, the center of each compound will be calculated without moving any :class:`Atoms` to keep the compounds intact. Instead, the resulting position vectors will be moved to the primary unit cell after calculation. Default False. unwrap : bool, optional If ``True``, compounds will be unwrapped before computing their centers. compound : {'group', 'segments', 'residues', 'molecules', 'fragments'}, optional If ``'group'``, the center of geometry of all :class:`Atoms` in the group will be returned as a single position vector. Else, the centers of geometry of each :class:`Segment` or :class:`Residue` will be returned as an array of position vectors, i.e. a 2d array. Note that, in any case, *only* the positions of :class:`Atoms` *belonging to the group* will be taken into account. Returns ------- center : numpy.ndarray Position vector(s) of the geometric center(s) of the group. If `compound` was set to ``'group'``, the output will be a single position vector. If `compound` was set to ``'segments'`` or ``'residues'``, the output will be a 2d array of shape ``(n, 3)`` where ``n`` is the number of compounds. .. versionchanged:: 0.8 Added `pbc` keyword .. versionchanged:: 0.19.0 Added `compound` parameter .. versionchanged:: 0.20.0 Added ``'molecules'`` and ``'fragments'`` compounds .. versionchanged:: 0.20.0 Added `unwrap` parameter .. versionchanged:: 1.0.0 Removed flags affecting default behaviour .. versionchanged:: 2.1.0 Renamed `pbc` kwarg to `wrap`. `pbc` is still accepted but is deprecated and will be removed in version 3.0. N)rrXr)r)r^rrrXs r center_of_geometryzGroupBase.center_of_geometrysn{{4dXf{MMMr"c|j}t|trt||}nqt j|}t |t |kr=tdt |t || }|dkr ||dS| |\}}} t|j dd} t j | g| z} t||D]\} } || }||d}|| | < | S)aaAccumulates the attribute associated with (compounds of) the group. Accumulates the attribute of :class:`Atoms` in the group. The accumulation per :class:`Residue`, :class:`Segment`, molecule, or fragment can be obtained by setting the `compound` parameter accordingly. By default, the method sums up all attributes per compound, but any function that takes an array and returns an acuumulation over a given axis can be used. For multi-dimensional input arrays, the accumulation is performed along the first axis. Parameters ---------- attribute : str or array_like Attribute or array of values to accumulate. If a :class:`numpy.ndarray` (or compatible) is provided, its first dimension must have the same length as the total number of atoms in the group. function : callable, optional The function performing the accumulation. It must take the array of attribute values to accumulate as its only positional argument and accept an (optional) keyword argument ``axis`` allowing to specify the axis along which the accumulation is performed. compound : {'group', 'segments', 'residues', 'molecules', 'fragments'},\ optional If ``'group'``, the accumulation of all attributes associated with atoms in the group will be returned as a single value. Otherwise, the accumulation of the attributes per :class:`Segment`, :class:`Residue`, molecule, or fragment will be returned as a 1d array. Note that, in any case, *only* the :class:`Atoms` *belonging to the group* will be taken into account. Returns ------- float or numpy.ndarray Acuumulation of the `attribute`. If `compound` is set to ``'group'``, the first dimension of the `attribute` array will be contracted to a single value. If `compound` is set to ``'segments'``, ``'residues'``, ``'molecules'``, or ``'fragments'``, the length of the first dimension will correspond to the number of compounds. In all cases, the other dimensions of the returned array will be of the original shape (without the first dimension). Raises ------ ValueError If the length of a provided `attribute` array does not correspond to the number of atoms in the group. ValueError If `compound` is not one of ``'group'``, ``'segments'``, ``'residues'``, ``'molecules'``, or ``'fragments'``. ~MDAnalysis.exceptions.NoDataError If `compound` is ``'molecule'`` but the topology doesn't contain molecule information (molnums), or if `compound` is ``'fragments'`` but the topology doesn't contain bonds. Examples -------- To find the total charge of a given :class:`AtomGroup`: .. testsetup:: GroupBase.center from MDAnalysis.tests.datafiles import PSF, DCD import MDAnalysis as mda u = mda.Universe(PSF, DCD) .. doctest:: GroupBase.center >>> sel = u.select_atoms('prop mass > 4.0') >>> sel.accumulate('charges') -251.68500316143036 To find the total mass per residue of all CA :class:`Atoms`: .. doctest:: GroupBase.center :options: +NORMALIZE_WHITESPACE >>> sel = u.select_atoms('name CA') >>> sel.accumulate('masses', compound='residues') array([12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, 12.011, ... To find the maximum atomic charge per fragment of a given :class:`AtomGroup`: .. doctest:: GroupBase.center >>> import numpy as np >>> sel.accumulate('charges', compound="fragments", function=np.max) array([0.20999999]) .. versionadded:: 0.20.0 zQThe input array length ({}) does not match the number of atoms ({}) in the group.rrrrN)rrrrrrrrrzrrmrrBr{r|)r^ attributerrXrattribute_valuesrrkrjr higher_dims accumulationrr _elements _accumulations r accumulatezGroupBase.accumulate saL  i % % &ui88  !z)44 #$$E 22 vc"233SZZ@@ ~~ 7??8,1555 5  + +D 1 1 2^[+1!""566 x ;<< (+NJ(G(G 8 8 $M9(3I$HYQ777M*7L ' 'r"c|j}|r|d}n|j}tj|d|dgS)apReturn the bounding box of the selection. The lengths A,B,C of the orthorhombic enclosing box are :: L = AtomGroup.bbox() A,B,C = L[1] - L[0] Parameters ---------- wrap : bool, optional If ``True``, move all :class:`Atoms` to the primary unit cell before calculation. [``False``] Returns ------- corners : numpy.ndarray 2x3 array giving corners of bounding box as ``[[xmin, ymin, zmin], [xmax, ymax, zmax]]``. .. versionadded:: 0.7.2 .. versionchanged:: 0.8 Added *pbc* keyword .. versionchanged:: 1.0.0 Removed flags affecting default behaviour .. versionchanged:: 2.1.0 Renamed `pbc` kwarg to `wrap`. `pbc` is still accepted but is deprecated and will be removed in version 3.0. Frorr)rrvrLrrminmax)r^r atomgrouprOs r bboxzGroupBase.bboxs`<J  $'''66AA#AxA1 6777r"c X|jj}|r-|d}|d}n|j}|d}t jt jt jt j ||z d}||fS)aReturn the bounding sphere of the selection. The sphere is calculated relative to the :meth:`center of geometry`. Parameters ---------- wrap : bool, optional If ``True``, move all atoms to the primary unit cell before calculation. [``False``] Returns ------- R : float Radius of the bounding sphere. center : numpy.ndarray Coordinates of the sphere center as ``[xcen, ycen, zcen]``. .. versionadded:: 0.7.3 .. versionchanged:: 0.8 Added *pbc* keyword .. versionchanged:: 2.1.0 Renamed `pbc` kwarg to `wrap`. `pbc` is still accepted but is deprecated and will be removed in version 3.0. FroTrrr) rr<rvrrLrsqrtrrzsquare)r^rrrOcentroidRs r bspherezGroupBase.bspheres6J.  @'''66A 333>>HH#A 333??H GBF26")AL"9"9BBBCC D D({r"ctj|}|ddddf}|dddf}||gd|S)aApply homogenous transformation matrix `M` to the coordinates. :class:`Atom` coordinates are rotated and translated in-place. Parameters ---------- M : array_like 4x4 matrix with the rotation in ``R = M[:3, :3]`` and the translation in ``t = M[:3, 3]``. Returns ------- self See Also -------- MDAnalysis.lib.transformations : module of all coordinate transforms Notes ----- The rotation :math:`\mathsf{R}` is about the origin and is applied before the translation :math:`\mathbf{t}`: .. math:: \mathbf{x}' = \mathsf{R}\mathbf{x} + \mathbf{t} Nrrrr)rrrotate translate)r^Mrts r transformzGroupBase.transforms]: JqMM bqb"1"fI bqb!eH{{1iii((221555r"c|jj}tj|}|jjjj|jxx|z cc<|S)aApply translation vector `t` to the selection's coordinates. :class:`Atom` coordinates are translated in-place. Parameters ---------- t : array_like vector to translate coordinates with Returns ------- self See Also -------- MDAnalysis.lib.transformations : module of all coordinate transforms Notes ----- The method applies a translation to the :class:`AtomGroup` from current coordinates :math:`\mathbf{x}` to new coordinates :math:`\mathbf{x}'`: .. math:: \mathbf{x}' = \mathbf{x} + \mathbf{t} ) rr<rrrr2r3rLr)r^rrvectors r rzGroupBase.translatesK:J. A%(293DEEEOEEE r"rctj|}tj|}|jj}t tj|}|r|| |jjj j }|j }tj |||j ||<|r|||S)aApply a rotation matrix `R` to the selection's coordinates. :math:`\mathsf{R}` is a 3x3 orthogonal matrix that transforms a vector :math:`\mathbf{x} \rightarrow \mathbf{x}'`: .. math:: \mathbf{x}' = \mathsf{R}\mathbf{x} :class:`Atom` coordinates are rotated in-place. Parameters ---------- R : array_like 3x3 rotation matrix point : array_like, optional Center of rotation Returns ------- self Notes ----- By default, rotates about the origin ``point=(0, 0, 0)``. To rotate a group ``g`` around its center of geometry, use ``g.rotate(R, point=g.center_of_geometry())``. See Also -------- rotateby : rotate around given axis and angle MDAnalysis.lib.transformations : module of all coordinate transforms )rrrr<rT count_nonzerorrr2r3rLrdotr)r^rpointrrequire_translationrOidxs r rzGroupBase.rotate%sD JqMM 5!!J. "2#3E#:#:;;  (    ' ' '   ) , 6#$$#  '    & & & r"Nctj|}tj|}||}tj|}t j|||}||S)aApply a rotation to the selection's coordinates. Parameters ---------- angle : float Rotation angle in degrees. axis : array_like Rotation axis vector. point : array_like, optional Center of rotation. If ``None`` then the center of geometry of this group is used. Returns ------- self Notes ----- The transformation from current coordinates :math:`\mathbf{x}` to new coordinates :math:`\mathbf{x}'` is .. math:: \mathbf{x}' = \mathsf{R}\,(\mathbf{x}-\mathbf{p}) + \mathbf{p} where :math:`\mathsf{R}` is the rotation by `angle` around the `axis` going through `point` :math:`\mathbf{p}`. See Also -------- MDAnalysis.lib.transformations.rotation_matrix : calculate :math:`\mathsf{R}` N)r)rradiansrrrrotation_matrixr)r^anglerralphars r rotatebyzGroupBase.rotatebyWsqF 5!!z$ =++--E 5!!  +E4u E E E~~a   r"Tc0|||S)aShift all :class:`Atoms` in this group to the primary unit cell. Parameters ---------- box : array_like Box dimensions, can be either orthogonal or triclinic information. Cell dimensions must be in an identical to format to those returned by :attr:`MDAnalysis.coordinates.timestep.Timestep.dimensions`, ``[lx, ly, lz, alpha, beta, gamma]``. If ``None``, uses these timestep dimensions. inplace : bool ``True`` to change coordinates in place. Returns ------- coords : numpy.ndarray Shifted atom coordinates. Notes ----- All atoms will be moved so that they lie between 0 and boxlength :math:`L_i` in all dimensions, i.e. the lower left corner of the simulation box is taken to be at (0,0,0): .. math:: x_i' = x_i - \left\lfloor\frac{x_i}{L_i}\right\rfloor The default is to take unit cell information from the underlying :class:`~MDAnalysis.coordinates.timestep.Timestep` instance. The optional argument `box` can be used to provide alternative unit cell information (in the MDAnalysis standard format ``[Lx, Ly, Lz, alpha, beta, gamma]``). Works with either orthogonal or triclinic box types. .. note:: :meth:`pack_into_box` is identical to :meth:`wrap` with all default keywords. .. note:: :meth:`AtomGroup.pack_into_box` is currently faster than :meth:`ResidueGroup.pack_into_box` or :meth:`SegmentGroup.pack_into_box`. .. versionadded:: 0.8 )boxrpr)r^rrps r rvzGroupBase.pack_into_boxsdyyS'y222r"rcomc||j}|tdnRtj|tj}tj|dkr |jdkrtd|j}|js|j }|j }|}| }|dvr"td |t|d kr tjd tjS|d kst|d krtj|j|} n| } | d kr*t%|jjdst+dn(| dkr"td ||j} | d krk|d|} tjtj| r-|dkrdnd} td || n|d|} | tjd} tj| |} | | z }|dkr| |z } n^||}t9|}d }|D]5}tj||k}| |xx||z cc<|d z }6|r| |_|js| |} | S)a/Shift the contents of this group back into the primary unit cell according to periodic boundary conditions. Specifying a `compound` will keep the :class:`Atoms` in each compound together during the process. If `compound` is different from ``'atoms'``, each compound as a whole will be shifted so that its `center` lies within the primary unit cell. Parameters ---------- compound : {'atoms', 'group', 'segments', 'residues', 'molecules', \ 'fragments'}, optional Which type of compound to keep together during wrapping. Note that, in any case, *only* the positions of :class:`Atoms` *belonging to the group* will be taken into account. center : {'com', 'cog'} How to define the center of a given group of atoms. If `compound` is ``'atoms'``, this parameter is meaningless and therefore ignored. box : array_like, optional The unitcell dimensions of the system, which can be orthogonal or triclinic and must be provided in the same format as returned by :attr:`MDAnalysis.coordinates.timestep.Timestep.dimensions`: ``[lx, ly, lz, alpha, beta, gamma]``. If ``None``, uses the dimensions of the current time step. inplace: bool, optional If ``True``, coordinates will be changed in place. Returns ------- numpy.ndarray Array of wrapped atom coordinates of dtype `np.float32` and shape ``(len(self.atoms.n_atoms), 3)`` Raises ------ ValueError If `compound` is not one of ``'atoms'``, ``'group'``, ``'segments'``, ``'residues'``, ``'molecules'``, or ``'fragments'``. ~MDAnalysis.exceptions.NoDataError If `compound` is ``'molecule'`` but the topology doesn't contain molecule information (molnums) or if `compound` is ``'fragments'`` but the topology doesn't contain bonds or if `center` is ``'com'`` but the topology doesn't contain masses. Notes ----- All atoms of the group will be moved so that the centers of its compounds lie within the primary periodic image. For orthorhombic unit cells, the primary periodic image is defined as the half-open interval :math:`[0,L_i)` between :math:`0` and boxlength :math:`L_i` in all dimensions :math:`i\in\{x,y,z\}`, i.e., the origin of the of the simulation box is taken to be at the origin :math:`(0,0,0)` of the euclidian coordinate system. A compound center residing at position :math:`x_i` in dimension :math:`i` will be shifted to :math:`x_i'` according to .. math:: x_i' = x_i - \left\lfloor\frac{x_i}{L_i}\right\rfloor\,. When specifying a `compound`, the translation is calculated based on each compound. The same translation is applied to all atoms within this compound, meaning it will not be broken by the shift. This might however mean that not all atoms of a compound will be inside the unit cell after wrapping, but rather will be the center of the compound. Be aware of the fact that only atoms *belonging to the group* will be taken into account! `center` allows to define how the center of each group is computed. This can be either ``'com'`` for center of mass, or ``'cog'`` for center of geometry. `box` allows a unit cell to be given for the transformation. If not specified, the :attr:`~MDAnalysis.coordinates.timestep.Timestep.dimensions` information from the current :class:`~MDAnalysis.coordinates.timestep.Timestep` will be used. .. note:: :meth:`AtomGroup.wrap` is currently faster than :meth:`ResidueGroup.wrap` or :meth:`SegmentGroup.wrap`. See Also -------- :meth:`pack_into_box` :meth:`unwrap` :meth:`MDAnalysis.lib.distances.apply_PBC` .. versionadded:: 0.9.2 .. versionchanged:: 0.20.0 The method only acts on atoms *belonging to the group* and returns the wrapped positions as a :class:`numpy.ndarray`. Added optional argument `inplace`. NzhNo dimensions information in Universe. Either use the 'box' argument or set the '.dimensions' attributer)zInvalid box: Box has invalid shape or not all box dimensions are positive. You can specify a valid box using the 'box' argument.)rrrKrJrRrSzUnrecognized compound definition '{}'. Please use one of 'atoms', 'group', 'segments', 'residues', 'molecules', or 'fragments'.r)rrrrrmassesz#>t#D#D +88H*I*I' 0##A8$4$9::DdOOOvi'88OOONII  ('EO} 0!,/Ir"rSc |j}t|dst|jjd|j}|X |}|dvrtn7#ttf$r#td |wxYw|dkrt|dstd|}|d krtj |d }|t|d kr|dkre|j }|} tj| d rtdtjd||dddf} | | z} n|d } | tjd } t+j| |j} || | z z }n|||dud } |j}| D]Y} | D]!}tj ||d ||<"|/|dkr|j | }|d} tjtj| d r"td |tjd|| |dddddf} | | dddfz} n|| d} | tjd } t+j| |j} || xx| dddddf| dddddfz z cc<[|r||_|js ||j}|S)a Move atoms of this group so that bonds within the group's compounds aren't split across periodic boundaries. This function is most useful when atoms have been packed into the primary unit cell, causing breaks mid-molecule, with the molecule then appearing on either side of the unit cell. This is problematic for operations such as calculating the center of mass of the molecule. :: +-----------+ +-----------+ | | | | | 6 3 | | 3 | 6 | ! ! | | ! | ! |-5-8 1-2-| ==> | 1-2-|-5-8 | ! ! | | ! | ! | 7 4 | | 4 | 7 | | | | +-----------+ +-----------+ Parameters ---------- compound : {'group', 'segments', 'residues', 'molecules', \ 'fragments'}, optional Which type of compound to unwrap. Note that, in any case, all atoms within each compound must be interconnected by bonds, i.e., compounds must correspond to (parts of) molecules. reference : {'com', 'cog', None}, optional If ``'com'`` (center of mass) or ``'cog'`` (center of geometry), the unwrapped compounds will be shifted so that their individual reference point lies within the primary unit cell. If ``None``, no such shift is performed. inplace : bool, optional If ``True``, coordinates are modified in place. Returns ------- coords : numpy.ndarray Unwrapped atom coordinate array of shape ``(n, 3)``. Raises ------ NoDataError If `compound` is ``'molecules'`` but the underlying topology does not contain molecule information, or if `reference` is ``'com'`` but the topology does not contain masses. ValueError If `reference` is not one of ``'com'``, ``'cog'``, or ``None``, or if `reference` is ``'com'`` and the total mass of any `compound` is zero. Note ---- Be aware of the fact that only atoms *belonging to the group* will be unwrapped! If you want entire molecules to be unwrapped, make sure that all atoms of these molecules are part of the group. An AtomGroup containing all atoms of all fragments in the group ``ag`` can be created with:: all_frag_atoms = sum(ag.fragments) See Also -------- :func:`~MDAnalysis.lib.mdamath.make_whole`, :meth:`wrap`, :meth:`pack_into_box`, :func:`~MDanalysis.lib.distances.apply_PBC` .. versionadded:: 0.20.0 bondsz.unwrap() not available; this AtomGroup lacks defined bonds. To resolve this, you can either: 1. Guess the bonds at universe creation using `guess_bonds = True`, or 2. Create a universe using a topology format where bonds are pre-defined.N)rrzEUnrecognized reference '{}'. Please use one of 'com', 'cog', or None.rrzACannot perform unwrap with reference='com', this requires masses.rFrorrzWCannot perform unwrap with reference='com' because the total mass of the group is zero.rsrrr)rdrzdCannot perform unwrap with reference='com' because the total mass of at least one of the {} is zero.rt)rryrr~rSr<rrrprzr make_wholerrrzriscloseryrxrwrrr}rMrmrLrr@rF)r^rXrqrpr unique_atomsrrLr total_massrefposrrkrrs r rzGroupBase.unwrap|s N ug&& >*\\\  ,    %OO-- N22$$3"J/    006y0A0A    glH&E&E ( ~~ 7??*<GGGI$Y!););%%)0F!'Jz*c22(9  Yz9fQQQWoNNFj(FF&^^^33Frz>>",VT_EEVf_, &@@)t"3AJ%.I'   %D&-&8$T*E'''IdOO( E))!-!4Y!?%+ZZQZ%7%7 6"*Z"="=>>",!239&,, ## "$)%i0"111aaa:."" *QQQW"55!*9!5!:!:!:!B!B#]]2:E]BBF&0IIFi(((qqq$z*VAAAtQQQJ-??(((  /%.L "~ >!%"<=Is A4BcD|dd}|||S)zTGet another group identical to this one. .. versionadded:: 0.19.0 N)_set_unique_caches_fromr^rs r r4zGroupBase.copy+s* QQQ %%d+++ r"c" |jd|jd<|jr ||jd<n#t$rYnwxYw |jd|jd<|jr&|jdr||jd<dSdSdS#t$rYdSwxYw)Nr@r<r>r7)rr@rr>rrs r rz!GroupBase._set_unique_caches_from5s 6&+l:&>DK #} 615 -.     D   8&+l:&>DK #} 8;??:..837DK000 8 888     DD s) 66B B Bc t}t|ttfrX|}t|tr|d}t |fdt DS|d}t |t D]O}t|dkr|k||<%|k|dd||<Ptj |S)aGroup together items in this group according to values of *topattr* Parameters ---------- topattrs: str or list One or more topology attributes to group components by. Single arguments are passed as a string. Multiple arguments are passed as a list. Returns ------- dict Unique values of the multiple combinations of topology attributes as keys, Groups as values. Example ------- To group atoms with the same mass together: .. testsetup:: GroupBase.groupby from MDAnalysis.tests.datafiles import PSF, DCD import MDAnalysis as mda u = mda.Universe(PSF, DCD) ag = u.atoms .. doctest:: GroupBase.groupby :options: +NORMALIZE_WHITESPACE >>> ag.groupby('masses') {32.06: , 1.008: , 12.011: , 14.007: , 15.999: } To group atoms with the same residue name and mass together: .. doctest:: GroupBase.groupby :options: +NORMALIZE_WHITESPACE >>> group_dict = ag.groupby(['resnames', 'masses']) >>> dict(sorted(group_dict.items())) {('ALA', 1.008): , ('ALA', 12.011): , ('ALA', 14.007): , ('ALA', 15.999): , ('ARG', 1.008): , ... .. doctest:: GroupBase.groupby >>> ag.groupby(['resnames', 'masses'])['ALA', 15.999] .. versionadded:: 0.16.0 .. versionchanged:: 0.18.0 The function accepts multiple attributes zutf-8c*i|]}||kSr$r$)rrNr^tas r z%GroupBase.groupby..s#666AtB!G}666r"rrN) rrrbytesdecodersetrgroupbyr flatten_dict)r^topattrsresr_rNrs` @r rzGroupBase.groupbyHszff he - - *D(E** 0w//t$$B66666c"gg666 6A;Dt$$BWW A Ax==A%%!"']CFF!"']228ABB<@@CFF$S)) )r"cx|j}|tj|j|g|jS)aConcatenate with another Group or Component of the same level. Duplicate entries and original order is preserved. It is synomymous to the `+` operator. Parameters ---------- other : Group or Component Group or Component with `other.level` same as `self.level` Returns ------- Group Group with elements of `self` and `other` concatenated Example ------- The order of the original contents (including duplicates) are preserved when performing a concatenation. .. testsetup:: GroupBase.concatenate from MDAnalysis.tests.datafiles import PDB, XTC import MDAnalysis as mda u = mda.Universe(PDB, XTC) .. doctest:: GroupBase.concatenate >>> ag1 = u.select_atoms('name O') >>> ag2 = u.select_atoms('name N') >>> ag3 = ag1 + ag2 # or ag1.concatenate(ag2) >>> ag3[:3].names array(['O', 'O', 'O'], dtype=object) >>> ag3[-3:].names array(['N', 'N', 'N'], dtype=object) .. versionadded:: 0.16.0 )rrYrrrrrs r rzGroupBase.concatenates;R~"" NDGT? + +T]   r"cv|j}|tj|j||jS)aGroup of elements either in this Group or another On the contrary to concatenation, this method sort the elements and removes duplicate ones. It is synomymous to the `|` operator. Parameters ---------- other : Group or Component Group or Component with `other.level` same as `self.level` Returns ------- Group Group with the combined elements of `self` and `other`, without duplicate elements Example ------- In contrast to :meth:`concatenate`, any duplicates are dropped and the result is sorted. .. testsetup:: GroupBase.union from MDAnalysis.tests.datafiles import PDB, XTC import MDAnalysis as mda u = mda.Universe(PDB, XTC) .. doctest:: GroupBase.union >>> ag1 = u.select_atoms('name O') >>> ag2 = u.select_atoms('name N') >>> ag3 = ag1 | ag2 # or ag1.union(ag2) >>> ag3[:3].names array(['N', 'O', 'N'], dtype=object) See Also -------- concatenate, intersection .. versionadded:: 0.16 )rrYrunion1drrrs r r$zGroupBase.unions2X~""2:dgt#<#>> shell1 = u.select_atoms('resname SOL and around 4.0 segid 1') >>> shell2 = u.select_atoms('resname SOL and around 4.0 segid 2') >>> common = shell1 & shell2 # or shell1.intersection(shell2) See Also -------- union .. versionadded:: 0.16 )rrYr intersect1drrrs r r'zGroupBase.intersections9J~"" N47D ) )4=   r"cV|j}tj|j|}||S)aGroup with elements from this Group that don't appear in other The original order of this group is kept, as well as any duplicate elements. If an element of this Group is duplicated and appears in the other Group or Component, then all the occurences of that element are removed from the returned Group. Parameters ---------- other : Group or Component Group or Component with `other.level` same as `self.level` Returns ------- Group Group with the elements of `self` that are not in `other`, conserves order and duplicates. Example ------- Unlike :meth:`difference` this method will not sort or remove duplicates. .. testsetup:: GroupBase.subtract import MDAnalysis as mda from MDAnalysis.tests.datafiles import PSF, DCD u = mda.Universe(PSF,DCD) .. doctest:: GroupBase.subtract >>> ag1 = u.atoms[[3, 3, 2, 2, 1, 1]] >>> ag2 = u.atoms[2] >>> ag3 = ag1.subtract(ag2) >>> ag3.indices array([3, 3, 1, 1]) See Also -------- concatenate, difference .. versionadded:: 0.16 )rrrr)r^rZrin_others r subtractzGroupBase.subtract! s+\~747D))XIr"cv|j}|tj|j||jS)aElements from this Group that do not appear in another This method removes duplicate elements and sorts the result. As such, it is different from :meth:`subtract`. :meth:`difference` is synomymous to the `-` operator. Parameters ---------- other : Group or Component Group or Component with `other.level` same as `self.level` Returns ------- Group Group with the elements of `self` that are not in `other`, without duplicate elements See Also -------- subtract, symmetric_difference .. versionadded:: 0.16 )rrYr setdiff1drrrs r rzGroupBase.differenceS s14~""2<$#?#?IIIr"cv|j}|tj|j||jS)aGroup of elements which are only in one of this Group or another This method removes duplicate elements and the result is sorted. It is synomym to the `^` operator. Parameters ---------- other : Group or Component Group or Component with `other.level` same as `self.level` Returns ------- Group Group with the elements that are in `self` or in `other` but not in both, without duplicate elements Example ------- .. testsetup:: GroupBase.symmetric_difference from MDAnalysis.tests.datafiles import PSF, DCD import MDAnalysis as mda u = mda.Universe(PSF, DCD) .. doctest:: GroupBase.symmetric_difference >>> ag1 = u.atoms[[0, 1, 5, 3, 3, 2]] >>> ag2 = u.atoms[[4, 4, 6, 2, 3, 5]] >>> ag3 = ag1 ^ ag2 # or ag1.symmetric_difference(ag2) >>> ag3.indices # 0 and 1 are only in ag1, 4 and 6 are only in ag2 array([0, 1, 4, 6]) See Also -------- difference .. versionadded:: 0.16 )rrYrsetxor1drrrs r r*zGroupBase.symmetric_differencep s2T~""2;tx#>#>HHHr"cNt||dkS)agIf the Group has no elements in common with the other Group Parameters ---------- other : Group or Component Group or Component with `other.level` same as `self.level` Returns ------- bool ``True`` if the two Groups do not have common elements .. versionadded:: 0.16 r)rr'rs r isdisjointzGroupBase.isdisjoint s% 4$$U++,,11r"c|t|j}t|j}||S)aIf all elements of this Group are part of another Group Note that an empty group is a subset of any group of the same level. Parameters ---------- other : Group or Component Group or Component with `other.level` same as `self.level` Returns ------- bool ``True`` if this Group is a subset of the other one .. versionadded:: 0.16 )rrrissubsetr^rZrs_ixs r rzGroupBase.issubset s2&5>""47||}}T"""r"c:||o||k S)alIf this Group is a subset of another Group but not identical Parameters ---------- other : Group or Component Group or Component with `other.level` same as `self.level` Returns ------- bool ``True`` if this Group is a strict subset of the other one .. versionadded:: 0.16 )rrs r is_strict_subsetzGroupBase.is_strict_subset s" }}U##9DEM(99r"c|t|j}t|j}||S)a`If all elements of another Group are part of this Group Parameters ---------- other : Group or Component Group or Component with `other.level` same as `self.level` Returns ------- bool ``True`` if this Group is a subset of the other one .. versionadded:: 0.16 )rrr issupersetrs r rzGroupBase.issuperset s2"5>""47||t$$$r"c:||o||k S)apIf this Group is a superset of another Group but not identical Parameters ---------- other : Group or Component Group or Component with `other.level` same as `self.level` Returns ------- bool ``True`` if this Group is a strict superset of the other one .. versionadded:: 0.16 )rrs r is_strict_supersetzGroupBase.is_strict_superset s" u%%;dem*;;r")FFF)FFr)rr)NT)rrNT)rSrT)CrSrrrrrrr]rr rrrrrr r"r%r(r+rgrrrrMrdr r7r<r>r@rPrZrmr rrrrrrrzrrrrrrrrvrrr4rrrr$r'rrr*rrrrrrrs@r r:r:!sAAF:HHHEEE.<<<<<$     '''"2&&& - - -###!!!(((000X   X   X X<<< VO**X* V ++X+ VJ,,X, VJ#C#CX#CJ6666p   B_?_?_?_?B___\_B4N4N4N\4Nl"H-/VgEEEEN$8$8$8\$8L%%%\%N 6 6 6D!!!F0000d)!)!)!)!V23232323hDDDDLmmmm^888&P*P*P*d+ + + Z,M,M,M\' ' ' R///bJJJ8*I*I*IX222$###,:::$%%%(<<<<<<`:: ag = AtomGroup([Atom1, Atom2, Atom3]) Or from providing a list of indices and the :class:`~MDAnalysis.core.universe.Universe` it should belong to:: ag = AtomGroup([72, 14, 25], u) Alternatively, an :class:`AtomGroup` is generated by indexing/slicing another :class:`AtomGroup`, such as the group of all :class:`Atoms` in the :class:`~MDAnalysis.core.universe.Universe` at :attr:`MDAnalysis.core.universe.Universe.atoms`. An :class:`AtomGroup` can be indexed and sliced like a list:: ag[0], ag[-1] will return the first and the last :class:`Atom` in the group whereas the slice:: ag[0:6:2] returns an :class:`AtomGroup` of every second element, corresponding to indices 0, 2, and 4. It also supports "advanced slicing" when the argument is a :class:`numpy.ndarray` or a :class:`list`:: aslice = [0, 3, -1, 10, 3] ag[aslice] will return a new :class:`AtomGroup` of :class:`Atoms` with those indices in the old :class:`AtomGroup`. Finally, :class:`AtomGroups` can be created from a selection. See :meth:`select_atoms`. .. note:: :class:`AtomGroups` originating from a selection are sorted and duplicate elements are removed. This is not true for :class:`AtomGroups` produced by slicing. Thus, slicing can be used when the order of atoms is crucial (for instance, in order to define angles or dihedrals). :class:`AtomGroups` can be compared and combined using group operators. For instance, :class:`AtomGroups` can be concatenated using `+` or :meth:`concatenate`:: ag_concat = ag1 + ag2 # or ag_concat = ag1.concatenate(ag2) When groups are concatenated, the order of the :class:`Atoms` is conserved. If :class:`Atoms` appear several times in one of the groups, the duplicates are kept in the resulting group. On the contrary to :meth:`concatenate`, :meth:`union` treats the :class:`AtomGroups` as sets so that duplicates are removed from the resulting group, and :class:`Atoms` are ordered. The `|` operator is synomymous to :meth:`union`:: ag_union = ag1 | ag2 # or ag_union = ag1.union(ag2) The opposite operation to :meth:`concatenate` is :meth:`subtract`. This method creates a new group with all the :class:`Atoms` of the group that are not in a given other group; the order of the :class:`Atoms` is kept, and so are duplicates. :meth:`difference` is the set version of :meth:`subtract`. The resulting group is sorted and deduplicated. All set methods are listed in the table below. These methods treat the groups as sorted and deduplicated sets of :class:`Atoms`. +-------------------------------+------------+----------------------------+ | Operation | Equivalent | Result | +===============================+============+============================+ | ``s.isdisjoint(t)`` | | ``True`` if ``s`` and | | | | ``t`` do not share | | | | elements | +-------------------------------+------------+----------------------------+ | ``s.issubset(t)`` | | test if all elements of | | | | ``s`` are part of ``t`` | +-------------------------------+------------+----------------------------+ | ``s.is_strict_subset(t)`` | | test if all elements of | | | | ``s`` are part of ``t``, | | | | and ``s != t`` | +-------------------------------+------------+----------------------------+ | ``s.issuperset(t)`` | | test if all elements of | | | | ``t`` are part of ``s`` | +-------------------------------+------------+----------------------------+ | ``s.is_strict_superset(t)`` | | test if all elements of | | | | ``t`` are part of ``s``, | | | | and ``s != t`` | +-------------------------------+------------+----------------------------+ | ``s.union(t)`` | ``s | t`` | new Group with elements | | | | from both ``s`` and ``t`` | +-------------------------------+------------+----------------------------+ | ``s.intersection(t)`` | ``s & t`` | new Group with elements | | | | common to ``s`` and ``t`` | +-------------------------------+------------+----------------------------+ | ``s.difference(t)`` | ``s - t`` | new Group with elements of | | | | ``s`` that are not in ``t``| +-------------------------------+------------+----------------------------+ | ``s.symmetric_difference(t)`` | ``s ^ t`` | new Group with elements | | | | that are part of ``s`` or | | | | ``t`` but not both | +-------------------------------+------------+----------------------------+ The following methods keep the order of the atoms as well as duplicates. +-------------------------------+------------+----------------------------+ | Operation | Equivalent | Result | +===============================+============+============================+ | ``len(s)`` | | number of elements (atoms, | | | | residues or segment) in | | | | the group | +-------------------------------+------------+----------------------------+ | ``s == t`` | | test if ``s`` and ``t`` | | | | contain the same elements | | | | in the same order | +-------------------------------+------------+----------------------------+ | ``s.concatenate(t)`` | ``s + t`` | new Group with elements | | | | from ``s`` and from ``t`` | +-------------------------------+------------+----------------------------+ | ``s.subtract(t)`` | | new Group with elements | | | | from ``s`` that are not | | | | in ``t`` | +-------------------------------+------------+----------------------------+ The `in` operator allows to test if an :class:`Atom` is in the :class:`AtomGroup`. :class:`AtomGroup` instances are always bound to a :class:`MDAnalysis.core.universe.Universe`. They cannot exist in isolation. During serialization, :class:`AtomGroup` will be pickled with its bound :class:`MDAnalysis.core.universe.Universe` which means after unpickling, a new :class:`MDAnalysis.core.universe.Universe` will be created and be attached by the new :class:`AtomGroup`. If the Universe is serialized with its :class:`AtomGroup`, they will still be bound together afterwards: .. testsetup:: AtomGroup import MDAnalysis as mda from MDAnalysis.tests.datafiles import PSF, DCD .. doctest:: AtomGroup >>> import pickle >>> u = mda.Universe(PSF, DCD) >>> g = u.atoms >>> g_pickled = pickle.loads(pickle.dumps(g)) >>> print("g_pickled.universe is u: ", u is g_pickled.universe) g_pickled.universe is u: False >>> g_pickled, u_pickled = pickle.loads(pickle.dumps((g, u))) >>> print("g_pickled.universe is u_pickled: ", ... u_pickled is g_pickled.universe) g_pickled.universe is u_pickled: True If multiple :class:`AtomGroup` are bound to the same :class:`MDAnalysis.core.universe.Universe`, they will bound to the same one after serialization: .. doctest:: AtomGroup >>> import pickle >>> u = mda.Universe(PSF, DCD) >>> g = u.atoms >>> h = u.atoms >>> g_pickled = pickle.loads(pickle.dumps(g)) >>> h_pickled = pickle.loads(pickle.dumps(h)) >>> print("g_pickled.universe is h_pickled.universe: ", ... g_pickled.universe is h_pickled.universe) g_pickled.universe is h_pickled.universe: False >>> g_pickled, h_pickled = pickle.loads(pickle.dumps((g, h))) >>> print("g_pickled.universe is h_pickled.universe: ", ... g_pickled.universe is h_pickled.universe) g_pickled.universe is h_pickled.universe: True The aforementioned two cases are useful for implementation of parallel analysis base classes. First, you always get an independent :class:`MDAnalysis.core.universe.Universe` in the new process; you don't have to worry about detaching and reattaching Universe with :class:`AtomGroup`. It also means the state of the new pickled AtomGroup will not be changed with the old Universe, So either the Universe has to pickled together with the AtomGroup (e.g. as a tuple, or as attributes of the object to be pickled), or the implicit new Universe (`AtomGroup.Universe`) needs to be used. Second, When multiple AtomGroup need to be pickled, they will recognize if they belong to the same Univese or not. Also keep in mind that they need to be pickled together. See Also -------- :class:`MDAnalysis.core.universe.Universe` .. deprecated:: 0.16.2 *Instant selectors* of :class:`AtomGroup` will be removed in the 1.0 release. .. versionchanged:: 1.0.0 Removed instant selectors, use select_atoms('name ...') to select atoms by name. .. versionchanged:: 2.0.0 :class:`AtomGroup` can always be pickled with or without its universe, instead of failing when not finding its anchored universe. .. versionchanged:: 2.1.0 Indexing an AtomGroup with ``None`` raises a ``TypeError``. c|dvrtd|z|dkrtdtt||S)N)rNrGThis Timestep has no rL This Universe has no coordinates)rr{r2r)r^r_r~s r rzAtomGroup.__getattr__ s[ + + +5<== = [ @AA AY%%11$777r"c,t|j|jffSr)r!rrrs r __reduce__zAtomGroup.__reduce__ sDM47344r"c|S)alThe :class:`AtomGroup` itself. See Also -------- copy : return a true copy of the :class:`AtomGroup` .. versionchanged:: 0.19.0 In previous versions, this returned a copy, but now the :class:`AtomGroup` itself is returned. This should not affect any code but only speed up calculations. r$rs r rzAtomGroup.atoms  r"c t|S)zYNumber of atoms in the :class:`AtomGroup`. Equivalent to ``len(self)``. rrs r n_atomszAtomGroup.n_atoms  4yyr"c|jjt|j}d|jd<d|jd<||jd<||jd<|S)z{A sorted :class:`ResidueGroup` of the unique :class:`Residues` present in the :class:`AtomGroup`. Tr@r>r7r<)rrJr rTrr^rgs r rJzAtomGroup.residues S ] #M$/$B$B C $ * $ *%' /"') #$ r"ct|trtj|jf}n{t|t r|j}n^ d|D}nP#t$rCdd d|D}t|dwxYwt|tjs]t|t|kr=tdt|t|t||D]/\}}|jjj|j|0dS)Ncg|] }|j Sr$)resindexrrs r rz&AtomGroup.residues.. 000q 000r"zACan only set AtomGroup residues to Residue or ResidueGroup not {}, c3^K|](}t|tt|V)dSr)rr6rRr s r rz%AtomGroup.residues.. K""() 1g8N8N" GG""""""r"z,Incorrect size: {} for AtomGroup of size: {})rr6 itertoolscycler r3rTrprzjoinrrrr|rrtt move_atomr)r^newr_ixrrr s r rJzAtomGroup.residues s{ c7 # # 2?CL?33DD \ * * 2>DD 200C000! 2 2 2--3V ""-0""".. ''T1 2$ 00 SYY#d))5K5K6#c((CII.. t__ ; ;EB M # & 0 0 : : : : ; ;  AA B)c*t|jS)zNumber of unique :class:`Residues` present in the :class:`AtomGroup`. Equivalent to ``len(self.residues)``. rrJrs r n_residueszAtomGroup.n_residues* s4=!!!r"c|jjt|j}d|jd<d|jd<||jd<||jd<|S)ziA sorted :class:`SegmentGroup` of the unique segments present in the :class:`AtomGroup`. Tr@r>r7r<rrKr rUrr^sgs r rKzAtomGroup.segments4 rr"c td)NzFCannot assign Segments to AtomGroup. Segments are assigned to ResiduesNotImplementedErrorr^rs r rKzAtomGroup.segments@ s! 0   r"c*t|jS)ztNumber of unique segments present in the :class:`AtomGroup`. Equivalent to ``len(self.segments)``. rrKrs r n_segmentszAtomGroup.n_segmentsG  4=!!!r"unique_restore_maskc|jr d|jj}nd|jj}|dz }t |)Nz@{0}._unique_restore_mask is not available if the {0} is unique. zG{0}._unique_restore_mask is only available after accessing {0}.unique. zmIf you see this error message in an unmodified release version of MDAnalysis, this is almost certainly a bug!)r@rzr~rS RuntimeError)r^msgs r rFzAtomGroup._unique_restore_maskO sj = !6$."9:: C ))/0G)H)H   E 3r"c||jd<dS)Nr))r)r^rs r rFzAtomGroup._unique_restore_maski s-1 )***r"ct|jdd}d|jd<d|jd<||jd<||jd<|S)aAn :class:`AtomGroup` containing sorted and unique :class:`Atoms` only. Examples -------- .. doctest:: AtomGroup.unique >>> import MDAnalysis as mda >>> from MDAnalysis.tests.datafiles import PSF, DCD >>> u = mda.Universe(PSF, DCD) >>> ag = u.atoms[[2, 1, 2, 2, 1, 0]] >>> ag >>> ag.ix array([2, 1, 2, 2, 1, 0]) >>> ag2 = ag.unique >>> ag2 >>> ag2.ix array([0, 1, 2]) >>> ag2.unique is ag2 False See Also -------- asunique .. versionadded:: 0.16.0 .. versionchanged:: 0.19.0 If the :class:`AtomGroup` is already unique, :attr:`AtomGroup.unique` now returns the group itself instead of a copy. .. versionchanged:: 2.0.0 This function now always returns a copy. NTr@r>r7r<r7rrs r rEzAtomGroup.uniquem sLL"111%#' Z #' Z (- _%*/ &' r"FcF|||jjdS)a_Return a :class:`AtomGroup` containing unique :class:`Atoms` only, with optional sorting. If the :class:`AtomGroup` is unique, this is the group itself. Parameters ---------- sorted: bool (optional) Whether or not the returned AtomGroup should be sorted by index. Returns ------- :class:`AtomGroup` Unique ``AtomGroup`` Examples -------- .. doctest:: AtomGroup.asunique >>> import MDAnalysis as mda >>> from MDAnalysis.tests.datafiles import PSF, DCD >>> u = mda.Universe(PSF, DCD) >>> ag = u.atoms[[2, 1, 0]] >>> ag2 = ag.asunique(sorted=False) >>> ag2 is ag True >>> ag2.ix array([2, 1, 0]) >>> ag3 = ag.asunique(sorted=True) >>> ag3 is ag False >>> ag3.ix array([0, 1, 2]) >>> u.atoms[[2, 1, 1, 0, 1]].asunique(sorted=False).ix array([2, 1, 0]) .. versionadded:: 2.0.0 T)rrrJ)rPrrr^rs r r;zAtomGroup.asunique s,V~~!4t   r"cD|jjjj|jS)a|Coordinates of the :class:`Atoms` in the :class:`AtomGroup`. A :class:`numpy.ndarray` with :attr:`~numpy.ndarray.shape`\ ``=(``\ :attr:`~AtomGroup.n_atoms`\ ``, 3)`` and :attr:`~numpy.ndarray.dtype`\ ``=numpy.float32``. The positions can be changed by assigning an array of the appropriate shape, i.e., either ``(``\ :attr:`~AtomGroup.n_atoms`\ ``, 3)`` to assign individual coordinates, or ``(3,)`` to assign the *same* coordinate to all :class:`Atoms` (e.g., ``ag.positions = array([0,0,0])`` will move all :class:`Atoms` to the origin). .. note:: Changing positions is not reflected in any files; reading any frame from the :attr:`~MDAnalysis.core.universe.Universe.trajectory` will replace the change with that from the file *except* if the :attr:`~MDAnalysis.core.universe.Universe.trajectory` is held in memory, e.g., when the :meth:`~MDAnalysis.core.universe.Universe.transfer_to_memory` method was used. Raises ------ ~MDAnalysis.exceptions.NoDataError If the underlying :class:`~MDAnalysis.coordinates.timestep.Timestep` does not contain :attr:`~MDAnalysis.coordinates.timestep.Timestep.positions`. rr2r3rLrrs r rLzAtomGroup.positions s>}'*4TW==r"cN|jjj}||j|jddf<dSrr3r^rcr3s r rLzAtomGroup.positions s+ ] % (#) TWaaaZ   r"cl|jjj}tj|j|jS)aVelocities of the :class:`Atoms` in the :class:`AtomGroup`. A :class:`numpy.ndarray` with :attr:`~numpy.ndarray.shape`\ ``=(``\ :attr:`~AtomGroup.n_atoms`\ ``, 3)`` and :attr:`~numpy.ndarray.dtype`\ ``=numpy.float32``. The velocities can be changed by assigning an array of the appropriate shape, i.e. either ``(``\ :attr:`~AtomGroup.n_atoms`\ ``, 3)`` to assign individual velocities or ``(3,)`` to assign the *same* velocity to all :class:`Atoms` (e.g. ``ag.velocities = array([0,0,0])`` will give all :class:`Atoms` zero :attr:`~Atom.velocity`). Raises ------ ~MDAnalysis.exceptions.NoDataError If the underlying :class:`~MDAnalysis.coordinates.timestep.Timestep` does not contain :attr:`~MDAnalysis.coordinates.timestep.Timestep.velocities`. )rr2r3rrrNrr^r3s r rNzAtomGroup.velocities s**] % (x dg.///r"cN|jjj}||j|jddf<dSrrr2r3rNrr5s r rNzAtomGroup.velocities + ] % ($* dgqqqj!!!r"cH|jjj}|j|jS)aNForces on each :class:`Atom` in the :class:`AtomGroup`. A :class:`numpy.ndarray` with :attr:`~numpy.ndarray.shape`\ ``=(``\ :attr:`~AtomGroup.n_atoms`\ ``, 3)`` and :attr:`~numpy.ndarray.dtype`\ ``=numpy.float32``. The forces can be changed by assigning an array of the appropriate shape, i.e. either ``(``\ :attr:`~AtomGroup.n_atoms`\ ``, 3)`` to assign individual forces or ``(3,)`` to assign the *same* force to all :class:`Atoms` (e.g. ``ag.forces = array([0,0,0])`` will give all :class:`Atoms` a zero :attr:`~Atom.force`). Raises ------ ~MDAnalysis.exceptions.NoDataError If the :class:`~MDAnalysis.coordinates.timestep.Timestep` does not contain :attr:`~MDAnalysis.coordinates.timestep.Timestep.forces`. rr2r3rGrr7s r rGzAtomGroup.forces s (] % (y!!r"cN|jjj}||j|jddf<dSrr<r5s r rGzAtomGroup.forces# + ] % ( & $'111*r"cX|jjj}||jS)axTemporary Timestep that contains the selection coordinates. A :class:`~MDAnalysis.coordinates.timestep.Timestep` instance, which can be passed to a trajectory writer. If :attr:`~AtomGroup.ts` is modified then these modifications will be present until the frame number changes (which typically happens when the underlying :attr:`~MDAnalysis.core.universe.Universe.trajectory` frame changes). It is not possible to assign a new :class:`~MDAnalysis.coordinates.timestep.Timestep` to the :attr:`AtomGroup.ts` attribute; change attributes of the object. )rr2r3 copy_slicer)r^trj_tss r r3z AtomGroup.ts( s' ),  ...r"Tgh㈵>g:0yE>N)periodicrtolatolupdatingr rdkit_kwargs smarts_kwargsc  |s"tjdtgS|f| z} D]G\} } t | t s-t d| jj | Ht fd| D}|rt|| }n=tfd|ddD|d }|S)aMSelect atoms from within this Group using a selection string. Returns an :class:`AtomGroup` sorted according to their index in the topology (this is to ensure that there are no duplicates, which can happen with complicated selections). Parameters ---------- sel : str string of the selection, eg "name Ca", see below for possibilities. othersel : iterable of str further selections to perform. The results of these selections will be appended onto the results of the first. periodic : bool (optional) for geometric selections, whether to account for atoms in different periodic images when searching atol : float, optional The absolute tolerance parameter for float comparisons. Passed to :func:``numpy.isclose``. rtol : float, optional The relative tolerance parameter for float comparisons. Passed to :func:``numpy.isclose``. updating : bool (optional) force the selection to be re evaluated each time the Timestep of the trajectory is changed. See section on **Dynamic selections** below. [``True``] sorted: bool, optional Whether to sort the output AtomGroup by index. rdkit_kwargs : dict (optional) Arguments passed to the :class:`~MDAnalysis.converters.RDKit.RDKitConverter` when using selection based on SMARTS queries smarts_kwargs : dict (optional) Arguments passed internally to RDKit's `GetSubstructMatches `_. **selgroups : keyword arguments of str: AtomGroup (optional) when using the "group" keyword in selections, groups are defined by passing them as keyword arguments. See section on **preexisting selections** below. Raises ------ TypeError If the arbitrary groups passed are not of type :class:`MDAnalysis.core.groups.AtomGroup` Examples -------- All simple selection listed below support multiple arguments which are implicitly combined with an or operator. For example .. testsetup:: AtomGroup.select_atoms from MDAnalysis.tests.datafiles import PSF, DCD import MDAnalysis as mda universe = mda.Universe(PSF, DCD) .. doctest:: AtomGroup.select_atoms >>> sel = universe.select_atoms('resname MET GLY') >>> sel is equivalent to .. doctest:: AtomGroup.select_atoms >>> sel = universe.select_atoms('resname MET or resname GLY') >>> sel Will select all atoms with a residue name of either MET or GLY. Subselections can be grouped with parentheses. .. doctest:: AtomGroup.select_atoms >>> sel = universe.select_atoms("segid 4AKE and not ( name H* O* )") >>> sel Existing :class:`AtomGroup` objects can be passed as named arguments, which will then be available to the selection parser. .. testsetup:: AtomGroup.select_atoms.namedarguments from MDAnalysis.tests.datafiles import PSF, DCD import MDAnalysis as mda universe = mda.Universe(PSF, DCD) sel = universe.select_atoms("segid 4AKE and not ( name H* O* )") .. doctest:: AtomGroup.select_atoms, AtomGroup.select_atoms.namedarguments >>> universe.select_atoms("around 10 group notHO", notHO=sel) Selections can be set to update automatically on frame change, by setting the `updating` keyword argument to `True`. This will return a :class:`UpdatingAtomGroup` which can represent the solvation shell around another object. .. testsetup:: AtomGroup.select_atoms.updating from MDAnalysis.tests.datafiles import PDB, XTC import MDAnalysis as mda universe = mda.Universe(PDB, XTC) .. doctest:: AtomGroup.select_atoms.updating :options: +NORMALIZE_WHITESPACE >>> universe.select_atoms("resname SOL and around 2.0 protein", ... updating=True) Notes ----- If exact ordering of atoms is required (for instance, for :meth:`~AtomGroup.angle` or :meth:`~AtomGroup.dihedral` calculations) then one supplies selections *separately* in the required order. Also, when multiple :class:`AtomGroup` instances are concatenated with the ``+`` operator, then the order of :class:`Atom` instances is preserved and duplicates are *not* removed. See Also -------- :ref:`selection-commands-label` for further details and examples. .. rubric:: Selection syntax The selection parser understands the following CASE SENSITIVE *keywords*: **Simple selections** protein, backbone, nucleic, nucleicbackbone selects all atoms that belong to a standard set of residues; a protein is identfied by a hard-coded set of residue names so it may not work for esoteric residues. segid *seg-name* select by segid (as given in the topology), e.g. ``segid 4AKE`` or ``segid DMPC`` resid *residue-number-range* resid can take a single residue number or a range of numbers. A range consists of two numbers separated by a colon (inclusive) such as ``resid 1:5``. A residue number ("resid") is taken directly from the topology. If icodes are present in the topology, then these will be taken into account. Ie 'resid 163B' will only select resid 163 with icode B while 'resid 163' will select only residue 163. Range selections will also respect icodes, so 'resid 162-163B' will select all residues in 162 and those in 163 up to icode B. resnum *resnum-number-range* resnum is the canonical residue number; typically it is set to the residue id in the original PDB structure. resname *residue-name* select by residue name, e.g. ``resname LYS`` name *atom-name* select by atom name (as given in the topology). Often, this is force field dependent. Example: ``name CA`` (for Cα atoms) or ``name OW`` (for SPC water oxygen) type *atom-type* select by atom type; this is either a string or a number and depends on the force field; it is read from the topology file (e.g. the CHARMM PSF file contains numeric atom types). It has non-sensical values when a PDB or GRO file is used as a topology atom *seg-name* *residue-number* *atom-name* a selector for a single atom consisting of segid resid atomname, e.g. ``DMPC 1 C2`` selects the C2 carbon of the first residue of the DMPC segment altloc *alternative-location* a selection for atoms where alternative locations are available, which is often the case with high-resolution crystal structures e.g. `resid 4 and resname ALA and altloc B` selects only the atoms of ALA-4 that have an altloc B record. moltype *molecule-type* select by molecule type, e.g. ``moltype Protein_A``. At the moment, only the TPR format defines the molecule type. record_type *record_type* for selecting either ATOM or HETATM from PDB-like files. e.g. ``select_atoms('name CA and not record_type HETATM')`` smarts *SMARTS-query* select atoms using Daylight's SMARTS queries, e.g. ``smarts [#7;R]`` to find nitrogen atoms in rings. Requires RDKit. All matches are combined as a single unique match. The `smarts` selection accepts two sets of key word arguments from `select_atoms()`: the ``rdkit_kwargs`` are passed internally to `RDKitConverter.convert()` and the ``smarts_kwargs`` are passed to RDKit's `GetSubstructMatches `_. By default, the `useChirality` kwarg in ``rdkit_kwargs`` is set to true and maxMatches in ``smarts_kwargs`` is ``max(1000, 10 * n_atoms)``, where ``n_atoms`` is either ``len(AtomGroup)`` or ``len(Universe.atoms)``, whichever is applicable. Note that the number of matches can occasionally exceed the default value of maxMatches, causing too few atoms to be returned. If this occurs, a warning will be issued. The problem can be fixed by increasing the value of maxMatches. This behavior may be updated in the future. .. testsetup:: AtomGroup.select_atoms.smarts from MDAnalysis.tests.datafiles import PSF, DCD from MDAnalysis.topology.guessers import guess_types import MDAnalysis as mda universe = mda.Universe(PSF, DCD) guessed_elements = guess_types(universe.atoms.names) universe.add_TopologyAttr('elements', guessed_elements) .. doctest:: AtomGroup.select_atoms.smarts >>> universe.select_atoms("smarts C", smarts_kwargs={"maxMatches": 100}) chiral *R | S* select a particular stereocenter. e.g. ``name C and chirality S`` to select only S-chiral carbon atoms. Only ``R`` and ``S`` will be possible options but other values will not raise an error. formalcharge *formal-charge* select atoms based on their formal charge, e.g. ``name O and formalcharge -1`` to select all oxygens with a negative 1 formal charge. **Boolean** not all atoms not in the selection, e.g. ``not protein`` selects all atoms that aren't part of a protein and, or combine two selections according to the rules of boolean algebra, e.g. ``protein and not resname ALA LYS`` selects all atoms that belong to a protein, but are not in a lysine or alanine residue **Geometric** around *distance* *selection* selects all atoms a certain cutoff away from another selection, e.g. ``around 3.5 protein`` selects all atoms not belonging to protein that are within 3.5 Angstroms from the protein point *x* *y* *z* *distance* selects all atoms within a cutoff of a point in space, make sure coordinate is separated by spaces, e.g. ``point 5.0 5.0 5.0 3.5`` selects all atoms within 3.5 Angstroms of the coordinate (5.0, 5.0, 5.0) prop [abs] *property* *operator* *value* selects atoms based on position, using *property* **x**, **y**, or **z** coordinate. Supports the **abs** keyword (for absolute value) and the following *operators*: **<, >, <=, >=, ==, !=**. For example, ``prop z >= 5.0`` selects all atoms with z coordinate greater than 5.0; ``prop abs z <= 5.0`` selects all atoms within -5.0 <= z <= 5.0. sphzone *radius* *selection* Selects all atoms that are within *radius* of the center of geometry of *selection* sphlayer *inner radius* *outer radius* *selection* Similar to sphzone, but also excludes atoms that are within *inner radius* of the selection COG isolayer *inner radius* *outer radius* *selection* Similar to sphlayer, but will find layer around all reference layer, creating an iso-surface. cyzone *externalRadius* *zMax* *zMin* *selection* selects all atoms within a cylindric zone centered in the center of geometry (COG) of a given selection, e.g. ``cyzone 15 4 -8 protein and resid 42`` selects the center of geometry of protein and resid 42, and creates a cylinder of external radius 15 centered on the COG. In z, the cylinder extends from 4 above the COG to 8 below. Positive values for *zMin*, or negative ones for *zMax*, are allowed. cylayer *innerRadius* *externalRadius* *zMax* *zMin* *selection* selects all atoms within a cylindric layer centered in the center of geometry (COG) of a given selection, e.g. ``cylayer 5 10 10 -8 protein`` selects the center of geometry of protein, and creates a cylindrical layer of inner radius 5, external radius 10 centered on the COG. In z, the cylinder extends from 10 above the COG to 8 below. Positive values for *zMin*, or negative ones for *zMax*, are allowed. **Connectivity** byres *selection* selects all atoms that are in the same segment and residue as selection, e.g. specify the subselection after the byres keyword bonded *selection* selects all atoms that are bonded to selection eg: ``select name H and bonded name O`` selects only hydrogens bonded to oxygens **Index** bynum *index-range* selects all atoms within a range of (1-based) inclusive indices, e.g. ``bynum 1`` selects the first atom in the universe; ``bynum 5:10`` selects atoms 5 through 10 inclusive. All atoms in the :class:`~MDAnalysis.core.universe.Universe` are consecutively numbered, and the index runs from 1 up to the total number of atoms. index *index-range* selects all atoms within a range of (0-based) inclusive indices, e.g. ``index 0`` selects the first atom in the universe; ``index 5:10`` selects atoms 6 through 11 inclusive. All atoms in the :class:`~MDAnalysis.core.universe.Universe` are consecutively numbered, and the index runs from 0 up to the total number of atoms - 1. **Preexisting selections** group `group-name` selects the atoms in the :class:`AtomGroup` passed to the function as a keyword argument named `group-name`. Only the atoms common to `group-name` and the instance :meth:`~MDAnalysis.core.groups.AtomGroup.select_atoms` was called from will be considered, unless ``group`` is preceded by the ``global`` keyword. `group-name` will be included in the parsing just by comparison of atom indices. This means that it is up to the user to make sure the `group-name` group was defined in an appropriate :class:`~MDAnalysis.core.universe.Universe`. global *selection* by default, when issuing :meth:`~MDAnalysis.core.groups.AtomGroup.select_atoms` from an :class:`~MDAnalysis.core.groups.AtomGroup`, selections and subselections are returned intersected with the atoms of that instance. Prefixing a selection term with ``global`` causes its selection to be returned in its entirety. As an example, the ``global`` keyword allows for ``lipids.select_atoms("around 10 global protein")`` --- where ``lipids`` is a group that does not contain any proteins. Were ``global`` absent, the result would be an empty selection since the ``protein`` subselection would itself be empty. When issuing :meth:`~MDAnalysis.core.groups.AtomGroup.select_atoms` from a :class:`~MDAnalysis.core.universe.Universe`, ``global`` is ignored. **Dynamic selections** If :meth:`~MDAnalysis.core.groups.AtomGroup.select_atoms` is invoked with named argument `updating` set to `True`, an :class:`~MDAnalysis.core.groups.UpdatingAtomGroup` instance will be returned, instead of a regular :class:`~MDAnalysis.core.groups.AtomGroup`. It behaves just like the latter, with the difference that the selection expressions are re-evaluated every time the trajectory frame changes (this happens lazily, only when the :class:`~MDAnalysis.core.groups.UpdatingAtomGroup` is accessed so that there is no redundant updating going on). Issuing an updating selection from an already updating group will cause later updates to also reflect the updating of the base group. A non-updating selection or a slicing operation made on an :class:`~MDAnalysis.core.groups.UpdatingAtomGroup` will return a static :class:`~MDAnalysis.core.groups.AtomGroup`, which will no longer update across frames. .. versionchanged:: 0.7.4 Added *resnum* selection. .. versionchanged:: 0.8.1 Added *group* and *fullgroup* selections. .. versionchanged:: 0.13.0 Added *bonded* selection. .. versionchanged:: 0.16.0 Resid selection now takes icodes into account where present. .. versionchanged:: 0.16.0 Updating selections now possible by setting the `updating` argument. .. versionchanged:: 0.17.0 Added *moltype* and *molnum* selections. .. versionchanged:: 0.19.0 Added strict type checking for passed groups. Added periodic kwarg (default True) .. versionchanged:: 0.19.2 Empty sel string now returns an empty Atom group. .. versionchanged:: 1.0.0 The ``fullgroup`` selection has now been removed in favor of the equivalent ``global group`` selection. Removed flags affecting default behaviour for periodic selections; periodic are now on by default (as with default flags) .. versionchanged:: 2.0.0 Added the *smarts* selection. Added `atol` and `rtol` keywords to select float values. Added the ``sort`` keyword. Added `rdkit_kwargs` to pass parameters to the RDKitConverter. .. versionchanged:: 2.2.0 Added `smarts_kwargs` to pass parameters to the RDKit GetSubstructMatch for *smarts* selection. z3Empty string to select atoms, empty group returned.z@Passed groups must be AtomGroups. You provided {} for group '{}'c 3fK|]+}tj|V,dS))rBrDrCrrFrGN)rParserparse) rrrDrBrFrC selgroupsrGrs r rz)AtomGroup.select_atoms.. si   &&%!!-"/'        r"c:g|]}|Sr$apply)rselr^s r rz*AtomGroup.select_atoms.. s#;;;S4;;;r"rNr)rr UserWarningitemsrr2rrzr~rSrr(rzrO)r^rPrBrCrDrErrFrGotherselrLsel_strsrthingr*atomgrps` ``` ``` ` r select_atomszAtomGroup.select_atoms? sj`   ME   8O6H$%OO--  LE5eY// 55;V0%66           "       'j(CCGG;;;;JqrrN;;;1 ##D))Gr"cPdddd}|dkrfdDS t||nW#t$rd|d}t|d t$r+d |d |}t |d wxYwfd t DS) a/Split :class:`AtomGroup` into a :class:`list` of :class:`AtomGroups` by `level`. Parameters ---------- level : {'atom', 'residue', 'molecule', 'segment'} .. versionadded:: 0.9.0 .. versionchanged:: 0.17.0 Added the 'molecule' level. rUrTrV)rIrHmoleculeatomc@g|]}jj|jgSr$)rrr)rar^s r rz#AtomGroup.split.. s'>>>ADM'/>>>r"zThis universe does not have zE information. Maybe it is not provided in the topology format in use.Nz level = 'z ' not supported, must be one of c(g|]}|kSr$r$)rindex levelindicesr^s r rz#AtomGroup.split..s3    & '   r")rrprrrr )r^r accessorsrr_s` @r splitzAtomGroup.split s0$#!  F??>>>>>>> > /"45)9::LL 3 3 3FuFFF !((d 2 / / /&E&&>>##&& V$$$ .  /     &|44    s 5AB 皙?皙?cddlm}m}m}ddlm}d}|d|||j|} | |j|jj } ||j d|} | | d | |j } ||j d |} | | d | |j}||j d |}| |dS) a1Guess bonds, angles, and dihedrals between the atoms in this :class:`AtomGroup` and add them to the underlying :attr:`~AtomGroup.universe`. Parameters ---------- vdwradii : dict, optional Dict relating atom types: vdw radii fudge_factor : float, optional The factor by which atoms must overlap each other to be considered a bond. Larger values will increase the number of bonds found. [0.55] lower_bound : float, optional The minimum bond length. All bonds found shorter than this length will be ignored. This is useful for parsing PDB with altloc records where atoms with altloc A and B may be very close together and there should be no chemical bond between them. [0.1] See Also -------- :func:`MDAnalysis.topology.guessers.guess_bonds` :func:`MDAnalysis.topology.guessers.guess_angles` :func:`MDAnalysis.topology.guessers.guess_dihedrals` .. versionadded:: 0.10.0 .. versionchanged:: 0.20.2 Now applies periodic boundary conditions when guessing bonds. .. versionchanged:: 2.5.0 Corrected misleading docs, and now allows passing of `fudge_factor` and `lower_bound` arguments. r)BondsAngles Dihedralsr)DefaultGuesserc t|j|S#t$r%|g}|||cYSwxYw)z*either get *name* or create one from *cls*)rrrpadd_TopologyAttr)rrr%r_s r get_TopAttrz*AtomGroup.guess_bonds..get_TopAttrGs^ q{D111!   s2ww""4(((  s,AAN) fudge_factor lower_boundrvdwradiirT)guessedangles dihedrals) topologyattrsrerfrgguesser.default_guesserrhrM guess_bondsrrLr _add_bonds guess_anglesrguess_dihedralsrp)r^rnrlrmrerfrgrhrkguesserbbondattrr\ angleattrddiheattrs r rtzAtomGroup.guess_bonds$s@@ <;;;;;;;;;<<<<<<   !. %#        DJ,@ A A;t}gu==At,,,   , ,K x@@ Q---  # #DK 0 0;t}k9EEAr"ct|dkrtdtj|j|jS)zThis :class:`AtomGroup` represented as a :class:`MDAnalysis.core.topologyobjects.Bond` object Raises ------ ValueError If the :class:`AtomGroup` is not length 2 .. versionadded:: 0.11.0 rz6bond only makes sense for a group with exactly 2 atoms)rrrBondrrrs r bondzAtomGroup.bondeA t99>>H #DGT];;;r"ct|dkrtdtj|j|jS)zThis :class:`AtomGroup` represented as an :class:`MDAnalysis.core.topologyobjects.Angle` object Raises ------ ValueError If the :class:`AtomGroup` is not length 3 .. versionadded:: 0.11.0 rz7angle only makes sense for a group with exactly 3 atoms)rrrAnglerrrs r rzAtomGroup.anglexsA t99>>I $TWdm<<>L '???r"ct|dkrtdtj|j|jS)aThis :class:`AtomGroup` represented as an :class:`MDAnalysis.core.topologyobjects.ImproperDihedral` object Raises ------ ValueError If the :class:`AtomGroup` is not length 4 .. versionadded:: 0.11.0 rz:improper only makes sense for a group with exactly 4 atoms)rrrImproperDihedralrrrs r improperzAtomGroup.impropersA t99>>L /GGGr"ct|dkrtdtj|j|jS)aThis :class:`AtomGroup` represented as an :class:`MDAnalysis.core.topologyobjects.UreyBradley` object Raises ------ ValueError If the :class:`AtomGroup` is not length 2 .. versionadded:: 1.0.0 rz>urey bradley only makes sense for a group with exactly 2 atoms)rrr UreyBradleyrrrs r ureybradleyzAtomGroup.ureybradleysA t99>>P *47DMBBBr"ct|dkrtdtj|j|jS)zThis :class:`AtomGroup` represented as an :class:`MDAnalysis.core.topologyobjects.CMap` object Raises ------ ValueError If the :class:`AtomGroup` is not length 5 .. versionadded:: 1.0.0 z6cmap only makes sense for a group with exactly 5 atoms)rrrCMaprrrs r cmapzAtomGroup.cmaprr" convert_to{trjname}_{frame}c t|jdkrtd|jj}||dkr |dd}nrt |t jrtd |j}||ur"td ||}n#t$r ||}YnwxYw|`tj tj |j\} } | | |j}t%j|||ndd }|d d} t|d kr| d krtd| |d } nt|d k} t)||| } | |fd|ji|5} || |jnC|jj} |D]}| |j ||n #||wxYwdddn #1swxYwYdS#ttf$rYnwxYw t1|||nd} | |fd|ji|5} | |jdddn #1swxYwYdS#tt2f$rYnwxYwtd |)a Write `AtomGroup` to a file. The output can either be a coordinate file or a selection, depending on the format. Examples -------- .. code-block:: python >>> ag = u.atoms >>> ag.write('selection.ndx') # Write a gromacs index file >>> ag.write('coordinates.pdb') # Write the current frame as PDB >>> # Write the trajectory in XTC format >>> ag.write('trajectory.xtc', frames='all') >>> # Write every other frame of the trajectory in PBD format >>> ag.write('trajectory.pdb', frames=u.trajectory[::2]) Parameters ---------- filename : str, optional ``None``: create TRJNAME_FRAME.FORMAT from filenamefmt [``None``] file_format : str, optional The name or extension of a coordinate, trajectory, or selection file format such as PDB, CRD, GRO, VMD (tcl), PyMol (pml), Gromacs (ndx) CHARMM (str) or Jmol (spt); case-insensitive [PDB] filenamefmt : str, optional format string for default filename; use substitution tokens 'trjname' and 'frame' ["%(trjname)s_%(frame)d"] bonds : str, optional how to handle bond information, especially relevant for PDBs. ``"conect"``: write only the CONECT records defined in the original file. ``"all"``: write out all bonds, both the original defined and those guessed by MDAnalysis. ``None``: do not write out bonds. Default is ``"conect"``. frames: array-like or slice or FrameIteratorBase or str, optional An ensemble of frames to write. The ensemble can be an list or array of frame indices, a mask of booleans, an instance of :class:`slice`, or the value returned when a trajectory is indexed. By default, `frames` is set to ``None`` and only the current frame is written. If `frames` is set to "all", then all the frame from trajectory are written. .. versionchanged:: 0.9.0 Merged with write_selection. This method can now write both selections out. .. versionchanged:: 0.19.0 Can write multiframe trajectories with the 'frames' argument. rz&Cannot write an AtomGroup with 0 atomsNrz)The "frames" argument cannot be a number.zpThe trajectory of {} provided to the frames keyword attribute is different from the trajectory of the AtomGroup.)trjnameframePDBT)extkeep multiframerFznCannot explicitely set "multiframe" to False and request more than 1 frame with the "frames" keyword argument.)rzrrzNo writer found for format: {})rrrrr2rrrrrrzrpospathsplitextbasenamefilenamerr rrrwriter3get_selection_writer_forr#)r^r file_format filenamefmtframesrtrj trj_framestest_trajectoryrrrwriterw current_framerus r rzAtomGroup.writesx tz??a  EFF Fm& >Vu__RRRJJ  0 1 1 $GHH H $"("3##--$%%+VF^^ $ " ) ) ) [  )  7++BG,<,GGDJ''''$'FLM+!+00AGGDJ////0M***M*** + + + + + + + + + + + + + + + FI&    D  .)@++eF AA$,A&AA $Q ### $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ F ./    D 9@@JJKKKsr1B!!B65B6H+1*HH< H HHH"%H"+H?>H?J'JJJJ/.J/rct|j|}t|t|jkr"td||jdkrt j|d}n}|jdkrr|"td|||}|jdkr"td|t j|d}|j|S)a/ Returns a sorted ``AtomGroup`` using a specified attribute as the key. Parameters ---------- key: str, optional The name of the ``AtomGroup`` attribute to sort by (e.g. ``ids``, ``ix``. default= ``ix`` ). keyfunc: callable, optional A function to convert multidimensional arrays to a single dimension. This 1D array will be used as the sort key and is required when sorting with an ``AtomGroup`` attribute key which has multiple dimensions. Note: this argument is ignored when the attribute is one dimensional. Returns ---------- :class:`AtomGroup` Sorted ``AtomGroup``. Example ---------- .. doctest:: AtomGroup.sort >>> import MDAnalysis as mda >>> from MDAnalysisTests.datafiles import PDB_small >>> u = mda.Universe(PDB_small) >>> ag = u.atoms[[3, 2, 1, 0]] >>> ag.ix array([3, 2, 1, 0]) >>> ag = ag.sort() >>> ag.ix array([0, 1, 2, 3]) >>> ag.positions array([[-11.921, 26.307, 10.41 ], [-11.447, 26.741, 9.595], [-12.44 , 27.042, 10.926], [-12.632, 25.619, 10.046]], dtype=float32) >>> ag = ag.sort("positions", lambda x: x[:, 1]) >>> ag.positions array([[-12.632, 25.619, 10.046], [-11.921, 26.307, 10.41 ], [-11.447, 26.741, 9.595], [-12.44 , 27.042, 10.926]], dtype=float32) Note ---------- This uses a stable sort as implemented by `numpy.argsort(kind='stable')`. .. versionadded:: 2.0.0 zpThe array returned by the attribute '{}' must have the same length as the number of atoms in the input AtomGrouprr\r]NzThe {} attribute returns a multidimensional array. In order to sort it, a function returning a 1D array (to be used as the sort key) must be passed to the keyfunc argumentzMThe function assigned to the argument 'keyfunc':{} doesn't return a 1D array.) rrrrrzrrra NameError)r^keykeyfuncrordersortkeyss r sortzAtomGroup.sortns ndj#&& s88s4: & &//5vc{{  8q==Js222EE X\\BCI&++  ws||H}!! >>DfWooJxh777Ez%  r"r)Nrbrc)NNrN)rN)%rSrrrrrrgrrrJrdrrKr'r rFrEr;rLrNrGr3rWrartrrrrrrrrrrrrrs@r r2r2 sVVp88888555X X  X _;;_;@""X"  X _  _ ""X" V !""  #"X 0 22! 2**X*X- - - - ^>>X>@***00X0.+++""X", ]'']'//X/4  yyyyyv ( ( ( T????B<<X<$==X=$@@X@$HHXH$CCXC$<<X<$,(899J' SLSLSLSLjO!O!O!O!O!O!O!O!r"r2ceZdZdZdZedZedZedZedZ edZ e j dZ ed Z ed Z dd Zd S)r3a)ResidueGroup base class. This class is used by a :class:`~MDAnalysis.core.universe.Universe` for generating its Topology-specific :class:`ResidueGroup` class. All the :class:`~MDAnalysis.core.topologyattrs.TopologyAttr` components are obtained from :class:`GroupBase`, so this class only includes ad-hoc methods specific to :class:`ResidueGroups`. ResidueGroups can be compared and combined using group operators. See the list of these operators on :class:`GroupBase`. .. deprecated:: 0.16.2 *Instant selectors* of Segments will be removed in the 1.0 release. .. versionchanged:: 1.0.0 Removed instant selectors, use select_atoms instead .. versionchanged:: 2.1.0 Indexing an ResidueGroup with ``None`` raises a ``TypeError``. c8t|j|jtffSr)r&rrr3rs r rzResidueGroup.__reduce__T]DG\BCCr"c|j}|j|jj|j}|||S)zAn :class:`AtomGroup` of :class:`Atoms` present in this :class:`ResidueGroup`. The :class:`Atoms` are ordered locally by :class:`Residue` in the :class:`ResidueGroup`. Duplicates are *not* removed. )rrrrresidues2atoms_1drrr^rags r rzResidueGroup.atomssF M WQ[^55dh?? @ ""4((( r"c*t|jS)zNumber of :class:`Atoms` present in this :class:`ResidueGroup`, including duplicate residues (and thus, duplicate atoms). Equivalent to ``len(self.atoms)``. rrrs r rzResidueGroup.n_atoms4:r"c|S)auThe :class:`ResidueGroup` itself. See Also -------- copy : return a true copy of the :class:`ResidueGroup` .. versionchanged:: 0.19.0 In previous versions, this returned a copy, but now the :class:`ResidueGroup` itself is returned. This should not affect any code but only speed up calculations. r$rs r rJzResidueGroup.residuesrr"c t|S)z_Number of residues in the :class:`ResidueGroup`. Equivalent to ``len(self)``. rrs r rzResidueGroup.n_residuesrr"c|jjt|j}d|jd<d|jd<||jd<||jd<|S)znGet sorted :class:`SegmentGroup` of the unique segments present in the :class:`ResidueGroup`. Tr@r>r7r<rrs r rKzResidueGroup.segments rr"ct|trtj|jf}n{t|t r|j}n^ d|D}nP#t$rCdd d|D}t|dwxYwt|tjs]t|t|kr=tdt|t|t||D]/\}}|jjj|j|0dS)Ncg|] }|j Sr$)segindex)rrs r rz)ResidueGroup.segments..rr"zECan only set ResidueGroup segments to Segment or SegmentGroup, not {}rc3^K|](}t|tt|V)dSr)rr7rRr s r rz(ResidueGroup.segments..$rr"z/Incorrect size: {} for ResidueGroup of size: {})rr7rrrr4rUrprzrrrrr|rrr move_residuer)r^rrrr rs r rKzResidueGroup.segmentss{ c7 # # 2?CL?33DD \ * * 2>DD 200C000! 2 2 2..4f ""-0"""// ''T1 2$ 00 SYY#d))5K5K6#c((CII.. dOO = =DAq M # & 3 3AD! < < < < = =rc*t|jS)znNumber of unique segments present in the ResidueGroup. Equivalent to ``len(self.segments)``. r&rs r r'zResidueGroup.n_segments7r(r"ct|jdd}d|jd<d|jd<||jd<||jd<|S)aReturn a :class:`ResidueGroup` containing sorted and unique :class:`Residues` only. Examples -------- .. testsetup:: ResidueGroup.unique import MDAnalysis as mda from MDAnalysis.tests.datafiles import PSF, DCD u = mda.Universe(PSF, DCD) .. doctest:: ResidueGroup.unique >>> rg = u.residues[[2, 1, 2, 2, 1, 0]] >>> rg >>> rg.ix array([2, 1, 2, 2, 1, 0]) >>> rg2 = rg.unique >>> rg2 >>> rg2.ix array([0, 1, 2]) >>> rg2.unique is rg2 False .. versionadded:: 0.16.0 .. versionchanged:: 0.19.0 If the :class:`ResidueGroup` is already unique, :attr:`ResidueGroup.unique` now returns the group itself instead of a copy. .. versionchanged:: 2.0.0 This function now always returns a copy. NTr@r>r7r<r/rs r rEzResidueGroup.unique?LJ"111%#' Z #' Z (- _%*/ &' r"FcD|||jjS)a}Return a :class:`ResidueGroup` containing unique :class:`Residues` only, with optional sorting. If the :class:`ResidueGroup` is unique, this is the group itself. Parameters ---------- sorted: bool (optional) Whether or not the returned ResidueGroup should be sorted by resindex. Returns ------- :class:`ResidueGroup` Unique ``ResidueGroup`` Examples -------- .. testsetup:: ResidueGroup.asunique import MDAnalysis as mda from MDAnalysis.tests.datafiles import PSF, DCD u = mda.Universe(PSF, DCD) .. doctest:: ResidueGroup.asunique >>> rg = u.residues[[2, 1, 2, 2, 1, 0]] >>> rg >>> rg.ix array([2, 1, 2, 2, 1, 0]) >>> rg2 = rg.asunique(sorted=True) >>> rg2 >>> rg2.ix array([0, 1, 2]) >>> rg2.asunique() is rg2 True .. versionadded:: 2.0.0 rr)rPrrJr1s r r;zResidueGroup.asuniquek X~~V4=3I~JJJr"Nr)rSrrrrrgrrrJrrKrdr'rEr;r$r"r r3r3s&&DDDX XX X  X _==_=@""X"))X)V,K,K,K,K,K,Kr"r3ceZdZdZdZedZedZedZedZ edZ edZ ed Z d d Z d S)r4aI:class:`SegmentGroup` base class. This class is used by a :class:`~MDAnalysis.core.universe.Universe` for generating its Topology-specific :class:`SegmentGroup` class. All the :class:`~MDAnalysis.core.topologyattrs.TopologyAttr` components are obtained from :class:`GroupBase`, so this class only includes ad-hoc methods specific to :class:`SegmentGroups`. :class:`SegmentGroups` can be compared and combined using group operators. See the list of these operators on :class:`GroupBase`. .. deprecated:: 0.16.2 *Instant selectors* of Segments will be removed in the 1.0 release. .. versionchanged:: 1.0.0 Removed instant selectors, use select_atoms instead .. versionchanged:: 2.1.0 Indexing an SegmentGroup with ``None`` raises a ``TypeError``. c8t|j|jtffSr)r&rrr4rs r rzSegmentGroup.__reduce__rr"c|j}|j|jj|j}|||S)a*An :class:`AtomGroup` of :class:`Atoms` present in this :class:`SegmentGroup`. The :class:`Atoms` are ordered locally by :class:`Residue`, which are further ordered by :class:`Segment` in the :class:`SegmentGroup`. Duplicates are *not* removed. )rrrrsegments2atoms_1drrrs r rzSegmentGroup.atomssF M WQ[^55dh?? @ ""4((( r"c*t|jS)zNumber of atoms present in the :class:`SegmentGroup`, including duplicate segments (and thus, duplicate atoms). Equivalent to ``len(self.atoms)``. rrs r rzSegmentGroup.n_atomsrr"c|jjtj|j}|||S)a A :class:`ResidueGroup` of :class:`Residues` present in this :class:`SegmentGroup`. The :class:`Residues` are ordered locally by :class:`Segment` in the :class:`SegmentGroup`. Duplicates are *not* removed. )rrJrrrTrrs r rJzSegmentGroup.residuess:] #BN4?$C$C D ""4((( r"c*t|jS)zNumber of residues present in this :class:`SegmentGroup`, including duplicate segments (and thus, residues). Equivalent to ``len(self.residues)``. rrs r rzSegmentGroup.n_residuess4=!!!r"c|S)auThe :class:`SegmentGroup` itself. See Also -------- copy : return a true copy of the :class:`SegmentGroup` .. versionchanged:: 0.19.0 In previous versions, this returned a copy, but now the :class:`SegmentGroup` itself is returned. This should not affect any code but only speed up calculations. r$rs r rKzSegmentGroup.segmentsrr"c t|S)z_Number of segments in the :class:`SegmentGroup`. Equivalent to ``len(self)``. rrs r r'zSegmentGroup.n_segmentsrr"ct|jdd}d|jd<d|jd<||jd<||jd<|S)aReturn a :class:`SegmentGroup` containing sorted and unique :class:`Segments` only. Examples -------- .. testsetup:: SegmentGroup.unique from MDAnalysis.tests.datafiles import CONECT import MDAnalysis as mda u = mda.Universe(CONECT) .. doctest:: SegmentGroup.unique >>> sg = u.segments[[2, 1, 2, 2, 1, 0]] >>> sg >>> sg.ix array([2, 1, 2, 2, 1, 0]) >>> sg2 = sg.unique >>> sg2 >>> sg2.ix array([0, 1, 2]) >>> sg2.unique is sg2 False .. versionadded:: 0.16.0 .. versionchanged:: 0.19.0 If the :class:`SegmentGroup` is already unique, :attr:`SegmentGroup.unique` now returns the group itself instead of a copy. .. versionchanged:: 2.0.0 This function now always returns a copy. NTr@r>r7r<r/rs r rEzSegmentGroup.uniquerr"FcD|||jjS)ayReturn a :class:`SegmentGroup` containing unique :class:`Segments` only, with optional sorting. If the :class:`SegmentGroup` is unique, this is the group itself. Parameters ---------- sorted: bool (optional) Whether or not the returned SegmentGroup should be sorted by segindex. Returns ------- :class:`SegmentGroup` Unique ``SegmentGroup`` Examples -------- .. testsetup:: SegmentGroup.asunique from MDAnalysis.tests.datafiles import CONECT import MDAnalysis as mda u = mda.Universe(CONECT) .. doctest:: SegmentGroup.asunique >>> sg = u.segments[[2, 1, 2, 2, 1, 0]] >>> sg >>> sg.ix array([2, 1, 2, 2, 1, 0]) >>> sg2 = sg.asunique(sorted=True) >>> sg2 >>> sg2.ix array([0, 1, 2]) >>> sg2.asunique() is sg2 True .. versionadded:: 2.0.0 r)rPrrKr1s r r;zSegmentGroup.asunique+rr"Nr)rSrrrrrgrrrJrrKr'rEr;r$r"r r4r4s&DDDX"XX ""X"X X))X)V,K,K,K,K,K,Kr"r4ceZdZdZdZfdZdZdZdZdZ e dZ d Z e d Ze d Ze d ZxZS) r;zBase class from which a :class:`~MDAnalysis.core.universe.Universe`\ 's Component class is built. Components are the individual objects that are found in Groups. ctt|tjstd||_||_dS)Nz1Component can only be indexed by a single integer)rrrrrr)r^rrs r rzComponentBase.__init__bs@"g.// C r"ct|j}|tvryt|}||jkr7||jkr,d}t ||||jd}t||jtt| |S)Nz:{selfcls} has no attribute {attr}. Do you mean {singular}?)rr_rjrr) rRrSrrfrjrprzrr{r;rrs r rzComponentBase.__getattr__lst**% ? " "!$'Cs|## (<(<.%JJ 'dS\ N!#**cl*"C"CDDD--99$?? ?r"c`|j|jkrtd|j|jkSNz%Can't compare different level objectsrrrrs r __lt__zComponentBase.__lt__s/ : $ $CDD Dw!!r"c`|j|jkrtd|j|jkSrrrs r r zComponentBase.__eq__s/ : $ $CDD Dw%(""r"c||k Srr$rs r __ne__zComponentBase.__ne__s5=  r"c*t|jSr)rrrs r rzComponentBase.__hash__sDG}}r"c|j}|jtj|j|g|jS)a`Concatenate the Component with another Component or Group of the same level. Parameters ---------- other : Component or Group Component or Group with `other.level` same as `self.level` Returns ------- Group Group with elements of `self` and `other` concatenated )rrrrrrrs r rzComponentBase.__add__s=~z  NDM40 1 14=   r"c|dkr%|j|j|jSt dt |jt |j)a^Using built-in sum requires supporting 0 + self. If other is anything other 0, an exception will be raised. Parameters ---------- other : int Other should be 0, or else an exception will be raised. Returns ------- self Group with elements of `self` reproduced rr)rrrrrrzrRrSrs r rzComponentBase.__radd__sf A:::$$T]DMBB B!!'JJ'e)="" r"c|jSrr-rs r rzComponentBase.universes wr"c|jS)a(Unique index of this component. If this component is an :class:`Atom`, this is the index of the :class:`Atom`. If it is a :class:`Residue`, this is the index of the :class:`Residue`. If it is a :class:`Segment`, this is the index of the :class:`Segment`. r/rs r rzComponentBase.ixs xr"cNtj|jgtjS)zUnique index of this component as an array. This method gives a consistent API between components and groups. See Also -------- ix r)rrrrrs r rzComponentBase.ix_arraysx 1111r")rSrrrrrrr rrrrrrgrrrrrs@r r;r;Zs @@@@@(""" ### !!!   (0XX 2 2X 2 2 2 2 2r"r;c<eZdZdZdZdZfdZedZej dZedZ e j dZ ed Z e j d Z ed Z e j d Z ed Z e j dZ xZS)r5ap:class:`Atom` base class. This class is used by a :class:`~MDAnalysis.core.universe.Universe` for generating its Topology-specific :class:`Atom` class. All the :class:`~MDAnalysis.core.topologyattrs.TopologyAttr` components are obtained from :class:`ComponentBase`, so this class only includes ad-hoc methods specific to :class:`Atoms`. cbd|jdz}t|dr|d|jz }t|dr|d|jz }t|dr|d|jz }t|d r|d |jz }t|d r|d |jz }t|d r|d|jz }|dzS)Nz ) rzrryrrRrrrrr^mes r r z Atom.__repr__s,   ! , , 4  * %,,ty)) )B 4  2 -&&ty11 1B 4 # # 9 #**4<88 8B 4 ! ! 1 +$$TZ00 0B 4 ! ! 5 /((44 4B 4 " " 7 "))$+66 6BCxr"c8t|j|jtffSr)r&rrr5rs r rzAtom.__reduce__sT]DGT:;;r"cddd}||vrtd||z|dkrtdtt||S)NrNrG)rQrOrrPr)rr{r5r)r^r_r3r~s r rzAtom.__getattr__si& : : 2::54@AA A Z  @AA AT4  ,,T222r"cP|jj|jjj|Sr)rrJrrTrs r rHz Atom.residue}%dm&=&H&NOOr"ct|ts/tdt ||jjj|j |j dS)Nz,Can only set Atom residue to Residue, not {}) rr6rrzrRrrrrrr r$s r rHz Atom.residuesh#w'' 6$s))$$  ",,TWclCCCCCr"cP|jj|jjj|SrrrKrrUrs r rIz Atom.segment rr"c td)Nz;Cannot set atom segment. Segments are assigned to Residuesr"r$s r rIz Atom.segments! L   r"ch|jjjj|jS)a/Coordinates of the atom. The position can be changed by assigning an array of length (3,). .. note:: changing the position is not reflected in any files; reading any frame from the trajectory will replace the change with that from the file Raises ------ ~MDAnalysis.exceptions.NoDataError If the underlying :class:`~MDAnalysis.coordinates.timestep.Timestep` does not contain :attr:`~MDAnalysis.coordinates.timestep.Timestep.positions`. )rr2r3rLrr4rs r rPz Atom.positions("}'*4TW=BBDDDr"cJ||jjjj|jddf<dSrr3)r^rcs r rPz Atom.position)s'r")rSrrrr rrrgrHrdrIrPrQrOrrs@r r5r5s <<<33333PPXP ^DD^DPPXP ^  ^ EEXE$_CC_C--X-&_++_+))X)& \''\'''''r"r5cjeZdZdZdZdZedZedZej dZdS)r6a|:class:`Residue` base class. This class is used by a :class:`~MDAnalysis.core.universe.Universe` for generating its Topology-specific :class:`Residue` class. All the :class:`~MDAnalysis.core.topologyattrs.TopologyAttr` components are obtained from :class:`ComponentBase`, so this class only includes ad-hoc methods specific to :class:`Residues`. cd}t|dr|d|jz }t|dr|d|jz }|dzS)Nz>r"c|jj|jjj|d}d|jd<d|jd<||jd<||jd<|S)z`An :class:`AtomGroup` of :class:`Atoms` present in this :class:`Residue`. rTr@r>r7r<rrrrrr^rs r rz Residue.atomsv[ ] !8!@!Fq!I J $ * $ *%' /"') #$ r"cP|jj|jjj|S)z6The :class:`Segment` this :class:`Residue` belongs to.rrs r rIzResidue.segments!}%dm&=&H&NOOr"ct|ts/tdt ||jjj|j |j dS)Nz/Can only set Residue segment to Segment, not {}) rr7rrzrRrrrrrrr$s r rIzResidue.segmentsh#w'' 6$s))$$  "//FFFFFr"N) rSrrrr rrgrrIrdr$r"r r6r6`s???  X PPXP ^GG^GGGr"r6cJeZdZdZdZdZedZedZdS)r7a:class:`Segment` base class. This class is used by a :class:`~MDAnalysis.core.universe.Universe` for generating its Topology-specific :class:`Segment` class. All the :class:`~MDAnalysis.core.topologyattrs.TopologyAttr` components are obtained from :class:`ComponentBase`, so this class only includes ad-hoc methods specific to :class:`Segments`. .. deprecated:: 0.16.2 *Instant selectors* of :class:`Segments` will be removed in the 1.0 release. .. versionchanged:: 1.0.0 Removed instant selectors, use either segment.residues[...] to select residue by number, or segment.residues[segment.residue.resnames = ...] to select by resname. cjd}t|dr|d|jz }|dzS)Nz` present in this :class:`Segment`. rTr@r>r7r<rrs r rz Segment.atomsrr"c|jj|jjj|d}d|jd<d|jd<||jd<||jd<|S)zhA :class:`ResidueGroup` of :class:`Residues` present in this :class:`Segment`. rTr@r>r7r<)rrJrrTrrs r rJzSegment.residuess` ] # M # .t 4Q 7 !% * $ *%' /"') #$ r"N) rSrrrr rrgrrJr$r"r r7r7sr" ???  X   X   r"r7> rrrr~ _base_group _lastupdate _selections is_uptodaterY_ensure_updatedupdate_selectionceZdZdZdZfdZedZejdZdZ dZ dZ fd Z ed Z d ZxZS) r(a:class:`AtomGroup` subclass that dynamically updates its selected atoms. Accessing any attribute/method of an :class:`UpdatingAtomGroup` instance triggers a check for the last frame the group was updated. If the last frame matches the current trajectory frame, the attribute is returned normally; otherwise the group is updated (the stored selections are re-applied), and only then is the attribute returned. .. versionadded:: 0.16.0 c|j|_||_||_||_d|_|j|_|jr|dSdS)a' Parameters ---------- base_group : :class:`AtomGroup` group on which *selections* are to be applied. selections : a tuple of :class:`~MDAnalysis.core.selection.Selection` instances selections ready to be applied to *base_group*. N)rrr_selection_stringsr r rYr)r^ base_groupr*stringss r rzUpdatingAtomGroup.__init__sh%%")%(7   #  " " " " " # #r"cZ|j|j}|rCtfd|ddD|dj}n t jgt j}tt| ||j d|_ dS)z Forces the reevaluation and application of the group's selection(s). This method is triggered automatically when accessing attributes, if the last update occurred under a different trajectory frame. c:g|]}|Sr$rN)rrPbgs r rz6UpdatingAtomGroup.update_selection..s#888ciimm888r"rNrrT) r rrzrOrrrrr{r(rrr)r^selsrrr~s @r rz"UpdatingAtomGroup.update_selections   -8888tABBx888$q'--:K:KLLOBB"BG,,,B &&//DMBBBr"cn |jjj|jkS#t$r|jdkcYSwxYw)a Checks whether the selection needs updating based on frame number only. Modifications to the coordinate data that render selections stale are not caught, and in those cases :attr:`is_uptodate` may return an erroneous value. Returns ------- bool ``True`` if the group's selection is up-to-date, ``False`` otherwise. rrr2rr rprs r rzUpdatingAtomGroup.is_uptodatesL *=+1T5EE E * * *#r) ) ) ) *s 44cz|r1 |jjj|_dS#t$r d|_YdSwxYwd|_dS)Nrr)r^r}s r rzUpdatingAtomGroup.is_uptodate.sa  $ &#'=#;#A   ! & & &#%     & $D   s 11c@|j}|s||S)z Checks whether the selection needs updating and updates it if needed. Returns ------- bool ``True`` if the group was already up-to-date, ``False`` otherwise. )rr)r^statuss r rz!UpdatingAtomGroup._ensure_updated9s+! $  ! ! # # # r"c|ds|tvs|t||S)Nru)rx_UAG_SHORTCUT_ATTRSrr__getattribute__r s r r"z"UpdatingAtomGroup.__getattribute__GsK$$ #0C(C(C  " " "&&tT222r"c\t|j|j|jffSr)r/r rrrrs r rzUpdatingAtomGroup.__reduce__Ps4  ++-- '   r"cjtt|}|js|Sdd|j}|j|jjurd}nd}d|dddt|jdkd||S) Nz'{}'z' + 'zthe entire Universe.zanother AtomGroup.z{}, with selection{} {} on {}>rrr) r{r(r rrzrr rrr)r^basestrrbasegrpr~s r r zUpdatingAtomGroup.__repr__^s)40099;;& N}}W\\$*ABBCC  t}2 2 2,GG*G/66 CRCL D+,,133 4      r"c|ddS)aGet a *static* :class:`AtomGroup` identical to the group of currently selected :class:`Atoms` in the :class:`UpdatingAtomGroup`. By returning a *static* :class:`AtomGroup` it becomes possible to compare the contents of the group *between* trajectory frames. See the Example below. Note ---- The :attr:`atoms` attribute of an :class:`UpdatingAtomGroup` behaves differently from :attr:`AtomGroup.atoms`: the latter returns the :class:`AtomGroup` itself whereas the former returns a :class:`AtomGroup` and not an :class:`UpdatingAtomGroup` (for this, use :meth:`UpdatingAtomGroup.copy`). Example ------- The static :attr:`atoms` allows comparison of groups of atoms between frames. For example, track water molecules that move in and out of a solvation shell of a protein .. code-block:: python u = mda.Universe(TPR, XTC) water_shell = u.select_atoms("name OW and around 3.5 protein", updating=True) water_shell_prev = water_shell.atoms for ts in u.trajectory: exchanged = water_shell - water_shell_prev print(ts.time, "waters in shell =", water_shell.n_residues) print(ts.time, "waters that exchanged = ", exchanged.n_residues) print(ts.time, "waters that remained bound = ", water_shell.n_residues - exchanged.n_residues) water_shell_prev = water_shell.atoms By remembering the atoms of the current time step in `water_shell_prev`, it becomes possible to use the :meth:`subtraction of AtomGroups` to find the water molecules that changed. See Also -------- copy : return a true copy of the :class:`UpdatingAtomGroup` Nr$rs r rzUpdatingAtomGroup.atomsqslAAAwr"cBt|j|j|jS)ziGet another :class:`UpdatingAtomGroup` identical to this one. .. versionadded:: 0.19.0 )r(r rrrs r r4zUpdatingAtomGroup.copys& !  d.0G   r")rSrrrrrrgrrdrr"rr rr4rrs@r r(r(s  &###.     &**X*&$$$   333         &55X5n       r"r(Level)rrjrrZrHrIcfd}|S)a\Decorator to check if all :class:`AtomGroup` arguments have certain attributes Example ------- When used to wrap a function, will check all :class:`AtomGroup` arguments for the listed requirements @requires('masses', 'charges') def mass_times_charge(atomgroup): return atomgroup.masses * atomgroup.charges cJtjfd}|S)Nc |D]cttrLfdD}|r.require_dec..check_args..s(NNNWQ=M=MNtNNNr"zR{funcname} failed. AtomGroup is missing the following required attributes: {attrs}r)funcnameattrs)rr2rrzrSr)rrmissingr\r/rs @r check_argsz1requires..require_dec..check_argss  a++ NNNNNNNG)228&)-&*ii&8&839334((( (r"r)rr1r/s` r require_deczrequires..require_decs?    ) ) ) ) )   ) r"r$)r/r2s` r requiresr3s$( r")Dr collectionsrnumpyrrrrrrnrrrrrrlibr lib.utilr r r r rrrrr`rrr*rrr exceptionsrr _get_readersrrr!r&r/rCrr8rrXrrrr:r2r3r4total_orderingr;r5r6r7r!r(_Level ATOMLEVEL RESIDUELEVEL SEGMENTLEVELrr3r$r"r r?sF0DDJ#"""""  !!!!!!11111111??????$$$$$$;;;;;;;; === DXEXEXEXEXEVXEXEXEvQQQQQ6QQQhV&   4\<\<\<\<\< \<\<\<~>}!}!}!}!}! }!}!}!@.WKWKWKWKWK9WKWKWKt}K}K}K}K}K9}K}K}K@ {2{2{2{2{2L{2{2{2|D'D'D'D'D'=D'D'D'N.G.G.G.G.Gm.G.G.Gb33333m333r$U U U U U U U U t G;;; < < F64 + + vi,77 vi,77    !  ! """""r"