diffPotTools
index
/home/schwitrs/xplor/python/diffPotTools.py


 
tools to create a potential term restraining the shape of protein using
components of rotation diffusion tensor. Together with facilities to 
fit NMR relaxation data.

 
Classes
       
builtins.object
FitResults
realx_datum
v_e

 
class FitResults(builtins.object)
     Methods defined here:
__init__(self)
Initialize self.  See help(type(self)) for accurate signature.

Data descriptors defined here:
__dict__

 
dictionary for instance variables (if defined)
__weakref__

 
list of weak references to the object (if defined)

 
class realx_datum(builtins.object)
     Methods defined here:
__init__(self)
Initialize self.  See help(type(self)) for accurate signature.

Data descriptors defined here:
__dict__

 
dictionary for instance variables (if defined)
__weakref__

 
list of weak references to the object (if defined)

 
class v_e(builtins.object)
     Methods defined here:
__init__(self)
Initialize self.  See help(type(self)) for accurate signature.

Data descriptors defined here:
__dict__

 
dictionary for instance variables (if defined)
__weakref__

 
list of weak references to the object (if defined)

 
Functions
       
Target_relax_function(in_param, ifp)
target function for fitting
addTmPAtoms(tpOatom=None, tpXatom=None, tpYatom=None, resid=None, segid=None, pot=None, mass=1000)
create psf and initial coordinates for pseudo atoms used for optimizing
correlation times tau_c, tau_t and tau_i
analyze(potList)
perform analysis of DiffPot terms and return nicely formatted summary
calcR2R1ratio(Freq=None, Ing=None, Rsel='resid 1:1000')
Subrutine which simulates NMR relaxation data                                         
INPUT:                                                                                 
Freq is spectrometer frequency in GHz                                                  
Ing is a vector of diffusion tensor parameters which will be used                      
    for relaxation rates calculation                                                   
    Ing=[Dx, Dy, Dz, alpha, betha, gamma]                                              
    for axial mode Ing=[Dxy, Dz, betha, alpha]                                 
    for iso mode   Ing=[Dxyz]                                                          
    Dx, Dy, Dz are in inverse nanoseconds, alpha, betha, and
    gamma are in degrees
    Ing is in the same format as results.Fit_vector                                    
res_sel is selection of residues in a format 'resid N:M' where
    integers N and M specify the range of residues used to
    simulate relaxation data                   
RETURN:                                                                                        
    out_dat list in format [resNum, R2/R1]
calc_relax_data(Fr=None, InG=None, res_sel=None)
# Subrutine which simulates NMR relaxation data                                                
# INPUT:                                                                                        
# Fr is spectrometer frequency in GHz                                                   
# InG is a vector of diffusion tensor parameters which will be used                     
#     for relaxation rates calculation                                                  
#     InG=[Dx, Dy, Dz, alpha, betha, gamma]                                             
#     for axial mode InG=[Dxy, Dz, betha, alpha]                                        
#     for iso mode   InG=[Dxyz]                                                         
#     Dx, Dy, Dz are in inverse nanoseconds, alpha, betha, and gamma are in degrees
#     InG is in the same format as results.Fit_vector                                   
# res_sel is selection of residues in a format 'resid N:M' where integers N and M       
#     specify the range of residues used to simulate relaxation data                    
# RETURN:                                                                                       
#     simulated_data list of realx_datum() structures containing R1, R2, and R2/R1      
#     for details see declaration of FitResults() class below.
create_DiffPot(name, sel='known and (not PSEUDO)', temperature=293, addAtoms=False, mass=1000, link_to=None)
create an instance of an diffPot.DiffPot object
 
Arguments:                                                                                                                                      
name        - is an instance name of a diffPot object.                                                                                  
sel         - is selection of atoms which will be used to create
              protein surface tessellation by surfTessellation object   
              This parameter is used only if the created relaxRatioPot
              instance is not using a surfTessellation 
              borrowed from another potential, i.e. link_to=None, in
              which case sel argument is omitted.
temperature - the nominal experimental temperature in Kelvins                                                                   
addAtoms    - flag wich specifies whether the pseudo atoms for
              temperature optimization are created or not. Default
              setting does not assume temperature optimization. The
              state addAtoms=True creates pseudo atoms
mass        - value for the mass of the pseudo atoms                                                                            
link_to     - used to link the potential to surfTessellation created
              by another potential or to a standing alone
              surfTessellation object. The default setting that
              external surfTessellation is not given, and, therefore,
              creates a new surfTessellation using sel atom selection.
 
returns a diffPot object
diffValuesEuler(dT_e)
given a diffusion tensor (in 100*[inverse ns]) return the
eigenvalues and Euler angles corresponding to the rotation matrix
formed from the eigenvectors 
in a list:
 
 [ a,b,c, gamma, beta, alpha ]
 
 The eigenvalues are scaled by a factor of 0.1 such that they have
