Biskit.Dock.Complex.Complex

init(self, rec_model=None, lig_model=None, ligMatrix=None, info={})
(Constructor)

Parameters:

rec_model (PDBModel OR PCRModel) - model of original receptor conformation
lig_model (PDBModel OR PCRModel) - model of original ligand conformation
ligMatrix (matrix) - Numeric array 4 by 4, ligand transformation matrix
info (dict) - {'eshape':-123.3, 'rms':12.2 }

values(self, keys=[], default=None)

Use:

  values( keys=None, default=None ) -> list of info dict values

Parameters:

keys ([str]) - give only values of these keys
default (any) - only used with keys!=[], default value for missing keys

Returns: [any]: all values (default) or values of requested keys (ordered)

get(self, key, default=None)

source code

Use:

  C.get(k[,default]) -> C.info[k] if C.info.has_key(k), else
                        default defaults to None.

Parameters:

key (str) - key to call
default (any) - default value if dictionary doesn't have key (default: None)

Returns: any OR None: dictionary value of key OR else default

lig(self, force=0, cache=1)

source code

Return ligand structure transformed. Use cached object, if available.

Parameters:

force (1|0) - force new transformation (default: 0)
cache (1|0) - cache transformed model (default: 1)

Returns: PCRModel: ligand model

writeLigand(self, fname, ter=0)

source code

Write transformed ligand to pdb file. Remove TER record for xplor usage (unless removeTer!=0).

Parameters:

fname (str) - output filename

ter (0|1|2) - option for how to treat the TER statement:

             - 0, don't write any TER statements (default)
             - 1, restore original TER statements
             - 2, put TER between all detected chains

writeReceptor(self, fname, ter=0)

source code

Write receptor to pdb without TER statement (unless removeTer!=0).

Parameters:

fname (str) - output file name

ter (0|1|2) - option for how to treat the TER statement:

             - 0, don't write any TER statements (default)
             - 1, restore original TER statements
             - 2, put TER between all detected chains

writeComplex(self, fname, ter=0)

source code

Write single pdb containing both receptor and ligand separated by END but not TER (unless ter!=0).

Parameters:

fname (str) - filename of pdb

ter - option for how to treat the TER statement:

             - 0, don't write any TER statements (default)
             - 1, restore original TER statements
             - 2, put TER between all detected chains

contactsOverlap(self, ref, cutoff=None)

source code

Fraction of overlapping residue-residue contacts between this and reference complex.

Parameters:

ref (Complex) - reference complex
cutoff (float) - maximal atom-atom distance, None .. previous setting

Returns: float: fraction of contacts shared between this and ref (normalized to number of all contacts)

contactsShared(self, reference, cutoff=None)

source code

Number of equal residue-residue contacts in this and reference complex.

Parameters:

reference (Complex) - reference complex
cutoff (float) - cutoff for atom-atom contact to be counted

Returns: int

the number or residue-residue contacts that are common to both this and reference:

 abs( N.sum( N.sum( contactMatrix_a - contactMatrix_b )))

contactsDiff(self, ref, cutoff=None)

source code

Number of different residue-residue contacts in this and reference complex.

Parameters:

ref (Complex) - to compare this one with
cutoff (float) - maximal atom-atom distance, None .. previous setting

Returns: int: number of contacts different in this and refererence complex.

fractionNativeContacts(self, ref, cutoff=None)

source code

Fraction of native residue-residue contacts.

Parameters:

ref (Complex) - native complex
cutoff (float) - maximal atom-atom distance, None .. previous setting

Returns: float: fraction of native contacts

fractionNativeSurface(self, cont, contRef)

source code

fraction of atoms/residues that are involved in any contacts in both complexes.

Parameters:

cont (matrix) - contact matrix
contRef (matrix) - reference contact matrix

Returns: (float, float): (fractRec, fractLig), fraction of atoms/residues that are involved in any contacts in both complexes

rmsLig(self, ref)

source code

Rms of ligand from reference ligand after superimposing the two receptors.

Parameters:

ref (Complex) - reference complex, must have identical atoms

Returns: float: ligand rmsd

Note: not implemented

rmsInterface(self, ref, cutoff=4.5, fit=1)

source code

Rmsd between this and reference interface. The interface is defined as any residue that has an atom which is within the distance given by |cutoff| from its partner.

