def __init__(self, miller_array,
xray_structure = None,
miller_array_twin = None,
mask_params = None,
compute_mask = True):
adopt_init_args(self, locals())
if(self.mask_params is not None): self.mask_params = mask_params
else: self.mask_params = mask_master_params.extract()
self.grid_step = self._get_grid_step()
self.atom_radii = None
self._f_mask = None
self._f_mask_twin = None
self.solvent_content_via_mask = None
self.layer_volume_fractions = None
self.sites_cart = None
if(xray_structure is not None):
self.atom_radii = vdw_radii_from_xray_structure(xray_structure =
self.xray_structure)
self.xray_structure = self.xray_structure.deep_copy_scatterers()
self.sites_cart = self.xray_structure.sites_cart()
twin=False
if(self.miller_array_twin is not None): twin=True
if(compute_mask): self.compute_f_mask()
if( not (self._f_mask is None) ):
assert self._f_mask[0].data().size() == self.miller_array.indices().size()
def __init__(
self,
xray_structure,
p1,
for_structure_factors,
n_real,
solvent_radius=None,
shrink_truncation_radius=None,
in_asu=False):
if([solvent_radius, shrink_truncation_radius].count(None)>0):
mask_params = mask_master_params.extract()
if(solvent_radius is None): solvent_radius = mask_params.solvent_radius
if(shrink_truncation_radius is None):
shrink_truncation_radius = mask_params.shrink_truncation_radius
xrs = xray_structure
sgt = xrs.space_group().type() # must be BEFORE going to P1, obviously!
if(p1): xrs = xrs.expand_to_p1(sites_mod_positive=True)
atom_radii = vdw_radii_from_xray_structure(xray_structure = xrs)
self.asu_mask = mmtbx.masks.atom_mask(
unit_cell = xrs.unit_cell(),
space_group = xrs.space_group(),
gridding_n_real = n_real,
solvent_radius = solvent_radius,
shrink_truncation_radius = shrink_truncation_radius)
self.asu_mask.compute(xrs.sites_frac(), atom_radii)
self.mask_data = self.asu_mask.mask_data_whole_uc()
if(for_structure_factors):
self.mask_data = self.mask_data / xrs.space_group().order_z()
if(in_asu):
assert p1
asu_map_ = asu_map_ext.asymmetric_map(sgt, self.mask_data)
self.mask_data = asu_map_.data()
def __init__(self,
miller_array,
xray_structure=None,
miller_array_twin=None,
mask_params=None,
compute_mask=True):
adopt_init_args(self, locals())
if (self.mask_params is not None): self.mask_params = mask_params
else: self.mask_params = mask_master_params.extract()
self.grid_step = self._get_grid_step()
self.atom_radii = None
self._f_mask = None
self._f_mask_twin = None
self.solvent_content_via_mask = None
self.layer_volume_fractions = None
self.sites_cart = None
if (xray_structure is not None):
self.atom_radii = vdw_radii_from_xray_structure(
xray_structure=self.xray_structure)
self.xray_structure = self.xray_structure.deep_copy_scatterers()
self.sites_cart = self.xray_structure.sites_cart()
twin = False
if (self.miller_array_twin is not None): twin = True
if (compute_mask): self.compute_f_mask()
if (not (self._f_mask is None)):
assert self._f_mask[0].data().size() == self.miller_array.indices(
).size()
def __init__(self,
miller_array,
xray_structure=None,
miller_array_twin=None,
mask_params=None,
compute_mask=True):
adopt_init_args(self, locals())
if (self.mask_params is not None): self.mask_params = mask_params
else: self.mask_params = mask_master_params.extract()
Fmask_res_high = self.mask_params.Fmask_res_high
self.sel_Fmask_res = miller_array.d_spacings().data() >= Fmask_res_high
self.sel_Fmask_res_twin = None
if (miller_array_twin is not None):
self.sel_Fmask_res_twin = miller_array_twin.d_spacings().data(
) >= Fmask_res_high
self.xray_structure = self._load_xrs(xray_structure)
self.atom_radii = None
self._f_mask = None
self._f_mask_twin = None
self.solvent_content_via_mask = None
self.layer_volume_fractions = None
self.sites_cart = None
if (self.xray_structure is not None):
self.atom_radii = vdw_radii_from_xray_structure(
xray_structure=self.xray_structure)
self.sites_cart = self.xray_structure.sites_cart()
twin = False
if (self.miller_array_twin is not None): twin = True
if (compute_mask): self.compute_f_mask()
if (not (self._f_mask is None)):
assert self._f_mask[0].data().size() == self.miller_array.indices(
).size()
def __init__(self,
xray_structure,
p1,
for_structure_factors,
n_real,
solvent_radius=None,
shrink_truncation_radius=None,
in_asu=False):
if ([solvent_radius, shrink_truncation_radius].count(None) > 0):
mask_params = mask_master_params.extract()
if (solvent_radius is None):
solvent_radius = mask_params.solvent_radius
if (shrink_truncation_radius is None):
shrink_truncation_radius = mask_params.shrink_truncation_radius
xrs = xray_structure
sgt = xrs.space_group().type(
) # must be BEFORE going to P1, obviously!
if (p1): xrs = xrs.expand_to_p1(sites_mod_positive=True)
atom_radii = vdw_radii_from_xray_structure(xray_structure=xrs)
self.asu_mask = mmtbx.masks.atom_mask(
unit_cell=xrs.unit_cell(),
space_group=xrs.space_group(),
gridding_n_real=n_real,
solvent_radius=solvent_radius,
shrink_truncation_radius=shrink_truncation_radius)
self.asu_mask.compute(xrs.sites_frac(), atom_radii)
self.mask_data = self.asu_mask.mask_data_whole_uc()
if (for_structure_factors):
self.mask_data = self.mask_data / xrs.space_group().order_z()
if (in_asu):
assert p1
asu_map_ = asu_map_ext.asymmetric_map(sgt, self.mask_data)
self.mask_data = asu_map_.data()
def mask(xray_structure, n_real, solvent_radius):
xrs_p1 = xray_structure.expand_to_p1(sites_mod_positive=True)
from cctbx.masks import vdw_radii_from_xray_structure
radii = vdw_radii_from_xray_structure(xray_structure = xrs_p1)
radii = radii + solvent_radius
return ext.mask(
sites_frac = xrs_p1.sites_frac(),
unit_cell = xrs_p1.unit_cell(),
n_real = n_real,
radii = radii)
def __init__(self,
xray_structure,
d_min=None,
n_real=None,
mask_params=None,
atom_radius=None):
adopt_init_args(self, locals())
assert [d_min, n_real].count(None) == 1
if (self.mask_params is None):
self.mask_params = mask_master_params.extract()
if (atom_radius is None):
self.atom_radii = vdw_radii_from_xray_structure(
xray_structure=self.xray_structure)
else:
self.atom_radii = flex.double(
self.xray_structure.scatterers().size(), atom_radius)
if (d_min is not None):
self.asu_mask = atom_mask(
unit_cell=self.xray_structure.unit_cell(),
group=self.xray_structure.space_group(),
resolution=self.d_min,
grid_step_factor=self.mask_params.grid_step_factor,
solvent_radius=self.mask_params.solvent_radius,
shrink_truncation_radius=self.mask_params.
shrink_truncation_radius)
else:
self.asu_mask = atom_mask(
unit_cell=self.xray_structure.unit_cell(),
space_group=self.xray_structure.space_group(),
gridding_n_real=self.n_real,
solvent_radius=self.mask_params.solvent_radius,
shrink_truncation_radius=self.mask_params.
shrink_truncation_radius)
selection = flex.bool(self.xray_structure.scatterers().size(), True)
if (self.mask_params.ignore_zero_occupancy_atoms):
selection &= self.xray_structure.scatterers().extract_occupancies(
) > 0
if (self.mask_params.ignore_hydrogens):
selection &= (~self.xray_structure.hd_selection())
sites_frac = self.xray_structure.sites_frac()
sites_frac = sites_frac.select(selection)
atom_radii = self.atom_radii.select(selection)
if (self.mask_params.n_radial_shells > 1):
# number of shell radii is one less than number of shells
# last shell is of unknown radius
shell_rads = [self.mask_params.radial_shell_width] * \
(self.mask_params.n_radial_shells-1)
# TODO: Should first shell width be:
shell_rads[0] -= self.mask_params.solvent_radius
if (shell_rads[0] < 0.):
shell_rads[0] = 0.
self.asu_mask.compute(sites_frac, atom_radii, shell_rads)
else:
self.asu_mask.compute(sites_frac, atom_radii)
def exercise_mask_data_2(space_group_info,
n_sites=100,
d_min=2.0,
resolution_factor=1. / 4):
from cctbx import maptbx
from cctbx.masks import vdw_radii_from_xray_structure
for yn2 in [0, 1]:
for yn in [0, 1]:
xrs = random_structure.xray_structure(
space_group_info=space_group_info,
elements=(("O", "N", "C") * (n_sites // 3 + 1))[:n_sites],
volume_per_atom=50,
min_distance=1.5)
xrs.shake_sites_in_place(mean_distance=10)
if (yn2): xrs = xrs.expand_to_p1(sites_mod_positive=True)
atom_radii = vdw_radii_from_xray_structure(xray_structure=xrs)
asu_mask = masks.atom_mask(unit_cell=xrs.unit_cell(),
group=xrs.space_group(),
resolution=d_min,
grid_step_factor=resolution_factor,
solvent_radius=1.0,
shrink_truncation_radius=1.0)
asu_mask.compute(xrs.sites_frac(), atom_radii)
mask_data = asu_mask.mask_data_whole_uc()
#
xrs_p1 = xrs.expand_to_p1(sites_mod_positive=True)
for site_frac in xrs_p1.sites_frac():
mv = mask_data.value_at_closest_grid_point(site_frac)
assert mv == 0
#
mask_data = mask_data / xrs.space_group().order_z()
if (yn == 1):
mask_data = maptbx.copy(mask_data,
flex.grid(mask_data.focus()))
#
for site_frac in xrs_p1.sites_frac():
mv = mask_data.value_at_closest_grid_point(site_frac)
assert mv == 0
#
fc = xrs.structure_factors(d_min=d_min).f_calc()
f_mask_1 = fc.set().array(
data=asu_mask.structure_factors(fc.indices()))
f_mask_2 = f_mask_1.structure_factors_from_map(
map=mask_data,
use_scale=True,
anomalous_flag=False,
use_sg=True)
fm1 = abs(f_mask_1).data()
fm2 = abs(f_mask_2).data()
r = flex.sum(flex.abs(fm1 - fm2)) / flex.sum(fm1 + fm2)
assert approx_equal(r, 0.0)
def exercise_mask_data_1(space_group_info, n_sites=100):
from cctbx import maptbx
from cctbx.masks import vdw_radii_from_xray_structure
for d_min in [1, 1.5, 2.1]:
for resolution_factor in [1. / 2, 1. / 3, 1. / 4, 1. / 5]:
xrs = random_structure.xray_structure(
space_group_info=space_group_info,
elements=(("O", "N", "C") * (n_sites // 3 + 1))[:n_sites],
volume_per_atom=30,
min_distance=1)
atom_radii = vdw_radii_from_xray_structure(xray_structure=xrs)
asu_mask = masks.atom_mask(unit_cell=xrs.unit_cell(),
group=xrs.space_group(),
resolution=d_min,
grid_step_factor=resolution_factor,
solvent_radius=1.0,
shrink_truncation_radius=1.0)
asu_mask.compute(xrs.sites_frac(), atom_radii)
mask_data = asu_mask.mask_data_whole_uc()
assert flex.min(mask_data) == 0.0
# It's not just 0 and 1 ...
assert flex.max(mask_data) == xrs.space_group().order_z()
# In fact, it is a mixture ...
if 0: # XXX this will rightfully crash
mask_data_ = mask_data / xrs.space_group().order_z()
s0 = mask_data_ < 0.5
s1 = mask_data_ > 0.5
if (mask_data_.size() != s0.count(True) + s1.count(True)):
for d in mask_data_:
if (d != 0 and d != 1):
print(d, xrs.space_group().order_z())
assert mask_data_.size(
) == s0.count(True) + s1.count(True), [
mask_data_.size() - (s0.count(True) + s1.count(True))
]
if (
0
): # XXX This would crash with the message: "... The grid is not ..."
cr_gr = maptbx.crystal_gridding(
unit_cell=xrs.unit_cell(),
d_min=d_min,
resolution_factor=resolution_factor)
asu_mask = masks.atom_mask(unit_cell=xrs.unit_cell(),
space_group=xrs.space_group(),
gridding_n_real=cr_gr.n_real(),
solvent_radius=1.0,
shrink_truncation_radius=1.0)
asu_mask.compute(xrs.sites_frac(), atom_radii)
def __init__(self, xray_structure, d_min=None, n_real=None, mask_params = None,
atom_radius = None):
adopt_init_args(self, locals())
assert [d_min, n_real].count(None) == 1
if(self.mask_params is None):
self.mask_params = mask_master_params.extract()
if(atom_radius is None):
self.atom_radii = vdw_radii_from_xray_structure(xray_structure =
self.xray_structure)
else:
self.atom_radii = flex.double(self.xray_structure.scatterers().size(),
atom_radius)
if(d_min is not None):
self.asu_mask = atom_mask(
unit_cell = self.xray_structure.unit_cell(),
group = self.xray_structure.space_group(),
resolution = self.d_min,
grid_step_factor = self.mask_params.grid_step_factor,
solvent_radius = self.mask_params.solvent_radius,
shrink_truncation_radius = self.mask_params.shrink_truncation_radius)
else:
self.asu_mask = atom_mask(
unit_cell = self.xray_structure.unit_cell(),
space_group = self.xray_structure.space_group(),
gridding_n_real = self.n_real,
solvent_radius = self.mask_params.solvent_radius,
shrink_truncation_radius = self.mask_params.shrink_truncation_radius)
selection = flex.bool(self.xray_structure.scatterers().size(), True)
if(self.mask_params.ignore_zero_occupancy_atoms):
selection &= self.xray_structure.scatterers().extract_occupancies() > 0
if(self.mask_params.ignore_hydrogens):
selection &= (~self.xray_structure.hd_selection())
sites_frac = self.xray_structure.sites_frac()
sites_frac = sites_frac.select(selection)
atom_radii = self.atom_radii.select(selection)
if(self.mask_params.n_radial_shells > 1):
# number of shell radii is one less than number of shells
# last shell is of unknown radius
shell_rads = [self.mask_params.radial_shell_width] * \
(self.mask_params.n_radial_shells-1)
# TODO: Should first shell width be:
shell_rads[0] -= self.mask_params.solvent_radius
if( shell_rads[0]<0. ):
shell_rads[0] = 0.
self.asu_mask.compute(sites_frac, atom_radii, shell_rads)
else:
self.asu_mask.compute(sites_frac, atom_radii)
def exercise_mask_data_2(space_group_info, n_sites=100, d_min=2.0,
resolution_factor=1./4):
from cctbx import maptbx
from cctbx.masks import vdw_radii_from_xray_structure
for yn2 in [0,1]:
for yn in [0,1]:
xrs = random_structure.xray_structure(
space_group_info=space_group_info,
elements=(("O","N","C")*(n_sites//3+1))[:n_sites],
volume_per_atom=50,
min_distance=1.5)
xrs.shake_sites_in_place(mean_distance=10)
if(yn2): xrs = xrs.expand_to_p1(sites_mod_positive=True)
atom_radii = vdw_radii_from_xray_structure(xray_structure = xrs)
asu_mask = masks.atom_mask(
unit_cell = xrs.unit_cell(),
group = xrs.space_group(),
resolution = d_min,
grid_step_factor = resolution_factor,
solvent_radius = 1.0,
shrink_truncation_radius = 1.0)
asu_mask.compute(xrs.sites_frac(), atom_radii)
mask_data = asu_mask.mask_data_whole_uc()
#
xrs_p1 = xrs.expand_to_p1(sites_mod_positive=True)
for site_frac in xrs_p1.sites_frac():
mv = mask_data.value_at_closest_grid_point(site_frac)
assert mv == 0
#
mask_data = mask_data / xrs.space_group().order_z()
if(yn == 1):
mask_data = maptbx.copy(mask_data, flex.grid(mask_data.focus()))
#
for site_frac in xrs_p1.sites_frac():
mv = mask_data.value_at_closest_grid_point(site_frac)
assert mv == 0
#
fc = xrs.structure_factors(d_min = d_min).f_calc()
f_mask_1 = fc.set().array(data = asu_mask.structure_factors(fc.indices()))
f_mask_2 = f_mask_1.structure_factors_from_map(map=mask_data,
use_scale = True, anomalous_flag = False, use_sg = True)
fm1 = abs(f_mask_1).data()
fm2 = abs(f_mask_2).data()
r = flex.sum( flex.abs( fm1 - fm2 ) ) / flex.sum( fm1 + fm2 )
assert approx_equal(r, 0.0)
def exercise_mask_data_1(space_group_info, n_sites=100):
from cctbx import maptbx
from cctbx.masks import vdw_radii_from_xray_structure
for d_min in [1, 1.5, 2.1]:
for resolution_factor in [1./2, 1./3, 1./4, 1./5]:
xrs = random_structure.xray_structure(
space_group_info=space_group_info,
elements=(("O","N","C")*(n_sites//3+1))[:n_sites],
volume_per_atom=30,
min_distance=1)
atom_radii = vdw_radii_from_xray_structure(xray_structure = xrs)
asu_mask = masks.atom_mask(
unit_cell = xrs.unit_cell(),
group = xrs.space_group(),
resolution = d_min,
grid_step_factor = resolution_factor,
solvent_radius = 1.0,
shrink_truncation_radius = 1.0)
asu_mask.compute(xrs.sites_frac(), atom_radii)
mask_data = asu_mask.mask_data_whole_uc()
assert flex.min(mask_data) == 0.0
# It's not just 0 and 1 ...
assert flex.max(mask_data) == xrs.space_group().order_z()
# In fact, it is a mixture ...
if 0: # XXX this will rightfully crash
mask_data_ = mask_data / xrs.space_group().order_z()
s0 = mask_data_ < 0.5
s1 = mask_data_ > 0.5
if(mask_data_.size() != s0.count(True)+s1.count(True)):
for d in mask_data_:
if(d != 0 and d != 1): print d, xrs.space_group().order_z()
assert mask_data_.size() == s0.count(True)+s1.count(True), [
mask_data_.size()-(s0.count(True)+s1.count(True))]
if(0): # XXX This would crash with the message: "... The grid is not ..."
cr_gr = maptbx.crystal_gridding(
unit_cell = xrs.unit_cell(),
d_min = d_min,
resolution_factor = resolution_factor)
asu_mask = masks.atom_mask(
unit_cell = xrs.unit_cell(),
space_group = xrs.space_group(),
gridding_n_real = cr_gr.n_real(),
solvent_radius = 1.0,
shrink_truncation_radius = 1.0)
asu_mask.compute(xrs.sites_frac(), atom_radii)
def mask(xray_structure,
n_real,
mask_value_inside_molecule=0,
mask_value_outside_molecule=1,
solvent_radius=0,
atom_radius=None):
xrs_p1 = xray_structure.expand_to_p1(sites_mod_positive=True)
if (atom_radius is None):
from cctbx.masks import vdw_radii_from_xray_structure
atom_radii = vdw_radii_from_xray_structure(xray_structure=xrs_p1)
else:
atom_radii = flex.double(xrs_p1.scatterers().size(), atom_radius)
return ext.mask(sites_frac=xrs_p1.sites_frac(),
unit_cell=xrs_p1.unit_cell(),
n_real=n_real,
mask_value_inside_molecule=mask_value_inside_molecule,
mask_value_outside_molecule=mask_value_outside_molecule,
radii=atom_radii + solvent_radius)
def __init__(
self,
xray_structure,
p1,
solvent_radius,
shrink_truncation_radius,
for_structure_factors,
n_real):
xrs = xray_structure
if(p1): xrs = xrs.expand_to_p1(sites_mod_positive=True)
atom_radii = vdw_radii_from_xray_structure(xray_structure = xrs)
self.asu_mask = mmtbx.masks.atom_mask(
unit_cell = xrs.unit_cell(),
space_group = xrs.space_group(),
gridding_n_real = n_real,
solvent_radius = solvent_radius,
shrink_truncation_radius = shrink_truncation_radius)
self.asu_mask.compute(xrs.sites_frac(), atom_radii)
self.mask_data = self.asu_mask.mask_data_whole_uc()
if(for_structure_factors):
self.mask_data = self.mask_data / xrs.space_group().order_z()
def __init__(self,
xray_structure,
ignore_zero_occupancy_atoms,
solvent_radius,
shrink_truncation_radius,
ignore_hydrogen_atoms=True,
gridding_n_real=None,
grid_step=None,
atom_radii=None):
global number_of_mask_calculations
number_of_mask_calculations += 1
assert [gridding_n_real, grid_step].count(None) == 1
self.xray_structure = xray_structure
if (gridding_n_real is None):
gridding_n_real = maptbx.crystal_gridding(
unit_cell=xray_structure.unit_cell(), step=grid_step).n_real()
if (atom_radii is None):
atom_radii = vdw_radii_from_xray_structure(
xray_structure=self.xray_structure)
sites_frac = xray_structure.sites_frac()
self.n_atoms_excluded = 0
selection = flex.bool(xray_structure.scatterers().size(), True)
if (ignore_zero_occupancy_atoms):
selection &= xray_structure.scatterers().extract_occupancies() > 0
if (ignore_hydrogen_atoms):
selection &= (~xray_structure.hd_selection())
sites_frac = sites_frac.select(selection)
atom_radii = atom_radii.select(selection)
self.n_atoms_excluded = selection.count(False)
around_atoms.__init__(
self,
unit_cell=xray_structure.unit_cell(),
space_group_order_z=xray_structure.space_group().order_z(),
sites_frac=sites_frac,
atom_radii=atom_radii,
gridding_n_real=gridding_n_real,
solvent_radius=solvent_radius,
shrink_truncation_radius=shrink_truncation_radius)
introspection.virtual_memory_info().update_max()
def __init__(self,
xray_structure,
ignore_zero_occupancy_atoms,
solvent_radius,
shrink_truncation_radius,
ignore_hydrogen_atoms=True,
gridding_n_real=None,
grid_step=None,
atom_radii=None):
global number_of_mask_calculations
number_of_mask_calculations += 1
assert [gridding_n_real, grid_step].count(None) == 1
self.xray_structure = xray_structure
if (gridding_n_real is None):
gridding_n_real = maptbx.crystal_gridding(
unit_cell=xray_structure.unit_cell(),
step=grid_step).n_real()
if(atom_radii is None):
atom_radii = vdw_radii_from_xray_structure(xray_structure =
self.xray_structure)
sites_frac = xray_structure.sites_frac()
self.n_atoms_excluded = 0
selection = flex.bool(xray_structure.scatterers().size(), True)
if(ignore_zero_occupancy_atoms):
selection &= xray_structure.scatterers().extract_occupancies() > 0
if(ignore_hydrogen_atoms):
selection &= (~xray_structure.hd_selection())
sites_frac = sites_frac.select(selection)
atom_radii = atom_radii.select(selection)
self.n_atoms_excluded = selection.count(False)
around_atoms.__init__(self,
unit_cell = xray_structure.unit_cell(),
space_group_order_z = xray_structure.space_group().order_z(),
sites_frac = sites_frac,
atom_radii = atom_radii,
gridding_n_real = gridding_n_real,
solvent_radius = solvent_radius,
shrink_truncation_radius = shrink_truncation_radius)
introspection.virtual_memory_info().update_max()
def get_f_mask(xrs, ma, step, option=2, r_shrink=None, r_sol=None):
#
result = ma.deep_copy()
sel = ma.d_spacings().data() >= 3
ma = ma.select(sel)
#
crystal_gridding = maptbx.crystal_gridding(
unit_cell=xrs.unit_cell(),
space_group_info=xrs.space_group_info(),
symmetry_flags=maptbx.use_space_group_symmetry,
step=step)
n_real = crystal_gridding.n_real()
atom_radii = vdw_radii_from_xray_structure(xray_structure=xrs)
mask_params = masks.mask_master_params.extract()
grid_step_factor = ma.d_min() / step
if (r_shrink is not None): mask_params.shrink_truncation_radius = r_shrink
if (r_sol is not None): mask_params.solvent_radius = r_sol
mask_params.grid_step_factor = grid_step_factor
# 1
if (option == 1):
asu_mask = ext.atom_mask(
unit_cell=xrs.unit_cell(),
group=xrs.space_group(),
resolution=ma.d_min(),
grid_step_factor=grid_step_factor,
solvent_radius=mask_params.solvent_radius,
shrink_truncation_radius=mask_params.shrink_truncation_radius)
asu_mask.compute(xrs.sites_frac(), atom_radii)
fm_asu = asu_mask.structure_factors(ma.indices())
f_mask = ma.set().array(data=fm_asu)
# 2
elif (option == 2):
asu_mask = ext.atom_mask(
unit_cell=xrs.unit_cell(),
space_group=xrs.space_group(),
gridding_n_real=n_real,
solvent_radius=mask_params.solvent_radius,
shrink_truncation_radius=mask_params.shrink_truncation_radius)
asu_mask.compute(xrs.sites_frac(), atom_radii)
fm_asu = asu_mask.structure_factors(ma.indices())
f_mask = ma.set().array(data=fm_asu)
# 3
elif (option == 3):
mask_p1 = mmtbx.masks.mask_from_xray_structure(
xray_structure=xrs,
p1=True,
for_structure_factors=True,
solvent_radius=mask_params.solvent_radius,
shrink_truncation_radius=mask_params.shrink_truncation_radius,
n_real=n_real,
in_asu=False).mask_data
maptbx.unpad_in_place(map=mask_p1)
mask = asu_map_ext.asymmetric_map(
xrs.crystal_symmetry().space_group().type(), mask_p1).data()
f_mask = ma.structure_factors_from_asu_map(asu_map_data=mask,
n_real=n_real)
# 4
elif (option == 4):
f_mask = masks.bulk_solvent(
xray_structure=xrs,
ignore_zero_occupancy_atoms=False,
solvent_radius=mask_params.solvent_radius,
shrink_truncation_radius=mask_params.shrink_truncation_radius,
ignore_hydrogen_atoms=False,
grid_step=step,
atom_radii=atom_radii).structure_factors(miller_set=ma)
elif (option == 5):
o = mmtbx.masks.bulk_solvent(
xray_structure=xrs,
ignore_zero_occupancy_atoms=False,
solvent_radius=mask_params.solvent_radius,
shrink_truncation_radius=mask_params.shrink_truncation_radius,
ignore_hydrogen_atoms=False,
gridding_n_real=n_real,
atom_radii=atom_radii)
assert approx_equal(n_real, o.data.accessor().all())
f_mask = o.structure_factors(ma)
elif (option == 6):
# XXX No control over n_real, so results with others don't match
mask_manager = masks.manager(miller_array=ma,
miller_array_twin=None,
mask_params=mask_params)
f_mask = mask_manager.shell_f_masks(xray_structure=xrs,
force_update=True)[0]
else:
assert 0
#
data = flex.complex_double(result.indices().size(), 0)
data = data.set_selected(sel, f_mask.data())
result = result.array(data=data)
return result
def __init__(self,
xray_structure,
mask_params=None,
d_min=None,
atom_radius=None):
"""
If d_min is not None then it defines the gridding. Otherwise mask_params is
used for that.
"""
adopt_init_args(self, locals())
if (mask_params is None):
mask_params = mmtbx.masks.mask_master_params.extract()
self.mask_params = mask_params
if (d_min is not None):
assert mask_params.grid_step_factor is not None
assert [mask_params.step, mask_params.n_real].count(None) in [1, 2]
assert mask_params.step is not None or mask_params.n_real is not None or \
[d_min, mask_params.grid_step_factor].count(None)==0
if (atom_radius is None):
self.atom_radii = vdw_radii_from_xray_structure(
xray_structure=self.xray_structure)
else:
self.atom_radii = flex.double(
self.xray_structure.scatterers().size(), atom_radius)
if (mask_params.step is not None):
crystal_gridding = maptbx.crystal_gridding(
unit_cell=self.xray_structure.unit_cell(),
space_group_info=self.xray_structure.space_group_info(),
symmetry_flags=maptbx.use_space_group_symmetry,
step=mask_params.step)
self.n_real = crystal_gridding.n_real()
else:
self.n_real = mask_params.n_real
if (d_min is not None):
self.asu_mask = atom_mask(
unit_cell=self.xray_structure.unit_cell(),
group=self.xray_structure.space_group(),
resolution=self.d_min,
grid_step_factor=self.mask_params.grid_step_factor,
solvent_radius=self.mask_params.solvent_radius,
shrink_truncation_radius=self.mask_params.
shrink_truncation_radius)
else:
self.asu_mask = atom_mask(
unit_cell=self.xray_structure.unit_cell(),
space_group=self.xray_structure.space_group(),
gridding_n_real=self.n_real,
solvent_radius=self.mask_params.solvent_radius,
shrink_truncation_radius=self.mask_params.
shrink_truncation_radius)
sites_frac = self.xray_structure.sites_frac()
if (self.mask_params.n_radial_shells > 1):
# number of shell radii is one less than number of shells
# last shell is of unknown radius
shell_rads = [self.mask_params.radial_shell_width] * \
(self.mask_params.n_radial_shells-1)
# TODO: Should first shell width be:
shell_rads[0] -= self.mask_params.solvent_radius
if (shell_rads[0] < 0.):
shell_rads[0] = 0.
self.asu_mask.compute(sites_frac, self.atom_radii, shell_rads)
else:
self.asu_mask.compute(sites_frac, self.atom_radii)
def get_f_mask(xrs, ma, step, option=2):
crystal_gridding = maptbx.crystal_gridding(
unit_cell=xrs.unit_cell(),
space_group_info=xrs.space_group_info(),
symmetry_flags=maptbx.use_space_group_symmetry,
step=step)
n_real = crystal_gridding.n_real()
atom_radii = vdw_radii_from_xray_structure(xray_structure=xrs)
mask_params = masks.mask_master_params.extract()
grid_step_factor = ma.d_min() / step
# 1
if (option == 1):
asu_mask = ext.atom_mask(
unit_cell=xrs.unit_cell(),
group=xrs.space_group(),
resolution=ma.d_min(),
grid_step_factor=grid_step_factor,
solvent_radius=mask_params.solvent_radius,
shrink_truncation_radius=mask_params.shrink_truncation_radius)
asu_mask.compute(xrs.sites_frac(), atom_radii)
fm_asu = asu_mask.structure_factors(ma.indices())
f_mask = ma.set().array(data=fm_asu)
# 2
elif (option == 2):
asu_mask = ext.atom_mask(
unit_cell=xrs.unit_cell(),
space_group=xrs.space_group(),
gridding_n_real=n_real,
solvent_radius=mask_params.solvent_radius,
shrink_truncation_radius=mask_params.shrink_truncation_radius)
asu_mask.compute(xrs.sites_frac(), atom_radii)
fm_asu = asu_mask.structure_factors(ma.indices())
f_mask = ma.set().array(data=fm_asu)
# 3
elif (option == 3):
mask_params.grid_step_factor = grid_step_factor
mask_manager = masks.manager(miller_array=ma,
miller_array_twin=None,
mask_params=mask_params)
f_mask = mask_manager.shell_f_masks(xray_structure=xrs,
force_update=True)[0]
# 4
elif (option == 4):
mask_p1 = mmtbx.masks.mask_from_xray_structure(
xray_structure=xrs,
p1=True,
for_structure_factors=True,
n_real=n_real,
in_asu=False).mask_data
maptbx.unpad_in_place(map=mask_p1)
mask = asu_map_ext.asymmetric_map(
xrs.crystal_symmetry().space_group().type(), mask_p1).data()
f_mask = ma.structure_factors_from_asu_map(asu_map_data=mask,
n_real=n_real)
elif (option == 5):
o = mmtbx.masks.bulk_solvent(
xray_structure=xrs,
ignore_zero_occupancy_atoms=False,
solvent_radius=mask_params.solvent_radius,
shrink_truncation_radius=mask_params.shrink_truncation_radius,
ignore_hydrogen_atoms=False,
gridding_n_real=n_real,
atom_radii=atom_radii)
f_mask = o.structure_factors(ma)
else:
assert 0
#
return f_mask