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)