def exercise_cc_peak():
def get_map():
av = [random.random() for i in xrange(10*20*30)]
m = flex.double(av)
m = m-flex.min(m)
m = m/flex.max(m)
m.resize(flex.grid((10,20,30)))
return m
m1 = get_map()
m2 = get_map()
for t in range(0,11):
t=t/10.
ccp=maptbx.cc_peak(map_1=m1, map_2=m2, cutoff=t)
#
sites_frac = flex.vec3_double([
(0.50,0.50,0.50)])
from cctbx import xray
xray_structure = xray.structure(
crystal_symmetry=crystal.symmetry(
unit_cell=(5,5,5,90,90,90),
space_group_symbol="P1"),
scatterers=flex.xray_scatterer([
xray.scatterer(label=str(i), scattering_type="C", site=site_frac)
for i,site_frac in enumerate(sites_frac)]))
fc1 = xray_structure.structure_factors(d_min=1.6).f_calc()
fc2 = xray_structure.structure_factors(d_min=1.7).f_calc()
for t in range(0,11):
t=t/10.
ccp=maptbx.cc_peak(map_coeffs_1=fc1, map_coeffs_2=fc2, cutoff=t)
#
m1_he = maptbx.volume_scale(map = m1, n_bins = 10000).map_data()
m2_he = maptbx.volume_scale(map = m2, n_bins = 10000).map_data()
cutoffs = flex.double([i/20. for i in range(1,20)])
df = maptbx.discrepancy_function(map_1=m1_he, map_2=m2_he, cutoffs=cutoffs)
#
fc1 = xray_structure.structure_factors(d_min=2.2).f_calc()
fc2 = xray_structure.structure_factors(d_min=2.2).f_calc()
for t in range(0,10):
t=t/10.
ccp=maptbx.cc_peak(map_coeffs_1=fc1, map_coeffs_2=fc2, cutoff=t)
assert approx_equal(ccp, 1)
# 1D case
m1_he_1d = maptbx.volume_scale_1d(map = m1.as_1d(), n_bins = 10000).map_data()
m2_he_1d = maptbx.volume_scale_1d(map = m2.as_1d(), n_bins = 10000).map_data()
df_1d = maptbx.discrepancy_function(
map_1=m1_he_1d, map_2=m2_he_1d, cutoffs=cutoffs)
assert approx_equal(df, df_1d)
def run():
"""
This test makes sure that composite full omit maps calculated using Marat's
ASU map code and not using ASU maps exactly match.
"""
# make up data
xrs = random_structure.xray_structure(
space_group_info=space_group_info("P 1"),
volume_per_atom=250,
general_positions_only=False,
elements=('C', 'N', 'O', "S") * 50,
u_iso=0.1,
min_distance=1.0)
xrs.scattering_type_registry(table="wk1995")
f_obs = abs(xrs.structure_factors(d_min=2).f_calc())
# create fmodel object
xrs.shake_sites_in_place(mean_distance=0.3)
sel = xrs.random_remove_sites_selection(fraction=0.1)
xrs = xrs.select(sel)
fmodel = mmtbx.f_model.manager(xray_structure=xrs, f_obs=f_obs)
fmodel.update_all_scales(update_f_part1=False)
crystal_gridding = fmodel.f_obs().crystal_gridding(
d_min=fmodel.f_obs().d_min(),
symmetry_flags=maptbx.use_space_group_symmetry,
resolution_factor=0.25)
# compute OMIT maps
r1 = omit_p1_specific(crystal_gridding=crystal_gridding,
fmodel=fmodel.deep_copy(),
max_boxes=70,
map_type="Fo")
r2 = omit_general_obsolete(crystal_gridding=crystal_gridding,
fmodel=fmodel.deep_copy(),
full_resolution_map=False,
map_type="Fo",
n_debias_cycles=1,
neutral_volume_box_cushion_width=0,
box_size_as_fraction=0.3,
max_boxes=70,
log=sys.stdout)
r3 = cfom.run(crystal_gridding=crystal_gridding,
fmodel=fmodel.deep_copy(),
full_resolution_map=False,
neutral_volume_box_cushion_width=0,
box_size_as_fraction=0.3,
max_boxes=70,
log=sys.stdout)
assert approx_equal(r1.r, r2.r)
def r_factor(x, y):
x = flex.abs(abs(x).data())
y = flex.abs(abs(y).data())
sc = flex.sum(x * y) / flex.sum(y * y)
return flex.sum(flex.abs(x - sc * y)) / flex.sum(x + sc * y) * 2
print(abs(r1.map_coefficients).data().min_max_mean().as_tuple())
print(abs(r2.map_coefficients).data().min_max_mean().as_tuple())
cc1 = flex.linear_correlation(
x=abs(r1.map_coefficients).data(),
y=abs(r2.map_coefficients).data()).coefficient()
assert approx_equal(cc1, 1.0)
cc2 = flex.linear_correlation(
x=abs(r1.map_coefficients).data(),
y=abs(r3.map_coefficients(filter_noise=False)).data()).coefficient()
assert cc2 > 0.8, cc2
assert approx_equal(r_factor(x=r1.map_coefficients, y=r2.map_coefficients),
0.0)
cc3 = flex.linear_correlation(x=r1.r, y=r3.r).coefficient()
assert cc3 > 0.95
for cutoff in [0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99]:
print(
maptbx.cc_peak(
cutoff=cutoff,
map_coeffs_1=r1.map_coefficients,
map_coeffs_2=r3.map_coefficients(filter_noise=False)),
"CCpeak", cutoff)
def run(args, out=sys.stdout, validated=False):
show_citation(out=out)
if (len(args) == 0):
master_phil.show(out=out)
print('\nUsage: phenix.map_comparison <CCP4> <CCP4>\n',\
' phenix.map_comparison <CCP4> <MTZ> mtz_label_1=<label>\n',\
' phenix.map_comparison <MTZ 1> mtz_label_1=<label 1> <MTZ 2> mtz_label_2=<label 2>\n', file=out)
sys.exit()
# process arguments
params = None
input_attributes = ['map_1', 'mtz_1', 'map_2', 'mtz_2']
try: # automatic parsing
params = phil.process_command_line_with_files(
args=args, master_phil=master_phil).work.extract()
except Exception: # map_file_def only handles one map phil
from libtbx.phil.command_line import argument_interpreter
arg_int = argument_interpreter(master_phil=master_phil)
command_line_args = list()
map_files = list()
for arg in args:
if (os.path.isfile(arg)):
map_files.append(arg)
else:
command_line_args.append(arg_int.process(arg))
params = master_phil.fetch(sources=command_line_args).extract()
# check if more files are necessary
n_defined = 0
for attribute in input_attributes:
if (getattr(params.input, attribute) is not None):
n_defined += 1
# matches files to phil scope, stops once there is sufficient data
for map_file in map_files:
if (n_defined < 2):
current_map = file_reader.any_file(map_file)
if (current_map.file_type == 'ccp4_map'):
n_defined += 1
if (params.input.map_1 is None):
params.input.map_1 = map_file
elif (params.input.map_2 is None):
params.input.map_2 = map_file
elif (current_map.file_type == 'hkl'):
n_defined += 1
if (params.input.mtz_1 is None):
params.input.mtz_1 = map_file
elif (params.input.mtz_2 is None):
params.input.mtz_2 = map_file
else:
print('WARNING: only the first two files are used', file=out)
break
# validate arguments (GUI sets validated to true, no need to run again)
assert (params is not None)
if (not validated):
validate_params(params)
# ---------------------------------------------------------------------------
# check if maps need to be generated from mtz
n_maps = 0
maps = list()
map_names = list()
for attribute in input_attributes:
filename = getattr(params.input, attribute)
if (filename is not None):
map_names.append(filename)
current_map = file_reader.any_file(filename)
maps.append(current_map)
if (current_map.file_type == 'ccp4_map'):
n_maps += 1
# construct maps, if necessary
crystal_gridding = None
m1 = None
m2 = None
# 1 map, 1 mtz file
if (n_maps == 1):
for current_map in maps:
if (current_map.file_type == 'ccp4_map'):
uc = current_map.file_object.unit_cell()
sg_info = space_group_info(
current_map.file_object.space_group_number)
n_real = current_map.file_object.unit_cell_grid
crystal_gridding = maptbx.crystal_gridding(
uc, space_group_info=sg_info, pre_determined_n_real=n_real)
m1 = current_map.file_object.map_data()
if (crystal_gridding is not None):
label = None
for attribute in [('mtz_1', 'mtz_label_1'),
('mtz_2', 'mtz_label_2')]:
filename = getattr(params.input, attribute[0])
label = getattr(params.input, attribute[1])
if ((filename is not None) and (label is not None)):
break
# labels will match currently open mtz file
for current_map in maps:
if (current_map.file_type == 'hkl'):
m2 = miller.fft_map(
crystal_gridding=crystal_gridding,
fourier_coefficients=current_map.file_server.
get_miller_array(
label)).apply_sigma_scaling().real_map_unpadded()
else:
raise Sorry('Gridding is not defined.')
# 2 mtz files
elif (n_maps == 0):
crystal_symmetry = get_crystal_symmetry(maps[0])
d_min = min(get_d_min(maps[0]), get_d_min(maps[1]))
crystal_gridding = maptbx.crystal_gridding(
crystal_symmetry.unit_cell(),
d_min=d_min,
resolution_factor=params.options.resolution_factor,
space_group_info=crystal_symmetry.space_group_info())
m1 = miller.fft_map(
crystal_gridding=crystal_gridding,
fourier_coefficients=maps[0].file_server.get_miller_array(
params.input.mtz_label_1)).apply_sigma_scaling(
).real_map_unpadded()
m2 = miller.fft_map(
crystal_gridding=crystal_gridding,
fourier_coefficients=maps[1].file_server.get_miller_array(
params.input.mtz_label_2)).apply_sigma_scaling(
).real_map_unpadded()
# 2 maps
else:
m1 = maps[0].file_object.map_data()
m2 = maps[1].file_object.map_data()
# ---------------------------------------------------------------------------
# analyze maps
assert ((m1 is not None) and (m2 is not None))
# show general statistics
s1 = maptbx.more_statistics(m1)
s2 = maptbx.more_statistics(m2)
show_overall_statistics(out=out, s=s1, header="Map 1 (%s):" % map_names[0])
show_overall_statistics(out=out, s=s2, header="Map 2 (%s):" % map_names[1])
cc_input_maps = flex.linear_correlation(x=m1.as_1d(),
y=m2.as_1d()).coefficient()
print("CC, input maps: %6.4f" % cc_input_maps, file=out)
# compute CCpeak
cc_peaks = list()
m1_he = maptbx.volume_scale(map=m1, n_bins=10000).map_data()
m2_he = maptbx.volume_scale(map=m2, n_bins=10000).map_data()
cc_quantile = flex.linear_correlation(x=m1_he.as_1d(),
y=m2_he.as_1d()).coefficient()
print("CC, quantile rank-scaled (histogram equalized) maps: %6.4f" % \
cc_quantile, file=out)
print("Peak correlation:", file=out)
print(" cutoff CCpeak", file=out)
cutoffs = [i / 100.
for i in range(1, 90)] + [i / 1000 for i in range(900, 1000)]
for cutoff in cutoffs:
cc_peak = maptbx.cc_peak(map_1=m1_he, map_2=m2_he, cutoff=cutoff)
print(" %3.2f %7.4f" % (cutoff, cc_peak), file=out)
cc_peaks.append((cutoff, cc_peak))
# compute discrepancy function (D-function)
discrepancies = list()
cutoffs = flex.double(cutoffs)
df = maptbx.discrepancy_function(map_1=m1_he, map_2=m2_he, cutoffs=cutoffs)
print("Discrepancy function:", file=out)
print(" cutoff D", file=out)
for c, d in zip(cutoffs, df):
print(" %3.2f %7.4f" % (c, d), file=out)
discrepancies.append((c, d))
# compute and output histograms
h1 = maptbx.histogram(map=m1, n_bins=10000)
h2 = maptbx.histogram(map=m2, n_bins=10000)
print("Map histograms:", file=out)
print("Map 1 (%s) Map 2 (%s)"%\
(params.input.map_1,params.input.map_2), file=out)
print("(map_value,cdf,frequency) <> (map_value,cdf,frequency)", file=out)
for a1, c1, v1, a2, c2, v2 in zip(h1.arguments(), h1.c_values(),
h1.values(), h2.arguments(),
h2.c_values(), h2.values()):
print("(%9.5f %9.5f %9.5f) <> (%9.5f %9.5f %9.5f)"%\
(a1,c1,v1, a2,c2,v2), file=out)
# store results
s1_dict = create_statistics_dict(s=s1)
s2_dict = create_statistics_dict(s=s2)
results = dict()
inputs = list()
for attribute in input_attributes:
filename = getattr(params.input, attribute)
if (filename is not None):
inputs.append(filename)
assert (len(inputs) == 2)
results['map_files'] = inputs
results['map_statistics'] = (s1_dict, s2_dict)
results['cc_input_maps'] = cc_input_maps
results['cc_quantile'] = cc_quantile
results['cc_peaks'] = cc_peaks
results['discrepancies'] = discrepancies
# TODO, verify h1,h2 are not dicts, e.g. .values is py2/3 compat. I assume it is here
results['map_histograms'] = ((h1.arguments(), h1.c_values(), h1.values()),
(h2.arguments(), h2.c_values(), h2.values()))
return results
def run(args, out=sys.stdout, validated=False):
show_citation(out=out)
if (len(args) == 0):
master_phil.show(out=out)
print >> out,\
'\nUsage: phenix.map_comparison <CCP4> <CCP4>\n',\
' phenix.map_comparison <CCP4> <MTZ> mtz_label_1=<label>\n',\
' phenix.map_comparison <MTZ 1> mtz_label_1=<label 1> <MTZ 2> mtz_label_2=<label 2>\n'
sys.exit()
# process arguments
params = None
input_attributes = ['map_1', 'mtz_1', 'map_2', 'mtz_2']
try: # automatic parsing
params = phil.process_command_line_with_files(
args=args, master_phil=master_phil).work.extract()
except Exception: # map_file_def only handles one map phil
from libtbx.phil.command_line import argument_interpreter
arg_int = argument_interpreter(master_phil=master_phil)
command_line_args = list()
map_files = list()
for arg in args:
if (os.path.isfile(arg)):
map_files.append(arg)
else:
command_line_args.append(arg_int.process(arg))
params = master_phil.fetch(sources=command_line_args).extract()
# check if more files are necessary
n_defined = 0
for attribute in input_attributes:
if (getattr(params.input, attribute) is not None):
n_defined += 1
# matches files to phil scope, stops once there is sufficient data
for map_file in map_files:
if (n_defined < 2):
current_map = file_reader.any_file(map_file)
if (current_map.file_type == 'ccp4_map'):
n_defined += 1
if (params.input.map_1 is None):
params.input.map_1 = map_file
elif (params.input.map_2 is None):
params.input.map_2 = map_file
elif (current_map.file_type == 'hkl'):
n_defined += 1
if (params.input.mtz_1 is None):
params.input.mtz_1 = map_file
elif (params.input.mtz_2 is None):
params.input.mtz_2 = map_file
else:
print >> out, 'WARNING: only the first two files are used'
break
# validate arguments (GUI sets validated to true, no need to run again)
assert (params is not None)
if (not validated):
validate_params(params)
# ---------------------------------------------------------------------------
# check if maps need to be generated from mtz
n_maps = 0
maps = list()
map_names = list()
for attribute in input_attributes:
filename = getattr(params.input, attribute)
if (filename is not None):
map_names.append(filename)
current_map = file_reader.any_file(filename)
maps.append(current_map)
if (current_map.file_type == 'ccp4_map'):
n_maps += 1
# construct maps, if necessary
crystal_gridding = None
m1 = None
m2 = None
# 1 map, 1 mtz file
if (n_maps == 1):
for current_map in maps:
if (current_map.file_type == 'ccp4_map'):
uc = current_map.file_object.unit_cell()
sg_info = space_group_info(current_map.file_object.space_group_number)
n_real = current_map.file_object.unit_cell_grid
crystal_gridding = maptbx.crystal_gridding(
uc, space_group_info=sg_info, pre_determined_n_real=n_real)
m1 = current_map.file_object.map_data()
if (crystal_gridding is not None):
label = None
for attribute in [('mtz_1', 'mtz_label_1'),
('mtz_2', 'mtz_label_2')]:
filename = getattr(params.input, attribute[0])
label = getattr(params.input, attribute[1])
if ( (filename is not None) and (label is not None) ):
break
# labels will match currently open mtz file
for current_map in maps:
if (current_map.file_type == 'hkl'):
m2 = miller.fft_map(
crystal_gridding=crystal_gridding,
fourier_coefficients=current_map.file_server.get_miller_array(
label)).apply_sigma_scaling().real_map_unpadded()
else:
raise Sorry('Gridding is not defined.')
# 2 mtz files
elif (n_maps == 0):
crystal_symmetry = get_crystal_symmetry(maps[0])
d_min = min(get_d_min(maps[0]), get_d_min(maps[1]))
crystal_gridding = maptbx.crystal_gridding(
crystal_symmetry.unit_cell(), d_min=d_min,
resolution_factor=params.options.resolution_factor,
space_group_info=crystal_symmetry.space_group_info())
m1 = miller.fft_map(
crystal_gridding=crystal_gridding,
fourier_coefficients=maps[0].file_server.get_miller_array(
params.input.mtz_label_1)).apply_sigma_scaling().real_map_unpadded()
m2 = miller.fft_map(
crystal_gridding=crystal_gridding,
fourier_coefficients=maps[1].file_server.get_miller_array(
params.input.mtz_label_2)).apply_sigma_scaling().real_map_unpadded()
# 2 maps
else:
m1 = maps[0].file_object.map_data()
m2 = maps[1].file_object.map_data()
# ---------------------------------------------------------------------------
# analyze maps
assert ( (m1 is not None) and (m2 is not None) )
# show general statistics
s1 = maptbx.more_statistics(m1)
s2 = maptbx.more_statistics(m2)
show_overall_statistics(out=out, s=s1, header="Map 1 (%s):"%map_names[0])
show_overall_statistics(out=out, s=s2, header="Map 2 (%s):"%map_names[1])
cc_input_maps = flex.linear_correlation(x = m1.as_1d(),
y = m2.as_1d()).coefficient()
print >> out, "CC, input maps: %6.4f" % cc_input_maps
# compute CCpeak
cc_peaks = list()
m1_he = maptbx.volume_scale(map = m1, n_bins = 10000).map_data()
m2_he = maptbx.volume_scale(map = m2, n_bins = 10000).map_data()
cc_quantile = flex.linear_correlation(x = m1_he.as_1d(),
y = m2_he.as_1d()).coefficient()
print >> out, "CC, quantile rank-scaled (histogram equalized) maps: %6.4f" % \
cc_quantile
print >> out, "Peak correlation:"
print >> out, " cutoff CCpeak"
cutoffs = [i/100. for i in range(1,90)]+ [i/1000 for i in range(900,1000)]
for cutoff in cutoffs:
cc_peak = maptbx.cc_peak(map_1=m1_he, map_2=m2_he, cutoff=cutoff)
print >> out, " %3.2f %7.4f" % (cutoff, cc_peak)
cc_peaks.append((cutoff, cc_peak))
# compute discrepancy function (D-function)
discrepancies = list()
cutoffs = flex.double(cutoffs)
df = maptbx.discrepancy_function(map_1=m1_he, map_2=m2_he, cutoffs=cutoffs)
print >> out, "Discrepancy function:"
print >> out, " cutoff D"
for c, d in zip(cutoffs, df):
print >> out, " %3.2f %7.4f" % (c,d)
discrepancies.append((c, d))
# compute and output histograms
h1 = maptbx.histogram(map=m1, n_bins=10000)
h2 = maptbx.histogram(map=m2, n_bins=10000)
print >> out, "Map histograms:"
print >> out, "Map 1 (%s) Map 2 (%s)"%\
(params.input.map_1,params.input.map_2)
print >> out, "(map_value,cdf,frequency) <> (map_value,cdf,frequency)"
for a1,c1,v1, a2,c2,v2 in zip(h1.arguments(), h1.c_values(), h1.values(),
h2.arguments(), h2.c_values(), h2.values()):
print >> out, "(%9.5f %9.5f %9.5f) <> (%9.5f %9.5f %9.5f)"%\
(a1,c1,v1, a2,c2,v2)
# store results
s1_dict = create_statistics_dict(s=s1)
s2_dict = create_statistics_dict(s=s2)
results = dict()
inputs = list()
for attribute in input_attributes:
filename = getattr(params.input,attribute)
if (filename is not None):
inputs.append(filename)
assert (len(inputs) == 2)
results['map_files'] = inputs
results['map_statistics'] = (s1_dict, s2_dict)
results['cc_input_maps'] = cc_input_maps
results['cc_quantile'] = cc_quantile
results['cc_peaks'] = cc_peaks
results['discrepancies'] = discrepancies
results['map_histograms'] = ( (h1.arguments(), h1.c_values(), h1.values()),
(h2.arguments(), h2.c_values(), h2.values()) )
return results
def run(args, validated=False):
show_citation()
if ( (len(args) == 0) or (len(args) > 2) ):
print '\nUsage: phenix.map_comparison map_1=<first map> map_2=<second map>\n'
sys.exit()
# process arguments
try: # automatic parsing
params = phil.process_command_line_with_files(
args=args, master_phil=master_phil).work.extract()
except Exception: # map_file_def only handles one map phil
from libtbx.phil.command_line import argument_interpreter
arg_int = argument_interpreter(master_phil=master_phil)
command_line_args = list()
map_files = list()
for arg in args:
if (os.path.isfile(arg)):
map_files.append(arg)
else:
command_line_args.append(arg_int.process(arg))
params = master_phil.fetch(sources=command_line_args).extract()
for map_file in map_files:
if (params.input.map_1 is None):
params.input.map_1 = map_file
else:
params.input.map_2 = map_file
# validate arguments (GUI sets validated to true, no need to run again)
if (not validated):
validate_params(params)
# ---------------------------------------------------------------------------
# map 1
ccp4_map_1 = iotbx.ccp4_map.map_reader(file_name=params.input.map_1)
cs_1 = crystal.symmetry(ccp4_map_1.unit_cell().parameters(),
ccp4_map_1.space_group_number)
m1 = ccp4_map_1.map_data()
# map 2
ccp4_map_2 = iotbx.ccp4_map.map_reader(file_name=params.input.map_2)
cs_2 = crystal.symmetry(ccp4_map_2.unit_cell().parameters(),
ccp4_map_2.space_group_number)
m2 = ccp4_map_2.map_data()
# show general statistics
s1 = maptbx.more_statistics(m1)
s2 = maptbx.more_statistics(m2)
show_overall_statistics(s=s1, header="Map 1 (%s):"%params.input.map_1)
show_overall_statistics(s=s2, header="Map 2 (%s):"%params.input.map_2)
cc_input_maps = flex.linear_correlation(x = m1.as_1d(),
y = m2.as_1d()).coefficient()
print "CC, input maps: %6.4f" % cc_input_maps
# compute CCpeak
cc_peaks = list()
m1_he = maptbx.volume_scale(map = m1, n_bins = 10000).map_data()
m2_he = maptbx.volume_scale(map = m2, n_bins = 10000).map_data()
cc_quantile = flex.linear_correlation(x = m1_he.as_1d(),
y = m2_he.as_1d()).coefficient()
print "CC, quantile rank-scaled (histogram equalized) maps: %6.4f" % \
cc_quantile
print "Peak correlation:"
print " cutoff CCpeak"
for cutoff in [i/100. for i in range(0,100,5)]+[0.99, 1.0]:
cc_peak = maptbx.cc_peak(map_1=m1_he, map_2=m2_he, cutoff=cutoff)
print " %3.2f %7.4f" % (cutoff, cc_peak)
cc_peaks.append((cutoff, cc_peak))
# compute discrepancy function (D-function)
discrepancies = list()
cutoffs = flex.double([i/20. for i in range(1,20)])
df = maptbx.discrepancy_function(map_1=m1_he, map_2=m2_he, cutoffs=cutoffs)
print "Discrepancy function:"
print " cutoff D"
for c, d in zip(cutoffs, df):
print " %3.2f %7.4f" % (c,d)
discrepancies.append((c, d))
# compute and output histograms
h1 = maptbx.histogram(map=m1, n_bins=10000)
h2 = maptbx.histogram(map=m2, n_bins=10000)
print "Map histograms:"
print "Map 1 (%s) Map 2 (%s)"%(params.input.map_1,params.input.map_2)
print "(map_value,cdf,frequency) <> (map_value,cdf,frequency)"
for a1,c1,v1, a2,c2,v2 in zip(h1.arguments(), h1.c_values(), h1.values(),
h2.arguments(), h2.c_values(), h2.values()):
print "(%9.5f %9.5f %9.5f) <> (%9.5f %9.5f %9.5f)"%(a1,c1,v1, a2,c2,v2)
# store results
s1_dict = create_statistics_dict(s1)
s2_dict = create_statistics_dict(s2)
results = dict()
results['map_files'] = (params.input.map_1, params.input.map_2)
results['map_statistics'] = (s1_dict, s2_dict)
results['cc_input_maps'] = cc_input_maps
results['cc_quantile'] = cc_quantile
results['cc_peaks'] = cc_peaks
results['discrepancies'] = discrepancies
results['map_histograms'] = ( (h1.arguments(), h1.c_values(), h1.values()),
(h2.arguments(), h2.c_values(), h2.values()) )
return results
def run():
"""
This test makes sure that composite full omit maps calculated using Marat's
ASU map code and not using ASU maps exactly match.
"""
# make up data
xrs = random_structure.xray_structure(
space_group_info = space_group_info("P 1"),
volume_per_atom = 250,
general_positions_only = False,
elements = ('C', 'N', 'O', "S")*50,
u_iso = 0.1,
min_distance = 1.0)
xrs.scattering_type_registry(table="wk1995")
f_obs = abs(xrs.structure_factors(d_min=2).f_calc())
# create fmodel object
xrs.shake_sites_in_place(mean_distance=0.3)
sel = xrs.random_remove_sites_selection(fraction=0.1)
xrs = xrs.select(sel)
fmodel = mmtbx.f_model.manager(
xray_structure = xrs,
f_obs = f_obs)
fmodel.update_all_scales(update_f_part1=False)
crystal_gridding = fmodel.f_obs().crystal_gridding(
d_min = fmodel.f_obs().d_min(),
symmetry_flags = maptbx.use_space_group_symmetry,
resolution_factor = 0.25)
# compute OMIT maps
r1 = omit_p1_specific(
crystal_gridding = crystal_gridding,
fmodel = fmodel.deep_copy(),
max_boxes=70,
map_type = "Fo")
r2 = omit_general_obsolete(
crystal_gridding = crystal_gridding,
fmodel = fmodel.deep_copy(),
full_resolution_map = False,
map_type = "Fo",
n_debias_cycles = 1,
neutral_volume_box_cushion_width = 0,
box_size_as_fraction=0.3,
max_boxes=70,
log=sys.stdout)
r3 = cfom.run(
crystal_gridding = crystal_gridding,
fmodel = fmodel.deep_copy(),
full_resolution_map = False,
neutral_volume_box_cushion_width = 0,
box_size_as_fraction=0.3,
max_boxes=70,
log=sys.stdout)
assert approx_equal(r1.r, r2.r)
def r_factor(x,y):
x = flex.abs(abs(x).data())
y = flex.abs(abs(y).data())
sc = flex.sum(x*y)/flex.sum(y*y)
return flex.sum(flex.abs(x-sc*y))/flex.sum(x+sc*y)*2
print abs(r1.map_coefficients).data().min_max_mean().as_tuple()
print abs(r2.map_coefficients).data().min_max_mean().as_tuple()
cc1=flex.linear_correlation(
x=abs(r1.map_coefficients).data(),
y=abs(r2.map_coefficients).data()).coefficient()
assert approx_equal(cc1, 1.0)
cc2=flex.linear_correlation(
x=abs(r1.map_coefficients).data(),
y=abs(r3.map_coefficients(filter_noise=False)).data()).coefficient()
assert cc2 > 0.8, cc2
assert approx_equal(r_factor(
x=r1.map_coefficients, y=r2.map_coefficients), 0.0)
cc3=flex.linear_correlation(x=r1.r, y=r3.r).coefficient()
assert cc3>0.95
for cutoff in [0.5,0.6,0.7,0.8,0.9,0.95,0.99]:
print maptbx.cc_peak(
cutoff = cutoff,
map_coeffs_1 = r1.map_coefficients,
map_coeffs_2 = r3.map_coefficients(filter_noise=False)), "CCpeak", cutoff
