def get_map_model_managers(): # Set up source data from iotbx.map_model_manager import map_model_manager mmm = map_model_manager() mmm.generate_map(wrapping=True) second_model=mmm.model().deep_copy() mmm.box_all_maps_around_model_and_shift_origin() mmm.map_manager().set_wrapping(False) mmm.set_log(sys.stdout) #now get a second one from scitbx import matrix r=matrix.sqr((-0.8090,0.5878,0.0000, -0.5878,-0.8090,-0.0000, 0.0000,-0.0000,1.0000,)) t = matrix.col((100,0,0)) new_sites_cart = r.elems*mmm.model().get_sites_cart() + t.elems second_model.set_sites_cart(new_sites_cart) from cctbx.maptbx.box import shift_and_box_model second_model = shift_and_box_model(second_model) second_mmm = map_model_manager(model=second_model) second_mmm.generate_map(model=second_model,wrapping=True) second_mmm.box_all_maps_around_model_and_shift_origin(box_cushion=10) second_mmm.map_manager().set_wrapping(False) second_mmm.set_log(sys.stdout) print(mmm.model().get_sites_cart()[0]) print(second_mmm.model().get_sites_cart()[0]) return mmm, second_mmm
def get_random_structure_and_map(
use_static_structure=False,
random_seed=171413,
):
if use_static_structure:
mmm = map_model_manager()
mmm.generate_map()
return group_args(model=mmm.model(), mm=mmm.map_manager())
import random
random.seed(random_seed)
i = random.randint(1, 714717)
flex.set_random_seed(i)
xrs = random_structure.xray_structure(
space_group_info=space_group_info(19),
volume_per_atom=25.,
elements=('C', 'N', 'O', 'H') * 10,
min_distance=1.5)
fc = xrs.structure_factors(d_min=2).f_calc()
fft_map = fc.fft_map(resolution_factor=0.25)
fft_map.apply_volume_scaling()
ph = iotbx.pdb.input(source_info=None,
lines=xrs.as_pdb_file()).construct_hierarchy()
ph.atoms().set_xyz(xrs.sites_cart())
map_data = fft_map.real_map_unpadded()
mm = map_manager(unit_cell_grid=map_data.accessor().all(),
unit_cell_crystal_symmetry=fc.crystal_symmetry(),
origin_shift_grid_units=(0, 0, 0),
map_data=map_data)
model = mmtbx.model.manager(model_input=None,
pdb_hierarchy=ph,
crystal_symmetry=fc.crystal_symmetry())
return group_args(model=model, mm=mm)
def read_map_and_model(file_name_1, file_name_2):
'''
Identify which file is map and which is model, read in and
create map_model_manager
'''
map_file_name = None
model_file_name = None
for f in [file_name_1, file_name_2]:
for ending in ['.ccp4', '.mrc', '.map']:
if f.endswith(ending):
map_file_name = f
for ending in ['.pdb', '.cif']:
if f.endswith(ending):
model_file_name = f
if not map_file_name or not model_file_name:
raise Sorry("Unable to identify map and model from %s and %s" %
(file_name_1, file_name_2))
from iotbx.data_manager import DataManager
from iotbx.map_model_manager import map_model_manager
dm = DataManager()
dm.process_real_map_file(map_file_name)
mm = dm.get_real_map(map_file_name)
dm.process_model_file(model_file_name)
model = dm.get_model(model_file_name)
mam = map_model_manager(model=model, map_manager=mm)
return mam
def run(args, log=sys.stdout):
print("-"*79, file=log)
print(legend, file=log)
print("-"*79, file=log)
inputs = mmtbx.utils.process_command_line_args(args = args,
master_params = master_params(),
suppress_symmetry_related_errors = True)
params = inputs.params.extract()
# model
broadcast(m="Input PDB:", log=log)
file_names = inputs.pdb_file_names
if(len(file_names) != 1): raise Sorry("PDB file has to given.")
from iotbx.data_manager import DataManager
dm = DataManager()
dm.set_overwrite(True)
model = dm.get_model(file_names[0])
# map
broadcast(m="Input map:", log=log)
if(inputs.ccp4_map is None): raise Sorry("Map file has to given.")
from iotbx.map_model_manager import map_model_manager
mam = map_model_manager(model = model, map_manager = inputs.ccp4_map,
wrapping = params.wrapping,
ignore_symmetry_conflicts = params.ignore_symmetry_conflicts)
mam.model().setup_scattering_dictionaries(
scattering_table=params.scattering_table)
mam.model().get_xray_structure().show_summary(f=log, prefix=" ")
inputs.ccp4_map.show_summary(prefix=" ")
# estimate resolution
d_min = params.resolution
if(d_min is None):
raise Sorry("Map resolution must be given.")
print(" d_min: %6.4f"%d_min, file=log)
#
result_obj = compdiff(
map_data_obs = mam.map_manager().map_data(), # NOTE this will always wrap map
xrs = mam.model().get_xray_structure(),
d_min = d_min,
vector_map = False)
output_map_manager=mam.map_manager().customized_copy(
map_data=result_obj.map_result)
dm.write_real_map_file(output_map_manager, "map_model_difference_1.ccp4")
#
result_obj = compdiff(
map_data_obs = mam.map_manager().map_data(),
xrs = mam.model().get_xray_structure(),
d_min = d_min,
vector_map = True)
output_map_manager=mam.map_manager().customized_copy(
map_data=result_obj.map_result)
dm.write_real_map_file(output_map_manager, "map_model_difference_2.ccp4")
def test_01(method='model_sharpen', expected_results=None):
# Source data
data_dir = os.path.dirname(os.path.abspath(__file__))
data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4')
data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_model.pdb')
data_ncs_spec = os.path.join(data_dir, 'data',
'non_zero_origin_ncs_spec.ncs_spec')
# Read in data
dm = DataManager(['ncs_spec', 'model', 'real_map', 'phil'])
dm.set_overwrite(True)
map_file = data_ccp4
dm.process_real_map_file(map_file)
mm = dm.get_real_map(map_file)
model_file = data_pdb
dm.process_model_file(model_file)
model = dm.get_model(model_file)
ncs_file = data_ncs_spec
dm.process_ncs_spec_file(ncs_file)
ncs = dm.get_ncs_spec(ncs_file)
mmm = map_model_manager(model=model,
map_manager_1=mm.deep_copy(),
map_manager_2=mm.deep_copy(),
ncs_object=ncs,
wrapping=False)
mmm.add_map_manager_by_id(map_id='external_map',
map_manager=mmm.map_manager().deep_copy())
mmm.set_resolution(3)
mmm.set_log(sys.stdout)
dc = mmm.deep_copy()
sharpen_method = getattr(mmm, method)
# sharpen by method (can be model_sharpen, half_map_sharpen or
# external_sharpen)
mmm = dc.deep_copy()
sharpen_method(anisotropic_sharpen=False, n_bins=10)
assert mmm.map_model_cc() > 0.9
sharpen_method(anisotropic_sharpen=False, n_bins=10, local_sharpen=True)
assert mmm.map_model_cc() > 0.9
sharpen_method(anisotropic_sharpen=True, n_bins=10)
assert mmm.map_model_cc() > 0.9
sharpen_method(anisotropic_sharpen=True,
n_bins=10,
local_sharpen=True,
n_boxes=1)
assert mmm.map_model_cc() > 0.9
def as_map_model_manager(self):
'''
Return map_model_manager object with contents of this class (not a deepcopy)
'''
from iotbx.map_model_manager import map_model_manager
mmm = map_model_manager(
map_manager=self.map_manager(),
model=self.model(),
)
# Keep track of the gridding in this boxing.
mmm.set_gridding_first(self.gridding_first)
mmm.set_gridding_last(self.gridding_last)
return mmm
def validate(self):
assert not None in [self.model, self.params, self.out]
if (self.model is None):
raise Sorry("Model is required.")
if (self.miller_array is None and self.map_inp is None):
raise Sorry("Map or map coefficients are required.")
# Sanity check for crystal symmetry
if (self.map_inp is not None and self.model is not None):
self.base = map_model_manager(map_manager=self.map_inp,
model=self.model,
ignore_symmetry_conflicts=self.
params.ignore_symmetry_conflicts)
self.cs_consensus = self.base.crystal_symmetry()
else:
self.base = None
def read_map_and_model(file_name_1,
file_name_2,
regression_directory=None,
prefix=None):
'''
Identify which file is map and which is model, read in and
create map_model_manager
If regression_directory is specified, look there for these files, assuming
prefix of $PHENIX/modules/phenix_regression/
'''
if regression_directory and not prefix:
import libtbx.load_env
prefix = libtbx.env.under_dist(module_name="phenix_regression",
path=regression_directory,
test=os.path.isdir)
if prefix:
file_name_1 = os.path.join(prefix, file_name_1)
file_name_2 = os.path.join(prefix, file_name_2)
map_file_name = None
model_file_name = None
for f in [file_name_1, file_name_2]:
for ending in ['.ccp4', '.mrc', '.map']:
if f.endswith(ending):
map_file_name = f
for ending in ['.pdb', '.cif']:
if f.endswith(ending):
model_file_name = f
if not map_file_name or not model_file_name:
raise Sorry("Unable to guess map and model from %s and %s" %
(file_name_1, file_name_2))
from iotbx.data_manager import DataManager
from iotbx.map_model_manager import map_model_manager
dm = DataManager()
dm.process_real_map_file(map_file_name)
mm = dm.get_real_map(map_file_name)
dm.process_model_file(model_file_name)
model = dm.get_model(model_file_name)
mam = map_model_manager(model=model, map_manager=mm)
return mam
def tst_01():
print (" test utilities in create_models_or_maps")
flex.set_random_seed(0)
random.seed(0)
model=generate_model()
assert approx_equal (
model.get_sites_cart()[0],
(14.476, 10.57, 8.342))
s_model=shake_model(model,shake=2)
assert approx_equal (
s_model.get_sites_cart()[0],
(14.162085804614943, 11.403509966523153, 6.450881839681677))
map_coeffs=generate_map_coefficients(model=model)
assert approx_equal(map_coeffs.data()[0],
(3.70494534745-0.185333495539j))
map_manager=generate_map(map_coeffs=map_coeffs)
mm_2= generate_map(map_coeffs=map_coeffs,
d_min=3.5,
gridding=map_manager.map_data().all(),
wrapping=True,
origin_shift_grid_units=(100,0,0),
low_resolution_fourier_noise_fraction=1,
high_resolution_fourier_noise_fraction=1,
low_resolution_real_space_noise_fraction=1,
high_resolution_real_space_noise_fraction=1,
)
assert approx_equal (mm_2.map_data()[323], -0.00339192976463)
mm_2.shift_origin()
model.set_shift_cart(mm_2.shift_cart())
mam=map_model_manager(map_manager=mm_2,model=model)
mam.write_map('map.mrc')
mam.write_model('model.pdb')
new_mam=read_map_and_model('map.mrc','model.pdb')
new_mam_2=read_map_and_model('model.pdb','map.mrc')
assert new_mam.map_manager().cc_to_other_map_manager(new_mam_2.map_manager())==1
def get_polder_diff_map(self, f_obs, r_free_flags, f_calc, f_mask,
model_selected, box_cushion):
fmodel = mmtbx.f_model.manager(f_obs=f_obs,
r_free_flags=r_free_flags,
f_calc=f_calc,
f_mask=f_mask)
fmodel.update_all_scales(remove_outliers=False)
mc_diff = map_tools.electron_density_map(
fmodel=fmodel).map_coefficients(map_type="mFo-DFc",
isotropize=True,
fill_missing=False)
fft_map = miller.fft_map(crystal_gridding=self.crystal_gridding,
fourier_coefficients=mc_diff)
fft_map.apply_sigma_scaling()
mm = fft_map.as_map_manager()
from iotbx.map_model_manager import map_model_manager
inputs = map_model_manager(
model=model_selected.deep_copy(),
map_manager=mm,
) # no need to allow ignore_symmetry_conflicts
return inputs
def run():
result = flex.bool()
for sgn in range(1, 231):
group = space_group_info(sgn)
xrs = random_structure.xray_structure(space_group_info=group,
volume_per_atom=25.,
general_positions_only=False,
elements=('C', 'N', 'O', 'H') *
30,
min_distance=1.0)
sgt = xrs.space_group().type()
fc = xrs.structure_factors(d_min=2).f_calc()
fft_map = fc.fft_map(symmetry_flags=maptbx.use_space_group_symmetry,
resolution_factor=1. / 3)
map_data = fft_map.real_map_unpadded()
n_real = map_data.all()
mm = iotbx.map_manager.map_manager(
map_data=map_data,
unit_cell_grid=map_data.accessor().all(),
unit_cell_crystal_symmetry=xrs.crystal_symmetry(),
origin_shift_grid_units=[0, 0, 0],
wrapping=True)
assert mm.is_consistent_with_wrapping() in [True, None]
assert mm.map_data().all() == n_real
new_mm = mm.as_full_size_map()
assert new_mm.map_data().all() == n_real
# Now cut off edges and should not work:
from iotbx.map_model_manager import map_model_manager
mmm = map_model_manager(map_manager=mm)
upper_bounds = tuple([x - 1 for x in mm.map_data().all()])
mmm.box_all_maps_with_bounds_and_shift_origin(
lower_bounds=(1, 1, 1), upper_bounds=upper_bounds)
mm = mmm.map_manager()
assert mm.is_consistent_with_wrapping() in [None, False]
assert mm.map_data().all() != n_real
new_mm = mm.as_full_size_map()
assert new_mm.map_data().all() == n_real
def exercise(file_name, out=sys.stdout):
# Set up source data
if not os.path.isfile(file_name):
raise Sorry("Missing the file: %s" % (file_name) + "\n")
print("Reading from %s" % (file_name))
from iotbx.map_manager import map_manager
m = map_manager(file_name)
# make a little model
sites_cart = flex.vec3_double(((8, 10, 12), (14, 15, 16)))
model = model_manager.from_sites_cart(
atom_name=' CA ',
resname='ALA',
chain_id='A',
b_iso=30.,
occ=1.,
scatterer='C',
sites_cart=sites_cart,
crystal_symmetry=m.crystal_symmetry())
# make a map_model_manager with lots of maps and model and ncs
from iotbx.map_model_manager import map_model_manager
from mmtbx.ncs.ncs import ncs
ncs_object = ncs()
ncs_object.set_unit_ncs()
mask_mm = m.deep_copy()
mask_mm.set_is_mask(True)
mam = map_model_manager(
map_manager=m,
ncs_object=ncs_object,
map_manager_1=m.deep_copy(),
map_manager_2=m.deep_copy(),
extra_map_manager_list=[m.deep_copy(),
m.deep_copy(),
m.deep_copy()],
extra_map_manager_id_list=["extra_1", "extra_2", "map_manager_mask"],
model=model.deep_copy(),
)
print(mam.map_manager())
print(mam.model())
print(mam.map_manager_1())
print(mam.map_manager_2())
print(mam.map_manager_mask())
print(mam.map_manager().ncs_object())
all_map_names = mam.map_id_list()
for id in all_map_names:
print("Map_manager %s: %s " % (id, mam.get_map_manager_by_id(id)))
dm = DataManager(['model', 'miller_array', 'real_map', 'phil', 'ncs_spec'])
dm.set_overwrite(True)
# Create a model with ncs
from iotbx.regression.ncs.tst_ncs import pdb_str_5
file_name = 'tst_mam.pdb'
f = open(file_name, 'w')
print(pdb_str_5, file=f)
f.close()
# Generate map data from this model (it has ncs)
mmm = map_model_manager()
mmm.generate_map(box_cushion=0, file_name=file_name, n_residues=500)
ncs_mam = mmm.deep_copy()
ncs_mam_copy = mmm.deep_copy()
# Make sure this model has 126 sites (42 sites times 3-fold ncs)
assert ncs_mam.model().get_sites_cart().size() == 126
assert approx_equal(ncs_mam.model().get_sites_cart()[0],
(23.560999999999996, 8.159, 10.660000000000002))
# Get just unique part (42 sites)
unique_mam = ncs_mam.extract_all_maps_around_model(
select_unique_by_ncs=True)
assert unique_mam.model().get_sites_cart().size() == 42
assert approx_equal(unique_mam.model().get_sites_cart()[0],
(18.740916666666664, 13.1794, 16.10544))
# Make sure that the extraction did not change the original but does change
# the extracted part
assert (unique_mam.model().get_sites_cart()[0] !=
ncs_mam.model().get_sites_cart()[0]
) # it was a deep copy so original stays
# Shift back the extracted part and make sure it matches the original now
shifted_back_unique_model = mmm.get_model_from_other(
unique_mam.deep_copy())
assert approx_equal(shifted_back_unique_model.get_sites_cart()[0],
(23.560999999999996, 8.158999999999997, 10.66))
# Change the extracted model
sites_cart = unique_mam.model().get_sites_cart()
sites_cart[0] = (1, 1, 1)
unique_mam.model().get_hierarchy().atoms().set_xyz(sites_cart)
# Note; setting xyz in hierarchy does not set xrs by itself. do that now:
unique_mam.model().set_sites_cart_from_hierarchy(multiply_ncs=False)
# Make sure we really changed it
assert approx_equal(unique_mam.model().get_sites_cart()[0], (1, 1, 1))
# Now propagate all the changes in this unique part to entire original model
# using NCS
ncs_mam.propagate_model_from_other(other=unique_mam,
model_id='model',
other_model_id='model')
# ...and check that copy 1 and copy 2 both change
assert approx_equal(
ncs_mam.model().get_sites_cart()[0],
(5.820083333333333, -4.020400000000001, -4.445440000000001))
assert approx_equal(
ncs_mam.model().get_sites_cart()[42],
(38.41904613024224, 17.233251085893276, 2.5547442135142524))
# Find ncs from map or model
nn = ncs_mam_copy
nn.write_map('ncs.ccp4')
nn.write_model('ncs.pdb')
ncs_object = nn.get_ncs_from_model()
dm.write_ncs_spec_file(ncs_object, 'ncs.ncs_spec')
print("NCS from map", ncs_object)
nn.set_ncs_object(ncs_object)
print("NCS now: ", nn.ncs_object())
nn.get_ncs_from_map(ncs_object=ncs_object)
print("ncs cc:", nn.ncs_cc())
assert approx_equal(nn.ncs_cc(), 0.961915979834, eps=0.01)
# Make a deep_copy
dc = mam.deep_copy()
new_mam = mam.deep_copy()
assert mam.map_manager().map_data()[0] == new_mam.map_manager().map_data(
)[0]
# Make a customized_copy
new_mam = mam.customized_copy(model_dict={'model': mam.model()})
assert new_mam.model() is mam.model()
assert not new_mam.map_dict() is mam.map_dict()
new_mam = mam.customized_copy(model_dict={'model': mam.model()},
map_dict=mam.map_dict())
assert new_mam.model() is mam.model()
assert new_mam.map_dict() is mam.map_dict()
print(mam)
# Add a map
mam = dc.deep_copy()
print(mam.map_id_list())
assert len(mam.map_id_list()) == 6
mam.add_map_manager_by_id(mam.map_manager().deep_copy(), 'new_map_manager')
print(mam.map_id_list())
assert len(mam.map_id_list()) == 7
# duplicate a map
mam = dc.deep_copy()
print(mam.map_id_list())
assert len(mam.map_id_list()) == 6
mam.duplicate_map_manager('map_manager', 'new_map_manager')
print(mam.map_id_list())
assert len(mam.map_id_list()) == 7
# resolution_filter a map
mam = dc.deep_copy()
print(mam.map_id_list())
mam.duplicate_map_manager('map_manager', 'new_map_manager')
mam.resolution_filter(map_id='new_map_manager', d_min=3.5, d_max=6)
# Add a model
mam = dc.deep_copy()
print(mam.model_id_list())
assert len(mam.model_id_list()) == 1
mam.add_model_by_id(mam.model().deep_copy(), 'new_model')
print(mam.model_id_list())
assert len(mam.model_id_list()) == 2
# Initialize a map
mam1 = new_mam.deep_copy()
mam1.initialize_maps(map_value=6)
assert mam1.map_manager().map_data()[225] == 6
# Create mask around density and apply to all maps
mam1 = new_mam.deep_copy()
mam1.mask_all_maps_around_density(
solvent_content=0.5,
soft_mask=True,
)
s = (mam1.get_map_manager_by_id('mask').map_data() > 0.5)
assert approx_equal((s.count(True), s.size()), (1024, 2048))
# Create mask around edges and apply to all maps
mam1 = new_mam.deep_copy()
mam1.mask_all_maps_around_edges()
s = (mam1.get_map_manager_by_id('mask').map_data() > 0.5)
assert approx_equal((s.count(True), s.size()), (1176, 2048))
# Create a soft mask around model and apply to all maps
new_mam.mask_all_maps_around_atoms(mask_atoms_atom_radius=8,
soft_mask=True)
s = (new_mam.get_map_manager_by_id('mask').map_data() > 0.5)
assert approx_equal((s.count(True), s.size()), (1944, 2048))
# Create a soft mask around model and do not do anything with it
new_mam.create_mask_around_atoms(mask_atoms_atom_radius=8, soft_mask=True)
s = (new_mam.get_map_manager_by_id('mask').map_data() > 0.5)
assert approx_equal((s.count(True), s.size()), (1944, 2048))
# Create a soft mask around model and do not do anything with it, wrapping =true
dummy_mam = new_mam.deep_copy()
dummy_mam.map_manager().set_wrapping(True)
dummy_mam.create_mask_around_atoms(mask_atoms_atom_radius=8,
soft_mask=True)
s = (dummy_mam.get_map_manager_by_id('mask').map_data() > 0.5)
assert approx_equal((s.count(True), s.size()), (1944, 2048))
# Create a sharp mask around model and do not do anything with it
new_mam.create_mask_around_atoms(soft_mask=False, mask_atoms_atom_radius=8)
s = (new_mam.get_map_manager_by_id('mask').map_data() > 0.5)
assert approx_equal((s.count(True), s.size()), (138, 2048))
# Mask around edges and do not do anything with it
mam = dc.deep_copy()
mam.create_mask_around_edges()
s = (mam.get_map_manager_by_id('mask').map_data() > 0.5)
assert approx_equal((s.count(True), s.size()), (1176, 2048))
# Mask around density and to not do anything with it
mam = dc.deep_copy()
mam.create_mask_around_density(soft_mask=False)
s = (mam.get_map_manager_by_id('mask').map_data() > 0.5)
assert approx_equal((s.count(True), s.size()), (1000, 2048))
# Apply the current mask to one map
mam.apply_mask_to_map('map_manager')
s = (mam.map_manager().map_data() > 0.)
assert approx_equal((s.count(True), s.size()), (640, 2048))
s = (mam.map_manager().map_data() != 0.)
assert approx_equal((s.count(True), s.size()), (1000, 2048))
assert approx_equal((mam.map_manager().map_data()[225]), -0.0418027862906)
# Apply any mask to one map
mam.apply_mask_to_map('map_manager', mask_id='mask')
s = (mam.map_manager().map_data() > 0.)
assert approx_equal((s.count(True), s.size()), (640, 2048))
s = (mam.map_manager().map_data() != 0.)
assert approx_equal((s.count(True), s.size()), (1000, 2048))
assert approx_equal((mam.map_manager().map_data()[225]), -0.0418027862906)
# Apply the mask to all maps
mam.apply_mask_to_maps()
s = (mam.map_manager().map_data() > 0.)
assert approx_equal((s.count(True), s.size()), (640, 2048))
s = (mam.map_manager().map_data() != 0.)
assert approx_equal((s.count(True), s.size()), (1000, 2048))
assert approx_equal((mam.map_manager().map_data()[225]), -0.0418027862906)
# Apply the mask to all maps, setting outside value to mean inside
mam.apply_mask_to_maps(set_outside_to_mean_inside=True)
s = (mam.map_manager().map_data() > 0.)
assert approx_equal((s.count(True), s.size()), (1688, 2048))
s = (mam.map_manager().map_data() != 0.)
assert approx_equal((s.count(True), s.size()), (2048, 2048))
assert approx_equal((mam.map_manager().map_data()[2047]), -0.0759598612785)
s = (mam.get_map_manager_by_id('mask').map_data() > 0).as_1d()
inside = mam.map_manager().map_data().as_1d().select(s)
outside = mam.map_manager().map_data().as_1d().select(~s)
assert approx_equal(
(inside.min_max_mean().max, outside.min_max_mean().max),
(0.335603952408, 0.0239064293122))
# Make a new map and model, get mam and box with selection
mmm = map_model_manager()
mmm.generate_map(box_cushion=0, wrapping=True)
mam = mmm
mam_dc = mam.deep_copy()
new_mm_1 = mam.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()),
((18, 25, 20), (18, 25, 20)))
# Get local fsc or randomized map
dc = mam_dc.deep_copy()
dc.map_manager().set_wrapping(False)
map_coeffs = dc.map_manager().map_as_fourier_coefficients(d_min=3)
from cctbx.development.create_models_or_maps import generate_map
new_mm_1 = generate_map(map_coeffs=map_coeffs,
d_min=3,
low_resolution_real_space_noise_fraction=1,
high_resolution_real_space_noise_fraction=50,
map_manager=dc.map_manager(),
random_seed=124321)
new_mm_2 = generate_map(map_coeffs=map_coeffs,
d_min=3,
low_resolution_real_space_noise_fraction=1,
high_resolution_real_space_noise_fraction=50,
map_manager=dc.map_manager(),
random_seed=734119)
dc.add_map_manager_by_id(new_mm_1, 'map_manager_1')
dc.add_map_manager_by_id(new_mm_2, 'map_manager_2')
cc = dc.map_map_cc()
fsc_curve = dc.map_map_fsc()
dc.set_log(sys.stdout)
dc.local_fsc(n_boxes=1)
# Get map-map FSC
dc = mam_dc.deep_copy()
dc.duplicate_map_manager(map_id='map_manager', new_map_id='filtered')
dc.resolution_filter(d_min=3.5, d_max=10, map_id='filtered')
dc.create_mask_around_atoms()
fsc_curve = dc.map_map_fsc(map_id_1='map_manager',
map_id_2='filtered',
mask_id='mask',
resolution=3.5,
fsc_cutoff=0.97)
assert approx_equal(fsc_curve.d_min, 3.91175024213, eps=0.01)
assert approx_equal(fsc_curve.fsc.fsc[-1], 0.695137718033)
# Get map-map CC
dc = mam_dc.deep_copy()
dc.duplicate_map_manager(map_id='map_manager', new_map_id='filtered')
dc.resolution_filter(d_min=3.5, d_max=6, map_id='filtered')
cc = dc.map_map_cc('map_manager', 'filtered')
assert approx_equal(cc, 0.706499206126)
# Get map-map CC with mask
dc = mam_dc.deep_copy()
dc.duplicate_map_manager(map_id='map_manager', new_map_id='filtered')
dc.create_mask_around_density(mask_id='filtered')
cc = dc.map_map_cc('map_manager', 'filtered', mask_id='mask')
assert approx_equal(cc, 0.411247493741)
# box around model
mam = mam_dc.deep_copy()
mam.box_all_maps_around_model_and_shift_origin(
selection_string="resseq 221:221")
new_mm_1 = mam.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()),
((18, 25, 20), (24, 20, 20)))
# extract_around_model (get new mam)
new_mam_dc = mam_dc.extract_all_maps_around_model(
selection_string="resseq 221:221")
new_mm_1a = new_mam_dc.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1a.map_data().all()),
((18, 25, 20), (24, 20, 20)))
assert approx_equal(new_mm_1.map_data(), new_mm_1a.map_data())
# box around_density
mam2 = mam_dc.deep_copy()
mam2.box_all_maps_around_density_and_shift_origin(box_cushion=0)
new_mm_2 = mam2.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_2.map_data().all()),
((18, 25, 20), (16, 23, 18)))
# extract_around_density (get new mam)
mam2 = mam_dc.deep_copy()
mam2_b = mam2.extract_all_maps_around_density(box_cushion=0)
new_mm_2 = mam2_b.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_2.map_data().all()),
((18, 25, 20), (16, 23, 18)))
# Repeat as map_model_manager:
mmm = mam_dc.as_map_model_manager().deep_copy()
mmm.box_all_maps_around_model_and_shift_origin(
selection_string="resseq 221:221")
new_mm_1a = mmm.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1a.map_data().all()),
((24, 20, 20), (24, 20, 20)))
assert approx_equal(new_mm_1.map_data(), new_mm_1a.map_data())
# box around density
mam.box_all_maps_around_density_and_shift_origin(box_cushion=0)
new_mm_1 = mam.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()),
((24, 20, 20), (22, 18, 18)))
# extract around density (get new mam)
mam1 = mam_dc.deep_copy()
mam1.extract_all_maps_around_density(box_cushion=0)
new_mm_1 = mam1.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()),
((24, 20, 20), (18, 25, 20)))
# create mask around density, then box around mask (i.e., box around density)
mam.create_mask_around_density(soft_mask=False)
mam.box_all_maps_around_mask_and_shift_origin(box_cushion=3)
new_mm_1 = mam.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()),
((24, 20, 20), (22, 18, 18)))
# box with bounds
mam.box_all_maps_with_bounds_and_shift_origin(lower_bounds=(10, 10, 10),
upper_bounds=(15, 15, 15))
new_mm_1 = mam.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()),
((24, 20, 20), (6, 6, 6)))
# extract with bounds
mam = mam_dc.deep_copy()
mam_1 = mam.extract_all_maps_with_bounds(lower_bounds=(10, 10, 10),
upper_bounds=(15, 15, 15))
new_mm_1 = mam_1.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()),
((24, 20, 20), (6, 6, 6)))
# box with unique
mam = mam_dc.deep_copy()
mam.box_all_maps_around_unique_and_shift_origin(molecular_mass=2500,
resolution=3)
new_mm_1 = mam.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()),
((24, 20, 20), (18, 25, 20)))
# extract with unique
mam = mam_dc.deep_copy()
mam_1 = mam.extract_all_maps_around_unique(molecular_mass=2500,
resolution=3)
new_mm_1 = mam_1.map_manager()
assert approx_equal((mmm.map_data().all(), new_mm_1.map_data().all()),
((24, 20, 20), (18, 25, 20)))
# extract a box and then restore model into same reference as current mam
mam = mam_dc.deep_copy()
mam.box_all_maps_with_bounds_and_shift_origin(lower_bounds=(2, 2, 2),
upper_bounds=(17, 17, 17))
print("mam:",
mam.model().get_sites_cart()[0],
mam.map_manager().origin_is_zero())
# extract a box
box_mam = mam.extract_all_maps_with_bounds(lower_bounds=(10, 10, 10),
upper_bounds=(15, 15, 15))
box_model = box_mam.model()
matched_box_model = mam.get_model_from_other(box_mam)
assert approx_equal(matched_box_model.get_sites_cart()[0],
mam.model().get_sites_cart()[0])
# Convert a map to fourier coefficients
mam = mam_dc.deep_copy()
ma = mam.map_as_fourier_coefficients(d_min=3)
assert approx_equal(ma.d_min(), 3.01655042414)
mam.add_map_from_fourier_coefficients(ma, map_id='new_map_manager')
cc = flex.linear_correlation(
mam.get_map_manager_by_id('map_manager').map_data().as_1d(),
mam.get_map_manager_by_id(
'new_map_manager').map_data().as_1d()).coefficient()
assert (cc >= 0.99)
# Get map-model CC
dc = mam_dc.extract_all_maps_around_model(
selection_string="(name ca or name cb or name c or name o) " +
"and resseq 221:221",
box_cushion=0)
cc = dc.map_model_cc(resolution=3)
assert approx_equal(cc, 0.450025539936)
# Remove model outside map
dc.remove_model_outside_map(boundary=0)
assert (mam_dc.model().get_sites_cart().size(),
dc.model().get_sites_cart().size()) == (86, 4)
# shift a model to match the map
dc = mam_dc.extract_all_maps_around_model(
selection_string="(name ca or name cb or name c or name o) " +
"and resseq 221:221",
box_cushion=0)
actual_model = dc.model().deep_copy()
working_model = dc.model().deep_copy()
working_model.set_shift_cart((0, 0, 0))
working_model.set_sites_cart(working_model.get_sites_cart() -
actual_model.shift_cart())
dc.shift_any_model_to_match(working_model)
assert approx_equal(actual_model.get_sites_cart()[0],
working_model.get_sites_cart()[0])
def exercise_around_model():
from cctbx.maptbx.box import make_list_symmetric
a = [3, 4, 5, 3, 9, 1, 6, 3, 2, 5, 6, 6]
new_a = make_list_symmetric(a)
from scitbx.array_family import flex
aa = flex.double(a)
new_aa = flex.double(new_a)
assert (aa.size(), new_aa.size()) == (12, 12)
assert aa.min_max_mean().mean == new_aa.min_max_mean().mean
print(a, new_a)
a = [3, 4, 5, 3, 8, 1, 6, 7, 3, 2, 5, 6, 6]
new_a = make_list_symmetric(a)
from scitbx.array_family import flex
aa = flex.double(a)
new_aa = flex.double(new_a)
print(a, new_a)
assert (aa.size(), new_aa.size()) == (13, 13)
assert aa.min_max_mean().mean == new_aa.min_max_mean().mean
mam = get_random_structure_and_map(use_static_structure=True)
map_data_orig = mam.mm.map_data().deep_copy()
sites_frac_orig = mam.model.get_sites_frac().deep_copy()
sites_cart_orig = mam.model.get_sites_cart().deep_copy()
cs_orig = mam.model.crystal_symmetry()
box = cctbx.maptbx.box.around_model(map_manager=mam.mm,
model=mam.model.deep_copy(),
box_cushion=10,
wrapping=True)
new_mm1 = box.map_manager()
new_mm2 = box.apply_to_map(map_manager=mam.mm.deep_copy())
assert approx_equal(new_mm1.map_data(), new_mm2.map_data())
new_model1 = box.model()
new_model2 = box.apply_to_model(model=mam.model.deep_copy())
assert new_model1.crystal_symmetry().is_similar_symmetry(
new_model2.crystal_symmetry())
assert new_model1.crystal_symmetry().is_similar_symmetry(
box.crystal_symmetry)
assert approx_equal(new_model1.get_sites_cart()[0],
(19.705233333333336, 15.631525, 13.5040625))
# make sure things did change
assert new_mm2.map_data().size() != map_data_orig.size()
# make sure things are changed in-place and are therefore different from start
assert box.map_manager().map_data().size() != map_data_orig.size()
assert box.model().get_sites_frac() != sites_frac_orig
assert box.model().get_sites_cart() != sites_cart_orig
assert (not cs_orig.is_similar_symmetry(box.model().crystal_symmetry()))
# make sure box, model and map_manager remember original crystal symmetry
assert cs_orig.is_similar_symmetry(
box.map_manager().unit_cell_crystal_symmetry())
assert cs_orig.is_similar_symmetry(
box.map_manager().unit_cell_crystal_symmetry())
assert approx_equal(
box.model().shift_cart(),
[5.229233333333334, 5.061524999999999, 5.162062499999999])
assert box.model().unit_cell_crystal_symmetry().is_similar_symmetry(
cs_orig)
assert (not box.model().crystal_symmetry().is_similar_symmetry(cs_orig))
assert approx_equal(
box.model()._figure_out_hierarchy_to_output(
do_not_shift_back=False).atoms().extract_xyz()[0],
(14.476, 10.57, 8.342))
# make sure we can stack shifts
sel = box.model().selection("resseq 219:219")
m_small = box.model().select(selection=sel)
assert approx_equal(box.model().shift_cart(), m_small.shift_cart())
# Now box again:
small_box = cctbx.maptbx.box.around_model(map_manager=mam.mm,
model=mam.model.deep_copy(),
box_cushion=5,
wrapping=True)
# Make sure nothing was zeroed out in this map (wrapping = True)
assert new_mm1.map_data().as_1d().count(0) == 0
# Now without wrapping...
box = cctbx.maptbx.box.around_model(map_manager=mam.mm,
model=mam.model.deep_copy(),
box_cushion=10,
wrapping=False)
# make sure things are changed in-place and are therefore different from start
assert box.map_manager().map_data().size() != map_data_orig.size()
assert box.model().get_sites_frac() != sites_frac_orig
assert box.model().get_sites_cart() != sites_cart_orig
assert (not cs_orig.is_similar_symmetry(box.model().crystal_symmetry()))
# make sure box, model and map_manager remember original crystal symmetry
assert cs_orig.is_similar_symmetry(
box.model().unit_cell_crystal_symmetry())
assert cs_orig.is_similar_symmetry(
box.map_manager().unit_cell_crystal_symmetry())
assert box.map_manager().map_data().as_1d().count(0) == 81264
# Now specify bounds directly
new_box = cctbx.maptbx.box.with_bounds(map_manager=mam.mm.deep_copy(),
lower_bounds=(-7, -7, -7),
upper_bounds=(37, 47, 39),
wrapping=False)
new_model = new_box.apply_to_model(mam.model.deep_copy())
# make sure things are changed in-place and are therefore different from start
assert new_box.map_manager().map_data().size() != map_data_orig.size()
assert new_model.get_sites_frac() != sites_frac_orig
assert new_model.get_sites_cart() != sites_cart_orig
assert (not cs_orig.is_similar_symmetry(new_model.crystal_symmetry()))
# make sure box, model and map_manager remember original crystal symmetry
assert cs_orig.is_similar_symmetry(
box.model().unit_cell_crystal_symmetry())
assert cs_orig.is_similar_symmetry(
box.map_manager().unit_cell_crystal_symmetry())
assert box.map_manager().map_data().as_1d().count(0) == 81264
# Now specify bounds directly and init with model
box = cctbx.maptbx.box.with_bounds(map_manager=mam.mm.deep_copy(),
lower_bounds=(-7, -7, -7),
upper_bounds=(37, 47, 39),
wrapping=False,
model=mam.model.deep_copy())
new_model = box.model()
# make sure things are changed in-place and are therefore different from start
assert box.map_manager().map_data().size() != map_data_orig.size()
assert new_model.get_sites_frac() != sites_frac_orig
assert new_model.get_sites_cart() != sites_cart_orig
assert (not cs_orig.is_similar_symmetry(new_model.crystal_symmetry()))
# make sure box, model and map_manager remember original crystal symmetry
assert cs_orig.is_similar_symmetry(
box.model().unit_cell_crystal_symmetry())
assert cs_orig.is_similar_symmetry(
box.map_manager().unit_cell_crystal_symmetry())
assert box.map_manager().map_data().as_1d().count(0) == 81264
# Extract using around_unique
data_dir = os.path.dirname(os.path.abspath(__file__))
data_ccp4 = os.path.join(data_dir, 'data', 'D7.ccp4')
data_ncs = os.path.join(data_dir, 'data', 'D7.ncs_spec')
data_seq = os.path.join(data_dir, 'data', 'D7.seq')
dm = DataManager(['real_map', 'phil', 'ncs_spec', 'sequence'])
dm.process_real_map_file(data_ccp4)
mm = dm.get_real_map(data_ccp4)
dm.process_ncs_spec_file(data_ncs)
ncs_obj = dm.get_ncs_spec(data_ncs)
dm.process_sequence_file(data_seq)
sequence = dm.get_sequence(data_seq)
sequence_as_text = sequence[0].sequence
map_model_mgr = map_model_manager(map_manager=mm, ncs_object=ncs_obj)
mm = map_model_mgr.map_manager()
mm.show_summary()
box = cctbx.maptbx.box.around_unique(
map_manager=mm.deep_copy(),
resolution=3,
box_cushion=1,
sequence=sequence_as_text,
soft_mask=True,
wrapping=False,
)
box.map_manager().write_map('new_box.ccp4')
# run again from map_manager
map_model_mgr.box_all_maps_around_unique_and_shift_origin(
resolution=3,
box_cushion=1,
sequence=sequence_as_text,
soft_mask=True,
)
# Get bounds around density
box = cctbx.maptbx.box.around_density(map_manager=mam.mm.deep_copy(),
wrapping=False)
# Create a mask
mm = mam.mm.deep_copy()
mm.create_mask_around_density(
resolution=3,
molecular_mass=2100,
sequence="GAVAGA",
solvent_content=0.5,
)
mask_mm = mm.get_mask_as_map_manager()
assert approx_equal(
(mask_mm.map_data().count(0), mask_mm.map_data().count(1),
mask_mm.map_data().size()), (19184, 19216, 38400))
# Box around the mask
box = cctbx.maptbx.box.around_mask(
map_manager=mam.mm.deep_copy(),
mask_as_map_manager=mask_mm,
wrapping=False,
)
assert (box.gridding_first, box.gridding_last) == ([0, 0, 0], [29, 39, 31])
# Box around the mask with cubic box
box = cctbx.maptbx.box.around_mask(
map_manager=mam.mm.deep_copy(),
mask_as_map_manager=mask_mm,
use_cubic_boxing=True,
wrapping=False,
)
assert (box.gridding_first, box.gridding_last) == ([1, 6, 2], [30, 35, 31])
#
# IF you are about to change this - THINK TWICE!
#
from libtbx.introspection import getfullargspec
r = getfullargspec(cctbx.maptbx.box.around_model.__init__)
assert r.args == [
'self', 'map_manager', 'model', 'box_cushion', 'wrapping',
'model_can_be_outside_bounds', 'stay_inside_current_map',
'use_cubic_boxing', 'require_match_unit_cell_crystal_symmetry', 'log'
], r.args
r = getfullargspec(cctbx.maptbx.box.with_bounds.__init__)
assert r.args == [
'self', 'map_manager', 'lower_bounds', 'upper_bounds', 'model',
'wrapping', 'model_can_be_outside_bounds', 'stay_inside_current_map',
'use_cubic_boxing', 'log'
], r.args
print("OK")
def exercise():
"""Test prepare_map_for_docking using data with known errors."""
# Generate two half-maps with same anisotropic signal, independent anisotropic
# noise. Test to see how well optimal map coefficients are estimated.
# Start by working out how large the padding will have to be so that
# starting automatically-generated map will be large enough to contain
# sphere with room to spare around model.
n_residues = 25
d_min = 2.5
from cctbx.development.create_models_or_maps import generate_model
test_model = generate_model(n_residues=n_residues)
sites_cart = test_model.get_sites_cart()
cart_min = flex.double(sites_cart.min())
cart_max = flex.double(sites_cart.max())
box_centre = (cart_min + cart_max) / 2
dsqrmax = flex.max((sites_cart - tuple(box_centre)).norms())**2
model_radius = math.sqrt(dsqrmax)
min_model_extent = flex.min(cart_max - cart_min)
pad_to_allow_cube = model_radius - min_model_extent / 2
# Extra space needed for eventual masking
boundary_to_smoothing_ratio = 2
soft_mask_radius = d_min
padding = soft_mask_radius * boundary_to_smoothing_ratio
box_cushion = padding + pad_to_allow_cube + d_min # A bit extra
# Make map in box big enough to cut out cube containing sphere
mmm = map_model_manager()
mmm.generate_map(n_residues=n_residues,
d_min=d_min,
k_sol=0.1,
b_sol=50.,
box_cushion=box_cushion)
# Keep copy of perfect map for tests of success
mm_start = mmm.map_manager().deep_copy()
mmm.add_map_manager_by_id(mm_start, 'perfect_map')
model = mmm.model()
sites_cart = model.get_sites_cart()
cart_min = flex.double(sites_cart.min())
cart_max = flex.double(sites_cart.max())
# Turn starting map into map coeffs for the signal
ucpars = mmm.map_manager().unit_cell().parameters()
d_max = max(ucpars[0], ucpars[1], ucpars[2])
start_map_coeffs = mmm.map_as_fourier_coefficients(d_min=d_min,
d_max=d_max)
# Apply anisotropic scaling to map coeffs
b_target = (100., 200., 300., -50., 50., 100.)
u_star_s = adptbx.u_cart_as_u_star(start_map_coeffs.unit_cell(),
adptbx.b_as_u(b_target))
# b_model = (30.,30.,30.,0.,0.,0.) # All atoms in model have B=30
# b_expected = list((flex.double(b_target) + flex.double(b_model)))
scaled_map_coeffs = start_map_coeffs.apply_debye_waller_factors(
u_star=u_star_s)
# Generate map coefficient errors for first half-map from complex normal
# distribution
b_target_e = (0., 0., 0., -50., -50., 100.) # Anisotropy for error terms
u_star_e = adptbx.u_cart_as_u_star(start_map_coeffs.unit_cell(),
adptbx.b_as_u(b_target_e))
se_target = 10. # Target for SigmaE variance term
rsigma = math.sqrt(se_target / 2.)
jj = 0. + 1.j # Define I for generating complex numbers
random_complexes1 = flex.complex_double()
ncoeffs = start_map_coeffs.size()
random.seed(123457) # Make runs reproducible
for i in range(ncoeffs):
random_complexes1.append(
random.gauss(0., rsigma) + random.gauss(0., rsigma) * jj)
rc1_miller = start_map_coeffs.customized_copy(data=random_complexes1)
mc1_delta = rc1_miller.apply_debye_waller_factors(u_star=u_star_e)
map1_coeffs = scaled_map_coeffs.customized_copy(
data=scaled_map_coeffs.data() + mc1_delta.data())
# Repeat for second half map with independent errors from same distribution
random_complexes2 = flex.complex_double()
for i in range(ncoeffs):
random_complexes2.append(
random.gauss(0., rsigma) + random.gauss(0., rsigma) * jj)
rc2_miller = start_map_coeffs.customized_copy(data=random_complexes2)
mc2_delta = rc2_miller.apply_debye_waller_factors(u_star=u_star_e)
map2_coeffs = scaled_map_coeffs.customized_copy(
data=scaled_map_coeffs.data() + mc2_delta.data())
# mmm.write_model("fake_map.pdb")
mmm.add_map_from_fourier_coefficients(map1_coeffs, map_id='map_manager_1')
mmm.add_map_from_fourier_coefficients(map2_coeffs, map_id='map_manager_2')
# Replace original map_manager with mean of half-maps
mm_mean_data = (mmm.map_manager_1().map_data() +
mmm.map_manager_2().map_data()) / 2
mmm.map_manager().set_map_data(map_data=mm_mean_data)
# Add mask map for ordered component of map
protein_mw = n_residues * 110. # MW from model would be better...
nucleic_mw = None
mask_id = 'ordered_volume_mask'
add_ordered_volume_mask(mmm,
d_min,
protein_mw=protein_mw,
nucleic_mw=nucleic_mw,
map_id_out=mask_id)
box_centre = tuple(flex.double((ucpars[0], ucpars[1], ucpars[2])) / 2)
# Now refine to assess parameters describing map errors
results = assess_cryoem_errors(mmm,
d_min,
sphere_cent=tuple(box_centre),
radius=model_radius + d_min,
verbosity=0)
# resultsdict = results.resultsdict
# b_refined_a = resultsdict["a_baniso"]
# print("\nIdeal A tensor as Baniso: ", b_expected)
# print("Refined A tensor as Baniso", b_refined_a)
# Note that all maps have been cut out with a spherical mask, so compare using these
new_mmm = results.new_mmm
perfect_mapCC = new_mmm.map_model_cc(map_id='perfect_map')
mapCC = new_mmm.map_model_cc(map_id='map_manager_wtd') # Achieved map
start_mapCC = new_mmm.map_model_cc(
) # Starting map with noise and anisotropy
mc_perfect = new_mmm.map_as_fourier_coefficients(d_min=d_min,
d_max=d_max,
map_id='perfect_map')
mc_achieved = new_mmm.map_as_fourier_coefficients(d_min=d_min,
d_max=d_max,
map_id='map_manager_wtd')
# Compare with results using theoretically perfect error parameters to compute
# ideal map coefficients.
sigmaS_terms = flex.pow2(get_power_spectrum(
mc_perfect)) # Actual signal power before anisotropy
mc_start = new_mmm.map_as_fourier_coefficients(d_min=d_min, d_max=d_max)
eE_ideal = mc_start.deep_copy()
ones_array = flex.double(eE_ideal.size(), 1)
all_ones = eE_ideal.customized_copy(data=ones_array)
u_star_s2 = tuple(flex.double(u_star_s) *
2.) # Square anisotropy for signal power calc
sigmaS_terms = sigmaS_terms * all_ones.apply_debye_waller_factors(
u_star=u_star_s2).data() # Corrected for anisotropy
u_star_e2 = tuple(flex.double(u_star_e) * 2.)
sigmaE_terms = all_ones.apply_debye_waller_factors(
u_star=u_star_e2).data() * se_target
scale_terms = 1. / flex.sqrt(sigmaS_terms + sigmaE_terms / 2.)
dobs_terms = 1. / flex.sqrt(1. + sigmaE_terms / (2 * sigmaS_terms))
mc_ideal = eE_ideal.customized_copy(data=eE_ideal.data() * scale_terms *
dobs_terms)
# write_mtz(mc_achieved,"achieved_map.mtz","achieved")
# write_mtz(mc_ideal,"ideal_map.mtz","ideal")
mapCC_ideal_achieved = mc_ideal.map_correlation(other=mc_achieved)
# print("CC between ideal and achieved maps:",mapCC_ideal_achieved)
assert (mapCC_ideal_achieved > 0.92)
new_mmm.add_map_from_fourier_coefficients(mc_ideal, map_id='ideal_map')
ideal_mapCC = new_mmm.map_model_cc(map_id='ideal_map')
# print("Perfect, starting, ideal and achieved mapCC: ", perfect_mapCC, start_mapCC, ideal_mapCC, mapCC)
assert (mapCC > 0.98 * ideal_mapCC)
def get_statistics(self):
if self.json_data['success_composition'] is False:
return
make_sub_header('Get statistics', out=self.logger)
self.save_json()
success = True
self.json_data['success_statistics'] = None
sc, r_sc = None, None
self.pickle_data.min_reso = None
self.pickle_data.d_inv = None
self.pickle_data.r_d_inv = None
self.pickle_data.d_inv_half = None
self.pickle_data.fsc_model = None
self.pickle_data.r_fsc_model = None
self.pickle_data.fsc_half = None
if self.json_data['restraints_file']:
cif_file = self.json_data['restraints_file']
cif_objects = monomer_library.server.read_cif(file_name=to_str(cif_file))
cif_objects = [(cif_file, cif_objects)]
else: cif_objects = None
for p, fn in zip(('', 'r_'),
[self.json_data['pdb_file_updated'], self.json_data['pdb_file_refined']]):
# TODO which file to use for initial!!
if (not fn or not os.path.isfile(fn)): continue
if p=='': print('Initial model', file=self.logger)
if p=='r_': print('\nRefined model', file=self.logger)
dm = DataManager()
dm.process_real_map_file(self.json_data['map_file'])
map_inp = dm.get_real_map(self.json_data['map_file'])
#map_inp = iotbx.ccp4_map.map_reader(file_name = self.json_data['map_file'])
map_inp_1, map_inp_2 = None, None
if self.json_data['map_file_1'] is not None:
#map_inp_1 = iotbx.ccp4_map.map_reader(file_name = self.json_data['map_file_1'])
dm.process_real_map_file(self.json_data['map_file_1'])
map_inp_1 = dm.get_real_map(self.json_data['map_file_1'])
#map_data_1 = map_inp_1.map_data()
if self.json_data['map_file_2'] is not None:
dm.process_real_map_file(self.json_data['map_file_2'])
map_inp_2 = dm.get_real_map(self.json_data['map_file_2'])
#map_inp_2 = iotbx.ccp4_map.map_reader(file_name = self.json_data['map_file_2'])
#map_data_2 = map_inp_2.map_data()
print('\tGet model class with restraints...', file=self.logger)
pdb_inp = iotbx.pdb.input(file_name = fn)
try:
model = mmtbx.model.manager(
model_input = pdb_inp,
restraint_objects = cif_objects,
build_grm = True,
stop_for_unknowns = False,
crystal_symmetry = map_inp.crystal_symmetry(),
log = null_out())
except Exception as e:
#success = False
self.json_data['success_statistics'] = False
msg = traceback.format_exc()
print(msg, file=self.logger)
self.write_log(
step = 'Statistics: Model class (with restraints) from pdb ',
msg = msg)
self.save_json()
continue
if not success: continue
# Emringer
if self.resolution < 4.0:
print('\tCalculate Emringer score', file=self.logger)
try:
emringer_score = self.get_emringer_score(
model = model.deep_copy(),
map_inp = map_inp.deep_copy())
self.json_data[p+'emringer'] = emringer_score
except Exception as e:
msg = traceback.format_exc()
print(msg, file=self.logger)
self.write_log(step = 'EMRinger failed ', msg = msg)
# TODO: save as success_statistics False?
# Rama-z score
try:
rama_z_score = rama_z.rama_z(
models = [model],
log = self.logger)
z_scores = rama_z_score.get_z_scores()
self.json_data[p+'z_score'] = z_scores['W'][0]
except Exception as e:
msg = traceback.format_exc()
print(msg, file=self.logger)
self.write_log(step = 'Rama z-score failed ', msg = msg)
# base = map_and_model.input(
# map_manager = map_inp,
# map_manager_1 = map_inp_1,
# map_manager_2 = map_inp_2,
# model = model,
# box = True)
checked = map_model_manager(
map_manager = map_inp,
map_manager_1 = map_inp_1,
map_manager_2 = map_inp_2,
model = model,
wrapping = None)
checked.box_all_maps_around_model_and_shift_origin()
params = validation_cryoem.master_params().extract()
params.resolution = self.resolution
params.slim = False
if (p == ''):
print('\tGet map parameters...', file=self.logger)
self.get_map_parameters(base = checked)
print('\tRun Mtriage...', file=self.logger)
try:
o = validation_cryoem.validation(
model = checked.model(),
map_data = checked.map_data(),
map_data_1 = checked.map_data_1(),
map_data_2 = checked.map_data_2(),
params = params)
except Exception as e:
# success = False
self.json_data['success_statistics'] = False
msg = traceback.format_exc()
print(msg, file=self.logger)
self.write_log(step = 'Statistics ', msg = msg)
self.save_json()
continue
print('\tStore info in pkl...', file=self.logger)
o_dict = self.fill_dictionary(o)
if (p == ''):
self.json_data['o'] = o_dict
sc = o.model.get_sites_cart()
elif (p == 'r_'):
self.json_data['o_refined'] = o_dict
r_sc = o.model.get_sites_cart()
if o is not None:
if o.model_vs_data is not None:
if o.model_vs_data.cc is not None:
if o.model_vs_data.cc.cc_per_chain is not None:
if (p == ''):
self.pickle_data.cc_per_chain = o.model_vs_data.cc.cc_per_chain
if (p == 'r_'):
self.pickle_data.r_cc_per_chain = o.model_vs_data.cc.cc_per_chain
if o.model_vs_data.cc.cc_per_residue is not None:
if (p == ''):
self.pickle_data.cc_per_residue = o.model_vs_data.cc.cc_per_residue
if (p == 'r_'):
self.pickle_data.r_cc_per_residue = o.model_vs_data.cc.cc_per_residue
if o.model_stats.geometry.ramachandran.ramalyze is not None:
rl = o.model_stats.geometry.ramachandran.ramalyze
if (p == ''): self.pickle_data.ramalyze = rl
if (p == 'r_'): self.pickle_data.r_ramalyze = rl
# values for the curve go up to very high reso, get highest reso limit
# if o is not None:
# reso_list = [self.json_data['d_pdb'],self.json_data['d_cif'],
# self.json_data['d_map'], self.json_data['o']['d99'],
# self.json_data['o']['d_model'], self.json_data['o']['d_fsc']]
# else:
# reso_list = [self.json_data['d_pdb'],self.json_data['d_cif'],
# self.json_data['d_map']]
# min_reso = min([elem for elem in reso_list if elem is not None])
# self.pickle_data.min_reso = min_reso
min_reso = self.resolution
self.pickle_data.min_reso = self.resolution
# apply some arbitrary buffer
min_reso = min_reso - 0.5
if o is not None:
masked = o.data_stats.masked
if (masked.fsc_curve_model is not None):
if ((masked.fsc_curve_model.d_inv is not None) and
(masked.fsc_curve_model.fsc is not None)):
if (p == ''):
self.pickle_data.d_inv = masked.fsc_curve_model.d_inv
self.pickle_data.fsc_model = masked.fsc_curve_model.fsc
if (p == 'r_'):
self.pickle_data.r_d_inv = masked.fsc_curve_model.d_inv
self.pickle_data.r_fsc_model = masked.fsc_curve_model.fsc
if (p == ''):
if (masked.fsc_curve is not None):
if (masked.fsc_curve.fsc is not None):
if ((masked.fsc_curve.fsc.d_inv is not None) and
(masked.fsc_curve.fsc.fsc is not None)):
self.pickle_data.d_inv_half = masked.fsc_curve.fsc.d_inv
self.pickle_data.fsc_half = masked.fsc_curve.fsc.fsc
if o is not None:
print("\nd99 :", o.data_stats.masked.d99)
print("d_model :", o.data_stats.masked.d_model)
print("d_fsc :", o.data_stats.masked.d_fsc)
print("ramachandran.outliers:", o.model_stats.geometry.ramachandran.outliers)
print("cc_mask :", o.model_vs_data.cc.cc_mask)
print("cc_box :", o.model_vs_data.cc.cc_box)
if sc is not None and r_sc is not None:
self.json_data['rmsd'] = sc.rms_difference(r_sc)
if self.json_data['success_statistics'] is not False:
self.json_data['success_statistics'] = success
def RunProbeTests(inFileName):
#========================================================================
# Call the test functions for the libraries we test.
ret = probeext.DotSpheres_test()
assert len(ret) == 0, "DotSpheres_test() failed: " + ret
ret = probeext.SpatialQuery_test()
assert len(ret) == 0, "SpatialQuery_test() failed: " + ret
ret = probeext.Scoring_test()
assert len(ret) == 0, "Scoring_test() failed: " + ret
AtomTypes.Test()
Helpers.Test()
#========================================================================
# Now ensure that we can use the C++-wrapped classes as intended to make sure
# that the wrapping code or parameters have not changed.
#========================================================================
# Make sure we can get at the DotSphere objects and their methods
cache = probeext.DotSphereCache(10)
sphere1 = cache.get_sphere(1)
dots = sphere1.dots()
#========================================================================
# Make sure we can fill in an ExtraAtomInfoList and pass it to scoring
# Generate an example data model with a small molecule in it
if inFileName is not None and len(inFileName) > 0:
# Read a model from a file using the DataManager
dm = DataManager()
dm.process_model_file(inFileName)
model = dm.get_model(inFileName)
else:
# Generate a small-molecule model using the map model manager
mmm = map_model_manager(
) # get an initialized instance of the map_model_manager
mmm.generate_map(
) # get a model from a generated small library model and calculate a map for it
model = mmm.model() # get the model
# Fix up bogus unit cell when it occurs by checking crystal symmetry.
cs = model.crystal_symmetry()
if (cs is None) or (cs.unit_cell() is None):
model = shift_and_box_model(model=model)
# Get the list of all atoms in the model
atoms = model.get_atoms()
# Get the bonding information we'll need to exclude our bonded neighbors.
try:
p = mmtbx.model.manager.get_default_pdb_interpretation_params()
model.process(make_restraints=True,
pdb_interpretation_params=p) # make restraints
geometry = model.get_restraints_manager().geometry
sites_cart = model.get_sites_cart() # cartesian coordinates
bond_proxies_simple, asu = \
geometry.get_all_bond_proxies(sites_cart = sites_cart)
except Exception as e:
raise Exception("Could not get bonding information for input file: " +
str(e))
bondedNeighbors = Helpers.getBondedNeighborLists(atoms,
bond_proxies_simple)
# Traverse the hierarchy and look up the extra data to be filled in.
ret = Helpers.getExtraAtomInfo(model)
extra = ret.extraAtomInfo
# Construct a SpatialQuery and fill in the atoms. Ensure that we can make a
# query within 1000 Angstroms of the origin.
sq = probeext.SpatialQuery(atoms)
nb = sq.neighbors((0, 0, 0), 0, 1000)
# Construct a DotScorer object.
# Find the radius of each atom in the structure and construct dot spheres for
# them. Find the atoms that are bonded to them and add them to an excluded list.
# Then compute the score for each of them and report the summed score over the
# whole molecule the way that Reduce will.
ds = probeext.DotScorer(extra)
total = 0
badBumpTotal = 0
for a in atoms:
rad = extra.getMappingFor(a).vdwRadius
assert rad > 0, "Invalid radius for atom look-up: " + a.name + " rad = " + str(
rad)
sphere = cache.get_sphere(rad)
# Excluded atoms that are bonded to me or to one of my neightbors.
# It has the side effect of excluding myself if I have any neighbors.
# Construct as a set to avoid duplicates.
exclude = set()
for n in bondedNeighbors[a]:
exclude.add(n)
for n2 in bondedNeighbors[n]:
exclude.add(n2)
exclude = list(exclude)
dots = sphere.dots()
res = ds.score_dots(a, 1.0, sq, rad * 3, 0.25, exclude, sphere.dots(),
sphere.density(), False)
total += res.totalScore()
if res.hasBadBump:
badBumpTotal += 1
# Test calling the single-dot checking code as will be used by Probe to make sure
# all of the Python linkage is working
dotOffset = [1, 0, 0]
check = ds.check_dot(atoms[0], dotOffset, 1, atoms, [atoms[0]])
overlapType = check.overlapType
# Test calling the interaction_type method to be sure Python linkage is working
interactionType = ds.interaction_type(check.overlapType, check.gap)
def test_01():
# Source data (map and model)
data_dir = os.path.dirname(os.path.abspath(__file__))
data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4')
data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_model.pdb')
# Read in map data with data_manager
dm = DataManager(['real_map'])
dm.set_overwrite(True)
# Next step uses map_manager to do the actual reading
dm.process_real_map_file(data_ccp4)
mm = dm.get_real_map()
# Shift the origin of the map; starts at (100,100,100)
print(mm.map_data().origin())
assert mm.map_data().origin() == (100, 100, 100)
assert mm.origin_shift_grid_units == (0, 0, 0)
mm.shift_origin()
assert mm.map_data().origin() == (0, 0, 0)
assert mm.origin_shift_grid_units == (100, 100, 100)
mm.show_summary()
# test cc_to_other_map
assert mm.cc_to_other_map_manager(mm) == 1
# test writing and reading file
dm.write_real_map_file(mm,
filename='test_map_manager.ccp4',
overwrite=True)
dm.process_real_map_file('test_map_manager.ccp4')
new_mm = dm.get_real_map('test_map_manager.ccp4')
os.remove('test_map_manager.ccp4')
new_mm.shift_origin()
# Check whether gridding and crystal_symmetry are similar for mm, new_mm
assert new_mm.is_similar(mm)
assert approx_equal(new_mm.map_data()[3125], mm.map_data()[3125])
# test writing and reading file without shifting origin
dm = DataManager(['real_map'])
dm.set_overwrite(True)
dm.process_real_map_file(data_ccp4)
mm = dm.get_real_map()
mm.show_summary()
dm.write_real_map_file(mm,
filename='test_map_manager.ccp4',
overwrite=True)
new_mm = map_manager('test_map_manager.ccp4')
assert (new_mm.is_similar(mm))
new_mm.shift_origin()
assert (not new_mm.is_similar(mm))
# get map_data
dm = DataManager(['real_map'])
dm.set_overwrite(True)
dm.process_real_map_file(data_ccp4)
mm = dm.get_real_map()
mm.shift_origin()
map_data = mm.map_data()
assert approx_equal(map_data[15, 10, 19], 0.38, eps=0.01)
# get crystal_symmetry
cs = mm.crystal_symmetry()
assert approx_equal(cs.unit_cell().parameters()[0], 22.41, eps=0.01)
# and full cell symmetry
full_cs = mm.unit_cell_crystal_symmetry()
assert approx_equal(full_cs.unit_cell().parameters()[0],
149.4066,
eps=0.01)
# write map directly:
mm.write_map('test_direct.ccp4')
# read back directly
new_mm = map_manager('test_direct.ccp4')
assert (not new_mm.is_similar(mm))
new_mm.shift_origin()
assert mm.is_similar(new_mm)
assert approx_equal(new_mm.map_data()[3125], mm.map_data()[3125])
# deep_copy
new_mm = mm.deep_copy()
assert new_mm.is_similar(mm)
assert approx_equal(new_mm.map_data()[3125], mm.map_data()[3125])
# deep_copy a map without shifting origin
# Make a DataManager that can write a map coeffs file too
dm = DataManager(['miller_array', 'real_map'])
dm.set_overwrite(True)
dm.process_real_map_file(data_ccp4)
omm = dm.get_real_map()
omm.show_summary()
new_omm = omm.deep_copy()
assert new_omm.is_similar(omm)
assert (not new_omm.is_similar(mm))
# customized_copy
new_mm = mm.customized_copy(map_data=mm.map_data().deep_copy())
assert new_mm.is_similar(mm)
# Initialize with parameters
mm_para = map_manager(
unit_cell_grid=mm.unit_cell_grid,
unit_cell_crystal_symmetry=mm.unit_cell_crystal_symmetry(),
origin_shift_grid_units=mm.origin_shift_grid_units,
map_data=mm.map_data(),
wrapping=False)
assert mm_para.is_similar(mm)
# Adjust origin and gridding:
mm_read = map_manager(data_ccp4)
mm_read.shift_origin()
mm.show_summary()
mm_read.show_summary()
mm_read.set_original_origin_and_gridding((10, 10, 10),
gridding=(100, 100, 100))
mm_read.show_summary()
assert (not mm_read.is_similar(mm))
assert (mm_read.origin_is_zero())
# Set program name
mm_read.set_program_name('test program')
assert mm_read.program_name == 'test program'
# Set limitation
mm_read.add_limitation('map_is_sharpened')
assert mm_read.limitations == ['map_is_sharpened']
# Add a label
mm_read.add_label('TEST LABEL')
assert mm_read.labels[0] == 'TEST LABEL'
mm_read.write_map('map_with_labels.mrc')
new_mm = map_manager('map_with_labels.mrc')
assert 'TEST LABEL' in new_mm.labels
assert new_mm.is_in_limitations('map_is_sharpened')
assert new_mm.labels[0].find('test program') > -1
# change the cell dimensions
mm_read = map_manager(data_ccp4)
mm_read.shift_origin()
assert mm_read.is_similar(mm)
assert approx_equal(mm_read.pixel_sizes(), (0.7470, 0.7231, 0.7374),
eps=0.001)
from cctbx import crystal
new_uc_params = list(
mm_read.unit_cell_crystal_symmetry().unit_cell().parameters())
new_uc_params[0] += 10
new_cs = crystal.symmetry(new_uc_params, 1)
mm_read.set_unit_cell_crystal_symmetry(new_cs)
assert not mm_read.crystal_symmetry().is_similar_symmetry(
mm.crystal_symmetry())
assert not mm_read.is_similar(mm)
mm_read.show_summary()
assert approx_equal(mm_read.pixel_sizes(), (0.7970, 0.7231, 0.7374),
eps=0.001)
# Read a map directly
mm_read = map_manager(data_ccp4)
mm_read.shift_origin()
assert mm_read.is_similar(mm)
# Set log
import sys
mm.set_log(sys.stdout)
# Add map_data
new_mm = mm_read.customized_copy(map_data=mm.map_data().deep_copy())
assert new_mm.is_similar(mm)
# replace data
new_mm.set_map_data(map_data=mm.map_data().deep_copy())
assert new_mm.is_similar(mm)
# create a full-sized map from this one
mm_full_size = mm_read.deep_copy().as_full_size_map()
assert not mm_full_size.is_similar(mm_read)
print(mm_full_size.map_data().origin(), mm_read.map_data().origin())
print(mm_full_size.map_data().all(), mm_read.map_data().all())
# Apply a mask to edges of a map
assert approx_equal(new_mm.map_data().as_1d().min_max_mean().max,
mm.map_data().as_1d().min_max_mean().max)
assert approx_equal((new_mm.map_data()[0], mm.map_data()[0]), (0.0, 0.0))
new_mm.create_mask_around_edges(soft_mask_radius=3)
new_mm.soft_mask(soft_mask_radius=3)
assert approx_equal(new_mm.map_data().as_1d().min_max_mean().max,
mm.map_data().as_1d().min_max_mean().max)
new_mm.apply_mask(set_outside_to_mean_inside=True)
assert approx_equal((new_mm.map_data()[0], mm.map_data()[0]),
(0.0116267086024, 0.0))
dm.process_real_map_file('test_map_manager.ccp4')
new_mm = dm.get_real_map('test_map_manager.ccp4')
new_mm.show_summary()
assert (not new_mm.is_similar(mm))
new_mm.shift_origin()
new_mm.show_summary()
assert new_mm.is_similar(mm)
os.remove('test_map_manager.ccp4')
# Check origin_shifts
print(new_mm.origin_shift_grid_units)
print(new_mm.shift_cart())
assert approx_equal(new_mm.origin_shift_grid_units, (100, 100, 100))
assert approx_equal(
new_mm.shift_cart(),
(-74.70333099365234, -72.30750274658205, -73.7437515258789))
# Convert to map coeffs, write out, read back, convert back to map
map_coeffs = mm.map_as_fourier_coefficients(d_min=3)
mtz_dataset = map_coeffs.as_mtz_dataset(column_root_label='F')
mtz_object = mtz_dataset.mtz_object()
dm.write_miller_array_file(mtz_object, filename="map_coeffs.mtz")
# Note these Fourier coeffs correspond to working map (not original position)
array_labels = dm.get_miller_array_labels("map_coeffs.mtz")
labels = array_labels[0]
dm.get_reflection_file_server(filenames=["map_coeffs.mtz"],
labels=[labels])
miller_arrays = dm.get_miller_arrays()
new_map_coeffs = miller_arrays[0]
mm_from_map_coeffs = mm.fourier_coefficients_as_map_manager(
map_coeffs=new_map_coeffs)
assert mm_from_map_coeffs.is_similar(mm)
# Find map symmetry in a map
data_d7 = os.path.join(data_dir, 'data', 'D7.ccp4')
dm = DataManager(['real_map', 'model'])
dm.process_real_map_file(data_d7)
dm.process_model_file(data_pdb)
mm = dm.get_real_map(data_d7)
model = dm.get_model(data_pdb)
mm.shift_origin()
mm.set_original_origin_and_gridding(original_origin=(0, 0, 0))
# Box it so it is not so easy to find symmetry
from cctbx.maptbx.box import with_bounds
box = with_bounds(mm, lower_bounds=(2, 2, 2), upper_bounds=(43, 43, 43))
new_mm = box.map_manager()
new_mm.find_map_symmetry(symmetry='d7',
min_ncs_cc=0.8,
include_helical_symmetry=False)
ncs_obj = new_mm.ncs_object()
assert ncs_obj is not None
print("NCS: ", new_mm.ncs_object().as_ncs_spec_string())
another_mm = map_manager(
unit_cell_grid=new_mm.unit_cell_grid,
unit_cell_crystal_symmetry=new_mm.unit_cell_crystal_symmetry(),
origin_shift_grid_units=new_mm.origin_shift_grid_units,
map_data=new_mm.map_data(),
ncs_object=ncs_obj,
wrapping=False)
assert another_mm.is_similar(new_mm)
assert ncs_obj.is_similar_ncs_object(another_mm.ncs_object())
assert new_mm.is_similar(another_mm)
# Adjust model and ncs symmetry to match this map
assert model.shift_cart() is None
new_mm.set_model_symmetries_and_shift_cart_to_match_map(model)
assert approx_equal(
model.shift_cart(),
(-0.888888888888889, -0.8888888888888891, -0.888888888888889))
assert new_mm.is_compatible_ncs_object(ncs_obj)
ncs_obj.set_shift_cart((0, 0, 0))
assert not new_mm.is_compatible_ncs_object(ncs_obj)
new_mm.set_ncs_object_shift_cart_to_match_map(ncs_obj)
new_mm.set_ncs_object(ncs_obj)
assert new_mm.is_compatible_ncs_object(new_mm.ncs_object())
new_mm.show_summary()
new_mm.shift_origin(desired_origin=(11, 1, 1))
print(new_mm.shift_cart(), new_mm.ncs_object().shift_cart())
assert new_mm.is_compatible_ncs_object(new_mm.ncs_object())
new_mm.shift_origin()
assert new_mm.is_compatible_ncs_object(new_mm.ncs_object())
# filter a map
dm = DataManager()
mm = dm.get_real_map(data_d7)
low_pass_filtered = mm.deep_copy()
low_pass_filtered.resolution_filter(d_min=2.5)
high_pass_filtered = mm.deep_copy()
high_pass_filtered.resolution_filter(d_max=2.5)
gaussian = mm.deep_copy()
gaussian.gaussian_filter(smoothing_radius=1)
binary = mm.deep_copy()
binary.binary_filter(threshold=0.5)
assert approx_equal(
(mm.map_data().as_1d()[1073],
low_pass_filtered.map_data().as_1d()[1073],
high_pass_filtered.map_data().as_1d()[1073],
gaussian.map_data().as_1d()[1073], binary.map_data().as_1d()[1073]),
(0.0171344596893, 0.0227163900537, -0.0072717454565, 0.0149086679298,
0.0))
info = mm.get_density_along_line((5, 5, 5), (10, 10, 10))
assert approx_equal([info.along_density_values[4]] +
list(info.along_sites[4]),
[-0.562231123447, 8.0, 8.0, 8.0])
from iotbx.map_model_manager import map_model_manager
extra_map_manager_id_list = [
"low_pass_filtered", "high_pass_filtered", "gaussian", "binary"
]
expected_cc = [
0.999920243317, 0.0129365545729, 0.971491994253, 0.733986499746
]
mam = map_model_manager(
map_manager=mm,
extra_map_manager_list=[
low_pass_filtered, high_pass_filtered, gaussian, binary
],
extra_map_manager_id_list=extra_map_manager_id_list,
)
for other_id, cc in zip(extra_map_manager_id_list, expected_cc):
assert approx_equal(
cc, mam.map_map_cc(map_id='map_manager', other_map_id=other_id))
(self.d_max - self.d_min)))
def get_i_bin_below(self, d_value):
return max(0, min(self.n_bins - 2, int(self.get_i_bin_real(d_value))))
def get_i_bin_above(self, d_value):
return max(1, min(self.n_bins - 1, 1 + self.get_i_bin_below(d_value)))
def exercise(self):
print("Exercising approx_amplitude_vs_resolution")
for d_value in range(20):
print("D-min %s rms FC %s " % (d_value, aavr.get_value(d_value)))
for d_min, d_max in ((1.1, 1.3), (2.7, 3.0), (3.5, 3.6), (10, 18)):
print("D_min %s D_max %s RMS FC: %s " %
(d_min, d_max, self.get_expected_value_in_bin(d_min, d_max)))
if __name__ == "__main__":
aavr = approx_amplitude_vs_resolution()
aavr.exercise()
from iotbx.map_model_manager import map_model_manager
mmm = map_model_manager()
mmm.generate_map()
new_aavr = approx_amplitude_vs_resolution(d_min=3,
n_bins=20,
map_model_manager=mmm)
print(list(new_aavr.get_target_scale_factors()))
def Test(inFileName = None):
#========================================================================
# Make sure we can fill in mmtbx.probe.ExtraAtomInfoList info.
# Generate an example data model with a small molecule in it unless we
# were given a file name on the command line.
if inFileName is not None and len(inFileName) > 0:
# Read a model from a file using the DataManager
dm = DataManager()
dm.process_model_file(inFileName)
model = dm.get_model(inFileName)
else:
# Generate a small-molecule model using the map model manager
mmm=map_model_manager() # get an initialized instance of the map_model_manager
mmm.generate_map() # get a model from a generated small library model and calculate a map for it
model = mmm.model() # get the model
# Fill in an ExtraAtomInfoList with an entry for each atom in the hierarchy.
# We first find the largest i_seq sequence number in the model and reserve that
# many entries so we will always be able to fill in the entry for an atom.
atoms = model.get_atoms()
maxI = atoms[0].i_seq
for a in atoms:
if a.i_seq > maxI:
maxI = a.i_seq
extra = []
for i in range(maxI+1):
extra.append(probe.ExtraAtomInfo())
# Traverse the hierarchy and look up the extra data to be filled in.
# Get a list of all the atoms in the chain while we're at it
at = AtomTypes()
ph = model.get_hierarchy()
for m in ph.models():
for chain in m.chains():
for rg in chain.residue_groups():
for ag in rg.atom_groups():
for a in ag.atoms():
ei, warn = at.FindProbeExtraAtomInfo(a)
extra[a.i_seq] = ei
# User code should test for and print warnings
#if len(warn) > 0:
# print(warn)
#========================================================================
# Find an Oxygen atom and ask for its radii with explicit Hydrogen, implicit Hydrogen,
# and Nuclear radii.
o = None
ph = model.get_hierarchy()
for a in ph.models()[0].atoms():
if a.element.strip() == 'O':
o = a
assert o is not None, "AtomTypes.Test(): Could not find Oxygen (internal test failure)"
explicitH = AtomTypes(useNeutronDistances = False,
useImplicitHydrogenDistances = False).FindProbeExtraAtomInfo(o)[0].vdwRadius
implicitH = AtomTypes(useNeutronDistances = False,
useImplicitHydrogenDistances = True).FindProbeExtraAtomInfo(o)[0].vdwRadius
neutronH = AtomTypes(useNeutronDistances = True,
useImplicitHydrogenDistances = False).FindProbeExtraAtomInfo(o)[0].vdwRadius
assert explicitH != implicitH, "AtomTypes.Test(): Implicit and explicit Oxygen radii did not differ as expected"
#========================================================================
# Check MaximumVDWRadius, calling it twice to make sure both the cached and non-cached
# results work.
for i in range(2):
assert at.MaximumVDWRadius() == 2.5, "AtomTypes.Test(): Unexpected MaximumVDWRadius(): got "+str(MaximumVDWRadius())+", expected 2.5"
#========================================================================
# Check IsAromatic() to ensure it gives results when expected and not when not.
aromaticChecks = [
['PHE', 'CE2', True],
[' U', 'HN3', True],
['ASN', 'O', False]
]
for a in aromaticChecks:
assert IsAromatic(a[0],a[1]) == a[2], "AtomTypes.Test(): {} {} not marked as aromatic {}".format(a[0],a[1],a[2])
def get_map_model_manager(self,
model_file=None,
map_files=None,
from_phil=False,
**kwargs):
'''
A convenience function for constructing a map_model_manager from the
files in the DataManager.
Parameters
==========
model_file: str
The name of the model file
map_files: str or list
The name(s) of the map files. If there is only one map, the name (str)
is sufficient. A list is expected to have only 1 (full) or 2 (two half-
maps) or 3 (full and 2 half-maps) map files. If three map files
are in the list,
the first map file is assumed to be the full map.
from_phil: bool
If set to True, the model and map names are retrieved from the
standard PHIL names. The model_file and map_files parameters must
be None if this parameter is set to True.
**kwargs: keyworded arguments
Extra keyworded arguments for map_model_manager constructor
Return
======
map_model_manager object
'''
# get filenames from PHIL
if from_phil:
if model_file is not None or map_files is not None:
raise Sorry(
'If from_phil is set to True, model_file and map_files must be None.'
)
params = self._program.params
map_model = None
if hasattr(params, 'map_model'):
map_model = params.map_model
elif hasattr(params, 'input_files') and hasattr(
params.input_files, 'map_model'):
map_model = params.input_files.map_model
else:
raise Sorry(
'Program does not have the "map_model" PHIL scope.')
model_file = map_model.model
map_files = []
full_map = getattr(map_model, 'full_map', None)
if full_map is not None:
map_files.append(full_map)
half_maps = getattr(map_model, 'half_map', None)
if half_maps:
if len(half_maps) != 2:
raise Sorry('Please provide 2 half-maps.')
map_files += half_maps
# If we didn't get anything, try looking directly at the
# available maps and models. If there are 1, 2 or 3 maps and 1 model,
# take them
if (not model_file) and self.get_model_names() and \
len(self.get_model_names()) == 1:
model_file = self.get_default_model_name()
if not map_files and self.get_real_map_names():
if len(self.get_real_map_names()) == 1:
map_files = self.get_default_real_map_name()
elif len(self.get_real_map_names()) in [2, 3]:
map_files = self.get_real_map_names()
# check map_files argument
mm = None
mm_1 = None
mm_2 = None
if isinstance(map_files, list):
if len(map_files) != 1 and len(map_files) != 2 and len(
map_files) != 3:
msg = 'Please provide only 1 full map or 2 half maps or 1 ' +\
'full map and 2 half maps.\n Found:\n'
for map_file in map_files:
msg += (' {map_file}\n'.format(map_file=map_file))
raise Sorry(msg)
if len(map_files) == 1:
mm = self.get_real_map(map_files[0])
elif len(map_files) == 2:
mm_1 = self.get_real_map(map_files[0])
mm_2 = self.get_real_map(map_files[1])
elif len(map_files) == 3:
mm = self.get_real_map(map_files[0])
mm_1 = self.get_real_map(map_files[1])
mm_2 = self.get_real_map(map_files[2])
elif map_files:
mm = self.get_real_map(map_files)
else:
mm = None
if model_file:
model = self.get_model(model_file)
else:
model = None
mmm = map_model_manager(model=model,
map_manager=mm,
map_manager_1=mm_1,
map_manager_2=mm_2,
**kwargs)
# clean up so that another read of maps and model will read again (these
# are shifted when map_model_manager is called)
if isinstance(map_files, list):
for file_name in map_files[:3]:
if file_name and file_name in self.get_real_map_names():
self.remove_real_map(file_name)
elif map_files:
self.remove_real_map(map_files)
if model_file:
self.remove_model(model_file)
return mmm
def __init__(self, model, fmodel, cc_min=0.8, molprobity_map_params=None):
from iotbx.pdb.amino_acid_codes import one_letter_given_three_letter
from mmtbx import real_space_correlation
validation.__init__(self)
pdb_hierarchy = model.get_hierarchy()
crystal_symmetry = model.crystal_symmetry()
# arrays for different components
self.everything = list()
self.protein = list()
self.other = list()
self.water = list()
aa_codes = one_letter_given_three_letter
# redo real_space_corelation.simple to use map objects instead of filenames
self.overall_rsc = None
rsc = None
try:
rsc_params = real_space_correlation.master_params().extract()
rsc_params.detail = "residue"
rsc_params.map_1.fill_missing_reflections = False
rsc_params.map_2.fill_missing_reflections = False
use_maps = False
if (molprobity_map_params is not None):
rsc_params.map_coefficients_file_name = \
molprobity_map_params.map_coefficients_file_name
rsc_params.map_coefficients_label = \
molprobity_map_params.map_coefficients_label
if (molprobity_map_params.map_file_name is not None):
use_maps = True
# use mmtbx/command_line/map_model_cc.py for maps
self.fsc = None
if (use_maps):
from iotbx.map_model_manager import map_model_manager
from mmtbx.maps import map_model_cc
# XXX no longer exists from mmtbx.maps.import get_fsc
from mmtbx.maps.mtriage import get_fsc # XXX replaced above
from iotbx.file_reader import any_file
params = map_model_cc.master_params().extract()
params.map_model_cc.resolution = molprobity_map_params.d_min
map_object = any_file(
molprobity_map_params.map_file_name).file_object
# check that model crystal symmetry matches map crystal symmetry
mmi = map_model_manager(map_manager=map_object, model=model)
rsc_object = map_model_cc.map_model_cc(
mmi.map_data(),
mmi.model().get_hierarchy(), mmi.crystal_symmetry(),
params.map_model_cc)
rsc_object.validate()
rsc_object.run()
rsc = rsc_object.get_results()
self.overall_rsc = (rsc.cc_mask, rsc.cc_volume, rsc.cc_peaks)
self.fsc = get_fsc(mmi.map_data(), mmi.model(),
params.map_model_cc)
self.fsc.atom_radius = rsc.atom_radius
rsc = rsc.cc_per_residue
# mmtbx/real_space_correlation.py for X-ray/neutron data and map
# coefficients
else:
self.overall_rsc, rsc = real_space_correlation.simple(
fmodel=fmodel,
pdb_hierarchy=pdb_hierarchy,
params=rsc_params,
log=null_out())
except Exception as e:
raise
else:
assert ((self.overall_rsc is not None) and (rsc is not None))
for i, result_ in enumerate(rsc):
if (use_maps
): # new rsc calculation (mmtbx/maps/model_map_cc.py)
result = residue_real_space(chain_id=result_.chain_id,
resname=result_.resname,
resseq=result_.resseq,
icode=result_.icode,
altloc="",
score=result_.cc,
b_iso=result_.b_iso_mean,
occupancy=result_.occ_mean,
outlier=result_.cc < cc_min,
xyz=result_.xyz_mean)
else: # old rsc calculation (mmtbx/maps/real_space_correlation.py)
result = residue_real_space(
chain_id=result_.chain_id,
resname=result_.residue.resname,
resseq=result_.residue.resseq,
icode=result_.residue.icode,
altloc="",
score=result_.cc,
b_iso=result_.b,
occupancy=result_.occupancy,
fmodel=result_.map_value_1,
two_fofc=result_.map_value_2,
outlier=result_.cc < cc_min,
xyz=result_.residue.atoms().extract_xyz().mean())
if result.is_outlier():
self.n_outliers += 1
# XXX unlike other validation metrics, we always save the results for
# the real-space correlation, since these are used as the basis for
# the multi-criterion plot in Phenix. The show() method will only
# print outliers, however.
if (result.resname != 'HOH'): # water is handled by waters.py
self.everything.append(result)
if result.resname in one_letter_given_three_letter:
self.protein.append(result)
else:
self.other.append(result)
self.everything += self.water
self.results = self.protein
def test_01():
# Source data
data_dir = os.path.dirname(os.path.abspath(__file__))
data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4')
data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_model.pdb')
data_ncs_spec = os.path.join(data_dir, 'data',
'non_zero_origin_ncs_spec.ncs_spec')
# Read in data
dm = DataManager(['ncs_spec', 'model', 'real_map', 'phil'])
dm.set_overwrite(True)
map_file = data_ccp4
dm.process_real_map_file(map_file)
mm = dm.get_real_map(map_file)
model_file = data_pdb
dm.process_model_file(model_file)
model = dm.get_model(model_file)
ncs_file = data_ncs_spec
dm.process_ncs_spec_file(ncs_file)
ncs = dm.get_ncs_spec(ncs_file)
mmm = map_model_manager(model=model,
map_manager_1=mm.deep_copy(),
map_manager_2=mm.deep_copy(),
ncs_object=ncs,
wrapping=False)
mmm.add_map_manager_by_id(map_id='external_map',
map_manager=mmm.map_manager().deep_copy())
mmm.set_resolution(3)
mmm.set_log(sys.stdout)
dc = mmm.deep_copy()
# Model sharpening
mmm = dc.deep_copy()
tls_info = mmm.tls_from_map(
n_bins=10,
model_id='model',
map_id='map_manager',
iterations=1,
)
tlso = tls_info.tlso_list[0]
print("t:", tlso.t)
print("l:", tlso.l)
print("s:", tlso.s)
print("origin:", tlso.origin)
assert approx_equal(
tlso.t,
(1.1665511122614693, 1.2026392186971397, 1.1654187623738737,
-0.08474662045683597, -0.02260930304525043, 0.06492095346560478))
assert approx_equal(tlso.l,
(-0.002162154945537812, -0.0023776908642138776,
0.0009748174775374614, -5.9732257180723945e-05,
-0.0001342760165428358, -9.055411066345411e-05))
assert approx_equal(
tlso.s,
(3.409944886438518e-08, 6.0542707156228405e-09, -8.938076172958137e-09,
4.8771411705994806e-09, -2.6247834187732072e-08,
4.605012474599143e-09, 6.090471572948155e-10, 2.1790753409285795e-09,
-7.851614684653208e-09))
assert approx_equal(
tlso.origin,
(-64.70331931297399, -62.30573551948903, -63.743687240164604))
print("TLS: ", tlso.t, tlso.l, tlso.s, tlso.origin)
def test_01():
# Source data
data_dir = os.path.dirname(os.path.abspath(__file__))
data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4')
data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_model.pdb')
data_ncs_spec = os.path.join(data_dir, 'data',
'non_zero_origin_ncs_spec.ncs_spec')
# DataManager
dm = DataManager(['ncs_spec', 'model', 'real_map', 'phil'])
dm.set_overwrite(True)
# Read in map and model and ncs
map_file = data_ccp4
dm.process_real_map_file(map_file)
mm = dm.get_real_map(map_file)
model_file = data_pdb
dm.process_model_file(model_file)
model = dm.get_model(model_file)
ncs_file = data_ncs_spec
dm.process_ncs_spec_file(ncs_file)
ncs = dm.get_ncs_spec(ncs_file)
ncs_dc = ncs.deep_copy()
mmmn = match_map_model_ncs()
mmmn.add_map_manager(mm)
mmmn.add_model(model)
mmmn.add_ncs_object(ncs)
# Save it
mmmn_dc = mmmn.deep_copy()
# Make sure we can add an ncs object that is either shifted or not
mmmn_dcdc = mmmn.deep_copy()
new_mmmn = match_map_model_ncs()
new_mmmn.add_map_manager(mmmn_dcdc.map_manager())
new_mmmn.add_model(mmmn_dcdc.model())
new_mmmn.add_ncs_object(mmmn_dcdc.ncs_object())
assert new_mmmn.ncs_object().shift_cart() == new_mmmn.map_manager(
).shift_cart()
mmmn_dcdc = mmmn.deep_copy()
new_mmmn = match_map_model_ncs()
new_mmmn.add_map_manager(mmmn_dcdc.map_manager())
new_mmmn.add_model(mmmn_dcdc.model())
new_mmmn.add_ncs_object(ncs_dc)
assert new_mmmn.ncs_object().shift_cart() == new_mmmn.map_manager(
).shift_cart()
original_ncs = mmmn.ncs_object()
assert approx_equal(
(24.0528, 11.5833, 20.0004),
tuple(original_ncs.ncs_groups()[0].translations_orth()[-1]),
eps=0.1)
assert tuple(mmmn._map_manager.origin_shift_grid_units) == (0, 0, 0)
# Shift origin to (0,0,0)
mmmn = mmmn_dc.deep_copy() # fresh version of match_map_model_ncs
mmmn.shift_origin()
new_ncs = mmmn.ncs_object()
assert tuple(mmmn._map_manager.origin_shift_grid_units) == (100, 100, 100)
mmmn.write_model('s.pdb')
mmmn.write_map('s.mrc')
shifted_ncs = mmmn.ncs_object()
assert approx_equal(
(-153.758, -74.044, -127.487),
tuple(shifted_ncs.ncs_groups()[0].translations_orth()[-1]),
eps=0.1)
# Shift a model and shift it back
mmmn = mmmn_dc.deep_copy() # fresh version of match_map_model_ncs
model = mmmn.model()
shifted_model = mmmn.shift_model_to_match_working_map(model=model)
model_in_original_position = mmmn.shift_model_to_match_original_map(
model=shifted_model)
assert (approx_equal(
model.get_sites_cart(), # not a copy
shifted_model.get_sites_cart()))
assert approx_equal(model.get_sites_cart(),
model_in_original_position.get_sites_cart())
# test data_manager map_model_manager
generated_mmm = dm.get_map_model_manager()
print(generated_mmm)
assert (isinstance(generated_mmm, map_model_manager))
# Generate a map and model
import sys
mmm = map_model_manager(log=sys.stdout)
mmm.generate_map()
model = mmm.model()
mm = mmm.map_manager()
assert approx_equal(model.get_sites_cart()[0], (14.476, 10.57, 8.34),
eps=0.01)
assert approx_equal(mm.map_data()[10, 10, 10], -0.0506, eps=0.001)
# Save it
mmm_dc = mmm.deep_copy()
# Create model from sites
mmm_sites = mmm_dc.deep_copy()
from scitbx.array_family import flex
sites_cart = flex.vec3_double()
sites_cart.append((3, 4, 5))
mmm_sites.model_from_sites_cart(sites_cart=sites_cart,
model_id='new_model')
assert mmm_sites.get_model_by_id('new_model').get_sites_cart()[0] == (3, 4,
5)
# Set crystal_symmetry and unit_cell_crystal_symmetry and shift_cart
# Box and shift the map_model_manager so we have new coordinate system
mmm_sites.box_all_maps_around_model_and_shift_origin()
new_model = mmm_sites.get_model_by_id('new_model')
assert approx_equal(
(3.747033333333334, 4.723075000000001, 5.0),
mmm_sites.get_model_by_id('new_model').get_sites_cart()[0])
# arbitrarily set unit_cell crystal symmetry of model to
# match crystal_symmetry. First have to set shift_cart to None
new_model.set_shift_cart(shift_cart=None)
new_model.set_unit_cell_crystal_symmetry_and_shift_cart()
assert new_model.crystal_symmetry() != mmm_sites.crystal_symmetry()
# now set crystal symmetries and shift cart of model to match the manager
mmm_sites.set_model_symmetries_and_shift_cart_to_match_map(new_model)
assert new_model.crystal_symmetry().is_similar_symmetry(
mmm_sites.crystal_symmetry())
assert new_model.unit_cell_crystal_symmetry().is_similar_symmetry(
mmm_sites.unit_cell_crystal_symmetry())
assert new_model.shift_cart() == mmm_sites.shift_cart()
# Import hierarchy into a model and set symmetries and shift to match
mmm_sites.model_from_hierarchy(hierarchy=mmm_sites.model().get_hierarchy(),
model_id='model_from_hierarchy')
assert mmm_sites.get_model_by_id('model_from_hierarchy').model_as_pdb() \
== mmm_sites.get_model_by_id('model').model_as_pdb()
# Check on wrapping
assert not mm.wrapping(
) # this one should not wrap because it is zero at edges
# Make a new one with no buffer so it is not zero at edges
mmm = map_model_manager()
mmm.generate_map(box_cushion=0)
mm = mmm.map_manager()
# check its compatibility with wrapping
assert mm.is_consistent_with_wrapping()
mmm.show_summary()
# now box it
sel = mmm.model().selection("resseq 221:221")
new_model = mmm.model().deep_copy().select(sel)
new_mmm = map_model_manager(model=new_model, map_manager=mm.deep_copy())
new_mmm.box_all_maps_around_model_and_shift_origin()
new_mm = new_mmm.map_manager()
assert not new_mm.wrapping()
assert not new_mm.is_consistent_with_wrapping()
# now box it with selection
new_mmm_1 = map_model_manager(model=mmm.model().deep_copy(),
map_manager=mm.deep_copy())
new_mmm_1.box_all_maps_around_model_and_shift_origin(
selection_string="resseq 221:221")
new_mm_1 = new_mmm_1.map_manager()
assert not new_mm_1.wrapping()
assert not new_mm_1.is_consistent_with_wrapping()
assert new_mm_1.map_data().all() == new_mm.map_data().all()
# create map_model_manager with just half-maps
mm1 = mm.deep_copy()
mm2 = mm.deep_copy()
map_data = mm2.map_data()
map_data += 1.
new_mmm = map_model_manager(model=mmm.model().deep_copy(),
map_manager_1=mm1,
map_manager_2=mm2)
assert new_mmm._map_dict.get(
'map_manager') is None # should not be any yet
assert approx_equal(new_mmm.map_manager().map_data()[232],
mm.deep_copy().map_data()[232] + 0.5)
assert new_mmm._map_dict.get(
'map_manager') is not None # now should be there
# generate map data from a model
mm1 = mm.deep_copy()
mm2 = mm.deep_copy()
new_mmm = map_model_manager(model=mmm.model().deep_copy(), map_manager=mm1)
mmm.generate_map(model=mmm.model())
mm = mmm.map_manager()
mmm.show_summary()
# check get_map_model_manager function
dm = DataManager(['model'])
assert not hasattr(dm, 'get_map_model_manager')
dm = DataManager(['real_map'])
assert not hasattr(dm, 'get_map_model_manager')
dm = DataManager(['sequence'])
assert not hasattr(dm, 'get_map_model_manager')
dm = DataManager(['model', 'real_map'])
assert hasattr(dm, 'get_map_model_manager')
# usage
dm.get_map_model_manager(model_file=data_pdb, map_files=data_ccp4)
dm.get_map_model_manager(model_file=data_pdb, map_files=[data_ccp4])
dm.get_map_model_manager(model_file=data_pdb,
map_files=[data_ccp4, data_ccp4, data_ccp4])
dm.get_map_model_manager(model_file=data_pdb,
map_files=data_ccp4,
ignore_symmetry_conflicts=True)
# errors
try:
dm.get_map_model_manager(model_file=data_pdb,
map_files=data_ccp4,
from_phil=True)
except Sorry as e:
assert 'from_phil is set to True' in str(e)
try:
dm.get_map_model_manager(model_file=data_pdb,
map_files=data_ccp4,
abc=123)
except TypeError as e:
assert 'unexpected keyword argument' in str(e)
try:
dm.get_map_model_manager(model_file=data_pdb,
map_files=[data_ccp4, data_ccp4])
except Sorry as e:
assert '1 full map and 2 half maps' in str(e)
# PHIL
class test_program(ProgramTemplate):
master_phil_str = '''
include scope iotbx.map_model_manager.map_model_phil_str
'''
working_phil_str = '''
map_model {
full_map = %s
half_map = %s
half_map = s.mrc
model = %s
}
''' % (data_ccp4, data_ccp4, data_pdb)
master_phil = parse(test_program.master_phil_str, process_includes=True)
working_phil = master_phil.fetch(parse(working_phil_str))
tp = test_program(dm, working_phil.extract())
try:
dm.get_map_model_manager(from_phil=True)
except Exception as e:
assert 'ignore_symmetry_conflicts' in str(e)
try:
dm.get_map_model_manager(from_phil=True,
ignore_symmetry_conflicts=True)
except AssertionError:
pass
def exercise(out=sys.stdout):
# test shift_aware_rt
mmm1, mmm2 = get_map_model_managers()
initial_shift_aware_rt_info = mmm1.shift_aware_rt_to_superpose_other(mmm2)
initial_rt_info = initial_shift_aware_rt_info.working_rt_info(
from_obj=mmm2, to_obj=mmm1)
model_2 = mmm2.model().apply_selection_string("resseq 222:235")
mmm2.set_model(model_2)
shift_aware_rt_info = mmm1.shift_aware_rt_to_superpose_other(mmm2)
rt_info = shift_aware_rt_info.working_rt_info(from_obj=mmm2, to_obj=mmm1)
assert shift_aware_rt_info.is_similar(initial_shift_aware_rt_info,
tol=0.002)
shift_aware_rt = mmm1.shift_aware_rt(working_rt_info=rt_info,
from_obj=mmm2,
to_obj=mmm1)
shift_aware_rt = mmm1.map_manager().shift_aware_rt(working_rt_info=rt_info,
from_obj=mmm2,
to_obj=mmm1)
print(mmm1, mmm2)
sites_cart_2 = mmm2.model().get_sites_cart()
mapped_sites_cart = shift_aware_rt.apply_rt(sites_cart=sites_cart_2,
from_obj=mmm2,
to_obj=mmm1)
assert approx_equal(
mapped_sites_cart,
mmm1.model().apply_selection_string("resseq 222:235").get_sites_cart(),
eps=0.01)
working_rt_info = shift_aware_rt.working_rt_info(from_obj=mmm2,
to_obj=mmm1)
mapped_sites_cart = working_rt_info.r.elems * mmm2.model().get_sites_cart(
) + working_rt_info.t.elems
assert approx_equal(
mapped_sites_cart,
mmm1.model().apply_selection_string("resseq 222:235").get_sites_cart(),
eps=0.01)
inverse_shift_aware_rt = shift_aware_rt.inverse()
mapped_sites_cart = inverse_shift_aware_rt.apply_rt(
sites_cart=mmm1.model().apply_selection_string(
"resseq 222:235").get_sites_cart(),
from_obj=mmm1,
to_obj=mmm2)
assert approx_equal(mapped_sites_cart,
mmm2.model().get_sites_cart(),
eps=0.01)
mmm1, mmm2 = get_map_model_managers()
# get r,t to map mmm2 model on mmm1 model
shift_aware_rt_info = mmm1.shift_aware_rt_to_superpose_other(mmm2)
rt_info = shift_aware_rt_info.working_rt_info(from_obj=mmm2, to_obj=mmm1)
print(rt_info)
# get mmm2 map superimposed on mmm1 map (in region where it is defined, zero
# outside that region)
new_mm = mmm1.superposed_map_manager_from_other(other=mmm2)
new_mm.write_map('super.ccp4')
mmm1.write_map('orig.ccp4')
mmm1.write_model('orig.pdb')
new_mm = mmm1.superposed_map_manager_from_other(
other=mmm2, selection_string="resseq 221:225")
assert approx_equal(new_mm.map_map_cc(mmm1.map_manager()),
0.994645868918,
eps=0.01)
new_mm.write_map('super_221-225.ccp4')
new_mm = mmm1.superposed_map_manager_from_other(other=mmm2,
working_rt_info=rt_info)
assert approx_equal(new_mm.map_map_cc(mmm1.map_manager()),
0.994645868918,
eps=0.01)
new_mm.write_map('super_221-225.ccp4')
# get a local resolution map (this one should look pretty constant!)
mmm1.set_resolution(3)
mmma = mmm1.deep_copy()
model = mmm1.model()
mmma.remove_model_by_id('model')
mmmb = mmma.deep_copy()
mmma.map_manager().randomize(random_seed=23412,
d_min=3,
high_resolution_fourier_noise_fraction=10,
low_resolution_noise_cutoff=5)
mmmb.map_manager().randomize(random_seed=887241,
d_min=3,
high_resolution_fourier_noise_fraction=10,
low_resolution_noise_cutoff=5)
assert approx_equal(mmma.map_manager().map_map_cc(mmmb.map_manager()),
0.16, 0.10)
from iotbx.map_model_manager import map_model_manager
model.set_b_iso(flex.double(model.get_sites_cart().size(), 0))
local_mmm = map_model_manager(map_manager_1=mmma.map_manager(),
map_manager_2=mmmb.map_manager(),
model=model)
local_mmm.set_resolution(3)
local_mmm.local_fsc()
from iotbx.data_manager import DataManager
dm = DataManager()
dm.set_overwrite(True)
cc_before = local_mmm.map_model_cc()
print("Working with randomized maps cc = ", cc_before)
dc = local_mmm.deep_copy()
dc.set_log(sys.stdout)
cc_before = dc.map_model_cc()
dc.half_map_sharpen(n_bins=15)
cc_after = dc.map_model_cc(map_id='map_manager_scaled')
print("CC before, after half map sharpen: ", cc_before, cc_after)
assert approx_equal((cc_before, cc_after), (0.80, 0.80), eps=0.10)
dc = local_mmm.deep_copy()
dc.set_log(sys.stdout)
cc_before = dc.map_model_cc()
dc.model_sharpen(n_bins=15,
local_sharpen=False,
anisotropic_sharpen=False,
optimize_b_eff=False)
cc_after = dc.map_model_cc(map_id='map_manager_scaled')
print("CC before, after std model sharpen: ", cc_before, cc_after)
assert approx_equal((cc_before, cc_after), (0.80, 0.90), eps=0.10)
model_sharpened_mm = dc.get_map_manager_by_id(map_id='map_manager_scaled')
dc = local_mmm.deep_copy()
dc.set_log(sys.stdout)
cc_before = dc.map_model_cc()
dc.model_sharpen(local_sharpen=True, n_boxes=1, n_bins=15)
cc_after = dc.map_model_cc(map_id='map_manager_scaled')
print("CC before, after local model sharpen n_boxes=1: ", cc_before,
cc_after)
assert approx_equal((cc_before, cc_after), (0.80, 0.90), eps=0.10)
model_sharpened_mm = dc.get_map_manager_by_id(map_id='map_manager_scaled')
dc = local_mmm.deep_copy()
dc.set_log(sys.stdout)
dc.add_map_manager_by_id(model_sharpened_mm, 'external_map')
cc_before = dc.map_map_cc(map_id='map_manager',
other_map_id='external_map')
dc.external_sharpen(n_bins=15, map_id_external_map='external_map')
print(dc)
cc_after = dc.map_map_cc(map_id='map_manager_scaled',
other_map_id='external_map')
print("CC before, after external sharpen n_boxes=1: ", cc_before, cc_after)
assert approx_equal((cc_before, cc_after), (0.7, 0.95), eps=0.10)
dc = local_mmm.deep_copy()
dc.set_log(sys.stdout)
dc.add_map_manager_by_id(model_sharpened_mm, 'external_map')
cc_before = dc.map_map_cc(map_id='map_manager',
other_map_id='external_map')
dc.external_sharpen(local_sharpen=True,
n_boxes=1,
n_bins=15,
map_id_external_map='external_map')
cc_after = dc.map_map_cc(map_id='map_manager_scaled',
other_map_id='external_map')
print("CC before, after external sharpen local n_boxes=1: ", cc_before,
cc_after)
assert approx_equal((cc_before, cc_after), (0.70, 0.95), eps=0.10)
dc = local_mmm.deep_copy()
dc.set_log(sys.stdout)
dc._local_sharpen(map_id_scaled_list=['map_manager_scaled'],
map_id_to_be_scaled_list=['map_manager'],
n_bins=15,
n_boxes=1)
cc = dc.map_model_cc()
assert approx_equal(cc, 0.80, eps=0.1)
# create a mask around density
dc.create_mask_around_density(soft_mask=False)
count = dc.get_map_manager_by_id('mask').map_data().count(1)
print(count)
assert 8000 < count < 14000
dc.expand_mask(buffer_radius=2)
count = dc.get_map_manager_by_id('mask').map_data().count(1)
print(count)
assert count == 1
# Test mask and map info functions
mmm1, mmm2 = get_map_model_managers()
mmm1.create_mask_around_density(soft_mask=False)
mask_info = mmm1.mask_info()
map_info = mmm1.map_info()
mask_info_by_id = mmm1.mask_info(mask_id='mask')
map_info_by_id = mmm1.map_info(map_id='map_manager')
assert mask_info() == mask_info_by_id()
assert map_info() == map_info_by_id()
assert approx_equal(mask_info.fraction_marked, 0.210091991342)
assert approx_equal(map_info.fraction_above_sigma_cutoff, 0.0577876984127)
# create a spherical mask around a point
print("Spherical masks", )
dc = mmm1.deep_copy()
dc.mask_info()
assert dc.mask_info().marked_points == 9318
dc.create_spherical_mask()
dc.mask_info()
assert dc.mask_info().marked_points == 1286
dc.create_spherical_mask(soft_mask_radius=1)
dc.mask_info()
assert dc.mask_info().marked_points == 8990
dc.create_spherical_mask(soft_mask=False)
dc.mask_info()
assert dc.mask_info().marked_points == 1458
dc.create_spherical_mask(mask_radius=4)
dc.mask_info()
assert dc.mask_info().marked_points == 914
dc.create_spherical_mask(soft_mask=False, mask_radius=4)
dc.mask_info()
assert dc.mask_info().marked_points == 654
def exercise(file_name=None, pdb_file_name = None, map_file_name = None ,
split_pdb_file_name = None,
out = sys.stdout):
# Set up source data
if not os.path.isfile(file_name):
raise Sorry("Missing the file: %s" %(file_name)+"\n")
print ("Reading from %s" %(file_name))
from iotbx.map_manager import map_manager
m = map_manager(file_name)
print ("Header information from %s:" %(file_name))
m.show_summary(out = out)
map_data = m.map_data().deep_copy()
crystal_symmetry = m.crystal_symmetry()
unit_cell_parameters = m.crystal_symmetry().unit_cell().parameters()
print ("\nMap origin: %s Extent %s" %( map_data.origin(), map_data.all()))
print ("Original unit cell, not just unit cell of part in this file): %s" %(
str(unit_cell_parameters)))
grid_point = (1, 2, 3)
if map_data.origin() != (0, 0, 0): # make sure it is inside
from scitbx.matrix import col
grid_point = tuple (col(grid_point)+col(map_data.origin()))
print ("\nValue of map_data at grid point %s: %.3f" %(str(grid_point),
map_data[grid_point]))
print ("Map data is %s" %(type(map_data)))
random_position = (10, 5, 7.9)
point_frac = crystal_symmetry.unit_cell().fractionalize(random_position)
value_at_point_frac = map_data.eight_point_interpolation(point_frac)
print ("Value of map_data at coordinates %s: %.3f" %(
str(random_position), value_at_point_frac))
map_data_as_float = map_data.as_float()
print ("Map data as float is %s" %(type(map_data_as_float)))
# make a little model
sites_cart = flex.vec3_double( ((8, 10, 12), (14, 15, 16)))
model = model_manager.from_sites_cart(
atom_name = ' CA ',
resname = 'ALA',
chain_id = 'A',
b_iso = 30.,
occ = 1.,
scatterer = 'C',
sites_cart = sites_cart,
crystal_symmetry = crystal_symmetry)
# Move map and a model to place origin at (0, 0, 0)
# map data is new copy but model is shifted in place.
from iotbx.map_model_manager import map_model_manager
mam = map_model_manager(
map_manager = m,
model = model.deep_copy(),
)
# Read in map and model and split up
dm = DataManager()
aa = dm.get_map_model_manager(model_file=pdb_file_name,
map_files=map_file_name)
bb = dm.get_map_model_manager(model_file=split_pdb_file_name,
map_files=map_file_name)
for selection_method in ['by_chain', 'by_segment','supplied_selections',
'boxes']:
if selection_method == 'boxes':
choices = [True, False]
else:
choices = [True]
if selection_method == 'by_chain':
mask_choices = [True,False]
else:
mask_choices = [False]
for select_final_boxes_based_on_model in choices:
for skip_empty_boxes in choices:
for mask_choice in mask_choices:
if mask_choice: # use split model
a=bb.deep_copy()
else: # usual
a=aa.deep_copy()
print ("\nRunning split_up_map_and_model with \n"+
"select_final_boxes_based_on_model="+
"%s skip_empty_boxes=%s selection_method=%s" %(
select_final_boxes_based_on_model,skip_empty_boxes,selection_method))
if selection_method == 'by_chain':
print ("Mask around unused atoms: %s" %(mask_choice))
box_info = a.split_up_map_and_model_by_chain(
mask_around_unselected_atoms=mask_choice)
elif selection_method == 'by_segment':
box_info = a.split_up_map_and_model_by_segment()
elif selection_method == 'supplied_selections':
selection = a.model().selection('all')
box_info = a.split_up_map_and_model_by_supplied_selections(
selection_list = [selection])
elif selection_method == 'boxes':
box_info = a.split_up_map_and_model_by_boxes(
skip_empty_boxes = skip_empty_boxes,
select_final_boxes_based_on_model =
select_final_boxes_based_on_model)
print (selection_method,skip_empty_boxes,
len(box_info.selection_list),
box_info.selection_list[0].count(True))
assert (selection_method,skip_empty_boxes,
len(box_info.selection_list),
box_info.selection_list[0].count(True)) in [
('by_chain',True,3,19),
("by_chain",True,1,86,),
("by_segment",True,1,86,),
("supplied_selections",True,1,86,),
("boxes",True,13,1,),
("boxes",False,36,0,),
("boxes",True,13,1,),
("boxes",False,36,0,),
]
# Change the coordinates in one box
small_model = box_info.mmm_list[0].model()
small_sites_cart = small_model.get_sites_cart()
from scitbx.matrix import col
small_sites_cart += col((1,0,0))
small_model.set_crystal_symmetry_and_sites_cart(
sites_cart = small_sites_cart,
crystal_symmetry = small_model.crystal_symmetry())
# Put everything back together
a.merge_split_maps_and_models(box_info = box_info)
mam.box_all_maps_around_model_and_shift_origin()
shifted_crystal_symmetry = mam.model().crystal_symmetry()
shifted_model = mam.model()
shifted_map_data = mam.map_data()
print ("\nOriginal map origin (grid units):", map_data.origin())
print ("Original model:\n", model.model_as_pdb())
print ("Shifted map origin:", shifted_map_data.origin())
print ("Shifted model:\n", shifted_model.model_as_pdb())
# Save the map_model manager
mam_dc=mam.deep_copy()
print ("dc",mam)
print ("dc mam_dc",mam_dc)
# Mask map around atoms
mam=mam_dc.deep_copy()
print ("dc mam_dc dc",mam_dc)
print (mam)
mam.mask_all_maps_around_atoms(mask_atoms_atom_radius = 3,
set_outside_to_mean_inside=True, soft_mask=False)
print ("Mean before masking", mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
-0.0585683621466)
print ("Max before masking", mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
-0.0585683621466)
# Mask map around atoms, with soft mask
mam=mam_dc.deep_copy()
mam.mask_all_maps_around_atoms(mask_atoms_atom_radius = 3, soft_mask = True,
soft_mask_radius = 5, set_outside_to_mean_inside=True)
print ("Mean after first masking", mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
-0.00177661714805)
print ("Max after first masking", mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
0.236853733659)
# Mask map around atoms again
mam.mask_all_maps_around_atoms(mask_atoms_atom_radius = 3,
set_outside_to_mean_inside = True, soft_mask=False)
print ("Mean after second masking", mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
-0.0585683621466)
print ("Max after second masking", mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
-0.0585683621466)
# Mask around edges
mam=mam_dc.deep_copy()
mam.mask_all_maps_around_edges( soft_mask_radius = 3)
print ("Mean after masking edges", mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
0.0155055604192)
print ("Max after masking edges", mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
0.249827131629)
print ("\nWriting map_data and model in shifted position (origin at 0, 0, 0)")
output_file_name = 'shifted_map.ccp4'
print ("Writing to %s" %(output_file_name))
mrcfile.write_ccp4_map(
file_name = output_file_name,
crystal_symmetry = shifted_crystal_symmetry,
map_data = shifted_map_data, )
output_file_name = 'shifted_model.pdb'
f = open(output_file_name, 'w')
print (shifted_model.model_as_pdb(), file=f)
f.close()
print ("\nWriting map_data and model in original position (origin at %s)" %(
str(mam.map_manager().origin_shift_grid_units)))
output_file_name = 'new_map_original_position.ccp4'
print ("Writing to %s" %(output_file_name))
mrcfile.write_ccp4_map(
file_name = output_file_name,
crystal_symmetry = shifted_crystal_symmetry,
map_data = shifted_map_data,
origin_shift_grid_units = mam.map_manager().origin_shift_grid_units)
print (shifted_model.model_as_pdb())
output_pdb_file_name = 'new_model_original_position.pdb'
f = open(output_pdb_file_name, 'w')
print (shifted_model.model_as_pdb(), file=f)
f.close()
# Write as mmcif
output_cif_file_name = 'new_model_original_position.cif'
f = open(output_cif_file_name, 'w')
print (shifted_model.model_as_mmcif(),file = f)
f.close()
# Read the new map and model
import iotbx.pdb
new_model = model_manager(
model_input = iotbx.pdb.input(
source_info = None,
lines = flex.split_lines(open(output_pdb_file_name).read())),
crystal_symmetry = crystal_symmetry)
assert new_model.model_as_pdb() == model.model_as_pdb()
new_model_from_cif = model_manager(
model_input = iotbx.pdb.input(
source_info = None,
lines = flex.split_lines(open(output_cif_file_name).read())),
crystal_symmetry = crystal_symmetry)
assert new_model_from_cif.model_as_pdb() == model.model_as_pdb()
# Read and box the original file again in case we modified m in any
# previous tests
m = map_manager(file_name)
mam=map_model_manager(model=model.deep_copy(),map_manager=m)
mam.box_all_maps_around_model_and_shift_origin()
file_name = output_file_name
print ("Reading from %s" %(file_name))
new_map = iotbx.mrcfile.map_reader(file_name = file_name, verbose = False)
new_map.data = new_map.data.shift_origin()
print ("Header information from %s:" %(file_name))
new_map.show_summary(out = out)
assert new_map.map_data().origin() == mam.map_manager().map_data().origin()
assert new_map.crystal_symmetry().is_similar_symmetry(mam.map_manager().crystal_symmetry())
# make a map_model_manager with lots of maps and model and ncs
from mmtbx.ncs.ncs import ncs
ncs_object=ncs()
ncs_object.set_unit_ncs()
mam = map_model_manager(
map_manager = m,
ncs_object = ncs_object,
map_manager_1 = m.deep_copy(),
map_manager_2 = m.deep_copy(),
extra_model_list = [model.deep_copy(),model.deep_copy()],
extra_model_id_list = ["model_1","model_2"],
extra_map_manager_list = [m.deep_copy(),m.deep_copy()],
extra_map_manager_id_list = ["extra_1","extra_2"],
model = model.deep_copy(),
)
# make a map_model_manager with lots of maps and model and ncs and run
# with wrapping and ignore_symmetry_conflicts on
from mmtbx.ncs.ncs import ncs
ncs_object=ncs()
ncs_object.set_unit_ncs()
m.set_ncs_object(ncs_object.deep_copy())
mam2 = map_model_manager(
map_manager = m.deep_copy(),
ncs_object = ncs_object.deep_copy(),
map_manager_1 = m.deep_copy(),
map_manager_2 = m.deep_copy(),
extra_model_list = [model.deep_copy(),model.deep_copy()],
extra_model_id_list = ["model_1","model_2"],
extra_map_manager_list = [m.deep_copy(),m.deep_copy()],
extra_map_manager_id_list = ["extra_1","extra_2"],
model = model.deep_copy(),
ignore_symmetry_conflicts = True,
wrapping = m.wrapping(),
)
assert mam.map_manager().is_similar(mam2.map_manager())
assert mam.map_manager().is_similar(mam2.map_manager_1())
for m in mam2.map_managers():
assert mam.map_manager().is_similar(m)
assert mam.model().shift_cart() == mam2.model().shift_cart()
assert mam.model().shift_cart() == mam2.get_model_by_id('model_2').shift_cart()
print ("OK")
def test_01():
# Source data
data_dir = os.path.dirname(os.path.abspath(__file__))
data_ccp4 = os.path.join(data_dir, 'data',
'non_zero_origin_map.ccp4')
data_pdb = os.path.join(data_dir, 'data',
'non_zero_origin_model.pdb')
data_ncs_spec = os.path.join(data_dir, 'data',
'non_zero_origin_ncs_spec.ncs_spec')
# Read in data
dm = DataManager(['ncs_spec','model', 'real_map', 'phil'])
dm.set_overwrite(True)
map_file=data_ccp4
dm.process_real_map_file(map_file)
mm = dm.get_real_map(map_file)
model_file=data_pdb
dm.process_model_file(model_file)
model = dm.get_model(model_file)
ncs_file=data_ncs_spec
dm.process_ncs_spec_file(ncs_file)
ncs = dm.get_ncs_spec(ncs_file)
mmm=map_model_manager(
model = model,
map_manager_1 = mm.deep_copy(),
map_manager_2 = mm.deep_copy(),
ncs_object = ncs,
wrapping = False)
mmm.add_map_manager_by_id(
map_id='external_map',map_manager=mmm.map_manager().deep_copy())
mmm.set_resolution(3)
mmm.set_log(sys.stdout)
dc = mmm.deep_copy()
# Model sharpening
mmm = dc.deep_copy()
tls_info=mmm.tls_from_map(n_bins=10,
model_id = 'model',
map_id = 'map_manager',
iterations = 1,
)
tlso = tls_info.tlso_list[0]
print ("t:", tlso.t)
print ("l:", tlso.l)
print ("s:", tlso.s)
print ("origin:", tlso.origin)
assert approx_equal(tlso.t,
(0.7920199173476214, 0.742281514408794, 0.7103008342583756, -0.05199687072329786, 0.04301326317889638, -0.0032498605215769945))
assert approx_equal(tlso.l,
(-0.0004103603606922303, -0.00042929108338180655, 0.0001519656028327732, -2.8489076942333132e-06, -6.23198622708519e-05, 3.694504506269563e-05))
assert approx_equal(tlso.s,
(5.562000065270741e-09, -5.108813278707348e-10, -4.132731326301999e-09, 7.925572910527853e-10, -2.7018794222798323e-09, 1.0742616538181975e-09, 7.501166703517675e-10, -1.0661760561475498e-09, -2.860120638319051e-09))
assert approx_equal(tlso.origin,
(-64.703319312974, -62.30575036040377, -63.74368724016462))
print("TLS: ",tlso.t,tlso.l,tlso.s,tlso.origin)
def run(args, out=None, verbose=True):
t0 = time.time()
if (out is None) : out = sys.stdout
from iotbx import file_reader
import iotbx.phil
cmdline = iotbx.phil.process_command_line_with_files(
args=args,
master_phil=master_phil,
pdb_file_def="model",
reflection_file_def="map_coeffs",
map_file_def="map_file",
cif_file_def="cif_file",
usage_string="""\
mmtbx.ringer model.pdb map_coeffs.mtz [cif_file ...] [options]
%s
""" % __doc__)
cmdline.work.show()
params = cmdline.work.extract()
validate_params(params)
pdb_in = file_reader.any_file(params.model, force_type="pdb")
pdb_in.check_file_type("pdb")
pdb_inp = iotbx.pdb.input(file_name=params.model)
model = mmtbx.model.manager(
model_input = pdb_inp)
crystal_symmetry_model = model.crystal_symmetry()
if crystal_symmetry_model is not None:
crystal_symmetry_model.show_summary()
hierarchy = model.get_hierarchy()
map_coeffs = map_inp = difference_map_coeffs = None
map_data, unit_cell = None, None
# get miller array if map coefficients are provided
if (params.map_coeffs is not None):
mtz_in = file_reader.any_file(params.map_coeffs, force_type="hkl")
mtz_in.check_file_type("hkl")
best_guess = None
best_labels = []
all_labels = []
for array in mtz_in.file_server.miller_arrays :
if (array.is_complex_array()):
labels = array.info().label_string()
if (labels == params.map_label):
map_coeffs = array
elif (labels == params.difference_map_label):
difference_map_coeffs = array
else :
if (params.map_label is None):
all_labels.append(labels)
if (labels.startswith("2FOFCWT") or labels.startswith("2mFoDFc") or
labels.startswith("FWT")):
best_guess = array
best_labels.append(labels)
if (params.difference_map_label is None):
if (labels.startswith("FOFCWT") or labels.startswith("DELFWT")):
difference_map_coeffs = array
if (map_coeffs is None):
if (len(all_labels) == 0):
raise Sorry("No valid (pre-weighted) map coefficients found in file.")
elif (best_guess is None):
raise Sorry("Couldn't automatically determine appropriate map labels. "+
"Choices:\n %s" % " \n".join(all_labels))
elif (len(best_labels) > 1):
raise Sorry("Multiple appropriate map coefficients found in file. "+
"Choices:\n %s" % "\n ".join(best_labels))
map_coeffs = best_guess
print(" Guessing %s for input map coefficients" % best_labels[0], file=out)
# get map_inp object and do sanity checks if map is provided
else :
ccp4_map_in = file_reader.any_file(params.map_file, force_type="ccp4_map")
ccp4_map_in.check_file_type("ccp4_map")
map_inp = ccp4_map_in.file_object
base = map_model_manager(
map_manager = map_inp,
model = model,
ignore_symmetry_conflicts = params.ignore_symmetry_conflicts)
cs_consensus = base.crystal_symmetry()
hierarchy = base.model().get_hierarchy()
map_data = base.map_data()
unit_cell = map_inp.grid_unit_cell()
hierarchy.atoms().reset_i_seq()
make_header("Iterating over residues", out=out)
t1 = time.time()
results = iterate_over_residues(
pdb_hierarchy=hierarchy,
map_coeffs=map_coeffs,
difference_map_coeffs=difference_map_coeffs,
map_data = map_data,
unit_cell = unit_cell,
params=params,
log=out).results
t2 = time.time()
if (verbose):
print("Time excluding I/O: %8.1fs" % (t2 - t1), file=out)
print("Overall runtime: %8.1fs" % (t2 - t0), file=out)
if (params.output_base is None):
pdb_base = os.path.basename(params.model)
params.output_base = os.path.splitext(pdb_base)[0] + "_ringer"
easy_pickle.dump("%s.pkl" % params.output_base, results)
print("Wrote %s.pkl" % params.output_base, file=out)
csv = "\n".join([ r.format_csv() for r in results ])
open("%s.csv" % params.output_base, "w").write(csv)
print("Wrote %s.csv" % params.output_base, file=out)
print("\nReference:", file=out)
print("""\
Lang PT, Ng HL, Fraser JS, Corn JE, Echols N, Sales M, Holton JM, Alber T.
Automated electron-density sampling reveals widespread conformational
polymorphism in proteins. Protein Sci. 2010 Jul;19(7):1420-31. PubMed PMID:
20499387""", file=out)
if (params.gui):
run_app(results)
else :
return results
def test_01():
data_dir = os.path.dirname(os.path.abspath(__file__))
data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4')
data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_model.pdb')
data_ncs_spec = os.path.join(data_dir, 'data',
'non_zero_origin_ncs_spec.ncs_spec')
dm = DataManager(['ncs_spec', 'model', 'real_map', 'phil'])
dm.set_overwrite(True)
# Read in map and model
map_file = data_ccp4
dm.process_real_map_file(map_file)
mm = dm.get_real_map(map_file)
model_file = data_pdb
dm.process_model_file(model_file)
model = dm.get_model(model_file)
ncs_file = data_ncs_spec
dm.process_ncs_spec_file(ncs_file)
ncs = dm.get_ncs_spec(ncs_file)
mmm = map_model_manager()
mmm.add_map_manager(mm)
mmm.add_model(model)
mmm.add_ncs_object(ncs)
original_ncs = mmm.ncs_object()
assert approx_equal(
(24.0528, 11.5833, 20.0004),
tuple(original_ncs.ncs_groups()[0].translations_orth()[-1]),
eps=0.1)
assert tuple(mmm._map_manager.origin_shift_grid_units) == (0, 0, 0)
# Shift origin to (0,0,0)
mmm.shift_origin()
assert tuple(mmm._map_manager.origin_shift_grid_units) == (100, 100, 100)
mmm.write_model('s.pdb')
mmm.write_map('s.mrc')
shifted_ncs = mmm.ncs_object()
assert approx_equal(
(-153.758, -74.044, -127.487),
tuple(shifted_ncs.ncs_groups()[0].translations_orth()[-1]),
eps=0.1)
# Shift a model and shift it back
model = mmm.model()
shifted_model = mmm.shift_model_to_match_working_map(model=model)
model_in_original_position = mmm.shift_model_to_match_original_map(
model=shifted_model)
assert (not approx_equal(
model.get_sites_cart(), shifted_model.get_sites_cart(), out=None))
assert approx_equal(model.get_sites_cart(),
model_in_original_position.get_sites_cart())
# Generate a map and model
mmm.generate_map()
model = mmm.model()
mm = mmm.map_manager()
assert approx_equal(model.get_sites_cart()[0], (14.476, 10.57, 8.34),
eps=0.01)
assert approx_equal(mm.map_data()[10, 10, 10], -0.0195, eps=0.001)
def test_01():
# Source data
data_dir = os.path.dirname(os.path.abspath(__file__))
data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4')
data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_model.pdb')
data_ncs_spec = os.path.join(data_dir, 'data',
'non_zero_origin_ncs_spec.ncs_spec')
# Read in data
dm = DataManager(['ncs_spec', 'model', 'real_map', 'phil'])
dm.set_overwrite(True)
map_file = data_ccp4
dm.process_real_map_file(map_file)
mm = dm.get_real_map(map_file)
model_file = data_pdb
dm.process_model_file(model_file)
model = dm.get_model(model_file)
ncs_file = data_ncs_spec
dm.process_ncs_spec_file(ncs_file)
ncs = dm.get_ncs_spec(ncs_file)
mmm = map_model_manager(model=model,
map_manager_1=mm.deep_copy(),
map_manager_2=mm.deep_copy(),
ncs_object=ncs,
wrapping=False)
mmm.add_map_manager_by_id(map_id='external_map',
map_manager=mmm.map_manager().deep_copy())
mmm.set_resolution(3)
mmm.set_log(sys.stdout)
dc = mmm.deep_copy()
# Model sharpening
mmm = dc.deep_copy()
tls_info = mmm.tls_from_map(
n_bins=10,
model_id='model',
map_id='map_manager',
iterations=1,
)
tlso = tls_info.tlso_list[0]
print("t:", tlso.t)
print("l:", tlso.l)
print("s:", tlso.s)
print("origin:", tlso.origin)
assert approx_equal(
tlso.t,
(1.180418902258779, 1.1747521845606608, 1.178996799712174,
-0.08474662674769494, -0.022609295693646402, 0.0649209491344932))
assert approx_equal(
tlso.l,
(-0.002159404807991249, -0.002107964765763024, 0.0008301439376854558,
-5.973347993775719e-05, -0.000134276871934738, -9.05515898670584e-05))
assert approx_equal(
tlso.s,
(2.9348223335616302e-08, 5.52441087256425e-09, -5.382459681103171e-09,
4.3530347434547015e-09, -2.3559464233595e-08, 4.217968590464982e-09,
-4.380707049750269e-09, 1.9232725033868253e-09,
-5.788759082799497e-09))
assert approx_equal(
tlso.origin,
(-64.70331931297399, -62.30573551948903, -63.743687240164604))
print("TLS: ", tlso.t, tlso.l, tlso.s, tlso.origin)
def test_01():
# Source data
data_dir = os.path.dirname(os.path.abspath(__file__))
data_ccp4 = os.path.join(data_dir, 'data', 'non_zero_origin_map.ccp4')
data_pdb = os.path.join(data_dir, 'data', 'non_zero_origin_model.pdb')
data_ncs_spec = os.path.join(data_dir, 'data',
'non_zero_origin_ncs_spec.ncs_spec')
# Read in data
dm = DataManager(['ncs_spec', 'model', 'real_map', 'phil'])
dm.set_overwrite(True)
map_file = data_ccp4
dm.process_real_map_file(map_file)
mm = dm.get_real_map(map_file)
model_file = data_pdb
dm.process_model_file(model_file)
model = dm.get_model(model_file)
ncs_file = data_ncs_spec
dm.process_ncs_spec_file(ncs_file)
ncs = dm.get_ncs_spec(ncs_file)
mmm = map_model_manager(model=model,
map_manager_1=mm.deep_copy(),
map_manager_2=mm.deep_copy(),
ncs_object=ncs,
wrapping=False)
mmm.add_map_manager_by_id(map_id='external_map',
map_manager=mmm.map_manager().deep_copy())
mmm.set_resolution(3)
mmm.set_log(sys.stdout)
dc = mmm.deep_copy()
# Model sharpening
mmm = dc.deep_copy()
tls_info = mmm.tls_from_map(
n_bins=10,
model_id='model',
map_id='map_manager',
iterations=1,
)
tlso = tls_info.tlso_list[0]
print("t:", tlso.t)
print("l:", tlso.l)
print("s:", tlso.s)
print("origin:", tlso.origin)
assert approx_equal(
tlso.t,
(0.6518723599417712, 0.6807846368236251, 0.6161941485135081,
-0.04791178588048965, -0.0014794039180157132, 0.032774655367019095))
assert approx_equal(tlso.l,
(-0.00020092054127279798, -9.557441568256003e-05,
-1.711699526358822e-05, -4.8893794663274e-05,
-2.026091444762368e-05, -2.194054393244713e-05))
assert approx_equal(
tlso.s,
(1.3393493443427932e-09, 3.660975429526433e-10, -6.07051859483934e-10,
4.1665859321329886e-10, -1.35856164931005e-09, 5.409502867516901e-10,
-5.4005830782848e-10, -1.2017586805521653e-09,
1.9212302485258283e-11))
assert approx_equal(
tlso.origin,
(-64.70331931297407, -62.305747062422725, -63.74368724016457))
print("TLS: ", tlso.t, tlso.l, tlso.s, tlso.origin)
