def initialize(self, params):
"""
Copy the parameters that ContactMaster is passing in as dict into
fields of this class.
@param params: defined in L{ContactMaster}
@type params: dict
"""
self.ferror = params['ferror']
self.log = StdLog()
if params['log']: ## log to same file as master
self.log = LogFile(self.flog)
self.verbose = params['verbose']
## reference complex data
self.c_ref_res_4_5 = self.c_ref_atom_4_5 = None
self.c_ref_atom_10 = None
self.mask_rec = self.mask_lig = None
self.mask_interface = self.mask_interface_bb = None
self.ref_interface_model = self.ref_interface_model_bb = None
## reduced models and reduced reference contacts
self.reduced_recs = self.reduced_ligs = None
self.c_ref_ratom_10 = None
## reference residue / atom contact matrices
if params.get('c_ref_res_4_5', None):
self.c_ref_res_4_5 = MU.unpackBinaryMatrix(params['c_ref_res_4_5'])
self.c_ref_atom_4_5 = MU.unpackBinaryMatrix(
params['c_ref_atom_4_5'])
self.c_ref_atom_10 = MU.unpackBinaryMatrix(params['c_ref_atom_10'])
## atom masks for casting
if params.get('mask_rec', None):
self.mask_rec = MU.unpackBinaryMatrix(params['mask_rec'])
self.mask_lig = MU.unpackBinaryMatrix(params['mask_lig'])
## for interface rms calculation
if params.get('mask_interface', None):
self.mask_interface = MU.unpackBinaryMatrix(
params['mask_interface'])
self.mask_interface_bb = MU.unpackBinaryMatrix(
params['mask_interface_bb'])
self.ref_interface_model = params['ref_interface_model']
self.ref_interface_model_bb = params['ref_interface_model_bb']
## reduced rec and lig models indexed by source
self.reduced_recs = params['reduced_recs']
self.reduced_ligs = params['reduced_ligs']
if params.get('c_ref_ratom_10', None):
self.c_ref_ratom_10 = MU.unpackBinaryMatrix(
params['c_ref_ratom_10'])
## only calculate certain values
self.force = params.get('force', [])
def test_ErrorHandler(self):
"""ErrorHandler test"""
from Biskit.LogFile import LogFile
self.err_log = LogFile(self.f_out)
self.e = ErrorHandler(log=self.err_log)
self.e.warning('A warning')
if self.local:
print 'An error log file was written to %s' % self.f_out
lines = open(self.err_log.fname).readlines()
self.assertEquals(lines[-1], 'Warning (ignored): A warning\n')
def prepare(self):
import tempfile
import shutil
from Biskit.LogFile import LogFile
self.query = T.testRoot() + '/Mod/project/target.fasta'
self.outfolder = tempfile.mkdtemp('_test_TemplateSearcher')
shutil.copy(self.query, self.outfolder)
## log file
self.f_out = self.outfolder + '/TemplateSearcher.log'
self.l = LogFile(self.f_out, mode='w')
if self.local: self.l = StdLog()
self.f_target = self.outfolder + '/target.fasta'
def prepare(self):
import tempfile
import shutil
from Biskit.LogFile import LogFile
## temp output directory
self.outfolder = tempfile.mkdtemp( '_test_TemplateCleaner' )
os.mkdir( self.outfolder +'/templates' )
## log file
self.f_out = self.outfolder + '/TemplateCleaner.log'
self.l = None
if not self.local:
self.l = LogFile( self.f_out, mode='w')
shutil.copytree( T.testRoot() + '/Mod/project/templates/nr',
self.outfolder + '/templates/nr' )
def initialize(self, params):
"""
Expects::
{'ferror':str,
'trajMap':[int],
'only_off_diagonal':1|0,
'only_cross_member':1|0}
@param params: parameters passed over from the L{TrajFlexMaster}
@type params: dict
"""
self.__dict__.update( params )
if not self.ferror:
self.errorLog = ErrLog()
else:
self.errorLog = LogFile( self.ferror, mode='a' )
self.frame_cache = {}
def __init__(self,
traj1,
traj2=None,
hosts=hosts.cpus_all,
niceness=hosts.nice_dic,
show_output=0,
add_hosts=0,
log=None,
slaveLog=None,
verbose=1,
only_off_diagonal=1,
only_cross_member=0):
"""
@param traj1: Trajectory or EnsembleTraj, traj1 and 2 must have the
same atom content. If only traj1 is given, the pairwise
rms is calculated between its frames.
@type traj1: Trajectory OR EnsembleTraj
@param traj2: see traj1
@type traj2: Trajectory OR EnsembleTraj
## @param aMask: atom mask, consider only subset of atoms (default: all)
## @type aMask: [0|1]
@param hosts: slave hosts to be used
(default: L{Biskit.PVM.hosts.cpus_all})
@type hosts: [str]
@param niceness: { str:int, 'default':int }, nice value for each
host
@type niceness: dict
@param show_output: open xterm window for each slave (default: 0)
@type show_output: 0|1
@param add_hosts: add hosts to PVM before starting (default: 0)
@type add_hosts: 1|0
@param log: log file for master (default: None-> StdErr )
@type log: LogFile
@param slaveLog: slave log (default: None->'TrajFlexSlave_errors.log')
@type slaveLog: LogFile
@param verbose: print progress infos (default: 1)
@type verbose: 0|1
@param only_off_diagonal: Don't calculate self-rms of frames.
Only considered for a single trajectory
(default: 1)
@type only_off_diagonal: 0|1
@param only_cross_member: Don't calculate rms between frames from
same member trajectory only considered for
a single trajectory(requires EnsembleTraj)
(default: 0)
@type only_cross_member: 0|1
"""
## create temporary folder accessible to all slaves
self.outFolder = tempfile.mktemp('trajFlex_',
dir=settings.tempDirShared)
os.mkdir(self.outFolder)
self.log = log or ErrLog()
self.slaveLog = slaveLog or LogFile('TrajFlexSlave_errors.log')
self.verbose = verbose
self.hosts = hosts
self.traj_1 = traj1
self.traj_2 = traj2
self.only_off_diagonal = traj2 is None and only_off_diagonal
self.only_cross_member = traj2 is None and only_cross_member
self.trajMap = None
if traj2 is None:
self.trajMap = self.memberMap(traj1)
## pickle chunks of coordinate frames
frame_files_1 = self.__dumpFrames(traj1, self.outFolder, 'traj1')
## None if traj2 is None
frame_files_2 = self.__dumpFrames(traj2, self.outFolder, 'traj2')
## assemble job dict
self.tasks = self.__taskDict(frame_files_1, frame_files_2)
chunk_size = 1
TrackingJobMaster.__init__(self,
self.tasks,
chunk_size,
hosts,
niceness,
self.slave_script,
show_output=show_output,
verbose=verbose,
add_hosts=add_hosts)
