def get_best_co(map_data, min_cutoff=0.5):
max_value = map_data.as_1d().min_max_mean().max
# Find max number of clusters in range of 0.5 to 1.0 * max
n = 100
max_clusters = None
cutoff = None
for t in range(int(min_cutoff * n), n + 1):
threshold = t * max_value / n
co, sorted_by_volume, min_b, max_b = get_co(map_data,
threshold=threshold,
wrapping=False)
if ((not max_clusters) or (len(sorted_by_volume) > max_clusters)) and (
len(sorted_by_volume) > 1):
max_clusters = len(sorted_by_volume)
cutoff = threshold
if max_clusters is None:
return None
print("Clusters: %s Threshold: %.2f " % (max_clusters, cutoff))
co, sorted_by_volume, min_b, max_b = get_co(map_data,
threshold=cutoff,
wrapping=False)
return group_args(group_args_type='co info',
co=co,
sorted_by_volume=sorted_by_volume)
def __init__(self, map_manager, wrapping, log=sys.stdout):
adopt_init_args(self, locals())
# safeguards
assert isinstance(wrapping, bool)
assert isinstance(map_manager, iotbx.map_manager.map_manager)
assert self.map_manager.map_data().accessor().origin() == (0, 0, 0)
if wrapping:
assert map_manager.unit_cell_grid == map_manager.map_data().all()
self.basis_for_boxing_string = 'around_mask bounds, wrapping=%s' % (
wrapping)
# Get a connectivity object that marks all the connected regions in map
from cctbx.maptbx.segment_and_split_map import get_co
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: # didn't work
raise Sorry("No mask obtained...")
# Get the biggest connected region in the map
original_id_from_id = {}
for i in range(1, len(sorted_by_volume)):
v, id = sorted_by_volume[i]
original_id_from_id[i] = id
id = 1
orig_id = original_id_from_id[id]
# Get lower and upper bounds of this region in grid units
self.gridding_first = min_b[orig_id]
self.gridding_last = max_b[orig_id]
# Ready with gridding...set up shifts and box crystal_symmetry
self.set_shifts_and_crystal_symmetry()
# Apply to map_manager so that self.map_manager is boxed version
self.map_manager = self.apply_to_map(self.map_manager)
def __init__(self,
map_manager,
mask_as_map_manager,
model=None,
box_cushion=3,
wrapping=None,
model_can_be_outside_bounds=False,
log=sys.stdout):
self._map_manager = map_manager
self._model = model
self.model_can_be_outside_bounds = model_can_be_outside_bounds
assert map_manager.shift_cart() == mask_as_map_manager.shift_cart()
# safeguards
assert isinstance(map_manager, iotbx.map_manager.map_manager)
assert isinstance(mask_as_map_manager, iotbx.map_manager.map_manager)
assert self._map_manager.map_data().accessor().origin() == (0, 0, 0)
assert map_manager.is_similar(mask_as_map_manager)
if self.map_manager().wrapping():
assert map_manager.unit_cell_grid == map_manager.map_data().all()
self._force_wrapping = wrapping
if wrapping is None:
wrapping = self.map_manager().wrapping()
self.basis_for_boxing_string = 'around_mask bounds, wrapping = %s' % (
wrapping)
# Make sure the map goes from 0 to 1
map_data = mask_as_map_manager.map_data()
mmm = map_data.as_1d().min_max_mean()
minimum = mmm.min
range_of_values = mmm.max - mmm.min
map_data = (map_data - minimum) / max(1.e-10, range_of_values)
# Get a connectivity object that marks all the connected regions in map
from cctbx.maptbx.segment_and_split_map import get_co
co, sorted_by_volume, min_b, max_b = get_co(map_data=map_data,
threshold=0.5,
wrapping=False)
if len(sorted_by_volume) < 2: # didn't work
raise Sorry("No mask obtained...")
# Get the biggest connected region in the map
original_id_from_id = {}
for i in range(1, len(sorted_by_volume)):
v, id = sorted_by_volume[i]
original_id_from_id[i] = id
id = 1
orig_id = original_id_from_id[id]
# Get lower and upper bounds of this region in grid units
self.gridding_first = min_b[orig_id]
self.gridding_last = max_b[orig_id]
# Increase range of bounds by box_cushion
cs = map_manager.crystal_symmetry()
cushion = flex.double(cs.unit_cell().fractionalize(
(box_cushion, ) * 3))
all_orig = map_manager.map_data().all()
self.gridding_first = [
max(0, ifloor(gf - c * n))
for c, gf, n in zip(cushion, self.gridding_first, all_orig)
]
self.gridding_last = [
min(n - 1, iceil(gl + c * n))
for c, gl, n in zip(cushion, self.gridding_last, all_orig)
]
# Ready with gridding...set up shifts and box crystal_symmetry
self.set_shifts_and_crystal_symmetry()
self.apply_to_model_ncs_and_map()
# Also apply to mask_as_map_manager so that mask_as_map_manager is boxed
mask_as_map_manager = self.apply_to_map(mask_as_map_manager)
self.mask_as_map_manager = mask_as_map_manager # save it
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