def run(self):
sqlite = (
'select'
' CrystalName,'
' PANDDA_site_event_map,'
' PANDDA_site_ligand_resname,'
' PANDDA_site_ligand_chain,'
' PANDDA_site_ligand_sequence_number,'
' PANDDA_site_ligand_altLoc '
'from panddaTable '
'where PANDDA_site_event_map not like "event%"'
)
query=self.db.execute_statement(sqlite)
progress_step=1
if len(query) != 0:
progress_step=100/float(len(query))
else:
progress_step=1
progress=0
self.emit(QtCore.SIGNAL('update_progress_bar'), progress)
for item in query:
xtalID=str(item[0])
event_map=str(item[1])
resname=str(item[2])
chainID=str(item[3])
resseq=str(item[4])
altLoc=str(item[5])
if os.path.isfile(os.path.join(self.initial_model_directory,xtalID,'refine.pdb')):
os.chdir(os.path.join(self.initial_model_directory,xtalID))
self.Logfile.insert('extracting ligand (%s,%s,%s,%s) from refine.pdb' %(str(resname),str(chainID),str(resseq),str(altLoc)))
XChemUtils.pdbtools('refine.pdb').save_specific_ligands_to_pdb(resname,chainID,resseq,altLoc)
if os.path.isfile('ligand_%s_%s_%s_%s.pdb' %(str(resname),str(chainID),str(resseq),str(altLoc))):
ligand_pdb='ligand_%s_%s_%s_%s.pdb' %(str(resname),str(chainID),str(resseq),str(altLoc))
print os.path.join(self.initial_model_directory,xtalID,ligand_pdb)
else:
self.Logfile.insert('could not extract ligand; trying next...')
continue
else:
self.Logfile.insert('directory: '+os.path.join(self.initial_model_directory,xtalID)+' -> cannot find refine.pdb; trying next')
continue
if os.path.isfile(os.path.join(self.initial_model_directory,xtalID,'refine.mtz')):
resolution=XChemUtils.mtztools(os.path.join(self.initial_model_directory,xtalID,'refine.mtz')).get_high_resolution_from_mtz()
else:
self.Logfile.insert('directory: '+os.path.join(self.initial_model_directory,xtalID)+' -> cannot find refine.mtz; trying next')
continue
convert_event_map_to_SF(self.initial_model_directory,xtalID,event_map,ligand_pdb,self.xce_logfile,self.datasource,resolution).run()
progress += progress_step
self.emit(QtCore.SIGNAL('update_progress_bar'), progress)
def prepare_e_density_maps(self, xtal, ligand):
FWT, PHWT, DELFWT, PHDELWT = XChemUtils.mtztools_gemmi(
'refine.mtz').get_map_labels()
self.Logfile.insert(xtal + ': calculating 2fofc map...')
XChemUtils.maptools().calculate_map('refine.mtz', FWT, PHWT)
if os.path.isfile('refine.ccp4'):
self.Logfile.insert(xtal + ': 2fofc map successfully calculated')
else:
self.Logfile.error(xtal + ': 2fofc map could not be calculated')
self.Logfile.insert(xtal + ': cutting 2fofc map 7A around ' + ligand)
XChemUtils.maptools().cut_map_around_ligand('refine.ccp4',
ligand + '.pdb', '7')
if os.path.isfile('refine_mapmask.ccp4'):
self.Logfile.insert(xtal + ': 2fofc map around ' + ligand +
' successfully created')
else:
self.Logfile.error(xtal + ': 2fofc map around ' + ligand +
' could not be created')
os.system('/bin/mv %s %s_%s_2fofc.ccp4' %
('refine_mapmask.ccp4', xtal, ligand))
FWTmap = xtal + '_' + ligand + '_2fofc.ccp4'
self.Logfile.insert(xtal + ': current 2fofc map -> ' + xtal + '_' +
ligand + '_2fofc.ccp4')
XChemUtils.maptools().calculate_map('refine.mtz', DELFWT, PHDELWT)
XChemUtils.maptools().cut_map_around_ligand('refine.ccp4',
ligand + '.pdb', '7')
os.system('/bin/mv %s %s_%s_fofc.ccp4' %
('refine_mapmask.ccp4', xtal, ligand))
DELFWTmap = xtal + '_' + ligand + '_fofc.ccp4'
return FWTmap, DELFWTmap
def __init__(self,panddas_directory,datasource,initial_model_directory,xce_logfile,update_datasource_only,which_models):
QtCore.QThread.__init__(self)
self.panddas_directory=panddas_directory
self.datasource=datasource
self.initial_model_directory=initial_model_directory
self.db=XChemDB.data_source(self.datasource)
self.db.create_missing_columns()
self.db_list=self.db.get_empty_db_dict()
self.external_software=XChemUtils.external_software(xce_logfile).check()
self.xce_logfile=xce_logfile
self.Logfile=XChemLog.updateLog(xce_logfile)
self.update_datasource_only=update_datasource_only
self.which_models=which_models
self.already_exported_models=[]
self.RefmacParams={ 'HKLIN': '', 'HKLOUT': '',
'XYZIN': '', 'XYZOUT': '',
'LIBIN': '', 'LIBOUT': '',
'TLSIN': '', 'TLSOUT': '',
'TLSADD': '',
'NCYCLES': '10',
'MATRIX_WEIGHT': 'AUTO',
'BREF': ' bref ISOT\n',
'TLS': '',
'NCS': '',
'TWIN': '' }
def get_datasets_which_fit_to_reference_file(self,ref,reference_directory,cluster_dict,allowed_unitcell_difference_percent):
refStructure=XChemUtils.pdbtools(os.path.join(reference_directory,ref+'.pdb'))
symmRef=refStructure.get_spg_number_from_pdb()
ucVolRef=refStructure.calc_unitcell_volume_from_pdb()
cluster_dict[ref]=[]
cluster_dict[ref].append(os.path.join(reference_directory,ref+'.pdb'))
for dataset in glob.glob(os.path.join(self.data_directory,self.pdb_style)):
datasetStructure=XChemUtils.pdbtools(dataset)
symmDataset=datasetStructure.get_spg_number_from_pdb()
ucVolDataset=datasetStructure.calc_unitcell_volume_from_pdb()
if symmDataset == symmRef:
try:
difference=math.fabs(1-(float(ucVolRef)/float(ucVolDataset)))*100
if difference < allowed_unitcell_difference_percent:
sampleID=dataset.replace('/'+self.pdb_style,'')[dataset.replace('/'+self.pdb_style,'').rfind('/')+1:]
cluster_dict[ref].append(sampleID)
except ZeroDivisionError:
continue
return cluster_dict
def compare_number_of_atoms_in_reference_vs_all_datasets(self,refData,dataset_list):
mismatched_datasets=[]
pdbtools=XChemUtils.pdbtools(refData)
refPDB=refData[refData.rfind('/')+1:]
refPDBlist=pdbtools.get_init_pdb_as_list()
n_atom_ref=len(refPDBlist)
for n_datasets,dataset in enumerate(dataset_list):
if os.path.isfile(os.path.join(self.data_directory.replace('*',''),dataset,self.pdb_style)):
n_atom=len(pdbtools.get_pdb_as_list(os.path.join(self.data_directory.replace('*',''),dataset,self.pdb_style)))
if n_atom_ref == n_atom:
self.Logfile.insert('%s: atoms in PDB file (%s): %s; atoms in Reference file: %s ===> OK' %(dataset,self.pdb_style,str(n_atom),str(n_atom_ref)))
if n_atom_ref != n_atom:
self.Logfile.insert('%s: atoms in PDB file (%s): %s; atoms in Reference file: %s ===> ERROR' %(dataset,self.pdb_style,str(n_atom),str(n_atom_ref)))
mismatched_datasets.append(dataset)
return n_datasets,mismatched_datasets
def calculate_electron_density_map(self,mtzin):
missing_columns=False
column_dict=XChemUtils.mtztools(mtzin).get_all_columns_as_dict()
if 'FWT' in column_dict['F'] and 'PHWT' in column_dict['PHS']:
labin=' labin F1=FWT PHI=PHWT\n'
elif '2FOFCWT' in column_dict['F'] and 'PH2FOFCWT' in column_dict['PHS']:
labin=' labin F1=2FOFCWT PHI=PH2FOFCWT\n'
else:
missing_columns=True
if not missing_columns:
os.chdir(os.path.join(self.project_directory,self.xtalID))
cmd = (
'fft hklin '+mtzin+' mapout 2fofc.map << EOF\n'
+labin+
'EOF\n'
)
self.Logfile.insert('calculating 2fofc map from '+mtzin)
os.system(cmd)
else:
self.Logfile.insert('cannot calculate 2fofc.map; missing map coefficients')
def settings(self, xce_object):
# set XCE version
xce_object.xce_version = 'v1.4.0'
# general settings
xce_object.allowed_unitcell_difference_percent = 12
xce_object.acceptable_low_resolution_limit_for_data = 3.5
xce_object.filename_root = '${samplename}'
xce_object.data_source_set = False
xce_object.max_queue_jobs = 100
## directory settings
# set current directory and direct log to it
xce_object.current_directory = os.getcwd()
xce_object.xce_logfile = os.path.join(xce_object.current_directory,
'xce.log')
# if in the correct place, set the various directories
if 'labxchem' in xce_object.current_directory:
if len(xce_object.current_directory.split('/')
) >= 9 and xce_object.current_directory.split(
'/'
)[6] == 'processing' and xce_object.current_directory.split(
'/')[8] == 'processing':
xce_object.labxchem_directory = '/' + os.path.join(
*xce_object.current_directory.split('/')
[1:8]) # need splat operator: *
xce_object.labxchem_directory_current = '/' + os.path.join(
*xce_object.current_directory.split('/')[1:9]
) # labxchem_directory_current is where they actually have write permission
else:
xce_object.labxchem_directory = '/' + os.path.join(
*xce_object.current_directory.split('/')
[1:6]) # need splat operator: *
xce_object.labxchem_directory_current = '/' + os.path.join(
*xce_object.current_directory.split('/')
[1:7]) # need splat operator: *
# xce_object.labxchem_directory = '/' + os.path.join(
# *xce_object.current_directory.split('/')[1:6]) # need splat operator: *
xce_object.beamline_directory = os.path.join(
xce_object.labxchem_directory, 'processing', 'beamline')
if os.path.isdir(
os.path.join(xce_object.labxchem_directory, 'processing',
'analysis', 'model_building')):
xce_object.initial_model_directory = os.path.join(
xce_object.labxchem_directory, 'processing', 'analysis',
'model_building')
else:
xce_object.initial_model_directory = os.path.join(
xce_object.labxchem_directory, 'processing', 'analysis',
'initial_model')
xce_object.reference_directory = os.path.join(
xce_object.labxchem_directory, 'processing', 'reference')
xce_object.database_directory = os.path.join(
xce_object.labxchem_directory, 'processing', 'database')
xce_object.panddas_directory = os.path.join(
xce_object.labxchem_directory, 'processing', 'analysis',
'panddas')
xce_object.datasets_summary_file = os.path.join(
xce_object.database_directory,
str(os.getcwd().split('/')[5]) + '_summary.pkl')
xce_object.data_source_file = ''
xce_object.html_export_directory = os.path.join(
xce_object.labxchem_directory, 'processing', 'html')
xce_object.group_deposit_directory = os.path.join(
xce_object.labxchem_directory, 'processing',
'group_deposition')
if os.path.isfile(
os.path.join(xce_object.labxchem_directory, 'processing',
'database', 'soakDBDataFile.sqlite')):
xce_object.data_source_file = 'soakDBDataFile.sqlite'
xce_object.database_directory = os.path.join(
xce_object.labxchem_directory, 'processing', 'database')
xce_object.data_source_set = True
xce_object.db = XChemDB.data_source(
os.path.join(xce_object.database_directory,
xce_object.data_source_file))
xce_object.db.create_missing_columns()
xce_object.ccp4_scratch_directory = os.path.join(
xce_object.labxchem_directory, 'processing', 'tmp')
directory_list = [
xce_object.beamline_directory,
os.path.join(xce_object.labxchem_directory, 'processing',
'analysis'), xce_object.initial_model_directory,
xce_object.panddas_directory, xce_object.reference_directory,
xce_object.database_directory,
xce_object.ccp4_scratch_directory,
xce_object.html_export_directory,
xce_object.group_deposit_directory
]
for directory in directory_list:
if not os.path.isdir(directory):
os.mkdir(directory)
# otherwise, use the current working directory
else:
xce_object.labxchem_directory_current = xce_object.current_directory
xce_object.beamline_directory = xce_object.current_directory
xce_object.initial_model_directory = xce_object.current_directory
xce_object.reference_directory = xce_object.current_directory
xce_object.database_directory = xce_object.current_directory
xce_object.data_source_file = ''
xce_object.ccp4_scratch_directory = os.getenv('CCP4_SCR')
xce_object.panddas_directory = xce_object.current_directory
xce_object.datasets_summary_file = ''
xce_object.group_deposit_directory = xce_object.current_directory
## deposition
xce_object.deposit_dict = {}
## internal lists and dictionaries
xce_object.data_collection_list = []
xce_object.visit_list = []
xce_object.target = ''
xce_object.dataset_outcome_combobox_dict = {}
xce_object.data_collection_dict = {}
xce_object.xtal_db_dict = {}
xce_object.pandda_analyse_input_table_dict = {}
xce_object.dewar_configuration_dict = {}
xce_object.data_collection_statistics_dict = {}
xce_object.initial_model_dimple_dict = {
} # contains toggle button if dimple should be run
xce_object.reference_file_list = []
xce_object.all_columns_in_data_source = XChemDB.data_source(os.path.join
(xce_object.database_directory,
xce_object.data_source_file)) \
.return_column_list()
xce_object.albula_button_dict = {
} # using dials.image_viewer instead of albula, but keep name for dictionary
xce_object.xtalform_dict = {}
xce_object.dataset_outcome_dict = {
} # contains the dataset outcome buttons
xce_object.data_collection_table_dict = {
} # contains the dataset table
xce_object.data_collection_image_dict = {}
xce_object.data_collection_column_three_dict = {}
xce_object.datasets_summary_dict = {}
xce_object.diffraction_data_table_dict = {}
xce_object.refinement_table_dict = {}
xce_object.main_data_collection_table_exists = False
xce_object.timer_to_check_for_new_data_collection = QtCore.QTimer()
xce_object.agamemnon = False
xce_object.target_list, xce_object.visit_list = XChemMain.get_target_and_visit_list(
xce_object.beamline_directory, False)
xce_object.diffraction_data_dict = {}
## internal switches and flags
xce_object.explorer_active = 0
xce_object.coot_running = 0
xce_object.progress_bar_start = 0
xce_object.progress_bar_step = 0
xce_object.albula = None
xce_object.albula_subframes = []
xce_object.show_diffraction_image = None
xce_object.gdaLogInstructions = [0, False]
# can be any widget to be displayed in data collection summary tab
xce_object.data_collection_details_currently_on_display = None
xce_object.dataset_outcome = [
"success", "Failed - centring failed", "Failed - no diffraction",
"Failed - processing", "Failed - loop empty",
"Failed - loop broken", "Failed - low resolution",
"Failed - no X-rays", "Failed - unknown"
]
xce_object.refinement_stage = [
'0 - All Datasets', '1 - Analysis Pending', '2 - PANDDA model',
'3 - In Refinement', '4 - CompChem ready', '5 - Deposition ready',
'6 - Deposited'
]
self.set_xce_logfile(xce_object)
## external software packages
xce_object.using_remote_qsub_submission = False
xce_object.remote_qsub_submission = "/usr/bin/ssh <dls fed ID>@nx.diamond.ac.uk 'module load global/cluster; qsub'"
xce_object.update_log = XChemLog.updateLog(xce_object.xce_logfile)
xce_object.update_log.insert('new session started')
xce_object.diffraction_data_directory = xce_object.current_directory
xce_object.diffraction_data_search_info = 'n/a'
xce_object.diffraction_data_reference_mtz = 'ignore'
xce_object.html_export_directory = os.getcwd()
xce_object.external_software = XChemUtils.external_software(
xce_object.xce_logfile).check()
xce_object.second_cif_file = None
software_list = ['acedrg', 'phenix.elbow', 'grade']
for software in software_list:
if xce_object.external_software[software]:
xce_object.restraints_program = str(software)
xce_object.update_log.insert(
'will use ' + str(software) +
' for generation of ligand coordinates and'
' restraints')
else:
xce_object.restraints_program = ''
xce_object.update_log.insert(
'No program for generation of ligand coordinates and restraints available!'
)
def RefreshData(self):
# initialize Refinement library
self.Refine=XChemRefine.Refine(self.project_directory,self.xtalID,self.compoundID,self.data_source)
self.Serial=self.Refine.GetSerial()
if self.Serial==1:
# i.e. no refinement has been done; data is probably straight out of dimple
if os.path.isfile(os.path.join(self.project_directory,self.xtalID,self.pdb_style)):
print '==> XCE: updating quality indicators in data source for '+self.xtalID
XChemUtils.parse().update_datasource_with_PDBheader(self.xtalID,self.data_source,os.path.join(self.project_directory,self.xtalID,self.pdb_style))
XChemUtils.parse().update_datasource_with_phenix_validation_summary(self.xtalID,self.data_source,'') # '' because file does not exist
elif os.path.isfile(os.path.join(self.project_directory,self.xtalID,'dimple.pdb')):
print '==> XCE: updating quality indicators in data source for '+self.xtalID
XChemUtils.parse().update_datasource_with_PDBheader(self.xtalID,self.data_source,os.path.join(self.project_directory,self.xtalID,'dimple.pdb'))
XChemUtils.parse().update_datasource_with_phenix_validation_summary(self.xtalID,self.data_source,'') # '' because file does not exist
# all this information is now updated in the datasource after each refinement cycle
self.QualityIndicators=self.db.get_db_dict_for_sample(self.xtalID)
if int(self.selected_site[0]) > 0:
self.spider_plot_data=self.db.get_db_pandda_dict_for_sample_and_site(self.xtalID,self.selected_site[0])
self.ligandIDValue.set_label(self.spider_plot_data['PANDDA_site_ligand_id'])
try:
self.ligand_occupancyValue.set_label( str(round(float(self.spider_plot_data['PANDDA_site_occupancy']),2)) )
self.ligand_BaverageValue.set_label( str(round(float(self.spider_plot_data['PANDDA_site_B_average']),2)) )
self.ligand_BratioSurroundingsValue.set_label( str(round(float(self.spider_plot_data['PANDDA_site_B_ratio_residue_surroundings']),2)) )
self.ligand_RSCCValue.set_label( str(round(float(self.spider_plot_data['PANDDA_site_RSCC']),2)) )
self.ligand_rmsdValue.set_label( str(round(float(self.spider_plot_data['PANDDA_site_rmsd']),2)) )
self.ligand_RSRValue.set_label( str(round(float(self.spider_plot_data['PANDDA_site_RSR']),2)) )
self.ligand_RSZDValue.set_label( str(round(float(self.spider_plot_data['PANDDA_site_RSZD']),2)) )
except ValueError:
self.ligand_occupancyValue.set_label('-')
self.ligand_BaverageValue.set_label('-')
self.ligand_BratioSurroundingsValue.set_label('-')
self.ligand_RSCCValue.set_label('-')
self.ligand_rmsdValue.set_label('-')
self.ligand_RSRValue.set_label('-')
self.ligand_RSZDValue.set_label('-')
#########################################################################################
# history
# if the structure was previously refined, try to read the parameters
# self.hbox_for_info_graphics.remove(self.canvas)
if self.Serial > 1:
self.RefmacParams=self.Refine.ParamsFromPreviousCycle(self.Serial-1)
# refinement_cycle,Rfree,Rcryst=self.Refine.GetRefinementHistory()
# self.canvas = FigureCanvas(self.update_plot(refinement_cycle,Rfree,Rcryst))
# else:
# self.canvas = FigureCanvas(self.update_plot([0],[0],[0])) # a gtk.DrawingArea
# self.canvas.set_size_request(190, 190)
# self.hbox_for_info_graphics.add(self.canvas)
# self.canvas.show()
#########################################################################################
# Spider plot
# Note: refinement history was shown instead previously
if os.path.isfile(self.spider_plot):
spider_plot_pic = gtk.gdk.pixbuf_new_from_file(self.spider_plot)
else:
spider_plot_pic = gtk.gdk.pixbuf_new_from_file(os.path.join(os.getenv('XChemExplorer_DIR'),'image','NO_SPIDER_PLOT_AVAILABLE.png'))
self.spider_plot_pic = spider_plot_pic.scale_simple(190, 190, gtk.gdk.INTERP_BILINEAR)
self.spider_plot_image.set_from_pixbuf(self.spider_plot_pic)
#########################################################################################
# update pdb & maps
#########################################################################################
# delete old PDB and MAP files
# - get a list of all molecules which are currently opened in COOT
# - remove all molecules/ maps before loading a new set
if len(coot_utils_XChem.molecule_number_list()) > 0:
for item in coot_utils_XChem.molecule_number_list():
coot.close_molecule(item)
#########################################################################################
# read new PDB files
# read protein molecule after ligand so that this one is the active molecule
coot.set_nomenclature_errors_on_read("ignore")
if os.path.isfile(os.path.join(self.project_directory,self.xtalID,self.compoundID+'.pdb')):
imol=coot.handle_read_draw_molecule_with_recentre(os.path.join(self.project_directory,self.xtalID,self.compoundID+'.pdb'),0)
self.mol_dict['ligand']=imol
coot.read_cif_dictionary(os.path.join(self.project_directory,self.xtalID,self.compoundID+'.cif'))
if not os.path.isfile(os.path.join(self.project_directory,self.xtalID,self.pdb_style)):
os.chdir(os.path.join(self.project_directory,self.xtalID))
# we want to be able to check dimple results immediately, but don't want to interfere with refinement
# if not os.path.isfile('REFINEMENT_IN_PROGRESS'):
# if os.path.isfile(os.path.join(self.project_directory,self.xtalID,self.xtalID+'-ensemble-model.pdb')):
# os.symlink(self.xtalID+'-ensemble-model.pdb',self.pdb_style)
# elif os.path.isfile(os.path.join(self.project_directory,self.xtalID,'dimple.pdb')):
# os.symlink('dimple.pdb',self.pdb_style)
# else:
# self.go_to_next_xtal()
if os.path.isfile(os.path.join(self.project_directory,self.xtalID,self.pdb_style)):
os.chdir(os.path.join(self.project_directory,self.xtalID))
imol=coot.handle_read_draw_molecule_with_recentre(os.path.join(self.project_directory,self.xtalID,self.pdb_style),0)
elif os.path.isfile(os.path.join(self.project_directory,self.xtalID,'dimple.pdb')):
os.chdir(os.path.join(self.project_directory,self.xtalID))
imol=coot.handle_read_draw_molecule_with_recentre(os.path.join(self.project_directory,self.xtalID,'dimple.pdb'),0)
else:
self.go_to_next_xtal()
self.mol_dict['protein']=imol
for item in coot_utils_XChem.molecule_number_list():
if coot.molecule_name(item).endswith(self.pdb_style):
coot.set_show_symmetry_master(1) # master switch to show symmetry molecules
coot.set_show_symmetry_molecule(item,1) # show symm for model
#########################################################################################
# read fofo maps
# - read ccp4 map: 0 - 2fofc map, 1 - fofc.map
# read 2fofc map last so that one can change its contour level
if os.path.isfile(os.path.join(self.project_directory,self.xtalID,'2fofc.map')):
coot.set_default_initial_contour_level_for_difference_map(3)
coot.handle_read_ccp4_map(os.path.join(self.project_directory,self.xtalID,'fofc.map'),1)
coot.set_default_initial_contour_level_for_map(1)
coot.handle_read_ccp4_map(os.path.join(self.project_directory,self.xtalID,'2fofc.map'),0)
coot.set_last_map_colour(0,0,1)
else:
# try to open mtz file with same name as pdb file
coot.set_default_initial_contour_level_for_map(1)
# if not os.path.isfile(os.path.join(self.project_directory,self.xtalID,self.mtz_style)):
# os.chdir(os.path.join(self.project_directory,self.xtalID))
# if not os.path.isfile('REFINEMENT_IN_PROGRESS'):
# if os.path.isfile(os.path.join(self.project_directory,self.xtalID,self.xtalID+'-pandda-input.mtz')):
# os.symlink(self.xtalID+'-pandda-input.mtz',self.mtz_style)
# elif os.path.isfile(os.path.join(self.project_directory,self.xtalID,'dimple.mtz')):
# os.symlink('dimple.mtz',self.mtz_style)
if os.path.isfile(os.path.join(self.project_directory,self.xtalID,self.mtz_style)):
coot.auto_read_make_and_draw_maps(os.path.join(self.project_directory,self.xtalID,self.mtz_style))
elif os.path.isfile(os.path.join(self.project_directory,self.xtalID,'dimple.mtz')):
coot.auto_read_make_and_draw_maps(os.path.join(self.project_directory,self.xtalID,'dimple.mtz'))
#########################################################################################
# check for PANDDAs EVENT maps
if os.path.isfile(self.event_map):
coot.handle_read_ccp4_map((self.event_map),0)
for imol in coot_utils_XChem.molecule_number_list():
if self.event_map in coot.molecule_name(imol):
coot.set_contour_level_in_sigma(imol,2)
# coot.set_contour_level_absolute(imol,0.5)
coot.set_last_map_colour(0.4,0,0.4)
# #########################################################################################
# # update Ligand Confidence combobox
# if str(self.ligand_confidence_of_sample)=='None':
# self.ligand_confidence_of_sample='Analysis Pending'
# db_dict={'RefinementLigandConfidence': self.ligand_confidence_of_sample}
## self.db.update_data_source(self.xtalID,db_dict)
# for n,criteria in enumerate(self.ligand_confidence):
# if criteria.replace('Ligand Confidence: ','')==self.ligand_confidence_of_sample:
# self.cb_ligand_confidence.set_active(n)
#########################################################################################
# update Quality Indicator table
try:
self.RRfreeValue.set_label( str(round(float(self.QualityIndicators['RefinementRcryst']),3)) +' / '+str(round(float(self.QualityIndicators['RefinementRfree']),3)))
except ValueError:
self.RRfreeValue.set_label('-')
try:
self.RRfreeBox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['RefinementRfreeTraficLight']))
except ValueError:
pass
self.ResolutionValue.set_label(self.QualityIndicators['RefinementResolution'])
try:
self.ResolutionBox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['RefinementResolutionTL']))
except ValueError:
pass
self.MolprobityScoreValue.set_label(self.QualityIndicators['RefinementMolProbityScore'])
try:
self.MolprobityScoreBox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['RefinementMolProbityScoreTL']))
except ValueError:
pass
self.RamachandranOutliersValue.set_label(self.QualityIndicators['RefinementRamachandranOutliers'])
try:
self.RamachandranOutliersBox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['RefinementRamachandranOutliersTL']))
except ValueError:
pass
self.RamachandranFavoredValue.set_label(self.QualityIndicators['RefinementRamachandranFavored'])
try:
self.RamachandranFavoredBox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['RefinementRamachandranFavoredTL']))
except ValueError:
pass
self.rmsdBondsValue.set_label(self.QualityIndicators['RefinementRmsdBonds'])
try:
self.rmsdBondsBox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['RefinementRmsdBondsTL']))
except ValueError:
pass
self.rmsdAnglesValue.set_label(self.QualityIndicators['RefinementRmsdAngles'])
try:
self.rmsdAnglesBox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(self.QualityIndicators['RefinementRmsdAnglesTL']))
except ValueError:
pass
self.MatrixWeightValue.set_label(self.QualityIndicators['RefinementMatrixWeight'])
try:
pic = gtk.gdk.pixbuf_new_from_file(os.path.join(self.project_directory,self.xtalID,self.compoundID+'.png'))
except gobject.GError:
pic = gtk.gdk.pixbuf_new_from_file(os.path.join(os.getenv('XChemExplorer_DIR'),'image','NO_COMPOUND_IMAGE_AVAILABLE.png'))
self.pic = pic.scale_simple(190, 190, gtk.gdk.INTERP_BILINEAR)
self.image.set_from_pixbuf(self.pic)
def __init__(self):
###########################################################################################
# read in settings file from XChemExplorer to set the relevant paths
print 'current dir',os.getcwd()
self.settings = pickle.load(open(".xce_settings.pkl","rb"))
print 'setting',self.settings
# self.refine_model_directory=self.settings['refine_model_directory']
self.database_directory=self.settings['database_directory']
self.xce_logfile=self.settings['xce_logfile']
self.data_source=self.settings['data_source']
self.db=XChemDB.data_source(self.data_source)
# checking for external software packages
self.external_software=XChemUtils.external_software(self.xce_logfile).check()
self.selection_criteria = [ '0 - All Datasets',
'1 - Analysis Pending',
'2 - PANDDA model',
'3 - In Refinement',
'4 - CompChem ready',
'5 - Deposition ready',
'6 - Deposited' ]
self.experiment_stage = [ ['Review PANDDA export', '2 - PANDDA model', 65000, 0, 0],
['In Refinement', '3 - In Refinement', 65000, 0, 0],
['Comp Chem Ready!', '4 - CompChem ready', 65000, 0, 0],
['Ready for Deposition!', '5 - Deposition ready', 65000, 0, 0] ]
self.ligand_confidence_category = [ '0 - no ligand present',
'1 - Low Confidence',
'2 - Correct ligand, weak density',
'3 - Clear density, unexpected ligand',
'4 - High Confidence' ]
self.ligand_site_information = self.db.get_list_of_pandda_sites_for_coot()
# this decides which samples will be looked at
self.selection_mode = ''
self.selected_site=''
# the Folder is kind of a legacy thing because my inital idea was to have separate folders
# for Data Processing and Refinement
self.project_directory = self.settings['initial_model_directory']
self.Serial=0
self.Refine=None
self.index = -1
self.Todo=[]
self.xtalID=''
self.compoundID=''
self.spider_plot=''
self.ligand_confidence=''
self.refinement_folder=''
# self.datasetOutcome=''
self.pdb_style='refine.pdb'
self.mtz_style='refine.mtz'
# stores imol of currently loaded molecules and maps
self.mol_dict = { 'protein': -1,
'ligand': -1,
'2fofc': -1,
'fofc': -1,
'event': -1 }
# two dictionaries which are flushed when a new crystal is loaded
# and which contain information to update the data source if necessary
self.db_dict_mainTable={}
self.db_dict_panddaTable={}
###########################################################################################
# some COOT settings
coot.set_map_radius(15)
coot.set_colour_map_rotation_for_map(0)
coot.set_colour_map_rotation_on_read_pdb_flag(0)
self.QualityIndicators = { 'RefinementRcryst': '-',
'RefinementRfree': '-',
'RefinementRfreeTraficLight': 'gray',
'RefinementResolution': '-',
'RefinementResolutionTL': 'gray',
'RefinementMolProbityScore': '-',
'RefinementMolProbityScoreTL': 'gray',
'RefinementRamachandranOutliers': '-',
'RefinementRamachandranOutliersTL': 'gray',
'RefinementRamachandranFavored': '-',
'RefinementRamachandranFavoredTL': 'gray',
'RefinementRmsdBonds': '-',
'RefinementRmsdBondsTL': 'gray',
'RefinementRmsdAngles': '-',
'RefinementRmsdAnglesTL': 'gray',
'RefinementMatrixWeight': '-' }
self.spider_plot_data = { 'PANDDA_site_ligand_id': '-',
'PANDDA_site_occupancy': '-',
'PANDDA_site_B_average': '-',
'PANDDA_site_B_ratio_residue_surroundings': '-',
'PANDDA_site_RSCC': '-',
'PANDDA_site_rmsd': '-',
'PANDDA_site_RSR': '-',
'PANDDA_site_RSZD': '-' }
# default refmac parameters
self.RefmacParams={ 'HKLIN': '', 'HKLOUT': '',
'XYZIN': '', 'XYZOUT': '',
'LIBIN': '', 'LIBOUT': '',
'TLSIN': '', 'TLSOUT': '',
'TLSADD': '',
'NCYCLES': '10',
'MATRIX_WEIGHT': 'AUTO',
'BREF': ' bref ISOT\n',
'TLS': '',
'NCS': '',
'TWIN': '' }
def update_pdb_mtz_files(self, pdbRoot):
# first remove all pdb and mtz files from memory
self.Logfile.insert('removing all PDB and MTZ files from memory')
if len(coot_utils_XChem.molecule_number_list()) > 0:
for item in coot_utils_XChem.molecule_number_list():
if coot.molecule_name(item).endswith(
'.pdb') or '.mtz' in coot.molecule_name(item):
self.Logfile.insert('removing %s' %
coot.molecule_name(item))
coot.close_molecule(item)
coot.set_nomenclature_errors_on_read("ignore")
# first we check if there is a refinement folder and the respective refine.pdb
# from previous refinement cycles
Root = self.cb_select_pdb.get_active_text()
print 'ROOT', Root
print 'REFI_DIR', os.path.join(self.reference_directory,
self.refinementDir, 'refine.pdb')
if os.path.isfile(
os.path.join(self.reference_directory, self.refinementDir,
'refine.pdb')):
os.chdir(self.reference_directory)
print 'CURRENT DIR', os.getcwd()
os.system('/bin/rm %s 2> /dev/null' % Root)
os.symlink(
os.path.realpath(os.path.join(self.refinementDir,
'refine.pdb')), '%s' % Root)
self.pdbFile = os.path.join(self.reference_directory,
self.refinementDir, 'refine.pdb')
elif os.path.isfile(os.path.join(self.reference_directory, Root)):
self.pdbFile = os.path.join(self.reference_directory, Root)
else:
self.Logfile.error('cannot find PDB file')
if self.pdbFile != '':
# os.chdir(os.path.join(self.reference_directory,self.refinementDir))
coot.set_colour_map_rotation_on_read_pdb(0)
imol = coot.handle_read_draw_molecule_with_recentre(
self.pdbFile, 0)
self.QualityIndicators = XChemUtils.parse().PDBheader(
os.path.join(self.pdbFile))
self.QualityIndicators.update(
XChemUtils.logtools(
os.path.join(self.reference_directory, self.refinementDir,
'refine_molprobity.log')).phenix_molprobity())
self.QualityIndicators.update(
XChemUtils.logtools(
os.path.join(self.reference_directory, self.refinementDir,
'Refine_' + str(self.Serial),
'refmac.log')).refmac_log())
self.mol_dict['protein'] = imol
if self.mtzFree == '':
print 'FREE', os.path.join(
self.reference_directory,
pdbRoot.replace('.pdb', '') + '.free.mtz')
if os.path.isfile(
os.path.join(self.reference_directory,
pdbRoot.replace('.pdb', '') + '.free.mtz')):
self.mtzFree = os.path.join(
self.reference_directory,
pdbRoot.replace('.pdb', '') + '.free.mtz')
self.mtzFree_label.set_text(
pdbRoot.replace('.pdb', '') + '.free.mtz')
self.REFINEbutton.set_sensitive(True)
else:
self.mtzFree_label.set_text('missing file')
self.Logfile.error(
'cannot find file with F,SIGF and FreeR_flag; cannot start refinement'
)
self.REFINEbutton.set_sensitive(False)
self.mtzRefine = ''
if os.path.isfile(
os.path.join(self.reference_directory, self.refinementDir,
'refine.mtz')):
self.mtzRefine = os.path.join(self.reference_directory,
self.refinementDir, 'refine.mtz')
mtzRefineReal = os.path.realpath(
os.path.join(self.reference_directory, self.refinementDir,
'refine.mtz'))
mtzRefineCurrent = mtzRefineReal.replace(
os.path.join(self.reference_directory,
self.refinementDir + '/'), '')
self.mtzRefine_label.set_text(mtzRefineCurrent)
coot.set_default_initial_contour_level_for_map(1)
if os.path.isfile(
os.path.join(self.reference_directory, self.refinementDir,
self.mtz_style)):
coot.auto_read_make_and_draw_maps(
os.path.join(self.reference_directory, self.refinementDir,
self.mtz_style))
else:
self.mtzRefine_label.set_text('missing file')
self.Logfile.warning(
'cannot find file with F,SIGF and FreeR_flag; cannot start refinement'
)
groundStateMap = os.path.join(self.reference_directory,
Root + '-mean-map.native.ccp4').replace(
'.pdb', '')
print '===>', groundStateMap
if os.path.isfile(groundStateMap):
imol = coot.handle_read_ccp4_map(groundStateMap, 0)
coot.set_contour_level_in_sigma(imol, 1)
coot.set_last_map_colour(0.6, 0.6, 0)
else:
print '==> XCE: ERROR - cannot find ground state mean map!'
self.RefreshData()
def __init__(self):
###########################################################################################
# read in settings file from XChemExplorer to set the relevant paths
self.settings = pickle.load(open(".xce_settings.pkl", "rb"))
remote_qsub_submission = self.settings['remote_qsub']
self.database_directory = self.settings['database_directory']
self.xce_logfile = self.settings['xce_logfile']
self.Logfile = XChemLog.updateLog(self.xce_logfile)
self.Logfile.insert('starting COOT gui for reference model refinement')
self.data_source = self.settings['data_source']
# checking for external software packages
self.external_software = XChemUtils.external_software(
self.xce_logfile).check()
self.external_software['qsub_remote'] = remote_qsub_submission
# the Folder is kind of a legacy thing because my inital idea was to have separate folders
# for Data Processing and Refinement
self.reference_directory = self.settings['reference_directory']
self.refinementDir = ''
self.Serial = 0
self.Refine = None
self.xtalID = ''
self.compoundID = ''
self.spider_plot = ''
self.refinement_folder = ''
self.pdbFile = ''
self.mtzFree = ''
self.pdb_style = 'refine.pdb'
self.mtz_style = 'refine.mtz'
# stores imol of currently loaded molecules and maps
self.mol_dict = {
'protein': -1,
'ligand': -1,
'2fofc': -1,
'fofc': -1,
'event': -1
}
self.ground_state_map_List = []
self.job_running = False
###########################################################################################
# some COOT settings
coot.set_map_radius(17)
coot.set_colour_map_rotation_for_map(0)
# coot.set_colour_map_rotation_on_read_pdb_flag(21)
self.QualityIndicators = {
'Rcryst': '-',
'Rfree': '-',
'RfreeTL': 'gray',
'ResolutionHigh': '-',
'ResolutionColor': 'gray',
'MolprobityScore': '-',
'MolprobityScoreColor': 'gray',
'RamachandranOutliers': '-',
'RamachandranOutliersColor': 'gray',
'RamachandranFavored': '-',
'RamachandranFavoredColor': 'gray',
'rmsdBonds': '-',
'rmsdBondsTL': 'gray',
'rmsdAngles': '-',
'rmsdAnglesTL': 'gray',
'MatrixWeight': '-'
}
# default refmac parameters
self.RefmacParams = {
'HKLIN': '',
'HKLOUT': '',
'XYZIN': '',
'XYZOUT': '',
'LIBIN': '',
'LIBOUT': '',
'TLSIN': '',
'TLSOUT': '',
'TLSADD': '',
'NCYCLES': '10',
'MATRIX_WEIGHT': 'AUTO',
'BREF': ' bref ISOT\n',
'TLS': '',
'NCS': '',
'TWIN': ''
}
def prepare(self, whichSamples):
self.Logfile.insert('======== preparing HTML summary ========')
self.makeFolders()
self.copy_jscss()
html = XChemMain.html_header()
firstFile = True
for xtal in self.db.samples_for_html_summary(whichSamples):
self.db_dict = self.db.get_db_dict_for_sample(xtal)
if firstFile:
if self.db_dict['ProteinName'] == 'None':
self.Logfile.warning('could not determine protein name')
try:
self.protein_name = xtal.split('-')[0]
self.Logfile.warning(
'xtal name = %s => setting protein name to %s' %
(xtal, self.protein_name))
except IndexError:
self.Logfile.warning(
'could not determine protein name from cystal name; setting to None'
)
self.protein_name = ''
else:
self.protein_name = self.db_dict['ProteinName']
self.Logfile.insert('protein name is: ' +
self.protein_name)
self.copy_pdb(xtal)
self.copy_mtz(xtal)
# self.copy_electron_density(xtal)
self.copy_ligand_files(xtal)
os.chdir(os.path.join(self.projectDir, xtal))
ligandDict = XChemUtils.pdbtools_gemmi(
'refine.pdb').center_of_mass_ligand_dict('LIG')
self.Logfile.insert(
xtal +
': saving ligand(s) of type LIG in refine.pdb as PDB files...')
XChemUtils.pdbtools_gemmi('refine.pdb').save_ligands_to_pdb('LIG')
for ligand in ligandDict:
self.Logfile.insert(xtal + ': current ligand -> ' + ligand)
os.chdir(os.path.join(self.projectDir, xtal))
# for ligand in self.ligands_in_pdbFile(xtal):
ligName = ligand.split('-')[0]
ligChain = ligand.split('-')[1]
ligNumber = ligand.split('-')[2]
# eventMap = self.find_matching_event_map_from_database(xtal, ligand)
# if eventMap:
# self.Logfile.insert('%s: using the following event map -> %s' %(xtal,eventMap))
# self.cut_and_copy_map(xtal, ligand+'.pdb', eventMap, xtal + '_' + ligand + '_event.ccp4','F','PHIF')
# eventMap = xtal + '_' + ligand + '_event.ccp4'
# else:
# self.Logfile.error('%s: value of event map -> %s' %(xtal,eventMap))
eventMap = ''
# self.Logfile.insert(xtal + ': looking for' + xtal + '_' + ligand + '_event.ccp4')
if os.path.isfile(xtal + '_' + ligand + '_event.ccp4'):
eventMap = xtal + '_' + ligand + '_event.ccp4'
# self.Logfile.insert(xtal + ': found ' + eventMap)
# else:
# self.Logfile.error(xtal + ': cannot find' + xtal + '_' + ligand + '_event.ccp4')
# x,y,z = self.pdb.get_centre_of_gravity_of_residue(ligand)
x = ligandDict[ligand][0]
y = ligandDict[ligand][1]
z = ligandDict[ligand][2]
self.copy_spider_plot(xtal, ligand)
pdbID = self.db_dict['Deposition_PDB_ID']
compoundImage = xtal + '_' + self.db_dict[
'CompoundCode'] + '.png'
compoundCIF = xtal + '_' + self.db_dict['CompoundCode'] + '.cif'
residuePlot = xtal + '_' + ligand + '.png'
pdb = xtal + '.pdb'
event = xtal + '_' + ligand + '_event.ccp4'
thumbNail = xtal + '_' + ligand + '_thumb.png'
resoHigh = self.db_dict['DataProcessingResolutionHigh']
spg = self.db_dict['RefinementSpaceGroup']
unitCell = self.db_dict['DataProcessingUnitCell']
t = ''
for ax in unitCell.split():
t += str(round(float(ax), 1)) + ' '
unitCell = t[:-1]
os.chdir(os.path.join(self.projectDir, xtal))
# FWT = xtal + '-' + ligand + '_2fofc.ccp4'
# self.cut_and_copy_map(xtal, ligand + '.pdb', '2fofc.map', FWT,'FWT','PHWT')
# DELFWT = xtal + '-' + ligand + '_fofc.ccp4'
# self.cut_and_copy_map(xtal, ligand + '.pdb', 'fofc.map', DELFWT,'DELFWT','PHDELWT')
if os.path.isfile('refine.mtz'):
self.Logfile.insert('%s: found refine.mtz' % xtal)
FWTmap, DELFWTmap = self.prepare_e_density_maps(
xtal, ligand)
self.copy_electron_density(xtal, ligand, eventMap)
ligConfidence = self.db.get_ligand_confidence_for_ligand(
xtal, ligChain, ligNumber, ligName)
if ligConfidence.startswith('0'):
self.Logfile.warning(
'%s: ligand confidence of %s-%s-%s is %s; ignoring...'
% (xtal, ligChain, ligNumber, ligName, ligConfidence))
self.Logfile.warning(
'%s: this seems unlikely because this structure is apparently ready for deposition'
% xtal)
self.Logfile.warning(
'%s: will set it to "not assigned" for now, but please update in soakDB'
% xtal)
ligConfidence = 'not assigned'
modelStatus = self.db_dict['RefinementOutcome']
if firstFile:
html += XChemMain.html_ngl(
pdb, eventMap.replace(self.projectDir, ''), FWTmap,
DELFWTmap, ligand)
html += XChemMain.html_download(self.protein_name)
html += XChemMain.html_guide()
html += XChemMain.html_table_header()
firstFile = False
html += XChemMain.html_table_row(xtal, pdbID, ligand,
compoundImage, residuePlot,
pdb, event, thumbNail,
resoHigh, spg, unitCell,
FWTmap, DELFWTmap,
ligConfidence, modelStatus)
self.make_thumbnail(xtal, x, y, z, ligand, eventMap)
self.prepare_for_download(xtal, pdb, event, compoundCIF,
ligand)
self.prepare_zip_archives()
# html = XChemMain.html_download_all_section(html,self.protein_name)
self.write_html_file(html)
self.Logfile.insert(
'======== finished preparing HTML summary ========')