Parameters:

ref (Complex) - reference complex
cutoff (float) - atom distance cutoff for interface residue definition (default: 4.5)
fit (1|0) - least-squares fit before calculating the rms (default: 1)

Returns: float: interface rmad

contactResPairs(self, cm=None)

source code

Get list of residue names paired up in contacts.

Parameters:

cm (matrix) - pre-calculated contact matrix (default: None)

Returns: [(str.str)..]: list of tuples [('N','G'), ('P','C')..]

contactResDistribution(self, cm=None)

source code

Count occurrence of residues in protein-protein interface.

Parameters:

cm (matrix) - pre-calculated contact matrix (default: None)

Returns: dict: {'A':3, 'C':1, .. } (20 standard amino acids)

contactTypeDistribution(self, cm=None)

source code

Count occurrence of residue types aromatic (a), charged(c), polar(p), else/unpolar(u).

Parameters:

cm (matrix) - pre-calculated contact matrix (default: None)

Returns: dict: {'a':4, 'c':5, 'p':12, 'u':4}

resPairCounts(self, cm=None)

source code

Count how often (all possible) res-res combinations occur in the given contacts.

Parameters:

cm (matrix) - pre-calculated contact matrix (default: None)

Returns: dict: {'AA':3,'AC':0, .. 'WW':2, 'WY':0 }

resContacts(self, cutoff=4.5, maskRec=None, maskLig=None, refComplex=None, force=0, cache=1, cache_pw=0)

source code

Matrix of all residue - residue contacts between receptor and ligand. Result is cached.

Parameters:

cutoff (float) - float/int, cutoff in \AA for atom-atom contact to be counted ( default 4.5; if None, last one used or 4.5)
maskRec ([1|0]) - atom mask, receptor atoms to consider
maskLig ([1|0]) - atom mask, ligand atoms to consider
force (0|1) - re-calculate even if cached matrix is available (default: 0)
cache (0|1) - cache result (default: 1)
cache_pw (0|1) - cache pairwise atom distances (default:0)
refComplex (Complex) - if <> None, 'reshape' contact matrix, so that residue positions match residue positions in matrices from castComplex. Useful if calling complex is a crystallized reference structure with slight sequence variations from the docked receptor and ligand.

Returns: array: residue contact matrix, 2-D array(residues_receptor x residues_ligand) of 0 or 1

__alignMatrixDimension(self, cm, thisSeq, castSeq, axis=0)

source code

Correct one dimension of contactMatrix by inserting and deleting columns, so that it can be later compared to contact matrices based on slightly different sequences.

Parameters:

cm (array) - contact matrix, 2D matrix of residue contacts recceptor x ligand sequence
thisSeq (string) - AA sequence of this dimension of the contactMatrix
castSeq (string) - AA sequence of this dimension in the other contact
axis (1|0) - which dimension to adapt (0=receptor, 1=ligand)

Returns: 2D array: contact matrix with residue contacts compatible to refSeq.

__unmaskedMatrix(self, contacts, rec_mask, lig_mask)

source code

Map contacts between selected rec and lig atoms back to all atoms matrix.

Parameters:

contacts (array) - contact matrix, array sum_rec_mask x sum_lig_mask
rec_mask ([1|0]) - atom mask
lig_mask ([1|0]) - atom mask

Returns: array: atom contact matrix, array N_atoms_rec x N_atoms_lig

__atomContacts(self, cutoff, rec_mask, lig_mask, cache)

source code

Intermolecular distances below cutoff after applying the two masks.

Parameters:

cutoff (float) - cutoff for atom-atom contact in \AA
rec_mask ([1|0]) - atom mask
lig_mask ([1|0]) - atom mask
cache (1|0) - cache pairwise atom distance matrix

Returns: array: atom contact matrix, array sum_rec_mask x sum_lig_mask

atomContacts(self, cutoff=4.5, rec_mask=None, lig_mask=None, cache=0, map_back=1)

source code

Find all inter-molecular atom-atom contacts between rec and lig

Parameters:

cutoff (float) - cutoff for atom - atom contact in \AA
rec_mask ([1|0]) - atom mask (default: all heavy)
lig_mask ([1|0]) - atom mask (default: all heavy)
cache (1|0) - cache pairwise atom distance matrix (default: 0)
map_back (1|0) - map masked matrix back to matrix for all atoms

