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()