def simple(fmodel, pdb_hierarchy, params=None, log=None, show_results=False):
if (params is None): params = master_params().extract()
if (log is None): log = sys.stdout
crystal_gridding = None
unit_cell = None
d_min = 1.0
map_1 = None
map_2 = None
# compute map_1 and map_2 if given F_obs (fmodel exists)
if ((params.map_file_name is None)
and (params.map_coefficients_file_name is None)
and (fmodel is not None)):
e_map_obj = fmodel.electron_density_map()
coeffs_2 = e_map_obj.map_coefficients(
map_type=params.map_2.type,
fill_missing=params.map_2.fill_missing_reflections,
isotropize=params.map_2.isotropize)
fft_map_2 = coeffs_2.fft_map(
resolution_factor=params.resolution_factor)
crystal_gridding = fft_map_2
fft_map_2.apply_sigma_scaling()
map_2 = fft_map_2.real_map_unpadded()
coeffs_1 = e_map_obj.map_coefficients(
map_type=params.map_1.type,
fill_missing=params.map_1.fill_missing_reflections,
isotropize=params.map_1.isotropize)
fft_map_1 = miller.fft_map(crystal_gridding=crystal_gridding,
fourier_coefficients=coeffs_1)
fft_map_1.apply_sigma_scaling()
map_1 = fft_map_1.real_map_unpadded()
unit_cell = fmodel.xray_structure.unit_cell()
d_min = fmodel.f_obs().d_min()
# or read map coefficents
elif (params.map_coefficients_file_name is not None):
map_handle = any_file(params.map_coefficients_file_name)
crystal_symmetry = get_crystal_symmetry(map_handle)
unit_cell = crystal_symmetry.unit_cell()
d_min = get_d_min(map_handle)
crystal_gridding = maptbx.crystal_gridding(
crystal_symmetry.unit_cell(),
d_min=d_min,
resolution_factor=params.resolution_factor,
space_group_info=crystal_symmetry.space_group_info())
coeffs_2 = map_handle.file_server.get_miller_array(
params.map_coefficients_label)
fft_map_2 = miller.fft_map(crystal_gridding=crystal_gridding,
fourier_coefficients=coeffs_2)
fft_map_2.apply_sigma_scaling()
map_2 = fft_map_2.real_map_unpadded()
# or read CCP4 map
else:
map_handle = any_file(params.map_file_name)
unit_cell = map_handle.file_object.unit_cell()
sg_info = space_group_info(map_handle.file_object.space_group_number)
n_real = map_handle.file_object.unit_cell_grid
crystal_gridding = maptbx.crystal_gridding(
unit_cell, space_group_info=sg_info, pre_determined_n_real=n_real)
map_2 = map_handle.file_object.map_data()
# check for origin shift
# modified from phenix.command_line.real_space_refine
# plan to centralize functionality in another location
# -------------------------------------------------------------------------
shift_manager = mmtbx.utils.shift_origin(
map_data=map_2,
pdb_hierarchy=pdb_hierarchy,
crystal_symmetry=map_handle.crystal_symmetry())
if (shift_manager.shift_cart is not None):
print("Map origin is not at (0,0,0): shifting the map and model.",
file=log)
pdb_hierarchy = shift_manager.pdb_hierarchy
map_2 = shift_manager.map_data
# -------------------------------------------------------------------------
# compute map_1 (Fc) if given a map (fmodel does not exist)
if (map_1 is None):
xray_structure = pdb_hierarchy.extract_xray_structure(
crystal_symmetry=crystal_gridding.crystal_symmetry())
fft_map_1 = compute_map_from_model(d_min,
None,
xray_structure,
crystal_gridding=crystal_gridding)
fft_map_1.apply_sigma_scaling()
map_1 = fft_map_1.real_map_unpadded()
# compute cc
assert ((map_1 is not None) and (map_2 is not None))
broadcast(m="Map correlation and map values", log=log)
overall_cc = flex.linear_correlation(x=map_1.as_1d(),
y=map_2.as_1d()).coefficient()
print(" Overall map cc(%s,%s): %6.4f" %
(params.map_1.type, params.map_2.type, overall_cc),
file=log)
detail, atom_radius = params.detail, params.atom_radius
detail, atom_radius = set_detail_level_and_radius(detail=detail,
atom_radius=atom_radius,
d_min=d_min)
use_hydrogens = params.use_hydrogens
if (use_hydrogens is None):
if (params.scattering_table == "neutron" or d_min <= 1.2):
use_hydrogens = True
else:
use_hydrogens = False
hydrogen_atom_radius = params.hydrogen_atom_radius
if (hydrogen_atom_radius is None):
if (params.scattering_table == "neutron"):
hydrogen_atom_radius = atom_radius
else:
hydrogen_atom_radius = 1
results = compute(pdb_hierarchy=pdb_hierarchy,
unit_cell=unit_cell,
fft_n_real=map_1.focus(),
fft_m_real=map_1.all(),
map_1=map_1,
map_2=map_2,
detail=detail,
atom_radius=atom_radius,
use_hydrogens=use_hydrogens,
hydrogen_atom_radius=hydrogen_atom_radius)
if (show_results):
show(log=log, results=results, params=params, detail=detail)
return overall_cc, results
def simple(fmodel, pdb_hierarchy, params=None, log=None, show_results=False):
if(params is None): params = master_params().extract()
if(log is None): log = sys.stdout
crystal_gridding = None
unit_cell = None
d_min = 1.0
map_1 = None
map_2 = None
# compute map_1 and map_2 if given F_obs (fmodel exists)
if ( (params.map_file_name is None) and
(params.map_coefficients_file_name is None) and
(fmodel is not None) ):
e_map_obj = fmodel.electron_density_map()
coeffs_2 = e_map_obj.map_coefficients(
map_type = params.map_2.type,
fill_missing = params.map_2.fill_missing_reflections,
isotropize = params.map_2.isotropize)
fft_map_2 = coeffs_2.fft_map(resolution_factor = params.resolution_factor)
crystal_gridding = fft_map_2
fft_map_2.apply_sigma_scaling()
map_2 = fft_map_2.real_map_unpadded()
coeffs_1 = e_map_obj.map_coefficients(
map_type = params.map_1.type,
fill_missing = params.map_1.fill_missing_reflections,
isotropize = params.map_1.isotropize)
fft_map_1 = miller.fft_map(crystal_gridding = crystal_gridding,
fourier_coefficients = coeffs_1)
fft_map_1.apply_sigma_scaling()
map_1 = fft_map_1.real_map_unpadded()
unit_cell = fmodel.xray_structure.unit_cell()
d_min = fmodel.f_obs().d_min()
# or read map coefficents
elif (params.map_coefficients_file_name is not None):
map_handle = any_file(params.map_coefficients_file_name)
crystal_symmetry = get_crystal_symmetry(map_handle)
unit_cell = crystal_symmetry.unit_cell()
d_min = get_d_min(map_handle)
crystal_gridding = maptbx.crystal_gridding(
crystal_symmetry.unit_cell(), d_min=d_min,
resolution_factor=params.resolution_factor,
space_group_info=crystal_symmetry.space_group_info())
coeffs_2 = map_handle.file_server.get_miller_array(
params.map_coefficients_label)
fft_map_2 = miller.fft_map(crystal_gridding=crystal_gridding,
fourier_coefficients=coeffs_2)
fft_map_2.apply_sigma_scaling()
map_2 = fft_map_2.real_map_unpadded()
# or read CCP4 map
else:
map_handle = any_file(params.map_file_name)
unit_cell = map_handle.file_object.unit_cell()
sg_info = space_group_info(map_handle.file_object.space_group_number)
n_real = map_handle.file_object.unit_cell_grid
crystal_gridding = maptbx.crystal_gridding(
unit_cell, space_group_info=sg_info, pre_determined_n_real=n_real)
map_2 = map_handle.file_object.map_data()
# compute map_1 (Fc) if given a map (fmodel does not exist)
if (map_1 is None):
xray_structure = pdb_hierarchy.extract_xray_structure(
crystal_symmetry=crystal_gridding.crystal_symmetry())
fft_map_1 = compute_map_from_model(d_min, None, xray_structure,
crystal_gridding=crystal_gridding)
fft_map_1.apply_sigma_scaling()
map_1 = fft_map_1.real_map_unpadded()
# compute cc
assert ( (map_1 is not None) and (map_2 is not None) )
broadcast(m="Map correlation and map values", log=log)
overall_cc = flex.linear_correlation(x = map_1.as_1d(),
y = map_2.as_1d()).coefficient()
print >> log, " Overall map cc(%s,%s): %6.4f"%(params.map_1.type,
params.map_2.type, overall_cc)
detail, atom_radius = params.detail, params.atom_radius
detail, atom_radius = set_detail_level_and_radius(
detail=detail, atom_radius=atom_radius, d_min=d_min)
use_hydrogens = params.use_hydrogens
if(use_hydrogens is None):
if(params.scattering_table == "neutron" or d_min <= 1.2):
use_hydrogens = True
else:
use_hydrogens = False
hydrogen_atom_radius = params.hydrogen_atom_radius
if(hydrogen_atom_radius is None):
if(params.scattering_table == "neutron"):
hydrogen_atom_radius = atom_radius
else:
hydrogen_atom_radius = 1
results = compute(
pdb_hierarchy = pdb_hierarchy,
unit_cell = unit_cell,
fft_n_real = map_1.focus(),
fft_m_real = map_1.all(),
map_1 = map_1,
map_2 = map_2,
detail = detail,
atom_radius = atom_radius,
use_hydrogens = use_hydrogens,
hydrogen_atom_radius = hydrogen_atom_radius)
if(show_results):
show(log=log, results=results, params=params, detail=detail)
return results
def cmd_run(args, command_name, log=None):
if (log is None): log = sys.stdout
args = list(args)
msg = """\
Compute map correlation coefficient given input PDB model and reflection data.
Examples:
phenix.real_space_correlation m.pdb d.mtz
phenix.real_space_correlation m.pdb d.mtz detail=atom
phenix.real_space_correlation m.pdb d.mtz detail=residue
phenix.real_space_correlation m.pdb d.mtz data_labels=FOBS
phenix.real_space_correlation m.pdb d.mtz scattering_table=neutron
phenix.real_space_correlation m.pdb d.mtz detail=atom use_hydrogens=true
phenix.real_space_correlation m.pdb d.mtz map_1.type=Fc map_2.type="2mFo-DFc"
phenix.real_space_correlation m.pdb d.mtz map_coefficients_label="2FOFCWT,PH2FOFCWT"
phenix.real_space_correlation m.pdb d.ccp4
"""
if (len(args) == 0) or (args == ["--help"]) or (args == ["--options"]):
print(msg, file=log)
broadcast(m="Default parameters:", log=log)
master_params().show(out=log, prefix=" ")
return
else:
pdb_file = None
reflection_file = None
map_file = None
phil_objects = []
n_files = 0
for arg in args:
if (os.path.isfile(arg)):
inp = any_file(arg)
if (inp.file_type == "phil"):
phil_objects.append(inp.file_object)
elif (inp.file_type == "pdb"):
pdb_file = inp
elif (inp.file_type == "hkl"):
reflection_file = inp
elif (inp.file_type == "ccp4_map"):
map_file = inp
else:
raise Sorry((
"Don't know how to deal with the file %s - unrecognized "
+
"format '%s'. Please verify that the syntax is correct."
) % (arg, str(inp.file_type)))
n_files += 1
else:
try:
phil_objects.append(iotbx.phil.parse(arg))
except RuntimeError as e:
raise Sorry(
"Unrecognized parameter or command-line argument '%s'."
% arg)
if (n_files > 2):
raise Sorry('Only 2 files are needed, a structure and the data')
working_phil, unused = master_params().fetch(
sources=phil_objects, track_unused_definitions=True)
if (len(unused) > 0):
for u in unused:
print(str(u))
raise Sorry("Unused parameters: see above.")
params = working_phil.extract()
# PDB file
extract_input_pdb(pdb_file=pdb_file, params=params)
broadcast(m="Input PDB file name: %s" % params.pdb_file_name, log=log)
pdbo = pdb_to_xrs(pdb_file_name=params.pdb_file_name,
scattering_table=params.scattering_table)
pdbo.xray_structure.show_summary(f=log, prefix=" ")
# data file
# set params.reflection_file_name and params.map_coefficients_file_name
extract_input_data(hkl_file=reflection_file, params=params)
data_and_flags = None
if (params.reflection_file_name is not None):
broadcast(m="Input reflection file name: %s" %
params.reflection_file_name,
log=log)
data_and_flags = extract_data_and_flags(params=params)
data_and_flags.f_obs.show_comprehensive_summary(f=log, prefix=" ")
# map file (if available)
# set params.map_file_name
check_map_file(map_file, params)
map_name = ((params.map_coefficients_file_name)
or (params.map_file_name))
if (map_name is not None):
map_handle = any_file(map_name)
broadcast(m='Input map file name: %s' % map_name, log=log)
print(' Map type: ', end=' ', file=log)
if (map_handle.file_type == 'hkl'):
print('map coefficients', file=log)
print(' Map labels:', params.map_coefficients_label, file=log)
else:
print('CCP4-format', file=log)
# check crystal symmetry
cs1 = pdbo.xray_structure.crystal_symmetry()
cs2 = get_crystal_symmetry(map_handle)
if (cs1.is_similar_symmetry(cs2) is False):
raise Sorry(
'The symmetry of the two files, %s and %s, is not similar'
% (fobs_handle.file_name, map_handle.file_name))
# check that only one data file is defined
if ((map_name is not None)
and (params.reflection_file_name is not None)):
raise Sorry('Please use F_obs or a map, not both.')
if ((params.reflection_file_name is None) and (map_name is None)):
raise Sorry('A data file is required.')
# create fmodel with f_obs (if available)
fmodel = None
if (params.reflection_file_name is not None):
r_free_flags = data_and_flags.f_obs.array(
data=flex.bool(data_and_flags.f_obs.size(), False))
fmodel = mmtbx.utils.fmodel_simple(
xray_structures=[pdbo.xray_structure],
scattering_table=params.scattering_table,
f_obs=data_and_flags.f_obs,
r_free_flags=r_free_flags)
broadcast(m="R-factors, reflection counts and scales", log=log)
fmodel.show(log=log, show_header=False)
# compute cc
results = simple(fmodel=fmodel,
pdb_hierarchy=pdbo.pdb_hierarchy,
params=params,
show_results=True,
log=log)
def cmd_run(args, command_name, log=None):
if(log is None): log = sys.stdout
args = list(args)
msg = """\
Compute map correlation coefficient given input PDB model and reflection data.
Examples:
phenix.real_space_correlation m.pdb d.mtz
phenix.real_space_correlation m.pdb d.mtz detail=atom
phenix.real_space_correlation m.pdb d.mtz detail=residue
phenix.real_space_correlation m.pdb d.mtz data_labels=FOBS
phenix.real_space_correlation m.pdb d.mtz scattering_table=neutron
phenix.real_space_correlation m.pdb d.mtz detail=atom use_hydrogens=true
phenix.real_space_correlation m.pdb d.mtz map_1.type=Fc map_2.type="2mFo-DFc"
phenix.real_space_correlation m.pdb d.mtz map_coefficients_label="2FOFCWT,PH2FOFCWT"
phenix.real_space_correlation m.pdb d.ccp4
"""
if(len(args) == 0) or (args == ["--help"]) or (args == ["--options"]):
print >> log, msg
broadcast(m="Default parameters:", log = log)
master_params().show(out = log, prefix=" ")
return
else :
pdb_file = None
reflection_file = None
map_file = None
phil_objects = []
n_files = 0
for arg in args :
if(os.path.isfile(arg)) :
inp = any_file(arg)
if( inp.file_type == "phil"): phil_objects.append(inp.file_object)
elif(inp.file_type == "pdb"): pdb_file = inp
elif(inp.file_type == "hkl"): reflection_file = inp
elif(inp.file_type == "ccp4_map"): map_file = inp
else:
raise Sorry(("Don't know how to deal with the file %s - unrecognized "+
"format '%s'. Please verify that the syntax is correct.") % (arg,
str(inp.file_type)))
n_files += 1
else:
try:
phil_objects.append(iotbx.phil.parse(arg))
except RuntimeError, e:
raise Sorry("Unrecognized parameter or command-line argument '%s'." %
arg)
if (n_files > 2):
raise Sorry('Only 2 files are needed, a structure and the data')
working_phil, unused = master_params().fetch(sources=phil_objects,
track_unused_definitions=True)
if(len(unused)>0):
for u in unused:
print str(u)
raise Sorry("Unused parameters: see above.")
params = working_phil.extract()
# PDB file
extract_input_pdb(pdb_file=pdb_file, params=params)
broadcast(m="Input PDB file name: %s"%params.pdb_file_name, log=log)
pdbo = pdb_to_xrs(pdb_file_name=params.pdb_file_name,
scattering_table=params.scattering_table)
pdbo.xray_structure.show_summary(f=log, prefix=" ")
# data file
# set params.reflection_file_name and params.map_coefficients_file_name
extract_input_data(hkl_file=reflection_file, params=params)
data_and_flags = None
if (params.reflection_file_name is not None):
broadcast(
m="Input reflection file name: %s"%params.reflection_file_name, log=log)
data_and_flags = extract_data_and_flags(params = params)
data_and_flags.f_obs.show_comprehensive_summary(f=log, prefix=" ")
# map file (if available)
# set params.map_file_name
check_map_file(map_file, params)
map_name = ( (params.map_coefficients_file_name) or
(params.map_file_name) )
if (map_name is not None):
map_handle = any_file(map_name)
broadcast(m='Input map file name: %s' % map_name, log=log)
print >> log, ' Map type: ',
if (map_handle.file_type == 'hkl'):
print >> log, 'map coefficients'
print >> log, ' Map labels:', params.map_coefficients_label
else:
print >> log, 'CCP4-format'
# check crystal symmetry
cs1 = pdbo.xray_structure.crystal_symmetry()
cs2 = get_crystal_symmetry(map_handle)
if (cs1.is_similar_symmetry(cs2) is False):
raise Sorry('The symmetry of the two files, %s and %s, is not similar' %
(fobs_handle.file_name, map_handle.file_name))
# check that only one data file is defined
if ( (map_name is not None) and
(params.reflection_file_name is not None) ):
raise Sorry('Please use F_obs or a map, not both.')
if ( (params.reflection_file_name is None) and
(map_name is None) ):
raise Sorry('A data file is required.')
# create fmodel with f_obs (if available)
fmodel = None
if (params.reflection_file_name is not None):
r_free_flags = data_and_flags.f_obs.array(
data = flex.bool(data_and_flags.f_obs.size(), False))
fmodel = mmtbx.utils.fmodel_simple(
xray_structures = [pdbo.xray_structure],
scattering_table = params.scattering_table,
f_obs = data_and_flags.f_obs,
r_free_flags = r_free_flags)
broadcast(m="R-factors, reflection counts and scales", log=log)
fmodel.show(log=log, show_header=False)
# compute cc
results = simple(
fmodel = fmodel,
pdb_hierarchy = pdbo.pdb_hierarchy,
params = params,
show_results = True,
log = log)