Returns: array: atom contact matrix, Numpy array N(atoms_lig) x N(atoms_rec)

__resContacts(self, cutoff, maskRec=None, maskLig=None, cache=0)

source code

Find all inter-molecule residue-residue contacts between receptor and ligand. A contact between A and B is set if any heavy atom of A is within |cutoff| A of B.

Parameters:

cutoff (float) - distance cutoff in \AA
maskRec ([1|0]) - atom mask (default: all heavy)
maskLig ([1|0]) - atom mask (default: all heavy)
cache (1|0) - cache pairwise atom distance matrix to pw_dist (default:0)

Returns: array: residue contact matrix, 2-D Numpy N.array(residues_receptor x residues_ligand) where 1-contact, 0-no contact

__atom2residueMatrix(self, m)

source code

Reduce binary matrix of n x k atoms to binary matrix of i x j residues.

Parameters:

m (array) - atom contact matrix, array n x k with 1(contact) or 0(no contact)

Returns: array: residue contact matrix, 2-D numpy array(residues_receptor x residues_ligand)

equalAtoms(self, ref)

source code

Compare two complexes' atom content of receptor and ligand. Apply to SORTED models without HETATOMS. Coordinates are not checked.

Parameters:

ref (Complex) - reference complex

Returns: [1|0], [1|0], [1|0], [1|0]: (mask_rec, mask_lig, mask_rec_ref, mask_lig_ref), 4 atom masks for all equal atoms

Note: in some rare cases m1.equalAtoms( m2 ) gives a different result than m2.equalAtoms( m1 ). This is due to the used SequenceMatcher class.

compareAtoms(self, ref)

source code

Compare atom content and oder of rec and lig of 2 complexes. Get list of all atom positions of rec and lig in both complexes that have a matching atom (by residue and atom name) in the other complex. Indices for this complex are returned in the right oder to match the atom order of ref. I.e., in contrast to equalAtoms, castAtoms can equalize two complexes where atoms are ordered differently within the residues.

Parameters:

ref (Complex) - reference complex

Returns: [int], [int], [int], [int]: (ind_rec, ind_lig, ind_rec_ref, ind_lig_ref), 4 lists of indices

take(self, rec_pos, lig_pos)

source code

Get copy of this complex with given atoms of rec and lig.

Parameters:

rec_pos ([int]) - receptor indices to take
lig_pos ([int]) - ligand indices to take

Returns: Complex: new complex

compress(self, rec_mask, lig_mask)

source code

Compress complex using a rec and lig mask.

Parameters:

rec_mask ([1|0]) - atom mask
lig_mask ([1|0]) - atom mask

Returns: Complex: compressed complex

contPairScore(self, cutoff=6.0)

source code

Score interaction surface residue pairs. Info on Scoring matrix see Biskit.molUtils

Parameters:

cutoff (float) - CB-CB distance cutoff for defining a contact (default: 6.0)

Returns: float: score

interfaceArea(self, profiles=0, log=StdLog(), verbose=1)

source code

Calculate the difference between the surface area of the complex vs. its free components in square angstrom.

Parameters:

profiles (1|0 (default: 0)) - option to return the lig, rec and com profiles rather than the value (both absolute and relative values are returned)
log (Biskit.LogFile) - log file [STDOUT]
verbose (bool | int) - give progress report [1]

Returns: (float, float) or dict: AS area, MS area OR a dictionary of lig, rec and com profiles

foldXEnergy(self, force=1)

source code

Calculate E_rec and/or E_lig only if not given:

 E_com - (E_rec + E_lig).

Parameters:

force (1|0) - force calc of E_rec and E_lig

Returns: dict: dict with the different fold-X energy terms

conservationScore(self, cons_type='cons_ent', ranNr=150, log=StdLog(), verbose=1)

source code

Score of conserved residue pairs in the interaction surface. Optionally, normalized by radom surface contacts.

Parameters:

cons_type (str) - precalculated conservation profile name, see Biskit.PDBDope.
ranNr (int) - number of random matricies to use (default: 150)
log (Biskit.LogFile) - log file [STDOUT]
verbose (bool | int) - give progress report [1]

Returns: float: conservation score

rtTuple2matrix(self, r, t)

source code

Put rotation and translation matrix into single 4x4 matrix.

Parameters:

