def generate_symmetry_mates(pdbin, pdbout, sgno, cell): """Takes the input pdb and generates the unit cell from the point group symmetry""" if not pdbout.endswith('.pdb'): pdbout = pdbout + '.pdb' if not os.path.exists(pdbin): raise IOError('pdbin does not exist! {!s}'.format(pdbin)) if os.path.exists(pdbout): raise Exception('pdbout already exists! {!s}'.format(pdbout)) assert isinstance(sgno, int), 'SPACEGROUP MUST BE AN INTEGER! {!s}'.format(sgno) assert isinstance(cell, list), 'CELL MUST BE A LIST! {!s}'.format(cell) # Initialise Commander PDBSET = CommandManager('pdbset') # Set Command Arguments PDBSET.add_command_line_arguments('XYZIN', os.path.abspath(pdbin), 'XYZOUT', os.path.abspath(pdbout)) # Set inputs PDBSET.add_standard_input([ 'SYMGEN {!s}'.format(sgno), 'CELL {!s}'.format(' '.join(map(str, cell))), 'END' ]) # run! PDBSET.run() if not os.path.exists(pdbout): raise ExternalProgramError( 'PDBSET has failed to generate SYMMETRY mates. {!s}\nCOM: {!s}\nOUT: {!s}\nERR: {!s}' .format(pdbin, PDBSET.command, PDBSET.out, PDBSET.err)) return pdbout
def create_cryst_line(pdbin, pdbout, sg, cell): """Adds a cryst line to pdbin""" if not pdbout.endswith('.pdb'): pdbout = pdbout + '.pdb' if not os.path.exists(pdbin): raise IOError('pdbin does not exist! {!s}'.format(pdbin)) if os.path.exists(pdbout): raise Exception('pdbout already exists! {!s}'.format(pdbout)) # Initialise Commander PDBSET = CommandManager('pdbset') # Set Command Arguments PDBSET.add_command_line_arguments('XYZIN', os.path.abspath(pdbin), 'XYZOUT', os.path.abspath(pdbout)) # Set Stdin PDBSET.add_standard_input([ 'SPACEGROUP {!s}'.format(sg), 'CELL {!s}'.format(' '.join(map(str, cell))) ]) # run! PDBSET.run() if not os.path.exists(pdbout): raise ExternalProgramError( 'PDBSET has failed to create cryst line for {!s}\nOUT: {!s}\nERR: {!s}' .format(pdbin, PDBSET.out, PDBSET.err)) return PDBSET
def extract_bfactor_statistics(pdb_file): """Analyse the b-factors in a pdb file and return a dictionary with all of the averages, rms deviations and Z-scores for the b-factors in a structure""" # Create a temporary file for the output summary table and pdb_file temp_handle, temp_path = tempfile.mkstemp(suffix='.table', prefix='baverage_') temp_handle2, temp_path2 = tempfile.mkstemp(suffix='.pdb', prefix='baverage_') BAVERAGE = CommandManager('baverage') BAVERAGE.add_command_line_arguments('XYZIN', pdb_file, 'RMSTAB', temp_path, 'XYZOUT', temp_path2) BAVERAGE.add_standard_input(['END']) BAVERAGE.run() if not os.path.exists(temp_path): raise ExternalProgramError( 'BAVERAGE has failed to calculate b-factor summary statistics for {!s}' .format(pdb_file)) # Process Table and Standard Out table_contents = open(temp_path, 'r').read().split('\n') if not table_contents: raise ExternalProgramError( 'BAVERAGE has failed to calculate b-factor summary statistics for {!s}' .format(pdb_file)) else: os.remove(temp_path) os.remove(temp_path2) return BAVERAGE, table_contents
def create_alpha_carbon_backbone(pdbin, pdbout): """Takes a pdb files and removes eveything except for the alpha carbons""" if not pdbout.endswith('.pdb'): pdbout = pdbout + '.pdb' if not os.path.exists(pdbin): raise IOError('pdbin does not exist! {!s}'.format(pdbin)) if os.path.exists(pdbout): raise Exception('pdbout already exists! {!s}'.format(pdbout)) # Initialise Commander PDBCUR = CommandManager('pdbcur') # Set Command Arguments PDBCUR.add_command_line_arguments('XYZIN', pdbin, 'XYZOUT', pdbout) # Set inputs PDBCUR.add_standard_input(['lvatom "CA[C]:*"', 'END']) # run! PDBCUR.run() if not os.path.exists(pdbout): raise ExternalProgramError( 'PDBCUR has failed to create carbon backbone. {!s}\nOUT: {!s}\nERR: {!s}' .format(pdbin, PDBCUR.out, PDBCUR.err)) return pdbout
def apply_rfree_set(refmtz, mtzin, mtzout): """Takes an input mtz and a reference mtz and transplants the rfree flags""" tempmtz = mtzin.replace('.mtz', '.temp.mtz') refobj = MtzSummary(refmtz) newobj = MtzSummary(mtzin) # Copy data columns from new mtz file F1, SIGF1 = newobj.label.f, newobj.label.sigf if not (F1 and SIGF1): raise LabelError('No Amplitudes found in {!s}'.format(mtzin)) # Get the spacegroup and the rfree from the reference mtz sgno = refobj.data.spacegroupno RFree2 = refobj.label.free if not sgno: raise LabelError( 'No Spacegroup information found in {!s}'.format(refmtz)) if not RFree2: raise LabelError('No RFreeFlags found in {!s}'.format(refmtz)) # Initialise Commander CAD = CommandManager('cad') # Set command arguments CAD.add_command_line_arguments('hklin1', mtzin, 'hklin2', refmtz, 'hklout', tempmtz) # Set inputs CAD.add_standard_input(['symmetry {!s}'.format(sgno),'labin file_number 1 E1={!s} E2={!s}'.format(F1, SIGF1), \ 'labout file_number 1 E1={!s} E2={!s}'.format(F1, SIGF1), \ 'labin file_number 2 E1={!s}'.format(RFree2), \ 'labout file_number 2 E1={!s}'.format(RFree2),'END']) # Run! CAD.run() if not os.path.exists(tempmtz): raise ExternalProgramError( 'CAD has failed to transplant RFree Flags. {!s}\nOUT: {!s}\nERR: {!s}' .format(mtzin, CAD.out, CAD.err)) # Now complete the free r set # Initialise Commander FREE = CommandManager('freerflag') # Set command arguments FREE.add_command_line_arguments('hklin', tempmtz, 'hklout', mtzout) # Set inputs FREE.add_standard_input(['COMPLETE FREE={!s}'.format(RFree2), 'END']) # Run! FREE.run() if not os.path.exists(mtzout): raise ExternalProgramError( 'freerflag has failed to complete the RFree Flag set. {!s}\nOUT: {!s}\nERR: {s}' .format(tempmtz, CAD.out, CAD.err)) os.remove(tempmtz) return CAD, FREE
def isolate_residue(inpdb, outpdb, resname): """Extract the residues identified by resname using pdbcur - i.e. 'UNL'""" PDBCUR = CommandManager('pdbcur') PDBCUR.add_command_line_arguments('XYZIN', inpdb, 'XYZOUT', outpdb) PDBCUR.add_standard_input(['lvresidue /*/*/({!s})'.format(resname), 'END']) PDBCUR.run() return PDBCUR
def merge_pdb_files(pdb1, pdb2, pdbout): """Merge two PDB Files using CCP4s pdb_merge""" # Initialise Commander MERGER = CommandManager('pdb_merge') # Set command arguments MERGER.add_command_line_arguments('xyzin1', pdb1, 'xyzin2', pdb2, 'xyzout', pdbout) # Set inputs MERGER.add_standard_input('END') # run! MERGER.run() return MERGER
def reindex_mtz_to_reference(in_mtz, out_mtz, reference_mtz, tolerance): """Reindex the data in one mtz to a reference mtz""" print '**************************' print '*** Running reindexing ***' print '**************************' cmd = CommandManager('pointless') cmd.add_command_line_arguments( ['hklin', in_mtz, 'hklref', reference_mtz, 'hklout', out_mtz]) cmd.add_standard_input(['tolerance {}'.format(tolerance)]) print_run_and_raise_error_maybe(cmd) if not os.path.exists(out_mtz): raise Failure( 'reindexing has failed -- {} does not exist'.format(out_mtz))
def transfer_rfree_flags(in_mtz, out_mtz, reference_mtz, input_free_r_flag, output_free_r_flag, delete_tmp_files=True): """Copy R-free flags from reference mtz""" print '*********************************' print '*** Transferring R-free flags ***' print '*********************************' tmp_mtz = splice_ext(path=out_mtz, new='step1-transfer') # Stage 1 - transfer R-free from reference cmd = CommandManager('cad') cmd.add_command_line_arguments( ['hklin1', in_mtz, 'hklin2', reference_mtz, 'hklout', tmp_mtz]) cmd.add_standard_input([ 'labin file_number 1 ALL', 'labin file_number 2 E1={}'.format(input_free_r_flag), 'labout file_number 2 E1={}'.format(output_free_r_flag), 'END' ]) print_run_and_raise_error_maybe(cmd) if not os.path.exists(tmp_mtz): raise Failure( 'transfer of R-free flags has failed -- {} does not exist'.format( tmp_mtz)) print '*******************************' print '*** Completing R-free flags ***' print '*******************************' # Stage 2 - populate missing R-free values cmd = CommandManager('freerflag') cmd.add_command_line_arguments(['hklin', tmp_mtz, 'hklout', out_mtz]) cmd.add_standard_input( ['COMPLETE FREE={}'.format(output_free_r_flag), 'END']) print_run_and_raise_error_maybe(cmd) if not os.path.exists(out_mtz): raise Failure( 'expanding of R-free flags has failed -- {} does not exist'.format( out_mtz)) if delete_tmp_files: os.remove(tmp_mtz)
def mask_map(mapin, maskpdb, mapout, border=1): """Takes mapin and masks around atoms in maskpdb""" # Masking object masker = CommandManager('mapmask') # Set input files masker.add_command_line_arguments( ['mapin', mapin, 'mapout', mapout, 'xyzin', maskpdb]) # Set stdin masker.add_standard_input(['BORDER {!s}'.format(border), 'END']) # Run! masker.run() # Report errors if masker.process.returncode != 0: raise RuntimeError('mapmask failed to mask map {!s}'.format(mapin)) # Return Command Managers for flexible handling of out & err return masker
def create_asu_map(mapin, mapout): """Takes mapin and masks to the asymmetric unit""" # Masking object masker = CommandManager('mapmask') # Set input files masker.add_command_line_arguments(['mapin', mapin, 'mapout', mapout]) # Set stdin masker.add_standard_input(['XYZLIM ASU', 'END']) # Run! masker.run() # Report errors if masker.process.returncode != 0: raise RuntimeError( 'mapmask failed to create asu map from {!s}'.format(mapin)) # Return Command Managers for flexible handling of out & err return masker
def reset_pdb_file(pdbin, pdbout): """Resets the B-Factors in a file and removes anisotropy""" if not pdbout.endswith('.pdb'): pdbout = pdbout + '.pdb' if not os.path.exists(pdbin): raise IOError('pdbin does not exist! {!s}'.format(pdbin)) if os.path.exists(pdbout): raise Exception('pdbout already exists! {!s}'.format(pdbout)) pdbtemp = pdbout.replace('.pdb', '.temp.pdb') # Initialise Commander PDBCUR = CommandManager('pdbcur') # Set Command Arguments PDBCUR.add_command_line_arguments('XYZIN', pdbin, 'XYZOUT', pdbtemp) # Set inputs PDBCUR.add_standard_input(['NOANISOU', 'DELSOLVENT', 'END']) # run! PDBCUR.run() if not os.path.exists(pdbtemp): raise ExternalProgramError( 'PDBCUR has failed to remove anisotropy and delete solvent. {!s}\nOUT: {!s}\nERR: {!s}' .format(pdbin, PDBCUR.out, PDBCUR.err)) # Initialise Commander PDBSET = CommandManager('pdbset') # Set Command Arguments PDBSET.add_command_line_arguments('XYZIN', pdbtemp, 'XYZOUT', pdbout) # Set inputs PDBSET.add_standard_input(['BFACTOR', 'END']) # run! PDBSET.run() if not os.path.exists(pdbout): raise ExternalProgramError( 'PDBSET has failed to reset B-factors. {!s}\nOUT: {!s}\nERR: {!s}'. format(pdbtemp, PDBSET.out, PDBSET.err)) else: os.remove(pdbtemp) return pdbout
def isolate_residue_by_res_id(inpdb, outpdb, chain, resnum, model='*', inscode=''): """Isolate the residues identified by residue ids using pdbcur - i.e. '0/A/54.A/'""" if inscode: selection = '/{!s}/{!s}/{!s}.{!s}'.format(model, chain, resnum, inscode) else: selection = '/{!s}/{!s}/{!s}'.format(model, chain, resnum) PDBCUR = CommandManager('pdbcur') PDBCUR.add_command_line_arguments('XYZIN', inpdb, 'XYZOUT', outpdb) PDBCUR.add_standard_input(['lvresidue {!s}'.format(selection), 'END']) PDBCUR.run() return PDBCUR
def fft_mtz_to_map(mtz_file, map_file, cols): """Converts an MTZ Format File to a MAP File (using fft as default)""" # Initialise writer = CommandManager('fft') # Set Program Arguments writer.add_command_line_arguments('hklin', mtz_file, 'mapout', map_file) # Set Program Input writer.add_standard_input( ['LABIN F1={!s} PHI={!s}'.format(cols['F'], cols['P']), 'END']) # RUN! writer.run() # Check Output if writer.process.returncode != 0: print('\nOUT\n\n' + writer.out) print('\nERR\n\n' + writer.err) raise RuntimeError( 'fft failed to generate map from {!s}'.format(mtz_file)) return writer
def merge_cif_libraries(incifs, outcif): """Take a list of cifs and merge into one cif""" assert isinstance(incifs, list), "'incifs' is not a list!" assert len(incifs) > 1, "'incifs' must be two or more files!" current = incifs.pop(0) to_be_deleted = [] for additional in incifs: # Create a file handle and path for the output temp_handle, temp_path = tempfile.mkstemp(suffix='.lib', prefix='libcheck_') to_be_deleted.append(temp_path) # Merge current and additional to temp_path LIBCHK = CommandManager('libcheck') LIBCHK.add_standard_input( '_DOC N', '_FILE_L {!s}'.format(current), '_FILE_L2 {!s}'.format(additional), '_FILE_O {!s}'.format(temp_path.replace('.lib', '')), '_END') LIBCHK.run() current = temp_path shutil.copy(current, outcif) for file in to_be_deleted: os.remove(file) assert os.path.exists(outcif), 'OUTPUT CIF DOES NOT EXIST! {!s}'.format( outcif) return outcif
def remove_residue_by_res_id(inpdb, outpdb, chain, resnum, model='*', inscode='', removeSolvent=False): """Remove the residues identified by res info using pdbcur - i.e. 'UNL'""" if inscode: selection = '/{!s}/{!s}/{!s}.{!s}'.format(model, chain, resnum, inscode) else: selection = '/{!s}/{!s}/{!s}'.format(model, chain, resnum) std_input = ['delresidue {!s}'.format(selection) ] + (removeSolvent) * ['delsolvent'] + ['END'] PDBCUR = CommandManager('pdbcur') PDBCUR.add_command_line_arguments('XYZIN', inpdb, 'XYZOUT', outpdb) PDBCUR.add_standard_input(std_input) PDBCUR.run() return PDBCUR
class BuilderObject(object): """Template Object for creating an Object to generate ligand restraints""" def __init__(self, time=True, verbose=True): self.allowed_args = allowed_builder_args self.ligname = DEFAULT_LIGAND_NAMES[0] # Settings self.time = time self.verbose = verbose self.runtime = -1.0 self.timeout = 1800 # Custom Init self._custom_init() def generate_ligand(self, ligsmile, outdir, outfile, flags=[]): """Generate ligand PDB and CIF from smile string""" # Prepare standard settings self._prepare_to_generate_ligand(ligsmile, outdir, outfile, flags) # Check to see if already run, and if not, run the custom part of the object - different for each program if os.path.exists(self.outpdb) and os.path.exists( self.outcif) and os.path.exists(self.outlog): if self.verbose: print('\tLigand already generated - DOING NOTHING') else: cmd_line_args, std_inpt_args = self._create_program_arguments( ligsmile, outdir, outfile, flags) # Initialise CommandManager self.builder = CommandManager(self.program) # Set Command-Line Args if cmd_line_args: self.builder.add_command_line_arguments(cmd_line_args) # Set Standard Input if std_inpt_args: self.builder.add_standard_input(std_inpt_args) # Set Parameters self.builder.set_timeout(timeout=self.timeout) # RUN self.builder.run() # Get runtime self.runtime = self.builder.runtime try: # Could add postprocess here pass finally: self.write_log_file() return self.outpdb, self.outcif, self.outlog def _prepare_to_generate_ligand(self, ligsmile, outdir, outfile, flags): """Set up the generic file names""" # Process outputfile if '/' in outfile: raise ValueError('outfile must be a file, not a path') # Record Template and Outdir self.outtemplate = os.path.join(outdir, outfile) self.outdir = outdir # Record Filenames self.outpdb = self.outtemplate + '.pdb' self.outcif = self.outtemplate + '.cif' self.outlog = self.outtemplate + '.log' def write_log_file(self): """Write the log file""" with open(self.outlog, 'w') as logfile: # Write out the input command logfile.write('\nCOMMAND\n\n') logfile.write('\n'.join(self.builder.cmd_line_args) + '\n') logfile.write('\nINPUT\n\n') logfile.write('\n'.join(self.builder.std_inp_lines) + '\n') # Write out & err logfile.write('\nSTDOUT\n\n') logfile.write(self.builder.output) logfile.write('\nSTDERR\n\n') logfile.write(self.builder.error)
def run(params): # Identify any existing output directories current_dirs = sorted(glob.glob(params.output.dir_prefix + '*')) if not current_dirs: next_int = 1 else: current_nums = [ s.replace(params.output.dir_prefix, '') for s in current_dirs ] next_int = sorted(map(int, current_nums))[-1] + 1 # Create output directory name from int out_dir = params.output.dir_prefix + '{:04}'.format(next_int) # Create output directory os.mkdir(out_dir) # Create log object log = Log(log_file=os.path.join( out_dir, params.output.out_prefix + '.quick-refine.log'), verbose=params.settings.verbose) # Report if current_dirs: log('Found existing refinement directories: \n\t{}'.format( '\n\t'.join(current_dirs))) log('') log('Creating new output directory: {}'.format(out_dir)) # Validate input parameters log.subheading('Validating input parameters') assert params.input.pdb is not None, 'No PDB given for refinement' assert params.input.mtz is not None, 'No MTZ given for refinement' if os.path.islink(params.input.mtz): log('Converting mtz path to real path:') log('{} -> {}'.format(params.input.mtz, os.path.realpath(params.input.mtz))) params.input.mtz = os.path.realpath(params.input.mtz) # Link input log('Copying/linking files to refinement folder') shutil.copy(params.input.pdb, os.path.abspath(os.path.join(out_dir, 'input.pdb'))) rel_symlink(params.input.mtz, os.path.abspath(os.path.join(out_dir, 'input.mtz'))) # Copy parameter file to output folder if params.input.params: shutil.copy(params.input.params, os.path.abspath(os.path.join(out_dir, 'input.params'))) # Create output prefixes output_prefix = os.path.join(out_dir, params.output.out_prefix) log('Real output file path prefixes: {}'.format(output_prefix)) log('Link output file path prefixes: {}'.format(params.output.link_prefix)) # Create command objects log.subheading('Preparing command line input for refinement program') # PHENIX if params.options.program == 'phenix': cm = CommandManager('phenix.refine') # Command line args cm.add_command_line_arguments([params.input.pdb, params.input.mtz]) cm.add_command_line_arguments( ['output.prefix={}'.format(output_prefix)]) if params.input.cif: cm.add_command_line_arguments(params.input.cif) if params.input.params and os.path.exists(params.input.params): cm.add_command_line_arguments([params.input.params]) # REFMAC elif params.options.program == 'refmac': cm = CommandManager('refmac5') # Command line args cm.add_command_line_arguments( ['xyzin', params.input.pdb, 'hklin', params.input.mtz]) cm.add_command_line_arguments([ 'xyzout', output_prefix + '.pdb', 'hklout', output_prefix + '.mtz' ]) if params.input.cif: for cif in params.input.cif: cm.add_command_line_arguments(['libin', cif]) # Standard input if params.input.params: cm.add_standard_input(open(params.input.params).read().split('\n')) cm.add_standard_input(['END']) elif params.options.program == "buster": cm = CommandManager('refine') # Command line arguments # inputs cm.add_command_line_arguments( ['-p', params.input.pdb, '-m', params.input.mtz, '-d', out_dir]) if params.input.cif: for cif in params.input.cif: cm.add_command_line_arguments(['-l', cif]) if params.input.params: cm.add_command_line_arguments(['-Gelly', params.input.params]) # Pass additional command line arguments? if params.input.args: cm.add_command_line_arguments(params.input.args) # Report log(str(cm)) log.bar() log('running refinement... ({})'.format(cm.program[0])) out = cm.run() log.subheading('Refinement output') if not log.verbose: log('output written to log file ({} lines)'.format( cm.output.count('\n'))) log('\n' + cm.output, show=False) if out != 0: log.subheading('Refinement Errors') log(cm.error) log.subheading('Post-processing output files') if params.options.program == "buster": log.subheading('Renaming buster output files') shutil.move(src=os.path.join(out_dir, 'refine.pdb'), dst=output_prefix + '.pdb') shutil.move(src=os.path.join(out_dir, 'refine.mtz'), dst=output_prefix + '.mtz') # Find output files try: real_pdb = glob.glob(output_prefix + '*.pdb')[0] real_mtz = glob.glob(output_prefix + '*.mtz')[0] except: log('Refinement has failed - output files do not exist') log('{}: {}'.format(output_prefix + '*.pdb', glob.glob(output_prefix + '*.pdb'))) log('{}: {}'.format(output_prefix + '*.mtz', glob.glob(output_prefix + '*.mtz'))) raise # List of links to make at the end of the run link_file_pairs = [(real_pdb, params.output.link_prefix + '.pdb'), (real_mtz, params.output.link_prefix + '.mtz')] # Split conformations if params.options.split_conformations: params.split_conformations.settings.verbose = params.settings.verbose log.subheading('Splitting refined structure conformations') # Running split conformations out_files = split_conformations.split_conformations( filename=real_pdb, params=params.split_conformations, log=log) # Link output files to top for real_file in out_files: link_file = params.output.link_prefix + os.path.basename( real_file.replace(os.path.splitext(real_pdb)[0], '')) link_file_pairs.append([real_file, link_file]) # Link output files log.subheading('linking output files') for real_file, link_file in link_file_pairs: log('Linking {} -> {}'.format(link_file, real_file)) if not os.path.exists(real_file): log('file does not exist: {}'.format(real_file)) continue if os.path.exists(link_file) and os.path.islink(link_file): log('removing existing link: {}'.format(link_file)) os.unlink(link_file) if not os.path.exists(link_file): rel_symlink(real_file, link_file) log.heading('finished - refinement')
def run(params): in_mtzs = params.input.mtz assert len(params.input.mtz) > 1, 'Need to provide at least one mtz files' # assert len(params.input.mtz) < 3, 'Need to provide at most two mtz files' out_mtz = params.output.mtz out_log = params.output.log ########################################### # COMMAND LINE COMMANDS ########################################### cm = CommandManager('cad') ########################################### # ITERATE THROUGH INPUT MTZS ########################################### for i_mtz, mtz in enumerate(in_mtzs): # Use numbering from 1 n_mtz = i_mtz + 1 # Create an mtz suffix if params.options.label_suffix == 'incremental': suffix = '-{}'.format(n_mtz) elif params.options.label_suffix == 'filename': suffix = '-{}'.format(os.path.splitext(os.path.basename(mtz))[0]) elif params.options.label_suffix == 'foldername': suffix = '-{}'.format(os.path.basename(os.path.dirname(mtz))) else: raise Exception('Not yet implemented, sorry') # Add to the command line cm.add_command_line_arguments(['hklin{}'.format(n_mtz), mtz]) # Select column labels cm.add_standard_input('labin file_number {0} {1}'.format( n_mtz, ' '.join([ 'E{0}={1}'.format(i + 1, c) for i, c in enumerate(params.options.column.label) ]))) cm.add_standard_input('labout file_number {0} {1}'.format( n_mtz, ' '.join([ 'E{0}={1}'.format(i + 1, c + suffix) for i, c in enumerate(params.options.column.label) ]))) ########################################### # OUTPUT FILES ########################################### cm.add_command_line_arguments(['hklout', out_mtz]) ########################################### # RUN ########################################### print 'Running CAD:' cm.print_settings() ret_code = cm.run() cm.write_output(log_file=out_log) if ret_code != 0: print '============================>' print 'Refmac returned with an error' print '============================>' print cm.output print '============================>' print cm.error print '============================>'
def run(params): # Identify any existing output directories current_dirs = sorted(glob.glob(params.output.dir_prefix + "*")) if not current_dirs: next_int = 1 else: current_nums = [ s.replace(params.output.dir_prefix, "") for s in current_dirs ] next_int = sorted(map(int, current_nums))[-1] + 1 # Create output directory name from int out_dir = params.output.dir_prefix + "{:04}".format(next_int) # Create output directory os.mkdir(out_dir) # Create log object log = Log( log_file=os.path.join(out_dir, params.output.out_prefix + ".quick-refine.log"), verbose=params.settings.verbose, ) # Report if current_dirs: log("Found existing refinement directories: \n\t{}".format( "\n\t".join(current_dirs))) log("") log("Creating new output directory: {}".format(out_dir)) # Validate input parameters log.subheading("Validating input parameters") assert params.input.pdb is not None, "No PDB given for refinement" assert params.input.mtz is not None, "No MTZ given for refinement" if os.path.islink(params.input.mtz): log("Converting mtz path to real path:") log("{} -> {}".format(params.input.mtz, os.path.realpath(params.input.mtz))) params.input.mtz = os.path.realpath(params.input.mtz) # Link input log("Copying/linking files to refinement folder") shutil.copy(params.input.pdb, os.path.abspath(os.path.join(out_dir, "input.pdb"))) rel_symlink(params.input.mtz, os.path.abspath(os.path.join(out_dir, "input.mtz"))) # Copy parameter file to output folder if params.input.params: shutil.copy(params.input.params, os.path.abspath(os.path.join(out_dir, "input.params"))) # Create output prefixes output_prefix = out_dir log("Real output file path prefixes: {}".format(output_prefix)) log("Link output file path prefixes: {}".format(params.output.link_prefix)) # Create command objects log.subheading("Preparing command line input for refinement program") # PHENIX if params.options.program == "phenix": cm = CommandManager("phenix.refine") # Command line args cm.add_command_line_arguments([params.input.pdb, params.input.mtz]) cm.add_command_line_arguments( ["output.prefix={}".format(output_prefix)]) if params.input.cif: cm.add_command_line_arguments(params.input.cif) if params.input.params and os.path.exists(params.input.params): cm.add_command_line_arguments([params.input.params]) # REFMAC elif params.options.program == "refmac": cm = CommandManager("refmac5") # Command line args cm.add_command_line_arguments( ["xyzin", params.input.pdb, "hklin", params.input.mtz]) cm.add_command_line_arguments([ "xyzout", output_prefix + ".pdb", "hklout", output_prefix + ".mtz" ]) if params.input.cif: for cif in params.input.cif: cm.add_command_line_arguments(["libin", cif]) # Standard input if params.input.params: cm.add_standard_input(open(params.input.params).read().split("\n")) cm.add_standard_input(["END"]) # Pass additional command line arguments? if params.input.args: cm.add_command_line_arguments(params.input.args) # Report log(str(cm)) log.bar() log("running refinement... ({})".format(cm.program[0])) out = cm.run() log.subheading("Refinement output") if not log.verbose: log("output written to log file ({} lines)".format( cm.output.count("\n"))) log("\n" + cm.output, show=False) if out != 0: log.subheading("Refinement Errors") log(cm.error) log.subheading("Post-processing output files") # Find output files try: real_pdb = os.path.join(output_prefix, params.output.out_prefix + ".pdb") real_mtz = os.path.join(output_prefix, params.output.out_prefix + ".mtz") print(real_pdb, "\n", real_mtz) except: log("Refinement has failed - output files do not exist") log("{}: {}".format(output_prefix + "*.pdb", glob.glob(output_prefix + "*.pdb"))) log("{}: {}".format(output_prefix + "*.mtz", glob.glob(output_prefix + "*.mtz"))) raise # List of links to make at the end of the run link_file_pairs = [ (real_pdb, params.output.link_prefix + ".pdb"), (real_mtz, params.output.link_prefix + ".mtz"), ] print(link_file_pairs) # Split conformations if params.options.split_conformations: params.split_conformations.settings.verbose = params.settings.verbose log.subheading("Splitting refined structure conformations") # Running split conformations out_files = split_conformations.split_conformations( filename=real_pdb, params=params.split_conformations, log=log) # Link output files to top for real_file in out_files: link_file = params.output.link_prefix + os.path.basename( real_file.replace(os.path.splitext(real_pdb)[0], "")) link_file_pairs.append([real_file, link_file]) # Link output files log.subheading("linking output files") for real_file, link_file in link_file_pairs: log("Linking {} -> {}".format(link_file, real_file)) if not os.path.exists(real_file): log("file does not exist: {}".format(real_file)) continue if os.path.exists(link_file) and os.path.islink(link_file): log("removing existing link: {}".format(link_file)) os.unlink(link_file) if not os.path.exists(link_file): rel_symlink(real_file, link_file) log.heading("finished - refinement")
def fill_missing_reflections(in_mtz, out_mtz, fill_resolution_low, fill_resolution_high, delete_tmp_files=True): """Complete the set of miller indices in an MTZ file""" print '***************************' print '*** Filling reflections ***' print '***************************' tmp_mtz_1 = splice_ext(path=out_mtz, new='step1-truncate') tmp_mtz_2 = splice_ext(path=out_mtz, new='step2-uniquify') tmp_mtz_3 = splice_ext(path=out_mtz, new='step3-remerged') # Stage 1 - truncate dataset, fill missing reflections, change column name cmd = CommandManager('cad') cmd.add_command_line_arguments(['hklin1', in_mtz, 'hklout', tmp_mtz_1]) cmd.add_standard_input([ 'monitor BRIEF', 'labin file_number 1 ALL', 'resolution file 1 {} {}'.format(fill_resolution_low, fill_resolution_high) ]) print_run_and_raise_error_maybe(cmd) if not os.path.exists(tmp_mtz_1): raise Failure( 'filling of missing reflections has failed -- {} does not exist'. format(tmp_mtz_1)) print '-------------------' # Stage 2 - Uniqueify the file cmd = CommandManager('uniqueify') cmd.add_command_line_arguments(['-p', '0.05', tmp_mtz_1, tmp_mtz_2]) print_run_and_raise_error_maybe(cmd) if not os.path.exists(tmp_mtz_2): raise Failure( 'filling of missing reflections has failed -- {} does not exist'. format(tmp_mtz_2)) print '-------------------' # Stage 3 - remerge the two files cmd = CommandManager('cad') cmd.add_command_line_arguments( ['hklin1', in_mtz, 'hklin2', tmp_mtz_2, 'hklout', tmp_mtz_3]) cmd.add_standard_input([ 'monitor BRIEF', 'labin file_number 1 ALL', 'labin file_number 2 E1=FreeR_flag', 'labout file_number 2 E1=dummy' ]) print_run_and_raise_error_maybe(cmd) if not os.path.exists(tmp_mtz_3): raise Failure( 'filling of missing reflections has failed -- {} does not exist'. format(tmp_mtz_3)) print '-------------------' # Stage 4 - remove the dummy column cmd = CommandManager('mtzutils') cmd.add_command_line_arguments(['hklin1', tmp_mtz_3, 'hklout', out_mtz]) cmd.add_standard_input( ['HEADER BRIEF', 'EXCLUDE 1 dummy', 'ONEFILE', 'END']) print_run_and_raise_error_maybe(cmd) if not os.path.exists(tmp_mtz_3): raise Failure( 'filling of missing reflections has failed -- {} does not exist'. format(out_mtz)) if delete_tmp_files: os.remove(tmp_mtz_1) os.remove(tmp_mtz_2) os.remove(tmp_mtz_3)
def run(params): in_pdb = params.input.pdb assert os.path.exists(in_pdb), 'PDB does not exist: {}'.format(in_pdb) in_mtz = params.input.mtz if in_mtz: assert os.path.exists(in_mtz), 'MTZ does not exist: {}'.format(in_mtz) if params.output.pdb: out_pdb = params.output.pdb else: out_pdb = os.path.splitext(in_pdb)[0] + params.output.suffix + '.pdb' if params.output.mtz: out_mtz = params.output.mtz elif in_mtz: out_mtz = os.path.splitext(in_mtz)[0] + params.output.suffix + '.mtz' else: out_mtz = None if params.output.log: out_log = params.output.log else: out_log = os.path.splitext(in_pdb)[0] + params.output.suffix + '.log' ########################################### # COMMAND LINE COMMANDS ########################################### cm = CommandManager('refmac5') if in_pdb: cm.add_command_line_arguments(['xyzin', in_pdb]) if out_pdb: cm.add_command_line_arguments(['xyzout', out_pdb]) if in_mtz: cm.add_command_line_arguments(['hklin', in_mtz]) if out_mtz: cm.add_command_line_arguments(['hklout', out_mtz]) ########################################### # MAIN PARAMETERS ########################################### cm.add_standard_input('MAKE NCYC {}'.format(params.options.n_cycles)) ########################################### # HYDROGENS ########################################### if params.options.add_hydrogens: cm.add_standard_input('MAKE HYDR A') else: cm.add_standard_input('MAKE HYDR Y') if params.options.output_hydrogens: cm.add_standard_input('MAKE HOUT Y') else: cm.add_standard_input('MAKE HOUT N') ########################################### # MISSING ATOMS ########################################### if params.options.build_absent_atoms: cm.add_standard_input('MAKE BUIL Y') else: cm.add_standard_input('MAKE BUIL N') ########################################### # LASTLY ########################################### cm.add_standard_input('END') ########################################### # RUN ########################################### print 'Running Refmac:' cm.print_settings() ret_code = cm.run() cm.write_output(log_file=out_log) if ret_code != 0: print '============================>' print 'Refmac returned with an error' print '============================>' print cm.output print '============================>' print cm.error print '============================>'