o Rŀg@sdZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z ddlZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z e rddl!m"Z"e#dZ$e#dZ%e e$e%fZ&e#dZ'ej(Z)e#ej(ej(ej(ej(fZ*GdddZ+GdddZ,Gd d!d!Z-Gd"d#d#e-Z.Gd$d%d%e-Z/Gd&d'd'Z0d(e1d)e1fd*d+Z2Gd,d-d-e3Z4Gd.d/d/e3Z5dS)0a1Classes to support internal coordinates for protein structures. Internal coordinates comprise Psi, Omega and Phi dihedral angles along the protein backbone, Chi angles along the sidechains, and all 3-atom angles and bond lengths defining a protein chain. These routines can compute internal coordinates from atom XYZ coordinates, and compute atom XYZ coordinates from internal coordinates. Secondary benefits include the ability to align and compare residue environments in 3D structures, support for 2D atom distance plots, converting a distance plot plus chirality information to a structure, generating an OpenSCAD description of a structure for 3D printing, and reading/writing structures as internal coordinate data files. **Usage:** :: from Bio.PDB.PDBParser import PDBParser from Bio.PDB.Chain import Chain from Bio.PDB.internal_coords import * from Bio.PDB.PICIO import write_PIC, read_PIC, read_PIC_seq from Bio.PDB.ic_rebuild import write_PDB, IC_duplicate, structure_rebuild_test from Bio.PDB.SCADIO import write_SCAD from Bio.Seq import Seq from Bio.SeqRecord import SeqRecord from Bio.PDB.PDBIO import PDBIO import numpy as np # load a structure as normal, get first chain parser = PDBParser() myProtein = parser.get_structure("7rsa", "pdb7rsa.ent") myChain = myProtein[0]["A"] # compute bond lengths, angles, dihedral angles myChain.atom_to_internal_coordinates(verbose=True) # check myChain makes sense (can get angles and rebuild same structure) resultDict = structure_rebuild_test(myChain) assert resultDict['pass'] == True # get residue 1 chi2 angle r1 = next(myChain.get_residues()) r1chi2 = r1.internal_coord.get_angle("chi2") # rotate residue 1 chi2 angle by 120 degrees (loops w/in +/-180) r1.internal_coord.set_angle("chi2", r1chi2 + 120.0) # or r1.internal_coord.bond_rotate("chi2", 120.0) # update myChain XYZ coordinates with chi2 changed myChain.internal_to_atom_coordinates() # write new conformation with PDBIO write_PDB(myProtein, "myChain.pdb") # or just the ATOM records without headers: io = PDBIO() io.set_structure(myProtein) io.save("myChain2.pdb") # write chain as 'protein internal coordinates' (.pic) file write_PIC(myProtein, "myChain.pic") # read .pic file myProtein2 = read_PIC("myChain.pic") # create default structure for random sequence by reading as .pic file myProtein3 = read_PIC_seq( SeqRecord( Seq("GAVLIMFPSTCNQYWDEHKR"), id="1RND", description="my random sequence", ) ) myProtein3.internal_to_atom_coordinates() write_PDB(myProtein3, "myRandom.pdb") # access the all-dihedrals array for the chain, e.g. residue 1 chi2 angle: r1chi2_obj = r1.internal_coord.pick_angle("chi2") # or same thing: r1chi2_obj = r1.internal_coord.pick_angle("CA:CB:CG:CD") r1chi2_key = r1chi2_obj.atomkeys # r1chi2_key is tuple of AtomKeys (1_K_CA, 1_K_CB, 1_K_CG, 1_K_CD) r1chi2_index = myChain.internal_coord.dihedraNdx[r1chi2_key] # or same thing: r1chi2_index = r1chi2_obj.ndx r1chi2_value = myChain.internal_coord.dihedraAngle[r1chi2_index] # also true: r1chi2_obj == myChain.internal_coord.dihedra[r1chi2_index] # access the array of all atoms for the chain, e.g. residue 1 C-beta r1_cBeta_index = myChain.internal_coord.atomArrayIndex[AtomKey("1_K_CB")] r1_cBeta_coords = myChain.internal_coord.atomArray[r1_cBeta_index] # r1_cBeta_coords = [ x, y, z, 1.0 ] # the Biopython Atom coord array is now a view into atomArray, so assert r1_cBeta_coords[1] == r1["CB"].coord[1] r1_cBeta_coords[1] += 1.0 # change the Y coord 1 angstrom assert r1_cBeta_coords[1] == r1["CB"].coord[1] # they are always the same (they share the same memory) r1_cBeta_coords[1] -= 1.0 # restore # create a selector to filter just the C-alpha atoms from the all atom array atmNameNdx = AtomKey.fields.atm atomArrayIndex = myChain.internal_coord.atomArrayIndex CaSelect = [ atomArrayIndex.get(k) for k in atomArrayIndex.keys() if k.akl[atmNameNdx] == "CA" ] # now the ordered array of C-alpha atom coordinates is: CA_coords = myChain.internal_coord.atomArray[CaSelect] # note this uses Numpy fancy indexing, so CA_coords is a new copy # create a C-alpha distance plot caDistances = myChain.internal_coord.distance_plot(CaSelect) # display with e.g. MatPlotLib: # import matplotlib.pyplot as plt # plt.imshow(caDistances, cmap="hot", interpolation="nearest") # plt.show() # build structure from distance plot: ## create the all-atom distance plot distances = myChain.internal_coord.distance_plot() ## get the sign of the dihedral angles chirality = myChain.internal_coord.dihedral_signs() ## get new, empty data structure : copy data structure from myChain myChain2 = IC_duplicate(myChain)[0]["A"] cic2 = myChain2.internal_coord ## clear the new atomArray and di/hedra value arrays, just for proof cic2.atomArray = np.zeros((cic2.AAsiz, 4), dtype=np.float64) cic2.dihedraAngle[:] = 0.0 cic2.hedraAngle[:] = 0.0 cic2.hedraL12[:] = 0.0 cic2.hedraL23[:] = 0.0 ## copy just the first N-Ca-C coords so structures will superimpose: cic2.copy_initNCaCs(myChain.internal_coord) ## copy distances to chain arrays: cic2.distplot_to_dh_arrays(distances, chirality) ## compute angles and dihedral angles from distances: cic2.distance_to_internal_coordinates() ## generate XYZ coordinates from internal coordinates: myChain2.internal_to_atom_coordinates() ## confirm result atomArray matches original structure: assert np.allclose(cic2.atomArray, myChain.internal_coord.atomArray) # superimpose all phe-phe pairs - quick hack just to demonstrate concept # for analyzing pairwise residue interactions. Generates PDB ATOM records # placing each PHE at origin and showing all other PHEs in environment ## shorthand for key variables: cic = myChain.internal_coord resNameNdx = AtomKey.fields.resname aaNdx = cic.atomArrayIndex ## select just PHE atoms: pheAtomSelect = [aaNdx.get(k) for k in aaNdx.keys() if k.akl[resNameNdx] == "F"] aaF = cic.atomArray[ pheAtomSelect ] # numpy fancy indexing makes COPY not view for ric in cic.ordered_aa_ic_list: # internal_coords version of get_residues() if ric.rbase[2] == "F": # if PHE, get transform matrices for chi1 dihedral chi1 = ric.pick_angle("N:CA:CB:CG") # chi1 space has C-alpha at origin cst = np.transpose(chi1.cst) # transform TO chi1 space # rcst = np.transpose(chi1.rcst) # transform FROM chi1 space cic.atomArray[pheAtomSelect] = aaF.dot(cst) # transform just the PHEs for res in myChain.get_residues(): # print PHEs in new coordinate space if res.resname in ["PHE"]: print(res.internal_coord.pdb_residue_string()) cic.atomArray[pheAtomSelect] = aaF # restore coordinate space from copy # write OpenSCAD program of spheres and cylinders to 3d print myChain backbone ## set atom load filter to accept backbone only: IC_Residue.accept_atoms = IC_Residue.accept_backbone ## delete existing data to force re-read of all atoms: myChain.internal_coord = None write_SCAD(myChain, "myChain.scad", scale=10.0) See the `''Internal coordinates module''` section of the `Biopython Tutorial and Cookbook` for further discussion. **Terms and key data structures:** Internal coordinates are defined on sequences of atoms which span residues or follow accepted nomenclature along sidechains. To manage these sequences and support Biopython's disorder mechanisms, :class:`AtomKey` specifiers are implemented to capture residue, atom and variant identification in a single object. A :class:`Hedron` object is specified as three sequential AtomKeys, comprising two bond lengths and the bond angle between them. A :class:`Dihedron` consists of four sequential AtomKeys, linking two Hedra with a dihedral angle between them. **Algorithmic overview:** The Internal Coordinates module combines a specification of connected atoms as hedra and dihedra in the :mod:`.ic_data` file with routines here to transform XYZ coordinates of these atom sets between a local coordinate system and the world coordinates supplied in e.g. a PDB or mmCif data file. The local coordinate system places the center atom of a hedron at the origin (0,0,0), one leg on the +Z axis, and the other leg on the XZ plane (see :class:`Hedron`). Measurement and creation or manipulation of hedra and dihedra in the local coordinate space is straightforward, and the calculated transformation matrices enable assembling these subunits into a protein chain starting from supplied (PDB) coordinates for the initial N-Ca-C atoms. Psi and Phi angles are defined on atoms from adjacent residues in a protein chain, see e.g. :meth:`.pick_angle` and :mod:`.ic_data` for the relevant mapping between residues and backbone dihedral angles. Transforms to and from the dihedron local coordinate space described above are accessible via :data:`IC_Chain.dCoordSpace` and :class:`Dihedron` attributes .cst and .rcst, and may be applied in the alignment and comparison of residues and their environments with code along the lines of:: chi1 = ric0.pick_angle("chi1") # chi1 space defined with CA at origin cst = np.transpose(chi1.cst) # transform TO chi1 local space newAtomCoords = oldAtomCoords.dot(cst) The core algorithms were developed independently during 1993-4 for `''Development and Application of a Three-dimensional Description of Amino Acid Environments in Protein,'' Miller, Douthart, and Dunker, Advances in Molecular Bioinformatics, IOS Press, 1994, ISBN 90 5199 172 x, pp. 9-30. `_ A Protein Internal Coordinate (.pic) file format is defined to capture sufficient detail to reproduce a PDB file from chain starting coordinates (first residue N, Ca, C XYZ coordinates) and remaining internal coordinates. These files are used internally to verify that a given structure can be regenerated from its internal coordinates. See :mod:`.PICIO` for reading and writing .pic files and :func:`.structure_rebuild_test` to determine if a specific PDB or mmCif datafile has sufficient information to interconvert between cartesian and internal coordinates. Internal coordinates may also be exported as `OpenSCAD `_ data arrays for generating 3D printed protein models. OpenSCAD software is provided as a starting point and proof-of-concept for generating such models. See :mod:`.SCADIO` and this `Thingiverse project `_ for a more advanced example. Refer to :meth:`.distance_plot` and :meth:`.distance_to_internal_coordinates` for converting structure data to/from 2D distance plots. The following classes comprise the core functionality for processing internal coordinates and are sufficiently related and coupled to place them together in this module: :class:`IC_Chain`: Extends Biopython Chain on .internal_coord attribute. Manages connected sequence of residues and chain breaks; holds numpy arrays for all atom coordinates and bond geometries. For 'parallel' processing IC_Chain methods operate on these arrays with single numpy commands. :class:`IC_Residue`: Extends Biopython Residue on .internal_coord attribute. Access for per residue views on internal coordinates and methods for serial (residue by residue) assembly. :class:`Dihedron`: four joined atoms forming a dihedral angle. Dihedral angle, homogeneous atom coordinates in local coordinate space, references to relevant Hedra and IC_Residue. Getter methods for residue dihedral angles, bond angles and bond lengths. :class:`Hedron`: three joined atoms forming a plane. Contains homogeneous atom coordinates in local coordinate space as well as bond lengths and angle between them. :class:`Edron`: base class for Hedron and Dihedron classes. Tuple of AtomKeys comprising child, string ID, mainchain membership boolean and other routines common for both Hedra and Dihedra. Implements rich comparison. :class:`AtomKey`: keys (dictionary and string) for referencing atom sequences. Capture residue and disorder/occupancy information, provides a no-whitespace key for .pic files, and implements rich comparison. Custom exception classes: :class:`HedronMatchError` and :class:`MissingAtomError` N)deque) namedtuple)Integral)cast)Optional)TextIO) TYPE_CHECKING)Union)protein_letters_3to1)Atom)DisorderedAtom)dihedra_primary_defaults)hedra_defaults)ic_data_backbone)ic_data_sidechain_extras)ic_data_sidechains)primary_angles)residue_atom_bond_state) coord_space)multi_coord_space) multi_rot_Z)Residue)AtomKeyrr)rrrrrrc @seZdZUdZdZ dZ dZ dZej e d< dZ dZ e gdZ e gdZdbd ed dfd d ZdcddZdedededed ef ddZddddd eefddZddZ dbdddeded ed ef d d!Zdbd ed dfd"d#Zddd$d%Zddd&d'Zd(eeefd)eeefd*eeefd+eeefd,eeefd df d-d.Zdbd ed dfd/d0Z  ded ed1ee!d2ee!d dfd3d4Z"dbd ed dfd5d6Z#ddd7d8Z$dfd9eej%d dfd:d;Z&dddd?Z(dbd ed dfd@dAZ)dddBdCZ*e+dDe,dEej d dfdFdGZ-e+dDe,dHdIdJedKe.e/d df dLdMZ0dgdDe,dNed dfdOdPZ1 dfdQee2ej%dfd ej%fdRdSZ3d ej%fdTdUZ4dVej%dWej%d dfdXdYZ5 dhdZee2edfd dfd[d\Z6did^d_Z7d`daZ8dS)jIC_Chaina%Class to extend Biopython Chain with internal coordinate data. Attributes ---------- chain: object reference The Biopython :class:`Bio.PDB.Chain.Chain` object this extends MaxPeptideBond: float **Class** attribute to detect chain breaks. Override for fully contiguous chains with some very long bonds - e.g. for 3D printing (OpenSCAD output) a structure with missing residues. :data:`MaxPeptideBond` ParallelAssembleResidues: bool **Class** attribute affecting internal_to_atom_coords. Short (50 residue and less) chains are faster to assemble without the overhead of creating numpy arrays, and the algorithm is easier to understand and trace processing a single residue at a time. Clearing (set to False) this flag will switch to the serial algorithm ordered_aa_ic_list: list IC_Residue objects internal_coords algorithms can process (e.g. no waters) initNCaC: List of N, Ca, C AtomKey tuples (NCaCKeys). NCaCKeys start chain segments (first residue or after chain break). These 3 atoms define the coordinate space for a contiguous chain segment, as initially specified by PDB or mmCIF file. AAsiz = int AtomArray size, number of atoms in this chain atomArray: numpy array homogeneous atom coords ([x,, y, z, 1.0]) for every atom in chain atomArrayIndex: dict maps AtomKeys to atomArray indexes hedra: dict Hedra forming residues in this chain; indexed by 3-tuples of AtomKeys. hedraLen: int length of hedra dict hedraNdx: dict maps hedra AtomKeys to numeric index into hedra data arrays e.g. hedraL12 below a2ha_map: [hedraLen x 3] atom indexes in hedraNdx order dihedra: dict Dihedra forming residues in this chain; indexed by 4-tuples of AtomKeys. dihedraLen: int length of dihedra dict dihedraNdx: dict maps dihedra AtomKeys to dihedra data arrays e.g. dihedraAngle a2da_map : [dihedraLen x 4] AtomNdx's in dihedraNdx order d2a_map : [dihedraLen x [4]] AtomNdx's for each dihedron (reshaped a2da_map) Numpy arrays for vector processing of chain di/hedra: hedraL12: numpy array bond length between hedron 1st and 2nd atom hedraAngle: numpy array bond angle for each hedron, in degrees hedraL23: numpy array bond length between hedron 2nd and 3rd atom id3_dh_index: dict maps hedron key to list of dihedra starting with hedron, used by assemble and bond_rotate to find dihedra with h1 key id32_dh_index: dict like id3_dh_index, find dihedra from h2 key hAtoms: numpy array homogeneous atom coordinates (3x4) of hedra, central atom at origin hAtomsR: numpy array hAtoms in reverse orientation hAtoms_needs_update: numpy array of bool indicates whether hAtoms represent hedraL12/A/L23 dihedraAngle: numpy array dihedral angles (degrees) for each dihedron dAtoms: numpy array homogeneous atom coordinates (4x4) of dihedra, second atom at origin dAtoms_needs_update: numpy array of bool indicates whether dAtoms represent dihedraAngle dCoordSpace: numpy array forward and reverse transform matrices standardising positions of first hedron. See :data:`dCoordSpace`. dcsValid: bool indicates dCoordSpace up to date See also attributes generated by :meth:`build_edraArrays` for indexing di/hedra data elements. Methods ------- internal_to_atom_coordinates: Process ic data to Residue/Atom coordinates; calls assemble_residues() assemble_residues: Generate IC_Chain atom coords from internal coordinates (parallel) assemble_residues_ser: Generate IC_Residue atom coords from internal coordinates (serial) atom_to_internal_coordinates: Calculate dihedrals, angles, bond lengths (internal coordinates) for Atom data write_SCAD: Write OpenSCAD matrices for internal coordinate data comprising chain; this is a support routine, see :func:`.SCADIO.write_SCAD` to generate OpenSCAD description of a protein chain. distance_plot: Generate 2D plot of interatomic distances with optional filter distance_to_internal_coordinates: Compute internal coordinates from distance plot and array of dihedral angle signs. make_extended: Arbitrarily sets all psi and phi backbone angles to 123 and -104 degrees. gffffff?TrN atomArray)TTTF)TTTTFverbosereturncCsF||_g|_g|_ttj|_i|_i|_ i|_ g|_ | |dS)zInitialize IC_Chain object, with or without residue/Atom data. :param Bio.PDB.Chain parent: Biopython Chain object Chain object this extends N) chainordered_aa_ic_list initNCaCsnpsquarerMaxPeptideBondsqMaxPeptideBondhedradihedraatomArrayIndex bpAtomArray _set_residues)selfparentrr,K/var/www/html/myenv/lib/python3.10/site-packages/Bio/PDB/internal_coords.py__init__szIC_Chain.__init__cs|t|d}|r |St||j|t|<|t|j_t|jj|j_t|jj |j_ t|j |_ t|j |_ t|j |_ |j _ |j_|j_t|j|_t|j|_t|j|_t|j|_|j_dgj_fddfdd}j D]7}||jt|j||_t|j||_t|j||_t|j||_t|j||_t|j||_q|j_t|j|_|j_|j_|j_|j _ t|j!|_!|j"_"|j#_#|j$_$t|j%|_%|j&_&|j'_'|j(_(|j)_)|j*_*|j+_+|j,_,|j-_-|j._.|j/_/|j0_0|j1_1|j2_2|j3_3|j4_4j5D]}j3d|j6|_7j3d|j6|_8qsS) z Implement deepcopy for IC_Chain.FNcs8t|j|}j|}j|ddf|_|j|<dS)Nr)rinternal_coordr'rcoordr(resatmakndx)dupr,r- setAtomVws  z(IC_Chain.__deepcopy__..setAtomVwcs@|D]}|r|jD]}||qq||qdSN) get_atoms is_disordered child_dictvaluesr3r4altAtom)r8r,r- setResAtmVws$s   z+IC_Chain.__deepcopy__..setResAtmVwsr)9getidtype__new__ __class__rcopydeepcopyr< child_listaksetaktuplerr'atomArrayValidrr%r& id3_dh_index id32_dh_indexAAsizr(residuerprevrnextak_setakcr$r hedraLenhedraL12 hedraAnglehedraL23hedraNdx dihedraLen dihedraAngledihedraAngleRads dihedraNdxa2da_mapa2d_mapd2a_mapdH1ndxdH2ndxhAtomshAtomsRhAtoms_needs_updatedRevdFwddAtoms_needs_updatedAtomsa4_pre_rotation dCoordSpacedcsValidr=r6cstrcst)r*memoexistingr@ricdr,)r7r8r- __deepcopy__sx                           zIC_Chain.__deepcopy__a0a1cutoffsqCutoffcCs|tt|j|jkSr9)r!sumr"r1)r*rtrurvrwr,r,r- _atm_dist_chk`szIC_Chain._atm_dist_chkprevrcurrc Csdt|jkr dSdt|jkrdt|jkrdS|jjsdS|jdd}|jdd}|dus5|durDd|dur?ddSddS|jd d}|jdd}|dusZ|dur\d Stjrm|rf|j}|rm|j}tjsx|s|s| ||t j |j }|rdSd t j d Sg}g} |r| |jn|g}|r| |jn|g} |D]} | D]} | | | t j |j rdSqqd t j d S) NrzPIC data missing atomsz1previous residue not standard/accepted amino acidNCzmissing z previous Cz atomCAz previous residue missing N or CazMaxPeptideBond (z angstroms) exceeded)lenr<r0isAcceptrB IC_Residue no_altlocr;selected_childryrr#r$extendr=) r*rzr{NatompCatompCAatompNatomdcNlistpClistncr,r,r-_peptide_checkds^  zIC_Chain._peptide_checkcCs|jD]}d|_qdS)z5Clear residue internal_coord settings for this chain.N)r get_residuesr0)r*r3r,r,r-clear_icszIC_Chain.clear_icr3last_res last_ord_resc st_|j_j}dt|kr5||kr5||djdur5|D]}|jj|j|q#dSt fdddDr|rlt|dkrl||krTd| }n t t ||dj}t d| d ||t|d t|d t|d f}|j|dSd S)a.Set rprev, rnext, manage chain break. Returns True for no chain break or residue has sufficient data to restart at this position after a chain break (sets initNCaC AtomKeys in this case). False return means insufficient data to extend chain with this residue. rNTc3|]}|jvVqdSr9)r<.0r4r3r,r- z(IC_Chain._add_residue..r|r~r}zdisordered residues after zchain break at z due to r|r~r}F)rr0cicrrrPrRappendrQall pretty_strrstrprint split_aklrr r) r*r3rrrrqrzreasoniNCaCr,rr- _add_residues0   zIC_Chain._add_residuecCsg}g}t}|jD]_}|jddks|jdtjvrkg}d|krFtjsF|j D]}| ||||rD| |j | |j jq-n| ||||r[| |j | |j jdt|kri|j||}|}q ||_t|j|_dS)aInitialize .internal_coord for loaded Biopython Residue objects. Add IC_Residue as .internal_coord attribute for each :class:`.Residue` in parent :class:`Bio.PDB.Chain.Chain`; populate ordered_aa_ic_list with :class:`IC_Residue` references for residues which can be built (amino acids and some hetatms); set rprev and rnext on each sequential IC_Residue, populate initNCaC at start and after chain breaks. Generates: self.akset : set of :class:`.AtomKey` s in this chain r N)setrrrCraccept_resnamesr;rr<r=rrr0updaterSrrrrJsortedr )r*rrrrJr3this_resrr,r,r-r)s.     zIC_Chain._set_residuescsfddfdd}tj_ttj_ttjtj_ t j jt d_ t j jdft jd_djddd f<dgj_jD]}||j|jikr^|qNdS) aBuild :class:`IC_Chain` numpy coordinate array from biopython atoms. See also :meth:`.init_edra` for more complete initialization of IC_Chain. Inputs: self.akset : set :class:`AtomKey` s in this chain Generates: self.AAsiz : int number of atoms in chain (len(akset)) self.aktuple : AAsiz x AtomKeys sorted akset AtomKeys self.atomArrayIndex : [AAsiz] of int numerical index for each AtomKey in aktuple self.atomArrayValid : AAsiz x bool atomArray coordinates current with internal coordinates if True self.atomArray : AAsiz x np.float64[4] homogeneous atom coordinates; Biopython :class:`.Atom` coordinates are view into this array after execution rak_cache : dict lookup cache for AtomKeys for each residue cspt|j|}zj|}Wn tyYdSw|jj|ddf<j|ddf|_dj|<|j|<dS)Nrr/T)rr0r'KeyErrorr1rrLr(r2r*r,r-setAtoms   z)IC_Chain.build_atomArray..setAtomcsT|D]#}|r"tjr||jq|jD]}||qq||qdSr9)r:r;rrrr<r=r>)rr,r- setResAtms(s   z,IC_Chain.build_atomArray..setResAtmsdtype?Nr/)rrJrOtuplerrKdictzipranger'r!zerosboolrLfloat64rr(rrPrT_build_rak_cache)r*rrqr,)r*rr-build_atomArrays     zIC_Chain.build_atomArrayc Cstjd|jddftjd|_tj|jtd|_tj|jddftjd|_ d|j dddddf<t |j |_ t |jd|_ i}dd t|jD|_d d t|jD}|jD]?\}}|d}tdD]}|j||}||||<qg||j|_|j|jD]}|j|} ||| |j| |qq[tt||_t||_tj|jddftjd|_d|jdddddf<t|jdf|_i} d d t|jD} tj|jtd|_tj|jtj d|_!tj|jtj d|_"d d t|jD|_#d d|j$%D|_&dd|j$%D|_'|j$D]\} } | d}| dd}| dd}|j(| }tdD]"}|j| |}|| ||<| |d| | |d|q9z||_)||_*|j|j)}Wn(t+y| ddd|_)| ddd|_*|j|j)}d|j| <d|_,Ynw|j|j*}|j|j)|_-|j|j*|_.||j!| <||j"| <|j#|| | |_|jd| |_/|jd| |_0|j&|| |j'|| qtt| |_1|j12dd|_3|jdk|_4dd | D|_5t |jd|_6dS)aG Build chain level hedra and dihedra arrays. Used by :meth:`init_edra` and :meth:`_hedraDict2chain`. Should be private method but exposed for documentation. Inputs: self.dihedraLen : int number of dihedra needed self.hedraLen : int number of hedra needed self.AAsiz : int length of atomArray self.hedraNdx : dict maps hedron keys to range(hedraLen) self.dihedraNdx : dict maps dihedron keys to range(dihedraLen) self.hedra : dict maps Hedra keys to Hedra for chain self.atomArray : AAsiz x np.float64[4] homogeneous atom coordinates for chain self.atomArrayIndex : dict maps AtomKeys to atomArray self.atomArrayValid : AAsiz x bool indicates coord is up-to-date Generates: self.dCoordSpace : [2][dihedraLen][4][4] transforms to/from dihedron coordinate space self.dcsValid : dihedraLen x bool indicates dCoordSpace is current self.hAtoms : hedraLen x 3 x np.float64[4] atom coordinates in hCoordSpace self.hAtomsR : hedraLen x 3 x np.float64[4] hAtoms in reverse order (trading space for time) self.hAtoms_needs_update : hedraLen x bool indicates hAtoms, hAtoms current self.a2h_map : AAsiz x [int ...] maps atomArrayIndex to hedraNdx's with that atom self.a2ha_map : [hedraLen x 3] AtomNdx's in hedraNdx order self.h2aa : hedraLen x [int ...] maps hedraNdx to atomNdx's in hedron (reshaped later) Hedron.ndx : int self.hedraNdx value stored inside Hedron object self.dRev : dihedraLen x bool dihedron reversed if true self.dH1ndx, dH2ndx : [dihedraLen] hedraNdx's for 1st and 2nd hedra self.h1d_map : hedraLen x [] hedraNdx -> [dihedra using hedron] Dihedron.h1key, h2key : [AtomKey ...] hedron keys for dihedron, reversed as needed Dihedron.hedron1, hedron2 : Hedron references inside dihedron to hedra Dihedron.ndx : int self.dihedraNdx info inside Dihedron object Dihedron.cst, rcst : np.float64p4][4] dCoordSpace references inside Dihedron self.a2da_map : [dihedraLen x 4] AtomNdx's in dihedraNdx order self.d2a_map : [dihedraLen x [4]] AtomNdx's for each dihedron (reshaped a2da_map) self.dFwd : bool dihedron is not Reversed if True self.a2d_map : AAsiz x [[dihedraNdx] [atom ndx 0-3 of atom in dihedron]], maps atom indexes to dihedra and atoms in them self.dAtoms_needs_update : dihedraLen x bool atoms in h1, h2 are current if False rrrr/rNTcSg|]}gqSr,r,r_r,r,r- z-IC_Chain.build_edraArrays..cSrr,r,rr,r,r-rrcSsg|]}gggqSr,r,rr,r,r-rcSrr,r,rr,r,r-rrcSi|] }|ddgqS)rr/r,rkr,r,r- z-IC_Chain.build_edraArrays..cSr)rArr,rr,r,r-rrrrAcSs(g|]}t|dt|dfqSrrA)r!array)rxir,r,r-rs()7r!emptyrZrrkrrrlrUrcrGrdfullrerrOa2h_maprYitemsr'r%r6atomkeysrrrr=a2ha_maph2aarirjrfint64rarbh1d_mapr]keysrMrNr&h1keyh2keyrreversehedron1hedron2rmrnr^reshaper`rgr_rh)r*rrhkhndxhstepir6r5akndxr^r_dkdndxdstepdid3did32rrh1ndxh2ndxr,r,r-build_edraArraysBsI                zIC_Chain.build_edraArrayshl12hahl23dabfacsc Cs|jD]j}g}|jD]8}d|kr7tjr!|t||jq |j D]} | j dur5|t|| q&q |j durD|t||q |gkrQ|j t |g|_|j|t|dt|dt|df|q|j gkr|jd}|t|dt|dt|df} |j | |t|j |_ tj\} } } }}}d}|jD]\}}|jj}|j||j|}}|j|durdnt|j|}||jd}|dur|d n|d }d}||r||}|dusd|kr?||s?t||j|dd |||durd n||||d}|dur9|dur&| |qt!|}| ||"||#q|"|qd|krQ||rQ|$||%||&||'}qt(||_)t*j+| t*j,d |_-t*j+| t*j,d |_.t*j+| t*j,d |_/t0t1t|2t3|j)|_4t(||_5t*j+| t*j,d |_6t*7|j6|_8t0t1t|2t3|j5|_9|:dS) aGenerate chain numpy arrays from :func:`.read_PIC` dicts. On entry: * chain internal_coord has ordered_aa_ic_list built, akset; * residues have rnext, rprev, ak_set and di/hedra dicts initialised * Chain, residues do NOT have NCaC info, id3_dh_index * Di/hedra have cic, atomkeys set * Dihedra do NOT have valid reverse flag, h1/2 info rNr|r~r}rrrAr/rr);rrPr:r;rrrrrr<r=r1r rNCaCKeyrr _link_dihedrarrfieldsr'rrqaklfloatrBrChas_iddisordered_has_idr raddr disordered_addflag_disordereddisordered_select set_bfactor set_occupancyget_serial_numberrrUr!fromiterrrVrWrXrrrrrYrZr[deg2radr\r]r)r*rrrrrrqinitNCaCr4r?rspNdxicNdxresnNdxatmNdx altlocNdxoccNdxsnr5r6r3altlococcbfacbpAtmnewAtomdisordered_atomr,r,r-_hedraDict2chains                        zIC_Chain._hedraDict2chainc Cs|j}|j}|j}|j}|j}|j}|jd}|j} ||ddd|_ |j } ||dd|_ |j } | |j kj dd} d|jt | <d} |rO| j| } tj}| |kj dd} d}t | rt | }| | }||dfd}t | | r~|| }n t|t | d d}|| ddd}t d ||dddf||<d ||<d| dd<|D]#}||| ||<||}|dD]}|||}||k | |<qq|d7}t | sa|r|jj}t|dd |d d | d|ddSdS)a7Generate atom coords from internal coords (vectorised). This is the 'Numpy parallel' version of :meth:`.assemble_residues_ser`. Starting with dihedra already formed by :meth:`.init_atom_coords`, transform each from dihedron local coordinate space into protein chain coordinate space. Iterate until all dependencies satisfied. Does not update :data:`dCoordSpace` as :meth:`assemble_residues_ser` does. Call :meth:`.update_dCoordSpace` if needed. Faster to do in single operation once all atom coordinates finished. :param bool verbose: default False. Report number of iterations to compute changed dihedra generates: self.dSet: AAsiz x dihedraLen x 4 maps atoms in dihedra to atomArray self.dSetValid : [dihedraLen][4] of bool map of valid atoms into dihedra to detect 3 or 4 atoms valid Output coordinates written to :data:`atomArray`. Biopython :class:`Bio.PDB.Atom` coordinates are a view on this data. rArraxisFNrr/Tz ijk,ik->ijrrz coordinates for z dihedra updated in z iterations)r^r_r`rrLrirkrlrdSet dSetValid _dihedraOKrr! logical_notsizerxr_dihedraSelectanywherereinsumrfull_idr)r*rr^r_r`rrLri dCoordSpace1rlrr workSelector dihedraWrktarg loopCountworkNdxsworkSet updateMapcspace initCoordsaadlistrrdvalidcidr,r,r-assemble_residuescs`        "zIC_Chain.assemble_residuesstartfincCsd|jdd<|jD]4}|r||jjdks |r/||jjdkr/d|_d|_i|j_g|j_q |j|d}|r>t | |_q dS)aGenerate IC_Residue atom coords from internal coordinates (serial). See :meth:`.assemble_residues` for 'numpy parallel' version. Filter positions between start and fin if set, find appropriate start coordinates for each residue and pass to :meth:`.assemble` :param bool verbose: default False. Describe runtime problems :param int start,fin: default None. Sequence position for begin, end of subregion to generate coords for. FNrAr) rlrrPrCrSrTr<rIassemblerr)r*rr)r*rq atom_coordsr,r,r-assemble_residues_sers   zIC_Chain.assemble_residues_sercCs|jdjikr|jD]}|j|dq t|ds|t|ds|t|j|_tj|jtj d|_ tj|jtj d|_ tj|jtj d|_ t tt|jtt|j|_t|j|_t|j|_t|j|_t tt|jt|j|_t|ds|dSdS)aCreate chain and residue di/hedra structures, arrays, atomArray. Inputs: self.ordered_aa_ic_list : list of IC_Residue Generates: * edra objects, self.di/hedra (executes :meth:`._create_edra`) * atomArray and support (executes :meth:`.build_atomArray`) * self.hedraLen : number of hedra in structure * hedraL12 : numpy arrays for lengths, angles (empty) * hedraAngle .. * hedraL23 .. * self.hedraNdx : dict mapping hedrakeys to hedraL12 etc * self.dihedraLen : number of dihedra in structure * dihedraAngle .. * dihedraAngleRads : np arrays for angles (empty) * self.dihedraNdx : dict mapping dihedrakeys to dihedraAngle rr+rLrUrreN)rr% _create_edrahasattrrrrUr!rrrVrWrXrrrrrrYr&rZr[r\r]r)r*rrqr,r,r- init_edras(    $   zIC_Chain.init_edracstjs"jjjjjBO_jtjM_jj@}j j@}jj}j j} t jrqt dj j}t |}t|d} jjjddddfj<|jjjddddfj<|jjjddddfj< jjjddddfj<|jjjddddfj<|jjjddddfj< djd<tj}jjdf|j|<jjdf|j|<tjdddfjdjdddfj<t|} jj|| |<jj|| |<tjdddfj| jdddfj< jj} jj} | |jddddf|<| dddddf|jddddf|< tjj} t| jjdddd d dd } | |jdddf|<| |jdddf|< djd< jD]=}d }tjfd d |Drd}|rjj|}t dD]}j!||}||j"|<d j|<qڐqdS)aSet chain level di/hedra initial coords from angles and distances. Initializes atom coordinates in local coordinate space for hedra and dihedra, will be transformed appropriately later by :data:`dCoordSpace` matrices for assembly. f@rNrrF.r/rrATcg|]}j|qSr,r'rr5rr,r-rz-IC_Chain.init_atom_coords..)#r!rrhrerarbrlrrgrfrrrWsincosrXrcrVrdrxrjmultiplyrrrirr\matmulrr rLrYrr'r)r*mdFwdmdRevudFwdudRevsarsinSarcosSarNdhlena4shiftdH1atoms dH1atomsRrza4rotrinvalidhatomsrandxr,rr-init_atom_coords"s            0    zIC_Chain.init_atom_coordsrcCsT|dur|t|j}|j|}t|t|d|jdd|f<d|j|<dS)a(Compute/update coordinate space transforms for chain dihedra. Requires all atoms updated so calls :meth:`.assemble_residues` (returns immediately if all atoms already assembled). :param [bool] workSelector: Optional mask to select dihedra for update NT)r(r!rrlrrrxrk)r*rr r,r,r-update_dCoordSpaces    zIC_Chain.update_dCoordSpacecCs(d}t|j}tjj}tjj}t}||kr|j|d}|j|}|d}||kr.|j} n |j|d} |j| } t || D]H} |j | s|j | } | j |} | j |}| dvrbd|j | | <n&||vr| dkrt | | D]}|j |j ||krd|j |<qo| |q?|d7}||ksdSdS)z5Track through di/hedra to invalidate dependent atoms.rrArFHN)rr rrr4resposrr'rOrrLrKrr)r*csNdxcsLenrposNdxdonestartAKcsStartcsnTrycsNextfinAKrJr5r4posrr,r,r-propagate_changess<         zIC_Chain.propagate_changesc Cs$t|dsdStjr\|s\|s\|||j|d|rVt|jsX|j|j  dd}|j D](}|j D]}||jsTtd|jjjd|d|jq8q1dSdSdS|r|j D]"}||jjd krlqa|t|d t|d t|d f}|j|qa||j|||d dS)aProcess IC data to Residue/Atom coords. :param bool verbose: default False. Describe runtime problems :param int start,fin: Optional sequence positions for begin, end of subregion to process. .. note:: Setting start or fin activates serial :meth:`.assemble_residues_ser` instead of (Numpy parallel) :meth:`.assemble_residues`. Start C-alpha will be at origin. .. seealso:: :data:`ParallelAssembleResidues` rhNr+rrzmissing coordinates for chain rz dihedral: rAr|r~r})rr)r*)r0rParallelAssembleResiduesrYrKr(r!rrLr^rrr&r=r6rrrrCrrPrrr rr.)r*rr)r*rrqrrrr,r,r-internal_to_atom_coordinatessN      z%IC_Chain.internal_to_atom_coordinatescCs|jgkrdS|j|d|jikrdS|j|jddd}tjj|dddf|dddfdd|_ tjj|dddf|ddd fdd|_ tjj|dddf|ddd fdd}tj t t |j t |j t |d |j |j |jd |j|jddd}t||jd |jd <d |jdd<t|jd|dddfddddd}tj|dddf|dddf|jd tj |j|jd t|d r|dSdS)alCalculate dihedrals, angles, bond lengths for Atom data. Generates atomArray (through init_edra), value arrays for hedra and dihedra, and coordinate space transforms for dihedra. Generates Gly C-beta if specified, see :data:`IC_Residue.gly_Cbeta` :param bool verbose: default False. describe runtime problems Nr+rr/rrrArroutT.gcb)rr1r&rrrr!linalgnormrVrXrad2degarccosr"rWr^rrZrkrlr:arctan2r\r[r0 _spec_glyCB)r*rrh_a0a2dhado4r,r,r-atom_to_internal_coordinatesVs<   ..,   0*  z%IC_Chain.atom_to_internal_coordinatescCs:d}t|dr ||j9}|jD]}|d}d|j|j|<|j}|d|d|d|df\}}}}|j|} | j } | j j } ||j | <d |j | <|j |j |||f|j| <d |j| j j <| j jD] } d|j|j| <qg|j||||fd } | rd |j| j }|d kr|n|d|j| <qd|j| <qd S)zPopulate values for Gly C-beta.gb?scaler/Fr|r~r}OguT5[@TNg!>^@r2v@x)r0rir^r=rLr'rqrakr&r6rrVrWrYrXrerrBr[)r* Ca_Cb_LengcbdcbakrqrNrCArCrOgCBdrrr5refvalanglr,r,r-rds6       zIC_Chain._spec_glyCBfpmtxcCs|dd}|D]2}|r|dn|dd}d}|D]}|r,|dt|q|t|d}q|dq |ddS)N[ Fz, [ T,  ])writer)rxry rowsStartedrow colsStartedcolr,r,r- _write_mtxs    zIC_Chain._write_mtxrrDihedronrYhedraSetc Cs|d|jdd||jd||jd|jrdndd ||j|vr(dndd|j|vr2dndd|d|j|jj|jj|jrIdnd|d t ||j |d dS) Nrz9.5fr{rArz // {} [ {} -- {} ] {} reversedz r|) r}anglerrrformatrCrrrrrn)rxrrrYrr,r,r-_writeSCAD_diheds&6  zIC_Chain._writeSCAD_dihed backboneOnlyc, s|djjdi}jD]*}|jjd}|dur#||dkr#q|dur,||kr,q|jD]\}} | ||<q1qt} i} t} d} i}t|D] }| ||<| d7} qK|di}i}d} d}jD]}|jjd}|durw||krwqf|dur||krqfd|j vr|j d kr|j d krt d |d |j d | ||<|r|dnd}|dt | dt |jjd |j d| d7} | |jddd}d}t|rdndD]}|dkr|rdnd}||d|jjd |j dd}t|jD]b\}}|j|vrb|dkr|s|dkrb|sb|jj|jrU|r0|dnd}|dt|||| |||<| |j| |j|d7}qt d|jd|jdqqqf|d|d|d t|D]}||}|d!|t|jd"d#t|jd"d#t|jd"d}d}d}|j D]}|j!t"j#j$}|j!t"j#j%}t&d$} | '|d}!d%|dkrd&}!|!durt&'|d} | dur| '|d}!nd}!|d'|!d(7}|| vr|d)7}ng|| vrXt(|d*st(|d+r$|dkr$|dkr|d)7}nG|dkr#|d,7}| |n8t(|d-s0t(|d.rN|dkrN|dkr?|d)7}n|dkrM|d,7}| |n|d,7}| |n|d)7}|d7}q||||g}"|")|j djd|j dj|")|j djd|j djd}#|"D]z}$d}%|$| vr| |$d/krd)}%n_|| vrd/}&|#rt(|d*rd0}&n5t(|d+rd1}&n,t(|d2rd3}&n#t(|d4rd5}&nt(|d-rd0}&nt(|d.rd1}&nt(|d6rd5}&|$| vrd/| |$<n|&| |$<d#t |&}%nd)}%||%d}#q|j dj!}'|d'|'t"j#j%d7|'t"j#j*d'|j+d(|d8t |d9qy|d:dj,dd<-|d;d}jD]}|jjd}|durj||krjqV|durv||krvqV|jD] \}} | ||<q{t|j.D]g}(d})dt/|j0krfdt2j4d?})|r|dnd}|d!t ||d't |jjd||j d@t |(d9t5||)|dAqqV|dBdS)CzWrite self to file fp as OpenSCAD data matrices. See `OpenSCAD `_. Works with :func:`.write_SCAD` and embedded OpenSCAD routines therein. z "z", // chain id rANrz! [ // residue array of dihedraFrjGAz*Unable to generate complete sidechain for rz missing O atomz ],Tz [ // z : z backbone ) resetLocationr,rz // z sidechain z, z zAtom missing for -z%, OpenSCAD chain may be discontiguousz ],z ], z [ //hedra z [ rr{XrMHsbz, ""z, 0 flex_female_1 flex_male_1z, 1 flex_female_2 flex_male_2StdBondFemaleJoinBond MaleJoinBondskinny_1 SkinnyBondhbond_1HBondhbond_2z", z ], //  z ], z0 [ // chain - world transform for each residue csg|] }jj|qSr,)rr'r5rr,r-rsz(IC_Chain._write_SCAD..rrz", //r|z ] )6r}rrCrrPr%rrrrTlcrrclear_transformsr,rr&r is_backbonerrlr6rrrrid3id32set_accuracy_95len12rlen23rrrrr4resnamerrBr0rrNe_classrLr[rrrQrr!identityrr),r*rxrr)r*r%rqrNrhatomSetbondDictrr6rYrresNdxr] chnStartedndx2startedrcmarrrhedatom_str atom_done_strrr5r4r3 ab_state_resab_statebondb0bwstrbondTyperrmtraclmtr,rr- _write_SCADs               (         *                      ""                     * zIC_Chain._write_SCADfiltercCsR|dur|j}n|j|}tjj|dddddf|dddddfddS)aGenerate 2D distance plot from atomArray. Default is to calculate distances for all atoms. To generate the classic C-alpha distance plot, pass a boolean mask array like:: atmNameNdx = internal_coords.AtomKey.fields.atm CaSelect = [ atomArrayIndex.get(k) for k in atomArrayIndex.keys() if k.akl[atmNameNdx] == "CA" ] plot = cic.distance_plot(CaSelect) Alternatively, this will select all backbone atoms:: backboneSelect = [ atomArrayIndex.get(k) for k in atomArrayIndex.keys() if k.is_backbone() ] :param [bool] filter: restrict atoms for calculation .. seealso:: :meth:`.distance_to_internal_coordinates`, which requires the default all atom distance plot. Nrr)rr!r_r`)r*rrr,r,r- distance_plots 8zIC_Chain.distance_plotcCs t|jS)zGet sign array (+1/-1) for each element of chain dihedraAngle array. Required for :meth:`.distance_to_internal_coordinates` )r!signr[rr,r,r-dihedral_signss zIC_Chain.dihedral_signsdistplot dihedra_signscCs|jdd}||dddf|dddff|_||dddf|dddff|_||dddf|dddff|_|j}||dddf|dddff|_||_dS)aLoad di/hedra distance arrays from distplot. Fill :class:`IC_Chain` arrays hedraL12, L23, L13 and dihedraL14 distance value arrays from input distplot, dihedra_signs array from input dihedra_signs. Distplot and di/hedra distance arrays must index according to AtomKey mappings in :class:`IC_Chain` .hedraNdx and .dihedraNdx (created in :meth:`IC_Chain.init_edra`) Call :meth:`atom_to_internal_coordinates` (or at least :meth:`init_edra`) to generate a2ha_map and d2a_map before running this. Explicitly removed from :meth:`.distance_to_internal_coordinates` so user may populate these chain di/hedra arrays by other methods. rr/NrrAr)rrrVrXhedraL13r` dihedraL14r)r*rrrrr,r,r-distplot_to_dh_arrayss&&&& zIC_Chain.distplot_to_dh_arrays resetAtomscCs|j|j}|j|j|j||j<|j|j}|j|j|j||j<|j|j}|j|j|j||j<|j|j}|j|j}|j}|||d}|||d} |||||||} | | || || |} d||||t||||||||d} t | } t | }| | | d| |}d||dk<d||dk<tj ||j tj d|j |j 9_ tj|j |jdtjt t|jt|jt|jd|j|j|jd|r d|jd d <d |jd d <d |jd d <d Sd S) aCompute chain di/hedra from from distance and chirality data. Distance properties on hedra L12, L23, L13 and dihedra L14 configured by :meth:`.distplot_to_dh_arrays` or alternative loader. dihedraAngles result is multiplied by dihedra_signs at final step recover chirality information lost in distance plot (mirror image of structure has same distances but opposite sign dihedral angles). Note that chain breaks will cause errors in rebuilt structure, use :meth:`.copy_initNCaCs` to avoid this Based on Blue, the Hedronometer's answer to `The dihedral angles of a tetrahedron in terms of its edge lengths `_ on `math.stackexchange.com `_. See also: `"Heron-like Hedronometric Results for Tetrahedral Volume" `_. Other values from that analysis included here as comments for completeness: * oa = hedron1 L12 if reverse else hedron1 L23 * ob = hedron1 L23 if reverse else hedron1 L12 * ac = hedron2 L12 if reverse else hedron2 L23 * ab = hedron1 L13 = law of cosines on OA, OB (hedron1 L12, L23) * oc = hedron2 L13 = law of cosines on OA, AC (hedron2 L12, L23) * bc = dihedron L14 target is OA, the dihedral angle along edge oa. :param bool resetAtoms: default True. Mark all atoms in di/hedra and atomArray for updating by :meth:`.internal_to_atom_coordinates`. Alternatively set this to False and manipulate `atomArrayValid`, `dAtoms_needs_update` and `hAtoms_needs_update` directly to reduce computation. rrgr)r]rr\FNT)rVrarXrgrbrrr!r"sqrtrbr\ longdoublerrar[rWrLrhre)r*roaobacabocbcYsZsYsqrZsqrHsqrYZcosOAr,r,r- distance_to_internal_coordinatessT '    8      z)IC_Chain.distance_to_internal_coordinatesothercs2fdd|jD}|j|j|<dj|<dS)aFCopy atom coordinates for initNCaC atoms from other IC_Chain. Copies the coordinates and sets atomArrayValid flags True for initial NCaC and after any chain breaks. Needed for :meth:`.distance_to_internal_coordinates` if target has chain breaks (otherwise each fragment will start at origin). Also useful if copying internal coordinates from another chain. N.B. :meth:`IC_Residue.set_angle()` and :meth:`IC_Residue.set_length()` invalidate their relevant atoms, so apply them before calling this function. c g|] }|D]}j|qqSr,r4)rrr5rr,r-r z+IC_Chain.copy_initNCaCs..TN)r rrL)r*rr6r,rr-copy_initNCaCsszIC_Chain.copy_initNCaCscCs(|jD]}|dd|ddqdS)z@Set all psi and phi angles to extended conformation (123, -104).psi{phiiN)r set_angle)r*rqr,r,r- make_extendeds  zIC_Chain.make_extendedF)rrrN)FNNr9NNT)rrrN)9__name__ __module__ __qualname____doc__r#rZrOrr!r__annotations__rkrlrrrr.rsr rryrrrrlistrr)rrrr r(intr.r1rKndarrayrLrYr[rhrd staticmethodrrrEKTrrr rrrrrrr,r,r,r-r8s   e?  1 * ?'      {l $ 1- 1 F 5$ } (  t rc@seZdZUdZdZ dZeed< dZeed< dZ eed< dZ e ed<d Z d Z e e Zd Zd ZeeZ dddZddZdddefddZdee efddfddZdddZdeddfddZde fd d!Zde fd"d#Zdd$eddfd%d&Zdd'd(Zdd)d*Zdede j!ffd+d,Z"dede j!ffd-d.Z#d/d0Z$  dd1ed$edeede j!fee%e j!fdffd2d3Z& dd4ee'd5e(dfd6ede(e'd5fd7d8Z)d4ee'd5e(dfddfd9d:Z*dd$eddfd;d<Z+dZ,dZ-e.dded=ede fd>d?Z/de fd@dAZ0e.dBdde fdCdDZ1e2dEgdFZ3dGdHe4dIDZ5e5dJe5dKBe5dLBe5dMBe5dNBZ6e5dOe5dPBe5dQBe5dRBZ7e7e6BZ8e5dSe5dTBe5dUBZ9e3e5dOe5dVe5dPe5dQe5dJe5dKe5dLe5dMe5dNe5dRe6e7e8e5dSe5dTe5dUe9e5dWe5dXZ: e:j;e:j e:?Z@ dedYe dZeAde'e eAffd[d\ZBd]d^e>ddfd_e d`e daeAdbeCeeDdfdceCeeDdfde f dddeZEdfe deCe'd5fdgdhZFeGHdiZIdjeJdeCedkfdldmZKdjeeJe fdeCedkfdndoZLdjeeJe fdeCeDfdpdqZMddjeeJe fdseDfdtduZNdvdwdxeDfdydzZOdjeeJe fdxeDfd{d|ZPdjeeJe fd}eDfd~dZQdee eRfde'eCe(deCeRffddZSdee eRfdeCeDfddZTdee eRfd}eDddfddZUde j!ddfddZVdS)raHClass to extend Biopython Residue with internal coordinate data. Parameters ---------- parent: biopython Residue object this class extends Attributes ---------- no_altloc: bool default False **Class** variable, disable processing of ALTLOC atoms if True, use only selected atoms. accept_atoms: tuple **Class** variable :data:`accept_atoms`, list of PDB atom names to use when generating internal coordinates. Default is:: accept_atoms = accept_mainchain + accept_hydrogens to exclude hydrogens in internal coordinates and generated PDB files, override as:: IC_Residue.accept_atoms = IC_Residue.accept_mainchain to get only mainchain atoms plus amide proton, use:: IC_Residue.accept_atoms = IC_Residue.accept_mainchain + ('H',) to convert D atoms to H, set :data:`AtomKey.d2h` = True and use:: IC_Residue.accept_atoms = ( accept_mainchain + accept_hydrogens + accept_deuteriums ) Note that `accept_mainchain = accept_backbone + accept_sidechain`. Thus to generate sequence-agnostic conformational data for e.g. structure alignment in dihedral angle space, use:: IC_Residue.accept_atoms = accept_backbone or set gly_Cbeta = True and use:: IC_Residue.accept_atoms = accept_backbone + ('CB',) Changing accept_atoms will cause the default `structure_rebuild_test` in :mod:`.ic_rebuild` to fail if some atoms are filtered (obviously). Use the `quick=True` option to test only the coordinates of filtered atoms to avoid this. There is currently no option to output internal coordinates with D instead of H. accept_resnames: tuple **Class** variable :data:`accept_resnames`, list of 3-letter residue names for HETATMs to accept when generating internal coordinates from atoms. HETATM sidechain will be ignored, but normal backbone atoms (N, CA, C, O, CB) will be included. Currently only CYG, YCM and UNK; override at your own risk. To generate sidechain, add appropriate entries to `ic_data_sidechains` in :mod:`.ic_data` and support in :meth:`IC_Chain.atom_to_internal_coordinates`. gly_Cbeta: bool default False **Class** variable :data:`gly_Cbeta`, override to True to generate internal coordinates for glycine CB atoms in :meth:`IC_Chain.atom_to_internal_coordinates` :: IC_Residue.gly_Cbeta = True pic_accuracy: str default "17.13f" **Class** variable :data:`pic_accuracy` sets accuracy for numeric values (angles, lengths) in .pic files. Default set high to support mmCIF file accuracy in rebuild tests. If you find rebuild tests fail with 'ERROR -COORDINATES-' and verbose=True shows only small discrepancies, try raising this value (or lower it to 9.5 if only working with PDB format files). :: IC_Residue.pic_accuracy = "9.5f" residue: Biopython Residue object reference The :class:`.Residue` object this extends hedra: dict indexed by 3-tuples of AtomKeys Hedra forming this residue dihedra: dict indexed by 4-tuples of AtomKeys Dihedra forming (overlapping) this residue rprev, rnext: lists of IC_Residue objects References to adjacent (bonded, not missing, possibly disordered) residues in chain atom_coords: AtomKey indexed dict of numpy [4] arrays **removed** Use AtomKeys and atomArrayIndex to build if needed ak_set: set of AtomKeys in dihedra AtomKeys in all dihedra overlapping this residue (see __contains__()) alt_ids: list of char AltLoc IDs from PDB file bfactors: dict AtomKey indexed B-factors as read from PDB file NCaCKey: List of tuples of AtomKeys List of tuples of N, Ca, C backbone atom AtomKeys; usually only 1 but more if backbone altlocs. is20AA: bool True if residue is one of 20 standard amino acids, based on Residue resname isAccept: bool True if is20AA or in accept_resnames below rbase: tuple residue position, insert code or none, resname (1 letter if standard amino acid) cic: IC_Chain default None parent chain :class:`IC_Chain` object scale: optional float used for OpenSCAD output to generate gly_Cbeta bond length Methods ------- assemble(atomCoordsIn, resetLocation, verbose) Compute atom coordinates for this residue from internal coordinates get_angle() Return angle for passed key get_length() Return bond length for specified pair pick_angle() Find Hedron or Dihedron for passed key pick_length() Find hedra for passed AtomKey pair set_angle() Set angle for passed key (no position updates) set_length() Set bond length in all relevant hedra for specified pair bond_rotate(delta) adjusts related dihedra angles by delta, e.g. rotating psi (N-Ca-C-N) will adjust the adjacent N-Ca-C-O by the same amount to avoid clashes bond_set(angle) uses bond_rotate to set specified dihedral to angle and adjust related dihedra accordingly rak(atom info) cached AtomKeys for this residue )CYGYCMUNKF _AllBondsr gly_Cbetaz17.13f pic_accuracy)r|r~r}rjOXT) CBCGCG1OG1OGSGCG2CDCD1SDOD1ND1CD2ND2CECE1NEOE1NE1CE2OE2NE2CE3CZNZCZ2CZ3OD2OHCH2NH1NH2)1rMH1H2H3HAHA2HA3HBHB1HB2HB3HG2HG3HD2HD3HE2HE3HZ1HZ2HZ3HG11HG12HG13HG21HG22HG23HZHD1HE1HD11HD12HD13HGHG1HD21HD22HD23rrHEHH11HH12HH21HH22HE21HE22r*HHHH2)1DD1D2D3DADA2DA3DBDB1DB2DB3DG2DG3DD2DD3DE2DE3DZ1DZ2DZ3DG11DG12DG13DG21DG22DG23DZDD1DE1DD11DD12DD13DGDG1DD21DD22DD23rr DEDH11DH12DH21DH22DE21DE22rXDHDH2r+rrNcCsD||_|i|_i|_i|_t|_g|_g|_i|_t j r dng|_ d|_ d|_ |j}|dd|dkr9|dnd|jg}z t|d|d<Wnty^d|_ |d|jvr\d|_ Ynwt||_|d|_|j r|D]$}t|drt j r||jqp|jD]}||qqp||qp|jr|dSdSdS)zInitialize IC_Residue with parent Biopython Residue. :param Residue parent: Biopython Residue object. The Biopython Residue this object extends NTrArrFr<)rPr%r&rTrrSrQrRbfactorsrralt_idsis20AArrCrr rrrrbaserr:r0 _add_atomrr<r=r)r*r+ridrzatomr4r,r,r-r. sJ$         zIC_Residue.__init__cCsf|t|d}|r |St||j}||t|<|j|j|t|j|_|t|j|_|S)z(Deep copy implementation for IC_Residue.F) rBrCrDrErF__dict__rrrPr*rorpr7r,r,r-rs; s zIC_Residue.__deepcopy__r5rcCsR||jvr'|j}t|d|jdkr'|d|jdkr'|d|jdkr'dSdS)z*Return True if atomkey is in this residue.rrArTF)rSrrrz)r*r5rr,r,r- __contains__H s zIC_Residue.__contains__r4cCsPz|j|}W|Sty't||}|j|<t|tr$d|_Y|SY|Sw)z(Cache calls to AtomKey for this residue.T)rTrr isinstancermissingr*r4r5r,r,r-rmT s   zIC_Residue.rakcCs8t|jD]}|jd}|j|dur||j|<qdS)a?Create explicit entries for for atoms so don't miss altlocs. This ensures that self.akc (atom key cache) has an entry for selected atom name (e.g. "CA") amongst any that have altlocs. Without this, rak() on the other altloc atom first may result in the main atom being missed. r/N)rrSrrTrB)r*r5atmNamer,r,r-r^ s   zIC_Residue._build_rak_cachecCsZd|jdkrd|jkrd|_nd|jkrd|_|j|jvr dS||}|j|dS)zrFilter Biopython Atom with accept_atoms; set ak_set. Arbitrarily renames O' and O'' to O and OXT rjrzO'zO''rN)name accept_atomsrmrSrrr,r,r-r{k s    zIC_Residue._add_atomcCs t|jjS)z"Print string is parent Residue ID.)rrPrrr,r,r-__repr__| s zIC_Residue.__repr__cCs.|jj}|jjd|d|d|dS)zNice string for residue ID.rrrAr)rPrCr)r*rCr,r,r-r s&zIC_Residue.pretty_strrc Cs|jD]}||_|j|_|j|jq|jD] }|j|j|j|_q|js0| g|_ |j | t |dt |dt |dfdS)zHousekeeping after loading all residues and dihedra. - Link dihedra to this residue - form id3_dh_index - form ak_set - set NCaCKey to be available AtomKeys called for loading PDB / atom coords r|r~r}N)r&r=rqrrSrrr%rTrrrrr)r*rdhrr,r,r-r s  zIC_Residue._link_dihedracCsx|jD]4}|jdkrd|_d|_q|jdrd|_q|jdr1|jdj ddkr1d|_ q|jdkr9d|_ qd S) znFor OpenSCAD, mark N-CA and CA-C bonds to be flexible joints. See :func:`.SCADIO.write_SCAD` NCACTNCACACrAr/r}CBCACN) r%r=rrrendswithr startswithrrrrr*rr,r,r- set_flexible s    zIC_Residue.set_flexiblecCs6|jD]}|jdkrd|_q|jdkrd|_qdS)zmFor OpenSCAD, mark H-N and C-O bonds to be hbonds (magnets). See :func:`.SCADIO.write_SCAD` HNCATCACON)r%r=rrrrr,r,r- set_hbond s  zIC_Residue.set_hbondcsxi}|jfddt|jD}dd|D}fdd|D}|D]}t|jD]\}}j|j|||<q*q#|S)z?Generate default N-Ca-C coordinates to build this residue from.csg|] }j|dqSr9)rMrB)rrrr,r-r rz0IC_Residue._default_startpos..cSsg|]}|dur|qSr9r,)rrrr,r,r-r crr,)r&)rsublistvalrr,r-r r)rrr enumeraterrir6)r* atomCoordsdlist0dlist1dlistrrrr$r,rr-_default_startpos szIC_Residue._default_startposcsfi}|j|jD] }tjfdd|Dr(|D] }jj|||<qq|ikr1|}|S)z3Find N-Ca-C coordinates to build this residue from.cr3r,r4r5rr,r-r r6z,IC_Residue._get_startpos..)rrr!rrLrr'r)r*startPosncacr5r,rr- _get_startpos s zIC_Residue._get_startposcCs"|jD] }d|jj|j<qdS)zInvalidate dihedra coordinate space attributes before assemble(). Coordinate space attributes are Dihedron.cst and .rcst, and :data:`IC_Chain.dCoordSpace` FN)r&r=rrlr6)r*rrr,r,r-r szIC_Residue.clear_transformsrc s|j}|j}|j}|j}|j}|jsdSt|j}|jd} | | d| d| df} d|j vrH| | | d| d| dfd|j vra| | | d| d| df| |t | } |rq|n|| rs tt| } |j| d} | durq| D]}|j|}t|jdjtjj}|j|j|_dt|jkrh|jd durh|j j}|jd } tfd d |jD}d|kr|| kr| !| ||jsfd d | D}t"|d|d |dd\|_#|_$d||j<qd |krS t%&fdd | D}t"|d|d |dd\|_#|_$d||j< |j$'|jd } ||<||||<d|||< || krR| !|q|rgt(d|t(fdd |jDq|rpt(d|q| sxS)a Compute atom coordinates for this residue from internal coordinates. This is the IC_Residue part of the :meth:`.assemble_residues_ser` serial version, see :meth:`.assemble_residues` for numpy vectorized approach which works at the :class:`IC_Chain` level. Join prepared dihedra starting from N-CA-C and N-CA-CB hedrons, computing protein space coordinates for backbone and sidechain atoms Sets forward and reverse transforms on each Dihedron to convert from protein coordinates to dihedron space coordinates for first three atoms (see :data:`IC_Chain.dCoordSpace`) Call :meth:`.init_atom_coords` to update any modified di/hedra before coming here, this only assembles dihedra into protein coordinate space. **Algorithm** Form double-ended queue, start with c-ca-n, o-c-ca, n-ca-cb, n-ca-c. if resetLocation=True, use initial coords from generating dihedron for n-ca-c initial positions (result in dihedron coordinate space) while queue not empty get 3-atom hedron key for each dihedron starting with hedron key (1st hedron of dihedron) if have coordinates for all 4 atoms already add 2nd hedron key to back of queue else if have coordinates for 1st 3 atoms compute forward and reverse transforms to take 1st 3 atoms to/from dihedron initial coordinate space use reverse transform to get position of 4th atom in current coordinates from dihedron initial coordinates add 2nd hedron key to back of queue else ordering failed, put hedron key at back of queue and hope next time we have 1st 3 atom positions (should not happen) loop terminates (queue drains) as hedron keys which do not start any dihedra are removed without action :param bool resetLocation: default False. - Option to ignore start location and orient so initial N-Ca-C hedron at origin. :returns: Dict of AtomKey -> homogeneous atom coords for residue in protein space relative to previous residue **Also** directly updates :data:`IC_Chain.atomArray` as :meth:`.assemble_residues` does. Nrr}r~r|rrjrr/csg|]}|vr|qSr,r,rr$rr,r-rk rz'IC_Residue.assemble..cg|]}|qSr,r,rrr,r-rx rrArTcrr,r,rrr,r-r rzno coords to startcs g|] }|ddur|qSr9)rBrrr,r-r s zno initial coords for))rrlrLr'rrSrrrzrrmrTrrrrrHKTpoprMrBr&rrrrrrNrir6initial_coordsrr appendleftrrmrnr!asarraydotr)r*rrrrlaaValidaaNdxaarrseqposstartLstqh1k dihedraKeysrrrdseqposd_h2keyr5acountacsacak3r,rr-r, sC  "               "        ezIC_Residue.assemblelst)r. missingOKcCstjj}tjj}g}t}i}i}|D]S} t|| <| |jvr4| j|dur4| j|dur4|| fqg} |jD]%} | | r^| | | || <| j|} | dur^| | ||  | q9|t | qd} |D]}t |}d|kr{|s{gS| |kr|} qkd| krg}|D] }|r||dqt |gSg}|D]J}g}|D]<}t |}d|krqd|kr||dq||||dvr|t |dq|D]} | j||kr|| qq|t |q|S)aJGet AtomKeys for this residue (ak_set) for generic list of AtomKeys. Changes and/or expands a list of 'generic' AtomKeys (e.g. 'N, C, C') to be specific to this Residue's altlocs etc., e.g. '(N-Ca_A_0.3-C, N-Ca_B_0.7-C)' Given a list of AtomKeys for a Hedron or Dihedron, return: list of matching atomkeys that have id3_dh in this residue (ak may change if occupancy != 1.00) or multiple lists of matching atomkeys expanded for all atom altlocs or empty list if any of atom_coord(ak) missing and not missingOK :param list lst: list[3] or [4] of AtomKeys. Non-altloc AtomKeys to match to specific AtomKeys for this residue :param bool missingOK: default False, see above. NrrA) rrrrrrSrr altloc_matchrrrr)r*rr altloc_ndxocc_ndxedraLstaltlocs posnAltlocsakMapr5ak2_lstak2rmaxcrlenAKLnewAKL new_edraLstalalhlr,r,r-r sp          zIC_Residue.split_aklc Cs|D]}|jr dSqt|}d|kr|jj|jt}}}n |jj|jt}}}t|tr4t |}n|}| |}|D]!} t| |kr^| |vrO|| || <| |vrY|| || <d|| _ q=dS)aRPopulate hedra/dihedra given edron ID tuple. Given list of AtomKeys defining hedron or dihedron convert to AtomKeys with coordinates in this residue add appropriately to self.di/hedra, expand as needed atom altlocs :param list lst: tuple of AtomKeys. Specifies Hedron or Dihedron NrT) rrrr%Hedronr&rrrrr needs_update) r*rr5lenLstcdctdctobjtlsthltnlstr,r,r- _gen_edra s*        zIC_Residue._gen_edrac s$jsdSddd}}}jdkr d}dtjkr߈jdjr߈jD]}|d|d|d}}} |j||| fdd } | D]$} | D]} | |jvraj| qS|jD] } | | rqj| qdqSqO||||f||||f|||| f|||f|||f||| fz|j d }Wq0t y|j dd}|dur||jvr܈j||||f||||fYq0wdtj kr|||ft }|D]}tfd d |Drfd d|D}|qjdurmt jg}|D]#}|dd}tfdd |Dr@fdd|D}|qtjrmt jg}|D]}tfdd |Drkfdd|D}|qOjrdjkrƈjtdd}d|_jj|d }|||f}|||||f}|j|}|_|tjdsij_|jj|<||rd g}j D]\}}t|t r|jr|!|q|rj"j#}|j$}t|j%j&}t'd|d|d|dSdSdS)zCreate IC_Chain and IC_Residue di/hedra for atom coordinates. AllBonds handled here. :param bool verbose: default False. Warn about missing N, Ca, C backbone atoms. Nr|r~r}rrrT)rrjc3rr9rTrrr,r-r rz*IC_Residue._create_edra..cg|]}|qSr,rmrr}rr,r-r r6z+IC_Residue._create_edra..rc3rr9rrrr,r-r rcrr,rrrr,r-r r6c3rr9rrrr,r-r rcrr,rrrr,r-r r6Fr^zchain z len z missing atom(s): )(rSrmrrrRrrrrrTrrBrQrrrrrrrrrrrJr&rq _set_hedrar0r^rrrrrrPr+rCr0rr)r*rsNsCAsCsCBrnnNnCAnCnextNCaCtplr5rn_aknOnCBbackboneedrar_edra sidechainedraLongsOhtpldtplrrrakkakvchnchn_idchn_lenr,rr-r/C s "   "                        zIC_Residue._create_edra cif_extendcCsd|kr$tjrt|j|Sd}|jD] }|t||7}q|S|j}|j}d}|r0d}|dtj dur;tj n|j |j |j |j tjdurKtjn|j|jd|jd|jd|jd|jd|j|j|j}|S) aFGenerate PDB ATOM record. :param Atom atm: Biopython Atom object reference :param IC_Residue.atom_sernum: Class variable default None. override atom serial number if not None :param IC_Residue.atom_chain: Class variable default None. override atom chain id if not None rrzW{:6}{:5d} {:4}{:1}{:3} {:1}{:4}{:1} {:8.3f}{:8.3f}{:8.3f}{:6.2f}{:6.2f} {:>4} zZ{:6}{:5d} {:4}{:1}{:3} {:1}{:4}{:1} {:10.5f}{:10.5f}{:10.5f}{:7.3f}{:6.2f} {:>4} ATOMNrAr)r;rr_pdb_atom_stringrr<r=r+r atom_sernum serial_numberfullnamerr atom_chainrCr1 occupancybfactorelement)r4rsr$r3rfmtr,r,r-r s>  zIC_Residue._pdb_atom_stringcCszd}|jj}|jj}|jd}tjj}t|jD]"}t |j ||kr:|t |||7}t j dur:t j d7_ q|S)aGenerate PDB ATOM records for this residue as string. Convenience method for functionality not exposed in PDBIO.py. Increments :data:`IC_Residue.atom_sernum` if not None :param IC_Residue.atom_sernum: Class variable default None. Override and increment atom serial number if not None :param IC_Residue.atom_chain: Class variable. Override atom chain id if not None .. todo:: move to PDBIO rrNrA)rr'r(rzrrrNrrSrrrrr)r*rr'r(rN resposNdxr5r,r,r-pdb_residue_string s  zIC_Residue.pdb_residue_stringr3cCsH|}|s d|krd}nd|d}t|d|j|dS)zGenerate PIC Residue string. Enough to create Biopython Residue object without actual Atoms. :param Residue res: Biopython Residue object reference rz []rr) get_segidisspacer get_full_idr)r3segidr,r,r-_residue_string s  zIC_Residue._residue_string_pfDef)romgrtauchi1chi2chi3chi4chi5pomgchi classic_bclassicr%primary secondaryr initAtomsbFactorscCsg|]}d|>qS)rAr,rrr,r,r-r= rzIC_Residue.rrrrr/ rA rrcCs`||}d|dkr|d7}|d|jd|d7}|d7}d|dkr,|d7}||fS)NrrzBFAC:rz6.2frAr)rmrC get_bfactor)r*r4rrr5r,r,r-_write_pic_bfac` s   zIC_Residue._write_pic_bfac0PDBrpdbidchainidpicFlagshCutpCutc Cs|tj}|dur d}|durd}t}||j}||jj@r}dt|jkr}t|dr}|j dur}t |jdj |jdj dks}| |j d} | dur}z(tj|jddd} | tj|jd dd7} | tj|jd dd7} || 7}Wn ty|Ynw|d |d } |j} ||jj@s||jj@rt|jD]b} ||jj@s||jj@r| jd krq|durt| d r| jn| j}|tvrt|d|krq| j}z&|| | jd | j||d | j||d | j||d7}WqtyYqwt|jD]]}|jr||jj@s||@sqn ||jj @s%q|dur@|jr@|j!t"vr@t"|j!d|kr@qz|| |jd | j#|j|d7}WqtybYqw||jj$@rd}t|j%D]=}d|&krtj's|j(dur|)|j*||\}}qs|j+D] }|)|||\}}qqs|)|||\}}qsd|dkr|d7}|S)a Write PIC format lines for this residue. See :func:`.PICIO.write_PIC`. :param str pdbid: PDB idcode string; default 0PDB :param str chainid: PDB Chain ID character; default A :param int picFlags: control details written to PIC file; see :meth:`.PICIO.write_PIC` :param float hCut: only write hedra with ref db angle std dev > this value; default None :param float pCut: only write primary dihedra with ref db angle std dev > this value; default None Nr"rrrr|T)rr~r}rr xrh_classrArrr),rrrrP pic_flagsrrrQr0rr!rr1 pick_anglerrrr%rrr=rr(rr6rCrVrWrXr&rbitsrpclassr r[rr:r;rrxr!rr<)r*r#r$r%r&r'pAccicrr NCaChedrontsbaserrhcrrrrr$r4r,r,r- _write_PICj s           0   .zIC_Residue._write_PICak_strc Cst}|}g}|d}t|}|D]_}|j|}|rh|ddkr8dt|jkr7|||jd|dq|ddkrUdt|jkrT|||jd|dq|ddkrg|| |dq|| |qt||krydSt |S) zConvert atom pair string to AtomKey tuple. :param str ak_str: Two atom names separated by ':', e.g. 'N:CA' Optional position specifier relative to self, e.g. '-1C:N' for preceding peptide bond. :rAz-1rr10N) rsplitr_relative_atom_rematchgrouprQrrRrmr) r*r4AKS angle_key2 akstr_listlenInputr$mr,r,r- _get_ak_tuple s.   zIC_Residue._get_ak_tuplez^(-?[10])([A-Z]+)$ angle_key)rrcCsLt|}d|kr|jtt|d}|Sd|kr$|jtt|d}|SdS)Nrr/)rr&rBrDKTr%r)r*rClen_mkeyrvalr,r,r-_get_angle_for_tuple szIC_Residue._get_angle_for_tuplecsd}t|tr|}|durjrjd|}|Sd|vrHtttt|}|dur2dS|}|durFjrFjd|}|Sd|kr}dtj krUdSj d} d d d}}}| d}j ||||fd}|Sd|krdtjkrdSjd}| d d d} }} d}|j | |||fd}|Sd |ksd |krdtjkrdSjd}| d| d d} } } d}|j | | ||fd}|Sd |kr) d d d}}}j |||fd}|dur'dtjkr'jd}|j |||fd}|S|d rt jd} | dur=dSd t|dd} z,| | } | d|krqfdd| ddD}ttt|}j |d}W|SWdSty~YdSw|S)aGet Hedron or Dihedron for angle_key. :param angle_key: - tuple of 3 or 4 AtomKeys - string of atom names ('CA') separated by :'s - string of [-1, 0, 1] separated by ':'s. -1 is previous residue, 0 is this residue, 1 is next residue - psi, phi, omg, omega, chi1, chi2, chi3, chi4, chi5 - tau (N-CA-C angle) see Richardson1981 - tuples of AtomKeys is only access for alternate disordered atoms Observe that a residue's phi and omega dihedrals, as well as the hedra comprising them (including the N:Ca:C `tau` hedron), are stored in the n-1 di/hedra sets; this overlap is handled here, but may be an issue if accessing directly. The following print commands are equivalent (except for sidechains with non-carbon atoms for chi2):: ric = r.internal_coord print( r, ric.get_angle("psi"), ric.get_angle("phi"), ric.get_angle("omg"), ric.get_angle("tau"), ric.get_angle("chi2"), ) print( r, ric.get_angle("N:CA:C:1N"), ric.get_angle("-1C:N:CA:C"), ric.get_angle("-1CA:-1C:N:CA"), ric.get_angle("N:CA:C"), ric.get_angle("CA:CB:CG:CD"), ) See ic_data.py for detail of atoms in the enumerated sidechain angles and the backbone angles which do not span the peptide bond. Using 's' for current residue ('self') and 'n' for next residue, the spanning (overlapping) angles are:: (sN, sCA, sC, nN) # psi (sCA, sC, nN, nCA) # omega i+1 (sC, nN, nCA, nC) # phi i+1 (sCA, sC, nN) (sC, nN, nCA) (nN, nCA, nC) # tau i+1 :return: Matching Hedron, Dihedron, or None. Nrr5rr|r~r}rromegarrrrrArcrr,rrrr,r-rpr6z)IC_Residue.pick_angle..)rrrGrQrrrBrrrRrmr&rBr%rrrrrD IndexError)r*rCrFrrrrrrppCpCAsclistr6rklsttklstr,rr-r* s|6  3 , " % "  "  "   zIC_Residue.pick_anglecCs||}|r t|jSdS)zqGet dihedron or hedron angle for specified key. See :meth:`.pick_angle` for key specifications. N)r*rr)r*rCedronr,r,r- get_anglezs  zIC_Residue.get_angleTvcCsL||}|dur dSt|ts|s||_dSt|j|}|||dS)a3Set dihedron or hedron angle for specified key. If angle is a `Dihedron` and `overlap` is True (default), overlapping dihedra are also changed as appropriate. The overlap is a result of protein chain definitions in :mod:`.ic_data` and :meth:`_create_edra` (e.g. psi overlaps N-CA-C-O). The default overlap=True is probably what you want for: `set_angle("chi1", val)` The default is probably NOT what you want when processing all dihedrals in a chain or residue (such as copying from another structure), as the overlapping dihedra will likely be in the set as well. N.B. setting e.g. PRO chi2 is permitted without error or warning! See :meth:`.pick_angle` for angle_key specifications. See :meth:`.bond_rotate` to change a dihedral by a number of degrees :param angle_key: angle identifier. :param float v: new angle in degrees (result adjusted to +/-180). :param bool overlap: default True. Modify overlapping dihedra as needed N)r*rrrr angle_dif_do_bond_rotate)r*rCrRoverlaprPdeltar,r,r-rs  zIC_Residue.set_angler1rrVc Csz?|jj|jD]4}|jj|}|j|7_z|jj|jdddD] }|jj|j|7_q$Wqty<YqwWdStyJtdw)z5Find and modify related dihedra through id3_dh_index.Nrz.bond_rotate, bond_set only for dihedral angles) rrMrr&rrrAttributeError RuntimeError)r*r1rVrdihedd2rkr,r,r-rTs   zIC_Residue._do_bond_rotatecCs&||}|dur|||dSdS)aXRotate set of overlapping dihedrals by delta degrees. Changes a dihedral angle by a given delta, i.e. new_angle = current_angle + delta Values are adjusted so new_angle will be within +/-180. Changes overlapping dihedra as in :meth:`.set_angle` See :meth:`.pick_angle` for key specifications. N)r*rT)r*rCrVr1r,r,r- bond_rotates zIC_Residue.bond_rotatercCs4||}|durt|j|}|||dSdS)a<Set dihedron to val, update overlapping dihedra by same amount. Redundant to :meth:`.set_angle`, retained for compatibility. Unlike :meth:`.set_angle` this is for dihedra only and no option to not update overlapping dihedra. See :meth:`.pick_angle` for key specifications. N)r*rrSrrT)r*rCrr1rVr,r,r-bond_sets zIC_Residue.bond_setak_specrcsg}t|trtt||}|durdS|jD]\}tfdd|Dr.||q|j D]}|jD]\}tfdd|DrM||q9q2||fS)aGet list of hedra containing specified atom pair. :param ak_spec: - tuple of two AtomKeys - string: two atom names separated by ':', e.g. 'N:CA' with optional position specifier relative to self, e.g. '-1C:N' for preceding peptide bond. Position specifiers are -1, 0, 1. The following are equivalent:: ric = r.internal_coord print( r, ric.get_length("0C:1N"), ) print( r, None if not ric.rnext else ric.get_length((ric.rak("C"), ric.rnext[0].rak("N"))), ) If atom not found on current residue then will look on rprev[0] to handle cases like Gly N:CA. For finer control please access `IC_Chain.hedra` directly. :return: list of hedra containing specified atom pair as tuples of AtomKeys Nrc3|]}|vVqdSr9r,r5hed_keyr,r-rz)IC_Residue.pick_length..c3r^r9r,r5r_r,r-rra) rrrBKTrBr%rrrrQ)r*r]rlsthed_valrJr,r_r- pick_lengths     zIC_Residue.pick_lengthcCsJ||\}}|dus|durdS|D]}||}|dur"|SqdS)zlGet bond length for specified atom pair. See :meth:`.pick_length` for ak_spec and details. N)re get_length)r*r]hed_lstak_spec2rrr,r,r-rfs zIC_Residue.get_lengthcCs@||\}}|dur|dur|D] }|||qdSdSdS)z`Set bond length for specified atom pair. See :meth:`.pick_length` for ak_spec. N)re set_length)r*r]rrgrhrr,r,r-ris zIC_Residue.set_lengthrycs^|jj}|jjtjjt|jdfddD}||}| | ||<dS)z0Apply matrix to atom_coords for this IC_Residue.rcs$g|]}|jkr|qSr,)rrBraairJrpndxr,r-r#s$z'IC_Residue.applyMtx..N) rrr'rrrNrrzrr transpose)r*ryraselectaasr,rjr-applyMtxszIC_Residue.applyMtx)r+rrNrrFFr)Wrrrrrrrrrrrraccept_backboneaccept_sidechainaccept_mainchainaccept_hydrogensaccept_deuteriumsrr.rsrr r rmrr{rrrrrrr!rrrrrr,rrrrr/rrrrrrrrr_b_bChi_bClassB_bClass_bAllr)rrrpicFlagsDefault_asdict picFlagsDictrr!rrr3rBrecompiler9rrGr*rQrrTr[r\rbrerfrirpr,r,r,r-rs      #33 7          R  "h(.( "  s      o "  0 rc@s<eZdZdZedZ ededde fddZ ede de fd d Z d e edefd e dd fddZddZdddefddZdefddZde fddZdefddZddde e deffddZdedefdd Zdedefd!d"Zdedefd#d$Zdedefd%d&Zdedefd'd(Zdedefd)d*Zd S)+Edrona{Base class for Hedron and Dihedron classes. Supports rich comparison based on lists of AtomKeys. Attributes ---------- atomkeys: tuple 3 (hedron) or 4 (dihedron) :class:`.AtomKey` s defining this di/hedron id: str ':'-joined string of AtomKeys for this di/hedron needs_update: bool indicates di/hedron local atom_coords do NOT reflect current di/hedron angle and length values in hedron local coordinate space e_class: str sequence of atoms (no position or residue) comprising di/hedron for statistics re_class: str sequence of residue, atoms comprising di/hedron for statistics cre_class: str sequence of covalent radii classes comprising di/hedron for statistics edron_re: compiled regex (Class Attribute) A compiled regular expression matching string IDs for Hedron and Dihedron objects cic: IC_Chain reference Chain internal coords object containing this hedron ndx: int index into IC_Chain level numpy data arrays for di/hedra. Set in :meth:`IC_Chain.init_edra` rc: int number of residues involved in this edron Methods ------- gen_key([AtomKey, ...] or AtomKey, ...) (Static Method) generate a ':'-joined string of AtomKey Ids is_backbone() Return True if all atomkeys atoms are N, Ca, C or O z^(?P\w+)?\s(?P[\w|\s])?\s(?P[\w\-\.]+):(?P[\w\-\.]+):(?P[\w\-\.]+)(:(?P[\w\-\.]+))?\s+(((?P\S+)\s+(?P\S+)\s+(?P\S+)\s*$)|((?P\S+)\s*$))rrrcCsddt|kr|djd|djd|djd|djS|djd|djd|djS)zGenerate string of ':'-joined AtomKey strings from input. Generate '2_A_C:3_P_N:3_P_CA' from (2_A_C, 3_P_N, 3_P_CA) :param list lst: list of AtomKey objects rrr5rArr/)rrC)rr,r,r-gen_keyks 2&z Edron.gen_keyakstrcCstdd|dDS)zGenerate AtomKey tuple for ':'-joined AtomKey string. Generate (2_A_C, 3_P_N, 3_P_CA) from '2_A_C:3_P_N:3_P_CA' :param str akstr: string of ':'-separated AtomKey strings cSsg|]}t|qSr,)rrr,r,r-r~rz#Edron.gen_tuple..r5)rr8)rr,r,r- gen_tuplewszEdron.gen_tupleargskwargsNc sg}|D]}t|tr|}qt|trt|}q|dur!||qg|krUtfdddDrUtdtdtdg}dvrUddurU|tdt||_t||_ t |j|_ d |_ |d |_ d |_d |_t}tjj}tjj}tjj}tjj} |D]1} | j} |j | |7_ |j| || |7_|| || | pd |j| 7_qt||_dS) a Initialize Edron with sequence of AtomKeys. Acceptable input: [ AtomKey, ... ] : list of AtomKeys AtomKey, ... : sequence of AtomKeys as args {'a1': str, 'a2': str, ... } : dict of AtomKeys as 'a1', 'a2' ... Nc3r^r9r,rrr,r-rraz!Edron.__init__..)rua2a3rurra4Tr)rrrrrrrrrrChash_hashrrre_class cre_classrrr4rrNicoderrcr_classrrc) r*rrrargrsetrrresPosrr5rr,rr-r.sH           zEdron.__init__cCsf|t|d}|r |St||j}||t|<|j|j|t|j|_t |j ||_ |S)z#Deep copy implementation for Edron.F) rBrCrDrErFr~rrrGrHrrr,r,r-rss zEdron.__deepcopy__r5cCs ||jvS)z(Return True if atomkey is in this edron.rr*r5r,r,r-r zEdron.__contains__cCstdd|jDS)z3Report True for contains only N, C, CA, O, H atoms.css|]}|VqdSr9)rr5r,r,r-rraz$Edron.is_backbone..)rrrr,r,r-rszEdron.is_backbonecCs t|jS)z)Tuple of AtomKeys is default repr string.)rrrr,r,r-rrzEdron.__repr__cC|jS)z,Hash calculated at init from atomkeys tuple.rrr,r,r-__hash__zEdron.__hash__rrcCs0t|j|jD]\}}||kr||fSqdS)z|Comparison function ranking self vs. other; False on equal. Priority is lowest value for sort: psi < chi1. F)rr)r*rak_sak_or,r,r-_cmps  z Edron._cmpcCst|t|s tS|j|jkSzTest for equality.rrDNotImplementedrCr*rr,r,r-__eq__ z Edron.__eq__cCst|t|s tS|j|jkSzTest for inequality.rrr,r,r-__ne__rz Edron.__ne__cCsFt|t|s tS||}|r!ttttf|}|d|dkSdS)Test greater than.rrAFrrDrrrrrr*rrsltr,r,r-__gt__ z Edron.__gt__cCsFt|t|s tS||}|r!ttttf|}|d|dkSdS)Test greater or equal.rrATrrr,r,r-__ge__rz Edron.__ge__cCsFt|t|s tS||}|r!ttttf|}|d|dkSdS)Test less than.rrAFrrr,r,r-__lt__rz Edron.__lt__cCsFt|t|s tS||}|r!ttttf|}|d|dkSdS)Test less or equal.rrATrrr,r,r-__le__ rz Edron.__le__)rrrrrredron_rerrrrrrr rr.rsrrrrrrrobjectrrrrrrr,r,r,r-r0s.*  " ;     rcseZdZdZdeedefdeddffdd Zdefd d Z e de fd d Z d dZ e jddd Z e ddZejddZe de fddZejddZdedee fddZdede fddZZS)raClass to represent three joined atoms forming a plane. Contains atom coordinates in local coordinate space: central atom at origin, one terminal atom on XZ plane, and the other on the +Z axis. Stored in two orientations, with the 3rd (forward) or first (reversed) atom on the +Z axis. See :class:`Dihedron` for use of forward and reverse orientations. Attributes ---------- len12: float distance between first and second atoms len23: float distance between second and third atoms angle: float angle (degrees) formed by three atoms in hedron xrh_class: string only for hedron spanning 2 residues, will have 'X' for residue contributing only one atom Methods ------- get_length() get bond length for specified atom pair set_length() set bond length for specified atom pair angle(), len12(), len23() setters for relevant attributes (angle in degrees) rrrrNc stj|i||jdkrqtjj}tjj}tjj}tjj}|j dj |j dj }}||||ks;||||krGd|j dd|_ dSd} t dD]} | |j | j ||j | j |7} qM| d|j dj ||_ dSdS)zInitialize Hedron with sequence of AtomKeys, kwargs. Acceptable input: As for Edron, plus optional 'len12', 'angle', 'len23' keyworded values. rrrArNr)superr.rrrrNrrr4rrrr(r) r*rrrrrrakl0akl1xrhcrrFr,r-r.6s   &zHedron.__init__c Cs,d|jd|jd|jd|jd|j S)zPrint string for Hedron object.z3-r)rCrrrrrr,r,r-rNs zHedron.__repr__cC&z|jj|jWStyYdSw)zGet this hedron angle.r)rrWr6rWrr,r,r-rU  z Hedron.anglecCs2d|jj|j<|jD] }d|jj|jj|<q dS)NTF)rrer6rrLr'rr,r,r-_invalidate_atoms]s zHedron._invalidate_atomscC:||jj|j<d|jj|j<d|jj|jj|jd<dS)z)Set this hedron angle; sets needs_update.TFrN)rrWr6rerLr'r)r* angle_degr,r,r-rbcCr)zGet first length for Hedron.r)rrVr6rWrr,r,r-rirz Hedron.len12cCsT||jj|j<d|jj|j<d|jj|jj|jd<d|jj|jj|jd<dS)z/Set first length for Hedron; sets needs_update.TFrArN)rrVr6rerLr'rr*rr,r,r-rqscCr)zGet second length for Hedron.r)rrXr6rWrr,r,r-ryrz Hedron.len23cCr)z0Set second length for Hedron; sets needs_update.TFrN)rrXr6rerLr'rrr,r,r-rrak_tplcs\dt|krdStfdd|DrjjjStfdd|Dr,jjjSdS)zGet bond length for specified atom pair. :param tuple ak_tpl: tuple of AtomKeys. Pair of atoms in this Hedron rNc3"|] }|jddvVqdSNrrr5rr,r-r z$Hedron.get_length..c3"|] }|jddvVqdSrANrr5rr,r-rr)rrrrVr6rX)r*rr,rr-rfs zHedron.get_length newLengthcsdt|kr td|tfdd|Dr |jjj<ntfdd|Dr3|jjj<n tdt|fdS)zSet bond length for specified atom pair; sets needs_update. :param tuple .ak_tpl: tuple of AtomKeys Pair of atoms in this Hedron rzRequire exactly 2 AtomKeys: c3rrrr5rr,r-rrz$Hedron.set_length..c3rrrr5rr,r-rrz%s not found in %sN) r TypeErrorrrrVr6rXrr)r*rrr,rr-ris  zHedron.set_lengthr)rrrrr rrrr.rpropertyrrrsetterrrrbrrfri __classcell__r,r,rr-rs&&    rcs2eZdZdZdeedefdeddffdd Zdefd d Z e d e d e de efd dZdefddZdeeeeffddZedefddZejdeddfddZe deeejfdeeejffddZe d)dededefdd Ze ded!efd"d#Zd$ddefd%d&Zdefd'd(ZZ S)*razClass to represent four joined atoms forming a dihedral angle. Attributes ---------- angle: float Measurement or specification of dihedral angle in degrees; prefer :meth:`IC_Residue.bond_set` to set hedron1, hedron2: Hedron object references The two hedra which form the dihedral angle h1key, h2key: tuples of AtomKeys Hash keys for hedron1 and hedron2 id3,id32: tuples of AtomKeys First 3 and second 3 atoms comprising dihedron; hxkey orders may differ ric: IC_Residue object reference :class:`.IC_Residue` object containing this dihedral reverse: bool Indicates order of atoms in dihedron is reversed from order of atoms in hedra primary: bool True if this is psi, phi, omega or a sidechain chi angle pclass: string (primary angle class) re_class with X for adjacent residue according to nomenclature (psi, omega, phi) cst, rcst: numpy [4][4] arrays transformations to (cst) and from (rcst) Dihedron coordinate space defined with atom 2 (Hedron 1 center atom) at the origin. Views on :data:`IC_Chain.dCoordSpace`. Methods ------- angle() getter/setter for dihdral angle in degrees; prefer :meth:`IC_Residue.bond_set` bits() return :data:`IC_Residue.pic_flags` bitmask for dihedron psi, omega, etc rrrrNcsltj|i|||||ttt|jdd|_ttt|jdd|_||d|_ dS)zInit Dihedron with sequence of AtomKeys and optional dihedral angle. Acceptable input: As for Edron, plus optional 'dihedral' keyworded angle value. rr/rArFN) rr.rrrrrr _setPrimaryr)r*rrrr,r-r.s zDihedron.__init__cCs$d|jd|jd|jd|jS)z!Print string for Dihedron object.z4-r)rCrrrqrr,r,r-rs$zDihedron.__repr__ic_resrcCs|j|d}|s#dt|jkr#|jD]}|j|d}|dur"nq|s@dt|jkr@|jD]}|j|d}|dur?|Sq/|S)z@Find specified hedron on this residue or its adjacent neighbors.Nr)r%rBrrQrR)rrhedronrJrr,r,r- _get_hedrons  zDihedron._get_hedroncCs|j}|dkr|jddd|_d|_d S|dkr)d|jdd |_d|_d S|d kr div by 0 )r!rrxr"rrSr)rrr,r,r- angle_pop_sds&zDihedron.angle_pop_sdrcCst|j|jS)z;Get angle difference between this and other +/- 180 angles.)rrSrrr,r,r- differenceszDihedron.differencecst}|jdkr |jjSt|dr|jdkr|jj|jjBS|jdkr&|jjS|jdkr/|jjSt j j t |jj}tfdd|jD}|D]!}t|dkrQqH||d d kri|jjt|d d d >SqHd S) zPGet :data:`IC_Residue.pic_flags` bitmasks for self is psi, omg, phi, pomg, chiX.rr, XCAXCPNPCArrc3s|]}|jVqdSr9)rr5rr,r-rrz Dihedron.bits..rrrrrA)rrr)rr0r,rr rrrr4rrBrqrrrrrr)r*r.scListaLster,rr-r+s&     z Dihedron.bitsrq)!rrrrr rrDrr.rrrrrrrrrrrrrrrr!rrSrrrrr+rr,r,rr-rs(&%( %( rc@sZeZdZdZedZ edZdZe dgdZ e dddd d d Z d Z d e eeeeefdeddfddZddZdefddZdefddZdddd dZiddddddddddddd d d!d d"d d#d d$d d%d d&d d'd d(d d)d*d+d*id,d*d-d*d.d*d/d0d1d0d2d0d3d4d5d6d7d6d8d6d9d:d;d:dd?d>d@dAdBdCZdddd d d d*dDZdEddefdFdGZdefdHdIZdefdJdKZde edffdLdMZdEdde eeffdNdOZ!dEe"defdPdQZ#dEe"defdRdSZ$dEe"defdTdUZ%dEe"defdVdWZ&dEe"defdXdYZ'dEe"defdZd[Z(dS)\ra Class for dict keys to reference atom coordinates. AtomKeys capture residue and disorder information together, and provide a no-whitespace string key for .pic files. Supports rich comparison and multiple ways to instantiate. AtomKeys contain: residue position (respos), insertion code (icode), 1 or 3 char residue name (resname), atom name (atm), altloc (altloc), and occupancy (occ) Use :data:`AtomKey.fields` to get the index to the component of interest by name: Get C-alpha atoms from IC_Chain atomArray and atomArrayIndex with AtomKeys:: atmNameNdx = internal_coords.AtomKey.fields.atm CaSelection = [ atomArrayIndex.get(k) for k in atomArrayIndex.keys() if k.akl[atmNameNdx] == "CA" ] AtomArrayCa = atomArray[CaSelection] Get all phenylalanine atoms in a chain:: resNameNdx = internal_coords.AtomKey.fields.resname PheSelection = [ atomArrayIndex.get(k) for k in atomArrayIndex.keys() if k.akl[resNameNdx] == "F" ] AtomArrayPhe = atomArray[PheSelection] 'resname' will be the uppercase 1-letter amino acid code if one of the 20 standard residues, otherwise the supplied 3-letter code. Supplied as input or read from .rbase attribute of :class:`IC_Residue`. Attributes ---------- akl: tuple All six fields of AtomKey fieldNames: tuple (Class Attribute) Mapping of key index positions to names fields: namedtuple (Class Attribute) Mapping of field names to index positions. id: str '_'-joined AtomKey fields, excluding 'None' fields atom_re: compiled regex (Class Attribute) A compiled regular expression matching the string form of the key d2h: bool (Class Attribute) default False Convert D atoms to H on input if True; must also modify :data:`IC_Residue.accept_atoms` missing: bool default False AtomKey __init__'d from string is probably missing, set this flag to note the issue. Set by :meth:`.IC_Residue.rak` ric: IC_Residue default None *If* initialised with IC_Residue, this references the IC_residue Methods ------- altloc_match(other) Returns True if this AtomKey matches other AtomKey excluding altloc and occupancy fields is_backbone() Returns True if atom is N, CA, C, O or H atm() Returns atom name, e.g. N, CA, CB, etc. cr_class() Returns covalent radii class e.g. Csb z^(?P-?\d+)(?P[A-Za-z])?_(?P[a-zA-Z]+)_(?P[A-Za-z0-9]+)(?:_(?P\w))?(?:_(?P-?\d\.\d+?))?$z \D+(\d+)$)rNrrr4rr _fieldsDefrrArr/rrFrrrNc Osrg}d|_|D]}t|tr6d|vr0|j|}|dur/|gkr&td|tt|jt j }q| |qt|t rL|gkrCtdt|j }||_qt|trdt|kr[td| |jt js|j}| |dkro|ndt|j}| |dkrt|ndq|ddg7}qt|ttfr||7}qt|trt j D] }| ||dqqtd tt|d D]} t|| kr|t j | } | dur| | qt|d trt|d |d <|jrt jj} || d d krtjd d || dd|| <ddt d|ddt|ddt d|ddg|_!|dgd t|7}t||_"t#|j"|_$d|_%dS)afInitialize AtomKey with residue and atom data. Examples of acceptable input:: (, 'CA', ...) : IC_Residue with atom info (, ) : IC_Residue with Biopython Atom ([52, None, 'G', 'CA', ...]) : list of ordered data fields (52, None, 'G', 'CA', ...) : multiple ordered arguments ({respos: 52, icode: None, atm: 'CA', ...}) : dict with fieldNames (respos: 52, icode: None, atm: 'CA', ...) : kwargs with fieldNames 52_G_CA, 52B_G_CA, 52_G_CA_0.33, 52_G_CA_B_0.33 : id strings Nrz+Atom Key init full key not first argument: z(Atom Key init Residue not first argumentr/z&Atom Key init Atom before Residue inforrzAtom Key init not recognisedrrrIrMrA)countrrF)&rqrratom_rer: Exceptionrmapr;r fieldNamesrrrzr rrrrrrrrrBrrd2hrr4rsubjoinrrCrrrr) r*rrrrrArrrrfldrr,r,r-r. st                  zAtomKey.__init__cCs`|t|d}|r |St||j}||t|<|j|j|jdur.|t|j|_|S)z%Deep copy implementation for AtomKey.FN)rBrCrDrErFr~rrqrr,r,r-rs`s  zAtomKey.__deepcopy__cCr)zRepr string from id.)rCrr,r,r-rnrzAtomKey.__repr__cCr)z'Hash calculated at init from akl tuple.rrr,r,r-rrrzAtomKey.__hash__)r|r~r}rjrrrrrrrrrrrrrr rr rr r r rrrrrrrrrrrrrrrrrrrrrMr)rBrrIErrMrcCs.t|t|r|jdd|jddkStS)z=Test AtomKey match to other discounting occupancy and altloc.NrrrDrrrr,r,r-rszAtomKey.altloc_matchcCs|j|jjdvS)z$Return True if is N, C, CA, O, or H.)r|r}r~rjrMrrr4rr,r,r-rszAtomKey.is_backbonecCs|j|jjS)z$Return atom name : N, CA, CB, O etc.rrr,r,r-r4sz AtomKey.atmc Cs|j}|jj}z td||WSty@z|jj}t||||WYSty?||ddkr9dndYYSww)z-Return covalent radii class for atom or None.rrrMrN)rrr4rrr)r*rrrr,r,r-rs   zAtomKey.cr_classcCstdD]z}|j||j|}}||kr|dur"|dur"dS|dur-|dur-dStjj|krtjj|krOtt|d}tt|d}||fStjj|kr_t|t|fStjj |kr|jtjj |jtjj }}|dur|durt |t |fSdS|durdSt |t |fS|j |d} |j |d} | dur| dur| | fS| dur| durdS| dur| durdS|j |d} |j |d} | dur| dur| | fS| dur| durdS| dur| durdS|d|d|d|df\} }}}||}}d| krud|kru||ks.|r]|r]|j|}|j|}|gkrR|gkrRt|dt|dfS|gkrZdSdS|rcdS|ridS|j||j|fSt|t|fSqd S) z~Comparison function ranking self vs. other. Priority is lower value, i.e. (CA, CB) gives (0, 1) for sorting. rNr)rArdrrArM)rArA)rrrrr4rrrrNrrord_backbone_sort_keysrB_sidechain_sort_keysisdigit _endnum_refindall_greek_sort_keys)r*rrrooisisacoacsbrssoss0s1o0o1s1do1denmSenmOr,r,r-rs|          $   Tz AtomKey._cmpcCst|t|r |j|jkStSrrrr,r,r-r zAtomKey.__ne__cCst|t|r |j|jkStSrrrr,r,r-r rzAtomKey.__eq__cCs,t|t|r||}|d|dkStS)rrrArrDrrrr,r,r-r' zAtomKey.__gt__cCs,t|t|r||}|d|dkStS)rrrArrr,r,r-r/rzAtomKey.__ge__cCs,t|t|r||}|d|dkStS)rrrArrr,r,r-r7rzAtomKey.__lt__cCs,t|t|r||}|d|dkStS)rrrArrr,r,r-r?rzAtomKey.__le__))rrrrrrrrrrrrrr rr rrrr.rsrrrrrrrrrr4rrrrrrrrrrr,r,r,r-rsJ  W      !"%]rnumrcCs t|dS)zReduce floating point accuracy to 9.5 (xxxx.xxxxx). Used by :class:`IC_Residue` class writing PIC and SCAD files. :param float num: input number :returns: float with specified accuracy r)r)rr,r,r-rHs rc@eZdZdZdS)rz,Cannot find hedron in residue for given key.Nrrrrr,r,r,r-rVrc@r)MissingAtomErrorz0Missing atom coordinates for hedron or dihedron.Nrr,r,r,r-rZrr)6rrGr collectionsrrnumbersrtypingrrrrr numpyr!Bio.Data.PDBDatar Bio.PDB.Atomr r Bio.PDB.ic_datar rrrrrrBio.PDB.vectorsrrrBio.PDB.ResiduerrrrDrrbrHACSDACSrrrrrrrrrrrr,r,r,r-s                        h#