def show_patterson_peaks(self,
min_relative_peak_height=0.1,
show_at_least=3):
print("Patterson peaks for %s:" % str(self.input.info()))
reciprocal_map = self.input
if (reciprocal_map.anomalous_flag()):
reciprocal_map = reciprocal_map.average_bijvoet_mates()
patterson_map = reciprocal_map.patterson_map(
symmetry_flags=maptbx.use_space_group_symmetry)
patterson_map.apply_sigma_scaling()
peak_list = patterson_map.tags().peak_search(
map=patterson_map.real_map(),
parameters=maptbx.peak_search_parameters())
max_height = peak_list.heights()[0]
sym_equiv_origin = sgtbx.sym_equiv_sites(
unit_cell=patterson_map.unit_cell(),
space_group=patterson_map.space_group(),
original_site=(0, 0, 0))
print(" Fractional coordinates Height Distance from origin")
for i_peak in range(peak_list.size()):
height = peak_list.heights()[i_peak]
if (height < max_height * min_relative_peak_height
and i_peak > show_at_least):
break
site = peak_list.sites()[i_peak]
dist_info = sgtbx.min_sym_equiv_distance_info(
sym_equiv_origin, site)
print(" %8.4f %8.4f %8.4f" % (dist_info.sym_op() * site), end=' ')
print(" %8.3f %8.3f" % (height, dist_info.dist()))
print()
def _find_peaks(self, min_peak_peak_distance=1.5):
cg = maptbx.crystal_gridding(
space_group_info=self.model.crystal_symmetry().space_group_info(),
symmetry_flags=maptbx.use_space_group_symmetry,
unit_cell=self.unit_cell,
pre_determined_n_real=self.map_data.accessor().all())
cgt = maptbx.crystal_gridding_tags(gridding=cg)
peak_search_parameters = maptbx.peak_search_parameters(
peak_search_level=3,
max_peaks=0,
peak_cutoff=self.cutoff,
interpolate=True,
min_distance_sym_equiv=0,
general_positions_only=False, # ???????XXXXXXXXXXXXXX
min_cross_distance=min_peak_peak_distance,
min_cubicle_edge=5)
psr = cgt.peak_search(parameters=peak_search_parameters,
map=self.map_data).all(max_clusters=99999999)
# Convert peaks into water xray.structure
mean_b = flex.mean(self.model.get_hierarchy().atoms().extract_b())
sp = crystal.special_position_settings(self.model.crystal_symmetry())
scatterers = flex.xray_scatterer()
for site_frac in psr.sites():
sc = xray.scatterer(label="O",
site=site_frac,
u=adptbx.b_as_u(mean_b),
occupancy=1.0)
scatterers.append(sc)
self.xrs_water = xray.structure(sp, scatterers)
#
self.ma.add(" total peaks found: %d" %
self.xrs_water.scatterers().size())
self.ma.add(" B factors set to : %8.3f" % mean_b)
if (self.debug): self._write_pdb_file(file_name_prefix="hoh_all_peaks")
def __init__(self, f_in_p1, **kwds):
isinstance(f_in_p1, miller.array)
assert f_in_p1.space_group().type().hall_symbol() == ' P 1'
self.f_in_p1 = f_in_p1
adopt_optional_init_args(self, kwds)
self.search_parameters = maptbx.peak_search_parameters(
peak_search_level=3,
interpolate=True,
min_distance_sym_equiv=0.25,
)
self.space_group = sgtbx.space_group('P 1', t_den=sg_t_den)
self.origin = None
self.symmetry_pool = []
self.find_centring_translations()
if self.space_group.order_z() > 1:
f_in_centered = self.f_in_p1.customized_copy(
space_group_info=sgtbx.space_group_info(group=self.space_group)
).eliminate_sys_absent().merge_equivalents().array()
self.cb_op_to_primitive = \
f_in_centered.change_of_basis_op_to_primitive_setting()
self.f_in_p1 = f_in_centered.change_basis(self.cb_op_to_primitive)
self.space_group = self.f_in_p1.space_group()
else:
self.cb_op_to_primitive = sgtbx.change_of_basis_op()
self.f_in_p1 = self.f_in_p1.generate_bijvoet_mates()
self.find_space_group()
self.space_group = sgtbx.space_group(
self.space_group.type().hall_symbol(), t_den=sgtbx.sg_t_den)
self.space_group_info = sgtbx.space_group_info(group=self.space_group)
def __init__(self, f_in_p1, **kwds):
isinstance(f_in_p1, miller.array)
assert f_in_p1.space_group().type().hall_symbol() == ' P 1'
self.f_in_p1 = f_in_p1
adopt_optional_init_args(self, kwds)
self.search_parameters = maptbx.peak_search_parameters(
peak_search_level=3,
interpolate=True,
min_distance_sym_equiv=0.25,
)
self.space_group = sgtbx.space_group('P 1', t_den=sg_t_den)
self.origin = None
self.symmetry_pool = []
self.find_centring_translations()
if self.space_group.order_z() > 1:
f_in_centered = self.f_in_p1.customized_copy(
space_group_info=sgtbx.space_group_info(group=self.space_group)
).eliminate_sys_absent().merge_equivalents().array()
self.cb_op_to_primitive = \
f_in_centered.change_of_basis_op_to_primitive_setting()
self.f_in_p1 = f_in_centered.change_basis(self.cb_op_to_primitive)
self.space_group = self.f_in_p1.space_group()
else:
self.cb_op_to_primitive = sgtbx.change_of_basis_op()
self.f_in_p1 = self.f_in_p1.generate_bijvoet_mates()
self.find_space_group()
self.space_group = sgtbx.space_group(self.space_group.type().hall_symbol(),
t_den=sgtbx.sg_t_den)
self.space_group_info = sgtbx.space_group_info(group=self.space_group)
def f_calc_symmetrisations(f_obs, f_calc_in_p1, min_cc_peak_height):
# The fast correlation map as per cctbx.translation_search.fast_nv1995
# is computed and its peaks studied.
# Inspiration from phenix.substructure.hyss for the parameters tuning.
if 0: # Display f_calc_in_p1
from crys3d.qttbx import map_viewer
map_viewer.display(window_title="f_calc in P1 before fast CC",
fft_map=f_calc_in_p1.fft_map(),
iso_level_positive_range_fraction=0.8)
crystal_gridding = f_obs.crystal_gridding(
symmetry_flags=translation_search.symmetry_flags(
is_isotropic_search_model=False,
have_f_part=False),
resolution_factor=1/3
)
correlation_map = translation_search.fast_nv1995(
gridding=crystal_gridding.n_real(),
space_group=f_obs.space_group(),
anomalous_flag=f_obs.anomalous_flag(),
miller_indices_f_obs=f_obs.indices(),
f_obs=f_obs.data(),
f_part=flex.complex_double(), ## no sub-structure is already fixed
miller_indices_p1_f_calc=f_calc_in_p1.indices(),
p1_f_calc=f_calc_in_p1.data()).target_map()
if 0: # Display correlation_map
from crys3d.qttbx import map_viewer
map_viewer.display(window_title="Fast CC map",
raw_map=correlation_map,
unit_cell=f_calc_in_p1.unit_cell(),
positive_iso_level=0.8)
search_parameters = maptbx.peak_search_parameters(
peak_search_level=1,
peak_cutoff=0.5,
interpolate=True,
min_distance_sym_equiv=1e-6,
general_positions_only=False,
min_cross_distance=f_obs.d_min()/2)
## The correlation map is not a miller.fft_map, just a 3D flex.double
correlation_map_peaks = crystal_gridding.tags().peak_search(
map=correlation_map,
parameters=search_parameters)
# iterate over the strong peak; for each, shift and symmetrised f_calc
for peak in correlation_map_peaks:
if peak.height < min_cc_peak_height: break
sr = symmetry_search.shift_refinement(
f_obs, f_calc_in_p1, peak.site)
yield sr.symmetrised_shifted_sf.f_x, sr.shift, sr.goos.correlation
def show_fft(file="map_coeff.pickle", map_level=3.0):
cmd.delete("all")
map_coeff = easy_pickle.load(file)
map_coeff.show_summary()
fft_map = map_coeff.fft_map(symmetry_flags=maptbx.use_space_group_symmetry)
print "map gridding:", fft_map.n_real()
show_map(fft_map.unit_cell(), fft_map.real_map(), "fft_map", map_level)
clusters = fft_map.tags().peak_search(
parameters=maptbx.peak_search_parameters(min_distance_sym_equiv=3.0,
max_clusters=10),
map=fft_map.real_map()).all()
show_peaks(fft_map.unit_cell(), clusters)
cmd.zoom('all', 15.0) # zoom with additional border of 15 Ang.
print
def show_fft(file="map_coeff.pickle", map_level=3.0):
cmd.delete("all")
map_coeff = easy_pickle.load(file)
map_coeff.show_summary()
fft_map = map_coeff.fft_map(
symmetry_flags=maptbx.use_space_group_symmetry)
print "map gridding:", fft_map.n_real()
show_map(fft_map.unit_cell(), fft_map.real_map(), "fft_map", map_level)
clusters = fft_map.tags().peak_search(
parameters=maptbx.peak_search_parameters(
min_distance_sym_equiv=3.0,
max_clusters=10),
map=fft_map.real_map()).all()
show_peaks(fft_map.unit_cell(), clusters)
cmd.zoom('all', 15.0) # zoom with additional border of 15 Ang.
print
def f_calc_symmetrisations(f_obs, f_calc_in_p1, min_cc_peak_height):
# The fast correlation map as per cctbx.translation_search.fast_nv1995
# is computed and its peaks studied.
# Inspiration from phenix.substructure.hyss for the parameters tuning.
if 0: # Display f_calc_in_p1
from crys3d.qttbx import map_viewer
map_viewer.display(window_title="f_calc in P1 before fast CC",
fft_map=f_calc_in_p1.fft_map(),
iso_level_positive_range_fraction=0.8)
crystal_gridding = f_obs.crystal_gridding(
symmetry_flags=translation_search.symmetry_flags(
is_isotropic_search_model=False, have_f_part=False),
resolution_factor=1 / 3)
correlation_map = translation_search.fast_nv1995(
gridding=crystal_gridding.n_real(),
space_group=f_obs.space_group(),
anomalous_flag=f_obs.anomalous_flag(),
miller_indices_f_obs=f_obs.indices(),
f_obs=f_obs.data(),
f_part=flex.complex_double(), ## no sub-structure is already fixed
miller_indices_p1_f_calc=f_calc_in_p1.indices(),
p1_f_calc=f_calc_in_p1.data()).target_map()
if 0: # Display correlation_map
from crys3d.qttbx import map_viewer
map_viewer.display(window_title="Fast CC map",
raw_map=correlation_map,
unit_cell=f_calc_in_p1.unit_cell(),
positive_iso_level=0.8)
search_parameters = maptbx.peak_search_parameters(
peak_search_level=1,
peak_cutoff=0.5,
interpolate=True,
min_distance_sym_equiv=1e-6,
general_positions_only=False,
min_cross_distance=f_obs.d_min() / 2)
## The correlation map is not a miller.fft_map, just a 3D flex.double
correlation_map_peaks = crystal_gridding.tags().peak_search(
map=correlation_map, parameters=search_parameters)
# iterate over the strong peak; for each, shift and symmetrised f_calc
for peak in correlation_map_peaks:
if peak.height < min_cc_peak_height: break
sr = symmetry_search.shift_refinement(f_obs, f_calc_in_p1, peak.site)
yield sr.symmetrised_shifted_sf.f_x, sr.shift, sr.goos.correlation
def _find_peaks(self, min_peak_peak_distance=1.5):
cg = maptbx.crystal_gridding(
space_group_info=self.model.crystal_symmetry().space_group_info(),
symmetry_flags=maptbx.use_space_group_symmetry,
unit_cell=self.unit_cell,
pre_determined_n_real=self.map_data.accessor().all())
cgt = maptbx.crystal_gridding_tags(gridding=cg)
peak_search_parameters = maptbx.peak_search_parameters(
peak_search_level=3,
max_peaks=0,
peak_cutoff=self.cutoff,
interpolate=True,
min_distance_sym_equiv=0,
general_positions_only=False, # ???????XXXXXXXXXXXXXX
min_cross_distance=min_peak_peak_distance,
min_cubicle_edge=5)
psr = cgt.peak_search(parameters=peak_search_parameters,
map=self.map_data).all(max_clusters=99999999)
self.sites_frac_water = psr.sites()
self.ma.add(" total peaks found: %d" % self.sites_frac_water.size())
if (self.debug): self._write_pdb_file(file_name_prefix="hoh_all_peaks")
def show_patterson_peaks(self, min_relative_peak_height=0.1, show_at_least=3):
print "Patterson peaks for %s:" % str(self.input.info())
reciprocal_map = self.input
if reciprocal_map.anomalous_flag():
reciprocal_map = reciprocal_map.average_bijvoet_mates()
patterson_map = reciprocal_map.patterson_map(symmetry_flags=maptbx.use_space_group_symmetry)
patterson_map.apply_sigma_scaling()
peak_list = patterson_map.tags().peak_search(
map=patterson_map.real_map(), parameters=maptbx.peak_search_parameters()
)
max_height = peak_list.heights()[0]
sym_equiv_origin = sgtbx.sym_equiv_sites(
unit_cell=patterson_map.unit_cell(), space_group=patterson_map.space_group(), original_site=(0, 0, 0)
)
print " Fractional coordinates Height Distance from origin"
for i_peak in xrange(peak_list.size()):
height = peak_list.heights()[i_peak]
if height < max_height * min_relative_peak_height and i_peak > show_at_least:
break
site = peak_list.sites()[i_peak]
dist_info = sgtbx.min_sym_equiv_distance_info(sym_equiv_origin, site)
print " %8.4f %8.4f %8.4f" % (dist_info.sym_op() * site),
print " %8.3f %8.3f" % (height, dist_info.dist())
print
def __init__(self,
fmodel,
map_type,
map_cutoff,
params=None,
log=None,
use_all_data=True,
silent=False,
map_coeffs=None):
adopt_init_args(self, locals())
assert (map_type is not None) or (map_coeffs is not None)
self.mapped = False
self.peaks_ = None
if (self.log is None): self.log = sys.stdout
if (self.params is None): self.params = master_params.extract()
if (map_coeffs is not None):
fft_map = map_coeffs.fft_map(
resolution_factor=self.params.resolution_factor,
symmetry_flags=maptbx.use_space_group_symmetry)
if (self.params.use_sigma_scaled_maps):
fft_map.apply_sigma_scaling()
map_units = "sigma"
else:
fft_map.apply_volume_scaling()
map_units = "e/A**3"
fft_map_data = fft_map.real_map_unpadded()
else:
fft_map = self.fmodel.electron_density_map().\
fft_map(resolution_factor = self.params.resolution_factor,
symmetry_flags = maptbx.use_space_group_symmetry,
map_type = self.map_type,
use_all_data = use_all_data)
if (self.params.use_sigma_scaled_maps):
fft_map.apply_sigma_scaling()
map_units = "sigma"
else:
fft_map.apply_volume_scaling()
map_units = "e/A**3"
fft_map_data = fft_map.real_map_unpadded()
crystal_gridding_tags = fft_map.tags()
max_number_of_peaks = self.params.max_number_of_peaks
if (self.params.max_number_of_peaks is None):
max_number_of_peaks = self.fmodel.xray_structure.scatterers().size(
) * 5
negative = False
if (self.map_cutoff < 0):
self.map_cutoff *= -1
negative = True
fft_map_data *= -1
min_distance_sym_equiv = self.params.peak_search.min_distance_sym_equiv
if (min_distance_sym_equiv is None):
min_distance_sym_equiv = \
self.fmodel.xray_structure.min_distance_sym_equiv()
peak_search_parameters = maptbx.peak_search_parameters(
peak_search_level=self.params.peak_search.peak_search_level,
max_peaks=self.params.peak_search.max_peaks,
peak_cutoff=self.map_cutoff,
interpolate=self.params.peak_search.interpolate,
min_distance_sym_equiv=min_distance_sym_equiv,
general_positions_only=self.params.peak_search.
general_positions_only,
min_cross_distance=self.params.peak_search.min_cross_distance,
min_cubicle_edge=self.params.peak_search.min_cubicle_edge)
if (self.fmodel.r_work() > 0.00001 and self.fmodel.r_free() > 0.00001):
cluster_analysis = crystal_gridding_tags.peak_search(
parameters=peak_search_parameters,
map=fft_map_data).all(max_clusters=max_number_of_peaks)
heights = cluster_analysis.heights()
if (negative):
heights *= -1.
self.peaks_ = peaks_holder(heights=heights,
sites=cluster_analysis.sites())
if (not self.silent):
print(
"Number of peaks found at %s map (map cutoff=%s %s)= %s" %
(self.map_type, format_value(
"%-5.2f", self.map_cutoff).strip(), map_units,
format_value("%-12d", self.peaks_.sites.size())),
file=self.log)
def run():
import sys
reflection_file_name = sys.argv[1]
import iotbx.cif
miller_arrays = iotbx.cif.reader(
file_path=reflection_file_name).as_miller_arrays()
for miller_array in miller_arrays:
s = str(miller_array.info())
if '_meas' in s:
if miller_array.is_xray_intensity_array():
break
elif miller_array.is_xray_amplitude_array():
break
if not ('_meas' in str(miller_array.info())
and (miller_array.is_xray_amplitude_array()
or miller_array.is_xray_intensity_array())):
print "Sorry: CIF does not contain an appropriate miller array"
return
miller_array.show_comprehensive_summary()
print
if (miller_array.is_xray_intensity_array()):
print "Converting intensities to amplitudes."
miller_array = miller_array.as_amplitude_array()
print
miller_array.setup_binner(auto_binning=True)
miller_array.binner().show_summary()
print
all_e_values = miller_array.quasi_normalize_structure_factors().sort(
by_value="data")
large_e_values = all_e_values.select(all_e_values.data() > 1.2)
print "number of large_e_values:", large_e_values.size()
print
from cctbx import dmtbx
triplets = dmtbx.triplet_generator(large_e_values)
from cctbx.array_family import flex
print "triplets per reflection: min,max,mean: %d, %d, %.2f" % (
flex.min(triplets.n_relations()),
flex.max(triplets.n_relations()),
flex.mean(triplets.n_relations().as_double()))
print "total number of triplets:", flex.sum(triplets.n_relations())
print
input_phases = large_e_values \
.random_phases_compatible_with_phase_restrictions()
tangent_formula_phases = input_phases.data()
for i in xrange(10):
tangent_formula_phases = triplets.apply_tangent_formula(
amplitudes=large_e_values.data(),
phases_rad=tangent_formula_phases,
selection_fixed=None,
use_fixed_only=False,
reuse_results=True)
e_map_coeff = large_e_values.phase_transfer(
phase_source=tangent_formula_phases)
from cctbx import maptbx
e_map = e_map_coeff.fft_map(
symmetry_flags=maptbx.use_space_group_symmetry)
e_map.apply_sigma_scaling()
e_map.statistics().show_summary(prefix="e_map ")
print
peak_search = e_map.peak_search(parameters=maptbx.peak_search_parameters(
min_distance_sym_equiv=1.2))
peaks = peak_search.all(max_clusters=10)
print "e_map peak list"
print " fractional coordinates peak height"
for site,height in zip(peaks.sites(), peaks.heights()):
print " (%9.6f, %9.6f, %9.6f)" % site, "%10.3f" % height
print
if (len(sys.argv) > 2):
coordinate_file_name = sys.argv[2]
xray_structure = iotbx.cif.reader(
file_path=coordinate_file_name).build_crystal_structures(
data_block_name="I")
xray_structure.show_summary().show_scatterers()
print
f_calc = abs(miller_array.structure_factors_from_scatterers(
xray_structure=xray_structure,
algorithm="direct").f_calc())
correlation = flex.linear_correlation(f_calc.data(), miller_array.data())
assert correlation.is_well_defined()
print "correlation of f_obs and f_calc: %.4f" % correlation.coefficient()
print
reference_model = xray_structure.as_emma_model()
assert reference_model.unit_cell().is_similar_to(e_map.unit_cell())
assert reference_model.space_group() == e_map.space_group()
from cctbx import euclidean_model_matching as emma
peak_model = emma.model(special_position_settings=reference_model)
for i,site in enumerate(peaks.sites()):
peak_model.add_position(emma.position(label="peak%02d" % i, site=site))
matches = emma.model_matches(
model1=reference_model,
model2=peak_model,
tolerance=1.,
models_are_diffraction_index_equivalent=True)
for match in matches.refined_matches:
match.show()
def exercise_one_structure(
target_structure,
flipping_type,
anomalous_flag,
d_min,
grid_resolution_factor=1. / 2,
verbose=False,
amplitude_type="F",
):
assert amplitude_type in ('F', 'E', 'quasi-E')
# Generate its structure factors
f_target = miller.build_set(
crystal_symmetry=target_structure,
anomalous_flag=target_structure.scatterers().count_anomalous() != 0,
d_min=d_min).structure_factors_from_scatterers(
xray_structure=target_structure, algorithm="direct").f_calc()
f_target_in_p1 = f_target.expand_to_p1()\
.as_non_anomalous_array()\
.merge_equivalents().array()
f_obs = f_target.as_amplitude_array()
# Unleash charge flipping on the amplitudes
flipping = flipping_type(delta=None)
extra = group_args()
if amplitude_type == 'E':
extra.normalisations_for = lambda f: f.amplitude_normalisations(
target_structure.unit_cell_content(omit=('H', 'D')))
elif amplitude_type == 'quasi-E':
extra.normalisations_for = charge_flipping.amplitude_quasi_normalisations
solving = charge_flipping.solving_iterator(
flipping,
f_obs,
yield_during_delta_guessing=True,
yield_solving_interval=1,
**extra.__dict__)
s = StringIO()
charge_flipping.loop(solving, verbose="highly", out=s)
if verbose:
print s.getvalue()
# check whether a phase transition has occured
assert solving.had_phase_transition
flipping = solving.flipping_iterator
f_result_in_p1 = solving.flipping_iterator.f_calc
# Euclidean matching of the peaks from the obtained map
# against those of the correct structure (in P1)
target_structure = target_structure.select(
target_structure.scattering_types() == "H", negate=True)
target_structure_in_p1 = target_structure.expand_to_p1()
search_parameters = maptbx.peak_search_parameters(
interpolate=True,
min_distance_sym_equiv=1.,
max_clusters=int(target_structure_in_p1.scatterers().size() * 1.2))
peak_search_outcome = flipping.rho_map.peak_search(search_parameters)
peak_structure = emma.model(
target_structure_in_p1.crystal_symmetry().special_position_settings(),
positions=[
emma.position('Q%i' % i, x)
for i, x in enumerate(peak_search_outcome.all().sites())
])
refined_matches = emma.model_matches(
target_structure_in_p1.as_emma_model(),
peak_structure,
tolerance=0.5,
break_if_match_with_no_singles=False).refined_matches
m = refined_matches[0]
assert m.rms < 0.2, m.rms # no farther than that
assert m.rt.r in (mat.identity(3), mat.inversion(3))
reference_shift = -refined_matches[0].rt.t
# Find the translation to bring back the structure to the same space-group
# setting as the starting f_obs from correlation map analysis
is_allowed = lambda x: f_target.space_group_info().is_allowed_origin_shift(
x, tolerance=0.1)
first_correct_correlation_peak = None
for i, (f_calc, shift,
cc_peak_height) in enumerate(solving.f_calc_solutions):
if (is_allowed(shift - reference_shift)
or is_allowed(shift + reference_shift)):
first_correct_correlation_peak = i
break
else:
if verbose == "more":
print "++ Incorrect peak: shift=(%.3f, %.3f, %.3f), height=%.2f"\
% (tuple(shift)+(cc_peak_height,))
print " Reference shift=(%.3f, %.3f, %.3f)" % tuple(
reference_shift)
assert first_correct_correlation_peak is not None
if verbose and first_correct_correlation_peak != 0:
print "** First correct correlation peak: #%i (%.3f) **"\
% (first_correct_correlation_peak, cc_peak_height)
# check Euclidean matching in the original space-group
search_parameters = maptbx.peak_search_parameters(
interpolate=True,
min_distance_sym_equiv=1.,
max_clusters=int(1.5 * target_structure.scatterers().size()))
solution_fft_map = f_calc.fft_map(
symmetry_flags=maptbx.use_space_group_symmetry)
solution_peaks = solution_fft_map.peak_search(search_parameters,
verify_symmetry=False)
solution_peak_structure = emma.model(
target_structure.crystal_symmetry().special_position_settings(),
positions=[
emma.position('Q%i' % i, x)
for i, x in enumerate(solution_peaks.all().sites())
])
refined_matches = emma.model_matches(
target_structure.as_emma_model(),
solution_peak_structure,
break_if_match_with_no_singles=False).refined_matches
assert refined_matches
m = refined_matches[0]
assert not m.singles1, m.show() # all sites match a peak
assert m.rms < 0.15, m.rms # no farther than that
assert m.rt.r in (mat.identity(3), mat.inversion(3))
# success!
if verbose:
print "@@ Success @@"
def __init__(self,
fmodel,
map_type,
map_cutoff,
params = None,
log = None,
use_all_data = True,
silent = False,
map_coeffs=None):
adopt_init_args(self, locals())
assert (map_type is not None) or (map_coeffs is not None)
self.mapped = False
self.peaks_ = None
if(self.log is None): self.log = sys.stdout
if(self.params is None): self.params = master_params.extract()
if (map_coeffs is not None) :
fft_map = map_coeffs.fft_map(
resolution_factor=self.params.resolution_factor,
symmetry_flags=maptbx.use_space_group_symmetry)
if(self.params.use_sigma_scaled_maps):
fft_map.apply_sigma_scaling()
map_units = "sigma"
else:
fft_map.apply_volume_scaling()
map_units = "e/A**3"
fft_map_data = fft_map.real_map_unpadded()
else:
fft_map = self.fmodel.electron_density_map().\
fft_map(resolution_factor = self.params.resolution_factor,
symmetry_flags = maptbx.use_space_group_symmetry,
map_type = self.map_type,
use_all_data = use_all_data)
if(self.params.use_sigma_scaled_maps):
fft_map.apply_sigma_scaling()
map_units = "sigma"
else:
fft_map.apply_volume_scaling()
map_units = "e/A**3"
fft_map_data = fft_map.real_map_unpadded()
crystal_gridding_tags = fft_map.tags()
max_number_of_peaks = self.params.max_number_of_peaks
if(self.params.max_number_of_peaks is None):
max_number_of_peaks = self.fmodel.xray_structure.scatterers().size() * 5
negative = False
if(self.map_cutoff < 0):
self.map_cutoff *= -1
negative = True
fft_map_data *= -1
min_distance_sym_equiv = self.params.peak_search.min_distance_sym_equiv
if(min_distance_sym_equiv is None):
min_distance_sym_equiv = \
self.fmodel.xray_structure.min_distance_sym_equiv()
peak_search_parameters = maptbx.peak_search_parameters(
peak_search_level = self.params.peak_search.peak_search_level,
max_peaks = self.params.peak_search.max_peaks,
peak_cutoff = self.map_cutoff,
interpolate = self.params.peak_search.interpolate,
min_distance_sym_equiv = min_distance_sym_equiv,
general_positions_only = self.params.peak_search.general_positions_only,
min_cross_distance = self.params.peak_search.min_cross_distance,
min_cubicle_edge = self.params.peak_search.min_cubicle_edge)
if(self.fmodel.r_work() > 0.00001 and self.fmodel.r_free() > 0.00001):
cluster_analysis = crystal_gridding_tags.peak_search(
parameters = peak_search_parameters,
map = fft_map_data).all(max_clusters = max_number_of_peaks)
heights = cluster_analysis.heights()
if(negative):
heights *= -1.
self.peaks_ = peaks_holder(heights = heights,
sites = cluster_analysis.sites())
if(not self.silent):
print >>self.log,"Number of peaks found at %s map (map cutoff=%s %s)= %s"%(
self.map_type, format_value("%-5.2f", self.map_cutoff).strip(),
map_units, format_value("%-12d", self.peaks_.sites.size()))
def run():
import sys
reflection_file_name = sys.argv[1]
import iotbx.cif
miller_arrays = iotbx.cif.reader(
file_path=reflection_file_name).as_miller_arrays()
for miller_array in miller_arrays:
s = str(miller_array.info())
if '_meas' in s:
if miller_array.is_xray_intensity_array():
break
elif miller_array.is_xray_amplitude_array():
break
if not ('_meas' in str(miller_array.info()) and
(miller_array.is_xray_amplitude_array()
or miller_array.is_xray_intensity_array())):
print "Sorry: CIF does not contain an appropriate miller array"
return
miller_array.show_comprehensive_summary()
print
if (miller_array.is_xray_intensity_array()):
print "Converting intensities to amplitudes."
miller_array = miller_array.as_amplitude_array()
print
miller_array.setup_binner(auto_binning=True)
miller_array.binner().show_summary()
print
all_e_values = miller_array.quasi_normalize_structure_factors().sort(
by_value="data")
large_e_values = all_e_values.select(all_e_values.data() > 1.2)
print "number of large_e_values:", large_e_values.size()
print
from cctbx import dmtbx
triplets = dmtbx.triplet_generator(large_e_values)
from cctbx.array_family import flex
print "triplets per reflection: min,max,mean: %d, %d, %.2f" % (
flex.min(triplets.n_relations()), flex.max(triplets.n_relations()),
flex.mean(triplets.n_relations().as_double()))
print "total number of triplets:", flex.sum(triplets.n_relations())
print
input_phases = large_e_values \
.random_phases_compatible_with_phase_restrictions()
tangent_formula_phases = input_phases.data()
for i in xrange(10):
tangent_formula_phases = triplets.apply_tangent_formula(
amplitudes=large_e_values.data(),
phases_rad=tangent_formula_phases,
selection_fixed=None,
use_fixed_only=False,
reuse_results=True)
e_map_coeff = large_e_values.phase_transfer(
phase_source=tangent_formula_phases)
from cctbx import maptbx
e_map = e_map_coeff.fft_map(symmetry_flags=maptbx.use_space_group_symmetry)
e_map.apply_sigma_scaling()
e_map.statistics().show_summary(prefix="e_map ")
print
peak_search = e_map.peak_search(parameters=maptbx.peak_search_parameters(
min_distance_sym_equiv=1.2))
peaks = peak_search.all(max_clusters=10)
print "e_map peak list"
print " fractional coordinates peak height"
for site, height in zip(peaks.sites(), peaks.heights()):
print " (%9.6f, %9.6f, %9.6f)" % site, "%10.3f" % height
print
if (len(sys.argv) > 2):
coordinate_file_name = sys.argv[2]
xray_structure = iotbx.cif.reader(
file_path=coordinate_file_name).build_crystal_structures(
data_block_name="I")
xray_structure.show_summary().show_scatterers()
print
f_calc = abs(
miller_array.structure_factors_from_scatterers(
xray_structure=xray_structure, algorithm="direct").f_calc())
correlation = flex.linear_correlation(f_calc.data(),
miller_array.data())
assert correlation.is_well_defined()
print "correlation of f_obs and f_calc: %.4f" % correlation.coefficient(
)
print
reference_model = xray_structure.as_emma_model()
assert reference_model.unit_cell().is_similar_to(e_map.unit_cell())
assert reference_model.space_group() == e_map.space_group()
from cctbx import euclidean_model_matching as emma
peak_model = emma.model(special_position_settings=reference_model)
for i, site in enumerate(peaks.sites()):
peak_model.add_position(
emma.position(label="peak%02d" % i, site=site))
matches = emma.model_matches(
model1=reference_model,
model2=peak_model,
tolerance=1.,
models_are_diffraction_index_equivalent=True)
for match in matches.refined_matches:
match.show()
def exercise_one_structure(
target_structure,
flipping_type,
anomalous_flag,
d_min,
grid_resolution_factor=1.0 / 2,
verbose=False,
amplitude_type="F",
):
assert amplitude_type in ("F", "E", "quasi-E")
# Generate its structure factors
f_target = (
miller.build_set(
crystal_symmetry=target_structure,
anomalous_flag=target_structure.scatterers().count_anomalous() != 0,
d_min=d_min,
)
.structure_factors_from_scatterers(xray_structure=target_structure, algorithm="direct")
.f_calc()
)
f_target_in_p1 = f_target.expand_to_p1().as_non_anomalous_array().merge_equivalents().array()
f_obs = f_target.as_amplitude_array()
# Unleash charge flipping on the amplitudes
flipping = flipping_type(delta=None)
extra = group_args()
if amplitude_type == "E":
extra.normalisations_for = lambda f: f.amplitude_normalisations(
target_structure.unit_cell_content(omit=("H", "D"))
)
elif amplitude_type == "quasi-E":
extra.normalisations_for = charge_flipping.amplitude_quasi_normalisations
solving = charge_flipping.solving_iterator(
flipping, f_obs, yield_during_delta_guessing=True, yield_solving_interval=1, **extra.__dict__
)
s = StringIO()
charge_flipping.loop(solving, verbose="highly", out=s)
if verbose:
print s.getvalue()
# check whether a phase transition has occured
assert solving.had_phase_transition
flipping = solving.flipping_iterator
f_result_in_p1 = solving.flipping_iterator.f_calc
# Euclidean matching of the peaks from the obtained map
# against those of the correct structure (in P1)
target_structure = target_structure.select(target_structure.scattering_types() == "H", negate=True)
target_structure_in_p1 = target_structure.expand_to_p1()
search_parameters = maptbx.peak_search_parameters(
interpolate=True, min_distance_sym_equiv=1.0, max_clusters=int(target_structure_in_p1.scatterers().size() * 1.2)
)
peak_search_outcome = flipping.rho_map.peak_search(search_parameters)
peak_structure = emma.model(
target_structure_in_p1.crystal_symmetry().special_position_settings(),
positions=[emma.position("Q%i" % i, x) for i, x in enumerate(peak_search_outcome.all().sites())],
)
refined_matches = emma.model_matches(
target_structure_in_p1.as_emma_model(), peak_structure, tolerance=0.5, break_if_match_with_no_singles=False
).refined_matches
m = refined_matches[0]
assert m.rms < 0.2, m.rms # no farther than that
assert m.rt.r in (mat.identity(3), mat.inversion(3))
reference_shift = -refined_matches[0].rt.t
# Find the translation to bring back the structure to the same space-group
# setting as the starting f_obs from correlation map analysis
is_allowed = lambda x: f_target.space_group_info().is_allowed_origin_shift(x, tolerance=0.1)
first_correct_correlation_peak = None
for i, (f_calc, shift, cc_peak_height) in enumerate(solving.f_calc_solutions):
if is_allowed(shift - reference_shift) or is_allowed(shift + reference_shift):
first_correct_correlation_peak = i
break
else:
if verbose == "more":
print "++ Incorrect peak: shift=(%.3f, %.3f, %.3f), height=%.2f" % (tuple(shift) + (cc_peak_height,))
print " Reference shift=(%.3f, %.3f, %.3f)" % tuple(reference_shift)
assert first_correct_correlation_peak is not None
if verbose and first_correct_correlation_peak != 0:
print "** First correct correlation peak: #%i (%.3f) **" % (first_correct_correlation_peak, cc_peak_height)
# check Euclidean matching in the original space-group
search_parameters = maptbx.peak_search_parameters(
interpolate=True, min_distance_sym_equiv=1.0, max_clusters=int(1.5 * target_structure.scatterers().size())
)
solution_fft_map = f_calc.fft_map(symmetry_flags=maptbx.use_space_group_symmetry)
solution_peaks = solution_fft_map.peak_search(search_parameters, verify_symmetry=False)
solution_peak_structure = emma.model(
target_structure.crystal_symmetry().special_position_settings(),
positions=[emma.position("Q%i" % i, x) for i, x in enumerate(solution_peaks.all().sites())],
)
refined_matches = emma.model_matches(
target_structure.as_emma_model(), solution_peak_structure, break_if_match_with_no_singles=False
).refined_matches
assert refined_matches
m = refined_matches[0]
assert not m.singles1, m.show() # all sites match a peak
assert m.rms < 0.15, m.rms # no farther than that
assert m.rt.r in (mat.identity(3), mat.inversion(3))
# success!
if verbose:
print "@@ Success @@"