r (array) - rotation matric, array 3x3 of float
t (vector) - translation vector, array 1x3 of float

Returns: array: rotation/translation matrix, array 4x4 of float

extractLigandMatrix(self, lig)

source code

Find transformation matrix for rigid body-transformed ligand.

Parameters:

lig (PDBModel) - ligand model

Returns: array: rotation/translation matrix, array 4x4 of float

__findTransformation(self, x, y)

source code

Match two arrays by rotation and translation. Returns the rotation matrix and the translation vector. Back transformation: for atom i new coordinates will be:

   y_new[i] = N.dot(r, y[i]) + t

for all atoms in one step:

   y_new = N.dot(y, N.transpose(r)) + t

Parameters:

x (array) - coordinates
y (array) - coordinates

Returns: array, array: rotation matrix, translation vector

Author: Michael Habeck

__pairwiseDistances(self, u, v)

source code

pairwise distance between 2 3-D numpy arrays of atom coordinates.

Parameters:

u (array) - coordinates
v (array) - coordinates

Returns: array: Numpy array len(u) x len(v)

Author: Wolfgang Rieping.

__extractLigandMatrix(self, fcomplex)

source code

Compare structure from hex complex with original ligand pdb and store transformation matrix of ligand in self.ligandMatrix.

Parameters:

fcomplex (complec) - pdb file with hex complex

Returns: (array, array): rotation matrix and translation matrix as tuple

Class Complex

__init__(self, rec_model=None, lig_model=None, ligMatrix=None, info={}) (Constructor)

version(self)

__getstate__(self)

__getitem__(self, key) (Indexing operator)

__setitem__(self, key, v) (Index assignment operator)

__delitem__(self, key) (Index deletion operator)

__contains__(self, key) (In operator)

__setstate__(self, state)

__defaults(self)

keys(self)

has_key(self, k)

values(self, keys=[], default=None)

get(self, key, default=None)

rec(self)

lig(self, force=0, cache=1)

model(self)

ligMatrix(self)

setLigMatrix(self, m)

getInfo(self)

writeLigand(self, fname, ter=0)

writeReceptor(self, fname, ter=0)

writeComplex(self, fname, ter=0)

slim(self)

contactsOverlap(self, ref, cutoff=None)

contactsShared(self, reference, cutoff=None)

contactsDiff(self, ref, cutoff=None)

fractionNativeContacts(self, ref, cutoff=None)

fractionNativeSurface(self, cont, contRef)

rmsLig(self, ref)

rmsInterface(self, ref, cutoff=4.5, fit=1)

contactResPairs(self, cm=None)

contactResDistribution(self, cm=None)

contactTypeDistribution(self, cm=None)

resPairCounts(self, cm=None)

loadResContacts(self)

resContacts(self, cutoff=4.5, maskRec=None, maskLig=None, refComplex=None, force=0, cache=1, cache_pw=0)

__alignMatrixDimension(self, cm, thisSeq, castSeq, axis=0)

__unmaskedMatrix(self, contacts, rec_mask, lig_mask)

__atomContacts(self, cutoff, rec_mask, lig_mask, cache)

atomContacts(self, cutoff=4.5, rec_mask=None, lig_mask=None, cache=0, map_back=1)

__resContacts(self, cutoff, maskRec=None, maskLig=None, cache=0)

__atom2residueMatrix(self, m)

equalAtoms(self, ref)

compareAtoms(self, ref)

take(self, rec_pos, lig_pos)

compress(self, rec_mask, lig_mask)

contPairScore(self, cutoff=6.0)

interfaceArea(self, profiles=0, log=StdLog(), verbose=1)

prosa2003Energy(self)

foldXEnergy(self, force=1)

conservationScore(self, cons_type='cons_ent', ranNr=150, log=StdLog(), verbose=1)

rtTuple2matrix(self, r, t)

extractLigandMatrix(self, lig)

__findTransformation(self, x, y)

__pairwiseDistances(self, u, v)

__extractLigandMatrix(self, fcomplex)

init(self, rec_model=None, lig_model=None, ligMatrix=None, info={})
(Constructor)

getstate(self)

getitem(self, key)
(Indexing operator)

setitem(self, key, v)
(Index assignment operator)

delitem(self, key)
(Index deletion operator)

contains(self, key)
(In operator)

setstate(self, state)