def run(self): model = self.data_manager.get_model() # Temporarly disable # self.params.output.prefix=self.data_manager.get_default_model_name().split('.')[0] # self.params.output.suffix='_helix' # self.data_manager.set_default_output_filename(self.get_default_output_filename()) self.rama_z = rama_z.rama_z(model=model, log=self.logger) # self.data_manager.write_model_file(model) # self.params.output.suffix='_sheet' # self.data_manager.set_default_output_filename(self.get_default_output_filename()) # self.data_manager.write_model_file(model) result = self.get_results() if result is None: print("Calculation of z-score failed for some reason", file=self.logger) else: for k in ["whole", "helix", "sheet", "loop"]: rc = k[0].upper() v = result.get(rc, None) if v is None: print("z-score %-5s: None, residues: %d" % (k, result['residue_counts'][rc]), file=self.logger) else: print("z-score %-5s: %6.3f (%5.3f), residues: %d" % (k, v[0], v[1], result['residue_counts'][rc]), file=self.logger)
def check_function(): inp = iotbx.pdb.input(fname) model = mmtbx.model.manager(model_input=inp) zs = rama_z(model, log=null_out()) z_scores = zs.get_z_scores() ss_cont = zs.get_residue_counts() # print (z_scores) # print (ss_cont) expected_z = { 'H': -2.7111077448509953, 'S': None, 'L': -0.7253113914835396, 'W': -1.0306993840276084 } expeted_ss = {'H': 277, 'S': 0, 'L': 15041, 'W': 15318} for k in expected_z: if z_scores[k] is not None: assert approx_equal(z_scores[k][0], expected_z[k]) if k == 'W': assert 0.01 < z_scores[k][1] < 0.1, z_scores[k][1] if k != 'weighted_mean': assert approx_equal(ss_cont[k], expeted_ss[k]) # check how separate scores translate to whole h_score = (z_scores['H'][0] * zs.calibration_values['H'][1] + zs.calibration_values['H'][0]) * ss_cont['H'] l_score = (z_scores['L'][0] * zs.calibration_values['L'][1] + zs.calibration_values['L'][0]) * ss_cont['L'] w_score = ((h_score + l_score) / (ss_cont['H'] + ss_cont['L']) - zs.calibration_values['W'][0]) / zs.calibration_values['W'][1] # print ("reconstructed:", w_score, z_scores['W'][0]) assert approx_equal(w_score, z_scores['W'][0])
def check_function(): inp = iotbx.pdb.input(fname) model = mmtbx.model.manager(model_input=inp) zs = rama_z([model], log=null_out()) z_scores = zs.get_z_scores() ss_cont = zs.get_residue_counts() # print (z_scores) # print (ss_cont) expected_z = { 'H': None, 'S': (-0.057428666470734, 0.5840017477579902), 'L': (-0.3588028726184504, 0.6941226745661744), 'W': (-0.4019606027769244, 0.6621289642029733) } expeted_ss = {'H': 0, 'S': 63, 'L': 71, 'W': 134} for k in expected_z: if z_scores[k] is not None: assert approx_equal(z_scores[k], expected_z[k], eps=1e-5) assert approx_equal(ss_cont[k], expeted_ss[k]) # check how separate scores translate to whole s_score = (z_scores['S'][0] * zs.calibration_values['S'][1] + zs.calibration_values['S'][0]) * ss_cont['S'] l_score = (z_scores['L'][0] * zs.calibration_values['L'][1] + zs.calibration_values['L'][0]) * ss_cont['L'] w_score = ((s_score + l_score) / (ss_cont['S'] + ss_cont['L']) - zs.calibration_values['W'][0]) / zs.calibration_values['W'][1] # print ("reconstructed:", w_score, z_scores['W'][0]) assert approx_equal(w_score, z_scores['W'][0])
def run(self): models = [] for model_name in self.data_manager.get_model_names(): models.append(self.data_manager.get_model(model_name)) # model = self.data_manager.get_model() self.inp_fn = os.path.basename( self.data_manager.get_default_model_name())[:-4] self.rama_z = rama_z.rama_z(models=models, log=self.logger) if len(models) == 1: model = models[0] cs = model.crystal_symmetry() if cs is None: model = shift_and_box_model(model) self._write_plots_if_needed(model, label='whole', type_of_plot='whole') helix_sel, sheet_sel, loop_sel = self.rama_z.get_ss_selections() if model.get_hierarchy().models_size() != 1: print( "Warning! Outputting partial models and plots are not supported \ for multi-model files", file=self.logger) else: for sel, label in [(helix_sel, "helix"), (sheet_sel, "sheet"), (loop_sel, "loop")]: selected_model = model.select(sel) if self.params.write_HSL_models: pdb_str = selected_model.model_as_pdb() fn = "%s" % self.get_default_output_filename( prefix='%s_' % self.inp_fn, suffix=label, serial=Auto) print("Writing out partial model: %s" % fn, file=self.logger) self.data_manager.write_model_file(selected_model, filename=fn) self._write_plots_if_needed(selected_model, label, type_of_plot='HSL') result = self.get_results() res_info = self.rama_z.get_detailed_values() print("Individual residues info:", file=self.logger) print("Residue name, type, SS, (phi, psi), Z", file=self.logger) for i in res_info: print('%4s %10s %1s (%7.2f, %7.2f) %7.4f' % (i[2], res_type_labels[i[1]], i[3], i[4], i[5], i[6]), file=self.logger) print(result.as_string(prefix=""), file=self.logger)
def run(self): model = self.data_manager.get_model() self.inp_fn = os.path.basename( self.data_manager.get_default_model_name())[:-4] self.rama_z = rama_z.rama_z(model=model, log=self.logger) self._write_plots_if_needed(model, label='whole', type_of_plot='whole') helix_sel, sheet_sel, loop_sel = self.rama_z.get_ss_selections() for sel, label in [(helix_sel, "helix"), (sheet_sel, "sheet"), (loop_sel, "loop")]: selected_model = model.select(sel) if self.params.write_HSL_models: pdb_str = selected_model.model_as_pdb() fn = "%s" % self.get_default_output_filename( prefix='%s_' % self.inp_fn, suffix=label, serial=Auto) print("Writing out partial model: %s" % fn, file=self.logger) self.data_manager.write_model_file(selected_model, filename=fn) self._write_plots_if_needed(selected_model, label, type_of_plot='HSL') result = self.get_results() if result is None: print("Calculation of z-score failed for some reason", file=self.logger) else: for k in ["whole", "helix", "sheet", "loop"]: rc = k[0].upper() v = result.get(rc, None) if v is None: print("z-score %-5s: None, residues: %d" % (k, result['residue_counts'][rc]), file=self.logger) else: print("z-score %-5s: %5.2f (%4.2f), residues: %d" % (k, v[0], v[1], result['residue_counts'][rc]), file=self.logger)
def get_statistics(self): if self.json_data['success_composition'] is False: return make_sub_header('Get statistics', out=self.logger) self.save_json() success = True self.json_data['success_statistics'] = None sc, r_sc = None, None self.pickle_data.min_reso = None self.pickle_data.d_inv = None self.pickle_data.r_d_inv = None self.pickle_data.d_inv_half = None self.pickle_data.fsc_model = None self.pickle_data.r_fsc_model = None self.pickle_data.fsc_half = None if self.json_data['restraints_file']: cif_file = self.json_data['restraints_file'] cif_objects = monomer_library.server.read_cif(file_name=to_str(cif_file)) cif_objects = [(cif_file, cif_objects)] else: cif_objects = None for p, fn in zip(('', 'r_'), [self.json_data['pdb_file_updated'], self.json_data['pdb_file_refined']]): # TODO which file to use for initial!! if (not fn or not os.path.isfile(fn)): continue if p=='': print('Initial model', file=self.logger) if p=='r_': print('\nRefined model', file=self.logger) dm = DataManager() dm.process_real_map_file(self.json_data['map_file']) map_inp = dm.get_real_map(self.json_data['map_file']) #map_inp = iotbx.ccp4_map.map_reader(file_name = self.json_data['map_file']) map_inp_1, map_inp_2 = None, None if self.json_data['map_file_1'] is not None: #map_inp_1 = iotbx.ccp4_map.map_reader(file_name = self.json_data['map_file_1']) dm.process_real_map_file(self.json_data['map_file_1']) map_inp_1 = dm.get_real_map(self.json_data['map_file_1']) #map_data_1 = map_inp_1.map_data() if self.json_data['map_file_2'] is not None: dm.process_real_map_file(self.json_data['map_file_2']) map_inp_2 = dm.get_real_map(self.json_data['map_file_2']) #map_inp_2 = iotbx.ccp4_map.map_reader(file_name = self.json_data['map_file_2']) #map_data_2 = map_inp_2.map_data() print('\tGet model class with restraints...', file=self.logger) pdb_inp = iotbx.pdb.input(file_name = fn) try: model = mmtbx.model.manager( model_input = pdb_inp, restraint_objects = cif_objects, build_grm = True, stop_for_unknowns = False, crystal_symmetry = map_inp.crystal_symmetry(), log = null_out()) except Exception as e: #success = False self.json_data['success_statistics'] = False msg = traceback.format_exc() print(msg, file=self.logger) self.write_log( step = 'Statistics: Model class (with restraints) from pdb ', msg = msg) self.save_json() continue if not success: continue # Emringer if self.resolution < 4.0: print('\tCalculate Emringer score', file=self.logger) try: emringer_score = self.get_emringer_score( model = model.deep_copy(), map_inp = map_inp.deep_copy()) self.json_data[p+'emringer'] = emringer_score except Exception as e: msg = traceback.format_exc() print(msg, file=self.logger) self.write_log(step = 'EMRinger failed ', msg = msg) # TODO: save as success_statistics False? # Rama-z score try: rama_z_score = rama_z.rama_z( models = [model], log = self.logger) z_scores = rama_z_score.get_z_scores() self.json_data[p+'z_score'] = z_scores['W'][0] except Exception as e: msg = traceback.format_exc() print(msg, file=self.logger) self.write_log(step = 'Rama z-score failed ', msg = msg) # base = map_and_model.input( # map_manager = map_inp, # map_manager_1 = map_inp_1, # map_manager_2 = map_inp_2, # model = model, # box = True) checked = map_model_manager( map_manager = map_inp, map_manager_1 = map_inp_1, map_manager_2 = map_inp_2, model = model, wrapping = None) checked.box_all_maps_around_model_and_shift_origin() params = validation_cryoem.master_params().extract() params.resolution = self.resolution params.slim = False if (p == ''): print('\tGet map parameters...', file=self.logger) self.get_map_parameters(base = checked) print('\tRun Mtriage...', file=self.logger) try: o = validation_cryoem.validation( model = checked.model(), map_data = checked.map_data(), map_data_1 = checked.map_data_1(), map_data_2 = checked.map_data_2(), params = params) except Exception as e: # success = False self.json_data['success_statistics'] = False msg = traceback.format_exc() print(msg, file=self.logger) self.write_log(step = 'Statistics ', msg = msg) self.save_json() continue print('\tStore info in pkl...', file=self.logger) o_dict = self.fill_dictionary(o) if (p == ''): self.json_data['o'] = o_dict sc = o.model.get_sites_cart() elif (p == 'r_'): self.json_data['o_refined'] = o_dict r_sc = o.model.get_sites_cart() if o is not None: if o.model_vs_data is not None: if o.model_vs_data.cc is not None: if o.model_vs_data.cc.cc_per_chain is not None: if (p == ''): self.pickle_data.cc_per_chain = o.model_vs_data.cc.cc_per_chain if (p == 'r_'): self.pickle_data.r_cc_per_chain = o.model_vs_data.cc.cc_per_chain if o.model_vs_data.cc.cc_per_residue is not None: if (p == ''): self.pickle_data.cc_per_residue = o.model_vs_data.cc.cc_per_residue if (p == 'r_'): self.pickle_data.r_cc_per_residue = o.model_vs_data.cc.cc_per_residue if o.model_stats.geometry.ramachandran.ramalyze is not None: rl = o.model_stats.geometry.ramachandran.ramalyze if (p == ''): self.pickle_data.ramalyze = rl if (p == 'r_'): self.pickle_data.r_ramalyze = rl # values for the curve go up to very high reso, get highest reso limit # if o is not None: # reso_list = [self.json_data['d_pdb'],self.json_data['d_cif'], # self.json_data['d_map'], self.json_data['o']['d99'], # self.json_data['o']['d_model'], self.json_data['o']['d_fsc']] # else: # reso_list = [self.json_data['d_pdb'],self.json_data['d_cif'], # self.json_data['d_map']] # min_reso = min([elem for elem in reso_list if elem is not None]) # self.pickle_data.min_reso = min_reso min_reso = self.resolution self.pickle_data.min_reso = self.resolution # apply some arbitrary buffer min_reso = min_reso - 0.5 if o is not None: masked = o.data_stats.masked if (masked.fsc_curve_model is not None): if ((masked.fsc_curve_model.d_inv is not None) and (masked.fsc_curve_model.fsc is not None)): if (p == ''): self.pickle_data.d_inv = masked.fsc_curve_model.d_inv self.pickle_data.fsc_model = masked.fsc_curve_model.fsc if (p == 'r_'): self.pickle_data.r_d_inv = masked.fsc_curve_model.d_inv self.pickle_data.r_fsc_model = masked.fsc_curve_model.fsc if (p == ''): if (masked.fsc_curve is not None): if (masked.fsc_curve.fsc is not None): if ((masked.fsc_curve.fsc.d_inv is not None) and (masked.fsc_curve.fsc.fsc is not None)): self.pickle_data.d_inv_half = masked.fsc_curve.fsc.d_inv self.pickle_data.fsc_half = masked.fsc_curve.fsc.fsc if o is not None: print("\nd99 :", o.data_stats.masked.d99) print("d_model :", o.data_stats.masked.d_model) print("d_fsc :", o.data_stats.masked.d_fsc) print("ramachandran.outliers:", o.model_stats.geometry.ramachandran.outliers) print("cc_mask :", o.model_vs_data.cc.cc_mask) print("cc_box :", o.model_vs_data.cc.cc_box) if sc is not None and r_sc is not None: self.json_data['rmsd'] = sc.rms_difference(r_sc) if self.json_data['success_statistics'] is not False: self.json_data['success_statistics'] = success
def rama_z_score(self): return rama_z.rama_z(models = [self.model], log = null_out()).get_result()