B bQ+@sdZddlmZmZmZddlZddlZddlmZddlm Z ddl m Z ddl mZdd l mZmZmZdd lmZmZmZdd lmZmZmZdd lmZdd lmZmZddl m!Z!m"Z"ddl#m$Z$ddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:g+Z%e &de j'e j(e j)d;Z*e*+e j,Z*e j-e j.j/dZ0e01e j.e*e 2e j3e j4e0e j5e j6e j7e j8gZ9dd?d@Z:dAdBZ;ddCdDZGdGdHdHe=Z?GdIdJdJe=Z@dKdLZAdMdNZBGdOdde>ZCGdPd2d2eCZDGdQd3d3e=ZEGdRd4d4e=ZFGdSd5d5e=ZGGdTdde=ZHGdUdde@e>ZIGdVdde=ZJGdWdde@e>ZKGdXdde?ZLGdYdde@e>ZMGdZd6d6e@e>ZNGd[ddeOe>ZPGd\d)d)eHZQGd]dde?ZRGd^dde@e>ZSGd_dde=ZTGd`dde@e>ZUGdadbdbe=ZVGdcd'd'e?ZWGdddde?ZXGded*d*e@e>ZYGdfd d e=ZZGdgd#d#e=Z[Gdhd$d$e@e>Z\Gdid%d%eTZ]Gdjdkdke=Z^Gdld&d&e@e>Z_Gdmdde=Z`Gdndde=ZaGdod9d9eCZbGdpd:d:e?ZcGdqd!d!e>ZddrdsZeGdtd(d(eOZfGdud"d"efZgGdvddefZhGdwd+d+e=ZiGdxd,d,e@e>ZjGdyd-d-ejZkGdzd0d0e=ZlGd{d|d|e=ZmemZnenemkstod}Gd~d.d.e=ZpGdd/d/e=ZqGdd8d8e=ZreIddZsdS)z This module contains objects that deal with system topology and parameters, such as atoms, residues, bonds, angles, etc. by Jason Swails )absolute_importdivisionprint_functionN)copy)wraps)unit) TINY_DIGITS) DEG_TO_RAD RAD_TO_DEGTINY) MoleculeErrorParameterErrorParameterWarning)angledihedral distance2) deprecated) iteritems string_types)rangezip)ElementAngle AngleTypeAtomAtomListBondBondType ChiralFrameCmapCmapTypeDihedral DihedralTypeDihedralTypeListImproper ImproperTypeMultipoleFrameOutOfPlaneBend PiTorsionResidue ResidueList StretchBendStretchBendTypeTorsionTorsionTorsionTorsionType TrigonalAngle TrackedList UreyBradleyOutOfPlaneBendTypeNonbondedExceptionNonbondedExceptionTypeAmoebaNonbondedExceptionType AcceptorDonorGroupAtomType NoUreyBradley ExtraPointTwoParticleExtraPointFrameThreeParticleExtraPointFrameOutOfPlaneExtraPointFrame RBTorsionTypeUnassignedAtomTypeLink DrudeAtomDrudeAnisotropyz akma timeZaks)ZsymbolcCsDt|r@|dkr6|jtjr,|tjS|tS||S|S)zu Strips any units from the given value by casting them into the AKMA unit system (or the requested unit) N)u is_quantityrZ is_compatibledegrees value_in_unitZvalue_in_unit_systemakma_unit_system)valuerrK5lib/python3.7/site-packages/parmed/topologyobjects.py _strip_units+s    rMcstfdd}|S)zf Wraps comparison operators to return NotImplemented instead of raising an AttributeError cs$y ||Stk rtSXdS)N)AttributeErrorNotImplemented)selfother)funcrKrLwrapper?s z-_exception_to_notimplemented..wrapper)r)rRrSrK)rRrL_exception_to_notimplemented:srTcsdkrdgfdd}|S)a Serializes based on all attributes except requested exclusions Parameters ---------- exclusions : list of str, optional List of all attributes to exclude from serialization (should be descriptors and 'list'). Default is None Notes ----- If exclusions is None, it defaults to excluding 'list'. If this is not desired, set exclusions to the empty list. Nlistcsfddt|jDS)Ncsi|]\}}|kr||qSrKrK).0keyval) exclusionsrKrL XszC_getstate_with_exclusions..__getstate__..)r__dict__)rP)rYrKrL __getstate__Wsz/_getstate_with_exclusions..__getstate__rK)rYr\rK)rYrL_getstate_with_exclusionsGs r]c@seZdZdZeddZdS) _ListItema Helpful methods for items that appear in some kind of tracked list. Subclasses of this method interact with their `list` attribute, if they have one, in order to determine _where_ in the list they occur. Attributes ---------- idx : ``int`` This is intended to be a read-only variable that determines where in the list this particular object is. If there is no `list` attribute for this object, or the item is not in the list at all, `idx` is -1 Notes ----- For lists that support indexing its members and tracking when that list is changed (so we know when to update indexes), this is a fast lookup, as indexing only needs to be done once, at most, for the entire list (until changes are made that could change the indexing). The ``idx`` lookup in a TrackedList is therefore an O(1) operation, while it is O(N) for standard containers (O(N^2) for looking up *all* indexes). cCsy |j}Wntk rdSX|dkr,dSy |j}Wn6tk rlx t|D]\}}||krP|SqPWdSX|s||jdkryd|_||jStk rx t|D]\}}||kr|SqWdSXn|jSdS)N)rUrNneeds_indexing enumerate_idx index_members)rPZmylistr`iitemrKrKrLidxws0  z _ListItem.idxN)__name__ __module__ __qualname____doc__propertyrfrKrKrKrLr^_sr^c@s(eZdZdZddZddZddZdS) _FourAtomTerma; A base class for a parameter that spans 4 atoms Parameters ---------- atom1 : :class:`Atom` The first atom in the term atom2 : :class:`Atom` The second atom in the term atom3 : :class:`Atom` The third atom in the term atom4 : :class:`Atom` The fourth atom in the term Notes ----- This is a base class that should be overridden by terms consisting of 4 atoms (like torsions). There are a lot of such terms in the Amoeba force field, so this functionality is broken out into a new form cCs`||ks0||ks0||ks0||ks0||ks0||krDtd||||f||_||_||_||_dS)Nz?4-atom term cannot have duplicate atoms! Atoms are: %s %s %s %s)r atom1atom2atom3atom4)rPrmrnrorprKrKrL__init__s  z_FourAtomTerm.__init__cCs(|j|kp&|j|kp&|j|kp&|j|kS)N)rmrnrorp)rPobjrKrKrL __contains__sz_FourAtomTerm.__contains__cCs,d|_|_|_|_t|dr(d|_dS)z@ Sets all atoms in this term to None, and its type if it exists Ntype)rmrnrorphasattrrt)rPrKrKrLdeletes z_FourAtomTerm.deleteN)rgrhrirjrqrsrvrKrKrKrLrls rlc@s eZdZdZddZddZdS)_ParameterTypea} A parameter type that defines the nature of a particular molecular interaction. This is a base class that simply indicates whether a particular parameter type is "used", which in turn is used to determine whether or not this parameter type needs to be printed Attributes ---------- used : ``bool`` If ``True``, then this parameter type should be considered *used*. If ``False``, it is not being used and does not need to be printed. penalty : float or None If this is assigned from a database, there might be a penalty assigned to the determination of this parameter cCsd|_d|_dS)NF)usedpenalty)rPrKrKrLrqsz_ParameterType.__init__cCs ||k S)NrK)rPrQrKrKrL__ne__sz_ParameterType.__ne__N)rgrhrirjrqrzrKrKrKrLrwsrwcCs|||dS)a Deletes a requested item from a list. If the item does not exist in the list, a ValueError is raised Parameters ---------- list : ``list`` The list from which an item will be deleted item : ``object`` The object to delete from the list N)popindex)rUrerKrKrL_delete_from_lists r}cCs4x.|D]&}t||sqt||}t|||qWdS)z Shallow-copies all requested attributes from `source` to `dest` if they are present. If not present, nothing is done N)rugetattrsetattr)destsourceZattrsattrZmyattrrKrKrL _safe_assignss    rc@s$eZdZdZdadd Zed d Zd d ZeddZ eddZ eddZ eddZ eddZ eddZejddZeddZeddZejddZed d!Zed"d#Zejd$d#Zed%d&Zed'd(Zejd)d(Zed*d+Zed,d-Zejd.d-Zed/d0Zed1d2Zejd3d2Zed4d5Zed6d7Zejd8d7Zed9d:Zed;d<Zed=d>Zdbd@dAZedBdCZ e jdDdCZ edEdFZ!dGdHZ"dIdJZ#dKdLZ$dMdNZ%dOdPZ&dQdRZ'dSdTZ(dUdVZ)dWdXZ*dYdZZ+d[d\Z,d]d^Z-d_d`Z.dS)cra * An atom. Only use these as elements in AtomList instances, since AtomList will keep track of when indexes and other stuff needs to be updated. All parameters are optional. Parameters ---------- atomic_number : ``int`` The atomic number of this atom name : ``str`` The name of this atom type : ``str`` The type name of this atom charge : ``float`` The partial atomic charge of this atom in fractions of an electron mass : ``float`` The atomic mass of this atom in daltons nb_idx : ``int`` The nonbonded index. This is a pointer that is relevant in the context of an Amber topology file and identifies its Lennard-Jones atom type solvent_radius : ``float`` The intrinsic solvation radius of this atom. screen : ``float`` The Generalized Born screening factor for this atom. occupancy : ``float`` The occupancy of the atom (see PDB file) bfactor : ``float`` The B-factor of the atom (see PDB file) altloc : ``str`` Alternate location indicator (see PDB file) Other Parameters ---------------- list : :class:`AtomList` The AtomList that this atom belongs to. If None, this atom does not belong to any list. This can be any iterable, but should typically be an AtomList or None tree : ``str`` The tree chain identifier assigned to this atom. Relevant in the context of an Amber topology file, and not used for very much. join : ``int`` The 'join` property of atoms stored in the Amber topology file. At the time of writing this class, `join` is unused, but still oddly required. Add support for future-proofing irotat : ``int`` The `irotat` property of atoms stored in the Amber topology file. Unused, but included for future-proofing. number : ``int`` The serial number given to the atom (see PDB file) rmin : ``float`` The Rmin/2 Lennard-Jones parameter for this atom. Default evaluates to 0 epsilon : ``float`` The epsilon (well depth) Lennard-Jones parameter for this atom. Default evaluates to 0 rmin14 : ``float`` The Rmin/2 Lennard-Jones parameter for this atom in 1-4 interactions. Default evaluates to 0 epsilon14 : ``float`` The epsilon (well depth) Lennard-Jones parameter for this atom in 1-4 interactions. Default evaluates to 0 Other Attributes ---------------- element : ``int`` This is an alias for atomic_number atom_type : :class:`AtomType` In some cases, "type" is an ambiguous choice of an integer serial number or a string descriptor. In this case, atom_type is an AtomType instance that disambiguates this discrepancy. anisou : numpy.ndarray(float64) (or list of floats) Anisotropic temperature scaling factors. This is a 6-element numpy array They are the 3x3 symmetric matrix elements U(1,1), U(2,2), U(3,3), U(1,2), U(1,3), U(2,3). If no factors available, it is None. idx : ``int`` The index of this atom in the list. Set to -1 if this atom is not part of a list or the index cannot otherwise be determined (i.e., if the containing list does not support indexing its members) residue : :class:`Residue` The Residue that this atom belongs to. This is assigned when this atom is passed to `Residue.add_atom` -- see below for more information. Until it is set there, it is None other_locations : ``dict`` of :class:`Atom` A dict of Atom instances that represent alternate conformers of this atom. The keys are the `altloc` characters for those Atoms. bonds : ``list`` of :class:`Bond` list of Bond objects in which this atom is a member. This attribute should not be modified. angles : ``list`` of :class:`Angle` list of Angle objects in which this atom is a member. This attribute should not be modified. dihedrals : ``list`` of :class:`Dihedral` list of Dihedral objects in which this atom is a member. This attribute should not be modified. urey_bradleys : ``list`` of :class:`UreyBradley` list of UreyBradley objects in which this atom is a member (CHARMM, AMOEBA). This attribute should not be modified. impropers : ``list`` of :class:`Improper` list of Improper objects in which the atom is a member (CHARMM). This attribute should not be modified. cmaps : ``list`` of :class:`Cmap` list of Cmap objects in which the atom is a member (CHARMM, AMOEBA). This attribute should not be modified. tortors : ``list`` of :class:`TorsionTorsion` list of TorsionTorsion objects in which the atom is a member (AMOEBA). This attribute should not be modified. bond_partners : ``list`` of :class:`Atom` list of Atoms to which this atom is bonded. Do not modify this attribute -- it will almost certainly not do what you think it will angle_partners : ``list`` of :class:`Atom` list of Atoms to which this atom forms an angle, but not a bond. Do not modify this attribute -- it will almost certainly not do what you think it will dihedral_partners : ``list`` of :class:`Atom` list of Atoms to which this atom forms an dihedral, but not a bond or angle. Do not modify this attribute -- it will almost certainly not do what you think it will tortor_partners : ``list`` of :class:`Atom` list of Atoms to which this atom forms a coupled Torsion-Torsion, but not a bond or angle (AMOEBA). Do not modify this attribute -- it will almost certainly not do what you think it will exclusion_partners : ``list`` of :class:`Atom` list of Atoms with which this atom is excluded, but not bonded, angled, or dihedraled to. Do not modify this attribute -- it will almost certainly not do what you think it will marked : ``int`` Mainly for internal use, it is used to indicate when certain atoms have been "marked" when traversing the bond network identifying topological features (like molecules and rings) children : ``list`` of :class:`ExtraPoint` This is the list of "child" ExtraPoint objects bonded to this atom number : ``int`` The serial number of the atom in the input structure (e.g., PDB file). If not present in the original structure, a default value of -1 is used rmin : ``float`` The Rmin/2 Lennard-Jones parameter for this atom. Default value is 0. If not set, it is taken from the `atom_type` attribute (if available) epsilon : ``float`` The epsilon (well depth) Lennard-Jones parameter for this atom. Default value is 0. If not set, it is taken from the `atom_type` attribute (if available) rmin_14 : ``float`` The Rmin/2 L-J parameter for 1-4 pairs. Default value is `rmin` (see above). If not set, it is taken from the `atom_type` attribute (if available). epsilon_14 : ``float`` The epsilon L-J parameter for 1-4 pairs. Default value is `epsilon` (see above). If not set, it is taken from the `atom_type` attribute (if available). Possible Attributes ------------------- xx : ``float`` The X-component of the position of this atom. Only present if coordinates have been loaded. Otherwise raises AttributeError xy : ``float`` The Y-component of the position of this atom. Only present if coordinates have been loaded. Otherwise raises AttributeError xz : ``float`` The Z-component of the position of this atom. Only present if coordinates have been loaded. Otherwise raises AttributeError vx : ``float`` The X-component of the velocity of this atom. Only present if the velocities have been loaded. Otherwise raises AttributeError vy : ``float`` The Y-component of the velocity of this atom. Only present if the velocities have been loaded. Otherwise raises AttributeError vz : ``float`` The Z-component of the velocity of this atom. Only present if the velocities have been loaded. Otherwise raises AttributeError type_idx : ``int`` The AMOEBA atom type index. Only present if initialized with the AMOEBA force field. Otherwise raises AttributeError. class_idx : ``int`` The AMOEBA class type index Only present if initialized with the AMOEBA force field. Otherwise raises AttributeError. multipoles : ``list(float)`` The list of the 10 multipole moments up through quadrupoles Only present if initialized with the AMOEBA force field. Otherwise raises AttributeError. polarizability : ``list(float)`` The polarizability of the atom. Only present if initialized with the AMOEBA force field. Otherwise raises AttributeError. vdw_parent : :class:`Atom` In the AMOEBA force field, this is the parent atom for the van der Waals term vdw_weight : ``float`` In the AMOEBA force field, this is the weight of the van der Waals interaction on the parent atom Notes ----- The bond_partners, angle_partners, dihedral_partners, and exclusion_partners arrays are actually generated as properties by taking differences of sets and sorting them. As a result, accessing this attribute constantly can be less efficient than you would expect. Iterating over them in a loop requires minimal overhead. But if frequent access is needed and these sets are guaranteed not to change, you should save a reference to the object and use that instead. Binary comparisons are done by atom index and are used primarily for sorting sublists of atoms. The == operator is not defined, so Atom equality should be done using the `is` operator. This allows Atom instances to be hashable (and so used as `dict` keys and put in `set`s) Examples -------- >>> a1 = Atom(name='CO', type='C', charge=0.5, mass=12.01) >>> a2 = Atom(name='OC', type='O', charge=-0.5, mass=12.01) >>> a1.bond_to(a2) >>> a1 in a2.bond_partners and a2 in a1.bond_partners True >>> a1.idx # Not part of a container -1 This object also supports automatic indexing when it is part of a container >>> atom_list = [] >>> atom_list.append(Atom(list=atom_list, name='CO', charge=0.5)) >>> atom_list.append(Atom(list=atom_list, name='OC', charge=-0.5)) >>> atom_list[0].idx 0 >>> atom_list[1].idx 1 NrBLAr_cCsV||_d|_||_||_y||_Wntk rD||_YnXt|tj |_ t|tj |_ ||_ t|tj|_| |_| |_| |_| |_||_||_| |_g|_g|_g|_g|_g|_d|_d|_ggg|_|_|_ ggg|_!|_"|_#g|_$i|_%t&|_'||_(d|_)t|tj*|_+t|tj,|_-t|tj*|_.t|tj,|_/g|_0dS)Nr_r)1rUrb atomic_numberstripnamertrNrMrEelementary_charge_chargeZdaltonmassnb_idxangstromsolvent_radiusscreentreejoinirotatbfactoraltloc occupancy_bond_partners_angle_partners_dihedral_partners_tortor_partners_exclusion_partnersresiduemarkedbondsangles dihedrals urey_bradleys improperscmapstortorsother_locationsr@ atom_typenumberanisou angstroms_rminkilocalories_per_mole_epsilon_rmin14 _epsilon14children)rPrUrrrtchargerrrrrrrrrrrrminepsilonrmin14 epsilon14rKrKrLrqsL  z Atom.__init__cCs||j|j|j|j|j|j|j|j|j|j |j |j |j |j d}|j|_t|j|_x"|jD]}t|j||j|<q\Wt||d|S)N)rrrtrrrrrrrrrrr) xxxyxzvxvyvztype_idx class_idx multipolespolarizabilityZ vdw_parent vdw_weight)rrrtrrrrrrrrrrrrrrrr)clsrenewrWrKrKrL_copys      z Atom._copycCst||S)z@ Returns a deep copy of this atom, but not attached to any list )rtr)rPrKrKrL__copy__sz Atom.__copy__cCs@t|j}x(|jD]}x|jD]}||qWqWtt|S)z Go through all bonded partners )setrraddsortedrU)rPbppcrKrKrL bond_partnerss    zAtom.bond_partnerscCsZt|j}t|j|}t}x&|D]}x|jD]}||q0Wq$W||O}tt|S)z7 List of all angle partners that are NOT bond partners )rrrrrrrU)rPraptoaddrrrKrKrLangle_partnerss   zAtom.angle_partnerscCsht|j}t|j}t|j||}t}x&|D]}x|jD]}||q>Wq2W||O}tt|S)zC List of all dihedral partners that are NOT angle or bond partners )rrrrrrrrU)rPrrdprrrrKrKrLdihedral_partners*s    zAtom.dihedral_partnerscCsvt|j}t|j}t|j}t|j|||}t}x&|D]}x|jD]}||qLWq@W||O}tt|S)z List of all 1-5 partners that are NOT in angle or bond partners. This is *only* used in the Amoeba force field ) rrrrrrrrrU)rPrrrtprrrrKrKrLtortor_partners7s     zAtom.tortor_partnersc Cst|j}t|j}t|j}t|j}t|j||||}t}x&|D]}x|jD]}||qZWqNW||O}tt |S)zX List of all exclusions not otherwise excluded by bonds/angles/torsions ) rrrrrrrrrrU) rPrrrreprrrrKrKrLexclusion_partnersHs      zAtom.exclusion_partnerscCs2|jdkr,|jtks |jjdkr$dS|jjS|jS)Ng)rrr@r)rPrKrKrLr`s  z Atom.chargecCst|tjd|_dS)N)r)rMrErr)rPrJrKrKrLrhscCs |jtjS)z Charge with units )rrEr)rPrKrKrLuchargelsz Atom.uchargecCs2|jdkr,|jtks |jjdkr$dS|jjS|jS)z; Lennard-Jones Rmin/2 parameter (the Lennard-Jones radius) Ng)rrr@r)rPrKrKrLrqs  z Atom.rmincCst|tjd|_dS)z; Lennard-Jones Rmin/2 parameter (the Lennard-Jones radius) )rN)rMrErr)rPrJrKrKrLrzscCs |jtjS)z+ Lennard-Jones Rmin/2 parameter with units )rrEr)rPrKrKrLurminsz Atom.urmincCs|jddS)z; Lennard-Jones sigma parameter -- directly related to Rmin g)N>?rD)r)rPrKrKrLsigmasz Atom.sigmacCst|tjddd|_dS)N)rgÚ?rD)rMrErr)rPrJrKrKrLrscCs |jtjS)z* Lennard-Jones sigma parameter with units )rrEr)rPrKrKrLusigmasz Atom.usigmacCs2|jdkr,|jtks |jjdkr$dS|jjS|jS)z@ Lennard-Jones epsilon parameter (the Lennard-Jones well depth) Ng)rrr@r)rPrKrKrLrs  z Atom.epsiloncCst|tjd|_dS)z@ Lennard-Jones epsilon parameter (the Lennard-Jones well depth) )rN)rMrEZkilocalorie_per_moler)rPrJrKrKrLrscCs |jtjS)z, Lennard-Jones epsilon parameter with units )rrEr)rPrKrKrLuepsilonsz Atom.uepsiloncCs4|jdkr.|jtks |jjdkr&|jS|jjS|jS)z( The 1-4 Lennard-Jones Rmin/2 parameter N)rrr@rmin_14r)rPrKrKrLrs  z Atom.rmin_14cCst|tj|_dS)z( The 1-4 Lennard-Jones Rmin/2 parameter N)rMrErr)rPrJrKrKrLrscCs |jtjS)z3 The 1-4 Lennard-Jones Rmin/2 parameter with units )rrEr)rPrKrKrLurmin_14sz Atom.urmin_14cCsD|jdkr6|jtks |jjdkr&|jS|jjddS|jddS)z; Lennard-Jones sigma parameter -- directly related to Rmin Ng)N>?rD)rrr@rr)rPrKrKrLsigma_14s  z Atom.sigma_14cCst|tjdd|_dS)NgÚ?rD)rMrErr)rPrJrKrKrLrscCs |jtjS)z2 The 1-4 Lennard-Jones sigma parameter with units )rrEr)rPrKrKrL usigma_14szAtom.usigma_14cCs4|jdkr.|jtks |jjdkr&|jS|jjS|jS)z) The 1-4 Lennard-Jones epsilon parameter N)rrr@ epsilon_14r)rPrKrKrLrs  zAtom.epsilon_14cCst|tj|_dS)z) The 1-4 Lennard-Jones epsilon parameter N)rMrErr)rPrJrKrKrLrscCs |jtjS)z) The 1-4 Lennard-Jones epsilon parameter )rrEr)rPrKrKrL uepsilon_14szAtom.uepsilon_14cCs |jtjS)N)Z_massrEdaltons)rPrKrKrLumasssz Atom.umasscCs |jtjS)z& Solvation radius with units attached )rrEr)rPrKrKrLusolvent_radiusszAtom.usolvent_radiusTcCs |jdkrtd|r|j}nd}g}x*|jD] }|j|}||kr.||q.Wx*|jD] }|j|}||krZ||qZWx*|jD] }|j|}||kr||qWx*|jD] }|j|}||kr||qWx*|jD] }|j|}||kr||qWt|S)a Returns the total number of nonbonded atom exclusions for this atom. The general rules for building the exclusion list is to include both exceptions AND exclusions (i.e., the Amber scaling of 1-4 interactions means that the 1-4 terms are excluded and a special pairlist is built to handle those exceptions). All atoms in the `_partners` arrays are nonbonded exclusions. Parameters ---------- only_greater : ``bool``, optional If True (default), only atoms whose `idx` value is greater than this `Atom`s `idx` will be counted as an exclusion (to avoid double- counting exclusions). If False, all exclusions will be counted. index_from : ``int``, optional This is the index of the first atom, and is intended to be 0 (for C- and Python-style numbering, default) or 1 (for Fortran-style numbering, such as that used in the Amber and CHARMM topology files) Returns ------- ``list of int`` The returned list will be the atom indexes of the exclusion partners for this atom (indexing starts from ``index_from``) Notes ----- If this instance's `idx` attribute evaluates to -1 -- meaning it is not in an AtomList -- a IndexError will be raised. If you have two extra points (i.e., those with atomic numbers of 0) bonded to each other, this routine may raise a ``RuntimeError`` if the recursion depth is exceeded. rz+Cannot find exclusions of an unindexed Atomr_) rf IndexErrorrappendrrrrr)rPZ only_greaterZ index_fromZbaselineZexclatmrdrKrKrLnonbonded_exclusionss6"           zAtom.nonbonded_exclusionscCs|jS)N)r)rPrKrKrLelement+sz Atom.elementcCs ||_dS)N)r)rPrJrKrKrLr.scCs t|jS)N)rr)rPrKrKrL element_name1szAtom.element_namecCsbt|tr|j|nt|tr.|j|||krFtd||f|j||j|dS)aI Log this atom as bonded to another atom. Parameters ---------- other : :class:`Atom` An atom that will be added to `bond_partners` Notes ----- This action adds `self` to `other.bond_partners`. Raises :class:`MoleculeError` if `other is self` z,Cannot bond atom to itself! Atoms are: %s %sN) isinstancer;rrr r)rPrQrKrKrLbond_to7s     z Atom.bond_tocCs4||krtd||f|j||j|dS)aK Log this atom as angled to another atom. Parameters ---------- other : :class:`Atom` An atom that will be added to `angle_partners` Notes ----- This action adds `self` to `other.angle_partners`. Raises :class:`MoleculeError` if `other is self` z2Cannot angle an atom with itself! Atoms are: %s %sN)r rr)rPrQrKrKrLangle_toQs   z Atom.angle_tocCs4||krtd||f|j||j|dS)aV Log this atom as dihedral-ed to another atom. Parameters ---------- other : :class:`Atom` An atom that will be added to `dihedral_partners` Notes ----- This action adds `self` to `other.dihedral_partners`. Raises :class:`MoleculeError` if `other is self` z5Cannot dihedral an atom with itself! Atoms are: %s %sN)r rr)rPrQrKrKrL dihedral_togs   zAtom.dihedral_tocCs4||krtd||f|j||j|dS)aR Log this atom as 1-5 partners to another atom Parameters ---------- other : :class:`Atom` An atom that will be added to `tortor_partners` Notes ----- This action adds `self` to `other.tortor_partners`. Raises :class:`MoleculeError` if `other is self` z7Cannot coupled-dihedral atom to itself Atoms are: %s %sN)r rr)rPrQrKrKrL tortor_to}s   zAtom.tortor_tocCs4||krtd||f|j||j|dS)aW Add one atom to my arbitrary exclusion list Parameters ---------- other : :class:`Atom` An atom that will be added to `exclusion_partners`. Notes ----- This action adds `self` to `other.exclusion_partners`. Raises :class:`MoleculeError` if `other is self` z4Cannot exclude an atom from itself! Atoms are: %s %sN)r rr)rPrQrKrKrLexcludes   z Atom.excludecCsDt|jt|jt|jt|jt|j}tt||_dS)a For extra points, the exclusion partners may be filled before the bond, angle, dihedral, and tortor partners. Since we don't want memory of these exclusions if any of those topological features were to break, we want to *remove* those from the exclusion list. This function makes sure that nothing in the bond, angle, dihedral, and tortor lists appears in the exclusion list. N)rrrrrrrrU)rPZexcludesrKrKrLprune_exclusionss & zAtom.prune_exclusionscCs |j|jkS)N)rf)rPrQrKrKrL__gt__sz Atom.__gt__cCs |j|jkS)N)rf)rPrQrKrKrL__lt__sz Atom.__lt__cCs ||k S)NrK)rPrQrKrKrL__ge__sz Atom.__ge__cCs ||k S)NrK)rPrQrKrKrL__le__sz Atom.__le__cCs^d|j|jf}|jdk r>t|jdr>|d|jj|jjfS|jdk rV|d|jS|dS)Nz z; In object %r>>)rrfrru)rPstartrKrKrL__repr__s  z Atom.__repr__cCst|j|j|j|j|j|j|j|j|j |j |j |j |j |j|j|j|j|j|j|j|j|jd}x6dD].}yt||||<Wqftk rwfYqfXqfW|S)N)rrtrrrrrrrrrrrrrrrrrrrr) rrrrrrrrrrrweights _frame_type)dictrrtrrrrrrrrrrrrrrrrrrrrr~rN)rPZretvalrWrKrKrLr\s       zAtom.__getstate__cCsrg|_g|_g|_g|_g|_d|_d|_ggg|_|_|_ ggg|_ |_ |_ g|_ i|_|j|dS)Nr)rrrrrrrrrrrrrrrr[update)rPdrKrKrL __setstate__szAtom.__setstate__)NrrrNrrrrrrrrrrr_NNNN)Tr)/rgrhrirjrq classmethodrrrkrrrrrrsetterrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr\rrKrKrKrLrsla *                    C   cseZdZdZfddZeddZeddZedd Zed d Z ed d Z eddZ eddZ ee ddZeje ddZZS)r;a An extra point is a massless, virtual site that is used to extend the flexibility of partial atomic charge fitting. They can be used to, for instance, give atoms permanent multipoles in a fixed-charge format. However, virtual sites are massless particles whose position is fixed with respect to a particular frame of reference. As a result, they must be treated specially when running dynamics. This class extends the `Atom` class with extra functionality specific to these "Extra points" or "virtual sites". See the documentation for the :class:`Atom` class for more information. Parameters ---------- weights : list of float, optional, keyword-only This is the list of weights defining its frame. See Also -------- :class:`Atom` -- The ExtraPoint constructor also takes all `Atom` arguments as well, and shares all of the same properties cs8d|kr|d|_nd|_tt|j||d|_dS)Nr)r{rsuperr;rqr)rPargskwargs) __class__rKrLrq s zExtraPoint.__init__cCs$y |jdStk rdSXdS)z The parent atom of this extra point is the atom it is bonded to (there should only be 1 bond partner, but the parent is defined as its first) rN)rr)rPrKrKrLparents zExtraPoint.parentcs<y"tjgfddjjDStk r6gSXdS)z6 List of all atoms bonded to this atom and its parent csg|]}|k r|qSrKrK)rVx)rPrKrL (sz,ExtraPoint.bond_partners..N)rrrrN)rPrK)rPrLr$s"zExtraPoint.bond_partnerscCs"y|jjStk rgSXdS)z6 List of all atoms angled to this atom and its parent N)rrrN)rPrKrKrLr,szExtraPoint.angle_partnerscCs"y|jjStk rgSXdS)N)rrrN)rPrKrKrLr4szExtraPoint.dihedral_partnerscCs"y|jjStk rgSXdS)N)rrrN)rPrKrKrLr;szExtraPoint.tortor_partnerscCs"y|jjStk rgSXdS)N)rrrN)rPrKrKrLrBszExtraPoint.exclusion_partnerscCsx|jdk r|jSt|jjdkr4d}d}x"|jjD]}||krF|}q4|}q4W|dk r^|dk sftd|jj}|j|jkr|j}n|j}y0|j |j |j }}}|j |j |j } } } Wn t k rt |d|_YnVX|| || || } } }| | | | |||kr"t |d|_n t |d|_|jSt|jjdkrVd}x:|jjD].}||krT|j|jkrx|j}n|j}PqTW|dk stdyL|j |j |j }}}|jj |jj |jj } } } |j |j |j }}}Wnt k rd}xD|jjD]8}||kr||kr|j|jkr2|j}n|j}PqW|dkrRtd|jjdkr|jdkr|jdkrt|d|_n t|d|_YnX|| || || g}|| || || g}td d t||D}td d t||D}td d t||D}t|t|t|}|tjdkrHt|d|_n t|d|_nt|jjd krrt||_|jS)a5 The type of frame used for this extra point. Whether the EP lies beyond (outside) or between (inside) the is determined from the positions of each atom in the frame and the extra point. If those are not set, the EP is assumed to be between the two points in the frame NrDzStrange bond pattern detectedTFrcSsg|]\}}||qSrKrK)rVryrKrKrLrsz)ExtraPoint.frame_type..cSsg|]\}}||qSrKrK)rVrrrKrKrLrscSsg|]\}}||qSrKrK)rVrrrKrKrLrs)rlenrrAssertionErrorrtreqrmrnrrrrNr< RuntimeErrorrr=sumrmathacossqrtZpir>)rPmybondZ otherbondbondZbonddistZ otheratomZx1Zy1Zz1Zx2Zy2Zz2dxZdyZdzZ other_atomZx3Zy3Zz3Z other_atom2Zvec1Zvec2Zdot11Zdot22Zdot12rrKrKrL frame_typeKs~       zExtraPoint.frame_typecCs|jS)N)r)rPrKrKrLradiiszExtraPoint.radiicCs ||_dS)N)r)rPrJrKrKrLrs)rgrhrirjrqrkrrrrrrrrrr __classcell__rKrK)rrLr;s     Yc@s*eZdZdZd ddZddZddZd S) r<a This class defines a frame of reference for a given extra point with a frame of reference defined by 2 particles Parameters ---------- ep : :class:`ExtraPoint` The extra point defined by this frame inside : ``bool`` If True, the extra point is contained inside the curve connecting all points in the frame of reference. If False, the point is outside that curve. See figures below for example Figures ------- In the figures, x marks the real particles, e marks the extra point (properly numbered). The numbers refer to the ordering this class expects those atoms to be in. The real particle that is the parent of the extra point is shown in upper-case Inside : x1-----e--X2 Outside : x1--------X2--e FcCs||_||_dS)N)rinside)rPrrrKrKrLrqsz#TwoParticleExtraPointFrame.__init__c snyfddjjjD\}Wn ttfk r>tdYnX|jjjkr\jj|jfSjj|jfSdS)z Returns the particles involved in the frame Returns ------- a1, a2 : :class:`Atom`, :class:`Atom` a1 is the parent atom of the extra point. a2 is the other atom bonded to the parent atom csg|]}j|kr|qSrK)r)rVr)rPrKrLrsz8TwoParticleExtraPointFrame.get_atoms..zBad bond pattern in EP frameN)rrr ValueError TypeErrorr rmrn)rPrrK)rPrL get_atomss z$TwoParticleExtraPointFrame.get_atomscCs|j}t|jjdkrtd|jj\}}||krD|jj}|jj}n|jj}|jj}|jrn|||||fS||||| fSdS)a Returns the weights for the two particles Returns ------- w1, w2 : ``float, float`` w1 is the weight of particle 1 (the parent atom), whereas w2 is the weight of particle 2 (the atom bonded to the parent atom) rDzCEP parent bond pattern inconsistent with 2-point virtual site frameN)rr rrrrtr r)rPrb1b2r1r2rKrKrL get_weightss   z&TwoParticleExtraPointFrame.get_weightsN)F)rgrhrirjrqrrrKrKrKrLr<s c@s8eZdZdZd ddZddZed dd Zd d ZdS)r=a This class defines a frame of reference for a given extra point with a frame of reference defined by 3 particles Parameters ---------- ep : :class:`ExtraPoint` The extra point defined by this frame inside : ``bool`` If True, the extra point is contained inside the curve connecting all points in the frame of reference. If False, the point is outside that curve. See figures below for example Figures ------- In the figures, x marks the real particles, e marks the extra point (properly numbered). The numbers refer to the ordering this class expects those atoms to be in. The real particle that is the parent of the extra point is shown in upper-case Inside : X /|\ / e \ x x Outside : e | X / \ / \ x x TcCs||_||_dS)N)rr)rPrrrKrKrLrqsz%ThreeParticleExtraPointFrame.__init__c sy fddjjjD\}}Wn ttfk r@tdYnX|jjjkrX|j}n|j}|jjjkrt|j}n|j}jj||fS)a' Returns the particles involved in the frame Returns ------- a1, a2, a3 : :class:`Atom`, :class:`Atom`, :class:`Atom` a1 is the parent atom of the extra point. a2 and a3 are the other atoms that are both bonded to the parent atom csg|]}j|kr|qSrK)r)rVr)rPrKrLr/sz:ThreeParticleExtraPointFrame.get_atoms..z'Unsupported bonding pattern in EP frame)rrrrrr rmrn)rPrroatom1oatom2rK)rPrLr$s  z&ThreeParticleExtraPointFrame.get_atomsNc Cs||jks||jkrtd||jkr8||jkr8td||krHtd|dksX|dkrxR|jD]H} || kr| jdkr~td| jj}|| kr`| jdkrtd| jj}q`W|dkrr|dkrr||jkr,x2|jD](} || krq| jdkrtd| jj}qWt||||||d||}nDx|j D]*} || kr4|| j k r4| jj t }Pq4Wdst dn>|dkrt||||||d||}n|t 9}t||tkrtd t|dt|d |S) a This function determines the necessary bond length between an ExtraPoint and its parent atom from the weights that are calculated in ``get_weights``. Parameters ---------- parent : :class:`Atom` The parent atom to the ExtraPoint a1 : :class:`Atom` The first atom in the frame bonded to the parent a2 : :class:`Atom` The second atom in the frame bonded to the parent w1 : float The first weight defining the ExtraPoint position wrt ``a1`` w2 : float The second weight defining the ExtraPoint position wrt ``a2`` dp1 : float, optional Equilibrium distance between parent and a1. If None, a bond with a bond type must be defined between parent and a1, and the distance will be taken from there. Units must be Angstroms. Default is None dp2 : float, optional Same as dp1 above, but between atoms parent and a2. Either both dp1 and dp2 should be None or neither should be. If one is None, the other will be ignored if not None. theteq : float, optional Angle between bonds parent-a1 and parent-a2. If None, d12 (below) will be used to calculate the angle. If both are None, the angle or d12 distance will be calculated from parametrized bonds or angles between a1, parent, and a2. Units of degrees. Default None. d12 : float, optional Distance between a1 and a2 as an alternative way to specify theteq. Default is None. Returns ------- dist : float The distance between the ExtraPoint and its parent atom that satisfies the weights Notes ----- parent must form a Bond with both a1 and a2. Then, if a1-parent-a2 forms an angle and it has an assigned type, that equilibrium value is used. Otherwise, the a1-a2 bond distance is used. If neither of those are defined, a ValueError is raised. Raises ------ ValueError if the necessary geometry requirements are not set or if the two weights are different z/Parent atom not bound to other 2 atoms in framez.No geometry defined between 2 non-parent atomsz*Currently only equal weights are supportedNz)Could not determine virtual site geometryrDFzCould not find matching anglez&Cannot deal with asymmetry in EP frameg?)rrrrrtrr rrrrntheteqr r absr cos) ra1a2Zw1Zw2Zdp1Zdp2r"Zd12rangrKrKrL from_weights<sH6        ,   ,z)ThreeParticleExtraPointFrame.from_weightscCs|j}t|jjdkrtd|jj\}}}||kr@||}}n||krR||}}d}x&|jjD]}||kr`||kr`d}Pq`W|r|jj}|jj}|jjt } t ||||d||t | } n|j |jkr|j} n|j } |j |jkr|j} n|j } | | jkrtdd} x"| jD]} | | kr | jj} q W| dkrNtd|jj}|jj}|jjt ||d | | }|jrd ||d|dfSd || d| dfSdS) a> Returns the weights for the three particles Returns ------- w1, w2, w3 : ``float, float, float`` w1 is the weight of particle 1 (the parent atom), whereas w2 and w3 are the weights of particles 2 and 3 (the atoms bonded to the parent atom) rzCEP parent bond pattern inconsistent with 3-point virtual site frameFTrDznEP frame definition incomplete for 3-point virtual site... cannot determine distance between particles 2 and 3NzGCannot determine 2-3 particle distance in three-site virtual site frameg?r)rr rrrrrtr r"r rrr$rmrnrr r)rPrrrZb3foundr'rrthetareq23r%r&rreq12req13weightrKrKrLrsL    .      "z(ThreeParticleExtraPointFrame.get_weights)T)NNNN) rgrhrirjrqr staticmethodr(rrKrKrKrLr=s    `c@s*eZdZdZd ddZddZddZd S) r>a This class defines a frame of reference for a given extra point with a frame of reference defined by 3 particles, but with the virtual site out of the plane of those 3 particles. For example, TIP5P Parameters ---------- ep : :class:`ExtraPoint` The extra point defined by this frame angle : ``float`` The angle out-of-plane that the extra point is. By default, it is half of the angle of a tetrahedron. Given in degrees Figures ------- In the figures, x marks the real particles, e marks the extra point (properly numbered). The numbers refer to the ordering this class expects those atoms to be in. The real particle that is the parent of the extra point is shown in upper-case e e \ / X / \ / \ x x Gz^K@cCs||_||_dS)N)rr)rPrrrKrKrLrqsz"OutOfPlaneExtraPointFrame.__init__c Csydd|jjjD\}}Wn ttfk r<tdYnX|j|jjkrT|j}n|j}|j|jjkrp|j}n|j}|jj||fS)a7 Returns the particles involved in the frame Returns ------- a1, a2, a3 : :class:`Atom`, :class:`Atom`, :class:`Atom` a1 is the parent atom of the extra point. a2 and a3 are the other atoms that are both bonded to the parent atom but are not EPs cSs(g|] }t|jtst|jts|qSrK)rrmr;rn)rVrrKrKrLr s z7OutOfPlaneExtraPointFrame.get_atoms..z'Unsupported bonding pattern in EP frame)rrrrrr rmrn)rPrrr r!rKrKrLrs z#OutOfPlaneExtraPointFrame.get_atomsc!s|j}g}d}xP|jjD]D}t|jts@t|jts@||q||kr|dk rXtd|}qWt |dkrttd|dkrt d|dd\}}|j j }|j j }d} x&|jj D]} || kr|| krd} PqW| r&| j} |j j } |j j } | j jt}t| | | | d| | t|}n|j|jkr<|j}n|j}|j|jkrX|j}n|j}||jkrrt dd}x"|jD]}||kr~|j j }q~W|dkrt d dt|||t} tjtj}||9}||9}||9}t|jt}t|jt}t| t}|||}||j j ||}||j j |t||d ||}|\}}}yp|j|j|j|j|j|jf}|j|j|j|j|j|jf}|jj|j|jj|j|jj|jfWnNt k r0x6|jjjD](}||jkrPt|tr| }PqWYnX|d |d|d|d |d|d |d |d|d |d |d |d ftt!fd dt"dD}tt!fddt"dD}t!fddt"dD}|||} | d kr| n|}|d|d|fS)aB Returns the weights for the three particles Returns ------- w1, w2, w3 : ``float, float, float`` w1 and w2 are the weights with respect to the second two particles in the frame (i.e., NOT the parent atom). w3 is the weight of the cross-product Nz&multiple bonds detected to extra pointrDzTEP parent bond pattern inconsistent with an out-of-plane, 3-point virtual site framez&No EP bond found... should not be hereFTznEP frame definition incomplete for 3-point virtual site... cannot determine distance between particles 2 and 3zGCannot determine 2-3 particle distance in three-site virtual site frameg?rrcsg|]}||qSrKrK)rVrd)crossrKrLrsz9OutOfPlaneExtraPointFrame.get_weights..rcsg|]}||qSrKrK)rVrd)v1erKrLrscsg|]}||qSrKrK)rVrd)r1r2rKrLrs)#rrrrrmr;rnrrr r rtr rr"r rrr$rZasinr rErZconversion_factor_toZ nanometersZsinrrrrrrNr r)!rPrZregbondsrrrrr,r-r)r'Zt213rrr*r+r%r&Z length_convZsinOOPZcosOOPZsin213ZlenCrossZ weightCrossr.Za3Zv12Zv13aZlencrossZlenv1eZ v1edotcrossZcosthetarK)r1r2rLrs      .     *"",  "   z%OutOfPlaneExtraPointFrame.get_weightsN)r0)rgrhrirjrqrrrKrKrKrLr>s c@sleZdZdZdddZddZdd Zed d Zej d d Zd dZ ddZ ddZ ddZ ddZdS)raQ A covalent bond connecting two atoms. Parameters ---------- atom1 : :class:`Atom` The first atom involved in the bond atom2 : :class:`Atom` The other atom involved in the bond type : :class:`BondType` or None, optional The bond type that defines the parameters for this bond. Default is None order : float, optional The bond order of this bond. Bonds are classified as follows: 1.0 -- single bond 2.0 -- double bond 3.0 -- triple bond 1.5 -- aromatic bond 1.25 -- amide bond Default is 1.0 Notes ----- You can test whether an :class:`Atom` is contained within the bond using the `in` operator. A `MoleculeError` is raised if `atom1` and `atom2` are identical. This bond instance is `append`ed to the `bonds` list for both `atom1` and `atom2` and is automatically removed from those lists upon garbage collection Examples -------- >>> a1, a2 = Atom(), Atom() >>> bond = Bond(a1, a2) >>> a1 in bond and a2 in bond True N?cCs||krtd||ft|tr4t|tr4td||_||_|jj||jj|||||_d|_ d|_ ||_ dS)z Bond constructor z,Cannot bond atom to itself! Atoms are: %s %sz3Cannot bond two virtual sites/extra points togetherrN) r rr;rmrnrrrrtfunct_orderorder)rPrmrnrtr7rKrKrLrqs z Bond.__init__cCs||jkp||jkS)z6 Quick and easy way to see if an Atom is in this Bond )rmrn)rPthingrKrKrLrsszBond.__contains__cCsRt|jj|t|jj|t|jj|jt|jj|jd|_|_|_dS)z Deletes this bond from the atoms that make it up. This method removes this bond from the `bonds` list for both atom1 and atom2 as well as removing atom1 from atom2.bond_partners and vice versa. N)r}rmrrnrrt)rPrKrKrLrvs z Bond.deletecCs|jS)z< Bond order. See description in :class:`Bond` argument list )r6)rPrKrKrLr7sz Bond.ordercCst||_dS)zg Order of the bond. Must be a float, or ValueError or TypeError will be raised N)floatr6)rPrJrKrKrLr7scCsBd|j|jfkrdSytt|j|jStk r<dSXdS)z Measures the current bond Returns ------- measurement : float or None If the atoms have coordinates, returns the distance between the two atoms. If any coordinates are missing, returns None N)rmrnrrrrN)rPrKrKrLmeasures z Bond.measurecCs|}|dk r|tjSdS)z# Same as "measure", but with units N)r:rEr)rPmrKrKrLumeasuresz Bond.umeasurecCs:|}|jdks|dkrdS||jj}|jj||S)a Measures the current bond energy Returns ------- energy : float or None Bond strain energy in kcal/mol. Return value is None if either the coordinates of either atom is not set or the bond type is not set N)r:rtr k)rPrrrKrKrLenergys  z Bond.energycCs|}|dk r|tjSdS)z" Same as energy(), but with units N)r>rEr)rPenerKrKrLuenergysz Bond.uenergycCsdt|j|j|j|jfS)Nz<%s %r--%r; type=%r>)rtrgrmrn)rPrKrKrLr sz Bond.__repr__)Nr4)rgrhrirjrqrsrvrkr7rr:r<r>r@rrKrKrKrLrs#  csleZdZdZdddZeddZddZd d Ze Z fd d Z d dZ e ddZe ddZZS)ra A bond type with a set of bond parameters Parameters ---------- k : ``float`` Force constant in kcal/mol/Angstrom^2 req : ``float`` Equilibrium bond distance in Angstroms list : :class:`TrackedList` A list of :class:`BondType`s in which this is a member Inherited Attributes -------------------- idx : int The index of this BondType inside its containing list Notes ----- Two `BondType`s are equal if their `k` and `req` attributes are equal Examples -------- >>> bt1 = BondType(10.0, 1.0) >>> bt2 = BondType(10.0, 1.0) >>> bt1 is bt2 False >>> bt1 == bt2 True >>> bt1.idx # Not in a list or container -1 As part of a list, they can be indexed >>> bond_list = [] >>> bond_list.append(BondType(10.0, 1.0, list=bond_list)) >>> bond_list.append(BondType(10.0, 1.0, list=bond_list)) >>> bond_list[0].idx 0 >>> bond_list[1].idx 1 NcCs@t|t|tjtjd|_t|tj|_||_d|_ dS)NrDr_) rwrqrMrErrr=r rUrb)rPr=r rUrKrKrLrq;s  zBondType.__init__cCs(t|j|jtko&t|j|jtkS)N)r#r=r r )rPrQrKrKrL__eq__BszBondType.__eq__cCsdt|j|j|jfS)Nz<%s; k=%.3f, req=%.3f>)rtrgr=r )rPrKrKrLrFszBondType.__repr__cCs|tkr |St|j|jS)z Not bound to any list )r:rr=r )rPrKrKrLrIszBondType.__copy__cs|tkr dStt|S)z Special-case NoUreyBradley, which should be a singleton. So if it's NoUreyBradley, return the same object. Otherwise, create a new one r:)r:rr __reduce__)rP)rrKrLrBRszBondType.__reduce__cCstt|jtt|jtfS)N)hashroundr= _TINY_DIGITSr )rPrKrKrL__hash__[szBondType.__hash__cCs|jtjtjdS)NrD)r=rErr)rPrKrKrLuk^sz BondType.ukcCs |jtjS)N)r rEr)rPrKrKrLureqbsz BondType.ureq)N)rgrhrirjrqrTrArrr]r\rBrFrkrGrHrrKrK)rrLrs*    c@sReZdZdZdddZddZddZd d Zd d Zd dZ ddZ ddZ dS)ra A valence angle between 3 atoms separated by two covalent bonds. Parameters ---------- atom1 : :class:`Atom` An atom one end of the valence angle atom2 : :class:`Atom` The atom in the middle of the valence angle bonded to both other atoms atom3 : :class:`Atom` An atom on the other end of the valence angle to atom1 type : :class:`AngleType` The AngleType object containing the parameters for this angle Notes ----- An Angle can contain bonds or atoms. A bond is contained if it exists between atoms 1 and 2 or atoms 2 and 3. Examples -------- >>> a1, a2, a3 = Atom(), Atom(), Atom() >>> angle = Angle(a1, a2, a3) >>> Bond(a1, a2) in angle and Bond(a3, a2) in angle True >>> a1 in angle and a2 in angle and a3 in angle True >>> Bond(a1, a3) in angle # this is not part of the angle definition False NcCs||ks||ks||kr*td|||f||_||_||_|j||j||j|||_||||||d|_dS)Nz0Cannot angle atom to itself! Atoms are: %s %s %sr) r rmrnrorrrtrr5)rPrmrnrortrKrKrLrqs      zAngle.__init__cCsPt|tr(||jkp&||jkp&||jkS|j|kr<|j|kpN|j|koN|j|kS)zA Quick and easy way to see if an Atom or a Bond is in this Angle )rrrmrnro)rPrrrKrKrLrss zAngle.__contains__cCst|jj|t|jj|t|jj|t|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jd|_|_|_|_dS)z Deletes this angle from the atoms that make it up. This method removes this angle from the `angles` list for atom1, atom2, and atom3 as well as removing each atom form each others' angle partner lists N)r}rmrrnrorrt)rPrKrKrLrvsz Angle.deletecCsDd|j|j|jfkrdSyt|j|j|jStk r>dSXdS)z Measures the current angle Returns ------- measurement : float or None If the atoms have coordinates, returns the angle between the three atoms. If any coordinates are missing, returns None N)rmrnrorrN)rPrKrKrLr:s z Angle.measurecCs|}|dk r|tjSdS)z# Same as measure(), but with units N)r:rErG)rPr;rKrKrLr<szAngle.umeasurecCs>|}|jdks|dkrdS||jjt}|jj||S)a  Measures the current angle energy Returns ------- energy : float or None Angle strain energy in kcal/mol. Return value is None if either the coordinates of either atom is not set or the angle type is not set N)r:rtr"r r=)rPr3ZdarKrKrLr>s z Angle.energycCs|}|dk r|tjSdS)z" Same as energy(), but with units N)r>rEr)rPr?rKrKrLr@sz Angle.uenergycCs dt|j|j|j|j|jfS)Nz<%s %r--%r--%r; type=%r>)rtrgrmrnro)rPrKrKrLrszAngle.__repr__)N) rgrhrirjrqrsrvr:r<r>r@rrKrKrKrLrhs c@s\eZdZdZdddZeddZddZd d Ze Z d d Z e d dZ e ddZdS)ra An angle type with a set of angle parameters Parameters ---------- k : ``float`` Force constant in kcal/mol/radians^2 theteq : ``float`` Equilibrium angle in Degrees list : :class:`TrackedList` A list of `AngleType`s in which this is a member Inherited Attributes -------------------- idx : ``int`` The index of this AngleType inside its containing list Notes ----- Two `AngleType`s are equal if their `k` and `theteq` attributes are equal Examples -------- >>> at1 = AngleType(10.0, 180.0) >>> at2 = AngleType(10.0, 180.0) >>> at1 is at2 False >>> at1 == at2 True >>> at1.idx # not part of any list or iterable -1 As part of a list, they can be indexed >>> angle_list = [] >>> angle_list.append(AngleType(10.0, 180.0, list=angle_list)) >>> angle_list.append(AngleType(10.0, 180.0, list=angle_list)) >>> angle_list[0].idx 0 >>> angle_list[1].idx 1 NcCs@t|t|tjtjd|_t|tj|_d|_ ||_ dS)NrDr_) rwrqrMrErradiansr=rGr"rbrU)rPr=r"rUrKrKrLrqs  zAngleType.__init__cCs(t|j|jtko&t|j|jtkS)N)r#r=r r")rPrQrKrKrLrAszAngleType.__eq__cCsdt|j|j|jfS)Nz<%s; k=%.3f, theteq=%.3f>)rtrgr=r")rPrKrKrLrszAngleType.__repr__cCst|j|jS)N)rr=r")rPrKrKrLrszAngleType.__copy__cCstt|jtt|jtfS)N)rCrDr=rEr")rPrKrKrLrF"szAngleType.__hash__cCs|jtjtjdS)NrD)r=rErrI)rPrKrKrLrG%sz AngleType.ukcCs |jtjS)N)r"rErG)rPrKrKrLutheteq)szAngleType.utheteq)N)rgrhrirjrqrTrArrr]r\rFrkrGrJrKrKrKrLrs*   c@steZdZdZdddZeddZejddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZdS)r"a A valence dihedral between 4 atoms separated by three covalent bonds. Parameters ---------- atom1 : :class:`Atom` An atom on one end of the valence dihedral bonded to atom 2 atom2 : :class:`Atom` An atom in the middle of the valence dihedral bonded to atom1 and atom3 atom3 : :class:`Atom` An atom in the middle of the valence dihedral bonded to atom2 and atom4 atom4 : :class:`Atom` An atom on the other end of the valence dihedral bonded to atom 3 improper : ``bool`` If True, this is an Amber-style improper torsion, where atom3 is the "central" atom bonded to atoms 1, 2, and 4 (atoms 1, 2, and 4 are *only* bonded to atom 3 in this instance) ignore_end : ``bool`` If True, the end-group interactions for this torsion are ignored, either because it is involved in a ring where the end-group atoms are excluded or because it is one term in a multi-term dihedral expansion type : :class:`DihedralType` The DihedralType object containing the parameters for this dihedral Notes ----- A Dihedral can contain bonds or atoms. A bond is contained if it exists between atoms 1 and 2, between atoms 2 and 3, or between atoms 3 and 4. Examples -------- >>> a1, a2, a3, a4 = Atom(), Atom(), Atom(), Atom() >>> dihed = Dihedral(a1, a2, a3, a4) >>> Bond(a1,a2) in dihed and Bond(a3,a2) in dihed and Bond(a3,a4) in dihed True >>> a1 in dihed and a2 in dihed and a3 in dihed and a4 in dihed True >>> Bond(a1, a4) in dihed # this is not part of the angle definition False For improper torsions, the bond pattern is different >>> a1, a2, a3, a4 = Atom(), Atom(), Atom(), Atom() >>> dihed = Dihedral(a1, a2, a3, a4, improper=True) >>> Bond(a1,a3) in dihed and Bond(a2,a3) in dihed and Bond(a3,a4) in dihed True >>> Bond(a1,a2) in dihed # Not like a normal dihedral! False >>> a1 in dihed and a2 in dihed and a3 in dihed and a4 in dihed True FNcCst||||||p|}|j||j||j||j|||_||_||_|rhd|_nB||||||||||||d|_dS)Nr) rlrqrrrtimproper ignore_end_functr)rPrmrnrorprKrLrtrKrKrLrqcs$          zDihedral.__init__cCsH|jdkrB|jdk r$t|jtr$dS|jdk r>t|jtr>dSdS|jS)N rr)rMrtrr$r?)rPrKrKrLr5zs zDihedral.functcCs ||_dS)N)rM)rPrJrKrKrLr5scCst|trt||S|jrX|j|kr0|j|kpV|j|krD|j|kpV|j|koV|j|kS|j|krl|j|kp|j|kr|j|kp|j|ko|j|kS)zG Quick and easy way to find out if an Atom or Bond is in this Dihedral ) rrrlrsrKrmrornrp)rPr8rKrKrLrss  zDihedral.__contains__cCst|tr^|j|jkr:|j|jkr:|j|jkr:|j|jkp\|j|jko\|j|jko\|j|jkSt|}t|dkrtdt |j t|f|jj |dkr|jj |dkr|jj |dkr|jj |dkp|jj |dko|jj |dko|jj |dko|jj |dkS)a Determines if this dihedral has the same atoms (or atom indexes) as another object Parameters ---------- thing : :class:`Dihedral` or other ``iterable`` A Dihedral or an iterable with 4 indexes that will be used to identify whether this torsion has the same atoms Returns ------- is_same : ``bool`` True if ``thing`` and ``self`` have the same atoms. ``False`` otherwise Notes ----- This raises a ``TypeError`` if thing is not a Dihedral and is not iterable Raises ------ TypeError rz)comparative %s has %d elements! Expect 4.rrrDr) rr"rmrnrorprUr rrtrgrf)rPr8rKrKrL same_atomss"   zDihedral.same_atomscCs t|jj|t|jj|t|jj|t|jj||jst|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jd|_|_|_|_|_dS)a Deletes this dihedral from the atoms that make it up. This method removes this dihedral from the `dihedrals` list for atom1, atom2, atom3, and atom4 as well as removing each atom form each others' dihedral partner lists N) r}rmrrnrorprKrrt)rPrKrKrLrvs$zDihedral.deletecCsLd|j|j|j|jfkrdSyt|j|j|j|jStk rFdSXdS)a Measures the current dihedral angle Returns ------- measurement : float or None If the atoms have coordinates, returns the dihedral angle between the four atoms in degrees. If any coordinates are missing, returns None N)rmrnrorprrN)rPrKrKrLr:s zDihedral.measurecCs|}|dk r|tjSdS)z# Same as measure(), but with units N)r:rErG)rPr;rKrKrLr<szDihedral.umeasurec Cs|}|dks|jdkrdS|t9}t|jtr\|jjdt|jj||jj tSt|jt rd}x6|jD],}||jdt|j||j t7}qtW|d9}|St ddS)a! Measures the current dihedral angle energy Returns ------- energy : float or None Dihedral angle energy in kcal/mol. Return value is None if either the coordinates of either atom is not set or the angle type is not set Nrrg?zLOnly DihedralType and DihedralTypeList are supported for energy calculations) r:rtr rr#phi_krr$perphaser$NotImplementedError)rPphieZtermrKrKrLr>s  $  zDihedral.energycCs|}|dk r|tjSdS)z" Same as energy(), but with units N)r>rEr)rPr?rKrKrLr@ szDihedral.uenergycCsT|jrdt|j}n |jr,dt|j}n t|j}d||j|j|j|j|jfS)Nz%s [imp]z%s [ign]z<%s; %r--%r--%r--%r; type=%r>)rKrtrgrLrmrnrorp)rPrrKrKrLr s zDihedral.__repr__)FFN)rgrhrirjrqrkr5rrsrOrvr:r<r>r@rrKrKrKrLr"/s2  1c@s\eZdZdZdddZeddZdd Zd d Ze Z d d Z e ddZ e ddZdS)r#a A dihedral type with a set of dihedral parameters Parameters ---------- phi_k : ``float`` The force constant in kcal/mol per : ``int`` The dihedral periodicity phase : ``float`` The dihedral phase in degrees scee : ``float``, optional 1-4 electrostatic scaling factor. Default is 1.0 scnb : ``float``, optional 1-4 Lennard-Jones scaling factor. Default is 1.0 list : :class:`TrackedList` A list of `DihedralType`s in which this is a member Inherited Attributes -------------------- idx : ``int`` The index of this DihedralType inside its containing list Notes ----- Two :class:`DihedralType`s are equal if their `phi_k`, `per`, `phase`, `scee`, and `scnb` attributes are equal Examples -------- >>> dt1 = DihedralType(10.0, 2, 180.0, 1.2, 2.0) >>> dt2 = DihedralType(10.0, 2, 180.0, 1.2, 2.0) >>> dt1 is dt2 False >>> dt1 == dt2 True >>> dt1.idx # not part of any list or iterable -1 As part of a list, they can be indexed >>> dihedral_list = [] >>> dihedral_list.append(DihedralType(10.0, 2, 180.0, 1.2, 2.0, ... list=dihedral_list)) >>> dihedral_list.append(DihedralType(10.0, 2, 180.0, 1.2, 2.0, ... list=dihedral_list)) >>> dihedral_list[0].idx 0 >>> dihedral_list[1].idx 1 ?NcCsXt|d|_t|tj|_t||_t|tj |_ ||_ ||_ ||_ d|_d|_dS)z DihedralType constructor Tr_N)rwrqlockedrMrErrPintrQrGrRsceescnbrUrb)rPrPrQrRrYrZrUrKrKrLrq] s  zDihedralType.__init__cCs\t|j|jtkoZ|j|jkoZt|j|jtkoZt|j|jtkoZt|j|jtkS)N)r#rPr rQrRrYrZ)rPrQrKrKrLrAl s (zDihedralType.__eq__cCs>dt|j|j|j|jfg}|d|j|jfd|S)Nz%<%s; phi_k=%.3f, per=%d, phase=%.3f, z scee=%.3f, scnb=%.3f>r) rtrgrPrQrRrrYrZr)rPretstrrKrKrLrr szDihedralType.__repr__cCst|j|j|j|j|jS)N)r#rPrQrRrYrZ)rPrKrKrLrx szDihedralType.__copy__cCs:tt|jtt|jtt|jtt|jtt|jtfS)N)rCrDrPrErQrRrYrZ)rPrKrKrLrF} szDihedralType.__hash__cCs |jtjS)N)rPrEr)rPrKrKrLuphi_k szDihedralType.uphi_kcCs |jtjS)N)rRrErG)rPrKrKrLuphase szDihedralType.uphase)rVrVN)rgrhrirjrqrTrArrr]r\rFrkr\r]rKrKrKrLr#& s3   c@seZdZdZdddZeddZdd Zd d Ze Z d d Z e ddZ e ddZe ddZe ddZe ddZe ddZdS)r?a A Ryckaert-Bellemans type with a set of dihedral parameters Parameters (and Attributes) --------------------------- c0 : float The coefficient of the constant term in kcal/mol c1 : float The coefficient of the linear term in kcal/mol c2 : float The coefficient of the quadratic term in kcal/mol c3 : float The coefficient of the cubic term in kcal/mol c4 : float The coefficient of the quartic term in kcal/mol c5 : float The coefficient of the quintic term in kcal/mol scee : float, optional 1-4 electrostatic scaling factor. Default is 1.0 scnb : float, optional 1-4 van der Waals scaling factor. Default is 1.0 list : TrackedList=None A list of `RBTorsionType`s in which this is a member Inherited Attributes -------------------- idx : int The index of this RBTorsionType inside its containing list Notes ----- Two `RBTorsionType`s are equal if their coefficients are all equal Examples -------- >>> dt1 = RBTorsionType(10.0, 20.0, 30.0, 40.0, 50.0, 60.0) >>> dt2 = RBTorsionType(10.0, 20.0, 30.0, 40.0, 50.0, 60.0) >>> dt1 is dt2 False >>> dt1 == dt2 True >>> dt1.idx # not part of any list or iterable -1 As part of a list, they can be indexed >>> rb_torsion_list = [] >>> rb_torsion_list.append(RBTorsionType(10.0, 20.0, 30.0, 40.0, 50.0, 60.0, ... list=rb_torsion_list)) >>> rb_torsion_list.append(RBTorsionType(10.0, 20.0, 30.0, 40.0, 50.0, 60.0, ... list=rb_torsion_list)) >>> rb_torsion_list[0].idx 0 >>> rb_torsion_list[1].idx 1 ?Nc Cszt|t|tj|_t|tj|_t|tj|_t|tj|_t|tj|_ t|tj|_ ||_ ||_ | |_ d|_dS)Nr_)rwrqrMrErc0c1c2c3c4c5rYrZrUrb) rPr_r`rarbrcrdrYrZrUrKrKrLrq s zRBTorsionType.__init__cCsxt|j|jtkovt|j|jtkovt|j|jtkovt|j|jtkovt|j|jtkovt|j|jtkS)N)r#r_r r`rarbrcrd)rPrQrKrKrLrA s zRBTorsionType.__eq__c Cs&t|j|j|j|j|j|j|j|jS)N) r?r_r`rarbrcrdrYrZ)rPrKrKrLr szRBTorsionType.__copy__c Cs(d|j|j|j|j|j|j|j|jfS)NzW)r_r`rarbrcrdrYrZ)rPrKrKrLr szRBTorsionType.__repr__c CsDtt|jtt|jtt|jtt|jtt|jtt|jtfS)N) rCrDr_rEr`rarbrcrd)rPrKrKrLrF szRBTorsionType.__hash__cCs |jtjS)N)r_rEr)rPrKrKrLuc0 szRBTorsionType.uc0cCs |jtjS)N)rarEr)rPrKrKrLuc1 szRBTorsionType.uc1cCs |jtjS)N)rarEr)rPrKrKrLuc2 szRBTorsionType.uc2cCs |jtjS)N)rbrEr)rPrKrKrLuc3 szRBTorsionType.uc3cCs |jtjS)N)rcrEr)rPrKrKrLuc4 szRBTorsionType.uc4cCs |jtjS)N)rdrEr)rPrKrKrLuc5 szRBTorsionType.uc5)r^r^N)rgrhrirjrqrTrArrr]r\rFrkrerfrgrhrirjrKrKrKrLr? s8       c@sjeZdZdZddZeddZeddZdd d Z e d d Z d dZ ddZ eddgZddZdS)r$a Dihedral types are a Fourier expansion of terms. In some cases, they are stored in a list like this one inside another TrackedList. In other cases, each term is a separate entry in the :class:`TrackedList`. In cases where `DihedralType`s are stored with every term in the same container, this object supports list assignment and indexing like :class:`DihedralType`. Parameters ---------- *args : objects Any arguments that ``list`` would take. list : TrackedList, optional A list that "contains" this DihedralTypeList instance. This is a keyword-only argument. Default is ``None`` (i.e., belonging to no list) **kwargs : keyword argument list All other keyword arguments passed directly to the ``list`` constructor cOs>d|kr|d|_nd|_tj|f||d|_d|_dS)NrUr_F)r{rUrqrbrx)rPrrrKrKrLrq s zDihedralTypeList.__init__c Cs:|j}|j}|j}|j}|j}|j}dtj}d|d|d||d|d} d|d|d|d} ||d} d |d|d } |d} | d }|}xHt| | | | | |fD]0\}}t |t kr| t ||||j |jd qWt|dkr6t | t kr.| t d d||j |jd ntd |S)aa Creates a Fourier series of proper torsions from a Ryckaerts-Bellemans torsion. Parameters ---------- rbtorsion : RBTorsionType The R-B torsion type to convert to a series of proper torsions Raises ------ ValueError if all terms in rbtorsion are zero except for c0 rrg @irrD)rYrZgz(Unable to convert RB torsion to propers.)r_r`rarbrcrdrErGrar#r rr#rYrZr r)rZ rbtorsionr_r`rarbrcrdrTZfc0Zfc1Zfc2Zfc3Zfc4Zfc5instrdfrKrKrLfrom_rbtorsion( s, (    zDihedralTypeList.from_rbtorsioncCs<t|t|krdSx"t||D]\}}||ks dSq WdS)NFT)r r)rPrQZt1Zt2rKrKrLrAS s zDihedralTypeList.__eq__FcCsrt|tstdxNt|D]B\}}|j|jkr||kr)rUr)rPrKrKrLr szDihedralTypeList.__repr__cCstdd|DS)NcSsg|] }t|qSrK)r)rVrrKrKrLr sz-DihedralTypeList.__copy__..)r$)rPrKrKrLr szDihedralTypeList.__copy__rUrycCs tt|S)N)rCtuple)rPrKrKrLrF szDihedralTypeList.__hash__N)F)rgrhrirjrqrrqrTrArrkryrrr]r\rFrKrKrKrLr$ s +  %  c@s2eZdZdZd ddZddZddZd d ZdS) r2a+ A Urey-Bradley angle type with a set of parameters. It has the same functional form as a bond, but it is defined between two atoms forming a valence angle separated by two bonds. Parameters ---------- atom1 : :class:`Atom` The first atom involved in the Urey-Bradley bond atom2 : :class:`Atom` The other atom involved in the Urey-Bradley bond type : :class:`BondType` The Urey-Bradley bond type that defines the parameters for this bond Notes ----- You can test whether an :class:`Atom` is contained within the bond using the `in` operator. A :class:`MoleculeError` is raised if `atom1` and `atom2` are identical. You can also test that a :class:`Bond` is contained in this Urey-Bradley valence angle Examples -------- >>> a1, a2, a3 = Atom(), Atom(), Atom() >>> b1 = Bond(a1, a2) >>> b2 = Bond(a2, a3) >>> angle = Angle(a1, a2, a3) >>> urey = UreyBradley(a1, a3) >>> a1 in urey and a3 in urey True >>> b1 in urey and b2 in urey True NcCsF||krtd||f||_||_|j||j|||_dS)z Bond constructor z+Cannot bond atom to itself! Atoms are %s %sN)r rmrnrrrt)rPrmrnrtrKrKrLrq s   zUreyBradley.__init__cCszt|tr||jkp||jkS|j|krD|j|kr6dS|j}|j}n |j}|j}x$|jD]}||krfqX||krXdSqXWdS)zF Quick and easy way to see if an Atom or Bond is in this Urey-Bradley FT)rrrmrnr)rPr8Zend1ZcentrrKrKrLrs s    zUreyBradley.__contains__cCs2t|jj|t|jj|d|_|_|_dS)z Deletes this Urey-Bradley from the atoms that make it up. This method removes this urey-bradley from the `urey_bradleys` list for atom1 and atom2. N)r}rmrrnrt)rPrKrKrLrv szUreyBradley.deletecCsdt|j|j|j|jfS)Nz<%s %r--%r; type=%r>)rtrgrmrn)rPrKrKrLr szUreyBradley.__repr__)N)rgrhrirjrqrsrvrrKrKrKrLr2 s ! ! c@sZeZdZdZdddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ dS)r%a A CHARMM-style improper torsion between 4 atoms. The first atom must be the central atom, as shown in the schematic below A3 | | A4 ----- A1 ----- A2 Parameters ---------- atom1 : :class:`Atom` The central atom A1 in the schematic above atom2 : :class:`Atom` An atom in the improper, A2 in the schematic above atom3 : :class:`Atom` An atom in the improper, A3 in the schematic above atom4 : :class:`Atom` An atom in the improper, A4 in the schematic above type : :class:`ImproperType` The ImproperType object containing the parameters for this improper torsion Notes ----- An Improper torsion can contain bonds or atoms. A bond is contained if it exists between atom 1 and any other atom. Raises :class:`MoleculeError` if any of the atoms are duplicates. Examples -------- >>> a1, a2, a3, a4 = Atom(), Atom(), Atom(), Atom() >>> imp = Improper(a1, a2, a3, a4) >>> Bond(a1, a2) in imp and Bond(a1, a3) in imp and Bond(a1, a4) in imp True >>> Bond(a2, a3) in imp False NcCsRt||||||j||j||j||j|||_d|_dS)NrD)rlrqrrrtr5)rPrmrnrorprtrKrKrLrq! s    zImproper.__init__cCsRt|trt||S|j|kr*|j|kpP|j|kr>|j|kpP|j|koP|j|kS)zW Quick and easy way to find out if an Atom or Bond is in this Improper )rrrlrsrmrnrorp)rPr8rKrKrLrs, s   zImproper.__contains__cCst|trJ|j|jk rdSt|j|j|jg}t|j|j|jg}||kSt|}t|dkrnt dt||jj |dkrdSt|jj |jj |jj g}t|d|d|dg}||kS)z| An improper has the same 4 atoms if atom1 is the same for both and the other 3 can be in any order FrzImpropers have 4 atoms, not %srrrDr) rr%rmrrnrorprUr r rf)rPr8ZselfsetZothersetrKrKrLrO7 s   zImproper.same_atomscCsLd|j|j|j|jfkrdSyt|j|j|j|jStk rFdSXdS)a  Measures the current torsional angle Returns ------- measurement : float or None If the atoms have coordinates, returns the torsional angle between the four atoms. If any coordinates are missing, returns None N)rmrnrorprrN)rPrKrKrLr:Q s zImproper.measurecCs|}|dk r|tjSdS)z# Same as measure(), but with units N)r:rErG)rPr;rKrKrLr<a szImproper.umeasurecCs>|}|dks|jdkrdS|jj|t}|jj||S)a! Measures the current dihedral angle energy Returns ------- energy : float or None Dihedral angle energy in kcal/mol. Return value is None if either the coordinates of either atom is not set or the angle type is not set N)r:rtpsi_eqr psi_k)rPrTZdphirKrKrLr>f s zImproper.energycCs|}|dk r|tjSdS)z" Same as energy(), but with units N)r>rEr)rPr?rKrKrLr@v szImproper.uenergycCsZt|jj|t|jj|t|jj|t|jj|d|_|_|_|_|_dS)z Deletes this Improper from the atoms that make it up. This method removes this Improper from the `impropers` list for atom1, atom2, atom3, and atom4 N)r}rmrrnrorprt)rPrKrKrLrv{ s zImproper.deletecCs$dt|j|j|j|j|j|jfS)Nz<%s; %r--(%r,%r,%r); type=%r>)rtrgrmrnrorp)rPrKrKrLr s zImproper.__repr__)N) rgrhrirjrqrsrOr:r<r>r@rvrrKrKrKrLr% s&   c@s\eZdZdZdddZeddZddZd d Ze Z d d Z e d dZ e ddZdS)r&a? An improper type with a set of improper torsion parameters Parameters ---------- psi_k : ``float`` Force constant in kcal/mol/radians^2 psi_eq : ``float`` Equilibrium torsion angle in Degrees list : :class:`TrackedList` A list of `ImproperType`s in which this is a member Inherited Attributes -------------------- idx : ``int`` The index of this ImproperType inside its containing list Notes ----- Two `ImproperType`s are equal if their `psi_k` and `psi_eq` attributes are equal Examples -------- >>> it1 = ImproperType(10.0, 180.0) >>> it2 = ImproperType(10.0, 180.0) >>> it1 is it2 False >>> it1 == it2 True >>> it1.idx # Not part of any list or iterable -1 As part of a list, they can be indexed >>> improper_list = [] >>> improper_list.append(ImproperType(10.0, 180.0, list=improper_list)) >>> improper_list.append(ImproperType(10.0, 180.0, list=improper_list)) >>> improper_list[0].idx 0 >>> improper_list[1].idx 1 NcCs@t|t|tjtjd|_t|tj|_||_ d|_ dS)NrDr_) rwrqrMrErrIryrGrxrUrb)rPryrxrUrKrKrLrq s  zImproperType.__init__cCs(t|j|jtko&t|j|jtkS)N)r#ryr rx)rPrQrKrKrLrA szImproperType.__eq__cCsdt|j|j|jfS)Nz<%s; psi_k=%.3f, psi_eq=%.3f>)rtrgryrx)rPrKrKrLr szImproperType.__repr__cCst|j|jS)N)r&ryrx)rPrKrKrLr szImproperType.__copy__cCstt|jtt|jtfS)N)rCrDryrErx)rPrKrKrLrF szImproperType.__hash__cCs|jtjtjdS)NrD)ryrErrI)rPrKrKrLupsi_k szImproperType.upsi_kcCs |jtjS)N)rxrErG)rPrKrKrLupsi_eq szImproperType.upsi_eq)N)rgrhrirjrqrTrArrr]r\rFrkrzr{rKrKrKrLr& s+   c@sHeZdZdZdddZedddZddZd d Zd d Z d dZ dS)r a A coupled-torsion correction map term defined between 5 atoms connected by four covalent bonds. This is a coupled-torsion potential in which the torsions are consecutive. Parameters ---------- atom1 : :class:`Atom` An atom on one end of the valence coupled-torsion bonded to atom2 atom2 : :class:`Atom` An atom in the middle of the CMAP bonded to atoms 1 and 3 atom3 : :class:`Atom` An atom in the middle of the CMAP bonded to atoms 2 and 4 atom4 : :class:`Atom` An atom in the middle of the CMAP bonded to atoms 3 and 5 atom5 : :class:`Atom` An atom in the middle of the CMAP bonded to atom 4 type : :class:`CmapType` The CmapType object containing the parameter map for this term Notes ----- A CMAP can contain bonds or atoms. A bond is contained if it exists between atoms 1 and 2, between atoms 2 and 3, between atoms 3 and 4, or between atoms 4 and 5. Examples -------- >>> a1, a2, a3, a4, a5 = Atom(), Atom(), Atom(), Atom(), Atom() >>> cmap = Cmap(a1, a2, a3, a4, a5) >>> Bond(a1, a2) in cmap and Bond(a2, a3) in cmap True >>> Bond(a1, a3) in cmap False Nc Cs|||||g}xXtt|D]H}xBt|dt|D],} |||| kr4td|||| fq4WqW||_||_||_||_||_|j ||j ||j ||j ||j |||_ d|_ dS)Nrz+Cannot cmap atom to itself! Atoms are %s %s) rr r rmrnrorpatom5rrrtr5) rPrmrnrorpr|rtZatmlistrdjrKrKrLrq s&     z Cmap.__init__c Cs4||k s||k s||k r td||||||| dS)a Alternative constructor for correction maps defined with 8 atoms (each torsion being separately specified). Correction maps are, to the best of my knowledge, used to parametrized "consecutive" torsions (i.e., atoms 2, 3, and 4 are common to both torsions). However, the CHARMM definition specifies the torsions separately. If the torsions are _not_ consecutive (i.e., if atoms 2, 3, and 4 are not the same as atoms 5, 6, and 7), NotImplementedError is raised. Parameters ---------- atom1 : :class:`Atom` The first atom of the first torsion atom2 : :class:`Atom` The second atom of the first torsion atom3 : :class:`Atom` The third atom of the first torsion atom4 : :class:`Atom` The fourth atom of the first torsion atom5 : :class:`Atom` The first atom of the second torsion atom6 : :class:`Atom` The second atom of the second torsion atom7 : :class:`Atom` The third atom of the second torsion atom8 : :class:`Atom` The fourth atom of the second torsion type : :class:`CmapType` The CmapType object containing the parameter map for this term zBOnly consecutive coupled-torsions are supported by CMAPs currently)rt)rS) rrmrnrorpr|atom6Zatom7Zatom8rtrKrKrLextended s!z Cmap.extendedcCst|tr<||jkp:||jkp:||jkp:||jkp:||jkS|j|krP|j|kp|j|krd|j|kp|j|krx|j|kp|j|ko|j|kS)zc Quick and easy way to find out an atom or bond is in this coupled-torsion )rrrmrnrorpr|)rPr8rKrKrLrs> s  zCmap.__contains__cCsPt|tr|j|jkrF|j|jkrF|j|jkrF|j|jkrF|j|jkp|j|jko|j|jko|j|jko|j|jko|j|jkSt|}t|dkrt dt||jj |dkr|jj |dkr|jj |dkr|jj |dkr|jj |dkpN|jj |dkoN|jj |dkoN|jj |dkoN|jj |dkoN|jj |dkS)z A coupled-torsion is equivalent if the 5 atoms are in the same or reverse order Allow comparison with another type of cmap or with a sequence of 5 indexes rlz&CMAP can compare to 5 elements, not %drrrDrr) rr rmrnrorpr|rUr r rf)rPr8rKrKrLrOL s       $$zCmap.same_atomscCsnt|jj|t|jj|t|jj|t|jj|t|jj|d|_|_|_|_|_|_dS)z Deletes this Cmap from the atoms that make it up. This method removes the Cmap from the `cmaps` list for atom1, atom2, atom3, atom4, and atom5 N)r}rmrrnrorpr|rt)rPrKrKrLrvg s z Cmap.deletecCs(dt|j|j|j|j|j|j|jfS)Nz!<%s; %r--%r--%r--%r--%r; type=%r>)rtrgrmrnrorpr|)rPrKrKrLrt s z Cmap.__repr__)N)N) rgrhrirjrqrrrsrOrvrrKrKrKrLr s#  % c@sDeZdZdZd ddZeddZddZd d Ze Z d d Z dS)r!aL A CMAP type with a potential energy interpoloation grid mapping out the 2-D potential of coupled torsions. Parameters ---------- resolution : ``int`` The number of grid points in the correction map potential in both torsion dimensions grid : ``iterable of floats`` This must be a 1-dimensional list of grid values. The dimension must be `resolution*resolution`, and must be row-major (i.e., the second dimension changes the fastest) when indexed with 2 indices. list : :class:`TrackedList` A list of `CmapType`s in which this is a member Attributes ---------- resolution : ``int`` Potential grid resolution (see description in Parameters) grid : :class:`_CmapGrid` A _CmapGrid object defining the interpolating potential energy grid, with each point having the units kcal/mol comments : ``list(str)`` List of strings that represent comments about this parameter type list : :class:`TrackedList` If not None, this is a list in which this instance _may_ be a member idx : ``int`` The index of this CmapType inside its containing list Notes ----- Two `CmapType`s are equal if their resolution is the same and each grid point is the same to within 1E-8 See the docs for `_CmapGrid` for information on how to access the interpolating grid data if necessary. Raises ------ TypeError is raised if the grid does not have the correct number of elements for the given resolution Examples -------- >>> ct = CmapType(2, [0, 1, 2, 3]) >>> ct.grid[0,0], ct.grid[0] (0, 0) >>> ct.grid[0,1], ct.grid[1] (1, 1) >>> ct.grid[1,0], ct.grid[2] (2, 2) >>> ct.grid[1,1], ct.grid[3] (3, 3) >>> ct.idx # not part of a list or iterable -1 NcCs^t|||_t|||_t||j|jkr8td|dkrHg|_n||_d|_||_ dS)Nz,CMAP grid does not match expected resolutionr_) rwrq resolution _CmapGridgridr rcommentsrbrU)rPrrrrUrKrKrLrq s  zCmapType.__init__cCs(|j|jko&tddt|j|jDS)Ncss"|]\}}t||tkVqdS)N)r#r )rVrdr}rKrKrL sz"CmapType.__eq__..)rallrr)rPrQrKrKrLrA s zCmapType.__eq__cCsdt|j|jfS)Nz<%s; resolution=%d>)rtrgr)rPrKrKrLr szCmapType.__repr__cCs t|jt|jj|jddS)N)r!rrr_datar)rPrKrKrLr szCmapType.__copy__cCst|j|jfS)N)rCrr)rPrKrKrLrF szCmapType.__hash__)NN) rgrhrirjrqrTrArrr]r\rFrKrKrKrLr!z s9 c@s~eZdZdZdddZeddZeZddZd d Z d d Z d dZ ddZ ddZ eddZddZddZddZdS)ra A grid object for storing Correction map data. Data can be accessed in one of two ways; either with 1 or 2 indexes. If 2 indexes [i,j] are given, the index into the flattened array is i*resolution+j. Indexing starts from 0. The _CmapGrid usually has ranges for the two angles from -180 to 180. Some places will expect the range to be 0-360 degrees (e.g., OpenMM). The switch_range method returns a _CmapGrid with the "other" range than the current object. i.e., if the current range is from 0 to 360 degrees, the _CmapGrid returned by `switch_range` will be from -180 to 180, and vice versa. Example: >>> g = _CmapGrid(2, [0, 1, 2, 3]) >>> print('%s %s' % (g[0], g[0,0])) 0 0 >>> print('%s %s' % (g[1], g[0,1])) 1 1 >>> print(g[1,0]) 2 >>> g[1,1] = 10 >>> print(g[3]) 10 >>> print(g.switch_range()) [10.0000, 2.0000 1.0000, 0.0000] NcCs>||_|dkr,ddt|j|jD|_nt|tj|_dS)NcSsg|]}dqS)rrK)rVrdrKrKrLr sz&_CmapGrid.__init__..)rrrrMrEr)rPrdatarKrKrLrq sz_CmapGrid.__init__csjtdrjSg}tj}x6tjD](}fddt||jD}||7}q*Wtj|_jS)z% The transpose of the potential grid _transposecsg|] }|qSrKrK)rVr})rPrKrLr sz'_CmapGrid.transpose..)rurr rrrr)rPrsizerdZpiecerK)rPrL transpose s   z_CmapGrid.transposecCsTt|trJ|d|jks&|d|jkr.td|j|j|d|dS|j|S)Nrrz_CmapGrid: Index out of range)rrwrrr)rPrfrKrKrL __getitem__ s  z_CmapGrid.__getitem__cCs*t|trT|d|jks&|d|jkr.tdt|tj|j|j|d|d<nyt| t |j}Wn&t k rt|tj|j|<YnXy t |}Wnt k rd}YnX|dkrxb|D]}t|tj|j|<qWnB|t |krt dn,x*t||D]\}}t|tj|j|<qWdS)Nrrz_CmapGrid: Index out of rangez&Wrong number of values setting a slice)rrwrrrMrErrrindicesr rNrrr)rPrfrXrZlenvalrrrKrKrL __setitem__ s& &     z_CmapGrid.__setitem__cCs t|jS)N)r r)rPrKrKrL__len__& sz_CmapGrid.__len__cCs t|jS)N)iterr)rPrKrKrL__iter__) sz_CmapGrid.__iter__cCsd|j|jfS)Nz<_CmapGrid: %dx%d>)r)rPrKrKrLr, sz_CmapGrid.__repr__cCsd|jd}d}xpt|D]d\}}|dkr.q|||7}|d|jdkrh|t|jdkrh|d7}q|t|dkr|d7}qW|dS)Nz[%.4f,rz %.4fr ,])rrarr )rPr[ZfmtrdrXrKrKrL__str__/ s $  z_CmapGrid.__str__cCs@|j|jkrdSx*t||D]\}}t||tkrdSqWdS)NFT)rrr#r )rPrQrrrKrKrLrA; s  z_CmapGrid.__eq__cCsj|j}|d}t|}xNt|D]B}|||}x0t|D]$}|||}|||f|||f<q:Wq W|S)z Returns a grid object whose range is 0 to 360 degrees in both dimensions instead of -180 to 180 degrees (or -180 to 180 degrees if the range is already 0 to 360 degrees) rD)rrr)rPresZmidZnewgridrdZiir}ZjjrKrKrL switch_rangeD s  z_CmapGrid.switch_rangecCst|jt|jS)N)rrrr)rPrKrKrLrU sz_CmapGrid.__copy__cCsttdd|DS)NcSsg|]}t|tqSrK)rDrE)rVrrKrKrLrY sz&_CmapGrid.__hash__..)rCrw)rPrKrKrLrFX sz_CmapGrid.__hash__)N)rgrhrirjrqrkrTrrrrrrrTrArrrFrKrKrKrLr s   rc@s*eZdZdZd ddZddZddZdS) r0a A trigonal-angle term in the AMOEBA force field. It exists in a pattern like the one shown below A1 | | A4----A2----A3 Parameters ---------- atom1 : :class:`Atom` The first atom involved in the trigonal angle atom2 : :class:`Atom` The central atom involved in the trigonal angle atom3 : :class:`Atom` The third atom involved in the trigonal angle atom4 : :class:`Atom` The fourth atom involved in the trigonal angle type : :class:`AngleType` The angle type containing the parameters Notes ----- Either `Atom`s or `Bond`s can be contained within this trigonal angle NcCst|||||||_dS)N)rlrqrt)rPrmrnrorprtrKrKrLrqx szTrigonalAngle.__init__cCsRt|trt||S|j|kr*|j|kpP|j|kr>|j|kpP|j|koP|j|kS)N)rrrlrsrmrnrorp)rPr8rKrKrLrs| s   zTrigonalAngle.__contains__cCs$dt|j|j|j|j|j|jfS)Nz<%s; %r--(%r,%r,%r); type=%r>)rtrgrnrmrorp)rPrKrKrLr s zTrigonalAngle.__repr__)N)rgrhrirjrqrsrrKrKrKrLr0] s c@s*eZdZdZd ddZddZddZdS) r(a Out-of-plane bending term in the AMOEBA force field. The bond pattern is the same as :class:`TrigonalAngle` Parameters ---------- atom1 : :class:`Atom` The first atom involved in the trigonal angle atom2 : :class:`Atom` The central atom involved in the trigonal angle atom3 : :class:`Atom` The third atom involved in the trigonal angle atom4 : :class:`Atom` The fourth atom involved in the trigonal angle type : :class:`OutOfPlaneBendType` The angle type containing the parameters Notes ----- Either `Atom`s or `Bond`s can be contained within this trigonal angle NcCst|||||||_dS)N)rlrqrt)rPrmrnrorprtrKrKrLrq szOutOfPlaneBend.__init__cCsRt|trt||S|j|kr*|j|kpP|j|kr>|j|kpP|j|koP|j|kS)N)rrrlrsrmrnrorp)rPr8rKrKrLrs s   zOutOfPlaneBend.__contains__cCs$dt|j|j|j|j|j|jfS)Nz<%s; %r--(%r,%r,%r); type=%r>)rtrgrnrmrorp)rPrKrKrLr s zOutOfPlaneBend.__repr__)N)rgrhrirjrqrsrrKrKrKrLr( s c@sPeZdZdZdddZeddZddZd d Ze Z d d Z e d dZ dS)r3a An angle type with a set of angle parameters Parameters ---------- k : ``float`` Force constant in kcal/mol/radians^2 list : :class:`TrackedList` A list of `OutOfPlaneBendType`s in which this is a member Inherited Attributes -------------------- idx : ``int`` The index of this OutOfPlaneBendType inside its containing list Notes ----- Two `OutOfPlaneBendType`s are equal if their `k` attribute is equal Examples -------- >>> ot1 = OutOfPlaneBendType(10.0) >>> ot2 = OutOfPlaneBendType(10.0) >>> ot1 is ot2 False >>> ot1 == ot2 True >>> ot1.idx # not part of any list or iterable -1 As part of a list, they can be indexed >>> oopbend_list = [] >>> oopbend_list.append(OutOfPlaneBendType(10.0, list=oopbend_list)) >>> oopbend_list.append(OutOfPlaneBendType(10.0, list=oopbend_list)) >>> oopbend_list[0].idx 0 >>> oopbend_list[1].idx 1 NcCs2t|t|tjtjd|_d|_||_dS)NrDr_) rwrqrMrErrIr=rbrU)rPr=rUrKrKrLrq s zOutOfPlaneBendType.__init__cCst|j|jtkS)N)r#r=r )rPrQrKrKrLrA szOutOfPlaneBendType.__eq__cCsdt|j|jfS)Nz <%s; k=%.3f>)rtrgr=)rPrKrKrLr szOutOfPlaneBendType.__repr__cCs t|jS)N)r3r=)rPrKrKrLr szOutOfPlaneBendType.__copy__cCstt|jtS)N)rCrDr=rE)rPrKrKrLrF szOutOfPlaneBendType.__hash__cCs|jtjtjdS)NrD)r=rErrI)rPrKrKrLrG szOutOfPlaneBendType.uk)N)rgrhrirjrqrTrArrr]r\rFrkrGrKrKrKrLr3 s(  c@s*eZdZdZd ddZddZddZdS) r)a| Defines a pi-torsion term in the AMOEBA force field. The Pi-torsion is defined around a sp2-hybridized pi-delocalized orbital (like an amide) by 6 atoms, as shown in the schematic below. A2 A5-AAA \ / \ / A3---A4 / \ / \ AAA-A1 A6 In the above schematic, A3 and A4 are sp2-hybridized, and atoms A2 and A6 are bonded *only* to A3 and A4, respectively. Atoms A1 and A5 are each bonded to 3 other atoms. Parameters ---------- atom1 : :class:`Atom` atom A1 in the schematic above atom2 : :class:`Atom` atom A2 in the schematic above atom3 : :class:`Atom` atom A3 in the schematic above atom4 : :class:`Atom` atom A4 in the schematic above atom5 : :class:`Atom` atom A5 in the schematic above atom6 : :class:`Atom` atom A6 in the schematic above type : :class:`DihedralType` The parameters for this Pi-torsion Notes ----- Both :class:`Bond`s and :class:`Atom`s can be contained in a pi-torsion NcCs.||_||_||_||_||_||_||_dS)N)rmrnrorpr|r~rt)rPrmrnrorpr|r~rtrKrKrLrqszPiTorsion.__init__cCst|trF||jkpD||jkpD||jkpD||jkpD||jkpD||jkS|j|krZ|j|kp|j|krn|j|kp|j|kr|j|kp|j|kr|j|kp|j|ko|j|kS)N)rrrmrnrorpr|r~)rPr8rKrKrLrs%s zPiTorsion.__contains__c Cs,dt|j|j|j|j|j|j|j|jfS)Nz'<%s; (%r,%r)--%r--%r--(%r,%r); type=%r>)rtrgrmrnrorpr|r~)rPrKrKrLr1s zPiTorsion.__repr__)N)rgrhrirjrqrsrrKrKrKrLr) s'  c@s*eZdZdZd ddZddZddZdS) r,a1 This term models the stretching and bending of a standard valence angle, and is used in the AMOEBA force field Parameters ---------- atom1 : :class:`Atom` The first atom on one end of the angle atom2 : :class:`Atom` The central atom in the angle atom3 : :class:`Atom` The atom on the other end of the angle type : :class:`StretchBendType` The type containing the stretch-bend parameters Notes ----- Both :class:`Bond`s and :class:`Atom`s can be contained in a stretch-bend term NcCs||_||_||_||_dS)N)rmrnrort)rPrmrnrortrKrKrLrqLszStretchBend.__init__cCsPt|tr(|j|kp&|j|kp&|j|kS|j|kr<|j|kpN|j|koN|j|kS)N)rrrmrnro)rPr8rKrKrLrsRs   zStretchBend.__contains__cCs dt|j|j|j|j|jfS)Nz<%s; %r--%r--%r; type=%r>)rtrgrmrnro)rPrKrKrLrYs zStretchBend.__repr__)N)rgrhrirjrqrsrrKrKrKrLr,8s c@seZdZdZdddZeddZddZd d Ze Z d d Z e d dZ e ddZe ddZe ddZe ddZdS)r-a A stretch-bend type with two distances and an angle in AMOEBA Parameters ---------- k1 : ``float`` First force constant in kcal/mol/(radians*angstroms) k2 : ``float`` Second force constant in kcal/mol/(radians*angstroms) req1 : ``float`` Equilibrium bond distance for bond between the first and second atoms in Angstroms req2 : ``float`` Equilibrium bond distance for bond between the second and third atoms in Angstroms theteq : ``float`` Equilibrium angle in degrees list : :class:`TrackedList` A list of `StretchBendType`s in which this is a member Inherited Attributes -------------------- idx : ``int`` The index of this StretchBendType inside its containing list Notes ----- Two `StretchBendType`s are equal if their `req1`, `req2`, `theteq`, and `k` attributes are equal Examples -------- >>> sbt1 = StretchBendType(10.0, 10.0, 1.0, 1.0, 180.0) >>> sbt2 = StretchBendType(10.0, 10.0, 1.0, 1.0, 180.0) >>> sbt1 is sbt2 False >>> sbt1 == sbt2 True >>> sbt1.idx # Not part of any list or iterable -1 As part of a list, they can be indexed >>> strbnd_list = [] >>> strbnd_list.append(StretchBendType(10.0, 10.0, 1.0, 1.0, 180.0, strbnd_list)) >>> strbnd_list.append(StretchBendType(10.0, 10.0, 1.0, 1.0, 180.0, strbnd_list)) >>> strbnd_list[0].idx 0 >>> strbnd_list[1].idx 1 NcCsxt|t|tjtjtj|_t|tjtjtj|_t|tj |_ t|tj |_ t|tj |_ d|_||_dS)Nr_)rwrqrMrErradianrk1k2rreq1req2rGr"rbrU)rPrrrrr"rUrKrKrLrqs zStretchBendType.__init__cCsdt|j|jtkobt|j|jtkobt|j|jtkobt|j|jtkobt|j|jtkS)N)r#rr rrrr")rPrQrKrKrLrAs zStretchBendType.__eq__cCs$dt|j|j|j|j|j|jfS)Nz9<%s; req1=%.3f, req2=%.3f, theteq=%.3f, k1=%.3f, k2=%.3f>)rtrgrrr"rr)rPrKrKrLrszStretchBendType.__repr__cCst|j|j|j|j|jS)N)r-rrrrr")rPrKrKrLrszStretchBendType.__copy__cCs:tt|jtt|jtt|jtt|jtt|jtfS)N)rCrDrrErrrr")rPrKrKrLrFszStretchBendType.__hash__cCs|jtjtjtjS)N)rrErrr)rPrKrKrLuk1szStretchBendType.uk1cCs|jtjtjtjS)N)rrErrr)rPrKrKrLuk2szStretchBendType.uk2cCs |jtjS)N)rrEr)rPrKrKrLureq1szStretchBendType.ureq1cCs |jtjS)N)rrEr)rPrKrKrLureq2szStretchBendType.ureq2cCs |jtjS)N)r"rErG)rPrKrKrLrJszStretchBendType.utheteq)N)rgrhrirjrqrTrArrr]r\rFrkrrrrrJrKrKrKrLr-_s3     c@s"eZdZdZdddZddZdS)r.a This is a coupled-torsion map used in the AMOEBA force field similar to the correction-map (CMAP) potential used by the CHARMM force field Parameters ---------- atom1 : :class:`Atom` An atom on one end of the valence torsion-torsion bonded to atom2 atom2 : :class:`Atom` An atom in the middle of the torsion-torsion bonded to atoms 1 and 3 atom3 : :class:`Atom` An atom in the middle of the torsion-torsion bonded to atoms 2 and 4 atom4 : :class:`Atom` An atom in the middle of the torsion-torsion bonded to atoms 3 and 5 atom5 : :class:`Atom` An atom in the middle of the torsion-torsion bonded to atom 4 type : :class:`TorsionTorsionType` The TorsionTorsionType object containing the parameter map for this term Notes ----- A TorsionTorsion can contain bonds or atoms. A bond is contained if it exists between atoms 1 and 2, between atoms 2 and 3, between atoms 3 and 4, or between atoms 4 and 5. Examples -------- >>> a1, a2, a3, a4, a5 = Atom(), Atom(), Atom(), Atom(), Atom() >>> tortor = TorsionTorsion(a1, a2, a3, a4, a5) >>> Bond(a1, a2) in tortor and Bond(a2, a3) in tortor True >>> Bond(a1, a3) in tortor False Nc Cst||||||||j||j||j||j||j|||||||||||||||||||||dS)N)r rqrrr)rPrmrnrorpr|rtrKrKrLrqs               zTorsionTorsion.__init__cCst|jj|t|jj|t|jj|t|jj|t|jj|t|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jt|jj|jd|_|_|_|_|_d|_dS)a  Deletes this TorsionTorsion from the atoms that make it up. This method removes the TorsionTorsion from the `tortors` list for atom1, atom2, atom3, atom4, and atom5, and removes each atom from the others' tortor_partners list. N) r}rmrrnrorpr|rrt)rPrKrKrLrvs6zTorsionTorsion.delete)N)rgrhrirjrqrvrKrKrKrLr.s" c@s<eZdZdZddZddZddZedd Zd d Z d S) _TorTorTablea Contains an interpolating potential grid for a coupled-torsion in the AMOEBA force field. Parameters ---------- ang1 : ``list of floats`` Angles in the first dimension of the interpolation table ang2 : ``list of floats`` Angles in the second dimension of the interpolation table data : ``list of floats`` Value of the potential grid at each point (ang2 varies fastest) Notes ----- Raises `TypeError` if the dimension of the data array does not match the number of data required by ang1 and ang2 Elements from the table are obtained and/or set by using angles as indexes. If the pair of angles was not one of the original angles passed to this table, a KeyError is raised. Examples -------- >>> table = _TorTorTable([1.0, 2.0], [1.0, 2.0, 3.0], [1, 2, 3, 4, 5, 6]) >>> table[1.0,1.0] 1 >>> table[1.0,2.0] 2 >>> table[2.0,2.0] 5 >>> table[2.0,2.0] = 10 >>> table.data [1, 2, 3, 4, 10, 6] cCst|t|t|krDtdt|t|t|t|t|ft|tj|_t|_d}x0|D](}x"|D]}||j||f<|d7}qnWqdWdS)NzPCoupled torsion parameter size mismatch. %dx%d grid expects %d elements (got %d)rr)r rrMrErrr_indexes)rPang1ang2rrdr%r&rKrKrLrqKs"  z_TorTorTable.__init__cCs|j|j|S)N)rr)rPrfrKrKrLrXsz_TorTorTable.__getitem__cCs(|jt|tj}t|tj|j|<dS)N)rrMrErGrr)rPrfrJrKrKrLr[sz_TorTorTable.__setitem__cCsRy4x.|jD] }t||||tkrdSqWWntk rHdSXdSdS)NFT)rkeysr#r KeyError)rPrQrfrKrKrLrA_s z_TorTorTable.__eq__cCs || S)N)rA)rPrQrKrKrLrzjsz_TorTorTable.__ne__N) rgrhrirjrqrrrTrArzrKrKrKrLr's #  rc@s<eZdZdZd ddZeddZddZd d Ze Z dS) r/a The type containing the parameter maps for the Amoeba torsion-torsion potentials. It contains the original potential as well as interpolated first and second derivatives for the AMOEBA force field. Parameters ---------- dims : ``tuple of 2 ints`` The table dimensions ang1 : ``list of floats`` The list of angles in the first dimension ang2 : ``list of floats`` The list of angles in the second dimension f : ``list of floats`` The interpolation table for the energy dfda1 : ``list of floats`` The interpolation table of the gradient w.r.t. angle 1 dfda2 : ``list of floats`` The interpolation table of the gradient w.r.t. angle 2 d2fda1da2 : ``list of floats`` The interpolation table of the 2nd derivative w.r.t. both angles list : :class:`TrackedList` The list containing this coupled torsion-torsion map Attributes ---------- dims : ``tuple of 2 ints`` The table dimensions ang1 : ``list of floats`` The list of angles in the first dimension ang2 : ``list of floats`` The list of angles in the second dimension f : :class:`_TorTorTable` The interpolation table for the energy as a _TorTorTable dfda1 : :class:`_TorTorTable` The interpolation table for the first gradient as a _TorTorTable dfda2 : :class:`_TorTorTable` The interpolation table for the second gradient as a _TorTorTable d2fda1da2 : :class:`_TorTorTable` The interpolation table for the second derivative as a _TorTorTable list : :class:`TrackedList` The list that may, or may not, contain this TorsionTorsionType idx : ``int`` The index of this item in the list or iterable defined by `list` Nc Cst|t|dkrtdt||dks>t||dkrFtdt||_t|tj|_ t|tj|_ t ||||_ |dkrd|_ nt ||||_ |dkrd|_nt ||||_|dkrd|_nt ||||_d|_||_dS)NrDz%dims must be a 2-dimensional iterablerrz%dims does match the angle definitionsr_)rwrqr rrwdimsrMrErGrrrrpdfda1dfda2 d2fda1da2rbrU) rPrrrrprrrrUrKrKrLrqs(    zTorsionTorsionType.__init__cCs`|j|jkrdS|j|jkr dS|j|jkr0dS|j|jko^|j|jko^|j|jko^|j|jkS)NF)rrrrprrr)rPrQrKrKrLrAs   zTorsionTorsionType.__eq__cCs dt|j|jd|jdfS)Nz <%s; %dx%d>rr)rtrgr)rPrKrKrLrszTorsionTorsionType.__repr__cCszt|jj}|jdkrd}n t|jj}|jdkr8d}n t|jj}|jdkrTd}n t|jj}t|j|j|j ||||S)N) rrprrrrr/rrr)rPrprrrrKrKrLrs       zTorsionTorsionType.__copy__)NNNN) rgrhrirjrqrTrArrr]r\rKrKrKrLr/os -  c@s(eZdZdZddZddZddZdS) ra A chiral frame as defined in the AMOEBA force field. It defines the frame of reference for a chiral center Parameters ---------- atom1 : :class:`Atom` The first atom defined in the chiral frame atom2 : :class:`Atom` The second atom defined in the chiral frame chirality : ``int`` Either 1 or -1 to identify directionality. A ValueError is raised if a different value is provided Notes ----- A chiral frame can only contain atoms. cCs.||_||_|dkr$|dkr$td||_dS)Nrr_zchirality must be 1 or -1)rmrnr chirality)rPrmrnrrKrKrLrqs zChiralFrame.__init__cCs||jkp||jkS)N)rmrn)rPr8rKrKrLrsszChiralFrame.__contains__cCsdt|j|j|j|jfS)Nz<%s; %r--%r, direction=%d>)rtrgrmrnr)rPrKrKrLrszChiralFrame.__repr__N)rgrhrirjrqrsrrKrKrKrLrsc@s eZdZdZddZddZdS)r'a This defines the frame of reference for computing multipole interactions in the AMOEBA force field. Parameters ---------- atom : :class:`Atom` The atom for which the frame of reference is defined frame_pt_num : ``int`` The frame point number vectail : ``int`` The vector tail index vechead : ``int`` The vector head index nvec : ``int`` The number of vectors Examples -------- >>> atom = Atom() >>> mf = MultipoleFrame(atom, 0, 1, 2, 3) >>> atom in mf True >>> mf.frame_pt_num 0 >>> mf.vectail 1 >>> mf.vechead 2 >>> mf.nvec 3 cCs"||_||_||_||_||_dS)N)atom frame_pt_numvectailvecheadnvec)rPrrrrrrKrKrLrqs zMultipoleFrame.__init__cCs |j|kS)N)r)rPr8rKrKrLrs&szMultipoleFrame.__contains__N)rgrhrirjrqrsrKrKrKrLr's c@s&eZdZdZd ddZeddZd S) rBa6 An Atom that has a Drude particle attached to it. This is a subclass of Atom, so it also has all the properties defined for regular Atoms. Parameters ---------- alpha : ``float`` the atomic polarizability thole : ``float`` the Thole damping facior drude_type : ``str`` the atom type to use for the Drude particle. Other Attributes ---------------- anisotropy : :class:`DrudeAnisotropy` describes how this atom is anisotropically polarizable. For isotropic atoms, this is None. ?DRUDcKs*tj|f|||_||_||_d|_dS)N)rrqalphathole drude_typeZ anisotropy)rPrrrrrKrKrLrqAs zDrudeAtom.__init__cCs\|jdkrdnd}t|jtjddtjtj}|t|ddtjtjdS)Nrr_rrgkA]a@rDi) rr#rErZkilojoules_per_moleZ nanometerrrr)rPZsignrrKrKrL drude_chargeHs$zDrudeAtom.drude_chargeN)rrr)rgrhrirjrqrkrrKrKrKrLrB+s c@seZdZdZddZdS)rCa A description of an anisotropically polarizable atom. Atom 1 is a :class:`DrudeAtom` whose polarizability is anisotropic. The other three atoms define the coordinate frame. Parameters ---------- atom1 : :class:`DrudeAtom` the polarizable atom atom2 : :class:`Atom` the second atom defining the coordinate frame atom3 : :class:`Atom` the third atom defining the coordinate frame atom4 : :class:`Atom` the fourth atom defining the coordinate frame a11 : ``float`` the scale factor for the polarizability along the direction defined by atom1 and atom2 a22 : ``float`` the scale factor for the polarizability along the direction defined by atom3 and atom4 cCs"t|||||||_||_dS)N)rlrqa11a22)rPrmrnrorprrrKrKrLrqiszDrudeAnisotropy.__init__N)rgrhrirjrqrKrKrKrLrCPsc@seZdZdZd#ddZddZd d Zd d Zd dZddZ ddZ ddZ ddZ ddZ ddZddZddZdd ZeZd!d"ZdS)$r*a A single residue that is composed of a small number of atoms Parameters ---------- name : ``str`` Name of the residue. Typical convention is to choose a name that is 4 characters or shorter number : ``int``, optional Residue number assigned in the input structure. Default is -1 chain : ``str``, optional The 1-letter chain identifier for this residue. Default is empty string insertion_code : ``str``, optional The insertion code (used in PDB files) for this residue. Default is empty string segid : ``str``, optional The segment identifier, used by CHARMM in a way similar to chain. Dfault is empty string list : :class:`TrackedList` List of residues in which this residue is a member Attributes ---------- name : ``str`` The name of this residue number : ``int`` The number of this residue in the input structure idx : ``int`` The index of this residue inside the container. If this residue has no container, or it is not present in the container, idx is -1 chain : ``str`` The 1-letter chain identifier for this residue insertion_code : ``str`` The insertion code (used in PDB files) for this residue ter : ``bool`` If True, there is a TER card directly after this residue (i.e., a molecule or chain ends). By default, it is False list : :class:`TrackedList` The container that _may_ have this residue contained inside atoms : ``list of`` :`class`Atom` ``instances`` This is the list of `Atom`s that make up this residue Notes ----- - Iterating over a residue will iterate over the atoms. It is exactly equivalent to iterating over the `atoms` attribute - Supports testing if an Atom instance is contained `in` this residue - `len()` returns the number of atoms in this residue r_rNcCsF||_||_||_||_||_d|_g|_d|_||_ dS)Nr_F) rrrchaininsertion_coderUrbatomsZtersegid)rPrrrrrrUrKrKrLrqs   zResidue.__init__cCs||_|j|dS)z Adds an atom to this residue Parameters ---------- atom : :class:`Atom` The atom to add to this residue Notes ----- This action assigns the `residue` attribute to `atom` N)rrr)rPrrKrKrLadd_atoms zResidue.add_atomcs:x4|jD]*}j|krd_fdd|jD|_qWdS)z If an atom is present in this residue, delete it from the list of atoms. No change if an atom is not present in this residue. Ncsg|]}|k r|qSrKrK)rVr3)rrKrLrsz'Residue.delete_atom..)rr)rPrr3rK)rrL delete_atoms  zResidue.delete_atomcCs ||jkS)z, True if an atom is present in this residue )r)rPr8rKrKrLrsszResidue.__contains__cCs t|jS)N)r r)rPrKrKrLrszResidue.__len__cCs t|jS)N)rr)rPrKrKrLrszResidue.__iter__cCs t|dkS)z Determines if there are any atoms in this residue Returns ------- empty: ``bool`` ``True`` if there are no atoms left. ``False`` otherwise. r)r )rPrKrKrLis_emptys zResidue.is_emptycCs|jdS)z, Sorts the atoms in this list by atom index N)rsort)rPrKrKrLrsz Residue.sortcCs |j|S)N)rr)rPrfrKrKrLrszResidue.__getitem__cCs|jdj|jdjkS)Nr)rrf)rPrQrKrKrLrszResidue.__lt__cCs|jdj|jdjkS)Nr)rrf)rPrQrKrKrLrszResidue.__gt__cCs|jdj|jdjk S)Nr)rrf)rPrQrKrKrLrszResidue.__le__cCs|jdj|jdjk S)Nr)rrf)rPrQrKrKrLrszResidue.__ge__cCsr|jdkr|j}n|j}dt|j|j|f}|jrB|d|j7}|jrV|d|j7}|jrj|d|j7}|dS)Nr_z <%s %s[%d]z ; chain=%sz; insertion_code=%sz ; segid=%sr)rrfrtrgrrrr)rPZnumZreprKrKrLrs zResidue.__repr__cCs$|j|x|D] }||_qWdS)N)r[rr)rPrr3rKrKrLrs  zResidue.__setstate__)r_rrrN)rgrhrirjrqrrrsrrrrrrrrrrr]r\rrKrKrKrLr*ps$1   csfdd}|S)z, Decorator to indicate the list has changed csd|_d|_|f||S)NT)changedr`)rPrr)rRrKrLnew_funcsz_changes..new_funcrK)rRrrK)rRrL_changess rc@seZdZdZddZddZeddZedd Zedd d Z ed dZ ee j Z ee j Z ee jZee jZee jZee jZddZddZddZddZddZdS)r1aM This creates a list type that allows you to see if anything has changed Attributes ---------- changed : ``bool`` Determines if something has been done to fundamentally change the underlying topology defined by this list such that the topology needs to be rebuilt needs_indexing : ``bool`` A flag to determine whether or not the items in a tracked list need to be indexed or not. Examples -------- >>> tl = TrackedList() >>> tl.append(Atom()) >>> tl.append(Atom()) >>> tl.append(Atom()) >>> tl.needs_indexing, tl.changed (True, True) >>> tl.index_members() >>> tl.needs_indexing, tl.changed (False, True) >>> tl.changed = False # Must do when changes have been incorporated >>> tl.needs_indexing, tl.changed (False, False) cGsd|_d|_tj|f|S)NF)rr`rUrq)rPrrKrKrLrq*szTrackedList.__init__csdtjg}tdkrb|fddtdD|d|fddtdd Dn|d dD|d d |S) Nz%s([ c3s|]}d|VqdS)z %r NrK)rVrd)rPrKrLr2sz'TrackedList.__repr__..z ... c3s|]}d|VqdS)z %r NrK)rVrd)rPrKrLr4srcss|]}d|VqdS)z %r NrK)rVrdrKrKrLr6sz])r)rtrgr extendrrr)rPr[rK)rPrLr/s    zTrackedList.__repr__c Csyt|t|}Wntk r0|g}YnXxT|D]L}yd||_Wntk r^YnXyd||_Wq8tk rYq8Xq8Wt||S)z/ Deletes items and slices. Make sure all items r_N)rrr rNrbrU __delitem__)rPrerr|rKrKrLr:s   zTrackedList.__delitem__cCs|t||dS)z% Python 2 still uses __delslice__... N)rslice)rPrstoprKrKrL __delslice__PszTrackedList.__delslice__r_cCs t||}t|drd|_|S)Nrbr_)rUr{rurb)rPrfrerKrKrLr{Us  zTrackedList.popcCs t||t|drd|_dS)Nrbr_)rUremoverurb)rPr8rKrKrLr\s  zTrackedList.removecCstt||S)N)r1rU__add__)rPrQrKrKrLrlszTrackedList.__add__cCstt||S)N)r1rU__mul__)rPZfacrKrKrLroszTrackedList.__mul__c Cs@x4t|D](\}}y ||_Wq tk r0Yq Xq Wd|_dS)z Assigns the idx variable for every member of this list to its place in the list, if the members of this list permit FN)rarbrNr`)rPrdrerKrKrLrcrs   zTrackedList.index_membersc CsBx4t|D](\}}y ||_Wq tk r0Yq Xq W|dS)z This method causes this list to "claim" all of the items it contains and subsequently indexes all of its items. N)rarUrNrc)rPrdrerKrKrLclaims   zTrackedList.claimc CsHxBttt|D].}y||js(||=Wqtk r>YqXqWdS)z This method inspects the `used` attribute of all of its members, if it has one, and deletes any item in which it is set to `False` N)reversedrr rxrN)rPrdrKrKrL prune_unuseds   zTrackedList.prune_unusedN)r_)rgrhrirjrqrrrrr{rrUrrinsertr__iadd____imul__rrrcrrrKrKrKrLr1 s&            c@s"eZdZdZdddZddZdS) r+z Array of `Residue` instances rc Cs|}|}y |d}Wn<tk rXt||||||d}||||YnxX|j|ks|j|ks|j|ks|j|ks|j |krt||||||d}||||n ||dS)ay Adds a new atom to the ResidueList, adding a new residue to this list if it has a different name or number as the last residue Parameters ---------- atom : :class:`Atom` The atom to add to this residue list resname : ``str`` The name of the residue this atom belongs to resnum : ``int`` The number of the residue this atom belongs to chain : ``str`` The chain ID character for this residue inscode : ``str`` The insertion code ID character for this residue (it is stripped) segid : ``str`` The segment identifier for this residue (it is stripped) Notes ----- If the residue name and number differ from the last residue in this list, a new residue is added and the atom is added to that residue r_)rUN) rrr*rrrrrrr) rPrZresnameZresnumrZinscoderZlastZnew_resrKrKrLrs"      zResidueList.add_atomcCs4x.ttt|D]}||}|r||=qWdS)a This function goes through the residue list and removes all empty residues from the list. This isn't done automatically when atoms are deleted, since it will become very slow. You must remember to do this to avoid including empty residues N)rrr r)rPrdrrKrKrLpruneszResidueList.pruneN)rrr)rgrhrirjrrrKrKrKrLr+s .c@szeZdZdZeddZedddZeddZd d Zed d Z ed dZ eddZ ddZ ddZ ddZdS)rz Array of Atoms Notes ----- Deleting an atom from the AtomList also deletes that atom from the residue it belongs to. cCszyt|t|}Wntk r0|g}YnXx6|D].}||}d|_d|_|jdk r8|j|q8Wt||dS)z; Deleting an atom also needs to delete it from the residue r_N) rrr rNrbrUrrr)rPrfrr|rrKrKrLrs   zAtomList.__delitem__r_cCs2t||}d|_d|_|jdk r.|j||S)Nr_)rUr{rbrr)rPrfrrKrKrLr{s   z AtomList.popcCsH|j|k rtd||jdk r,|j|d|_d|_t||dS)Nz%r is not in listr_)rUrrrrbr)rPrrKrKrLrs   zAtomList.removecCsx|D] }d|_qWdS)z Unmark all atoms in this list rN)r)rPrrKrKrLunmarks zAtomList.unmarkcCs||_t||S)a Add an Atom to the end of the list and have this list claim ownership of the item. Parameters ---------- item : :class:`Atom` The atom to add to this list Notes ----- Only Atom objects should be added here, so if `item` does not have a `list` attribute, an AttributeError will be raised. This action assigns this list as the `list` attribute to the passed Atom. )rUr)rPrerKrKrLr szAtomList.appendcCs x|D] }||_qWt||S)a0 Add an iterable of `Atom`s to the end of the list and have this list claim ownership of the items. Parameters ---------- items : iterable of :class:`Atom`s The iterable containing Atom instances to add to the end of this list Notes ----- Any generator passed here will be exhausted. The `list` attribute for every object in `items` will have their `list` attribute set to this list, and an AttributeError will be raised if this is not possible. )rUr)rPitemsrerKrKrLrs  zAtomList.extendcCs||_t|||S)aB Insert an Atom into the atom list Parameters ---------- idx : ``int`` The index in front of (i.e., before) which to insert the item item : :class:`Atom` The atom to insert in the desired index. This atom will be claimed by the AtomList )rUr)rPrfrerKrKrLr4s zAtomList.insertc Csd}t|}t}g}x.t|D]"\}}|jtkr:tdd|j_q Wxt|D]~\}}|j}|jdkrjqP||_||t|<||x>t |d|D],}||} | j} | jdkrq|| kr|| _qW|d7}qPWx|D]}|jj|_ qWddt |dD} xt|D]t\}} xh| j D]^} | j | \}}}}y || }Wnt k rVwYn X|j||||f}| | |qWq W| S)a Assigns the nb_idx attribute of every atom inside here from the atom_type definition. If the atom_type is not assigned, RuntimeError is raised. Returns ------- ``list of dict`` Each element is a `set` of the `nb_idx` indices for which NBFIX alterations are defined for the type with that given that index (minus 1, to adjust for indexing from 0 and nb_idx starting from 1) rzatom types are not assignedr_cSsg|] }tqSrK)r)rVrdrKrKrLrmsz4AtomList.assign_nbidx_from_types..)r rrarr@r rbstrrrrnbfixrr)rPrfZnatomsZatom_type_lookupsZatom_type_listrdrZtype1r}rnZtype2Z nbfix_listrtrWrepsreps14ZotyperrrKrKrLassign_nbidx_from_typesDsH             z AtomList.assign_nbidx_from_typescCs,x|D]}|j|kr|SqWtd|dS)a4 Finds an atom with the given original index. Cannot assume that the original indexes are in order, since reordering may have been necessary. As a result, the complexity of this algorithm is O(N) Parameters ---------- idx : int The integer corresponding to the original index Returns ------- atom : :class:`Atom` The atom with the original index ``idx`` Raises ------ IndexError If no atom has the original index ``idx`` zNo atom found with index %dN)rr)rPrfrrKrKrLfind_original_index|s  zAtomList.find_original_indexcCstS)N)rO)rPrQrKrKrLrszAtomList.__iadd__N)r_)rgrhrirjrrr{rrrrrrrrrKrKrKrLrs      8c@s*eZdZdZd ddZddZddZdS) r4a The AMOEBA force field has complex exclusion and exception rules (referred to as "adjustments" in the Amber-converted files). This class stores per-particle exceptions. Parameters ---------- atom1 : :class:`Atom` One of the atoms in the exclusion pair atom2 : :class:`Atom` The other atom in the exclusion pair type : :class:`NonbondedExceptionType` The nonbonded exception type that describes how the various nonbonded interactions between these two atoms should work Notes ----- NonbondedException objects "contain" two atoms and will return True when used with the binary `in` operator NcCs||_||_||_d|_dS)Nr)rmrnrtr5)rPrmrnrtrKrKrLrqszNonbondedException.__init__cCs||jkp||jkS)N)rmrn)rPr8rKrKrLrsszNonbondedException.__contains__cCsJdt|j|j|jfg}|jdk r6|d|jn |dd|S)Nz<%s; %r and %rz , type=%r>rr)rtrgrmrnrr)rPr[rKrKrLrs    zNonbondedException.__repr__)N)rgrhrirjrqrsrrKrKrKrLr4s c@szeZdZdZdddZeddZejddZed d Zed d Z ed dZ ddZ e ddZ eZddZdS)r5a A parameter describing how the various nonbonded interactions between a particular pair of atoms behaves in a specified nonbonded exception (e.g., in 1-4 interacting terms) Parameters ---------- rmin : float The combined Rmin value for this particular pair of atom types (dimension length, default units are Angstroms) epsilon : float The combined well-depth value for this particular pair of atom types (dimension energy, default units are kcal/mol) chgscale : float, optional The scaling factor by which to multiply the product of the charges for this pair. Default is 1.0. list : :class:`TrackedList` The list containing this nonbonded exception ?NcCs<t|t|tj|_t|tj|_||_d|_ ||_ dS)N) rwrqrMrErrrrchgscalerbrU)rPrrrrUrKrKrLrqs  zNonbondedExceptionType.__init__cCs |jdS)Ng)N>?)r)rPrKrKrLrszNonbondedExceptionType.sigmacCs|d|_dS)NgÚ?)r)rPrJrKrKrLrscCs |jtjS)N)rrEr)rPrKrKrLrszNonbondedExceptionType.usigmacCs |jtjS)N)rrEr)rPrKrKrLrszNonbondedExceptionType.urmincCs |jtjS)N)rrEr)rPrKrKrLrszNonbondedExceptionType.uepsiloncCsdt|j|j|j|jfS)Nz,<%s; rmin=%.4f, epsilon=%.4f, chgscale=%.4f>)rtrgrrr)rPrKrKrLrszNonbondedExceptionType.__repr__cCs<t|j|jtko:t|j|jtko:t|j|jtkS)N)r#rr rr)rPrQrKrKrLrAs(zNonbondedExceptionType.__eq__cCs&tt|jtt|jtt|jtfS)N)rCrDrrErr)rPrKrKrLrFszNonbondedExceptionType.__hash__)rN)rgrhrirjrqrkrrrrrrrTrAr]r\rFrKrKrKrLr5s      c@s<eZdZdZd ddZeddZddZeZ d d Z dS) r6a A parameter describing how the various nonbonded interactions between a particular pair of atoms is scaled in the AMOEBA force field Parameters ---------- vdw_weight : ``float`` The scaling factor by which van der Waals interactions are multiplied multipole_weight : ``float`` The scaling factor by which multipole interactions are multiplied direct_weight : ``float`` The scaling factor by which direct-space interactions are multiplied polar_weight : ``float`` The scaling factor by which polarization interactions are multiplied mutual_weight : ``float`` The scaling factor by which mutual interactions are multiplied list : :class:`TrackedList` The list containing this nonbonded exception Other Attributes ---------------- idx : ``int`` The index of this term in the list that contains it NcCs.||_||_||_||_||_d|_||_dS)Nr_)rmultipole_weight direct_weight polar_weight mutual_weightrbrU)rPrrrrrrUrKrKrLrqsz%AmoebaNonbondedExceptionType.__init__cCsdt|j|jtkobt|j|jtkobt|j|jtkobt|j|jtkobt|j|jtkS)N)r#rr rrrr)rPrQrKrKrLrA(s z#AmoebaNonbondedExceptionType.__eq__cCst|j|j|j|j|jS)N)r6rrrrr)rPrKrKrLr0sz%AmoebaNonbondedExceptionType.__copy__cCs:tt|jtt|jtt|jtt|jtt|jtfS)N)rCrDrrErrrr)rPrKrKrLrF8s     z%AmoebaNonbondedExceptionType.__hash__)N) rgrhrirjrqrTrArr]r\rFrKrKrKrLr6s  c@seZdZdZd*ddZeddZd+d d Zed d Z e j d d Z ddZ d,ddZ eddZ e j ddZ eddZeddZej ddZeddZeddZeddZed d!Zed"d#Zd$d%Zd&d'Zd(d)ZdS)-r9a Atom types can either be compared by indexes or names. Can be assigned with a string, integer, (string is not automatically cast) or with both. Parameters ---------- name : ``str`` The name of the atom type number : ``int`` The serial index of the atom type mass : ``float`` The mass of the atom type atomic_number : ``int``, optional The atomic number of the element of the atom type. Default -1 bond_type : ``str``, optional If defined, this is the type name used to look up bonded parameters. Default is None (which falls back to ``name``) charge : ``float``, optional If defined, this is the partial atomic charge in elementary charge units. Default is None Other Attributes ---------------- epsilon : ``float`` If set, it is the Lennard-Jones well depth of this atom type rmin : ``float`` If set, it is the Lennard-Jones Rmin/2 parameter of this atom type epsilon_14 : ``float`` If set, it is the Lennard-Jones well depth of this atom type in 1-4 nonbonded interactions rmin_14 : ``float`` If set, it is the Lennard-Jones Rmin/2 parameter of this atom type in 1-4 nonbonded interactions sigma : ``float`` This is the sigma parameter, which is just equal to Rmin*2^(1/6) sigma_14 : ``float`` This is the sigma parameter corresponding to rmin_14, which is just equal to Rmin_14*2^(1/6) nbfix : ``dict(str:tuple)`` A hash that maps atom type names of other atom types with which _this_ atom type has a defined NBFIX with a tuple containing the terms (Rmin, epsilon, Rmin14, Epsilon14) _bond_type : str or None If an explicit value was given to bond_type, _bond_type will be set to a value. Otherwise, _bond_type will be None (and bond_type will be the same as ``name``). This can be used to determine if a bond_type was specified by comparing to None. Notes ----- This object is primarily used to build parameter databases from parameter files. Also, sigma is related to Rmin, but rmin is Rmin/2, so there is an extra factor of 2 in the sigma for this reason. Examples -------- >>> at = AtomType('HA', 1, 1.008, 1) >>> at.name, at.number ('HA', 1) >>> at2 = AtomType('CA', 2, 12.01, 6) >>> at2.name, at2.number ('CA', 2) >>> print("%s: %d" % (str(at), int(at))) HA: 1 r_NcCs|dkr6|dk r6t|tr(||_d|_qF||_d|_n||_t||_t|tj|_||_d|_ |_ |_ |_ t |_d|_||_||_dS)Nr_)rrXrrrMrErrrrrrrrrrb _bond_typer)rPrrrr bond_typerrKrKrLrqs  zAtomType.__init__cCst|trH|j|jks$|j|jkr(dSd}d}xTdD]L}t||dkr^t||dkr^d}q6q6t||dkszt||dkr~dSd}q6W|r|r|r|rtd|sdS|jdks|jdkr|j|jk rdSnt|j|jtkrdSt|j |j tkoFt|j |j tkoFt|j |j tkoFt|j |j tkoF|j |j kSt|tr^|j|kSt|trt|j|kS||j|jfkS)zm Compares based on available properties (name and number, just name, or just number) FT)rrrrNz%Should have all or none at this point)rr9rrr~r rr#r rrrrrrrX)rPrQZhas_allZhas_nonerrKrKrLrAs>        zAtomType.__eq__cCs`t|r|tj}t|r,|tj}|dkr8|}|dkrD|}||_||_||_||_dS)z1 Sets Lennard-Jones parameters on this atom type N) rErFrHrrrrrr)rPrrrrrKrKrL set_lj_paramss    zAtomType.set_lj_paramscCs|jdkr|jS|jS)N)rr)rPrKrKrLrs zAtomType.bond_typecCs ||_dS)N)r)rPrJrKrKrLrscCs|jS)z8 The integer representation of an AtomType is its index )r)rPrKrKrL__int__szAtomType.__int__cCs.|dkr |}|dkr|}||||f|j|<dS)a Adds a new NBFIX exclusion for this atom type Parameters ---------- typename : str The name of the *other* type with which this NBFIX is defined rmin : float The combined Rmin value for this NBFIXed pair. If no units, assumed to be in Angstroms epsilon : float The combined epsilon value for this NBFIXed pair. If no units, assumed to be in kcal/mol rmin14 : float, optional Same as rmin, but for 1-4 interactions. If None (default), it is given the same value as rmin epsilon14 : float, optional Same as epsilon, but for 1-4 interactions. If None (default), it is given the same value as rmin N)r)rPtypenamerrrrrKrKrL add_nbfixs zAtomType.add_nbfixcCs|jddS)z Sigma is Rmin / 2^(1/6) g)N>?rD)r)rPrKrKrLrszAtomType.sigmacCs|dd|_dS)NgÚ?rD)r)rPrJrKrKrLrscCs |jtjS)N)rrEr)rPrKrKrLrszAtomType.usigmacCs|jddS)z Sigma is Rmin / 2^(1/6) g)N>?rD)r)rPrKrKrLr szAtomType.sigma_14cCs|dd|_dS)NgÚ?rD)r)rPrJrKrKrLrscCs |jtjS)N)rrEr)rPrKrKrLrszAtomType.usigma_14cCs |jtjS)N)rrEr)rPrKrKrLrszAtomType.urmincCs |jtjS)N)rrEr)rPrKrKrLrszAtomType.uepsiloncCs |jtjS)N)rrEr)rPrKrKrLrszAtomType.urmin_14cCs |jtjS)N)rrEr)rPrKrKrLr"szAtomType.uepsilon_14cCs|jS)N)r)rPrKrKrLr&szAtomType.__str__cCsPt|j|j|j|j|j|jd}|j|_|j|_|j |_ |j |_ |j |_ |S)N)rr) r9rrrrrrrrrrrr)rPZcprKrKrLr)s zAtomType.__copy__c Cs8t|j|j|j|j|j|j|j|j|j t |j f S)N) rCrrrrrrrrrrwrr)rPrKrKrLrF3szAtomType.__hash__)r_Nr)NN)NN)rgrhrirjrqrTrArrkrrrrrrrrrrrrrrrFrKrKrKrLr9As*@  +            csDeZdZdZdZfddZddZddZd d Zd d Z Z S) _UnassignedAtomTypezk This raises the appropriate exceptions (ParameterError) when you try to access its properties Ncs"|jdkrtt|||_|jS)N)_OBJrr__new__)r)rrKrLrAs z_UnassignedAtomType.__new__cCs tddS)NzAtom type is not defined)r)rPrKrKrLrFsz_UnassignedAtomType.__int__cCs tddS)NzAtom type is not defined)r)rPrKrKrLrIsz_UnassignedAtomType.__str__cCs t|tS)N)rr)rPrQrKrKrLrALsz_UnassignedAtomType.__eq__cCsdS)Nr@rK)rPrKrKrLrBOsz_UnassignedAtomType.__reduce__) rgrhrirjrrrrrArBrrKrK)rrLr:s rzNot a singletonc@s(eZdZdZddZddZddZdS) r7z Just a holder for donors and acceptors in CHARMM speak Parameters ---------- atom1 : :class:`Atom` First atom in the donor/acceptor group atom2 : :class:`Atom` Second atom in the donor/acceptor group cCs||_||_dS)N)rmrn)rPrmrnrKrKrLrqbszAcceptorDonor.__init__cCsd|j|jfS)Nz)rmrn)rPrKrKrLrfszAcceptorDonor.__repr__cCs||jkp||jkS)z+ See if the atom is in this donor/acceptor )rmrn)rPr8rKrKrLrsiszAcceptorDonor.__contains__N)rgrhrirjrqrrsrKrKrKrLr7Xs c@s$eZdZdZddZeddZdS)r8a~ An 'interacting' group defined by CHARMM PSF files Parameters ---------- atom : :class:`Atom` The first atom within a group type : ``int`` Flag for group information; 0 when all atoms have zero charge, 1 when group has a net zero charge but at least one atom has a non-zero partial charge, 2 when the net charge of the group is not zero move : ``int`` 0 if the atoms are not fixed, 1 when they are Notes ----- See the discussion on Github for the source of the meanings of these variables: https://github.com/ParmEd/ParmEd/pull/307#issuecomment-128244134 cCs||_||_||_dS)N)rrtmove)rPrrtrrKrKrLrqszGroup.__init__cCs$|j|jko"|j|jko"|j|jkS)N)rrtr)rPrQrKrKrLrAsz Group.__eq__N)rgrhrirjrqrTrArKrKrKrLr8osc@seZdZdZdddZdS)rAaF An intra-residue "Link" as defined by the PDB standard: See http://www.wwpdb.org/documentation/file-format-content/format33/sect6.html#LINK for more information Parameters ---------- atom1 : :class:`Atom` The first Atom involved in the Link atom2 : :class:`Atom` The other atom to which ``atom1`` is bonded in this link length : float The length of the link symmetry_op1 : str, optional The first symmetry operator for the link symmetry_op2 : str, optional The second symmetry operator for the link 1555cCs"||_||_||_||_||_dS)N)rmrnlength symmetry_op1 symmetry_op2)rPrmrnrrrrKrKrLrqs z Link.__init__N)rr)rgrhrirjrqrKrKrKrLrAsg)N)N)trjZ __future__rrrrrrr functoolsrrrrEZ constantsr rEr r r exceptionsr rrZgeometryrrrZutils.decoratorsrZ utils.sixrrZutils.six.movesrrZperiodic_tabler__all__rrrrZ scale_factorrHZ picosecondsZBaseUnitZpicosecond_base_unitZ dimensionZakma_time_unitZdefine_conversion_factor_toZ UnitSystemZangstrom_base_unitZdalton_base_unitZelementary_charge_base_unitZkelvin_base_unitZmole_base_unitZradian_base_unitrIrMrTr]objectr^rlrwr}rrr;r<r=r>rrrrr"r#r?rUr$r2r%r&r r!rr0r(r3r)r,r-r.rr/rr'rBrCr*rr1r+rr4r5r6r9rr@r r7r8rAr:rKrKrKrLs             6(  :Na/Y|KxfbM Z ,'DD'l\Hl#-% ?A)B<z