iPXvdZddlmZddlZddlZddlZddlZddlm Z ddl m Z ddl m Z Gd d eZdS) a* Default Guesser ================ .. _DefaultGuesser: DefaultGuesser is a generic guesser class that has basic guessing methods. This class is a general purpose guesser that can be used with most topologies, but being generic makes it the least accurate among all guessers. Guessing behavior ----------------- This section describes how each attribute is guessed by the DefaultGuesser. Masses ~~~~~~ We first attempt to look up the mass of an atom based on its element if the element TopologyAttr is available. If not, we attempt to lookup the mass based on the atom type (``type``) TopologyAttr. If neither of these is available, we attempt to guess the atom type based on the atom name (``name``) and then lookup the mass based on the guessed atom type. Types ~~~~~ We attempt to guess the atom type based on the atom name (``name``). The name is first stripped of any numbers and symbols, and then looked up in the :data:`MDAnalysis.guesser.tables.atomelements` table. If the name is not found, we continue checking variations of the name following the logic in :meth:`DefaultGuesser.guess_atom_element`. Ultimately, if no match is found, the first character of the stripped name is returned. Elements ~~~~~~~~ This follows the same method as guessing atom types. Bonds ~~~~~ Bonds are guessed based on the distance between atoms. See :meth:`DefaultGuesser.guess_bonds` for more details. Angles ~~~~~~ Angles are guessed based on the bonds between atoms. See :meth:`DefaultGuesser.guess_angles` for more details. Dihedrals ~~~~~~~~~ Dihedrals are guessed based on the angles between atoms. See :meth:`DefaultGuesser.guess_dihedrals` for more details. Improper Dihedrals ~~~~~~~~~~~~~~~~~~ Improper dihedrals are guessed based on the angles between atoms. See :meth:`DefaultGuesser.guess_improper_dihedrals` for more details. Aromaticities ~~~~~~~~~~~~~ Aromaticity is guessed using RDKit's GetIsAromatic method. See :meth:`DefaultGuesser.guess_aromaticities` for more details. Classes ------- .. autoclass:: DefaultGuesser :members: :inherited-members: ) GuesserBaseN) NoDataError) distances)tablesceZdZdZdZ dfd ZddZdZd Zdd Z d Z dd Z dd Z ddZ ddZdZddZdZxZS)DefaultGuessera_ This guesser holds generic methods (not directed to specific contexts) for guessing different topology attribute. It has the same methods which where originally found in Topology.guesser.py. The attributes that can be guessed by this class are: - masses - types - elements - angles - dihedrals - bonds - improper dihedrals - aromaticities You can use this guesser either directly through an instance, or through the :meth:`~MDAnalysis.core.universe.Universe.guess_TopologyAttrs` method. Parameters ---------- universe : Universe The Universe to apply the guesser on box : np.ndarray, optional The box of the Universe. This is used for bond guessing. vdwradii : dict, optional Dict relating atom types: vdw radii. This is used for bond guessing 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] Examples -------- to guess bonds for a universe:: import MDAnalysis as mda from MDAnalysisTests.datafiles import two_water_gro u = mda.Universe(two_water_gro, context='default', to_guess=['bonds']) .. versionadded:: 2.8.0 defaultN皙?皙?c tj|f||||d||j|j|j|j|j|j|j|jd|_ dS)N)boxvdwradii fudge_factor lower_bound)massestypeselementsbondsangles dihedrals impropers aromaticities) super__init__ guess_masses guess_types guess_bonds guess_anglesguess_dihedralsguess_improper_dihedralsguess_aromaticities_guesser_methods)selfuniverserrrrkwargs __class__s l/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/MDAnalysis/guesser/default_guesser.pyrzDefaultGuesser.__init__s   %#       '%(%'-6!5 ! ! c| jjj}nx#t$rk jjj}nU#t$rH jjj}n#t$rtddwxYwYnwxYwYnwxYw|||}tjfd|Dtj }|S)a Guess the mass of many atoms based upon their type. For guessing masses through :meth:`~MDAnalysis.core.universe.Universe.guess_TopologyAttrs`: First try to guess masses from atom elements, if not available, try to guess masses from types and if not available, try to guess types. Parameters ---------- atom_types : Optional[np.ndarray] Atom types/elements to guess masses from indices_to_guess : Optional[np.ndarray] Mask array for partially guess masses for certain atoms Returns ------- atom_masses : np.ndarray dtype float64 Raises ------ :exc:`ValueError` If there are no atom types or elements to guess mass from. N atom_typesz`there is no reference attributes (elements, types, or names) in this universe to guess mass fromc:g|]}|S) get_atom_mass.0atomr%s r) z/DefaultGuesser.guess_masses..s' = = =$T   % % = = =r*dtype) _universeatomsrrrrnamesnparrayfloat64)r%r-indices_to_guessrs` r)rzDefaultGuesser.guess_massess#2   $!^1:  $ $ $ $!%!5!;JJ" $ $ $ $%)%5%5'+~';'A&6&& '$$$)C $ $$#  $ $  '#$45J = = = =* = = =RZ    sF B 4B  B%A%$B%BBB BB  B c tj|S#t$rT tj|cYS#t$rt jdt YYdSwxYwwxYw)zReturn the atomic mass in u for *element*. Masses are looked up in :data:`MDAnalysis.guesser.tables.masses`. .. Warning:: Until version 3.0.0 unknown masses are set to 0.0 zUnknown masses are set to 0.0 for current version, this will be deprecated in version 3.0.0 and replaced by Masse's no_value_label (np.nan))rrKeyErrorupperwarningswarnPendingDeprecationWarning)r%elements r)r0zDefaultGuesser.get_atom_masss =) )    }W]]__5555    7.  sss  s, A2#AA2$A.)A2-A..A2cR|||S)aGuess a mass based on the atom name. :func:`guess_atom_element` is used to determine the kind of atom. .. warning:: Until version 3.0.0 anything not recognized is simply set to 0.0; if you rely on the masses you might want to double-check. )r0guess_atom_element)r%atomnames r)guess_atom_masszDefaultGuesser.guess_atom_mass s&!!$"9"9("C"CDDDr*c|1 jjj}n#t$rtddwxYw|||}t jfd|Dt S)aGuess the atom type of many atoms based on atom name Parameters ---------- atom_types (optional) atoms names if types guessing is desired to be from names indices_to_guess (optional) Mask array for partially guess types for certain atoms Returns ------- atom_types : np.ndarray dtype object Raises ------ :exc:`ValueError` If there is no names to guess types from. NzEthere is no reference attributes in this universe to guess types fromc:g|]}|Sr/)rGr1s r)r4z.DefaultGuesser.guess_types..6s' B B BtT $ $T * * B B Br*r5)r7r8r9rr:r;object)r%r-r=s` r)rzDefaultGuesser.guess_typess(   !^17    !*   '#$45Jx B B B Bz B B B    s2ctjd}tjd}|dkrdS tj|S#t $rtj|d|}tj|d|}|tjvrtj|cYS|r|tjvr|cYS|ddtjvr |ddcYS|ddtjvr |ddcYSt|dkr |dcYS|dd}||cYSwxYw) aGuess the element of the atom from the name. First all numbers and symbols are stripped from the name. Then the name is looked up in the :data:`MDAnalysis.guesser.tables.atomelements` table. If the name is not found, we remove the last character or first character from the name and check the table for both, with a preference for removing the last character. If the name is still not found, we iteratively continue to remove the last character or first character until we find a match. If ultimately no match is found, the first character of the stripped name is returned. If the input name is an empty string, an empty string is returned. The table comes from CHARMM and AMBER atom types, where the first character is not sufficient to determine the atom type. Some GROMOS ions have also been added. .. Warning: The translation table is incomplete. This will probably result in some mistakes, but it still better than nothing! See Also -------- :func:`guess_atom_type` :mod:`MDAnalysis.guesser.tables` z[0-9]z[*+-]Nrrr) recompiler atomelementsrAr@subrlen)r%rHNUMBERSSYMBOLS no_symbolsnames r)rGz!DefaultGuesser.guess_atom_element:sl8*X&&*X&& r>>2 &x~~'7'78 8   X66J6'2z2288::Dv****40000 !6?**KKK9//9$$$8v..8OOOt99>>7NNNCRCy !   + s0#AA(EE E6 EE5EEc | |jj}||jjj}t|t|krt d|jdd}tj |jdd}|r |t|dr|j }n| |j}tfdt!|DsDt d d fd t!|Dzd zd z|jdd}|jdd}|t%j|}t)fd|D}g} t+j|d|z||\} } t/| D]a\} \} }|| ||z|z}| | |kr-| || j||jfbt5| S)aGuess if bonds exist between two atoms based on their distance. Bond between two atoms is created, if the two atoms are within .. math:: d < f \cdot (R_1 + R_2) of each other, where :math:`R_1` and :math:`R_2` are the VdW radii of the atoms and :math:`f` is an ad-hoc *fudge_factor*. This is the `same algorithm that VMD uses`_. Parameters ---------- atoms: AtomGroup atoms for which bonds should be guessed coords: np.ndarray, optional coordinates of the atoms. If not provided, the coordinates of the ``atoms`` in the universe are used. Returns ------- list List of tuples suitable for use in Universe topology building. Warnings -------- No check is done after the bonds are guessed to see if Lewis structure is correct. This is wrong and will burn somebody. Raises ------ :exc:`ValueError` If inputs are malformed or `vdwradii` data is missing. .. _`same algorithm that VMD uses`: http://www.ks.uiuc.edu/Research/vmd/vmd-1.9.1/ug/node26.html Nz+'atoms' and 'coord' must be the same lengthrr rrr,c3 K|]}|vV dSNr/)r2valrs r) z-DefaultGuesser.guess_bonds..s'==s3(?======r*zvdw radii for types: z, cg|]}|v| Sr/r/r2trs r)r4z.DefaultGuesser.guess_bonds..s#HHHqax6G6G6G6G6Gr*z). These can be defined manually using thez keyword 'vdwradii'rr rc g|] }| Sr/r/r_s r)r4z.DefaultGuesser.guess_bonds..s666qx{666r*g@) max_cutoff min_cutoffr)r7r8 positionsrT ValueError_kwargsgetrrcopyupdatehasattrrrr9allsetjoinr:asarraymaxrself_capped_distance enumerateappendindextuple)r%r8coordsr user_vdwradii atomtypesrrmax_vdwrpairsdistidxijdrs @r)rzDefaultGuesser.guess_bondsssR =N(E >^)3F u::V $ $JKK K|''== ?'')) ((T::  + OOM * * * 5' " " A II((EK(@@I====c)nn===== +iiHHHHC NNHHHB B - -   l&&}c:: lud++ ?*S//C 6666I666774 sW}#   t%U++ ? ?KC!Q1&)A,)??ACy1}} eAhneAhn=>>>U||r*cddlm}t}|t|jjdr|jjj}n{|t|jj}| | |jj|jjj |jj}|D]}|D]}| |}|jD]p}||krh| |} t|j|j| jg} | d| dkr | ddd} || qt|S)aGiven a list of Bonds, find all angles that exist between atoms. Works by assuming that if atoms 1 & 2 are bonded, and 2 & 3 are bonded, then (1,2,3) must be an angle. Parameters ---------- bonds : Bonds from which angles should be guessed Returns ------- list of tuples List of tuples defining the angles. Suitable for use in u._topology See Also -------- :meth:`guess_bonds` rUniverseNrn_atomsrrO) core.universerrlrjr7r8remptyrT add_bondsrrdpartnerrtrsadd) r%rr angles_foundtemp_ubr3other_aother_bthird_adescs r)r zDefaultGuesser.guess_angless}. -,,,,,uu =t~+W55 +,2!DN4H0I0IJJ  $$,dn.B.L  * / /A / /))D//#z / /G!||")//$"7"7$$]DJ F   7T"X--#'":D$((... / /\"""r*cddlm}|t|jjdr|jjj}n|t|jj}|| |jj|jjj | | |jj |jj}t}|D]}td|D}t!|jd|jdg|ddd|gD]x\}}|j D]k} | ||vrR| |} || jfz} | d| dkr | ddd} || lyt|S) aGiven a list of Angles, find all dihedrals that exist between atoms. Works by assuming that if (1,2,3) is an angle, and 3 & 4 are bonded, then (1,2,3,4) must be a dihedral. Parameters ---------- angles : Angles from which dihedrals should be guessed Returns ------- list of tuples List of tuples defining the dihedrals. Suitable for use in u._topology rrNrrcg|] }|j Sr/rs)r2as r)r4z2DefaultGuesser.guess_dihedrals..9s...q17...r*rrO)rrrjr7r8rrrTrrrd add_anglesr rrlrtziprrsr) r%rrrdihedrals_foundra_tupr3prefixrrrs r)r!zDefaultGuesser.guess_dihedralss$ -,,,,, >t~+X66 --4"DN4H0I0IJJ  $$,dn.B.L !!$"3"3FL4F"G"GHHH,%% 2 2A..A...//E!$QWR[)E$$B$K+?!! 2 2 f $z22G"??400A55")//$"7"7%(887T"X--#'":D'++D111 2 2_%%%r*c ddlm}|t|jjdr|jjj}n|t|jj}|| |jj|jjj | | |jj |jj}t}|D] d}t fddD}|j D]X}||}| vr=||jfz} | d | d kr | ddd } || Yt|S) aGiven a list of Angles, find all improper dihedrals that exist between atoms. Works by assuming that if (1,2,3) is an angle, and 2 & 4 are bonded, then (2, 1, 3, 4) must be an improper dihedral. ie the improper dihedral is the angle between the planes formed by (1, 2, 3) and (1, 3, 4) Returns ------- List of tuples defining the improper dihedrals. Suitable for use in u._topology rrNrrrc*g|]}|jSr/r)r2rrs r)r4z;DefaultGuesser.guess_improper_dihedrals..qs999!1Q4:999r*)rrrrrO)rrrjr7r8rrrTrrrdrr rrlrtrrsr) r%rrrrr3rr other_atomrrs @r)r"z'DefaultGuesser.guess_improper_dihedralsIs -,,,,, >t~+X66 --4"DN4H0I0IJJ  $$,dn.B.L !!$"3"3FL4F"G"GHHH,%% . .AQ4D9999y999::E : . .$__T22 Q&& J$4#66DAwb))#DDbDz#''--- ._%%%r*cdS)zbGuess atom charge from the name. .. Warning:: Not implemented; simply returns 0. r?r/)r%r8s r)guess_atom_chargez DefaultGuesser.guess_atom_charges sr*c| |jj}|d}tjd|DS)zGuess aromaticity of atoms using RDKit Returns ------- aromaticities : numpy.ndarray Array of boolean values for the aromaticity of each atom NRDKITc6g|]}|Sr/) GetIsAromaticr2r3s r)r4z6DefaultGuesser.guess_aromaticities..s$III$++--IIIr*)r7r8 convert_tor:r;GetAtoms)r% atomgroupmols r)r#z"DefaultGuesser.guess_aromaticitiessN  ,I""7++xII#,,..IIIJJJr*c|d}ddlm}||dtjd|DtjS)aJGuess Gasteiger partial charges using RDKit Parameters ---------- atomgroup : mda.core.groups.AtomGroup Atoms for which the charges will be guessed Returns ------- charges : numpy.ndarray Array of float values representing the charge of each atom rr)ComputeGasteigerChargesT)throwOnParamFailurec8g|]}|dS)_GasteigerCharge) GetDoubleProprs r)r4z:DefaultGuesser.guess_gasteiger_charges..s7   ""#566   r*r5)rrdkit.Chem.rdPartialChargesrr:r;rfloat32)r%rrrs r)guess_gasteiger_chargesz&DefaultGuesser.guess_gasteiger_chargess""7++GGGGGG>>>>x  LLNN   *     r*)NNr r )NNr[)__name__ __module__ __qualname____doc__contextrrr0rIrrGrr r!r"rr#r __classcell__)r(s@r)r r usF--^G        81111f*EEE# # # # J777reeeeN5#5#5#5#n6&6&6&6&p4&4&4&4&l K K K K       r*r )rbasernumpyr:rBmathrP exceptionsrlibrrNrr r/r*r)rs.QQd $$$$$$z z z z z [z z z z z r*