def test_phil_param_read(self): """ Verify that phil parameters are properly read """ # print sys._getframe().f_code.co_name # check correctness expected_ncs_selection = ['(chain A)', '(chain A) or (chain B)'] expected_ncs_to_asu = [{ 'chain A': ['chain B', 'chain C'] }, { 'chain A': ['chain C', 'chain E'], 'chain B': ['chain D', 'chain F'] }] expected_ncs_chains = [['chain A'], ['chain A', 'chain B']] for i, phil_case in enumerate([user_phil1, user_phil2]): phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(phil_case)).extract() trans_obj = iotbx.ncs.input(ncs_phil_groups=phil_groups.ncs_group) self.assertEqual(trans_obj.ncs_selection_str, expected_ncs_selection[i]) self.assertEqual(trans_obj.ncs_to_asu_selection, expected_ncs_to_asu[i]) self.assertEqual(trans_obj.ncs_chain_selection, expected_ncs_chains[i]) # error reporting for pc in [user_phil3, user_phil4, user_phil5]: phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(pc)).extract() self.assertRaises( IOError, iotbx.ncs.input, # ncs_phil_string=pc ncs_phil_groups=phil_groups.ncs_group)
def test_print_ncs_phil_param(self): """ Verify correct printout of NCS phil parameters. need to supply exclude_selection=None because model consist only from UNK residues. """ # print sys._getframe().f_code.co_name pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_test_data2) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(pdb_test_data2_phil)).extract() trans_obj = ncs.input(ncs_phil_groups=phil_groups.ncs_group, hierarchy=pdb_inp.construct_hierarchy(), exclude_selection=None) result = trans_obj.print_ncs_phil_param(write=False) # print "="*50 # print "resutl" # print result # print "="*50 test = (pdb_test_data2_phil == result) test = test or (pdb_test_data2_phil_reverse == result) self.assertTrue(test) # spec_object = mmtbx.ncs.ncs.ncs() spec_object.read_ncs(lines=test_ncs_spec.splitlines()) trans_obj = ncs.input(spec_ncs_groups=spec_object, hierarchy=self.pdb_inp.construct_hierarchy()) result = trans_obj.print_ncs_phil_param(write=False) self.assertEqual(result, test_phil_3)
def test_superpos_pdb(self): """ verify creation of transformations using superpose_pdb need to supply exclude_selection=None because model consist only from UNK residues. """ # print sys._getframe().f_code.co_name # read file and create pdb object pdb_inp = pdb.input(source_info=None, lines=pdb_test_data1) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(pdb_test_data1_phil)).extract() p = iotbx.ncs.input.get_default_params() p.ncs_search.exclude_selection = None p.ncs_search.minimum_number_of_atoms_in_copy = 0 trans_obj = ncs.input(ncs_phil_groups=phil_groups.ncs_group, hierarchy=pdb_inp.construct_hierarchy(), params=p.ncs_search) nrgl = trans_obj.get_ncs_restraints_group_list() # nrgl._show() sels = nrgl.get_array_of_str_selections() assert sels == [["chain 'A'", "chain 'C'", "chain 'E'"], ["chain 'B'", "chain 'D'", "chain 'F'"]] self.assertTrue( approx_equal(nrgl[0].copies[0].r, matrix.sqr([ 0.309017, -0.809017, 0.5, 0.809017, 0.5, 0.309017, -0.5, 0.309017, 0.809017 ]), eps=0.01))
def test_print_ncs_phil_param(self): """ Verify correct printout of NCS phil parameters. need to supply exclude_selection=None because model consist only from UNK residues. """ # print sys._getframe().f_code.co_name pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_test_data2) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(pdb_test_data2_phil)).extract() trans_obj = ncs.input( ncs_phil_groups=phil_groups.ncs_group, hierarchy=pdb_inp.construct_hierarchy(), exclude_selection=None) result = trans_obj.print_ncs_phil_param(write=False) # print "="*50 # print "resutl" # print result # print "="*50 test = (pdb_test_data2_phil == result) test = test or (pdb_test_data2_phil_reverse == result) self.assertTrue(test) # spec_object = mmtbx.ncs.ncs.ncs() spec_object.read_ncs(lines=test_ncs_spec.splitlines()) trans_obj = ncs.input( spec_ncs_groups=spec_object, hierarchy = self.pdb_inp.construct_hierarchy()) result = trans_obj.print_ncs_phil_param(write=False) self.assertEqual(result,test_phil_3)
def test_phil_processing(self): """ Verify that phil parameters are properly processed need to supply exclude_selection=None because model consist only from UNK residues. """ # print sys._getframe().f_code.co_name # read file and create pdb object pdb_inp = pdb.input(source_info=None, lines=pdb_test_data2) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(pdb_test_data2_phil)).extract() trans_obj = iotbx.ncs.input( ncs_phil_groups=phil_groups.ncs_group, hierarchy=pdb_inp.construct_hierarchy(), exclude_selection=None) expected = "(chain 'A') or (chain 'B' or chain 'C')" self.assertEqual(trans_obj.ncs_selection_str,expected) expected = {"chain 'A'": ["chain 'D'", "chain 'G'"], "chain 'B' or chain 'C'": ["chain 'E' or chain 'F'", "chain 'H' or chain 'I'"]} self.assertEqual(trans_obj.ncs_to_asu_selection,expected) # check ncs_transform group_ids = [x.ncs_group_id for x in trans_obj.ncs_transform.itervalues()] tran_sn = {x.serial_num for x in trans_obj.ncs_transform.itervalues()} group_keys = {x for x in trans_obj.ncs_transform.iterkeys()} # self.assertEqual(len(group_ids),6) self.assertEqual(set(group_ids),{1,2}) self.assertEqual(tran_sn,{1,2,3,4,5,6}) self.assertEqual(group_keys,{'0000000005','0000000004','0000000006','0000000001','0000000003','0000000002'}) self.assertEqual(trans_obj.ncs_atom_selection.count(True),4)
def exercise_3(): """ Same as 2, but also provide groups and don't check them allowing AC to be included """ phil_str = """ ncs_group { reference = chain A selection = chain B } """ search_params = ncs.input.get_default_params() search_params.ncs_search.exclude_selection = "element H or element D" search_params.ncs_search.validate_user_supplied_groups = False phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(phil_str)).extract() h = iotbx.pdb.input(lines=pdb_str_1, source_info=None).construct_hierarchy() ncs_inp = ncs.input(hierarchy=h, params=search_params.ncs_search, ncs_phil_groups=phil_groups.ncs_group) ncs_groups = ncs_inp.get_ncs_restraints_group_list() assert len(ncs_groups) == 1 assert ncs_groups[0].master_iselection.size( ) == 72, ncs_groups[0].master_iselection.size() assert ncs_groups[0].master_iselection.size( ) == ncs_groups[0].copies[0].iselection.size() assert h.atoms_size() == 72 * 2, h.atoms_size() # covers whole model
def test_phil_param_read(self): """ Verify that phil parameters are properly read """ # print sys._getframe().f_code.co_name # check correctness expected_ncs_selection =['(chain A)','(chain A) or (chain B)'] expected_ncs_to_asu = [ {'chain A': ['chain B', 'chain C']}, {'chain A': ['chain C', 'chain E'], 'chain B': ['chain D', 'chain F']}] expected_ncs_chains = [['chain A'],['chain A', 'chain B']] for i,phil_case in enumerate([user_phil1,user_phil2]): phil_groups = ncs_group_master_phil.fetch(iotbx.phil.parse(phil_case)).extract() trans_obj = iotbx.ncs.input( ncs_phil_groups=phil_groups.ncs_group) self.assertEqual(trans_obj.ncs_selection_str,expected_ncs_selection[i]) self.assertEqual(trans_obj.ncs_to_asu_selection,expected_ncs_to_asu[i]) self.assertEqual(trans_obj.ncs_chain_selection,expected_ncs_chains[i]) # error reporting for pc in [user_phil3,user_phil4,user_phil5]: phil_groups = ncs_group_master_phil.fetch(iotbx.phil.parse(pc)).extract() self.assertRaises( IOError,iotbx.ncs.input, # ncs_phil_string=pc ncs_phil_groups=phil_groups.ncs_group)
def test_superpos_pdb(self): """ verify creation of transformations using superpose_pdb need to supply exclude_selection=None because model consist only from UNK residues. """ # print sys._getframe().f_code.co_name # read file and create pdb object pdb_inp = pdb.input(source_info=None, lines=pdb_test_data1) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(pdb_test_data1_phil)).extract() trans_obj = ncs.input( ncs_phil_groups=phil_groups.ncs_group, hierarchy=pdb_inp.construct_hierarchy(), exclude_selection=None) # print "trans_obj.ncs_selection_str", trans_obj.ncs_selection_str # print "trans_obj.ncs_to_asu_selection", trans_obj.ncs_to_asu_selection self.assertEqual(trans_obj.ncs_selection_str,"(chain 'A') or (chain 'B')") expected = {"chain 'A'": ["chain 'C'", "chain 'E'"], "chain 'B'": ["chain 'D'", "chain 'F'"]} self.assertEqual(trans_obj.ncs_to_asu_selection,expected) # check ncs_transform group_ids = [x.ncs_group_id for x in trans_obj.ncs_transform.itervalues()] tran_sn = {x.serial_num for x in trans_obj.ncs_transform.itervalues()} group_keys = {x for x in trans_obj.ncs_transform.iterkeys()} r1 = trans_obj.ncs_transform['0000000004'].r r2 = trans_obj.ncs_transform['0000000002'].r # self.assertEqual(len(group_ids),6) self.assertEqual(set(group_ids),{1,2}) self.assertEqual(tran_sn,{1,2,3,4,5,6}) self.assertEqual(group_keys,{'0000000005','0000000004','0000000006','0000000001','0000000003','0000000002'}) # self.assertTrue(r1.is_r3_identity_matrix()) expected_r = matrix.sqr( [0.309017,-0.809017,0.5,0.809017,0.5,0.309017,-0.5,0.309017,0.809017]) d = r2 - expected_r d = map(abs,d) self.assertTrue(max(d)<0.01) # test that ncs_asu does not contain the identity transforms expected = {"chain 'A'_0000000002", "chain 'A'_0000000003", "chain 'B'_0000000005", "chain 'B'_0000000006"} self.assertEqual(expected,set(trans_obj.ncs_to_asu_map.keys())) # test mapping of the different selection in the NCS self.assertEqual(list(trans_obj.asu_to_ncs_map["chain 'A'"]),[0,1]) self.assertEqual(list(trans_obj.asu_to_ncs_map["chain 'B'"]),[2]) # test that transform_chain_assignment contains all transforms self.assertEqual(expected,set(trans_obj.transform_chain_assignment))
def test_check_ncs_group_list(self): """ Test that ncs_restraints_group_list test is working properly """ phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(phil_str)).extract() pdb_inp = iotbx.pdb.input(source_info=None, lines=test_pdb_str_2) ncs_obj_phil = ncs.input(hierarchy=pdb_inp.construct_hierarchy(), ncs_phil_groups=phil_groups.ncs_group) nrgl = ncs_obj_phil.get_ncs_restraints_group_list() pdb_inp = iotbx.pdb.input(lines=test_pdb_str_2, source_info=None) ph = pdb_inp.construct_hierarchy() # passing test self.assertTrue(nu.check_ncs_group_list(nrgl, ph, chain_max_rmsd=1)) # make sure test fails when it suppose to nrgl[0].copies[1].t = matrix.col([100, -89.7668, 5.8996]) self.assertFalse(nu.check_ncs_group_list(nrgl, ph, chain_max_rmsd=1))
def test_ncs_group_iselection(self): """ selection of a complete NCS group """ phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(phil_str)).extract() pdb_inp = iotbx.pdb.input(source_info=None, lines=test_pdb_str_2) ncs_obj = ncs.input(hierarchy=pdb_inp.construct_hierarchy(), ncs_phil_groups=phil_groups.ncs_group) nrgl = ncs_obj.get_ncs_restraints_group_list() self.assertEqual(len(nrgl), 2) isel = nu.ncs_group_iselection(nrgl, 1) expected = [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23] self.assertEqual(list(isel), expected) isel = nu.ncs_group_iselection(nrgl, 0) expected = [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19] self.assertEqual(list(isel), expected)
def test_ncs_group_iselection(self): """ selection of a complete NCS group """ phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(phil_str)).extract() pdb_inp = iotbx.pdb.input(source_info=None, lines=test_pdb_str_2) ncs_obj = ncs.input(hierarchy=pdb_inp.construct_hierarchy(), ncs_phil_groups=phil_groups.ncs_group) nrgl = ncs_obj.get_ncs_restraints_group_list() self.assertEqual(len(nrgl),2) isel = nu.ncs_group_iselection(nrgl,1) expected = [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23] self.assertEqual(list(isel),expected) isel = nu.ncs_group_iselection(nrgl,0) expected = [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19] self.assertEqual(list(isel),expected)
def test_whole_group_iselection(): """ selection of a complete NCS group """ phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(phil_str)).extract() pdb_inp = iotbx.pdb.input(source_info=None, lines=test_pdb_str_2) ncs_obj = ncs.input(hierarchy=pdb_inp.construct_hierarchy(), ncs_phil_groups=phil_groups.ncs_group) nrgl = ncs_obj.get_ncs_restraints_group_list() assert len(nrgl) == nrgl.get_n_groups() == 2 isel = nrgl[1].whole_group_iselection() expected = [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23] assert list(isel) == expected isel = nrgl[0].whole_group_iselection() expected = [0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19] assert list(isel) == expected
def test_check_ncs_group_list(self): """ Test that ncs_restraints_group_list test is working properly """ phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(phil_str)).extract() pdb_inp = iotbx.pdb.input(source_info=None, lines=test_pdb_str_2) ncs_obj_phil = ncs.input( hierarchy=pdb_inp.construct_hierarchy(), ncs_phil_groups=phil_groups.ncs_group) nrgl = ncs_obj_phil.get_ncs_restraints_group_list() pdb_inp = iotbx.pdb.input(lines=test_pdb_str_2,source_info=None) ph = pdb_inp.construct_hierarchy() # passing test self.assertTrue(nu.check_ncs_group_list(nrgl,ph,chain_max_rmsd=1)) # make sure test fails when it suppose to nrgl[0].copies[1].t = matrix.col([100, -89.7668, 5.8996]) self.assertFalse(nu.check_ncs_group_list(nrgl,ph,chain_max_rmsd=1))
def test_correct_grouping(self): """ test correct representation of groups in .ncs file""" pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str_4) h = pdb_inp.construct_hierarchy() ncs_obj = iotbx.ncs.input( hierarchy=h, transform_info=pdb_inp.process_mtrix_records(eps=0.01)) self.assertEqual(ncs_obj.number_of_ncs_groups,1) gr = ncs_obj.print_ncs_phil_param() self.assertEqual(gr,answer_4) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(answer_4)).extract() ncs_obj = iotbx.ncs.input(ncs_phil_groups=phil_groups.ncs_group) self.assertEqual(ncs_obj.number_of_ncs_groups,1) gr = ncs_obj.print_ncs_phil_param() self.assertEqual(gr,answer_4)
def test_correct_grouping(self): """ test correct representation of groups in .ncs file""" pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_str_4) h = pdb_inp.construct_hierarchy() ncs_obj = iotbx.ncs.input( hierarchy=h, transform_info=pdb_inp.process_MTRIX_records(eps=0.01)) self.assertEqual(ncs_obj.number_of_ncs_groups, 1) gr = ncs_obj.print_ncs_phil_param() self.assertEqual(gr, answer_4) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(answer_4)).extract() ncs_obj = iotbx.ncs.input(ncs_phil_groups=phil_groups.ncs_group) self.assertEqual(ncs_obj.number_of_ncs_groups, 1) gr = ncs_obj.print_ncs_phil_param() self.assertEqual(gr, answer_4)
def test_phil_processing(self): """ Verify that phil parameters are properly processed need to supply exclude_selection=None because model consist only from UNK residues. """ # print sys._getframe().f_code.co_name # read file and create pdb object pdb_inp = pdb.input(source_info=None, lines=pdb_test_data2) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(pdb_test_data2_phil)).extract() p = iotbx.ncs.input.get_default_params() p.ncs_search.exclude_selection=None p.ncs_search.minimum_number_of_atoms_in_copy=0 trans_obj = iotbx.ncs.input( ncs_phil_groups=phil_groups.ncs_group, hierarchy=pdb_inp.construct_hierarchy(), params=p.ncs_search) nrgl = trans_obj.get_ncs_restraints_group_list() # nrgl._show() sels = nrgl.get_array_of_str_selections() assert sels == [["chain 'A'", "chain 'D'", "chain 'G'"], ["chain 'B' or chain 'C'", "chain 'E' or chain 'F'", "chain 'H' or chain 'I'"]]
def test_print_ncs_phil_param(self): """ Verify correct printout of NCS phil parameters. need to supply exclude_selection=None because model consist only from UNK residues. """ # print sys._getframe().f_code.co_name pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_test_data2) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(pdb_test_data2_phil)).extract() p = iotbx.ncs.input.get_default_params() p.ncs_search.exclude_selection = None p.ncs_search.minimum_number_of_atoms_in_copy = 0 trans_obj = ncs.input(ncs_phil_groups=phil_groups.ncs_group, hierarchy=pdb_inp.construct_hierarchy(), params=p.ncs_search) result = trans_obj.print_ncs_phil_param(write=False) # print "="*50 # print "resutl" # print result # print "="*50 test = (pdb_test_data2_phil == result) test = test or (pdb_test_data2_phil_reverse == result) self.assertTrue(test)
def test_split_by_chain(): phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(phil_str2)).extract() pdb_inp = iotbx.pdb.input(source_info=None, lines=test_pdb_str_2) pars = ncs.input.get_default_params() pars.ncs_search.chain_max_rmsd = 100 h = pdb_inp.construct_hierarchy() ncs_obj_phil = ncs.input(hierarchy=h, ncs_phil_groups=phil_groups.ncs_group, params=pars.ncs_search) nrgl = ncs_obj_phil.get_ncs_restraints_group_list() assert nrgl.get_array_of_str_selections() == \ [["chain 'Aa' or chain 'Ab'", "chain 'Ae' or chain 'Af'"]] splitted_nrgl = nrgl.split_by_chains(hierarchy=h) assert splitted_nrgl.get_n_groups() == 2 for g in splitted_nrgl: assert g.get_number_of_copies() == 1 assert approx_equal(g.copies[0].r, nrgl[0].copies[0].r) assert approx_equal(g.copies[0].t, nrgl[0].copies[0].t) splitted_nrgl.update_str_selections_if_needed(hierarchy=h) assert splitted_nrgl.get_array_of_str_selections() == \ [["chain 'Aa'", "chain 'Ae'"], ["chain 'Ab'", "chain 'Af'"]]
def test_phil_processing(self): """ Verify that phil parameters are properly processed need to supply exclude_selection=None because model consist only from UNK residues. """ # print sys._getframe().f_code.co_name # read file and create pdb object pdb_inp = pdb.input(source_info=None, lines=pdb_test_data2) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(pdb_test_data2_phil)).extract() trans_obj = iotbx.ncs.input(ncs_phil_groups=phil_groups.ncs_group, hierarchy=pdb_inp.construct_hierarchy(), exclude_selection=None) expected = "(chain 'A') or (chain 'B' or chain 'C')" self.assertEqual(trans_obj.ncs_selection_str, expected) expected = { "chain 'A'": ["chain 'D'", "chain 'G'"], "chain 'B' or chain 'C'": ["chain 'E' or chain 'F'", "chain 'H' or chain 'I'"] } self.assertEqual(trans_obj.ncs_to_asu_selection, expected) # check ncs_transform group_ids = [ x.ncs_group_id for x in trans_obj.ncs_transform.itervalues() ] tran_sn = {x.serial_num for x in trans_obj.ncs_transform.itervalues()} group_keys = {x for x in trans_obj.ncs_transform.iterkeys()} # self.assertEqual(len(group_ids), 6) self.assertEqual(set(group_ids), {1, 2}) self.assertEqual(tran_sn, {1, 2, 3, 4, 5, 6}) self.assertEqual( group_keys, { '0000000005', '0000000004', '0000000006', '0000000001', '0000000003', '0000000002' }) self.assertEqual(trans_obj.ncs_atom_selection.count(True), 4)
def get_inputs(prefix, pdb_answer, pdb_poor, ncs_params_str, real_space, d_min): pdb_file_name_answer = "answer_%s.pdb"%prefix of=open(pdb_file_name_answer, "w") print >> of, pdb_answer of.close() # pdb_file_name_poor = "poor_%s.pdb"%prefix of=open(pdb_file_name_poor, "w") print >> of, pdb_poor of.close() # pdb_inp_answer = iotbx.pdb.input(file_name=pdb_file_name_answer) ph_answer = pdb_inp_answer.construct_hierarchy() ph_answer.atoms().reset_i_seq() xrs_answer = pdb_inp_answer.xray_structure_simple() sites_cart_answer = xrs_answer.sites_cart() # pdb_inp_poor = iotbx.pdb.input(file_name=pdb_file_name_poor) ph_poor = pdb_inp_poor.construct_hierarchy() ph_poor.atoms().reset_i_seq() xrs_poor = pdb_inp_poor.xray_structure_simple() # ppf = mmtbx.utils.process_pdb_file_srv(log=False).process_pdb_files( raw_records=pdb_poor.splitlines())[0] mmtbx.utils.assert_xray_structures_equal( x1=ppf.xray_structure(show_summary = False), x2=xrs_poor) restraints_manager = mmtbx.restraints.manager( geometry = ppf.geometry_restraints_manager(show_energies = False), normalization = True) restraints_manager.geometry.remove_c_beta_torsion_restraints_in_place() # phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(ncs_params_str)).extract() pdb_inp = iotbx.pdb.input(lines=pdb_poor,source_info=None) ncs_inp = ncs.input( hierarchy=pdb_inp.construct_hierarchy(), ncs_phil_groups=phil_groups.ncs_group) ncs_groups = ncs_inp.get_ncs_restraints_group_list() # print "ncs_groups:", len(ncs_groups) # print "master isel:", list(ncs_groups[0].master_iselection) # for c in ncs_groups[0].copies: # print "copy isel:", list(c.iselection) # set_scattering_dictionary(xray_structure = xrs_answer, d_min = d_min) set_scattering_dictionary(xray_structure = xrs_poor, d_min = d_min) # # map_data, fmodel = None, None if(real_space): fc = xrs_answer.structure_factors(d_min=d_min, algorithm="direct").f_calc() fft_map = fc.fft_map(resolution_factor = 0.25) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() else: f_obs = abs(xrs_answer.structure_factors(d_min=d_min, algorithm="direct").f_calc()) params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract() params.algorithm = "direct" fmodel = mmtbx.f_model.manager( f_obs = f_obs, xray_structure = xrs_poor, sf_and_grads_accuracy_params = params, target_name = "ls_wunit_k1") if(1): print "d_min:", d_min if(1): print "r_work(start):", fmodel.r_work() return group_args( fmodel = fmodel, map_data = map_data, xrs_poor = xrs_poor, d_min = d_min, ncs_groups = ncs_groups, restraints_manager = restraints_manager, ph = ph_poor)
def test_superpos_pdb(self): """ verify creation of transformations using superpose_pdb need to supply exclude_selection=None because model consist only from UNK residues. """ # print sys._getframe().f_code.co_name # read file and create pdb object pdb_inp = pdb.input(source_info=None, lines=pdb_test_data1) phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(pdb_test_data1_phil)).extract() trans_obj = ncs.input(ncs_phil_groups=phil_groups.ncs_group, hierarchy=pdb_inp.construct_hierarchy(), exclude_selection=None) # print "trans_obj.ncs_selection_str", trans_obj.ncs_selection_str # print "trans_obj.ncs_to_asu_selection", trans_obj.ncs_to_asu_selection self.assertEqual(trans_obj.ncs_selection_str, "(chain 'A') or (chain 'B')") expected = { "chain 'A'": ["chain 'C'", "chain 'E'"], "chain 'B'": ["chain 'D'", "chain 'F'"] } self.assertEqual(trans_obj.ncs_to_asu_selection, expected) # check ncs_transform group_ids = [ x.ncs_group_id for x in trans_obj.ncs_transform.itervalues() ] tran_sn = {x.serial_num for x in trans_obj.ncs_transform.itervalues()} group_keys = {x for x in trans_obj.ncs_transform.iterkeys()} r1 = trans_obj.ncs_transform['0000000004'].r r2 = trans_obj.ncs_transform['0000000002'].r # self.assertEqual(len(group_ids), 6) self.assertEqual(set(group_ids), {1, 2}) self.assertEqual(tran_sn, {1, 2, 3, 4, 5, 6}) self.assertEqual( group_keys, { '0000000005', '0000000004', '0000000006', '0000000001', '0000000003', '0000000002' }) # self.assertTrue(r1.is_r3_identity_matrix()) expected_r = matrix.sqr([ 0.309017, -0.809017, 0.5, 0.809017, 0.5, 0.309017, -0.5, 0.309017, 0.809017 ]) d = r2 - expected_r d = map(abs, d) self.assertTrue(max(d) < 0.01) # test that ncs_asu does not contain the identity transforms expected = { "chain 'A'_0000000002", "chain 'A'_0000000003", "chain 'B'_0000000005", "chain 'B'_0000000006" } self.assertEqual(expected, set(trans_obj.ncs_to_asu_map.keys())) # test mapping of the different selection in the NCS self.assertEqual(list(trans_obj.asu_to_ncs_map["chain 'A'"]), [0, 1]) self.assertEqual(list(trans_obj.asu_to_ncs_map["chain 'B'"]), [2]) # test that transform_chain_assignment contains all transforms self.assertEqual(expected, set(trans_obj.transform_chain_assignment))
def get_inputs(prefix, pdb_answer, pdb_poor, ncs_params_str, real_space, d_min): pdb_file_name_answer = "answer_%s.pdb" % prefix of = open(pdb_file_name_answer, "w") print >> of, pdb_answer of.close() # pdb_file_name_poor = "poor_%s.pdb" % prefix of = open(pdb_file_name_poor, "w") print >> of, pdb_poor of.close() # pdb_inp_answer = iotbx.pdb.input(file_name=pdb_file_name_answer) ph_answer = pdb_inp_answer.construct_hierarchy() ph_answer.atoms().reset_i_seq() xrs_answer = pdb_inp_answer.xray_structure_simple() sites_cart_answer = xrs_answer.sites_cart() # pdb_inp_poor = iotbx.pdb.input(file_name=pdb_file_name_poor) ph_poor = pdb_inp_poor.construct_hierarchy() ph_poor.atoms().reset_i_seq() xrs_poor = pdb_inp_poor.xray_structure_simple() # ppf = mmtbx.utils.process_pdb_file_srv(log=False).process_pdb_files( raw_records=pdb_poor.splitlines())[0] mmtbx.utils.assert_xray_structures_equal( x1=ppf.xray_structure(show_summary=False), x2=xrs_poor) restraints_manager = mmtbx.restraints.manager( geometry=ppf.geometry_restraints_manager(show_energies=False), normalization=True) restraints_manager.geometry.remove_c_beta_torsion_restraints_in_place() # phil_groups = ncs_group_master_phil.fetch( iotbx.phil.parse(ncs_params_str)).extract() pdb_inp = iotbx.pdb.input(lines=pdb_poor, source_info=None) ncs_inp = ncs.input(hierarchy=pdb_inp.construct_hierarchy(), ncs_phil_groups=phil_groups.ncs_group) ncs_groups = ncs_inp.get_ncs_restraints_group_list() # print "ncs_groups:", len(ncs_groups) # print "master isel:", list(ncs_groups[0].master_iselection) # for c in ncs_groups[0].copies: # print "copy isel:", list(c.iselection) # set_scattering_dictionary(xray_structure=xrs_answer, d_min=d_min) set_scattering_dictionary(xray_structure=xrs_poor, d_min=d_min) # # map_data, fmodel = None, None if (real_space): fc = xrs_answer.structure_factors(d_min=d_min, algorithm="direct").f_calc() fft_map = fc.fft_map(resolution_factor=0.25) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() else: f_obs = abs( xrs_answer.structure_factors(d_min=d_min, algorithm="direct").f_calc()) params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract() params.algorithm = "direct" fmodel = mmtbx.f_model.manager(f_obs=f_obs, xray_structure=xrs_poor, sf_and_grads_accuracy_params=params, target_name="ls_wunit_k1") if (1): print "d_min:", d_min if (1): print "r_work(start):", fmodel.r_work() return group_args(fmodel=fmodel, map_data=map_data, xrs_poor=xrs_poor, d_min=d_min, ncs_groups=ncs_groups, restraints_manager=restraints_manager, ph=ph_poor)