def get_random_structure_and_map( use_static_structure=False, random_seed=171413, ): if use_static_structure: mmm = map_model_manager() mmm.generate_map() return group_args(model=mmm.model(), mm=mmm.map_manager()) import random random.seed(random_seed) i = random.randint(1, 714717) flex.set_random_seed(i) xrs = random_structure.xray_structure( space_group_info=space_group_info(19), volume_per_atom=25., elements=('C', 'N', 'O', 'H') * 10, min_distance=1.5) fc = xrs.structure_factors(d_min=2).f_calc() fft_map = fc.fft_map(resolution_factor=0.25) fft_map.apply_volume_scaling() ph = iotbx.pdb.input(source_info=None, lines=xrs.as_pdb_file()).construct_hierarchy() ph.atoms().set_xyz(xrs.sites_cart()) map_data = fft_map.real_map_unpadded() mm = map_manager(unit_cell_grid=map_data.accessor().all(), unit_cell_crystal_symmetry=fc.crystal_symmetry(), origin_shift_grid_units=(0, 0, 0), map_data=map_data) model = mmtbx.model.manager(model_input=None, pdb_hierarchy=ph, crystal_symmetry=fc.crystal_symmetry()) return group_args(model=model, mm=mm)
def get_map_manager( map_data, wrapping, unit_cell_dimensions=None, crystal_symmetry=None, ): ''' Get a minimal map_manager in SG p1 from any map_data and if unit_cell_dimensions. Assume cell angles are 90,90,90 Shift origin to (0,0,0) ''' assert unit_cell_dimensions or crystal_symmetry assert isinstance(wrapping, bool) from iotbx.map_manager import map_manager map_data = map_data.shift_origin() if not crystal_symmetry: from cctbx import crystal crystal_symmetry = crystal.symmetry( tuple(list(unit_cell_dimensions[:3]) + [90, 90, 90]), 1) mm = map_manager(map_data=map_data, unit_cell_grid=map_data.all(), unit_cell_crystal_symmetry=crystal_symmetry, origin_shift_grid_units=(0, 0, 0), wrapping=wrapping) return mm
def read_map(self, file_name=None, log=sys.stdout): # Read in a map and make sure its symmetry is similar to others mm = map_manager(file_name) self.add_map_manager(mm, log=log)
def test_01(): data_dir = os.path.dirname(os.path.abspath(__file__)) data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4') data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4') dm = DataManager(['miller_array','real_map', 'phil']) dm.set_overwrite(True) dm.process_real_map_file(data_ccp4) # test writing and reading file mm = dm.get_real_map() mm.shift_origin() mm.show_summary() dm.write_map_with_map_manager(mm, filename='test_map_manager.ccp4', overwrite=True) # get map_data map_data=mm.map_data() assert approx_equal(map_data[15,10,19], 0.38,eps=0.01) # get crystal_symmetry cs=mm.crystal_symmetry() assert approx_equal(cs.unit_cell().parameters()[0] ,22.41,eps=0.01) # and full cell symmetry full_cs=mm.unit_cell_crystal_symmetry() assert approx_equal(full_cs.unit_cell().parameters()[0] ,149.4066,eps=0.01) # write map directly: mm.write_map('test_direct.ccp4') # read back directly new_mm=map_manager('test_direct.ccp4') assert (not new_mm.is_similar(mm)) new_mm.shift_origin() assert mm.is_similar(new_mm) # deep_copy new_mm=mm.deep_copy() assert new_mm.is_similar(mm) # customized_copy new_mm=mm.customized_copy(map_data=mm.map_data().deep_copy()) assert new_mm.is_similar(mm) # Initialize with parameters mm_para=map_manager( unit_cell_grid= mm.unit_cell_grid, unit_cell_crystal_symmetry= mm.unit_cell_crystal_symmetry(), origin_shift_grid_units= mm.origin_shift_grid_units, map_data=mm.map_data()) assert mm_para.is_similar(mm) # Adjust origin and gridding: mm_read=map_manager(data_ccp4) mm_read.set_origin_and_gridding((10,10,10),gridding=(100,100,100)) assert (not mm_read.is_similar(mm)) assert (not mm_read.already_shifted()) # Adjust origin and gridding should fail if origin already shifted: mm_read=map_manager(data_ccp4) mm_read.shift_origin() mm_read.set_origin_and_gridding((10,10,10),gridding=(100,100,100)) assert (mm_read.is_similar(mm)) # not shifted as it failed assert (mm_read.already_shifted()) # Set input_file name mm_read.set_input_file_name('test input_file') assert mm_read.input_file_name=='test input_file' # Set program name mm_read.set_program_name('test program') assert mm_read.program_name=='test program' # Set limitation mm_read.add_limitation('map_is_sharpened') assert mm_read.limitations==['map_is_sharpened'] # Add a label mm_read.add_label('TEST LABEL') assert mm_read.labels[0]=='TEST LABEL' mm_read.write_map('map_with_labels.mrc') new_mm=map_manager('map_with_labels.mrc') assert 'TEST LABEL' in new_mm.labels assert new_mm.is_in_limitations('map_is_sharpened') assert new_mm.labels[0].find('test program')>-1 # Read a map directly mm_read=map_manager(data_ccp4) mm_read.shift_origin() assert mm_read.is_similar(mm) # Set log import sys mm.set_log(sys.stdout) # Add map_data mm_read.replace_map_data(map_data=mm.map_data().deep_copy()) assert mm_read.is_similar(mm) dm.process_real_map_file('test_map_manager.ccp4') new_mm=dm.get_real_map('test_map_manager.ccp4') new_mm.show_summary() assert (not new_mm.is_similar(mm)) new_mm.shift_origin() new_mm.show_summary() assert new_mm.is_similar(mm) os.remove('test_map_manager.ccp4') # Convert to map coeffs, write out, read back, convert back to map map_coeffs = mm.map_as_fourier_coefficients(high_resolution = 3) mtz_dataset = map_coeffs.as_mtz_dataset(column_root_label='F') mtz_object=mtz_dataset.mtz_object() dm.write_miller_array_file(mtz_object, filename="map_coeffs.mtz") # Note these Fourier coeffs correspond to working map (not original position) array_labels=dm.get_miller_array_labels("map_coeffs.mtz") labels=array_labels[0] dm.get_reflection_file_server(filenames=["map_coeffs.mtz"],labels=[labels]) miller_arrays=dm.get_miller_arrays() new_map_coeffs=miller_arrays[0] map_data_from_map_coeffs=mm.fourier_coefficients_as_map( map_coeffs=new_map_coeffs) mm_from_map_coeffs=mm.customized_copy(map_data=map_data_from_map_coeffs) assert mm_from_map_coeffs.is_similar(mm)
def exercise(file_name=None, pdb_file_name = None, map_file_name = None , split_pdb_file_name = None, out = sys.stdout): # Set up source data if not os.path.isfile(file_name): raise Sorry("Missing the file: %s" %(file_name)+"\n") print ("Reading from %s" %(file_name)) from iotbx.map_manager import map_manager m = map_manager(file_name) print ("Header information from %s:" %(file_name)) m.show_summary(out = out) map_data = m.map_data().deep_copy() crystal_symmetry = m.crystal_symmetry() unit_cell_parameters = m.crystal_symmetry().unit_cell().parameters() print ("\nMap origin: %s Extent %s" %( map_data.origin(), map_data.all())) print ("Original unit cell, not just unit cell of part in this file): %s" %( str(unit_cell_parameters))) grid_point = (1, 2, 3) if map_data.origin() != (0, 0, 0): # make sure it is inside from scitbx.matrix import col grid_point = tuple (col(grid_point)+col(map_data.origin())) print ("\nValue of map_data at grid point %s: %.3f" %(str(grid_point), map_data[grid_point])) print ("Map data is %s" %(type(map_data))) random_position = (10, 5, 7.9) point_frac = crystal_symmetry.unit_cell().fractionalize(random_position) value_at_point_frac = map_data.eight_point_interpolation(point_frac) print ("Value of map_data at coordinates %s: %.3f" %( str(random_position), value_at_point_frac)) map_data_as_float = map_data.as_float() print ("Map data as float is %s" %(type(map_data_as_float))) # make a little model sites_cart = flex.vec3_double( ((8, 10, 12), (14, 15, 16))) model = model_manager.from_sites_cart( atom_name = ' CA ', resname = 'ALA', chain_id = 'A', b_iso = 30., occ = 1., scatterer = 'C', sites_cart = sites_cart, crystal_symmetry = crystal_symmetry) # Move map and a model to place origin at (0, 0, 0) # map data is new copy but model is shifted in place. from iotbx.map_model_manager import map_model_manager mam = map_model_manager( map_manager = m, model = model.deep_copy(), ) # Read in map and model and split up dm = DataManager() aa = dm.get_map_model_manager(model_file=pdb_file_name, map_files=map_file_name) bb = dm.get_map_model_manager(model_file=split_pdb_file_name, map_files=map_file_name) for selection_method in ['by_chain', 'by_segment','supplied_selections', 'boxes']: if selection_method == 'boxes': choices = [True, False] else: choices = [True] if selection_method == 'by_chain': mask_choices = [True,False] else: mask_choices = [False] for select_final_boxes_based_on_model in choices: for skip_empty_boxes in choices: for mask_choice in mask_choices: if mask_choice: # use split model a=bb.deep_copy() else: # usual a=aa.deep_copy() print ("\nRunning split_up_map_and_model with \n"+ "select_final_boxes_based_on_model="+ "%s skip_empty_boxes=%s selection_method=%s" %( select_final_boxes_based_on_model,skip_empty_boxes,selection_method)) if selection_method == 'by_chain': print ("Mask around unused atoms: %s" %(mask_choice)) box_info = a.split_up_map_and_model_by_chain( mask_around_unselected_atoms=mask_choice) elif selection_method == 'by_segment': box_info = a.split_up_map_and_model_by_segment() elif selection_method == 'supplied_selections': selection = a.model().selection('all') box_info = a.split_up_map_and_model_by_supplied_selections( selection_list = [selection]) elif selection_method == 'boxes': box_info = a.split_up_map_and_model_by_boxes( skip_empty_boxes = skip_empty_boxes, select_final_boxes_based_on_model = select_final_boxes_based_on_model) print (selection_method,skip_empty_boxes, len(box_info.selection_list), box_info.selection_list[0].count(True)) assert (selection_method,skip_empty_boxes, len(box_info.selection_list), box_info.selection_list[0].count(True)) in [ ('by_chain',True,3,19), ("by_chain",True,1,86,), ("by_segment",True,1,86,), ("supplied_selections",True,1,86,), ("boxes",True,13,1,), ("boxes",False,36,0,), ("boxes",True,13,1,), ("boxes",False,36,0,), ] # Change the coordinates in one box small_model = box_info.mmm_list[0].model() small_sites_cart = small_model.get_sites_cart() from scitbx.matrix import col small_sites_cart += col((1,0,0)) small_model.set_crystal_symmetry_and_sites_cart( sites_cart = small_sites_cart, crystal_symmetry = small_model.crystal_symmetry()) # Put everything back together a.merge_split_maps_and_models(box_info = box_info) mam.box_all_maps_around_model_and_shift_origin() shifted_crystal_symmetry = mam.model().crystal_symmetry() shifted_model = mam.model() shifted_map_data = mam.map_data() print ("\nOriginal map origin (grid units):", map_data.origin()) print ("Original model:\n", model.model_as_pdb()) print ("Shifted map origin:", shifted_map_data.origin()) print ("Shifted model:\n", shifted_model.model_as_pdb()) # Save the map_model manager mam_dc=mam.deep_copy() print ("dc",mam) print ("dc mam_dc",mam_dc) # Mask map around atoms mam=mam_dc.deep_copy() print ("dc mam_dc dc",mam_dc) print (mam) mam.mask_all_maps_around_atoms(mask_atoms_atom_radius = 3, set_outside_to_mean_inside=True, soft_mask=False) print ("Mean before masking", mam.map_data().as_1d().min_max_mean().mean) assert approx_equal(mam.map_data().as_1d().min_max_mean().mean, -0.0585683621466) print ("Max before masking", mam.map_data().as_1d().min_max_mean().max) assert approx_equal(mam.map_data().as_1d().min_max_mean().max, -0.0585683621466) # Mask map around atoms, with soft mask mam=mam_dc.deep_copy() mam.mask_all_maps_around_atoms(mask_atoms_atom_radius = 3, soft_mask = True, soft_mask_radius = 5, set_outside_to_mean_inside=True) print ("Mean after first masking", mam.map_data().as_1d().min_max_mean().mean) assert approx_equal(mam.map_data().as_1d().min_max_mean().mean, -0.00177661714805) print ("Max after first masking", mam.map_data().as_1d().min_max_mean().max) assert approx_equal(mam.map_data().as_1d().min_max_mean().max, 0.236853733659) # Mask map around atoms again mam.mask_all_maps_around_atoms(mask_atoms_atom_radius = 3, set_outside_to_mean_inside = True, soft_mask=False) print ("Mean after second masking", mam.map_data().as_1d().min_max_mean().mean) assert approx_equal(mam.map_data().as_1d().min_max_mean().mean, -0.0585683621466) print ("Max after second masking", mam.map_data().as_1d().min_max_mean().max) assert approx_equal(mam.map_data().as_1d().min_max_mean().max, -0.0585683621466) # Mask around edges mam=mam_dc.deep_copy() mam.mask_all_maps_around_edges( soft_mask_radius = 3) print ("Mean after masking edges", mam.map_data().as_1d().min_max_mean().mean) assert approx_equal(mam.map_data().as_1d().min_max_mean().mean, 0.0155055604192) print ("Max after masking edges", mam.map_data().as_1d().min_max_mean().max) assert approx_equal(mam.map_data().as_1d().min_max_mean().max, 0.249827131629) print ("\nWriting map_data and model in shifted position (origin at 0, 0, 0)") output_file_name = 'shifted_map.ccp4' print ("Writing to %s" %(output_file_name)) mrcfile.write_ccp4_map( file_name = output_file_name, crystal_symmetry = shifted_crystal_symmetry, map_data = shifted_map_data, ) output_file_name = 'shifted_model.pdb' f = open(output_file_name, 'w') print (shifted_model.model_as_pdb(), file=f) f.close() print ("\nWriting map_data and model in original position (origin at %s)" %( str(mam.map_manager().origin_shift_grid_units))) output_file_name = 'new_map_original_position.ccp4' print ("Writing to %s" %(output_file_name)) mrcfile.write_ccp4_map( file_name = output_file_name, crystal_symmetry = shifted_crystal_symmetry, map_data = shifted_map_data, origin_shift_grid_units = mam.map_manager().origin_shift_grid_units) print (shifted_model.model_as_pdb()) output_pdb_file_name = 'new_model_original_position.pdb' f = open(output_pdb_file_name, 'w') print (shifted_model.model_as_pdb(), file=f) f.close() # Write as mmcif output_cif_file_name = 'new_model_original_position.cif' f = open(output_cif_file_name, 'w') print (shifted_model.model_as_mmcif(),file = f) f.close() # Read the new map and model import iotbx.pdb new_model = model_manager( model_input = iotbx.pdb.input( source_info = None, lines = flex.split_lines(open(output_pdb_file_name).read())), crystal_symmetry = crystal_symmetry) assert new_model.model_as_pdb() == model.model_as_pdb() new_model_from_cif = model_manager( model_input = iotbx.pdb.input( source_info = None, lines = flex.split_lines(open(output_cif_file_name).read())), crystal_symmetry = crystal_symmetry) assert new_model_from_cif.model_as_pdb() == model.model_as_pdb() # Read and box the original file again in case we modified m in any # previous tests m = map_manager(file_name) mam=map_model_manager(model=model.deep_copy(),map_manager=m) mam.box_all_maps_around_model_and_shift_origin() file_name = output_file_name print ("Reading from %s" %(file_name)) new_map = iotbx.mrcfile.map_reader(file_name = file_name, verbose = False) new_map.data = new_map.data.shift_origin() print ("Header information from %s:" %(file_name)) new_map.show_summary(out = out) assert new_map.map_data().origin() == mam.map_manager().map_data().origin() assert new_map.crystal_symmetry().is_similar_symmetry(mam.map_manager().crystal_symmetry()) # make a map_model_manager with lots of maps and model and ncs from mmtbx.ncs.ncs import ncs ncs_object=ncs() ncs_object.set_unit_ncs() mam = map_model_manager( map_manager = m, ncs_object = ncs_object, map_manager_1 = m.deep_copy(), map_manager_2 = m.deep_copy(), extra_model_list = [model.deep_copy(),model.deep_copy()], extra_model_id_list = ["model_1","model_2"], extra_map_manager_list = [m.deep_copy(),m.deep_copy()], extra_map_manager_id_list = ["extra_1","extra_2"], model = model.deep_copy(), ) # make a map_model_manager with lots of maps and model and ncs and run # with wrapping and ignore_symmetry_conflicts on from mmtbx.ncs.ncs import ncs ncs_object=ncs() ncs_object.set_unit_ncs() m.set_ncs_object(ncs_object.deep_copy()) mam2 = map_model_manager( map_manager = m.deep_copy(), ncs_object = ncs_object.deep_copy(), map_manager_1 = m.deep_copy(), map_manager_2 = m.deep_copy(), extra_model_list = [model.deep_copy(),model.deep_copy()], extra_model_id_list = ["model_1","model_2"], extra_map_manager_list = [m.deep_copy(),m.deep_copy()], extra_map_manager_id_list = ["extra_1","extra_2"], model = model.deep_copy(), ignore_symmetry_conflicts = True, wrapping = m.wrapping(), ) assert mam.map_manager().is_similar(mam2.map_manager()) assert mam.map_manager().is_similar(mam2.map_manager_1()) for m in mam2.map_managers(): assert mam.map_manager().is_similar(m) assert mam.model().shift_cart() == mam2.model().shift_cart() assert mam.model().shift_cart() == mam2.get_model_by_id('model_2').shift_cart() print ("OK")
def exercise(file_name, out=sys.stdout): # Set up source data if not os.path.isfile(file_name): raise Sorry("Missing the file: %s" % (file_name) + "\n") print("Reading from %s" % (file_name)) from iotbx.map_manager import map_manager m = map_manager(file_name) # make a little model sites_cart = flex.vec3_double(((8, 10, 12), (14, 15, 16))) model = model_manager.from_sites_cart( atom_name=' CA ', resname='ALA', chain_id='A', b_iso=30., occ=1., scatterer='C', sites_cart=sites_cart, crystal_symmetry=m.crystal_symmetry()) # make a map_model_manager with lots of maps and model and ncs from iotbx.map_model_manager import map_model_manager from mmtbx.ncs.ncs import ncs ncs_object = ncs() ncs_object.set_unit_ncs() mask_mm = m.deep_copy() mask_mm.set_is_mask(True) mam = map_model_manager( map_manager=m, ncs_object=ncs_object, map_manager_1=m.deep_copy(), map_manager_2=m.deep_copy(), extra_map_manager_list=[m.deep_copy(), m.deep_copy(), m.deep_copy()], extra_map_manager_id_list=["extra_1", "extra_2", "map_manager_mask"], model=model.deep_copy(), ) print(mam.map_manager()) print(mam.model()) print(mam.map_manager_1()) print(mam.map_manager_2()) print(mam.map_manager_mask()) print(mam.map_manager().ncs_object()) all_map_names = mam.map_id_list() for id in all_map_names: print("Map_manager %s: %s " % (id, mam.get_map_manager_by_id(id))) dm = DataManager(['model', 'miller_array', 'real_map', 'phil', 'ncs_spec']) dm.set_overwrite(True) # Create a model with ncs from iotbx.regression.ncs.tst_ncs import pdb_str_5 file_name = 'tst_mam.pdb' f = open(file_name, 'w') print(pdb_str_5, file=f) f.close() # Generate map data from this model (it has ncs) mmm = map_model_manager() mmm.generate_map(box_cushion=0, file_name=file_name, n_residues=500) ncs_mam = mmm.deep_copy() ncs_mam_copy = mmm.deep_copy() # Make sure this model has 126 sites (42 sites times 3-fold ncs) assert ncs_mam.model().get_sites_cart().size() == 126 assert approx_equal(ncs_mam.model().get_sites_cart()[0], (23.560999999999996, 8.159, 10.660000000000002)) # Get just unique part (42 sites) unique_mam = ncs_mam.extract_all_maps_around_model( select_unique_by_ncs=True) assert unique_mam.model().get_sites_cart().size() == 42 assert approx_equal(unique_mam.model().get_sites_cart()[0], (18.740916666666664, 13.1794, 16.10544)) # Make sure that the extraction did not change the original but does change # the extracted part assert (unique_mam.model().get_sites_cart()[0] != ncs_mam.model().get_sites_cart()[0] ) # it was a deep copy so original stays # Shift back the extracted part and make sure it matches the original now shifted_back_unique_model = mmm.get_model_from_other( unique_mam.deep_copy()) assert approx_equal(shifted_back_unique_model.get_sites_cart()[0], (23.560999999999996, 8.158999999999997, 10.66)) # Change the extracted model sites_cart = unique_mam.model().get_sites_cart() sites_cart[0] = (1, 1, 1) unique_mam.model().get_hierarchy().atoms().set_xyz(sites_cart) # Note; setting xyz in hierarchy does not set xrs by itself. do that now: unique_mam.model().set_sites_cart_from_hierarchy(multiply_ncs=False) # Make sure we really changed it assert approx_equal(unique_mam.model().get_sites_cart()[0], (1, 1, 1)) # Now propagate all the changes in this unique part to entire original model # using NCS ncs_mam.propagate_model_from_other(other=unique_mam, model_id='model', other_model_id='model') # ...and check that copy 1 and copy 2 both change assert approx_equal( ncs_mam.model().get_sites_cart()[0], (5.820083333333333, -4.020400000000001, -4.445440000000001)) assert approx_equal( ncs_mam.model().get_sites_cart()[42], (38.41904613024224, 17.233251085893276, 2.5547442135142524)) # Find ncs from map or model nn = ncs_mam_copy nn.write_map('ncs.ccp4') nn.write_model('ncs.pdb') ncs_object = nn.get_ncs_from_model() dm.write_ncs_spec_file(ncs_object, 'ncs.ncs_spec') print("NCS from map", ncs_object) nn.set_ncs_object(ncs_object) print("NCS now: ", nn.ncs_object()) nn.get_ncs_from_map(ncs_object=ncs_object) print("ncs cc:", nn.ncs_cc()) assert approx_equal(nn.ncs_cc(), 0.961915979834, eps=0.01) # Make a deep_copy dc = mam.deep_copy() new_mam = mam.deep_copy() assert mam.map_manager().map_data()[0] == new_mam.map_manager().map_data( )[0] # Make a customized_copy new_mam = mam.customized_copy(model_dict={'model': mam.model()}) assert new_mam.model() is mam.model() assert not new_mam.map_dict() is mam.map_dict() new_mam = mam.customized_copy(model_dict={'model': mam.model()}, map_dict=mam.map_dict()) assert new_mam.model() is mam.model() assert new_mam.map_dict() is mam.map_dict() print(mam) # Add a map mam = dc.deep_copy() print(mam.map_id_list()) assert len(mam.map_id_list()) == 6 mam.add_map_manager_by_id(mam.map_manager().deep_copy(), 'new_map_manager') print(mam.map_id_list()) assert len(mam.map_id_list()) == 7 # duplicate a map mam = dc.deep_copy() print(mam.map_id_list()) assert len(mam.map_id_list()) == 6 mam.duplicate_map_manager('map_manager', 'new_map_manager') print(mam.map_id_list()) assert len(mam.map_id_list()) == 7 # resolution_filter a map mam = dc.deep_copy() print(mam.map_id_list()) mam.duplicate_map_manager('map_manager', 'new_map_manager') mam.resolution_filter(map_id='new_map_manager', d_min=3.5, d_max=6) # Add a model mam = dc.deep_copy() print(mam.model_id_list()) assert len(mam.model_id_list()) == 1 mam.add_model_by_id(mam.model().deep_copy(), 'new_model') print(mam.model_id_list()) assert len(mam.model_id_list()) == 2 # Initialize a map mam1 = new_mam.deep_copy() mam1.initialize_maps(map_value=6) assert mam1.map_manager().map_data()[225] == 6 # Create mask around density and apply to all maps mam1 = new_mam.deep_copy() mam1.mask_all_maps_around_density( solvent_content=0.5, soft_mask=True, ) s = (mam1.get_map_manager_by_id('mask').map_data() > 0.5) assert approx_equal((s.count(True), s.size()), (1024, 2048)) # Create mask around edges and apply to all maps mam1 = new_mam.deep_copy() mam1.mask_all_maps_around_edges() s = (mam1.get_map_manager_by_id('mask').map_data() > 0.5) assert approx_equal((s.count(True), s.size()), (1176, 2048)) # Create a soft mask around model and apply to all maps new_mam.mask_all_maps_around_atoms(mask_atoms_atom_radius=8, soft_mask=True) s = (new_mam.get_map_manager_by_id('mask').map_data() > 0.5) assert approx_equal((s.count(True), s.size()), (1944, 2048)) # Create a soft mask around model and do not do anything with it new_mam.create_mask_around_atoms(mask_atoms_atom_radius=8, soft_mask=True) s = (new_mam.get_map_manager_by_id('mask').map_data() > 0.5) assert approx_equal((s.count(True), s.size()), (1944, 2048)) # Create a soft mask around model and do not do anything with it, wrapping =true dummy_mam = new_mam.deep_copy() dummy_mam.map_manager().set_wrapping(True) dummy_mam.create_mask_around_atoms(mask_atoms_atom_radius=8, soft_mask=True) s = (dummy_mam.get_map_manager_by_id('mask').map_data() > 0.5) assert approx_equal((s.count(True), s.size()), (1944, 2048)) # Create a sharp mask around model and do not do anything with it new_mam.create_mask_around_atoms(soft_mask=False, mask_atoms_atom_radius=8) s = (new_mam.get_map_manager_by_id('mask').map_data() > 0.5) assert approx_equal((s.count(True), s.size()), (138, 2048)) # Mask around edges and do not do anything with it mam = dc.deep_copy() mam.create_mask_around_edges() s = (mam.get_map_manager_by_id('mask').map_data() > 0.5) assert approx_equal((s.count(True), s.size()), (1176, 2048)) # Mask around density and to not do anything with it mam = dc.deep_copy() mam.create_mask_around_density(soft_mask=False) s = (mam.get_map_manager_by_id('mask').map_data() > 0.5) assert approx_equal((s.count(True), s.size()), (1000, 2048)) # Apply the current mask to one map mam.apply_mask_to_map('map_manager') s = (mam.map_manager().map_data() > 0.) assert approx_equal((s.count(True), s.size()), (640, 2048)) s = (mam.map_manager().map_data() != 0.) assert approx_equal((s.count(True), s.size()), (1000, 2048)) assert approx_equal((mam.map_manager().map_data()[225]), -0.0418027862906) # Apply any mask to one map mam.apply_mask_to_map('map_manager', mask_id='mask') s = (mam.map_manager().map_data() > 0.) assert approx_equal((s.count(True), s.size()), (640, 2048)) s = (mam.map_manager().map_data() != 0.) assert approx_equal((s.count(True), s.size()), (1000, 2048)) assert approx_equal((mam.map_manager().map_data()[225]), -0.0418027862906) # Apply the mask to all maps mam.apply_mask_to_maps() s = (mam.map_manager().map_data() > 0.) assert approx_equal((s.count(True), s.size()), (640, 2048)) s = (mam.map_manager().map_data() != 0.) assert approx_equal((s.count(True), s.size()), (1000, 2048)) assert approx_equal((mam.map_manager().map_data()[225]), -0.0418027862906) # Apply the mask to all maps, setting outside value to mean inside mam.apply_mask_to_maps(set_outside_to_mean_inside=True) s = (mam.map_manager().map_data() > 0.) assert approx_equal((s.count(True), s.size()), (1688, 2048)) s = (mam.map_manager().map_data() != 0.) assert approx_equal((s.count(True), s.size()), (2048, 2048)) assert approx_equal((mam.map_manager().map_data()[2047]), -0.0759598612785) s = (mam.get_map_manager_by_id('mask').map_data() > 0).as_1d() inside = mam.map_manager().map_data().as_1d().select(s) outside = mam.map_manager().map_data().as_1d().select(~s) assert approx_equal( (inside.min_max_mean().max, outside.min_max_mean().max), (0.335603952408, 0.0239064293122)) # Make a new map and model, get mam and box with selection mmm = map_model_manager() mmm.generate_map(box_cushion=0, wrapping=True) mam = mmm mam_dc = mam.deep_copy() new_mm_1 = mam.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()), ((18, 25, 20), (18, 25, 20))) # Get local fsc or randomized map dc = mam_dc.deep_copy() dc.map_manager().set_wrapping(False) map_coeffs = dc.map_manager().map_as_fourier_coefficients(d_min=3) from cctbx.development.create_models_or_maps import generate_map new_mm_1 = generate_map(map_coeffs=map_coeffs, d_min=3, low_resolution_real_space_noise_fraction=1, high_resolution_real_space_noise_fraction=50, map_manager=dc.map_manager(), random_seed=124321) new_mm_2 = generate_map(map_coeffs=map_coeffs, d_min=3, low_resolution_real_space_noise_fraction=1, high_resolution_real_space_noise_fraction=50, map_manager=dc.map_manager(), random_seed=734119) dc.add_map_manager_by_id(new_mm_1, 'map_manager_1') dc.add_map_manager_by_id(new_mm_2, 'map_manager_2') cc = dc.map_map_cc() fsc_curve = dc.map_map_fsc() dc.set_log(sys.stdout) dc.local_fsc(n_boxes=1) # Get map-map FSC dc = mam_dc.deep_copy() dc.duplicate_map_manager(map_id='map_manager', new_map_id='filtered') dc.resolution_filter(d_min=3.5, d_max=10, map_id='filtered') dc.create_mask_around_atoms() fsc_curve = dc.map_map_fsc(map_id_1='map_manager', map_id_2='filtered', mask_id='mask', resolution=3.5, fsc_cutoff=0.97) assert approx_equal(fsc_curve.d_min, 3.91175024213, eps=0.01) assert approx_equal(fsc_curve.fsc.fsc[-1], 0.695137718033) # Get map-map CC dc = mam_dc.deep_copy() dc.duplicate_map_manager(map_id='map_manager', new_map_id='filtered') dc.resolution_filter(d_min=3.5, d_max=6, map_id='filtered') cc = dc.map_map_cc('map_manager', 'filtered') assert approx_equal(cc, 0.706499206126) # Get map-map CC with mask dc = mam_dc.deep_copy() dc.duplicate_map_manager(map_id='map_manager', new_map_id='filtered') dc.create_mask_around_density(mask_id='filtered') cc = dc.map_map_cc('map_manager', 'filtered', mask_id='mask') assert approx_equal(cc, 0.411247493741) # box around model mam = mam_dc.deep_copy() mam.box_all_maps_around_model_and_shift_origin( selection_string="resseq 221:221") new_mm_1 = mam.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()), ((18, 25, 20), (24, 20, 20))) # extract_around_model (get new mam) new_mam_dc = mam_dc.extract_all_maps_around_model( selection_string="resseq 221:221") new_mm_1a = new_mam_dc.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1a.map_data().all()), ((18, 25, 20), (24, 20, 20))) assert approx_equal(new_mm_1.map_data(), new_mm_1a.map_data()) # box around_density mam2 = mam_dc.deep_copy() mam2.box_all_maps_around_density_and_shift_origin(box_cushion=0) new_mm_2 = mam2.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_2.map_data().all()), ((18, 25, 20), (16, 23, 18))) # extract_around_density (get new mam) mam2 = mam_dc.deep_copy() mam2_b = mam2.extract_all_maps_around_density(box_cushion=0) new_mm_2 = mam2_b.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_2.map_data().all()), ((18, 25, 20), (16, 23, 18))) # Repeat as map_model_manager: mmm = mam_dc.as_map_model_manager().deep_copy() mmm.box_all_maps_around_model_and_shift_origin( selection_string="resseq 221:221") new_mm_1a = mmm.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1a.map_data().all()), ((24, 20, 20), (24, 20, 20))) assert approx_equal(new_mm_1.map_data(), new_mm_1a.map_data()) # box around density mam.box_all_maps_around_density_and_shift_origin(box_cushion=0) new_mm_1 = mam.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()), ((24, 20, 20), (22, 18, 18))) # extract around density (get new mam) mam1 = mam_dc.deep_copy() mam1.extract_all_maps_around_density(box_cushion=0) new_mm_1 = mam1.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()), ((24, 20, 20), (18, 25, 20))) # create mask around density, then box around mask (i.e., box around density) mam.create_mask_around_density(soft_mask=False) mam.box_all_maps_around_mask_and_shift_origin(box_cushion=3) new_mm_1 = mam.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()), ((24, 20, 20), (22, 18, 18))) # box with bounds mam.box_all_maps_with_bounds_and_shift_origin(lower_bounds=(10, 10, 10), upper_bounds=(15, 15, 15)) new_mm_1 = mam.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()), ((24, 20, 20), (6, 6, 6))) # extract with bounds mam = mam_dc.deep_copy() mam_1 = mam.extract_all_maps_with_bounds(lower_bounds=(10, 10, 10), upper_bounds=(15, 15, 15)) new_mm_1 = mam_1.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()), ((24, 20, 20), (6, 6, 6))) # box with unique mam = mam_dc.deep_copy() mam.box_all_maps_around_unique_and_shift_origin(molecular_mass=2500, resolution=3) new_mm_1 = mam.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()), ((24, 20, 20), (18, 25, 20))) # extract with unique mam = mam_dc.deep_copy() mam_1 = mam.extract_all_maps_around_unique(molecular_mass=2500, resolution=3) new_mm_1 = mam_1.map_manager() assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()), ((24, 20, 20), (18, 25, 20))) # extract a box and then restore model into same reference as current mam mam = mam_dc.deep_copy() mam.box_all_maps_with_bounds_and_shift_origin(lower_bounds=(2, 2, 2), upper_bounds=(17, 17, 17)) print("mam:", mam.model().get_sites_cart()[0], mam.map_manager().origin_is_zero()) # extract a box box_mam = mam.extract_all_maps_with_bounds(lower_bounds=(10, 10, 10), upper_bounds=(15, 15, 15)) box_model = box_mam.model() matched_box_model = mam.get_model_from_other(box_mam) assert approx_equal(matched_box_model.get_sites_cart()[0], mam.model().get_sites_cart()[0]) # Convert a map to fourier coefficients mam = mam_dc.deep_copy() ma = mam.map_as_fourier_coefficients(d_min=3) assert approx_equal(ma.d_min(), 3.01655042414) mam.add_map_from_fourier_coefficients(ma, map_id='new_map_manager') cc = flex.linear_correlation( mam.get_map_manager_by_id('map_manager').map_data().as_1d(), mam.get_map_manager_by_id( 'new_map_manager').map_data().as_1d()).coefficient() assert (cc >= 0.99) # Get map-model CC dc = mam_dc.extract_all_maps_around_model( selection_string="(name ca or name cb or name c or name o) " + "and resseq 221:221", box_cushion=0) cc = dc.map_model_cc(resolution=3) assert approx_equal(cc, 0.450025539936) # Remove model outside map dc.remove_model_outside_map(boundary=0) assert (mam_dc.model().get_sites_cart().size(), dc.model().get_sites_cart().size()) == (86, 4) # shift a model to match the map dc = mam_dc.extract_all_maps_around_model( selection_string="(name ca or name cb or name c or name o) " + "and resseq 221:221", box_cushion=0) actual_model = dc.model().deep_copy() working_model = dc.model().deep_copy() working_model.set_shift_cart((0, 0, 0)) working_model.set_sites_cart(working_model.get_sites_cart() - actual_model.shift_cart()) dc.shift_any_model_to_match(working_model) assert approx_equal(actual_model.get_sites_cart()[0], working_model.get_sites_cart()[0])
def _try_as_ccp4_map(self): from iotbx.map_manager import map_manager from libtbx.utils import null_out map_object = map_manager(file_name=str(self.file_name), log=null_out()) self._file_type = "ccp4_map" self._file_object = map_object
def test_01(): # Source data (map and model) data_dir = os.path.dirname(os.path.abspath(__file__)) data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4') data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_model.pdb') # Read in map data with data_manager dm = DataManager(['real_map']) dm.set_overwrite(True) # Next step uses map_manager to do the actual reading dm.process_real_map_file(data_ccp4) mm = dm.get_real_map() # Shift the origin of the map; starts at (100,100,100) print(mm.map_data().origin()) assert mm.map_data().origin() == (100, 100, 100) assert mm.origin_shift_grid_units == (0, 0, 0) mm.shift_origin() assert mm.map_data().origin() == (0, 0, 0) assert mm.origin_shift_grid_units == (100, 100, 100) mm.show_summary() # test cc_to_other_map assert mm.cc_to_other_map_manager(mm) == 1 # test writing and reading file dm.write_real_map_file(mm, filename='test_map_manager.ccp4', overwrite=True) dm.process_real_map_file('test_map_manager.ccp4') new_mm = dm.get_real_map('test_map_manager.ccp4') os.remove('test_map_manager.ccp4') new_mm.shift_origin() # Check whether gridding and crystal_symmetry are similar for mm, new_mm assert new_mm.is_similar(mm) assert approx_equal(new_mm.map_data()[3125], mm.map_data()[3125]) # test writing and reading file without shifting origin dm = DataManager(['real_map']) dm.set_overwrite(True) dm.process_real_map_file(data_ccp4) mm = dm.get_real_map() mm.show_summary() dm.write_real_map_file(mm, filename='test_map_manager.ccp4', overwrite=True) new_mm = map_manager('test_map_manager.ccp4') assert (new_mm.is_similar(mm)) new_mm.shift_origin() assert (not new_mm.is_similar(mm)) # get map_data dm = DataManager(['real_map']) dm.set_overwrite(True) dm.process_real_map_file(data_ccp4) mm = dm.get_real_map() mm.shift_origin() map_data = mm.map_data() assert approx_equal(map_data[15, 10, 19], 0.38, eps=0.01) # get crystal_symmetry cs = mm.crystal_symmetry() assert approx_equal(cs.unit_cell().parameters()[0], 22.41, eps=0.01) # and full cell symmetry full_cs = mm.unit_cell_crystal_symmetry() assert approx_equal(full_cs.unit_cell().parameters()[0], 149.4066, eps=0.01) # write map directly: mm.write_map('test_direct.ccp4') # read back directly new_mm = map_manager('test_direct.ccp4') assert (not new_mm.is_similar(mm)) new_mm.shift_origin() assert mm.is_similar(new_mm) assert approx_equal(new_mm.map_data()[3125], mm.map_data()[3125]) # deep_copy new_mm = mm.deep_copy() assert new_mm.is_similar(mm) assert approx_equal(new_mm.map_data()[3125], mm.map_data()[3125]) # deep_copy a map without shifting origin # Make a DataManager that can write a map coeffs file too dm = DataManager(['miller_array', 'real_map']) dm.set_overwrite(True) dm.process_real_map_file(data_ccp4) omm = dm.get_real_map() omm.show_summary() new_omm = omm.deep_copy() assert new_omm.is_similar(omm) assert (not new_omm.is_similar(mm)) # customized_copy new_mm = mm.customized_copy(map_data=mm.map_data().deep_copy()) assert new_mm.is_similar(mm) # Initialize with parameters mm_para = map_manager( unit_cell_grid=mm.unit_cell_grid, unit_cell_crystal_symmetry=mm.unit_cell_crystal_symmetry(), origin_shift_grid_units=mm.origin_shift_grid_units, map_data=mm.map_data(), wrapping=False) assert mm_para.is_similar(mm) # Adjust origin and gridding: mm_read = map_manager(data_ccp4) mm_read.shift_origin() mm.show_summary() mm_read.show_summary() mm_read.set_original_origin_and_gridding((10, 10, 10), gridding=(100, 100, 100)) mm_read.show_summary() assert (not mm_read.is_similar(mm)) assert (mm_read.origin_is_zero()) # Set program name mm_read.set_program_name('test program') assert mm_read.program_name == 'test program' # Set limitation mm_read.add_limitation('map_is_sharpened') assert mm_read.limitations == ['map_is_sharpened'] # Add a label mm_read.add_label('TEST LABEL') assert mm_read.labels[0] == 'TEST LABEL' mm_read.write_map('map_with_labels.mrc') new_mm = map_manager('map_with_labels.mrc') assert 'TEST LABEL' in new_mm.labels assert new_mm.is_in_limitations('map_is_sharpened') assert new_mm.labels[0].find('test program') > -1 # change the cell dimensions mm_read = map_manager(data_ccp4) mm_read.shift_origin() assert mm_read.is_similar(mm) assert approx_equal(mm_read.pixel_sizes(), (0.7470, 0.7231, 0.7374), eps=0.001) from cctbx import crystal new_uc_params = list( mm_read.unit_cell_crystal_symmetry().unit_cell().parameters()) new_uc_params[0] += 10 new_cs = crystal.symmetry(new_uc_params, 1) mm_read.set_unit_cell_crystal_symmetry(new_cs) assert not mm_read.crystal_symmetry().is_similar_symmetry( mm.crystal_symmetry()) assert not mm_read.is_similar(mm) mm_read.show_summary() assert approx_equal(mm_read.pixel_sizes(), (0.7970, 0.7231, 0.7374), eps=0.001) # Read a map directly mm_read = map_manager(data_ccp4) mm_read.shift_origin() assert mm_read.is_similar(mm) # Set log import sys mm.set_log(sys.stdout) # Add map_data new_mm = mm_read.customized_copy(map_data=mm.map_data().deep_copy()) assert new_mm.is_similar(mm) # replace data new_mm.set_map_data(map_data=mm.map_data().deep_copy()) assert new_mm.is_similar(mm) # create a full-sized map from this one mm_full_size = mm_read.deep_copy().as_full_size_map() assert not mm_full_size.is_similar(mm_read) print(mm_full_size.map_data().origin(), mm_read.map_data().origin()) print(mm_full_size.map_data().all(), mm_read.map_data().all()) # Apply a mask to edges of a map assert approx_equal(new_mm.map_data().as_1d().min_max_mean().max, mm.map_data().as_1d().min_max_mean().max) assert approx_equal((new_mm.map_data()[0], mm.map_data()[0]), (0.0, 0.0)) new_mm.create_mask_around_edges(soft_mask_radius=3) new_mm.soft_mask(soft_mask_radius=3) assert approx_equal(new_mm.map_data().as_1d().min_max_mean().max, mm.map_data().as_1d().min_max_mean().max) new_mm.apply_mask(set_outside_to_mean_inside=True) assert approx_equal((new_mm.map_data()[0], mm.map_data()[0]), (0.0116267086024, 0.0)) dm.process_real_map_file('test_map_manager.ccp4') new_mm = dm.get_real_map('test_map_manager.ccp4') new_mm.show_summary() assert (not new_mm.is_similar(mm)) new_mm.shift_origin() new_mm.show_summary() assert new_mm.is_similar(mm) os.remove('test_map_manager.ccp4') # Check origin_shifts print(new_mm.origin_shift_grid_units) print(new_mm.shift_cart()) assert approx_equal(new_mm.origin_shift_grid_units, (100, 100, 100)) assert approx_equal( new_mm.shift_cart(), (-74.70333099365234, -72.30750274658205, -73.7437515258789)) # Convert to map coeffs, write out, read back, convert back to map map_coeffs = mm.map_as_fourier_coefficients(d_min=3) mtz_dataset = map_coeffs.as_mtz_dataset(column_root_label='F') mtz_object = mtz_dataset.mtz_object() dm.write_miller_array_file(mtz_object, filename="map_coeffs.mtz") # Note these Fourier coeffs correspond to working map (not original position) array_labels = dm.get_miller_array_labels("map_coeffs.mtz") labels = array_labels[0] dm.get_reflection_file_server(filenames=["map_coeffs.mtz"], labels=[labels]) miller_arrays = dm.get_miller_arrays() new_map_coeffs = miller_arrays[0] mm_from_map_coeffs = mm.fourier_coefficients_as_map_manager( map_coeffs=new_map_coeffs) assert mm_from_map_coeffs.is_similar(mm) # Find map symmetry in a map data_d7 = os.path.join(data_dir, 'data', 'D7.ccp4') dm = DataManager(['real_map', 'model']) dm.process_real_map_file(data_d7) dm.process_model_file(data_pdb) mm = dm.get_real_map(data_d7) model = dm.get_model(data_pdb) mm.shift_origin() mm.set_original_origin_and_gridding(original_origin=(0, 0, 0)) # Box it so it is not so easy to find symmetry from cctbx.maptbx.box import with_bounds box = with_bounds(mm, lower_bounds=(2, 2, 2), upper_bounds=(43, 43, 43)) new_mm = box.map_manager() new_mm.find_map_symmetry(symmetry='d7', min_ncs_cc=0.8, include_helical_symmetry=False) ncs_obj = new_mm.ncs_object() assert ncs_obj is not None print("NCS: ", new_mm.ncs_object().as_ncs_spec_string()) another_mm = map_manager( unit_cell_grid=new_mm.unit_cell_grid, unit_cell_crystal_symmetry=new_mm.unit_cell_crystal_symmetry(), origin_shift_grid_units=new_mm.origin_shift_grid_units, map_data=new_mm.map_data(), ncs_object=ncs_obj, wrapping=False) assert another_mm.is_similar(new_mm) assert ncs_obj.is_similar_ncs_object(another_mm.ncs_object()) assert new_mm.is_similar(another_mm) # Adjust model and ncs symmetry to match this map assert model.shift_cart() is None new_mm.set_model_symmetries_and_shift_cart_to_match_map(model) assert approx_equal( model.shift_cart(), (-0.888888888888889, -0.8888888888888891, -0.888888888888889)) assert new_mm.is_compatible_ncs_object(ncs_obj) ncs_obj.set_shift_cart((0, 0, 0)) assert not new_mm.is_compatible_ncs_object(ncs_obj) new_mm.set_ncs_object_shift_cart_to_match_map(ncs_obj) new_mm.set_ncs_object(ncs_obj) assert new_mm.is_compatible_ncs_object(new_mm.ncs_object()) new_mm.show_summary() new_mm.shift_origin(desired_origin=(11, 1, 1)) print(new_mm.shift_cart(), new_mm.ncs_object().shift_cart()) assert new_mm.is_compatible_ncs_object(new_mm.ncs_object()) new_mm.shift_origin() assert new_mm.is_compatible_ncs_object(new_mm.ncs_object()) # filter a map dm = DataManager() mm = dm.get_real_map(data_d7) low_pass_filtered = mm.deep_copy() low_pass_filtered.resolution_filter(d_min=2.5) high_pass_filtered = mm.deep_copy() high_pass_filtered.resolution_filter(d_max=2.5) gaussian = mm.deep_copy() gaussian.gaussian_filter(smoothing_radius=1) binary = mm.deep_copy() binary.binary_filter(threshold=0.5) assert approx_equal( (mm.map_data().as_1d()[1073], low_pass_filtered.map_data().as_1d()[1073], high_pass_filtered.map_data().as_1d()[1073], gaussian.map_data().as_1d()[1073], binary.map_data().as_1d()[1073]), (0.0171344596893, 0.0227163900537, -0.0072717454565, 0.0149086679298, 0.0)) info = mm.get_density_along_line((5, 5, 5), (10, 10, 10)) assert approx_equal([info.along_density_values[4]] + list(info.along_sites[4]), [-0.562231123447, 8.0, 8.0, 8.0]) from iotbx.map_model_manager import map_model_manager extra_map_manager_id_list = [ "low_pass_filtered", "high_pass_filtered", "gaussian", "binary" ] expected_cc = [ 0.999920243317, 0.0129365545729, 0.971491994253, 0.733986499746 ] mam = map_model_manager( map_manager=mm, extra_map_manager_list=[ low_pass_filtered, high_pass_filtered, gaussian, binary ], extra_map_manager_id_list=extra_map_manager_id_list, ) for other_id, cc in zip(extra_map_manager_id_list, expected_cc): assert approx_equal( cc, mam.map_map_cc(map_id='map_manager', other_map_id=other_id))
def generate_map( output_map_file_name=None, map_coeffs=None, # Required d_min=None, map_manager=None, # source of info, not map gridding=None, wrapping=False, resolution_factor=None, origin_shift_grid_units=None, low_resolution_fourier_noise_fraction=0, high_resolution_fourier_noise_fraction=0, low_resolution_real_space_noise_fraction=0, high_resolution_real_space_noise_fraction=0, low_resolution_noise_cutoff=None, random_seed=None, log=sys.stdout): ''' Generate map from map_coefficients and add noise in Fourier or real space This function typically accessed and tested through map_model_manager Summary: -------- Calculate a map and optionally add noise to it. Supply map coefficients (miller_array object) and types of noise to add, along with optional gridding (nx,ny,nz), and origin_shift_grid_units. Optionally create map coefficients from a model and optionally generate a model. Unique aspect of this noise generation is that it can be specified whether the noise is local in real space (every point in a map gets a random value before Fourier filtering), or local in Fourier space (every Fourier coefficient gets a complex random offset). Also the relative contribution of each type of noise vs resolution can be controlled. Parameters: ----------- output_map_file_name (string, None): Output map file (MRC/CCP4 format) map_coeffs (miller.array object, None) : map coefficients d_min(float): high_resolution limit (A) gridding (tuple (nx,ny,nz), None): Gridding of map (optional) origin_shift_grid_units (tuple (ix,iy,iz), None): Move location of origin of resulting map to (ix,iy,iz) before writing out low_resolution_fourier_noise_fraction (float, 0): Low-res Fourier noise high_resolution_fourier_noise_fraction (float, 0): High-res Fourier noise low_resolution_real_space_noise_fraction(float, 0): Low-res real-space noise high_resolution_real_space_noise_fraction (float, 0): High-res real-space noise low_resolution_noise_cutoff (float, None): Low resolution where noise starts to be added ''' if random_seed: random_seed = int(random_seed) import random random.seed(random_seed) random_seed = random.randint(1, 714717) flex.set_random_seed(random_seed) if map_manager: origin_shift_grid_units = map_manager.origin_shift_grid_units gridding = map_manager.map_data().all() wrapping = map_manager.wrapping() if gridding: if type(gridding) in [type( (1, 2, 3)), type([1, 2, 3])] and type(gridding[0]) == type(1): pass # already fine else: new_gridding = [] for x in str(gridding).replace("(", "").replace(")", "").replace( "[", "").replace("]", "").replace(",", "").split(): new_gridding.append(int(x)) gridding = new_gridding low_resolution_fourier_noise_fraction = float( low_resolution_fourier_noise_fraction) high_resolution_fourier_noise_fraction = float( high_resolution_fourier_noise_fraction) low_resolution_real_space_noise_fraction = float( low_resolution_real_space_noise_fraction) high_resolution_real_space_noise_fraction = float( high_resolution_real_space_noise_fraction) if low_resolution_noise_cutoff: low_resolution_noise_cutoff = float(low_resolution_noise_cutoff) if d_min: d_min = float(d_min) map_coeffs = map_coeffs.resolution_filter(d_min=d_min) # Calculate a map from Fourier coefficients: map_data = get_map_from_map_coeffs( map_coeffs=map_coeffs, crystal_symmetry=map_coeffs.crystal_symmetry(), n_real=gridding, resolution_factor=resolution_factor, apply_sigma_scaling=False) # Optionally add noise to this map as an additive noise map # Noise can be added in Fourier space (leads to correlated errors # in real space) or in real space (leads to correlated errors # in Fourier space). # Noise is Fourier-weighted as function of resolution. # RMS noise to add at low-resolution (Fourier based noise) as fraction of RMS # value in map at low-resolution is: low_resolution_fourier_noise_fraction # RMS Fourier high-res noise:is high_resolution_fourier_noise_fraction # RMS real-space low-res noise:is low_resolution_real_space_noise_fraction # RMS real-space high-res noise:is high_resolution_real_space_noise_fraction # Low-resolution where noise begins to be added is low_resolution_noise_cutoff if (low_resolution_fourier_noise_fraction or high_resolution_fourier_noise_fraction): fourier_noise_map = get_fourier_noise_map( n_real=map_data.all(), map_coeffs=map_coeffs, low_resolution_fourier_noise_fraction= low_resolution_fourier_noise_fraction, high_resolution_fourier_noise_fraction= high_resolution_fourier_noise_fraction, d_min=d_min, low_resolution_noise_cutoff=low_resolution_noise_cutoff, log=log) else: fourier_noise_map = None if (low_resolution_real_space_noise_fraction or high_resolution_real_space_noise_fraction): real_space_noise_map = get_real_space_noise_map( map_data=map_data, map_coeffs=map_coeffs, low_resolution_real_space_noise_fraction= low_resolution_real_space_noise_fraction, high_resolution_real_space_noise_fraction= high_resolution_real_space_noise_fraction, d_min=d_min, low_resolution_noise_cutoff=low_resolution_noise_cutoff, log=log) else: real_space_noise_map = None if fourier_noise_map: map_data += fourier_noise_map if real_space_noise_map: map_data += real_space_noise_map if map_manager: mm = map_manager.customized_copy(map_data=map_data) else: # Create a map_manager object directly (unusual use of map_manager) from iotbx.map_manager import map_manager mm = map_manager( map_data=map_data, unit_cell_grid=map_data.all(), unit_cell_crystal_symmetry=map_coeffs.crystal_symmetry(), origin_shift_grid_units=origin_shift_grid_units, wrapping=wrapping) if output_map_file_name: mm.write_map(output_map_file_name) else: print("Generated map with origin at %s and size of %s" % (mm.map_data().origin(), mm.map_data().all()), file=log) return mm
def generate_map(map_coeffs=None, high_resolution=3, gridding=None, origin_shift_grid_units=None, low_resolution_fourier_noise_fraction=0, high_resolution_fourier_noise_fraction=0, low_resolution_real_space_noise_fraction=0, high_resolution_real_space_noise_fraction=0, output_map_file_name=None, log=sys.stdout, **pass_through_kw ): # pass_through_kw picks up all the keywords that are to be # passed to other routines ''' generate_map Convenience method to calculate a map and optionally add noise to it. Supply map coefficients (miller_array object) and types of noise to add, along with optional gridding (nx,ny,nz), and origin_shift_grid_units. Not implemented: Unique aspect of this noise generation is that it can be specified whether the noise is local in real space (every point in a map gets a random value before Fourier filtering), or local in Fourier space (every Fourier coefficient gets a complex random offset). Also the relative contribution of each type of noise vs resolution can be controlled. Full list of keywords that can be supplied. These affect generate_model, generate_map_coefficients and generate_map: model_file_name=None # file to read model from n_residues=10, # how many residues to include b_iso=30, # what b_iso to set all the atoms to box_buffer=5, # buffer around atoms start_res=None, # residue to start with space_group_number=1, # space group number for model and map output_model_file_name=None, # file name for model (if any) random_seed=None, # random seed for shake shake=None, # rms offset for each atom if any scattering_table='electron', # scattering table, electron n_gaussian gridding=None, # optional gridding for map origin_shift_grid_units=None, # optional origin for map low_resolution_fourier_noise_fraction=0, # fourier noise lowres high_resolution_fourier_noise_fraction=0, # hires low_resolution_real_space_noise_fraction=0, # real-space noise lowres high_resolution_real_space_noise_fraction=0, # real-space noise hires output_map_file_name=None, # optional output map file namd ''' if gridding: if type(gridding) == type([1, 2, 3]) and type(gridding[0]) == type(1): pass # already fine else: gridding = [] for x in str(gridding).replace(",", "").split(): gridding.append(int(x)) if not map_coeffs: # get map coefficients map_coeffs = generate_map_coefficients(high_resolution=high_resolution, log=log, **pass_through_kw) if high_resolution: map_coeffs = map_coeffs.resolution_filter(d_min=high_resolution) # Calculate a map from Fourier coefficients: from cctbx.maptbx.segment_and_split_map import get_map_from_map_coeffs map_data = get_map_from_map_coeffs( map_coeffs=map_coeffs, crystal_symmetry=map_coeffs.crystal_symmetry(), n_real=gridding, apply_sigma_scaling=False) from iotbx.map_manager import map_manager mm = map_manager(map_data=map_data, unit_cell_grid=map_data.all(), unit_cell_parameters=map_coeffs.crystal_symmetry( ).unit_cell().parameters(), space_group_number=map_coeffs.crystal_symmetry(). space_group().info().symbol_and_number().split('(')[0], origin_shift_grid_units=origin_shift_grid_units) if output_map_file_name: mm.write_map(output_map_file_name) else: print("Generated map with origin at %s and size of %s" % (mm.map_data().origin(), mm.map_data().all()), file=log) return mm
def test_01(): data_dir = os.path.dirname(os.path.abspath(__file__)) data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4') data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4') dm = DataManager(['miller_array', 'real_map', 'phil']) dm.set_overwrite(True) dm.process_real_map_file(data_ccp4) # test writing and reading file mm = dm.get_real_map() mm.shift_origin() mm.show_summary() dm.write_real_map_file(mm, filename='test_map_manager.ccp4', overwrite=True) os.remove('test_map_manager.ccp4') # test writing and reading file without shifting origin dm = DataManager(['miller_array', 'real_map', 'phil']) dm.set_overwrite(True) dm.process_real_map_file(data_ccp4) mm = dm.get_real_map() mm.show_summary() dm.write_real_map_file(mm, filename='test_map_manager.ccp4', overwrite=True) new_mm = map_manager('test_map_manager.ccp4') assert (new_mm.is_similar(mm)) new_mm.shift_origin() assert (not new_mm.is_similar(mm)) # get map_data mm.shift_origin() map_data = mm.map_data() assert approx_equal(map_data[15, 10, 19], 0.38, eps=0.01) # get crystal_symmetry cs = mm.crystal_symmetry() assert approx_equal(cs.unit_cell().parameters()[0], 22.41, eps=0.01) # and full cell symmetry full_cs = mm.unit_cell_crystal_symmetry() assert approx_equal(full_cs.unit_cell().parameters()[0], 149.4066, eps=0.01) # write map directly: mm.write_map('test_direct.ccp4') # read back directly new_mm = map_manager('test_direct.ccp4') assert (not new_mm.is_similar(mm)) new_mm.shift_origin() assert mm.is_similar(new_mm) # deep_copy new_mm = mm.deep_copy() assert new_mm.is_similar(mm) # deep_copy a map without shifting origin dm = DataManager(['miller_array', 'real_map', 'phil']) dm.set_overwrite(True) dm.process_real_map_file(data_ccp4) omm = dm.get_real_map() omm.show_summary() new_omm = omm.deep_copy() assert new_omm.is_similar(omm) assert (not new_omm.is_similar(mm)) # customized_copy new_mm = mm.customized_copy(map_data=mm.map_data().deep_copy()) assert new_mm.is_similar(mm) # Initialize with parameters mm_para = map_manager( unit_cell_grid=mm.unit_cell_grid, unit_cell_crystal_symmetry=mm.unit_cell_crystal_symmetry(), origin_shift_grid_units=mm.origin_shift_grid_units, map_data=mm.map_data()) assert mm_para.is_similar(mm) # Adjust origin and gridding: mm_read = map_manager(data_ccp4) mm_read.shift_origin() mm.show_summary() mm_read.show_summary() mm_read.set_original_origin_and_gridding((10, 10, 10), gridding=(100, 100, 100)) mm_read.show_summary() assert (not mm_read.is_similar(mm)) assert (mm_read.origin_is_zero()) # Set program name mm_read.set_program_name('test program') assert mm_read.program_name == 'test program' # Set limitation mm_read.add_limitation('map_is_sharpened') assert mm_read.limitations == ['map_is_sharpened'] # Add a label mm_read.add_label('TEST LABEL') assert mm_read.labels[0] == 'TEST LABEL' mm_read.write_map('map_with_labels.mrc') new_mm = map_manager('map_with_labels.mrc') assert 'TEST LABEL' in new_mm.labels assert new_mm.is_in_limitations('map_is_sharpened') assert new_mm.labels[0].find('test program') > -1 # Read a map directly mm_read = map_manager(data_ccp4) mm_read.shift_origin() assert mm_read.is_similar(mm) # Set log import sys mm.set_log(sys.stdout) # Add map_data new_mm = mm_read.customized_copy(map_data=mm.map_data().deep_copy()) assert new_mm.is_similar(mm) # replace data new_mm.set_map_data(map_data=mm.map_data().deep_copy()) assert new_mm.is_similar(mm) # Apply a mask to edges of a map assert approx_equal(new_mm.map_data().as_1d().min_max_mean().max, mm.map_data().as_1d().min_max_mean().max) assert approx_equal((new_mm.map_data()[0], mm.map_data()[0]), (0.0, 0.0)) new_mm.create_mask_around_edges(soft_mask_radius=3) new_mm.soft_mask(soft_mask_radius=3) assert approx_equal(new_mm.map_data().as_1d().min_max_mean().max, mm.map_data().as_1d().min_max_mean().max) new_mm.apply_mask(set_outside_to_mean_inside=True) assert approx_equal((new_mm.map_data()[0], mm.map_data()[0]), (0.0116267086024, 0.0)) dm.process_real_map_file('test_map_manager.ccp4') new_mm = dm.get_real_map('test_map_manager.ccp4') new_mm.show_summary() assert (not new_mm.is_similar(mm)) new_mm.shift_origin() new_mm.show_summary() assert new_mm.is_similar(mm) os.remove('test_map_manager.ccp4') # Check origin_shifts print(new_mm.origin_shift_grid_units) print(new_mm.origin_shift_cart()) assert approx_equal(new_mm.origin_shift_grid_units, (100, 100, 100)) assert approx_equal( new_mm.origin_shift_cart(), (74.70333099365234, 72.30750274658205, 73.7437515258789)) # Convert to map coeffs, write out, read back, convert back to map map_coeffs = mm.map_as_fourier_coefficients(high_resolution=3) mtz_dataset = map_coeffs.as_mtz_dataset(column_root_label='F') mtz_object = mtz_dataset.mtz_object() dm.write_miller_array_file(mtz_object, filename="map_coeffs.mtz") # Note these Fourier coeffs correspond to working map (not original position) array_labels = dm.get_miller_array_labels("map_coeffs.mtz") labels = array_labels[0] dm.get_reflection_file_server(filenames=["map_coeffs.mtz"], labels=[labels]) miller_arrays = dm.get_miller_arrays() new_map_coeffs = miller_arrays[0] map_data_from_map_coeffs = mm.fourier_coefficients_as_map( map_coeffs=new_map_coeffs) mm_from_map_coeffs = mm.customized_copy(map_data=map_data_from_map_coeffs) assert mm_from_map_coeffs.is_similar(mm)
def __init__(self, model, target_map, refine_ncs_operators=False, number_of_cycles=1, cycles_to_converge=2, min_mode='simple_cycles', resolution=3., log=None): # completely new way of doing this. using RSR macro-cycle # for test compatibility: print("Minimizing using reference map...", file=log) if model.ncs_constraints_present(): print(" Minimizing... (NCS)", file=log) else: print(" Minimizing...", file=log) from phenix.refinement.macro_cycle_real_space import run as rsr_mc_run import scitbx.math from phenix.refinement import rsr rsr_master_params = rsr.master_params_str import iotbx.phil rsr_master_params = iotbx.phil.parse(rsr_master_params, process_includes=True) import mmtbx.idealized_aa_residues.rotamer_manager sin_cos_table = scitbx.math.sin_cos_table(n=10000) params = rsr_master_params.extract() params.pdb_interpretation = model._pdb_interpretation_params.pdb_interpretation params.refinement.run = "minimization_global+local_grid_search" params.refine_ncs_operators=False params.refinement.macro_cycles = number_of_cycles params.resolution = resolution rotamer_manager = mmtbx.idealized_aa_residues.rotamer_manager.load( rotamers = "favored") rigid_body_selections = [] # no RBR here from iotbx import map_model_manager from iotbx import map_manager mm = map_manager.map_manager( map_data = target_map, unit_cell_grid = target_map.all(), wrapping = False, unit_cell_crystal_symmetry = model.crystal_symmetry()) mmm = map_model_manager.map_model_manager( model = model, map_manager = mm) res = rsr_mc_run( params = params, map_model_manager = mmm, log = log, rotamer_manager = rotamer_manager, sin_cos_table = sin_cos_table, rigid_body_selections = rigid_body_selections) model.set_sites_cart_from_hierarchy(res.model.get_hierarchy()) res.structure_monitor.states_collector.write(file_name="rsr_all_states.pdb") return # end =================================================== # Very sophisticated implementation. Need to investigate before removal. from mmtbx.refinement.geometry_minimization import add_rotamer_restraints from mmtbx.refinement.minimization_monitor import minimization_monitor self.model = model self.log = log print("Minimizing using reference map...", file=self.log) self.log.flush() # copy-paste from cctbx_project/mmtbx/refinement/geometry_minimization.py: # minimize_wrapper_for_ramachandran self.model.get_restraints_manager().geometry.pair_proxies( sites_cart=self.model.get_sites_cart()) ncs_restraints_group_list = self.model.get_ncs_groups() if ncs_restraints_group_list is None: ncs_restraints_group_list = [] ncs_groups=None if len(ncs_restraints_group_list) > 0: ncs_groups=ncs_restraints_group_list min_monitor = minimization_monitor( number_of_cycles=number_of_cycles, max_number_of_cycles=20, cycles_to_converge=cycles_to_converge, mode=min_mode) selection_real_space = None import mmtbx.refinement.real_space.weight self.w = 1 print("number_of_cycles", number_of_cycles, file=log) print("Stats before minimization:", file=log) ms = self.model.geometry_statistics() ms.show(log=log) while min_monitor.need_more_cycles(): print("Cycle number", min_monitor.get_current_cycle_n(), file=self.log) self.model.get_restraints_manager().geometry.\ update_ramachandran_restraints_phi_psi_targets( hierarchy=self.model.get_hierarchy()) print(" Updating rotamer restraints...", file=self.log) add_rotamer_restraints( pdb_hierarchy = self.model.get_hierarchy(), restraints_manager = self.model.get_restraints_manager(), selection = None, sigma = 5, mode = "fix_outliers", accept_allowed = False, mon_lib_srv = self.model.get_mon_lib_srv(), rotamer_manager = self.model.get_rotamer_manager()) self.model.set_sites_cart_from_hierarchy() if min_monitor.need_weight_optimization(): # if self.w is None: print(" Determining weight...", file=self.log) self.log.flush() self.weight = mmtbx.refinement.real_space.weight.run( map_data = target_map, xray_structure = self.model.get_xray_structure(), pdb_hierarchy = self.model.get_hierarchy(), geometry_restraints_manager = self.model.get_restraints_manager(), rms_bonds_limit = 0.015, rms_angles_limit = 1.0, ncs_groups = ncs_groups) # division is to put more weight onto restraints. Checked. Works. self.w = self.weight.weight/3.0 # self.w = self.weight.weight/15.0 # self.w = 0 # self.w = self.weight.weight for s in self.weight.msg_strings: print(s, file=self.log) if ncs_restraints_group_list is None or len(ncs_restraints_group_list)==0: #No NCS print(" Minimizing...", file=self.log) print(" with weight %f" % self.w, file=self.log) self.log.flush() refine_object = simple( target_map = target_map, selection = None, max_iterations = 150, geometry_restraints_manager = self.model.get_restraints_manager().geometry, selection_real_space = selection_real_space, states_accumulator = None, ncs_groups = ncs_groups) refine_object.refine(weight = self.w, xray_structure = self.model.get_xray_structure()) self.rmsd_bonds_final, self.rmsd_angles_final = refine_object.rmsds() print("RMSDS:", self.rmsd_bonds_final, self.rmsd_angles_final, file=log) # print >> log, "sizes:", len(refine_object.sites_cart()), len(self.xrs.scatterers()) self.model.set_sites_cart(refine_object.sites_cart(), update_grm=True) # print >> log, "sizes", self.xrs.scatterers() else: # Yes NCS # copy-paste from macro_cycle_real_space.py # !!! Don't rearrange NCS groups here because master was just fixed! # import mmtbx.ncs.ncs_utils as nu # nu.get_list_of_best_ncs_copy_map_correlation( # ncs_groups = ncs_restraints_group_list, # xray_structure = self.model.get_xray_structure(), # map_data = target_map, # d_min = 3) print(" Minimizing... (NCS)", file=self.log) tfg_obj = mmtbx.refinement.minimization_ncs_constraints.\ target_function_and_grads_real_space( map_data = target_map, xray_structure = self.model.get_xray_structure(), ncs_restraints_group_list = ncs_restraints_group_list, refine_selection = None, real_space_gradients_delta = 1, restraints_manager = self.model.get_restraints_manager(), data_weight = self.w, refine_sites = True) minimized = mmtbx.refinement.minimization_ncs_constraints.lbfgs( target_and_grads_object = tfg_obj, xray_structure = self.model.get_xray_structure(), ncs_restraints_group_list = ncs_restraints_group_list, refine_selection = None, finite_grad_differences_test = False, max_iterations = 100, refine_sites = True) self.model.set_sites_cart(tfg_obj.xray_structure.sites_cart()) ncs_restraints_group_list.recalculate_ncs_transforms(self.model.get_sites_cart()) ms = self.model.geometry_statistics() min_monitor.save_cycle_results(geometry=ms) ms.show(log=log)