def _compute_soft_mask_from_density(self): from cctbx.maptbx.segment_and_split_map import get_iterated_solvent_fraction mask_data, solvent_fraction = get_iterated_solvent_fraction( crystal_symmetry=self.crystal_symmetry, fraction_of_max_mask_threshold=0.05, # cell_cutoff_for_solvent_from_mask=1, # Use low-res method always mask_resolution=self.resolution, return_mask_and_solvent_fraction=True, verbose=False, map=self.map_data, out=null_out()) if solvent_fraction: from cctbx.maptbx.segment_and_split_map import apply_soft_mask map_data, smoothed_mask_data = apply_soft_mask( map_data=self.map_data, mask_data=mask_data.as_double(), rad_smooth=self.radius_smooth, crystal_symmetry=self.crystal_symmetry, out=null_out()) return smoothed_mask_data else: return None
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 : required 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 resolution is not None assert (map_manager is not None) 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, solvent_fraction = 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 solvent_fraction is None: raise Sorry("Unable to get solvent fraction in auto-masking") # Set up map_manager with this mask self._map_manager = map_manager.customized_copy(map_data=self._mask) # Initialize soft mask self._is_soft_mask = False self._is_soft_mask_around_edges = False
def __init__(self, map_manager, model = None, target_ncs_au_model = None, regions_to_keep = None, residues_per_region = None, keep_this_region_only = None, solvent_content = None, resolution = None, sequence = None, molecular_mass = None, symmetry = None, use_symmetry_in_extract_unique = True, chain_type = 'PROTEIN', keep_low_density = True, # default from map_box box_cushion= 5, soft_mask = True, mask_expand_ratio = 1, wrapping = None, log = None): self.model_can_be_outside_bounds = None # not used but required to be set self._map_manager = map_manager self._model = model self._mask_data = None self._force_wrapping = wrapping if wrapping is None: wrapping = self.map_manager().wrapping() self.basis_for_boxing_string = 'around_unique, wrapping = %s' %( wrapping) if log is None: log = null_out() # Print only if a log is supplied assert isinstance(map_manager, iotbx.map_manager.map_manager) assert self._map_manager.map_data().accessor().origin() == (0, 0, 0) assert resolution is not None if model is not None: assert isinstance(model, mmtbx.model.manager) assert map_manager.is_compatible_model(model) if self.map_manager().wrapping(): # map must be entire unit cell assert map_manager.unit_cell_grid == map_manager.map_data().all() # Get crystal_symmetry crystal_symmetry = map_manager.crystal_symmetry() # Convert to map_data from cctbx.maptbx.segment_and_split_map import run as segment_and_split_map assert self._map_manager.map_data().origin() == (0, 0, 0) args = [] if residues_per_region: args.append("residues_per_region=%s" %(residues_per_region)) if keep_this_region_only is not None: regions_to_keep = -1 * keep_this_region_only if solvent_content is None and sequence is None and molecular_mass is None: from cctbx.maptbx.segment_and_split_map \ import get_iterated_solvent_fraction solvent_content = get_iterated_solvent_fraction( crystal_symmetry = crystal_symmetry, mask_resolution = resolution, map = self._map_manager.map_data(), out = log) ncs_group_obj, remainder_ncs_group_obj, tracking_data = \ segment_and_split_map(args, map_data = self._map_manager.map_data(), crystal_symmetry = crystal_symmetry, ncs_obj = self._map_manager.ncs_object() if \ use_symmetry_in_extract_unique else None, target_model = target_ncs_au_model, write_files = False, auto_sharpen = False, add_neighbors = False, density_select = False, save_box_map_ncs_au = True, resolution = resolution, solvent_content = solvent_content, chain_type = chain_type, sequence = sequence, molecular_mass = molecular_mass, symmetry = symmetry if use_symmetry_in_extract_unique else None, keep_low_density = keep_low_density, regions_to_keep = regions_to_keep, box_buffer = box_cushion, soft_mask_extract_unique = soft_mask, mask_expand_ratio = mask_expand_ratio, out = log) from scitbx.matrix import col # Note number of selected regions used. if hasattr(tracking_data, 'available_selected_regions'): self.set_info(group_args( group_args_type = 'available selected regions from around_unique', available_selected_regions = tracking_data.available_selected_regions, )) if not hasattr(tracking_data, 'box_mask_ncs_au_map_data'): raise Sorry(" Extraction of unique part of map failed...") ncs_au_mask_data = tracking_data.box_mask_ncs_au_map_data lower_bounds = ncs_au_mask_data.origin() upper_bounds = tuple( col(ncs_au_mask_data.focus())-col((1, 1, 1))) print("\nBounds for unique part of map: %s to %s " %( str(lower_bounds), str(upper_bounds)), file = log) # shift the map so it is in the same position as the box map will be in ncs_au_mask_data.reshape(flex.grid(ncs_au_mask_data.all())) assert col(ncs_au_mask_data.all()) == \ col(upper_bounds)-col(lower_bounds)+col((1, 1, 1)) self.gridding_first = lower_bounds self.gridding_last = upper_bounds # Ready with gridding...set up shifts and box crystal_symmetry self.set_shifts_and_crystal_symmetry() # Apply boxing to model, ncs, and map (if available) self.apply_to_model_ncs_and_map() # Note that at this point, self._map_manager has been boxed assert ncs_au_mask_data.all() == self._map_manager.map_data().all() self._mask_data = ncs_au_mask_data # Now separately apply the mask to the boxed map self.apply_around_unique_mask( self._map_manager, resolution = resolution, soft_mask = soft_mask)