def Mtz2sca(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
class Mtz2scaWrapper(DriverInstance.__class__):
'''A wrapper class for Mtz2sca.'''
def __init__(self):
DriverInstance.__class__.__init__(self)
self.set_executable('mtz2sca')
self._hklin = None
self._scaout = None
return
def set_hklin(self, hklin):
self._hklin = hklin
return
def set_scaout(self, scaout):
self._scaout = scaout
return
def mtz2sca(self):
self.add_command_line(self._hklin)
self.add_command_line(self._scaout)
self.start()
self.close_wait()
self.check_for_errors()
return
return Mtz2scaWrapper()
def Sortmtz(DriverType = None):
'''Create a sortmtz instance based on the passed in (string) DriverType.
If this is None (not specified) then just use whatever the DriverFactory
produces.'''
# Instantiate the appropriate kind of Driver to use in here
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class SortmtzWrapper(CCP4DriverInstance.__class__):
'''A wrapper for Sortmtz, using the CCP4Driver.'''
def __init__(self):
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('sortmtz')
def sort(self):
self.check_hklin()
self.check_hklout()
self.set_task('Sort reflections from %s to %s' % \
(os.path.split(self.get_hklin())[-1],
os.path.split(self.get_hklout())[-1]))
self.start()
self.input('H K L M/ISYM BATCH')
self.close_wait()
return self.get_ccp4_status()
return SortmtzWrapper()
def Truncate(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class TruncateWrapper(CCP4DriverInstance.__class__):
def __init__(self):
# generic things
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('truncate')
# specific things
self._nres = None
return
def set_nres(self, nres):
self._nres = nres
return
def truncate(self):
self.check_hklin()
self.check_hklout()
self.start()
if self._nres:
self.input('nres %d' % self._nres)
self.close_wait()
self.check_for_errors()
self.check_ccp4_errors()
return
return TruncateWrapper()
def Freerflag(DriverType = None):
'''Create a Freerflag instance based on the passed in Driver type.'''
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class FreerflagWrapper(CCP4DriverInstance.__class__):
'''A wrapper class for adding freer flags to mtz files.'''
def __init__(self):
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('freerflag')
def freerflag(self):
self.check_hklin()
self.check_hklout()
self.set_task('Adding freer flag column to %s => %s' % \
(os.path.split(self.getHklin())[-1],
os.path.split(self.getHklout())[-1]))
self.start()
self.close_wait()
return self.get_ccp4_status()
return FreerflagWrapper()
def Freerflag(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class FreerflagWrapper(CCP4DriverInstance.__class__):
def __init__(self):
# generic things
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('freerflag')
return
def freerflag(self):
self.check_hklin()
self.check_hklout()
self.start()
self.close_wait()
self.check_for_errors()
self.check_ccp4_errors()
return
return FreerflagWrapper()
def Pointless(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class PointlessWrapper(CCP4DriverInstance.__class__):
def __init__(self):
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('pointless')
self._cc = 0.0
self._reindex = None
return
def check_origin(self):
self.check_hklin()
self.check_xyzin()
self.check_hklout()
self.start()
self.close_wait()
self.check_for_errors()
self.check_ccp4_errors()
# get the reindexing operation which was applied... assert that
# this was the one with the highest correlation coefficient
# which I think is written out first
collect = False
for record in self.get_all_output():
if 'No possible alternative indexing' in record:
self._cc = 1.0
self._reindex = 'h,k,l'
return self.get_hklin()
if 'Alternative reindexing' in record and 'CC' in record:
collect = True
continue
if collect:
self._reindex = record.split()[0][1:-1]
self._cc = float(record.split()[1])
collect = False
return self.get_hklout()
def get_cc(self):
return self._cc
def get_reindex(self):
return self._reindex
return PointlessWrapper()
def testnoprogram(self):
'''Test how the driver handles the executable not existing.'''
d = DriverFactory.Driver()
# UNIT TEST now much simpler, see changes in DefaultDriver detailed
# 1/SEP/06 - however, should this also test against the environment
# variable to switch off this test?
self.assertRaises(NotAvailableError, d.set_executable, 'nosuchprogram')
def Unique(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class UniqueWrapper(CCP4DriverInstance.__class__):
def __init__(self):
# generic things
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('unique')
# local things
self._cell = None
self._symmetry = None
self._resolution = None
return
def set_cell(self, cell):
self._cell = cell
return
def set_symmetry(self, symmetry):
self._symmetry = symmetry
return
def set_resolution(self, resolution):
self._resolution = resolution
return
def unique(self):
self.check_hklout()
if not self._cell:
raise RuntimeError, 'cell not assigned'
if not self._symmetry:
raise RuntimeError, 'symmetry not assigned'
if not self._resolution:
raise RuntimeError, 'resolution not assigned'
self.start()
self.input('cell %f %f %f %f %f %f' % self._cell)
self.input('symmetry "%s"' % self._symmetry)
self.input('resolution %f' % self._resolution)
self.input('labout F=F_UNIQUE SIGF=SIGF_UNIQUE')
self.close_wait()
self.check_for_errors()
self.check_ccp4_errors()
return
return UniqueWrapper()
def Empty(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
class EmptyWrapper(DriverInstance.__class__):
'''A wrapper class for Empty.'''
def __init__(self):
DriverInstance.__class__.__init__(self)
self.set_executable('empty')
return EmptyWrapper()
def Empty(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class EmptyWrapper(CCP4DriverInstance.__class__):
def __init__(self):
# generic things
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('empty')
return EmptyWrapper()
def F2mtz(DriverType = None):
'''Create a F2mtz instance based on the passed in Driver type.'''
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class F2mtzWrapper(CCP4DriverInstance.__class__):
'''A wrapper class for converting reflections to mtz.'''
def __init__(self):
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('f2mtz')
self._cell = None
self._symmetry = None
def set_cell(self, cell):
self._cell = cell
def set_symmetry(self, symmetry):
self._symmetry = symmetry
def f2mtz(self):
self.check_hklin()
self.check_hklout()
if self._symmetry is None:
raise RuntimeError, 'symmetry not set'
if self._cell is None:
raise RuntimeError, 'cell not set'
self.set_task('Converting reflections to mtz %s => %s' % \
(os.path.split(self.getHklin())[-1],
os.path.split(self.getHklout())[-1]))
self.start()
self.input('cell %f %f %f %f %f %f' % \
tuple(map(float, self._cell)))
self.input('symmetry %s' % self._symmetry)
self.input('labout H K L FP FOM PHIB SIGFP')
self.input('CTYPOUT H H H F W P Q')
self.close_wait()
return self.get_ccp4_status()
return F2mtzWrapper()
def Scala(DriverType=None):
'''Create a Scala instance based on the requirements proposed in the
DriverType argument.'''
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class ScalaWrapper(CCP4DriverInstance.__class__):
'''A wrapper for Scala, using the CCP4-ified Driver.'''
def __init__(self):
# generic things
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('scala')
self._scalepack = None
def set_scalepack(self, scalepack):
self._scalepack = scalepack
def scale(self):
self.check_hklin()
self.check_hklout()
self.set_task('Scale reflections from %s to %s' % \
(os.path.split(self.get_hklin())[-1],
os.path.split(self.get_hklout())[-1]))
if self._scalepack:
self.add_command_line('SCALEPACK')
self.add_command_line(self._scalepack)
self.start()
if self._scalepack:
self.input('output polish unmerged')
self.input('resolution 1.65')
self.input(
'scales rotation spacing 5 secondary 6 bfactor on tails')
self.input('cycles 20')
self.input('anomalous on')
self.input('sdcorrection full 1.0 15.0 0.02')
self.input('sdcorrection partial 1.0 15.0 0.00')
self.close_wait()
return self.get_ccp4_status()
return ScalaWrapper()
def Reindex(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class ReindexWrapper(CCP4DriverInstance.__class__):
def __init__(self):
# generic things
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('reindex')
# reindex specific things
self._symmetry = None
self._reindex_op = None
return
def set_symmetry(self, symmetry):
self._symmetry = symmetry
return
def set_reindex_op(self, reindex_op):
self._reindex_op = reindex_op
return
def reindex(self):
self.check_hklin()
self.check_hklout()
if not self._symmetry and not self._reindex_op:
raise RuntimeError, 'assign either spacegroup or reindex'
self.start()
if self._symmetry:
self.input('symmetry %s' % self._symmetry)
if self._reindex_op:
self.input('reindex %s' % self._reindex_op)
self.close_wait()
self.check_for_errors()
self.check_ccp4_errors()
return
return ReindexWrapper()
def Shelxe(DriverType=None):
'''Create a Shelxe instance based on the DriverType.'''
DriverInstance = DriverFactory.Driver(DriverType)
class ShelxeWrapper(DriverInstance.__class__):
'''A wrapper class for Shelxe.'''
def __init__(self):
DriverInstance.__class__.__init__(self)
self.set_executable('shelxe')
self._name = None
self._solvent = 0.0
def set_solvent(self, solvent):
self._solvent = solvent
return
def set_name(self, name):
self._name = name
return
def phase(self):
'''Actually compute the phases from the heavy atom locations.'''
self.add_command_line('%s' % self._name)
self.add_command_line('%s_fa' % self._name)
self.add_command_line('-h')
self.add_command_line('-s%f' % self._solvent)
self.add_command_line('-m20')
self.start()
self.close()
while True:
line = self.output()
if not line:
break
print line[:-1]
return ShelxeWrapper()
def Shelxe(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
class ShelxeWrapper(DriverInstance.__class__):
def __init__(self):
DriverInstance.__class__.__init__(self)
self.set_executable('shelxe')
self._name = None
self._solvent = 0.0
self._enantiomorph = False
def set_solvent(self, solvent):
self._solvent = solvent
return
def set_name(self, name):
self._name = name
return
def set_enantiomorph(self, enantiomorph=True):
self._enantiomorph = enantiomorph
return
def shelxe(self):
self.add_command_line('%s' % self._name)
self.add_command_line('%s_fa' % self._name)
self.add_command_line('-h')
self.add_command_line('-s%f' % self._solvent)
self.add_command_line('-m20')
if self._enantiomorph:
self.add_command_line('-i')
self.start()
self.close_wait()
# read the CC's and what-have-you from the lst file
return
return ShelxeWrapper()
def Pdbset(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class PdbsetWrapper(CCP4DriverInstance.__class__):
def __init__(self):
# generic things
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('pdbset')
# specific things
self._cell = None
self._symmetry = None
return
def set_cell(self, cell):
self._cell = cell
return
def set_symmetry(self, symmetry):
self._symmetry = symmetry
return
def pdbset(self):
self.check_xyzin()
self.check_xyzout()
if not self._cell:
raise RuntimeError, 'cell not assigned'
if not self._symmetry:
raise RuntimeError, 'symmetry not assigned'
self.start()
self.input('cell %f %f %f %f %f %f' % self._cell)
self.input('symmetry "%s"' % self._symmetry)
self.close_wait()
self.check_for_errors()
self.check_ccp4_errors()
return
return PdbsetWrapper()
def generateXIA2CORE(self, _edObject=None, executable=None):
"""Factory method to create and configure a xia2core Driver
instance."""
if executable is None:
executable = self.getExecutable()
if executable is None:
raise RuntimeError, 'no executable set in factory'
EDVerbose.DEBUG("Driver created for executable %s" % executable)
driver = DriverFactory.Driver(self.__strConfigXIA2COREType)
driver.set_executable(executable)
driver.set_working_directory(self.getWorkingDirectory())
return driver
def testsignalabrt(self):
'''Test the abort signal.'''
d = DriverFactory.Driver()
try:
d.set_executable('EPAbrt')
d.start()
d.close()
while True:
line = d.output()
if not line:
break
except RuntimeError, e:
# this should probably error
self.assertEqual(str(e), 'child aborted')
return
def testsignalkill(self):
'''Test the kill signal.'''
d = DriverFactory.Driver()
d.set_executable('EPKill')
d.start()
# in some cases the termination of the child process may be caught
# this is OK
try:
d.close()
except RuntimeError, re:
# this could have one or more records...
# self.assertEqual(str(re), 'child process has termimated')
self.assertEqual(1, 1)
return
def testsignalsegv(self):
'''Test the segmentation fault signal.'''
d = DriverFactory.Driver()
try:
d.set_executable('EPSegv')
d.start()
d.close()
while True:
line = d.output()
if not line:
break
except RuntimeError, e:
self.assertEqual(str(e), 'child segmentation fault')
return
def Cad(DriverType = None):
'''Create a Cad instance based on the passed in Driver type.'''
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class CadWrapper(CCP4DriverInstance.__class__):
'''A wrapper class for rewriting mtz files.'''
def __init__(self):
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('cad')
def cad(self):
self.check_hklin()
self.check_hklout()
# this has to be passed in on a HKLIN1 token
hklin = self.get_hklin()
self.set_hklin(None)
self.add_command_line('hklin1')
self.add_command_line(hklin)
self.set_task('Rewriting reflections %s => %s' %
` (os.path.split(hklin)[-1],
` os.path.split(self.getHklout())[-1]))
self.start()
self.input('labin file 1 E1=FP E2=FOM E3=PHIB E4=SIGFP')
self.input('labout E1=FP E4=SIGFP E3=PHIB E2=FOM')
self.close_wait()
# CAD eof looks like "Normal Termination of CAD" - Bummer!
return self.get_ccp4_status().replace(' of CAD', '')
return CadWrapper()
def Shelxd(DriverType=None):
'''Create a Shelxd instance based on the DriverType.'''
DriverInstance = DriverFactory.Driver(DriverType)
class ShelxdWrapper(DriverInstance.__class__):
'''A wrapper class for Shelxd.'''
def __init__(self):
DriverInstance.__class__.__init__(self)
self.set_executable('shelxd')
self._name = None
def set_name(self, name):
self._name = name
return
def find_sites(self):
'''Find the HA sites.'''
self.add_command_line('%s_fa' % self._name)
self.start()
# self.close_wait()
self.close()
while True:
line = self.output()
if not line:
break
print line[:-1]
return
return ShelxdWrapper()
def testsimple(self):
'''Test the Driver class with the simple ExampleProgram.'''
d = DriverFactory.Driver()
d.set_executable('ExampleProgram')
d.start()
d.close()
results = []
while True:
line = d.output()
if not line:
break
results.append(line.strip())
self.assertEqual(len(results), 10)
self.assertEqual(results[0], 'Hello, world!')
def Shelxc(DriverType = None):
'''Create a Shelxc instance based on the DriverType.'''
DriverInstance = DriverFactory.Driver(DriverType)
class ShelxcWrapper(DriverInstance.__class__):
'''A wrapper class for Shelxc.'''
def __init__(self):
DriverInstance.__class__.__init__(self)
self.set_executable('shelxc')
# input files
self._infl = None
self._lrem = None
self._peak = None
self._hrem = None
self._sad = None
self._native = None
# heavy atom information
self._nha = 0
# cell and symmetry
self._cell = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
self._symmetry = None
# naming information
self._name = None
def set_cell(self, cell):
self._cell = cell
return
def set_symmetry(self, symmetry):
self._symmetry = symmetry
return
def set_nha(self, nha):
self._nha = nha
return
def set_peak(self, peak):
self._peak = peak
return
def set_infl(self, infl):
self._infl = infl
return
def set_lrem(self, lrem):
self._lrem = lrem
return
def set_hrem(self, hrem):
self._hrem = hrem
return
def set_native(self, native):
self._native = native
return
def set_sad(self, sad):
self._sad = sad
return
def set_name(self, name):
self._name = name
return
def prepare(self):
'''Prepare the experimental phasing data.'''
task = 'Preparing experimental phasing data using:\n'
if self._peak:
task += 'PEAK %s\n' % self._peak
if self._infl:
task += 'INFL %s\n' % self._infl
if self._hrem:
task += 'HREM %s\n' % self._hrem
if self._lrem:
task += 'LREM %s\n' % self._lrem
if self._sad:
task += 'SAD %s\n' % self._sad
if self._native:
task += 'NATIVE %s\n' % self._native
self.setTask(task)
self.add_command_line(self._name)
self.start()
if self._peak:
self.input('PEAK %s\n' % self._peak)
if self._infl:
self.input('INFL %s\n' % self._infl)
if self._hrem:
self.input('HREM %s\n' % self._hrem)
if self._lrem:
self.input('LREM %s\n' % self._lrem)
if self._sad:
self.input('SAD %s\n' % self._sad)
if self._native:
self.input('NATIVE %s\n' % self._native)
self.input('CELL %f %f %f %f %f %f' % tuple(self._cell))
self.input('SPAG %s' % self._symmetry)
self.input('FIND %d' % self._nha)
self.input('NTRY 20')
self.input('MIND -3.5')
self.close()
while True:
line = self.output()
if not line:
break
print line[:-1]
return
return ShelxcWrapper()
def Mosflm_integrate(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
class Mosflm_integrateWrapper(DriverInstance.__class__):
def __init__(self):
# generic things
DriverInstance.__class__.__init__(self)
self.set_executable('ipmosflm')
self._template = None
self._directory = None
self._beam = None
self._limits_dict = {}
self._images = []
self._spacegroup = None
self._mosaic = None
self._matrix = None
self._resolution = None
return
def set_template(self, template):
self._template = template
return
def set_directory(self, directory):
self._directory = directory
return
def set_beam(self, beam):
self._beam = beam
return
def set_limits_dict(self, limits_dict):
self._limits_dict = limits_dict
return
def add_image(self, image):
self._images.append(image)
return
def set_spacegroup(self, spacegroup):
self._spacegroup = spacegroup
return
def set_resolution(self, resolution):
self._resolution = resolution
def set_mosaic(self, mosaic):
self._mosaic = mosaic
return
def set_matrix(self, matrix):
if self.get_working_directory() in matrix:
matrix = matrix.replace(self.get_working_directory(), '.')
self._matrix = matrix
return
def set_anomalous(self, anomalous=True):
self._anomalous = anomalous
return
def get_phi_start(self):
return self._phi_start
def get_phi_end(self):
return self._phi_end
def get_phi_width(self):
return self._phi_width
def get_completeness(self):
return self._completeness
def integrate(self):
assert (self._template != None)
assert (self._directory != None)
assert (self._spacegroup != None)
assert (self._resolution != None)
assert (self._matrix != None)
assert (self._images != [])
self.start()
if self._limits_dict:
c0 = 'xmin {xmin} xmax {xmax} ymin {ymin} ymax {ymax}'.format(
**self._limits_dict)
c1 = 'rmin {rmin} rmax {rmax}'.format(**self._limits_dict)
c2 = 'xscan {xscan} yscan {yscan}'.format(**self._limits_dict)
self.input('limits %s' % c0)
self.input('limits %s' % c1)
self.input('limits %s' % c2)
self.input('symmetry %s' % self._spacegroup)
self.input('matrix %s' % self._matrix)
self.input('template %s' % self._template)
if self._beam:
self.input('beam %f %f' % self._beam)
self.input('directory %s' % self._directory)
if '.cbf' in self._template[-4:]:
self.input('detector pilatus')
self.input('findspots find %s' % self._images[0])
self.input('go')
self.input('mosaic %f' % self._mosaic)
if self._resolution:
self.input('resolution %f' % self._resolution)
self.input('postref fix all')
self.input('best on')
for image in self._images:
self.input('process %d %d' % (image, image))
self.input('go')
self.close_wait()
# now pull out the output... though don't really want this
for record in self.get_all_output():
pass
# do want to chmod the files bestfile.par and bestfile.hkl
for f in 'bestfile.par', 'bestfile.hkl':
try:
os.chmod(os.path.join(self.get_working_directory(), f),
0644)
except:
pass
return
return Mosflm_integrateWrapper()
def Mosflm_index(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
class Mosflm_indexWrapper(DriverInstance.__class__):
def __init__(self):
# generic things
DriverInstance.__class__.__init__(self)
self.set_executable('ipmosflm')
self._template = None
self._directory = None
self._images = []
self._cell = None
self._spacegroup = None
self._mosaic = None
self._detector_type = None
self._matrix = None
self._omega = 0
self._beam = 0
return
def set_template(self, template):
self._template = template
return
def set_directory(self, directory):
self._directory = directory
return
def set_detector_type(self, detector_type):
self._detector_type = detector_type
return
def set_omega(self, omega):
self._omega = omega
return
def add_image(self, image):
self._images.append(image)
return
def set_spacegroup(self, spacegroup):
# FIXME add in test that the spacegroup is a sensible value
self._spacegroup = spacegroup
return
def get_spacegroup(self):
return self._spacegroup
def get_cell(self):
return self._cell
def get_mosaic(self):
return self._mosaic
def get_matrix(self):
return self._matrix
def get_beam(self):
return self._beam
def index(self):
assert (self._template != None)
assert (self._directory != None)
assert (self._images != [])
self.start()
self.input('newmat mosflm_index.mat')
self.input('template %s' % self._template)
self.input('directory %s' % self._directory)
if self._detector_type:
self.input('detector %s' % self._detector_type)
elif '.cbf' in self._template[-4:]:
self.input('detector pilatus')
if self._omega:
self.input('detector omega %d' % self._omega)
if self._spacegroup:
self.input('symmetry %s' % self._spacegroup)
for image in self._images:
self.input('autoindex dps refine image %d' % image)
self.input('best on')
self.input('mosaic estimate')
self.input('go')
self.close_wait()
# now pull out the output...
for record in self.get_all_output():
if 'Final cell' in record and 'after refinement' in record:
self._cell = tuple(map(float, record.split()[-6:]))
if 'Refining solution #' in record:
self._spacegroup = record.split('(')[0].split()[-1]
if 'The mosaicity has been estimated as' in record:
self._mosaic = float(record.split()[7])
if 'Beam coordinates of' in record and \
'have been refined to' in record:
self._beam = tuple(map(float, record.split()[-2:]))
self._matrix = os.path.join(self.get_working_directory(),
'mosflm_index.mat')
return
return Mosflm_indexWrapper()
def Phaser(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
class PhaserWrapper(DriverInstance.__class__):
def __init__(self):
DriverInstance.__class__.__init__(self)
self.set_executable('phaser')
self._hklin = None
self._hklout = None
self._xyzin = None
self._xyzout = None
# FIXME code around this for cases where the identity is 100%
# - i.e. copy the sequence from the input pdb file. No!
# allow for a sequence file, if not set then compute molecular
# weight from sequence in input pdb file.
self._molecular_weight = 0
self._mode = 'MR'
self._colin = {'F': 'F', 'SIGF': 'SIGF'}
return
def set_molecular_weight(self, molecular_weight):
self._molecular_weight = molecular_weight
return
def set_hklin(self, hklin):
self._hklin = hklin
return
def get_hklin(self):
return self._hklin
def set_hklout(self, hklout):
self._hklout = hklout
return
def get_hklout(self):
return self._hklout
def set_xyzin(self, xyzin):
self._xyzin = xyzin
return
def get_xyzin(self):
return self._xyzin
def set_xyzout(self, xyzout):
self._xyzout = xyzout
return
def get_xyzout(self):
return self._xyzout
def mr(self):
assert (self._xyzin)
assert (self._hklin)
assert (self._molecular_weight)
self.start()
self.input('mode mr_auto')
self.input('hklin %s' % self._hklin)
self.input('labin F=F SIGF=SIGF')
self.input('ensemble model pdb %s identity 100' % self._xyzin)
self.input('composition protein mw %d num 1' % \
self._molecular_weight)
self.input('search ensemble model num 1')
self.input('root mr')
self.close_wait()
# fixme check return status &c.
self.check_for_errors()
shutil.copyfile(
os.path.join(self.get_working_directory(), 'mr.1.pdb'),
self._xyzout)
shutil.copyfile(
os.path.join(self.get_working_directory(), 'mr.1.mtz'),
self._hklout)
return
return PhaserWrapper()
def BestStrategy(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
class BestStrategyWrapper(DriverInstance.__class__):
def __init__(self):
DriverInstance.__class__.__init__(self)
self.set_executable('best')
# Input parameters - lower case per frame
# upper case whole scan
self._detector = None
self._t_ref = None
self._trans_ref = 100.0
self._t_min = None
self._T_max = None
self._S_max = 10.0
self._w_min = 0.05
self._M_min = 3.0
self._C_min = 0.99
self._i2s = 2.0
self._sensitivity = 1.0
self._shape = 1.0
self._mos_dat = None
self._mos_par = None
self._mos_hkl = []
self._anomalous = False
# output parameters
self._phi_start = None
self._phi_end = None
self._phi_width = None
self._completeness = None
self._multiplicity = None
self._exposure_time = None
self._transmission = None
self._resolution = None
return
def set_detector(self, detector):
self._detector = detector
def set_t_ref(self, t_ref):
self._t_ref = t_ref
def set_trans_ref(self, trans_ref):
self._trans_ref = trans_ref
def set_T_max(self, T_max):
self._T_max = T_max
def set_t_min(self, t_min):
self._t_min = t_min
def set_S_max(self, S_max):
self._S_max = S_max
def set_w_min(self, w_min):
self._w_min = w_min
def set_M_min(self, M_min):
self._M_min = M_min
def set_C_min(self, C_min):
self._C_min = C_min
def set_i2s(self, i2s):
self._i2s = i2s
def set_sensitivity(self, sensitivity):
self._sensitivity = sensitivity
def set_shape(self, shape):
self._shape = shape
def set_mos_dat(self, mos_dat):
self._mos_dat = mos_dat
def set_mos_par(self, mos_par):
self._mos_par = mos_par
def add_mos_hkl(self, mos_hkl):
self._mos_hkl.append(mos_hkl)
def set_anomalous(self, anomalous=True):
self._anomalous = anomalous
def get_phi_start(self):
return self._phi_start
def get_phi_end(self):
return self._phi_end
def get_phi_width(self):
return self._phi_width
def get_completeness(self):
return self._completeness
def get_multiplicity(self):
return self._multiplicity
def get_transmission_percent(self):
return self._transmission_percent
def get_exposure_time(self):
return self._exposure_time
def strategy(self):
assert self._detector
assert self._t_ref
assert self._t_min
assert self._T_max
assert self._S_max
assert self._w_min
assert self._M_min
assert self._C_min
assert self._i2s
assert self._sensitivity
assert self._shape
assert self._mos_dat
assert self._mos_par
assert self._mos_hkl
self.set_command_line([
'-f', self._detector, '-t',
'%.3f' % self._t_ref, '-M',
'%.3f' % self._t_min, '-T',
'%.3f' % self._T_max, '-Trans',
'%.3f' % self._trans_ref, '-S',
'%.3f' % self._S_max, '-w',
'%.3f' % self._w_min, '-R',
'%.3f' % self._M_min, '-C',
'%.3f' % (0.01 * self._C_min), '-i2s',
'%.3f' % self._i2s, '-su',
'%.3f' % self._sensitivity, '-sh',
'%.3f' % self._shape
])
if self._anomalous:
self.add_command_line('-a')
self.add_command_line('-mos')
self.add_command_line(self._mos_dat)
self.add_command_line(self._mos_par)
for mos_hkl in self._mos_hkl:
self.add_command_line(mos_hkl)
self.start()
self.close_wait()
# FIXME really I should check for bugs or errors
output = self.get_all_output()
for record in output:
if 'ERROR' in record:
raise RuntimeError, record.strip()
# BEWARE this is dependent on order of output
for j, record in enumerate(output):
tokens = record.split()
if 'Resolution limit' in record and 'Transmission' in record:
self._transmission_percent = float(tokens[6].replace(
'%', ''))
if 'Phi_start - Phi_finish' in record:
self._phi_start = float(tokens[-3])
self._phi_end = float(tokens[-1])
if 'Overall Completeness' in record:
self._completeness = float(tokens[-1].replace('%', ''))
if 'Redundancy' in record:
self._multiplicity = float(tokens[-1])
if 'WEDGE PARAMETERS' in record:
data_items = output[j + 6].replace('|', ' ').split()
self._phi_width = float(data_items[2])
self._exposure_time = float(data_items[3])
if 'Resolution limit =' in record and 'Transmission =' in record:
self._transmission = float(tokens[6].replace('%', ''))
self._resolution = float(tokens[2].replace('=', ''))
return
def get_completeness(self):
return self._completeness
def get_multiplicity(self):
return self._multiplicity
def get_exposure_time(self):
return self._exposure_time
def get_transmission(self):
return self._transmission
def get_resolution(self):
return self._resolution
return BestStrategyWrapper()
def Mosflm_strategy(DriverType = None):
DriverInstance = DriverFactory.Driver(DriverType)
class Mosflm_strategyWrapper(DriverInstance.__class__):
def __init__(self):
# generic things
DriverInstance.__class__.__init__(self)
self.set_executable('ipmosflm')
self._template = None
self._directory = None
self._detector = None
self._images = []
self._spacegroup = None
self._mosaic = None
self._anomalous = False
self._matrix = None
self._resolution = None
self._phi_start = None
self._phi_end = None
self._phi_width = None
self._completeness = None
self._omega = 0
return
def set_template(self, template):
self._template = template
return
def set_directory(self, directory):
self._directory = directory
return
def set_detector(self, detector):
self._detector = detector
return
def add_image(self, image):
self._images.append(image)
return
def set_spacegroup(self, spacegroup):
self._spacegroup = spacegroup
return
def set_resolution(self, resolution):
self._resolution = resolution
def set_mosaic(self, mosaic):
self._mosaic = mosaic
return
def set_matrix(self, matrix):
if self.get_working_directory() in matrix:
matrix = matrix.replace(self.get_working_directory(), '.')
self._matrix = matrix
return
def set_omega(self, omega):
self._omega = omega
return
def set_anomalous(self, anomalous = True):
self._anomalous = anomalous
return
def get_phi_start(self):
return self._phi_start
def get_phi_end(self):
return self._phi_end
def get_phi_width(self):
return self._phi_width
def get_completeness(self):
return self._completeness
def strategy(self):
assert(self._template != None)
assert(self._directory != None)
assert(self._spacegroup != None)
assert(self._resolution != None)
assert(self._matrix != None)
assert(self._images != [])
self.start()
self.input('symmetry %s' % self._spacegroup)
self.input('matrix %s' % self._matrix)
self.input('template %s' % self._template)
self.input('directory %s' % self._directory)
if self._detector:
self.input('detector %s' % self._detector)
elif '.cbf' in self._template[-4:]:
self.input('detector pilatus')
if self._omega:
self.input('detector omega %d' % self._omega)
self.input('findspots find %s' % self._images[0])
self.input('go')
self.input('mosaic %f' % self._mosaic)
if self._resolution:
self.input('resolution %f' % self._resolution)
if self._anomalous:
self.input('strategy testgen anomalous overlap 0.5')
else:
self.input('strategy testgen overlap 0.5')
self.input('go')
self.close_wait()
# now pull out the output...
save_phi_width = False
phi_widths = []
for record in self.get_all_output():
if 'From' in record and 'to' in record and 'degrees' in record:
self._phi_start = float(record.split()[1])
self._phi_end = float(record.split()[3])
if 'Phi start' in record and 'no of images' in record:
save_phi_width = True
continue
if save_phi_width:
if record.strip():
phi_widths.append(float(record.split()[3]))
else:
save_phi_width = False
self._phi_width = min(phi_widths)
if 'Optimum rotation' in record:
self._completeness = 0.01 * float(
record.replace('%', '').split()[3])
return
return Mosflm_strategyWrapper()
def Cad(DriverType=None):
DriverInstance = DriverFactory.Driver(DriverType)
CCP4DriverInstance = DecoratorFactory.Decorate(DriverInstance, 'ccp4')
class CadWrapper(CCP4DriverInstance.__class__):
def __init__(self):
# generic things
CCP4DriverInstance.__class__.__init__(self)
self.set_executable('cad')
# N.B. Since CAD takes more than one input file the
# ccp4 decorator hklin is not helpful...
self._hklin_files = []
# optional assignment of new cell constants (i.e. for MAD
# experiments) or updating the column names.
self._cell_parameters = None
self._column_suffix = None
# assignment of project / crystal / dataset
self._pname = None
self._xname = None
self._dname = None
# stuff to specifically copy in the freer column...
self._freein = None
self._freein_column = 'FreeR_flag'
# overload the set_hklin() method as this will not work with
# CAD...
def set_hklin(self, hklin):
raise RuntimeError, 'cannot use set_hklin with Cad wrapper'
def add_hklin(self, hklin):
self._hklin_files.append(hklin)
return
def set_freein(self, freein, freein_column='FreeR_flag'):
if not os.path.exists(freein):
raise RuntimeError, '%s does not exist' % freein
# FIXME should really check that the column is in the free file.
self._freein = freein
self._freein_column = freein_column
return
def set_project_info(self, pname, xname, dname):
self._pname = pname
self._xname = xname
self._dname = dname
return
def set_new_suffix(self, suffix):
self._column_suffix = suffix
return
def set_new_cell(self, cell):
self._cell_parameters = cell
return
# three real "doing" methods for this one - merge() to merge the files
# in the hklin list and update() to change properties of one file
# (which should be assigned as HKLIN) and copyfree() to copy the
# FreeR_flag column from freein to hklout with the columns
# from hklin
def merge(self):
if not self._hklin_files:
raise RuntimeError, 'no hklin files defined'
self.check_hklout()
hklin_counter = 0
# for each reflection file, need to gather the column names
# and so on, to put in the cad input here - also check to see
# if the column names clash... check also that the spacegroups
# match up...
symmetry = None
column_names = []
column_names_by_file = {}
for hklin in self._hklin_files:
mtzdump = Mtzdump()
mtzdump.set_working_directory(self.get_working_directory())
mtzdump.set_hklin(hklin)
mtzdump.dump()
columns = mtzdump.get_columns()
this_symmetry = mtzdump.get_symmetry()
if symmetry is None:
symmetry = this_symmetry
if this_symmetry != symmetry:
raise RuntimeError, 'spacegroups do not match'
column_names_by_file[hklin] = []
for c in columns:
name = c[0]
if name in ['H', 'K', 'L']:
continue
if name in column_names:
raise RuntimeError, 'duplicate column names'
column_names.append(name)
column_names_by_file[hklin].append(name)
# create the command line
hklin_counter = 0
for hklin in self._hklin_files:
hklin_counter += 1
self.add_command_line('hklin%d' % hklin_counter)
self.add_command_line(hklin)
self.start()
hklin_counter = 0
for hklin in self._hklin_files:
column_counter = 0
hklin_counter += 1
labin_command = 'labin file_number %d' % hklin_counter
for column in column_names_by_file[hklin]:
column_counter += 1
labin_command += ' E%d=%s' % (column_counter, column)
self.input(labin_command)
self.close_wait()
self.check_for_errors()
self.check_ccp4_errors()
return
def update(self):
if not self._hklin_files:
raise RuntimeError, 'no hklin files defined'
if len(self._hklin_files) > 1:
raise RuntimeError, 'can have only one hklin to update'
hklin = self._hklin_files[0]
self.check_hklout()
column_names_by_file = {}
dataset_names_by_file = {}
mtzdump = Mtzdump()
mtzdump.set_hklin(self._hklin)
mtzdump.dump()
columns = mtzdump.get_columns()
column_names_by_file[hklin] = []
dataset_names_by_file[hklin] = mtzdump.get_datasets()
dataset_ids = [mtzdump.get_dataset_info(d)['id'] for \
d in mtzdump.get_datasets()]
for c in columns:
name = c[0]
if name in ['H', 'K', 'L']:
continue
column_names_by_file[hklin].append(name)
self.add_command_line('hklin1')
self.add_command_line(hklin)
self.start()
dataset_id = dataset_ids[0]
if self._pname and self._xname and self._dname:
self.input('drename file_number 1 %d %s %s' % \
(dataset_id, self._xname, self._dname))
self.input('dpname file_number 1 %d %s' % \
(dataset_id, self._pname))
column_counter = 0
labin_command = 'labin file_number 1'
for column in column_names_by_file[hklin]:
column_counter += 1
labin_command += ' E%d=%s' % (column_counter, column)
self.input(labin_command)
pname, xname, dname = dataset_names_by_file[hklin][0].split('/')
dataset_id = dataset_ids[0]
if self._cell_parameters:
a, b, c, alpha, beta, gamma = self._cell_parameters
self.input('dcell file_number 1 %d %f %f %f %f %f %f' % \
(dataset_id, a, b, c, alpha, beta, gamma))
if self._column_suffix:
suffix = self._column_suffix
column_counter = 0
labout_command = 'labout file_number 1'
for column in column_names_by_file[hklin]:
column_counter += 1
labout_command += ' E%d=%s_%s' % \
(column_counter, column, suffix)
self.input(labout_command)
self.close_wait()
self.check_for_errors()
self.check_ccp4_errors()
return
def copyfree(self):
if not self._hklin_files:
raise RuntimeError, 'no hklin files defined'
if len(self._hklin_files) > 1:
raise RuntimeError, 'can have only one hklin to update'
hklin = self._hklin_files[0]
self.check_hklout()
if self._freein is None:
raise RuntimeError, 'freein not defined'
if self._freein_column is None:
raise RuntimeError, 'freein column not defined'
self.add_command_line('hklin1')
self.add_command_line(self._freein)
self.add_command_line('hklin2')
self.add_command_line(hklin)
self.start()
self.input('labin file_number 1 E1=%s' % self._freein_column)
self.input('labin file_number 2 all')
self.close_wait()
self.check_for_errors()
self.check_ccp4_errors()
return
return CadWrapper()