def macro_cycle(xray_structure, target_map, geometry_restraints, max_iterations=50, expload=False, n_expload=1, log=None): if (not log): if (log is None): log = sys.stdout d_min = maptbx.d_min_from_map(map_data=target_map, unit_cell=xray_structure.unit_cell()) all_selection = flex.bool(xray_structure.scatterers().size(), True) rsr_simple_refiner = individual_sites.simple( target_map=target_map, selection=all_selection, real_space_gradients_delta=d_min / 4, max_iterations=max_iterations, geometry_restraints_manager=geometry_restraints) xray_structure = shift_to_center_of_mass(xray_structure=xray_structure, target_map=target_map) cm = xray_structure.center_of_mass() sites_cart = xray_structure.sites_cart() sc = scorer(unit_cell=xray_structure.unit_cell(), sites_frac=xray_structure.sites_frac(), target_map=target_map, log=log) weights = flex.double() sampling_range = [0, 90, 180, 270] for the in sampling_range: for psi in sampling_range: for phi in sampling_range: sites_cart_new = apply_rigid_body_shift(sites_cart=sites_cart, cm=cm, x=0, y=0, z=0, the=the, psi=psi, phi=phi) xray_structure = xray_structure.replace_sites_cart( new_sites=sites_cart_new) w = run_refine(rsr_simple_refiner=rsr_simple_refiner, xray_structure=xray_structure, scorer=sc, log=log, weight=flex.mean_default(weights, 1.0)) weights.append(w) if (expload): for i in xrange(n_expload): xray_structure_ = xray_structure.deep_copy_scatterers() xray_structure_.shake_sites_in_place(mean_distance=1.0) run_refine(rsr_simple_refiner=rsr_simple_refiner, xray_structure=xray_structure_, scorer=sc, log=log) if (log): print >> log, "Final target:", sc.target return xray_structure.replace_sites_frac(new_sites=sc.sites_frac_best)
def macro_cycle( xray_structure, target_map, geometry_restraints, max_iterations = 50, expload = False, n_expload = 1, log = None): if(not log): if(log is None): log = sys.stdout d_min = maptbx.d_min_from_map( map_data = target_map, unit_cell = xray_structure.unit_cell()) all_selection = flex.bool(xray_structure.scatterers().size(),True) rsr_simple_refiner = individual_sites.simple( target_map = target_map, selection = all_selection, real_space_gradients_delta = d_min/4, max_iterations = max_iterations, geometry_restraints_manager = geometry_restraints) xray_structure = shift_to_center_of_mass(xray_structure=xray_structure, target_map=target_map) cm = xray_structure.center_of_mass() sites_cart = xray_structure.sites_cart() sc = scorer( unit_cell = xray_structure.unit_cell(), sites_frac = xray_structure.sites_frac(), target_map = target_map, log = log) weights = flex.double() sampling_range = [0, 90, 180, 270] for the in sampling_range: for psi in sampling_range: for phi in sampling_range: sites_cart_new = apply_rigid_body_shift( sites_cart=sites_cart, cm=cm, x=0,y=0,z=0, the=the, psi=psi, phi=phi) xray_structure = xray_structure.replace_sites_cart( new_sites=sites_cart_new) w = run_refine( rsr_simple_refiner = rsr_simple_refiner, xray_structure = xray_structure, scorer = sc, log = log, weight = flex.mean_default(weights, 1.0)) weights.append(w) if(expload): for i in xrange(n_expload): xray_structure_ = xray_structure.deep_copy_scatterers() xray_structure_.shake_sites_in_place(mean_distance=1.0) run_refine( rsr_simple_refiner = rsr_simple_refiner, xray_structure = xray_structure_, scorer = sc, log = log) if(log): print >> log, "Final target:", sc.target return xray_structure.replace_sites_frac(new_sites=sc.sites_frac_best)
def run(args, log=None, ccp4_map=None, return_as_miller_arrays=False, nohl=False, return_f_obs=False, space_group_number=None, out=sys.stdout): if log is None: log = out inputs = mmtbx.utils.process_command_line_args( args=args, master_params=master_params()) got_map = False if ccp4_map: got_map = True broadcast(m="Parameters:", log=log) inputs.params.show(prefix=" ", out=out) params = inputs.params.extract() if (ccp4_map is None and inputs.ccp4_map is not None): broadcast(m="Processing input CCP4 map file: %s" % inputs.ccp4_map_file_name, log=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ", out=out) got_map = True if (not got_map): raise Sorry("Map file is needed.") # m = ccp4_map if (m.space_group_number > 1): raise Sorry("Input map space group: %d. Must be P1." % m.space_group_number) broadcast(m="Input map information:", log=log) print("m.all() :", m.data.all(), file=out) print("m.focus() :", m.data.focus(), file=out) print("m.origin():", m.data.origin(), file=out) print("m.nd() :", m.data.nd(), file=out) print("m.size() :", m.data.size(), file=out) print("m.focus_size_1d():", m.data.focus_size_1d(), file=out) print("m.is_0_based() :", m.data.is_0_based(), file=out) print("map: min/max/mean:", flex.min(m.data), flex.max(m.data), flex.mean(m.data), file=out) print("unit cell:", m.unit_cell_parameters, file=out) # if not space_group_number: space_group_number = 1 if space_group_number <= 1: symmetry_flags = None else: symmetry_flags = maptbx.use_space_group_symmetry, #cs = crystal.symmetry(m.unit_cell_parameters, space_group_number) # this will not work if m.unit_cell_grid != m.data.all() # Instead use ccp4 map crystal_symmetry and classify according to the case cs = m.crystal_symmetry() if m.unit_cell_grid == m.data.all(): print("\nOne unit cell of data is present in map", file=out) else: if params.keep_origin: print("\nNOTE: This map does not have exactly one unit cell of data, so \n"+\ "keep_origin is not available\n", file=out) print( "--> Setting keep_origin=False and creating a new cell and gridding.\n", file=out) params.keep_origin = False print("Moving origin of input map to (0,0,0)", file=out) print("New cell will be: (%.3f, %.3f, %.3f, %.1f, %.1f, %.1f) A " % (cs.unit_cell().parameters()), file=out) print("New unit cell grid will be: (%s, %s, %s) " % (m.data.all()), file=out) map_data = m.data # Get origin in grid units and new position of origin in grid units original_origin = map_data.origin() print("\nInput map has origin at grid point (%s,%s,%s)" % (tuple(original_origin)), file=out) if params.output_origin_grid_units is not None: params.keep_origin = False new_origin = tuple(params.output_origin_grid_units) print("User-specified origin at grid point (%s,%s,%s)" % (tuple(params.output_origin_grid_units)), file=out) if tuple(params.output_origin_grid_units) == tuple(original_origin): print("This is the same as the input origin. No origin shift.", file=out) elif params.keep_origin: new_origin = original_origin print("Keeping origin at grid point (%s,%s,%s)" % (tuple(original_origin)), file=out) else: new_origin = ( 0, 0, 0, ) print("New origin at grid point (%s,%s,%s)" % (tuple(( 0, 0, 0, ))), file=out) # shift_cart is shift away from (0,0,0) if new_origin != ( 0, 0, 0, ): shift_cart = get_shift_cart(map_data=map_data, crystal_symmetry=cs, origin=new_origin) else: shift_cart = ( 0, 0, 0, ) map_data = maptbx.shift_origin_if_needed(map_data=map_data).map_data # generate complete set of Miller indices up to given high resolution d_min n_real = map_data.focus() crystal_gridding = maptbx.crystal_gridding( unit_cell=cs.unit_cell(), space_group_info=cs.space_group_info(), symmetry_flags=symmetry_flags, pre_determined_n_real=n_real) # d_min = params.d_min if (d_min is None and not params.box): d_min = maptbx.d_min_from_map( map_data=map_data, unit_cell=cs.unit_cell(), resolution_factor=params.resolution_factor) print("\nResolution of map coefficients using "+\ "resolution_factor of %.2f: %.1f A\n" %(params.resolution_factor,d_min), file=out) if (d_min is None): # box of reflections in |h|<N1/2, |k|<N2/2, 0<=|l|<N3/2 f_obs_cmpl = miller.structure_factor_box_from_map( map=map_data.as_double(), crystal_symmetry=cs, include_000=True) else: complete_set = miller.build_set(crystal_symmetry=cs, anomalous_flag=False, d_min=d_min) try: f_obs_cmpl = complete_set.structure_factors_from_map( map=map_data.as_double(), use_scale=True, anomalous_flag=False, use_sg=False) except Exception as e: if (str(e) == "cctbx Error: Miller index not in structure factor map."): msg = "Too high resolution requested. Try running with larger d_min." raise Sorry(msg) else: raise Sorry(str(e)) if params.scale_max is not None: f_obs_cmpl = f_obs_cmpl.apply_scaling(target_max=params.scale_max) from scitbx.matrix import col if col(shift_cart) != col(( 0, 0, 0, )): print("Output origin is at: (%.3f, %.3f, %.3f) A " % (tuple(-col(shift_cart))), file=out) f_obs_cmpl = f_obs_cmpl.translational_shift( cs.unit_cell().fractionalize(-col(shift_cart)), deg=False) else: print("Output origin is at (0.000, 0.000, 0.000) A", file=out) if nohl and return_as_miller_arrays and not return_f_obs: return f_obs_cmpl mtz_dataset = f_obs_cmpl.as_mtz_dataset(column_root_label="F") f_obs = abs(f_obs_cmpl) f_obs.set_sigmas(sigmas=flex.double(f_obs_cmpl.data().size(), 1)) if nohl and return_as_miller_arrays and return_f_obs: return f_obs mtz_dataset.add_miller_array(miller_array=f_obs, column_root_label="F-obs") mtz_dataset.add_miller_array(miller_array=f_obs.generate_r_free_flags(), column_root_label="R-free-flags") if not nohl: # convert phases into HL coefficeints broadcast(m="Convert phases into HL coefficients:", log=log) hl = get_hl(f_obs_cmpl=f_obs_cmpl, k_blur=params.k_blur, b_blur=params.b_blur) cc = get_cc(f=f_obs_cmpl, hl=hl) print("cc:", cc, file=out) if (abs(1. - cc) > 1.e-3): print( "Supplied b_blur is not good. Attempting to find optimal b_blur.", file=out) cc_best = 999. b_blur_best = params.b_blur for b_blur in range(1, 100): hl = get_hl(f_obs_cmpl=f_obs_cmpl, k_blur=params.k_blur, b_blur=b_blur) cc = get_cc(f=f_obs_cmpl, hl=hl) if (cc < cc_best): cc_best = cc b_blur_best = b_blur if (abs(1. - cc) < 1.e-3): b_blur_best = b_blur break hl = get_hl(f_obs_cmpl=f_obs_cmpl, k_blur=params.k_blur, b_blur=b_blur_best) print("cc:", get_cc(f=f_obs_cmpl, hl=hl), file=out) print("b_blur_best:", b_blur_best, file=out) mtz_dataset.add_miller_array(miller_array=hl, column_root_label="HL") else: hl = None if return_as_miller_arrays: if return_f_obs: return f_obs, hl else: return f_obs_cmpl, hl else: # write output MTZ file with all the data broadcast(m="Writing output MTZ file:", log=log) print(" file name:", params.output_file_name, file=log) mtz_object = mtz_dataset.mtz_object() mtz_object.write(file_name=params.output_file_name)
def run(args, log=None, ccp4_map=None, return_as_miller_arrays=False, nohl=False, return_f_obs=False, space_group_number=None, out=sys.stdout): if log is None: log = out inputs = mmtbx.utils.process_command_line_args( args=args, master_params=master_params()) got_map = False if ccp4_map: got_map = True broadcast(m="Parameters:", log=log) inputs.params.show(prefix=" ", out=out) params = inputs.params.extract() if (ccp4_map is None and inputs.ccp4_map is not None): broadcast(m="Processing input CCP4 map file: %s" % inputs.ccp4_map_file_name, log=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ", out=out) got_map = True if (not got_map): raise Sorry("Map file is needed.") # m = ccp4_map if (m.space_group_number > 1): raise Sorry("Input map space group: %d. Must be P1." % m.space_group_number) broadcast(m="Input map information:", log=log) print >> out, "m.all() :", m.data.all() print >> out, "m.focus() :", m.data.focus() print >> out, "m.origin():", m.data.origin() print >> out, "m.nd() :", m.data.nd() print >> out, "m.size() :", m.data.size() print >> out, "m.focus_size_1d():", m.data.focus_size_1d() print >> out, "m.is_0_based() :", m.data.is_0_based() print >> out, "map: min/max/mean:", flex.min(m.data), flex.max( m.data), flex.mean(m.data) print >> out, "unit cell:", m.unit_cell_parameters # if not space_group_number: space_group_number = 1 if space_group_number <= 1: symmetry_flags = None else: symmetry_flags = maptbx.use_space_group_symmetry, cs = crystal.symmetry(m.unit_cell_parameters, space_group_number) map_data = m.data # Get origin in grid units and new position of origin in grid units original_origin = map_data.origin() print >> out, "Input map has origin at grid point (%s,%s,%s)" % ( tuple(original_origin)) if params.output_origin_grid_units is not None: params.keep_origin = False new_origin = tuple(params.output_origin_grid_units) print >> out, "User-specified origin at grid point (%s,%s,%s)" % ( tuple(params.output_origin_grid_units)) if tuple(params.output_origin_grid_units) == tuple(original_origin): print >> out, "This is the same as the input origin. No origin shift." elif params.keep_origin: new_origin = original_origin print >> out, "Keeping origin at grid point (%s,%s,%s)" % ( tuple(original_origin)) else: new_origin = ( 0, 0, 0, ) print >> out, "New origin at grid point (%s,%s,%s)" % (tuple(( 0, 0, 0, ))) # shift_cart is shift away from (0,0,0) if new_origin != ( 0, 0, 0, ): shift_cart = get_shift_cart(map_data=map_data, crystal_symmetry=cs, origin=new_origin) else: shift_cart = ( 0, 0, 0, ) map_data = maptbx.shift_origin_if_needed(map_data=map_data).map_data # generate complete set of Miller indices up to given high resolution d_min n_real = map_data.focus() crystal_gridding = maptbx.crystal_gridding( unit_cell=cs.unit_cell(), space_group_info=cs.space_group_info(), symmetry_flags=symmetry_flags, pre_determined_n_real=n_real) # d_min = params.d_min if (d_min is None and not params.box): d_min = maptbx.d_min_from_map(map_data=map_data, unit_cell=cs.unit_cell()) if (d_min is None): # box of reflections in |h|<N1/2, |k|<N2/2, 0<=|l|<N3/2 f_obs_cmpl = miller.structure_factor_box_from_map( map=map_data.as_double(), crystal_symmetry=cs, include_000=True) else: complete_set = miller.build_set(crystal_symmetry=cs, anomalous_flag=False, d_min=d_min) try: f_obs_cmpl = complete_set.structure_factors_from_map( map=map_data.as_double(), use_scale=True, anomalous_flag=False, use_sg=False) except Exception, e: if (str(e) == "cctbx Error: Miller index not in structure factor map."): msg = "Too high resolution requested. Try running with larger d_min." raise Sorry(msg) else: raise Sorry(str(e))
def __init__(self, map_manager=None, resolution=None, buffer_radius=5, minimum_fraction_of_max=0.01): ''' Create a mask (map object) with values of 1 expanded by buffer_radius Parameters are: map_manager: source of previous mask. resolution : optional resolution of map buffer_radius: radius to expand in A minimum_fraction_of_max: smallest-sized region to expand as ratio to biggest ''' assert (map_manager is not None) if not resolution: from cctbx.maptbx import d_min_from_map resolution = d_min_from_map( map_data=map_manager.map_data(), unit_cell=map_manager.crystal_symmetry().unit_cell()) self._crystal_symmetry = map_manager.crystal_symmetry() from cctbx.maptbx.segment_and_split_map import estimate_expand_size, get_co expand_size = estimate_expand_size( crystal_symmetry=map_manager.crystal_symmetry(), map_data=map_manager.map_data(), expand_target=buffer_radius, minimum_expand_size=0, out=null_out()) if expand_size < 1: return # do nothing co, sorted_by_volume, min_b, max_b = get_co( map_data=map_manager.map_data(), threshold=0.5, wrapping=False) if len(sorted_by_volume) < 2: return # do nothing minimum_size = sorted_by_volume[1][0] * minimum_fraction_of_max s = None for v1, i1 in sorted_by_volume[1:]: if v1 < minimum_size: break bool_region_mask = co.expand_mask(id_to_expand=i1, expand_size=expand_size) if s is None: s = (bool_region_mask == True) else: s |= (bool_region_mask == True) self._mask = map_manager.deep_copy().map_data() self._mask.set_selected(s, 1) self._mask.set_selected(~s, 0) self._solvent_content = s.count(False) / s.size() # Set up map_manager with this mask self._map_manager = map_manager.customized_copy(map_data=self._mask) self._map_manager.set_is_mask(True) # Initialize soft mask self._is_soft_mask = False self._is_soft_mask_around_edges = False
def __init__(self, map_manager=None, resolution=None, molecular_mass=None, sequence=None, solvent_content=None): ''' Create a mask (map object) with values of 1 near molecule Parameters are: map_manager: source of information about density resolution : optional resolution of map molecular_mass: optional mass (Da) of object in density sequence: optional sequence of object in density solvent_content : optional solvent_content of map ''' assert (map_manager is not None) if not resolution: from cctbx.maptbx import d_min_from_map resolution = d_min_from_map( map_data=map_manager.map_data(), unit_cell=map_manager.crystal_symmetry().unit_cell()) self._crystal_symmetry = map_manager.crystal_symmetry() if (molecular_mass or sequence) and (not solvent_content): # Try to get a good starting value of solvent_content from cctbx.maptbx.segment_and_split_map import get_solvent_fraction solvent_content = get_solvent_fraction( params=None, molecular_mass=molecular_mass, sequence=sequence, do_not_adjust_dalton_scale=True, crystal_symmetry=self._crystal_symmetry, out=null_out()) # Now use automatic procedure to get a mask from cctbx.maptbx.segment_and_split_map import \ get_iterated_solvent_fraction self._mask, self._solvent_content = get_iterated_solvent_fraction( crystal_symmetry=self._crystal_symmetry, fraction_of_max_mask_threshold=0.05, # solvent_content=solvent_content, cell_cutoff_for_solvent_from_mask=1, # Use low-res method always use_solvent_content_for_threshold=True, mask_resolution=resolution, return_mask_and_solvent_fraction=True, map=map_manager.map_data(), verbose=False, out=null_out()) if self._solvent_content is None: from libtbx.utils import Sorry raise Sorry("Unable to get solvent content in auto-masking") # Set up map_manager with this mask self._map_manager = map_manager.customized_copy(map_data=self._mask) self._map_manager.set_is_mask(True) # Initialize soft mask self._is_soft_mask = False self._is_soft_mask_around_edges = False
def run(args, crystal_symmetry=None, ncs_object=None, pdb_hierarchy=None, map_data=None, lower_bounds=None, upper_bounds=None, write_output_files=True, log=None): h = "phenix.map_box: extract box with model and map around selected atoms" if (log is None): log = sys.stdout print_statistics.make_header(h, out=log) default_message = """\ %s. Usage: phenix.map_box model.pdb map_coefficients.mtz selection="chain A and resseq 1:10" or phenix.map_box map.ccp4 density_select=True Parameters:""" % h if (len(args) == 0 and not pdb_hierarchy): print default_message master_phil.show(prefix=" ") return inputs = mmtbx.utils.process_command_line_args(args=args, cmd_cs=crystal_symmetry, master_params=master_phil) params = inputs.params.extract() master_phil.format(python_object=params).show(out=log) # Overwrite params with parameters in call if available if lower_bounds: params.lower_bounds = lower_bounds if upper_bounds: params.upper_bounds = upper_bounds # PDB file if params.pdb_file and not inputs.pdb_file_names and not pdb_hierarchy: inputs.pdb_file_names = [params.pdb_file] if (len(inputs.pdb_file_names) != 1 and not params.density_select and not pdb_hierarchy and not params.keep_map_size and not params.upper_bounds and not params.extract_unique): raise Sorry("PDB file is needed unless extract_unique, " + "density_select, keep_map_size \nor bounds are set .") if (len(inputs.pdb_file_names)!=1 and not pdb_hierarchy and \ (params.mask_atoms or params.soft_mask )): raise Sorry("PDB file is needed for mask_atoms or soft_mask") if (params.density_select and params.keep_map_size): raise Sorry("Cannot set both density_select and keep_map_size") if (params.density_select and params.upper_bounds): raise Sorry("Cannot set both density_select and bounds") if (params.keep_map_size and params.upper_bounds): raise Sorry("Cannot set both keep_map_size and bounds") if (params.upper_bounds and not params.lower_bounds): raise Sorry("Please set lower_bounds if you set upper_bounds") if (params.extract_unique and not params.resolution): raise Sorry("Please set resolution for extract_unique") print_statistics.make_sub_header("pdb model", out=log) if len(inputs.pdb_file_names) > 0: pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0]) pdb_hierarchy = pdb_inp.construct_hierarchy() if pdb_hierarchy: pdb_atoms = pdb_hierarchy.atoms() pdb_atoms.reset_i_seq() else: pdb_hierarchy = None # Map or map coefficients map_coeff = None if (not map_data): # read first mtz file if ((len(inputs.reflection_file_names) > 0) or (params.map_coefficients_file is not None)): # file in phil takes precedent if (params.map_coefficients_file is not None): if (len(inputs.reflection_file_names) == 0): inputs.reflection_file_names.append( params.map_coefficients_file) else: inputs.reflection_file_names[ 0] = params.map_coefficients_file map_coeff = reflection_file_utils.extract_miller_array_from_file( file_name=inputs.reflection_file_names[0], label=params.label, type="complex", log=log) if not crystal_symmetry: crystal_symmetry = map_coeff.crystal_symmetry() fft_map = map_coeff.fft_map( resolution_factor=params.resolution_factor) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() map_or_map_coeffs_prefix = os.path.basename( inputs.reflection_file_names[0][:-4]) # or read CCP4 map elif ((inputs.ccp4_map is not None) or (params.ccp4_map_file is not None)): if (params.ccp4_map_file is not None): af = any_file(params.ccp4_map_file) if (af.file_type == 'ccp4_map'): inputs.ccp4_map = af.file_content inputs.ccp4_map_file_name = params.ccp4_map_file print_statistics.make_sub_header("CCP4 map", out=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ", out=log) if not crystal_symmetry: crystal_symmetry = ccp4_map.crystal_symmetry() map_data = ccp4_map.data #map_data() if inputs.ccp4_map_file_name.endswith(".ccp4"): map_or_map_coeffs_prefix = os.path.basename( inputs.ccp4_map_file_name[:-5]) else: map_or_map_coeffs_prefix = os.path.basename( inputs.ccp4_map_file_name[:-4]) else: # have map_data map_or_map_coeffs_prefix = None if crystal_symmetry and not inputs.crystal_symmetry: inputs.crystal_symmetry = crystal_symmetry # final check that map_data exists if (map_data is None): raise Sorry("Map or map coefficients file is needed.") if len(inputs.pdb_file_names) > 0: output_prefix = os.path.basename(inputs.pdb_file_names[0])[:-4] else: output_prefix = map_or_map_coeffs_prefix if not pdb_hierarchy: # get an empty hierarchy from cctbx.array_family import flex pdb_hierarchy = iotbx.pdb.input( source_info='', lines=flex.split_lines('')).construct_hierarchy() xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry=inputs.crystal_symmetry) xray_structure.show_summary(f=log) # selection = pdb_hierarchy.atom_selection_cache().selection( string=params.selection) if selection.size(): print_statistics.make_sub_header("atom selection", out=log) print >> log, "Selection string: selection='%s'" % params.selection print >> log, \ " selects %d atoms from total %d atoms."%(selection.count(True), selection.size()) sites_cart_all = xray_structure.sites_cart() sites_cart = sites_cart_all.select(selection) selection = xray_structure.selection_within(radius=params.selection_radius, selection=selection) if not ncs_object: from mmtbx.ncs.ncs import ncs ncs_object = ncs() if params.symmetry_file: ncs_object.read_ncs(params.symmetry_file, log=log) print >> log, "Total of %s operators read" % ( ncs_object.max_operators()) if not ncs_object or ncs_object.max_operators() < 1: print >> log, "No symmetry available" if ncs_object: n_ops = max(1, ncs_object.max_operators()) else: n_ops = 1 # Get sequence if extract_unique is set sequence = None if params.extract_unique: if params.sequence_file: if n_ops > 1: # get unique part of sequence and multiply remove_duplicates = True else: remove_duplicates = False from iotbx.bioinformatics import get_sequences sequence = n_ops * (" ".join( get_sequences(file_name=params.sequence_file, remove_duplicates=remove_duplicates))) if sequence and not params.molecular_mass: # get molecular mass from sequence from iotbx.bioinformatics import text_from_chains_matching_chain_type if params.chain_type in [None, 'PROTEIN']: n_protein = len( text_from_chains_matching_chain_type(text=sequence, chain_type='PROTEIN')) else: n_protein = 0 if params.chain_type in [None, 'RNA']: n_rna = len( text_from_chains_matching_chain_type(text=sequence, chain_type='RNA')) else: n_rna = 0 if params.chain_type in [None, 'DNA']: n_dna = len( text_from_chains_matching_chain_type(text=sequence, chain_type='DNA')) else: n_dna = 0 params.molecular_mass = n_protein * 110 + (n_rna + n_dna) * 330 elif not params.molecular_mass: raise Sorry( "Need a sequence file or molecular mass for extract_unique") else: molecular_mass = None # if params.density_select: print_statistics.make_sub_header( "Extracting box around selected density and writing output files", out=log) else: print_statistics.make_sub_header( "Extracting box around selected atoms and writing output files", out=log) # if params.value_outside_atoms == 'mean': print >> log, "\nValue outside atoms mask will be set to mean inside mask" if params.get_half_height_width and params.density_select: print >> log, "\nHalf width at half height will be used to id boundaries" if params.soft_mask and sites_cart_all.size() > 0: print >> log, "\nSoft mask will be applied to model-based mask" if params.keep_map_size: print >> log, "\nEntire map will be kept (not cutting out region)" if params.restrict_map_size: print >> log, "\nOutput map will be within input map" if params.lower_bounds and params.upper_bounds: print >> log, "Bounds for cut out map are (%s,%s,%s) to (%s,%s,%s)" % ( tuple(list(params.lower_bounds) + list(params.upper_bounds))) box = mmtbx.utils.extract_box_around_model_and_map( xray_structure=xray_structure, map_data=map_data.as_double(), box_cushion=params.box_cushion, selection=selection, density_select=params.density_select, threshold=params.density_select_threshold, get_half_height_width=params.get_half_height_width, mask_atoms=params.mask_atoms, soft_mask=params.soft_mask, soft_mask_radius=params.soft_mask_radius, mask_atoms_atom_radius=params.mask_atoms_atom_radius, value_outside_atoms=params.value_outside_atoms, keep_map_size=params.keep_map_size, restrict_map_size=params.restrict_map_size, lower_bounds=params.lower_bounds, upper_bounds=params.upper_bounds, extract_unique=params.extract_unique, chain_type=params.chain_type, sequence=sequence, solvent_content=params.solvent_content, molecular_mass=params.molecular_mass, resolution=params.resolution, ncs_object=ncs_object, symmetry=params.symmetry, ) ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) box.hierarchy = ph_box if (inputs and inputs.crystal_symmetry and inputs.ccp4_map and inputs.crystal_symmetry.unit_cell().parameters() and inputs.ccp4_map.unit_cell_parameters) and ( inputs.crystal_symmetry.unit_cell().parameters() != inputs.ccp4_map.unit_cell_parameters): print >> log, "\nNOTE: Mismatch of unit cell parameters from CCP4 map:" print >>log,"Unit cell from CCP4 map 'unit cell parameters': "+\ "%.1f, %.1f, %.1f, %.1f, %.1f, %.1f)" %tuple( inputs.ccp4_map.unit_cell_parameters) print >>log,"Unit cell from CCP4 map 'map grid': "+\ "%.1f, %.1f, %.1f, %.1f, %.1f, %.1f)" %tuple( inputs.crystal_symmetry.unit_cell().parameters()) print >>log,"\nInterpreting this as the 'unit cell parameters' was "+\ "original map \ndimension and 'map grid' is the "+\ "portion actually in the map that was supplied here.\n" box.unit_cell_parameters_from_ccp4_map = inputs.ccp4_map.unit_cell_parameters box.unit_cell_parameters_deduced_from_map_grid=\ inputs.crystal_symmetry.unit_cell().parameters() else: box.unit_cell_parameters_from_ccp4_map = None box.unit_cell_parameters_deduced_from_map_grid = None # ncs_object is original # box.ncs_object is shifted by shift_cart print >> log, "Box cell dimensions: (%.2f, %.2f, %.2f) A" % ( box.box_crystal_symmetry.unit_cell().parameters()[:3]) if params.keep_origin: print >> log, "Box origin is at grid position of : (%d, %d, %d) " % ( tuple(box.origin_shift_grid_units(reverse=True))) print >> log, "Box origin is at coordinates: (%.2f, %.2f, %.2f) A" % ( tuple(-col(box.shift_cart))) if box.pdb_outside_box_msg: print >> log, box.pdb_outside_box_msg # NOTE: box object is always shifted to place origin at (0,0,0) # For output files ONLY: # keep_origin==False leave origin at (0,0,0) # keep_origin==True: we shift everything back to where it was, if (not params.keep_origin): if box.shift_cart: print >>log,\ "Final coordinate shift for output files: (%.2f,%.2f,%.2f) A" %( tuple(box.shift_cart)) else: print >>log,"\nOutput files are in same location as original: origin "+\ "is at (0,0,0)" else: # keep_origin print >> log, "\nOutput files are in same location as original, just cut out." print >> log, "Note that output maps are only valid in the cut out region.\n" if params.keep_origin: ph_box_original_location = ph_box.deep_copy() sites_cart = box.shift_sites_cart_back( box.xray_structure_box.sites_cart()) xrs_offset = ph_box_original_location.extract_xray_structure( crystal_symmetry=box.xray_structure_box.crystal_symmetry( )).replace_sites_cart(new_sites=sites_cart) ph_box_original_location.adopt_xray_structure(xrs_offset) box.hierarchy_original_location = ph_box_original_location else: box.hierarchy_original_location = None if write_output_files: # Write PDB file if ph_box.overall_counts().n_residues > 0: if (params.output_file_name_prefix is None): file_name = "%s_box.pdb" % output_prefix else: file_name = "%s.pdb" % params.output_file_name_prefix if params.keep_origin: # Keeping origin print >> log, "Writing boxed PDB with box unit cell and in "+\ "original\n position to: %s"%( file_name) ph_box_original_location.write_pdb_file( file_name=file_name, crystal_symmetry=box.xray_structure_box.crystal_symmetry()) else: # write box PDB in box cell print >> log, "Writing shifted boxed PDB to file: %s" % file_name ph_box.write_pdb_file( file_name=file_name, crystal_symmetry=box.xray_structure_box.crystal_symmetry()) # Write NCS file if NCS if ncs_object and ncs_object.max_operators() > 0: if (params.output_file_name_prefix is None): output_symmetry_file = "%s_box.ncs_spec" % output_prefix else: output_symmetry_file = "%s.ncs_spec" % params.output_file_name_prefix if params.keep_origin: if params.symmetry_file: print >> log, "\nDuplicating symmetry in %s and writing to %s" % ( params.symmetry_file, output_symmetry_file) else: print >> log, "\nWriting symmetry to %s" % ( output_symmetry_file) ncs_object.format_all_for_group_specification( file_name=output_symmetry_file) else: print >> log, "\nOffsetting symmetry in %s and writing to %s" % ( params.symmetry_file, output_symmetry_file) box.ncs_object.format_all_for_group_specification( file_name=output_symmetry_file) # Write ccp4 map. Shift back to original location if keep_origin=True if ("ccp4" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.ccp4" % output_prefix else: file_name = "%s.ccp4" % params.output_file_name_prefix if params.keep_origin: print >> log, "Writing boxed map with box unit_cell and "+\ "original\n position to CCP4 formatted file: %s"%file_name else: print >> log, "Writing box map shifted to (0,0,0) to CCP4 "+\ "formatted file: %s"%file_name box.write_ccp4_map(file_name=file_name, shift_back=params.keep_origin) # Write xplor map. Shift back if keep_origin=True if ("xplor" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.xplor" % output_prefix else: file_name = "%s.xplor" % params.output_file_name_prefix if params.keep_origin: print >> log, "Writing boxed map with box unit_cell and original "+\ "position\n to X-plor formatted file: %s"%file_name else: print >> log, "Writing box_map shifted to (0,0,0) to X-plor "+\ "formatted file: %s"%file_name box.write_xplor_map(file_name=file_name, shift_back=params.keep_origin) # Write mtz map coeffs. Shift back if keep_origin=True if ("mtz" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.mtz" % output_prefix else: file_name = "%s.mtz" % params.output_file_name_prefix if params.keep_origin: print >> log, "Writing map coefficients with box_map unit_cell"+\ " but position matching\n "+\ " original position to MTZ file: %s"%file_name else: print >> log, "Writing box_map coefficients shifted to (0,0,0) "+\ "to MTZ file: %s"%file_name if (map_coeff is not None): d_min = map_coeff.d_min() elif params.resolution is not None: d_min = params.resolution else: d_min = maptbx.d_min_from_map( map_data=box.map_box, unit_cell=box.xray_structure_box.unit_cell()) box.map_coefficients(d_min=d_min, resolution_factor=params.resolution_factor, file_name=file_name, shift_back=params.keep_origin) print >> log return box
def run(args, crystal_symmetry=None, ncs_object=None, pdb_hierarchy=None, map_data=None, lower_bounds=None, upper_bounds=None, write_output_files=True, log=None): h = "phenix.map_box: extract box with model and map around selected atoms" if(log is None): log = sys.stdout print_statistics.make_header(h, out=log) default_message="""\ %s. Usage: phenix.map_box model.pdb map_coefficients.mtz selection="chain A and resseq 1:10" or phenix.map_box map.ccp4 density_select=True Parameters:"""%h if(len(args) == 0 and not pdb_hierarchy): print default_message master_phil.show(prefix=" ") return inputs = mmtbx.utils.process_command_line_args(args = args, cmd_cs=crystal_symmetry, master_params = master_phil) params = inputs.params.extract() master_phil.format(python_object=params).show(out=log) # Overwrite params with parameters in call if available if lower_bounds: params.lower_bounds=lower_bounds if upper_bounds: params.upper_bounds=upper_bounds # PDB file if params.pdb_file and not inputs.pdb_file_names and not pdb_hierarchy: inputs.pdb_file_names=[params.pdb_file] if(len(inputs.pdb_file_names)!=1 and not params.density_select and not pdb_hierarchy and not params.keep_map_size and not params.upper_bounds and not params.extract_unique): raise Sorry("PDB file is needed unless extract_unique, "+ "density_select, keep_map_size \nor bounds are set .") if (len(inputs.pdb_file_names)!=1 and not pdb_hierarchy and \ (params.mask_atoms or params.soft_mask )): raise Sorry("PDB file is needed for mask_atoms or soft_mask") if (params.density_select and params.keep_map_size): raise Sorry("Cannot set both density_select and keep_map_size") if (params.density_select and params.upper_bounds): raise Sorry("Cannot set both density_select and bounds") if (params.keep_map_size and params.upper_bounds): raise Sorry("Cannot set both keep_map_size and bounds") if (params.upper_bounds and not params.lower_bounds): raise Sorry("Please set lower_bounds if you set upper_bounds") if (params.extract_unique and not params.resolution): raise Sorry("Please set resolution for extract_unique") if (write_output_files) and ("mtz" in params.output_format) and ( (params.keep_origin) and (not params.keep_map_size)): raise Sorry("Please set output_format=ccp4 to skip mtz or set "+\ "keep_origin=False or keep_map_size=True") if params.keep_input_unit_cell_and_grid and ( (params.output_unit_cell_grid is not None ) or (params.output_unit_cell is not None ) ): raise Sorry("If you set keep_input_unit_cell_and_grid then you cannot "+\ "set \noutput_unit_cell_grid or output_unit_cell") if params.output_origin_grid_units is not None and params.keep_origin: params.keep_origin=False print "Setting keep_origin=False as output_origin_grid_units is set" print_statistics.make_sub_header("pdb model", out=log) if len(inputs.pdb_file_names)>0: pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0]) pdb_hierarchy = pdb_inp.construct_hierarchy() if pdb_hierarchy: pdb_atoms = pdb_hierarchy.atoms() pdb_atoms.reset_i_seq() else: pdb_hierarchy=None # Map or map coefficients map_coeff = None input_unit_cell_grid=None input_unit_cell=None if (not map_data): # read first mtz file if ( (len(inputs.reflection_file_names) > 0) or (params.map_coefficients_file is not None) ): # file in phil takes precedent if (params.map_coefficients_file is not None): if (len(inputs.reflection_file_names) == 0): inputs.reflection_file_names.append(params.map_coefficients_file) else: inputs.reflection_file_names[0] = params.map_coefficients_file map_coeff = reflection_file_utils.extract_miller_array_from_file( file_name = inputs.reflection_file_names[0], label = params.label, type = "complex", log = log) if not crystal_symmetry: crystal_symmetry=map_coeff.crystal_symmetry() fft_map = map_coeff.fft_map(resolution_factor=params.resolution_factor) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() map_or_map_coeffs_prefix=os.path.basename( inputs.reflection_file_names[0][:-4]) # or read CCP4 map elif ( (inputs.ccp4_map is not None) or (params.ccp4_map_file is not None) ): if (params.ccp4_map_file is not None): af = any_file(params.ccp4_map_file) if (af.file_type == 'ccp4_map'): inputs.ccp4_map = af.file_content inputs.ccp4_map_file_name = params.ccp4_map_file print_statistics.make_sub_header("CCP4 map", out=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ",out=log) if not crystal_symmetry: crystal_symmetry=ccp4_map.crystal_symmetry() map_data = ccp4_map.data #map_data() input_unit_cell_grid=ccp4_map.unit_cell_grid input_unit_cell=ccp4_map.unit_cell_parameters if inputs.ccp4_map_file_name.endswith(".ccp4"): map_or_map_coeffs_prefix=os.path.basename( inputs.ccp4_map_file_name[:-5]) else: map_or_map_coeffs_prefix=os.path.basename( inputs.ccp4_map_file_name[:-4]) else: # have map_data map_or_map_coeffs_prefix=None if params.output_origin_grid_units is not None: origin_to_match=tuple(params.output_origin_grid_units) else: origin_to_match=None if origin_to_match: sc=[] for x,o,a in zip(crystal_symmetry.unit_cell().parameters()[:3], origin_to_match, map_data.all()): sc.append(-x*o/a) shift_cart_for_origin_to_match=tuple(sc) else: origin_to_match=None shift_cart_for_origin_to_match=None if crystal_symmetry and not inputs.crystal_symmetry: inputs.crystal_symmetry=crystal_symmetry # final check that map_data exists if(map_data is None): raise Sorry("Map or map coefficients file is needed.") if len(inputs.pdb_file_names)>0: output_prefix=os.path.basename(inputs.pdb_file_names[0])[:-4] else: output_prefix=map_or_map_coeffs_prefix if not pdb_hierarchy: # get an empty hierarchy from cctbx.array_family import flex pdb_hierarchy=iotbx.pdb.input( source_info='',lines=flex.split_lines('')).construct_hierarchy() xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry=inputs.crystal_symmetry) xray_structure.show_summary(f=log) # selection = pdb_hierarchy.atom_selection_cache().selection( string = params.selection) if selection.size(): print_statistics.make_sub_header("atom selection", out=log) print >> log, "Selection string: selection='%s'"%params.selection print >> log, \ " selects %d atoms from total %d atoms."%(selection.count(True), selection.size()) sites_cart_all = xray_structure.sites_cart() sites_cart = sites_cart_all.select(selection) selection = xray_structure.selection_within( radius = params.selection_radius, selection = selection) if not ncs_object: from mmtbx.ncs.ncs import ncs ncs_object=ncs() if params.symmetry_file: ncs_object.read_ncs(params.symmetry_file,log=log) print >>log,"Total of %s operators read" %(ncs_object.max_operators()) if not ncs_object or ncs_object.max_operators()<1: print >>log,"No symmetry available" if ncs_object: n_ops=max(1,ncs_object.max_operators()) else: n_ops=1 # Get sequence if extract_unique is set sequence=None if params.extract_unique: if params.sequence_file: if n_ops > 1: # get unique part of sequence and multiply remove_duplicates=True else: remove_duplicates=False from iotbx.bioinformatics import get_sequences sequence=n_ops * (" ".join(get_sequences(file_name=params.sequence_file, remove_duplicates=remove_duplicates))) if sequence and not params.molecular_mass: # get molecular mass from sequence from iotbx.bioinformatics import text_from_chains_matching_chain_type if params.chain_type in [None,'PROTEIN']: n_protein=len(text_from_chains_matching_chain_type( text=sequence,chain_type='PROTEIN')) else: n_protein=0 if params.chain_type in [None,'RNA']: n_rna=len(text_from_chains_matching_chain_type( text=sequence,chain_type='RNA')) else: n_rna=0 if params.chain_type in [None,'DNA']: n_dna=len(text_from_chains_matching_chain_type( text=sequence,chain_type='DNA')) else: n_dna=0 params.molecular_mass=n_protein*110+(n_rna+n_dna)*330 elif not params.molecular_mass: raise Sorry("Need a sequence file or molecular mass for extract_unique") else: molecular_mass=None # if params.density_select: print_statistics.make_sub_header( "Extracting box around selected density and writing output files", out=log) else: print_statistics.make_sub_header( "Extracting box around selected atoms and writing output files", out=log) # if params.value_outside_atoms=='mean': print >>log,"\nValue outside atoms mask will be set to mean inside mask" if params.get_half_height_width and params.density_select: print >>log,"\nHalf width at half height will be used to id boundaries" if params.soft_mask and sites_cart_all.size()>0: print >>log,"\nSoft mask will be applied to model-based mask" if params.keep_map_size: print >>log,"\nEntire map will be kept (not cutting out region)" if params.restrict_map_size: print >>log,"\nOutput map will be within input map" if params.lower_bounds and params.upper_bounds: print >>log,"Bounds for cut out map are (%s,%s,%s) to (%s,%s,%s)" %( tuple(list(params.lower_bounds)+list(params.upper_bounds))) box = mmtbx.utils.extract_box_around_model_and_map( xray_structure = xray_structure, map_data = map_data.as_double(), box_cushion = params.box_cushion, selection = selection, density_select = params.density_select, threshold = params.density_select_threshold, get_half_height_width = params.get_half_height_width, mask_atoms = params.mask_atoms, soft_mask = params.soft_mask, soft_mask_radius = params.soft_mask_radius, mask_atoms_atom_radius = params.mask_atoms_atom_radius, value_outside_atoms = params.value_outside_atoms, keep_map_size = params.keep_map_size, restrict_map_size = params.restrict_map_size, lower_bounds = params.lower_bounds, upper_bounds = params.upper_bounds, extract_unique = params.extract_unique, chain_type = params.chain_type, sequence = sequence, solvent_content = params.solvent_content, molecular_mass = params.molecular_mass, resolution = params.resolution, ncs_object = ncs_object, symmetry = params.symmetry, ) ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) box.hierarchy=ph_box if (inputs and # XXX fix or remove this inputs.crystal_symmetry and inputs.ccp4_map and inputs.crystal_symmetry.unit_cell().parameters() and inputs.ccp4_map.unit_cell_parameters ) and ( inputs.crystal_symmetry.unit_cell().parameters() != inputs.ccp4_map.unit_cell_parameters): print >>log,"\nNOTE: Mismatch of unit cell parameters from CCP4 map:" print >>log,"Unit cell from CCP4 map 'unit cell parameters': "+\ "%.1f, %.1f, %.1f, %.1f, %.1f, %.1f)" %tuple( inputs.ccp4_map.unit_cell_parameters) print >>log,"Unit cell from CCP4 map 'map grid': "+\ "%.1f, %.1f, %.1f, %.1f, %.1f, %.1f)" %tuple( inputs.crystal_symmetry.unit_cell().parameters()) print >>log,"\nInterpreting this as the 'unit cell parameters' was "+\ "original map \ndimension and 'map grid' is the "+\ "portion actually in the map that was supplied here.\n" box.unit_cell_parameters_from_ccp4_map=inputs.ccp4_map.unit_cell_parameters box.unit_cell_parameters_deduced_from_map_grid=\ inputs.crystal_symmetry.unit_cell().parameters() else: box.unit_cell_parameters_from_ccp4_map=None box.unit_cell_parameters_deduced_from_map_grid=None if box.pdb_outside_box_msg: print >> log, box.pdb_outside_box_msg # NOTE: box object is always shifted to place origin at (0,0,0) # NOTE ON ORIGIN SHIFTS: The shifts are applied locally here. The box # object is not affected and always has the origin at (0,0,0) # output_box is copy of box with shift_cart corresponding to the output # files. Normally this is the same as the original shift_cart. However # if user has specified a new output origin it will differ. # For output files ONLY: # keep_origin==False leave origin at (0,0,0) # keep_origin==True: we shift everything back to where it was, # output_origin_grid_units=10,10,10: output origin is at (10,10,10) # ncs_object is original # box.ncs_object is shifted by shift_cart # output_box.ncs_object is shifted back by -new shift_cart # Additional note on output unit_cell and grid_units. # The ccp4-style output map can specify the unit cell and grid units # corresponding to that cell. This can be separate from the origin and # number of grid points in the map as written. If specified, write these # out to the output ccp4 map and also use this unit cell for writing # any output PDB files from copy import deepcopy output_box=deepcopy(box) # won't use box below here except to return it print >>log,"\nBox cell dimensions: (%.2f, %.2f, %.2f) A" %( box.box_crystal_symmetry.unit_cell().parameters()[:3]) if box.shift_cart: print>>log,"Working origin moved from grid position of"+\ ": (%d, %d, %d) to (0,0,0) " %( tuple(box.origin_shift_grid_units(reverse=True))) print>>log,"Working origin moved from coordinates of:"+\ " (%.2f, %.2f, %.2f) A to (0,0,0)\n" %( tuple(-col(box.shift_cart))) if (params.keep_origin): print >>log,"\nRestoring original position for output files" print >>log,"Origin will be at grid position of"+\ ": (%d, %d, %d) " %( tuple(box.origin_shift_grid_units(reverse=True))) print >>log,\ "\nOutput files will be in same location as original", if not params.keep_map_size: print >>log,"just cut out." else: print >>log,"keeping entire map" print >>log,"Note that output maps are only valid in the cut out region.\n" else: if origin_to_match: output_box.shift_cart=shift_cart_for_origin_to_match if params.output_origin_grid_units: print >>log,"Output map origin to be shifted to match target" print >>log, "Placing origin at grid point (%s, %s, %s)" %( origin_to_match)+"\n"+ \ "Final coordinate shift for output files: (%.2f,%.2f,%.2f) A\n" %( tuple(col(output_box.shift_cart)-col(box.shift_cart))) elif box.shift_cart: output_box.shift_cart=(0,0,0) # not shifting back print >>log,"Final origin will be at (0,0,0)" print >>log,\ "Final coordinate shift for output files: (%.2f,%.2f,%.2f) A\n" %( tuple(col(output_box.shift_cart)-col(box.shift_cart))) else: print >>log,\ "\nOutput files are in same location as original and origin "+\ "is at (0,0,0)\n" ph_output_box_output_location = ph_box.deep_copy() if output_box.shift_cart: # shift coordinates and NCS back by shift_cart # NOTE output_box.shift_cart could be different than box.shift_cart if # there is a target position for the origin and it is not the same as the # original origin. sites_cart = output_box.shift_sites_cart_back( output_box.xray_structure_box.sites_cart()) xrs_offset = ph_output_box_output_location.extract_xray_structure( crystal_symmetry=output_box.xray_structure_box.crystal_symmetry() ).replace_sites_cart(new_sites = sites_cart) ph_output_box_output_location.adopt_xray_structure(xrs_offset) if output_box.ncs_object: output_box.ncs_object=output_box.ncs_object.coordinate_offset( tuple(-col(output_box.shift_cart))) shift_back=True else: shift_back=False if params.keep_input_unit_cell_and_grid and \ (input_unit_cell_grid is not None) and \ (input_unit_cell is not None): params.output_unit_cell=input_unit_cell params.output_unit_cell_grid=input_unit_cell_grid print >>log,"Setting output unit cell parameters and unit cell grid to"+\ " match\ninput map file" if params.output_unit_cell: # Set output unit cell parameters from cctbx import crystal output_crystal_symmetry=crystal.symmetry( unit_cell=params.output_unit_cell, space_group="P1") output_unit_cell=output_crystal_symmetry.unit_cell() print >>log,\ "Output unit cell set to: %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)" %tuple( output_crystal_symmetry.unit_cell().parameters()) else: output_crystal_symmetry=None # ============= Check/set output unit cell grid and cell parameters ======= if params.output_unit_cell_grid or output_crystal_symmetry: if params.output_unit_cell_grid: output_unit_cell_grid=params.output_unit_cell_grid else: output_unit_cell_grid=output_box.map_box.all() print >>log,\ "Output unit cell grid set to: (%s, %s, %s)" %tuple( output_unit_cell_grid) expected_output_abc=[] box_spacing=[] output_spacing=[] box_abc=output_box.xray_structure_box.\ crystal_symmetry().unit_cell().parameters()[:3] if output_crystal_symmetry: output_abc=output_crystal_symmetry.unit_cell().parameters()[:3] else: output_abc=[None,None,None] for a_box,a_output,n_box,n_output in zip( box_abc, output_abc, output_box.map_box.all(), output_unit_cell_grid): expected_output_abc.append(a_box*n_output/n_box) box_spacing.append(a_box/n_box) if output_crystal_symmetry: output_spacing.append(a_output/n_output) else: output_spacing.append(a_box/n_box) if output_crystal_symmetry: # make sure it is compatible... r0=expected_output_abc[0]/output_abc[0] r1=expected_output_abc[1]/output_abc[1] r2=expected_output_abc[2]/output_abc[2] from libtbx.test_utils import approx_equal if not approx_equal(r0,r1,eps=0.001) or not approx_equal(r0,r2,eps=0.001): print >>log,"WARNING: output_unit_cell and cell_grid will "+\ "change ratio of grid spacing.\nOld spacings: "+\ "(%.2f, %.2f, %.2f) A " %(tuple(box_spacing))+\ "\nNew spacings: (%.2f, %.2f, %.2f) A \n" %(tuple(output_spacing)) else: output_abc=expected_output_abc from cctbx import crystal output_crystal_symmetry=crystal.symmetry( unit_cell=list(output_abc)+[90,90,90], space_group="P1") print >>log, \ "Output unit cell will be: (%.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n"%( tuple(output_crystal_symmetry.unit_cell().parameters())) else: output_unit_cell_grid = map_data=output_box.map_box.all() output_crystal_symmetry=output_box.xray_structure_box.crystal_symmetry() # ========== Done check/set output unit cell grid and cell parameters ===== if write_output_files: # Write PDB file if ph_box.overall_counts().n_residues>0: if(params.output_file_name_prefix is None): file_name = "%s_box.pdb"%output_prefix else: file_name = "%s.pdb"%params.output_file_name_prefix ph_output_box_output_location.write_pdb_file(file_name=file_name, crystal_symmetry = output_crystal_symmetry) print >> log, "Writing boxed PDB with box unit cell to %s" %( file_name) # Write NCS file if NCS if output_box.ncs_object and output_box.ncs_object.max_operators()>0: if(params.output_file_name_prefix is None): output_symmetry_file = "%s_box.ncs_spec"%output_prefix else: output_symmetry_file = "%s.ncs_spec"%params.output_file_name_prefix output_box.ncs_object.format_all_for_group_specification( file_name=output_symmetry_file) print >>log,"\nWriting symmetry to %s" %( output_symmetry_file) # Write ccp4 map. if("ccp4" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.ccp4"%output_prefix else: file_name = "%s.ccp4"%params.output_file_name_prefix output_box.write_ccp4_map(file_name=file_name, output_crystal_symmetry=output_crystal_symmetry, output_unit_cell_grid=output_unit_cell_grid, shift_back=shift_back) print >> log, "Writing boxed map "+\ "to CCP4 formatted file: %s"%file_name # Write xplor map. Shift back if keep_origin=True if("xplor" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.xplor"%output_prefix else: file_name = "%s.xplor"%params.output_file_name_prefix output_box.write_xplor_map(file_name=file_name, output_crystal_symmetry=output_crystal_symmetry, output_unit_cell_grid=output_unit_cell_grid, shift_back=shift_back,) print >> log, "Writing boxed map "+\ "to X-plor formatted file: %s"%file_name # Write mtz map coeffs. Shift back if keep_origin=True if("mtz" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.mtz"%output_prefix else: file_name = "%s.mtz"%params.output_file_name_prefix print >> log, "Writing map coefficients "+\ "to MTZ file: %s"%file_name if(map_coeff is not None): d_min = map_coeff.d_min() elif params.resolution is not None: d_min = params.resolution else: d_min = maptbx.d_min_from_map(map_data=output_box.map_box, unit_cell=output_box.xray_structure_box.unit_cell()) output_box.map_coefficients(d_min=d_min, resolution_factor=params.resolution_factor, file_name=file_name, shift_back=shift_back) print >> log return box
def calculate_inverse_fft(map_data=None, crystal_symmetry=None, d_min=None, box=False, resolution_factor=0.333, out=sys.stdout): ''' Combines two possible methods of generating the complete set of indices. Box means supply all possible reflections that can be calculated using the gridding in map_data in the FFT. Otherwise, generate Miller indices inside a sphere of resolution. This may be faster if the box is large and most indices in the box are not going to be used. If box=True, supply full box of reflections (all possible) Otherwise, generate complete set of Miller indices up to given high resolution d_min. If d_min not specified, use minimum resolution allowed with gridding available and requested resolution_factor (1/2 is finest available, 1/3 is typical) ''' n_real = map_data.focus() # Choose d_min and make sure it is bigger than smallest allowed if (d_min is None and not box): d_min = maptbx.d_min_from_map(map_data=map_data, unit_cell=crystal_symmetry.unit_cell(), resolution_factor=resolution_factor) print("\nResolution of map coefficients using "+\ "resolution_factor of %.2f: %.1f A\n" %(resolution_factor,d_min), file=out) elif (not box): # make sure d_min is big enough d_min_allowed = maptbx.d_min_from_map( map_data=map_data, unit_cell=crystal_symmetry.unit_cell(), resolution_factor=0.5) if d_min < d_min_allowed: print( "\nResolution of map coefficients allowed by gridding is %.3f " % (d_min_allowed), file=out) d_min = d_min_allowed if (d_min is None): # box of reflections in |h|<N1/2, |k|<N2/2, 0<=|l|<N3/2 f_obs_cmpl = miller.structure_factor_box_from_map( map=map_data.as_double(), crystal_symmetry=crystal_symmetry, include_000=True) else: complete_set = miller.build_set(crystal_symmetry=crystal_symmetry, anomalous_flag=False, d_min=d_min) try: f_obs_cmpl = complete_set.structure_factors_from_map( map=map_data.as_double(), use_scale=True, anomalous_flag=False, use_sg=False) except Exception as e: if (str(e) == "cctbx Error: Miller index not in structure factor map."): msg = "Too high resolution requested. Try running with larger d_min." raise Sorry(msg) else: raise Sorry(str(e)) return f_obs_cmpl
def run(args, crystal_symmetry=None, log=None): h = "phenix.map_box: extract box with model and map around selected atoms" if(log is None): log = sys.stdout print_statistics.make_header(h, out=log) default_message="""\ %s. Usage: phenix.map_box model.pdb map_coefficients.mtz selection="chain A and resseq 1:10" or phenix.map_box map.ccp4 density_select=True Parameters:"""%h if(len(args) == 0): print default_message master_phil.show(prefix=" ") return inputs = mmtbx.utils.process_command_line_args(args = args, cmd_cs=crystal_symmetry, master_params = master_phil) params = inputs.params.extract() # PDB file if params.pdb_file and not inputs.pdb_file_names: inputs.pdb_file_names=[params.pdb_file] if(len(inputs.pdb_file_names)!=1 and not params.density_select): raise Sorry("PDB file is needed unless density_select is set.") print_statistics.make_sub_header("pdb model", out=log) if len(inputs.pdb_file_names)>0: pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0]) pdb_hierarchy = pdb_inp.construct_hierarchy() pdb_atoms = pdb_hierarchy.atoms() pdb_atoms.reset_i_seq() else: pdb_hierarchy=None # Map or map coefficients map_coeff = None if(inputs.ccp4_map is None): if(len(inputs.reflection_file_names)!=1): raise Sorry("Map or map coefficients file is needed.") map_coeff = reflection_file_utils.extract_miller_array_from_file( file_name = inputs.reflection_file_names[0], label = params.label, type = "complex", log = log) fft_map = map_coeff.fft_map(resolution_factor=params.resolution_factor) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() map_or_map_coeffs_prefix=os.path.basename( inputs.reflection_file_names[0][:-4]) else: print_statistics.make_sub_header("CCP4 map", out=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ") map_data = ccp4_map.map_data() if inputs.ccp4_map_file_name.endswith(".ccp4"): map_or_map_coeffs_prefix=os.path.basename( inputs.ccp4_map_file_name[:-5]) else: map_or_map_coeffs_prefix=os.path.basename( inputs.ccp4_map_file_name[:-4]) # if len(inputs.pdb_file_names)>0: output_prefix=os.path.basename(inputs.pdb_file_names[0])[:-4] else: output_prefix=map_or_map_coeffs_prefix if not pdb_hierarchy: # get an empty hierarchy from cctbx.array_family import flex pdb_hierarchy=iotbx.pdb.input( source_info='',lines=flex.split_lines('')).construct_hierarchy() xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry=inputs.crystal_symmetry) xray_structure.show_summary(f=log) # selection = pdb_hierarchy.atom_selection_cache().selection( string = params.selection) if selection.size(): print_statistics.make_sub_header("atom selection", out=log) print >> log, "Selection string: selection='%s'"%params.selection print >> log, \ " selects %d atoms from total %d atoms."%(selection.count(True), selection.size()) sites_cart_all = xray_structure.sites_cart() sites_cart = sites_cart_all.select(selection) selection = xray_structure.selection_within( radius = params.selection_radius, selection = selection) # if params.density_select: print_statistics.make_sub_header( "Extracting box around selected density and writing output files", out=log) else: print_statistics.make_sub_header( "Extracting box around selected atoms and writing output files", out=log) # box = mmtbx.utils.extract_box_around_model_and_map( xray_structure = xray_structure, map_data = map_data.as_double(), box_cushion = params.box_cushion, selection = selection, density_select = params.density_select, threshold = params.density_select_threshold) if box.initial_shift_cart: print >>log,"\nInitial coordinate shift will be (%.1f,%.1f,%.1f)\n" %( box.initial_shift_cart) if box.total_shift_cart: print >>log,"Final coordinate shift: (%.1f,%.1f,%.1f)" %( box.total_shift_cart) print >>log,"Final cell dimensions: (%.1f,%.1f,%.1f)\n" %( box.box_crystal_symmetry.unit_cell().parameters()[:3]) if box.pdb_outside_box_msg: print >> log, box.pdb_outside_box_msg if(params.output_file_name_prefix is None): file_name = "%s_box.pdb"%output_prefix else: file_name = "%s.pdb"%params.output_file_name_prefix ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) ph_box.write_pdb_file(file_name=file_name, crystal_symmetry = box.xray_structure_box.crystal_symmetry()) if("ccp4" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.ccp4"%output_prefix else: file_name = "%s.ccp4"%params.output_file_name_prefix print >> log, "writing map to CCP4 formatted file: %s"%file_name box.write_ccp4_map(file_name=file_name) if("xplor" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.xplor"%output_prefix else: file_name = "%s.xplor"%params.output_file_name_prefix print >> log, "writing map to X-plor formatted file: %s"%file_name box.write_xplor_map(file_name=file_name) if("mtz" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.mtz"%output_prefix else: file_name = "%s.mtz"%params.output_file_name_prefix print >> log, "writing map coefficients to MTZ file: %s"%file_name if(map_coeff is not None): d_min = map_coeff.d_min() else: d_min = maptbx.d_min_from_map(map_data=box.map_box, unit_cell=box.xray_structure_box.unit_cell()) box.map_coefficients(d_min=d_min, resolution_factor=params.resolution_factor, file_name=file_name) if params.ncs_file: if(params.output_file_name_prefix is None): output_ncs_file = "%s_box.ncs_spec"%output_prefix else: output_ncs_file = "%s.ncs_spec"%params.output_file_name_prefix print >>log,"\nOffsetting NCS in %s and writing to %s" %( params.ncs_file,output_ncs_file) from mmtbx.ncs.ncs import ncs ncs_object=ncs() ncs_object.read_ncs(params.ncs_file,log=log) ncs_object.display_all(log=log) if not ncs_object or ncs_object.max_operators()<1: print >>log,"Skipping...no NCS available" elif box.total_shift_cart: from scitbx.math import matrix print >>log,"Shifting NCS operators "+\ "based on coordinate shift of (%7.1f,%7.1f,%7.1f)" %( tuple(box.total_shift_cart)) ncs_object=ncs_object.coordinate_offset( coordinate_offset=matrix.col(box.total_shift_cart)) ncs_object.display_all(log=log) ncs_object.format_all_for_group_specification( file_name=output_ncs_file) box.ncs_object=ncs_object else: box.ncs_object=None print >> log return box
def run(args, crystal_symmetry=None, pdb_hierarchy=None, map_data=None, write_output_files=True, log=None): h = "phenix.map_box: extract box with model and map around selected atoms" if (log is None): log = sys.stdout print_statistics.make_header(h, out=log) default_message = """\ %s. Usage: phenix.map_box model.pdb map_coefficients.mtz selection="chain A and resseq 1:10" or phenix.map_box map.ccp4 density_select=True Parameters:""" % h if (len(args) == 0 and not pdb_hierarchy): print default_message master_phil.show(prefix=" ") return inputs = mmtbx.utils.process_command_line_args(args=args, cmd_cs=crystal_symmetry, master_params=master_phil) params = inputs.params.extract() # PDB file if params.pdb_file and not inputs.pdb_file_names and not pdb_hierarchy: inputs.pdb_file_names = [params.pdb_file] if (len(inputs.pdb_file_names) != 1 and not params.density_select and not pdb_hierarchy): raise Sorry("PDB file is needed unless density_select is set.") print_statistics.make_sub_header("pdb model", out=log) if len(inputs.pdb_file_names) > 0: pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0]) pdb_hierarchy = pdb_inp.construct_hierarchy() if pdb_hierarchy: pdb_atoms = pdb_hierarchy.atoms() pdb_atoms.reset_i_seq() else: pdb_hierarchy = None # Map or map coefficients map_coeff = None if (not map_data): # read first mtz file if ((len(inputs.reflection_file_names) > 0) or (params.map_coefficients_file is not None)): # file in phil takes precedent if (params.map_coefficients_file is not None): if (len(inputs.reflection_file_names) == 0): inputs.reflection_file_names.append( params.map_coefficients_file) else: inputs.reflection_file_names[ 0] = params.map_coefficients_file map_coeff = reflection_file_utils.extract_miller_array_from_file( file_name=inputs.reflection_file_names[0], label=params.label, type="complex", log=log) fft_map = map_coeff.fft_map( resolution_factor=params.resolution_factor) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() map_or_map_coeffs_prefix = os.path.basename( inputs.reflection_file_names[0][:-4]) # or read CCP4 map elif ((inputs.ccp4_map is not None) or (params.ccp4_map_file is not None)): if (params.ccp4_map_file is not None): af = any_file(params.ccp4_map_file) if (af.file_type == 'ccp4_map'): inputs.ccp4_map = af.file_content inputs.ccp4_map_file_name = params.ccp4_map_file print_statistics.make_sub_header("CCP4 map", out=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ", out=log) map_data = ccp4_map.data #map_data() if inputs.ccp4_map_file_name.endswith(".ccp4"): map_or_map_coeffs_prefix = os.path.basename( inputs.ccp4_map_file_name[:-5]) else: map_or_map_coeffs_prefix = os.path.basename( inputs.ccp4_map_file_name[:-4]) else: # have map_data map_or_map_coeffs_prefix = None # final check that map_data exists if (map_data is None): raise Sorry("Map or map coefficients file is needed.") if len(inputs.pdb_file_names) > 0: output_prefix = os.path.basename(inputs.pdb_file_names[0])[:-4] else: output_prefix = map_or_map_coeffs_prefix if not pdb_hierarchy: # get an empty hierarchy from cctbx.array_family import flex pdb_hierarchy = iotbx.pdb.input( source_info='', lines=flex.split_lines('')).construct_hierarchy() xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry=inputs.crystal_symmetry) xray_structure.show_summary(f=log) # selection = pdb_hierarchy.atom_selection_cache().selection( string=params.selection) if selection.size(): print_statistics.make_sub_header("atom selection", out=log) print >> log, "Selection string: selection='%s'" % params.selection print >> log, \ " selects %d atoms from total %d atoms."%(selection.count(True), selection.size()) sites_cart_all = xray_structure.sites_cart() sites_cart = sites_cart_all.select(selection) selection = xray_structure.selection_within(radius=params.selection_radius, selection=selection) # if params.density_select: print_statistics.make_sub_header( "Extracting box around selected density and writing output files", out=log) else: print_statistics.make_sub_header( "Extracting box around selected atoms and writing output files", out=log) # if params.value_outside_atoms == 'mean': print >> log, "\nValue outside atoms mask will be set to mean inside mask" if params.get_half_height_width: print >> log, "\nHalf width at half height will be used to id boundaries" box = mmtbx.utils.extract_box_around_model_and_map( xray_structure=xray_structure, map_data=map_data.as_double(), box_cushion=params.box_cushion, selection=selection, density_select=params.density_select, threshold=params.density_select_threshold, get_half_height_width=params.get_half_height_width, mask_atoms=params.mask_atoms, soft_mask=params.soft_mask, soft_mask_radius=params.soft_mask_radius, mask_atoms_atom_radius=params.mask_atoms_atom_radius, value_outside_atoms=params.value_outside_atoms, ) if box.initial_shift_cart: print >> log, "\nInitial coordinate shift will be (%.1f,%.1f,%.1f)\n" % ( box.initial_shift_cart) if box.total_shift_cart: print >> log, "Final coordinate shift: (%.1f,%.1f,%.1f)" % ( box.total_shift_cart) print >> log, "Final cell dimensions: (%.1f,%.1f,%.1f)\n" % ( box.box_crystal_symmetry.unit_cell().parameters()[:3]) if box.pdb_outside_box_msg: print >> log, box.pdb_outside_box_msg ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) box.hierarchy = ph_box if not write_output_files: return box if (params.output_file_name_prefix is None): file_name = "%s_box.pdb" % output_prefix else: file_name = "%s.pdb" % params.output_file_name_prefix ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) ph_box.write_pdb_file( file_name=file_name, crystal_symmetry=box.xray_structure_box.crystal_symmetry()) if ("ccp4" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.ccp4" % output_prefix else: file_name = "%s.ccp4" % params.output_file_name_prefix print >> log, "writing map to CCP4 formatted file: %s" % file_name box.write_ccp4_map(file_name=file_name) if ("xplor" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.xplor" % output_prefix else: file_name = "%s.xplor" % params.output_file_name_prefix print >> log, "writing map to X-plor formatted file: %s" % file_name box.write_xplor_map(file_name=file_name) if ("mtz" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.mtz" % output_prefix else: file_name = "%s.mtz" % params.output_file_name_prefix print >> log, "writing map coefficients to MTZ file: %s" % file_name if (map_coeff is not None): d_min = map_coeff.d_min() else: d_min = maptbx.d_min_from_map( map_data=box.map_box, unit_cell=box.xray_structure_box.unit_cell()) box.map_coefficients(d_min=d_min, resolution_factor=params.resolution_factor, file_name=file_name) if params.ncs_file: if (params.output_file_name_prefix is None): output_ncs_file = "%s_box.ncs_spec" % output_prefix else: output_ncs_file = "%s.ncs_spec" % params.output_file_name_prefix print >> log, "\nOffsetting NCS in %s and writing to %s" % ( params.ncs_file, output_ncs_file) from mmtbx.ncs.ncs import ncs ncs_object = ncs() ncs_object.read_ncs(params.ncs_file, log=log) ncs_object.display_all(log=log) if not ncs_object or ncs_object.max_operators() < 1: print >> log, "Skipping...no NCS available" elif box.total_shift_cart: from scitbx.math import matrix print >>log,"Shifting NCS operators "+\ "based on coordinate shift of (%7.1f,%7.1f,%7.1f)" %( tuple(box.total_shift_cart)) ncs_object = ncs_object.coordinate_offset( coordinate_offset=matrix.col(box.total_shift_cart)) ncs_object.display_all(log=log) ncs_object.format_all_for_group_specification( file_name=output_ncs_file) box.ncs_object = ncs_object else: box.ncs_object = None print >> log return box
def run(args, log=None, ccp4_map=None, return_as_miller_arrays=False, nohl=False, out=sys.stdout): if log is None: log=out inputs = mmtbx.utils.process_command_line_args(args = args, master_params = master_params()) got_map = False if ccp4_map: got_map=True broadcast(m="Parameters:", log=log) inputs.params.show(prefix=" ",out=out) params = inputs.params.extract() if(ccp4_map is None and inputs.ccp4_map is not None): broadcast(m="Processing input CCP4 map file: %s"%inputs.ccp4_map_file_name, log=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ",out=out) got_map = True if(not got_map): raise Sorry("Map file is needed.") # m = ccp4_map broadcast(m="Input map information:", log=log) print >>out,"m.all() :", m.data.all() print >>out,"m.focus() :", m.data.focus() print >>out,"m.origin():", m.data.origin() print >>out,"m.nd() :", m.data.nd() print >>out,"m.size() :", m.data.size() print >>out,"m.focus_size_1d():", m.data.focus_size_1d() print >>out,"m.is_0_based() :", m.data.is_0_based() print >>out,"map: min/max/mean:", flex.min(m.data), flex.max(m.data), flex.mean(m.data) print >>out,"unit cell:", m.unit_cell_parameters # map_data=m.data shift_needed = not \ (map_data.focus_size_1d() > 0 and map_data.nd() == 3 and map_data.is_0_based()) if(shift_needed): map_data = map_data.shift_origin() # generate complete set of Miller indices up to given high resolution d_min n_real = map_data.focus() cs = crystal.symmetry(m.unit_cell_parameters, 1) crystal_gridding = maptbx.crystal_gridding( unit_cell = cs.unit_cell(), space_group_info = cs.space_group_info(), #symmetry_flags = maptbx.use_space_group_symmetry, pre_determined_n_real = n_real) # d_min = params.d_min if(d_min is None and not params.box): d_min = maptbx.d_min_from_map( map_data = map_data, unit_cell = cs.unit_cell()) if(d_min is None): # box of reflections in |h|<N1/2, |k|<N2/2, 0<=|l|<N3/2 max_index = [(i-1)//2 for i in n_real] print >>out,"max_index:", max_index complete_set = miller.build_set( crystal_symmetry = cs, anomalous_flag = False, max_index = max_index) indices = complete_set.indices() indices.append((0,0,0)) complete_set = complete_set.customized_copy(indices = indices) #if(not params.box): # # XXX What is sphere resolution corresponding to given box? # uc = complete_set.unit_cell() # d1 = uc.d([0,0,max_index[2]]) # d2 = uc.d([0,max_index[1],0]) # d3 = uc.d([max_index[0],1,0]) # print >>out, d1,d2,d3 # complete_set_sp = miller.build_set( # crystal_symmetry = cs, # anomalous_flag = False, # d_min = min(d1,d2,d3)) # complete_set = complete_set.common_set(complete_set_sp) else: complete_set = miller.build_set( crystal_symmetry = cs, anomalous_flag = False, d_min = d_min) broadcast(m="Complete set information:", log=log) complete_set.show_comprehensive_summary(prefix=" ",f=out) try: f_obs_cmpl = complete_set.structure_factors_from_map( map = map_data.as_double(), use_scale = True, anomalous_flag = False, use_sg = False) except Exception, e: if(str(e) == "cctbx Error: Miller index not in structure factor map."): msg = "Too high resolution requested. Try running with larger d_min." raise Sorry(msg) else: raise Sorry(str(e))
def run(args, log=None, ccp4_map=None, return_as_miller_arrays=False, nohl=False, space_group_number=None, out=sys.stdout): if log is None: log = out inputs = mmtbx.utils.process_command_line_args( args=args, master_params=master_params()) got_map = False if ccp4_map: got_map = True broadcast(m="Parameters:", log=log) inputs.params.show(prefix=" ", out=out) params = inputs.params.extract() if (ccp4_map is None and inputs.ccp4_map is not None): broadcast(m="Processing input CCP4 map file: %s" % inputs.ccp4_map_file_name, log=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ", out=out) got_map = True if (not got_map): raise Sorry("Map file is needed.") # m = ccp4_map if (m.space_group_number > 1): raise Sorry("Input map space group: %d. Must be P1." % m.space_group_number) broadcast(m="Input map information:", log=log) print >> out, "m.all() :", m.data.all() print >> out, "m.focus() :", m.data.focus() print >> out, "m.origin():", m.data.origin() print >> out, "m.nd() :", m.data.nd() print >> out, "m.size() :", m.data.size() print >> out, "m.focus_size_1d():", m.data.focus_size_1d() print >> out, "m.is_0_based() :", m.data.is_0_based() print >> out, "map: min/max/mean:", flex.min(m.data), flex.max( m.data), flex.mean(m.data) print >> out, "unit cell:", m.unit_cell_parameters # map_data = m.data shift_needed = not \ (map_data.focus_size_1d() > 0 and map_data.nd() == 3 and map_data.is_0_based()) if (shift_needed): map_data = map_data.shift_origin() # generate complete set of Miller indices up to given high resolution d_min n_real = map_data.focus() if not space_group_number: space_group_number = 1 if space_group_number <= 1: symmetry_flags = None else: symmetry_flags = maptbx.use_space_group_symmetry, cs = crystal.symmetry(m.unit_cell_parameters, space_group_number) crystal_gridding = maptbx.crystal_gridding( unit_cell=cs.unit_cell(), space_group_info=cs.space_group_info(), symmetry_flags=symmetry_flags, pre_determined_n_real=n_real) # d_min = params.d_min if (d_min is None and not params.box): d_min = maptbx.d_min_from_map(map_data=map_data, unit_cell=cs.unit_cell()) if (d_min is None): # box of reflections in |h|<N1/2, |k|<N2/2, 0<=|l|<N3/2 max_index = [(i - 1) // 2 for i in n_real] print >> out, "max_index:", max_index complete_set = miller.build_set(crystal_symmetry=cs, anomalous_flag=False, max_index=max_index) indices = complete_set.indices() indices.append((0, 0, 0)) complete_set = complete_set.customized_copy(indices=indices) #if(not params.box): # # XXX What is sphere resolution corresponding to given box? # uc = complete_set.unit_cell() # d1 = uc.d([0,0,max_index[2]]) # d2 = uc.d([0,max_index[1],0]) # d3 = uc.d([max_index[0],1,0]) # print >>out, d1,d2,d3 # complete_set_sp = miller.build_set( # crystal_symmetry = cs, # anomalous_flag = False, # d_min = min(d1,d2,d3)) # complete_set = complete_set.common_set(complete_set_sp) else: complete_set = miller.build_set(crystal_symmetry=cs, anomalous_flag=False, d_min=d_min) broadcast(m="Complete set information:", log=log) complete_set.show_comprehensive_summary(prefix=" ", f=out) try: f_obs_cmpl = complete_set.structure_factors_from_map( map=map_data.as_double(), use_scale=True, anomalous_flag=False, use_sg=False) except Exception, e: if (str(e) == "cctbx Error: Miller index not in structure factor map." ): msg = "Too high resolution requested. Try running with larger d_min." raise Sorry(msg) else: raise Sorry(str(e))