units of (10 * [inverse ns]).
estimate_Dxyz(in_data, omega_1)
Estimates eigenvalue of diffusion tensor for given set of initial data
 using assumption of isotropic tumbling model
fill_in_relax_datum(datum, datum_line, pattern)
# service subroutine which distributes 
# the list of given data into given 
# rerealx_datum structure according given pattern
fill_in_results(results, in_Fit_res_list, mode, dlina, dT_e)
fitRelaxData(data_in=None, Fr=None, InG=None, mode='full', inc_sel='known', Err_calc=1)
Function which fits NMR NH relaxation data using Nelder-Mead downhill
 (amoeba) simplex method                               
 
Arguments:
data_in  - list of realx_datum structures which is generated by
           readInRelaxData                                              
Fr       - is the spectrometer frequency in MHz                                                                                                  
mode     - specifies the model for relaxation data fitting                                                                                       
             the available options for mode are:                                                                                         
             full  - is fully anisotropic tensor                                                                                         
             axial - is axially symmetric tensor                                                                                                 
             iso   - is spherically symmetric tensor                                                                                             
InG      - optional list of initial guess parameters for fitting
           routine which should be compatiable with mode settings:                                                                                       
    for full mode  InG=[Dx, Dy, Dz, alpha, betha, gamma]                                                                         
    for axial mode InG=[Dxy, Dz, betha, alpha]                                                                                   
    for iso mode   InG-[Dxyz]                                                                                                            
    Dx, Dy, Dz are in inverse nanoseconds, alpha, betha, and gamma are
      in degrees                                      
    if InG is not given then it is estimated for the loaded protein
    coordinates  using facilities in diffPot
                                                                                                         
inc_sel  - specifies the residues which will which will be included
           into the fit when relaxation data are available in data_in.
           Could be either a text string or an atom selection object.            
Err_calc - number of bootstrap cycles for error calculations                                                                     
    default settings Err_calc=1 which means that only the original data
    is used: no synthetic data sets prepared and no confidence
    intervals calculated. Bootstrap error estimations is lengthy. For
    robust estimation of confidence intervals the number of bootstrap
    cycles, Err_calc, should be equal to the number of R2/R1 relaxation
    data points in the data set used for fitting, len(in_relax).
    However to get an estimate of the order of magnitude for confidence
    intervals one may use about 20% of this number.   
 
Returns:                                                                                                                                 
    list_results[0], a python structure containing results of fitting
    for the original data set of relaxation data 
    for details see declaration of FitResults() class below.
make_ratio(datum)
For given realx_datum structure constructs a ratio of relaxation
rates R2/R1.
meanTemperature(term)
term can be a single potential term, or a list of terms
merge2values(value1, err1, value2, err2)
mergeRelaxData(data_merged)
# subroutine with analyzes give list of realx_datum structures,        
# sorts the list according to the residue number,                       
# finds items with the same residue numbers,                            
# and merges them in a single relaxa_datum.
readInRST(restraints=None)
# routine like above which starts from reading restraints
# for use in test file
readInRelaxData(file, pattern=['resid', 'ratio', 'ratio_err'], verbose=False)
# pattern specifies the way the data given in the file
# possible keys for pattern are :
# resid         - residue number
# ratio         - ratio of relaxation rates
# ratio_err     - errors in ration of relaxation rates
# R1            - longitudinal relaxation rate
# R1_err        - error in longitudinal relaxation rate
# R2            - transverse relaxation rate
# R2_err        - error in transverse relaxation rate 
# skip       - skip entry
# T1            - longitudinal relaxation time
# T1_err        - error in longitudinal relaxation time
# T2            - transverse relaxation time
# T2_err        - error in transverse relaxation time
# NOE           - heteronuclear NOE
# NOE_err       - error in heteronuclear NOE
registerTerm(term)
add the given DiffPot object to a list associated with its Simulation.
These objects will be automatically processed by topologySetup and
massSetup.
remove_position_from_list(l_st, p_sn)
reset_DiffPot_temp(pot=None, temperature=None)
rms_relax_function(in_param, ifp)
showFitResults(results)
show_relax_datum(datum)
debugging subroutine printing out the content of realx_datum structure
sqrt(x, /)
Return the square root of x.
str2num(line=None)
tensParams(Dx, Dy, Dz)
Given eigenvalues of a diffusion tensor, return a tuple
containing (tau, anisotropy , rhombicity), where tau is the
correlation time in ns.
topologySetup(ivm, list=[])
configure the given ivm.IVM object's topology setup using the
freedom string for each DiffPot in list.
This function should be called prior to
ivm.IVM.autoTorsion() or protocol.torsionTopology()

 
Data
        default_resid = 2700
default_segid = ''
psfTmPTemplate = '\nstructure\nPSF\n\n 1 !NTITLE\n REMARKS preP... 1 0 !NGRP\n 0 0 0\n\nend\n'
radiusMap = {'C': 1.85, 'H': 1.0, 'N': 1.75, 'O': 1.6, 'P': 2.05, 'S': 2.0}
registeredTerms = {}