def get_files_sorted(pdb_files, hkl_files):
ifn_p = open("/".join([pdb_files, "INDEX"]), "r")
ifn_r = os.listdir(hkl_files)
pdbs = flex.std_string()
mtzs = flex.std_string()
codes = flex.std_string()
sizes = flex.double()
cntr = 0
for lp in ifn_p.readlines():
lp = lp.strip()
pdb_file_name = "/".join([pdb_files, lp])
assert os.path.isfile(pdb_file_name)
pdb_code = lp[-11:-7]
#
# FOR DEBUGGING
#if pdb_code != "4w71": continue
#
#
lr = lp.replace("pdb", "r")
hkl_file_name = "/".join([hkl_files, "%s.mtz" % pdb_code])
if (os.path.isfile(hkl_file_name)):
cntr += 1
s = os.path.getsize(pdb_file_name) + os.path.getsize(hkl_file_name)
pdbs.append(pdb_file_name)
mtzs.append(hkl_file_name)
codes.append(pdb_code)
sizes.append(s)
#if codes.size()==100: break
print("Total:", cntr)
sel = flex.sort_permutation(sizes)
pdbs = pdbs.select(sel)
mtzs = mtzs.select(sel)
codes = codes.select(sel)
sizes = sizes.select(sel)
return pdbs, mtzs, codes, sizes
def run(args):
command_line = (option_parser().option(
"--output_dirname",
"-o",
type="string",
help="Directory for output files.")).process(args=args)
args = command_line.args
output_dirname = command_line.options.output_dirname
if output_dirname is None:
output_dirname = os.path.dirname(args[0])
assert len(args) == 2
xy_pairs = []
for i, filename in enumerate(args):
print "Reading data from: %s" % filename
f = open(filename, 'rb')
x, y = zip(*[
line.split() for line in f.readlines() if not line.startswith("#")
])
x = flex.double(flex.std_string(x))
y = flex.double(flex.std_string(y))
xy_pairs.append((x, y))
signal = xy_pairs[0]
background = xy_pairs[1]
signal_x, background_subtracted = subtract_background(signal,
background,
plot=True)
filename = os.path.join(output_dirname, "background_subtracted.txt")
f = open(filename, "wb")
print >> f, "\n".join(
["%i %f" % (x, y) for x, y in zip(signal_x, background_subtracted)])
f.close()
print "Background subtracted spectrum written to %s" % filename
def import_ptms(ptms_outfile):
chain_id = flex.std_string()
resid = flex.int()
resname = flex.std_string()
goto_atom = flex.std_string()
short_name = flex.std_string()
full_name = flex.std_string()
cc = flex.double()
d_ref = flex.double()
d_mid = flex.double()
d_new_in_ref = flex.double()
d_new_diff = flex.double()
d_far = flex.double()
ratio = flex.double()
score = flex.double()
model_id = flex.int()
d_min = flex.double()
b_factor = flex.double()
imported_ptms = (chain_id, resid, resname, goto_atom, short_name,
full_name, cc, d_ref, d_mid, d_new_in_ref, d_new_diff,
d_far, ratio, score, model_id, d_min, b_factor)
with open(ptms_outfile, "rb") as out:
for line in out.readlines():
items = line.split()
for array, coerce_lambda in zip(
imported_ptms,
(lambda x: x, lambda x: int(x), lambda x: x, lambda x: x,
lambda x: x, lambda x: x, lambda x: float(x),
lambda x: float(x), lambda x: float(x), lambda x: float(x),
lambda x: float(x), lambda x: float(x), lambda x: float(x),
lambda x: float(x), lambda x: int(x), lambda x: float(x),
lambda x: float(x))):
array.append(coerce_lambda(items.pop(0)))
return imported_ptms
def run(args):
command_line = (option_parser()
.option("--output_dirname", "-o",
type="string",
help="Directory for output files.")
).process(args=args)
args = command_line.args
output_dirname = command_line.options.output_dirname
if output_dirname is None:
output_dirname = os.path.dirname(args[0])
assert len(args) == 2
xy_pairs = []
for i, filename in enumerate(args):
print "Reading data from: %s" %filename
f = open(filename, 'rb')
x, y = zip(*[line.split() for line in f.readlines() if not line.startswith("#")])
x = flex.double(flex.std_string(x))
y = flex.double(flex.std_string(y))
xy_pairs.append((x,y))
signal = xy_pairs[0]
background = xy_pairs[1]
signal_x, background_subtracted = subtract_background(signal, background, plot=True)
filename = os.path.join(output_dirname, "background_subtracted.txt")
f = open(filename, "wb")
print >> f, "\n".join(["%i %f" %(x, y)
for x, y in zip(signal_x, background_subtracted)])
f.close()
print "Background subtracted spectrum written to %s" %filename
def exercise_01():
import libtbx.load_env
if not libtbx.env.has_module("reduce"):
print "Reduce not installed, needed for model.add_hydrogens(). skipping"
return
pdb_file_name = "add_h_to_hoh.pdb"
tmp_f = open(pdb_file_name, "w")
tmp_f.write(input_model)
tmp_f.close()
processed_pdb_files_srv = mmtbx.utils.process_pdb_file_srv(log=StringIO())
processed_pdb_file, pdb_inp = processed_pdb_files_srv.process_pdb_files(pdb_file_names=[pdb_file_name])
xray_structure = processed_pdb_file.xray_structure()
#
geometry = processed_pdb_file.geometry_restraints_manager(show_energies=False, assume_hydrogens_all_missing=True)
restraints_manager = mmtbx.restraints.manager(geometry=geometry)
#
model = mmtbx.model.manager(
refinement_flags=None,
processed_pdb_files_srv=processed_pdb_files_srv,
restraints_manager=restraints_manager,
xray_structure=xray_structure,
pdb_hierarchy=processed_pdb_file.all_chain_proxies.pdb_hierarchy,
log=None,
)
####
model.add_hydrogens(correct_special_position_tolerance=1.0)
result = StringIO()
model.write_pdb_file(out=result)
result = result.getvalue().splitlines()
####
result1 = []
for r1 in result:
if r1.startswith("ATOM") or r1.startswith("HETATM"):
result1.append(r1)
result2 = []
for r2 in expected_result.splitlines():
if r2.startswith("ATOM") or r2.startswith("HETATM"):
result2.append(r2)
assert len(result1) == len(result2)
for r1, r2 in zip(result1, result2):
r1 = r1[:30] + r1[60:]
r2 = r2[:30] + r2[60:]
assert not show_diff(r1, r2)
####
cntr = 0
xrs1 = iotbx.pdb.pdb_input(
source_info=None, lines=flex.std_string(expected_result.splitlines())
).xray_structure_simple()
xrs2 = iotbx.pdb.pdb_input(source_info=None, lines=flex.std_string(result)).xray_structure_simple()
for s1, s2 in zip(xrs1.scatterers(), xrs2.scatterers()):
if s1.element_symbol().strip() not in ["H", "D"]:
assert s1.element_symbol().strip() == s2.element_symbol().strip()
assert approx_equal(s1.site, s2.site)
cntr += 1
assert cntr == 19
def exercise_writer():
from iotbx import file_reader
from cctbx import uctbx, sgtbx
from scitbx.array_family import flex
file_name = libtbx.env.find_in_repositories(
relative_path=
"phenix_regression/wizards/partial_refine_001_map_coeffs.mtz",
test=os.path.isfile)
if file_name is None:
print "Can't find map coefficients file, skipping."
return
mtz_in = file_reader.any_file(file_name, force_type="hkl").file_object
miller_arrays = mtz_in.as_miller_arrays()
map_coeffs = miller_arrays[0]
fft_map = map_coeffs.fft_map(resolution_factor=1 / 3.0)
fft_map.apply_sigma_scaling()
fft_map.as_ccp4_map(file_name="2mFo-DFc.map")
m = iotbx.ccp4_map.map_reader(file_name="2mFo-DFc.map")
real_map = fft_map.real_map_unpadded()
mmm = flex.double(list(real_map)).min_max_mean()
assert approx_equal(m.unit_cell_parameters,
map_coeffs.unit_cell().parameters())
assert approx_equal(mmm.min, m.header_min)
assert approx_equal(mmm.max, m.header_max)
#assert approx_equal(mmm.mean, m.header_mean)
# random small maps of different sizes
for nxyz in flex.nested_loop((1, 1, 1), (4, 4, 4)):
mt = flex.mersenne_twister(0)
grid = flex.grid(nxyz)
map = mt.random_double(size=grid.size_1d())
map.reshape(grid)
real_map = fft_map.real_map_unpadded()
iotbx.ccp4_map.write_ccp4_map(
file_name="random.map",
unit_cell=uctbx.unit_cell((1, 1, 1, 90, 90, 90)),
space_group=sgtbx.space_group_info("P1").group(),
gridding_first=(0, 0, 0),
gridding_last=tuple(fft_map.n_real()),
map_data=real_map,
labels=flex.std_string(["iotbx.ccp4_map.tst"]))
m = iotbx.ccp4_map.map_reader(file_name="random.map")
mmm = flex.double(list(real_map)).min_max_mean()
assert approx_equal(m.unit_cell_parameters, (1, 1, 1, 90, 90, 90))
assert approx_equal(mmm.min, m.header_min)
assert approx_equal(mmm.max, m.header_max)
#
gridding_first = (0, 0, 0)
gridding_last = tuple(fft_map.n_real())
map_box = maptbx.copy(map, gridding_first, gridding_last)
map_box.reshape(flex.grid(map_box.all()))
iotbx.ccp4_map.write_ccp4_map(
file_name="random_box.map",
unit_cell=uctbx.unit_cell((1, 1, 1, 90, 90, 90)),
space_group=sgtbx.space_group_info("P1").group(),
map_data=map_box,
labels=flex.std_string(["iotbx.ccp4_map.tst"]))
def exercise_writer () :
from iotbx import file_reader
from cctbx import uctbx, sgtbx
from scitbx.array_family import flex
file_name = libtbx.env.find_in_repositories(
relative_path="phenix_regression/wizards/partial_refine_001_map_coeffs.mtz",
test=os.path.isfile)
if file_name is None :
print "Can't find map coefficients file, skipping."
return
mtz_in = file_reader.any_file(file_name, force_type="hkl").file_object
miller_arrays = mtz_in.as_miller_arrays()
map_coeffs = miller_arrays[0]
fft_map = map_coeffs.fft_map(resolution_factor=1/3.0)
fft_map.apply_sigma_scaling()
fft_map.as_ccp4_map(file_name="2mFo-DFc.map")
m = iotbx.ccp4_map.map_reader(file_name="2mFo-DFc.map")
real_map = fft_map.real_map_unpadded()
mmm = flex.double(list(real_map)).min_max_mean()
assert approx_equal(m.unit_cell_parameters,
map_coeffs.unit_cell().parameters())
assert approx_equal(mmm.min, m.header_min)
assert approx_equal(mmm.max, m.header_max)
#assert approx_equal(mmm.mean, m.header_mean)
# random small maps of different sizes
for nxyz in flex.nested_loop((1,1,1),(4,4,4)):
mt = flex.mersenne_twister(0)
grid = flex.grid(nxyz)
map = mt.random_double(size=grid.size_1d())
map.reshape(grid)
real_map = fft_map.real_map_unpadded()
iotbx.ccp4_map.write_ccp4_map(
file_name="random.map",
unit_cell=uctbx.unit_cell((1,1,1,90,90,90)),
space_group=sgtbx.space_group_info("P1").group(),
gridding_first=(0,0,0),
gridding_last=tuple(fft_map.n_real()),
map_data=real_map,
labels=flex.std_string(["iotbx.ccp4_map.tst"]))
m = iotbx.ccp4_map.map_reader(file_name="random.map")
mmm = flex.double(list(real_map)).min_max_mean()
assert approx_equal(m.unit_cell_parameters, (1,1,1,90,90,90))
assert approx_equal(mmm.min, m.header_min)
assert approx_equal(mmm.max, m.header_max)
#
gridding_first = (0,0,0)
gridding_last = tuple(fft_map.n_real())
map_box = maptbx.copy(map, gridding_first, gridding_last)
map_box.reshape(flex.grid(map_box.all()))
iotbx.ccp4_map.write_ccp4_map(
file_name="random_box.map",
unit_cell=uctbx.unit_cell((1,1,1,90,90,90)),
space_group=sgtbx.space_group_info("P1").group(),
map_data=map_box,
labels=flex.std_string(["iotbx.ccp4_map.tst"]))
def run(args):
assert len(args) == 0
from cctbx.crystal.distance_based_connectivity import \
build_simple_two_way_bond_sets
from scitbx.array_family import flex
sites_cart = flex.vec3_double([
(25.655, 43.266, 42.630),
(24.038, 43.853, 43.337),
(23.048, 44.525, 43.290),
(21.223, 44.207, 41.475),
(24.951, 47.170, 37.585),
(19.298, 46.942, 51.808)])
elements = flex.std_string(["S", "C", "N", "CU", "ZN", "CA"])
bond_list = build_simple_two_way_bond_sets(
sites_cart=sites_cart, elements=elements)
assert [sorted(b) for b in bond_list] == [[1], [0,2], [1,3], [2], [], []]
#
# caffeine
sites_cart = flex.vec3_double([
(-2.986, 0.015, 1.643),
(-1.545, 0.015, 1.643),
(-0.733, 0.015, 2.801),
(0.592, 0.015, 2.395),
(0.618, 0.015, 1.034),
(1.758, 0.015, 0.102),
(3.092, -0.06, 0.694),
(1.525, 0.015, -1.360),
(2.489, -0.024, -2.139),
(0.158, 0.015, -1.888),
(-0.025, 0.024, -3.330),
(-0.986, 0.015, -0.959),
(-2.155, 0.008, -1.408),
(-0.733, 0.015, 0.565),
(-3.346, 0.016, 2.662),
(-3.347, 0.896, 1.133),
(-3.347, -0.868, 1.136),
(-1.083, 0.02, 3.822),
(3.184, -0.975, 1.26),
(3.245, 0.785, 1.348),
(3.835, -0.047, -0.09),
(0.508, 0.861, -3.756),
(-1.076, 0.113, -3.560),
(0.358, -0.896, -3.748)
])
elements = flex.std_string([
' C', ' N', ' C', ' N', ' C', ' N', ' C', ' C', ' O', ' N', ' C', ' C',
' O', ' C', ' H', ' H', ' H', ' H', ' H', ' H', ' H', ' H', ' H', ' H'])
bonds = build_simple_two_way_bond_sets(
sites_cart=sites_cart, elements=elements)
assert bonds.size() == sites_cart.size()
assert list(bonds[0]) == [1, 14, 15, 16]
#
print "OK"
def __init__(self,
seq_a,
seq_b,
style="global",
gap_opening_penalty=1,
gap_extension_penalty=1,
similarity_function="identity",
masking_a=None):
assert style in ["global", "local", "no_end_gaps"]
sim_fun_str = similarity_function
self.similarity_function_call = None
if (similarity_function is None or similarity_function == "identity"):
self.similarity_function_call = identity
elif (similarity_function == "dayhoff"):
self.similarity_function_call = dayhoff
elif (similarity_function == "blosum50"):
self.similarity_function_call = blosum50
elif (isinstance(similarity_function, str)):
raise RuntimeError('Unknown similarity_function: "%s"' %
similarity_function)
from six import string_types
if isinstance(seq_a, string_types):
seq_a = seq_a.upper()
seq_b = seq_b.upper()
else:
seq_a = flex.std_string(seq_a)
seq_b = flex.std_string(seq_b)
if masking_a: # Gap penalty for insertion scaled by masking_a after
# corresponding position in sequence a and scaled by
# masking_a for deletion before corresponding position in
# sequence a. Allows increasing mask everywhere
# except where you want a gap to occur
assert len(list(masking_a)) == len(seq_a)
else:
masking_a = [1] * len(
seq_a) # no masking; standard gap penalty everywhere
m = flex.float(masking_a)
super(align, self).__init__(
seq_a=seq_a,
seq_b=seq_b,
masking=m,
style=style,
gap_opening_penalty=gap_opening_penalty,
gap_extension_penalty=gap_extension_penalty,
similarity_function=sim_fun_str,
)
self.seq_a = seq_a
self.seq_b = seq_b
self.style = style
self.similarity_function = sim_fun_str
m, n = self.m, self.n = len(seq_a), len(seq_b)
def main(filenames,
map_file,
npoints=192,
max_resolution=6,
reverse_phi=False):
rec_range = 1 / max_resolution
image = ImageFactory(filenames[0])
panel = image.get_detector()[0]
beam = image.get_beam()
s0 = beam.get_s0()
pixel_size = panel.get_pixel_size()
xlim, ylim = image.get_raw_data().all()
xy = recviewer.get_target_pixels(panel, s0, xlim, ylim, max_resolution)
s1 = panel.get_lab_coord(xy * pixel_size[0]) # FIXME: assumed square pixel
s1 = s1 / s1.norms() * (1 / beam.get_wavelength()) # / is not supported...
S = s1 - s0
grid = flex.double(flex.grid(npoints, npoints, npoints), 0)
cnts = flex.int(flex.grid(npoints, npoints, npoints), 0)
for filename in filenames:
print "Processing image", filename
try:
fill_voxels(ImageFactory(filename), grid, cnts, S, xy, reverse_phi,
rec_range)
except:
print " Failed to process. Skipped this."
recviewer.normalize_voxels(grid, cnts)
uc = uctbx.unit_cell((npoints, npoints, npoints, 90, 90, 90))
ccp4_map.write_ccp4_map(map_file, uc, sgtbx.space_group("P1"), (0, 0, 0),
grid.all(), grid,
flex.std_string(["cctbx.miller.fft_map"]))
return
from scitbx import fftpack
fft = fftpack.complex_to_complex_3d(grid.all())
grid_complex = flex.complex_double(reals=flex.pow2(grid),
imags=flex.double(grid.size(), 0))
grid_transformed = flex.abs(fft.backward(grid_complex))
print flex.max(grid_transformed), flex.min(
grid_transformed), grid_transformed.all()
ccp4_map.write_ccp4_map(map_file, uc, sgtbx.space_group("P1"), (0, 0, 0),
grid.all(), grid_transformed,
flex.std_string(["cctbx.miller.fft_map"]))
def update_structure (self, pdb_hierarchy, atomic_bonds,
special_position_settings=None) :
from scitbx.array_family import flex
self.pdb_hierarchy = pdb_hierarchy
self.atoms = pdb_hierarchy.atoms()
self.atom_count = self.atoms.size()
assert (self.atom_count == len(atomic_bonds))
if atomic_bonds is None :
atomic_bonds = flex.stl_set_unsigned(self.atom_count)
self.atomic_bonds = atomic_bonds
self.selection_cache = pdb_hierarchy.atom_selection_cache(
special_position_settings=special_position_settings)
#self.index_atoms()
atom_index = []
atom_labels = flex.std_string()
for atom in self.pdb_hierarchy.atoms_with_labels() :
atom_index.append(atom)
atom_labels.append(format_atom_label(atom))
self.atom_index = atom_index
self.atom_labels = atom_labels
self.trace_bonds = extract_trace(pdb_hierarchy, self.selection_cache)
if self.draw_mode is None or self.draw_mode.startswith("trace") :
self.current_bonds = self.trace_bonds
else :
self.current_bonds = self.atomic_bonds
atom_radii = flex.double(self.atoms.size(), 1.5)
hydrogen_flag = flex.bool(self.atoms.size(), False)
for i_seq, atom in enumerate(self.atom_index) :
if atom.element.strip() in ["H", "D"] :
atom_radii[i_seq] = 0.75
hydrogen_flag[i_seq] = True
self.atom_radii = atom_radii
self.hydrogen_flag = hydrogen_flag
self._color_cache = {}
self.is_changed = True
def write_ccp4_map(map_data, unit_cell, space_group, file_name):
iotbx.mrcfile.write_ccp4_map(
file_name = file_name,
unit_cell = unit_cell,
space_group = space_group,
map_data = map_data.as_double(),
labels=flex.std_string([" "]))
def write_real_map_file(self, filename, unit_cell, space_group,
map_data, labels, overwrite=False):
# WAS: wrapper for iotbx.ccp4_map.write_ccp4_map
# NOW: moved to mrcfile (https://github.com/ccpem/mrcfile)
if (os.path.isfile(filename) and (not overwrite)):
raise Sorry('%s already exists and overwrite is set to %s.' %
(filename, overwrite))
import iotbx.mrcfile
# check labels (maybe other arugments?)
if (not isinstance(labels, flex.std_string)):
try:
labels = flex.std_string(labels)
except Exception as err:
# trap Boost.Python.ArgumentError
if (str(err).startswith('Python argument types in')):
raise Sorry('A list of strings is required for the "labels" argument')
else:
raise
try:
iotbx.mrcfile.write_ccp4_map(
file_name = filename,
unit_cell = unit_cell,
space_group = space_group,
map_data = map_data,
labels = labels
)
except IOError as err:
raise Sorry('There was an error with writing %s.\n%s' %
(filename, err))
self._output_files.append(filename)
self._output_types.append(RealMapDataManager.datatype)
def exercise_00():
d = iaa.residue_dict()
assert len(d.keys()) == 44
for aac in iotbx.pdb.amino_acid_codes.one_letter_given_three_letter:
assert aac.lower() in d.keys()
#
mon_lib_srv = monomer_library.server.server()
ener_lib = monomer_library.server.ener_lib()
for aac in iotbx.pdb.amino_acid_codes.one_letter_given_three_letter:
aac = aac.lower()
for aac_ in [aac, aac+"_h"]:
residue_as_string = iaa.__dict__[aac_]
rs = flex.std_string(residue_as_string.splitlines())
processed_pdb_file = monomer_library.pdb_interpretation.process(
mon_lib_srv = mon_lib_srv,
ener_lib = ener_lib,
raw_records = rs)
sites_cart = processed_pdb_file.xray_structure().sites_cart()
grm = processed_pdb_file.geometry_restraints_manager(
show_energies = False, plain_pairs_radius = 5.0)
es = grm.energies_sites(
sites_cart = sites_cart)
b = es.bond_deviations()
a = es.angle_deviations()
b_z = es.bond_deviations_z()
a_z = es.angle_deviations_z()
print "%5s"%aac_, "bonds : %5.3f %5.3f %5.3f"%b, \
"angles : %5.3f %5.3f %5.3f"%a
assert a[2] < 1.2, a[2]
assert b[2] < 0.005, b[2]
print "%5s"%aac_, "bonds rmsZ: %5.3f %5.3f %5.3f"%b_z, \
"angles rmsZ: %5.3f %5.3f %5.3f"%a_z
assert a_z[2] < 0.7, a_z[2]
assert b_z[2] < 0.7, b_z[2]
def run(args):
show_citation()
if len(args) != 1:
raise Sorry("Need to provide CCP4 formatted map file.")
# map
try:
ccp4_map = iotbx.ccp4_map.map_reader(file_name=args[0])
except Exception: # XXX should probably be RuntimeError?
raise Sorry("Not a valid file (provide CCP4 formatted map file).")
cs = crystal.symmetry(ccp4_map.unit_cell().parameters(), ccp4_map.space_group_number)
m = ccp4_map.data.as_double()
# show general statistics
show_overall_statistics(m=m, header="Map basic info (%s):" % args[0])
# HE
m_he = maptbx.volume_scale(map=m, n_bins=10000).map_data()
show_overall_statistics(m=m_he, header="Rank-scaled (HE) map info:")
#
iotbx.ccp4_map.write_ccp4_map(
file_name=args[0] + "_rank_scaled.ccp4",
unit_cell=cs.unit_cell(),
space_group=cs.space_group(),
# gridding_first=(0,0,0),# This causes a bug (map gets shifted)
# gridding_last=n_real, # This causes a bug (map gets shifted)
map_data=m_he,
labels=flex.std_string([""]),
)
def _goniometer(self):
'''Return a model for a simple single-axis goniometer. This should
probably be checked against the image header, though for miniCBF
there are limited options for this.'''
if 'Phi' in self._cif_header_dictionary:
phi_value = float(self._cif_header_dictionary['Phi'].split()[0])
else:
phi_value = 0.0
if 'Kappa' in self._cif_header_dictionary:
kappa_value = float(self._cif_header_dictionary['Kappa'].split()[0])
else:
kappa_value = 0.0
if 'Omega' in self._cif_header_dictionary:
omega_value = float(self._cif_header_dictionary['Omega'].split()[0])
else:
omega_value = 0.0
from scitbx import matrix
from scitbx.array_family import flex
phi = (1.0, 0.0, 0.0)
kappa = (0.914, 0.279, -0.297)
omega = (1.0, 0.0, 0.0)
axes = flex.vec3_double((phi, kappa, omega))
angles = flex.double((phi_value, kappa_value, omega_value))
names = flex.std_string(("GON_PHI", "GON_KAPPA", "GON_OMEGA"))
return self._goniometer_factory.make_multi_axis_goniometer(
axes, angles, names, scan_axis=2)
def tst_hdf5(filename):
from dxtbx.format.image import HDF5Reader
from dxtbx.format.nexus import dataset_as_flex_int
from scitbx.array_family import flex
import h5py
handle = h5py.File(filename, "r")
reader = HDF5Reader(handle.id.id, flex.std_string(["/entry/data/data"]))
image = reader.image(0)
data1 = image.as_int().tile(0).data()
dataset = handle['/entry/data/data']
N, height, width = dataset.shape
data2 = dataset_as_flex_int(
dataset.id.id,
(slice(0, 1, 1), slice(0, height, 1), slice(0, width, 1)))
data2.reshape(flex.grid(data2.all()[1:]))
assert N == len(reader)
assert data1.all()[0] == data2.all()[0]
assert data1.all()[1] == data2.all()[1]
diff = flex.abs(data1 - data2)
assert flex.max(diff) < 1e-7
print 'OK'
def run(args):
show_citation()
if (len(args) != 1):
raise Sorry("Need to provide CCP4 formatted map file.")
# map
try:
ccp4_map = iotbx.mrcfile.map_reader(file_name=args[0])
except Exception: # XXX should probably be RuntimeError?
raise Sorry("Not a valid file (provide CCP4 formatted map file).")
cs = crystal.symmetry(ccp4_map.unit_cell().parameters(),
ccp4_map.space_group_number)
m = ccp4_map.data.as_double()
# show general statistics
show_overall_statistics(m=m, header="Map basic info (%s):" % args[0])
# HE
m_he = maptbx.volume_scale(map=m, n_bins=10000).map_data()
show_overall_statistics(m=m_he, header="Rank-scaled (HE) map info:")
#
iotbx.mrcfile.write_ccp4_map(
file_name=args[0] + "_rank_scaled.ccp4",
unit_cell=cs.unit_cell(),
space_group=cs.space_group(),
#gridding_first=(0,0,0),# This causes a bug (map gets shifted)
#gridding_last=n_real, # This causes a bug (map gets shifted)
map_data=m_he,
labels=flex.std_string([""]))
def write_ccp4_map(map_data, cs, file_name):
from iotbx import mrcfile
mrcfile.write_ccp4_map(file_name=file_name,
unit_cell=cs.unit_cell(),
space_group=cs.space_group(),
map_data=map_data,
labels=flex.std_string([""]))
def get_pdb_hierarchy(file_names):
assert 0, "Hopefully is not used"
pdb_combined = iotbx.pdb.combine_unique_pdb_files(file_names=file_names)
pdb_structure = iotbx.pdb.input(source_info=None,
lines=flex.std_string(
pdb_combined.raw_records))
return pdb_structure.construct_hierarchy()
def format_column(key, data, format_strings=None):
if isinstance(data, flex.vec3_double):
c_strings = [
c.as_string(format_strings[i].strip())
for i, c in enumerate(data.parts())
]
elif isinstance(data, flex.miller_index):
c_strings = [
c.as_string(format_strings[i].strip())
for i, c in enumerate(data.as_vec3_double().parts())
]
elif isinstance(data, flex.size_t):
c_strings = [data.as_int().as_string(format_strings[0].strip())]
elif isinstance(data, flex.shoebox):
x1, x2, y1, y2, z1, z2 = data.bounding_boxes().parts()
bbox_sizes = ((z2 - z1) * (y2 - y1) * (x2 - x1)).as_double()
c_strings = [bbox_sizes.as_string(format_strings[0].strip())]
key += " (N pix)"
else:
c_strings = [data.as_string(format_strings[0].strip())]
column = flex.std_string()
max_element_lengths = [c.max_element_length() for c in c_strings]
for i in range(len(c_strings[0])):
column.append(
("%%%is" % len(key))
% ", ".join(
("%%%is" % max_element_lengths[j]) % c_strings[j][i]
for j in range(len(c_strings))
)
)
return column
def write_array_as_map(self, array, f_name, origin_shift=True):
"""Take array of values and write as map the shape of the grid"""
# Convert from numpy array is necessary
if isinstance(array, numpy.ndarray):
array = array.astype(float).flatten()
else:
array = list(array)
# Convert to flex.double and shape
array = flex.double(array)
array.reshape(self.indexer())
# If origin, apply shift to map
if origin_shift is True:
array = cctbx.maptbx.rotate_translate_map(
unit_cell=self.unit_cell(),
map_data=array,
rotation_matrix=scitbx.matrix.rec([1, 0, 0, 0, 1, 0, 0, 0, 1],
(3, 3)).elems,
translation_vector=(-1.0 *
scitbx.matrix.rec(self.cart_origin(),
(3, 1))).elems)
# Write the map
iotbx.ccp4_map.write_ccp4_map(file_name=f_name,
unit_cell=self.unit_cell(),
space_group=self.space_group(),
map_data=array,
labels=flex.std_string(['']))
def ccp4_map(crystal_symmetry, file_name, map_data):
from iotbx import mrcfile
mrcfile.write_ccp4_map(file_name=file_name,
unit_cell=crystal_symmetry.unit_cell(),
space_group=crystal_symmetry.space_group(),
map_data=map_data,
labels=flex.std_string([""]))
def test_hdf5(dials_regression, hdf5_image):
h5py = pytest.importorskip("h5py")
# Import after we know h5py is present
from dxtbx.format.nexus import dataset_as_flex_int
filename = os.path.join(dials_regression, hdf5_image)
handle = h5py.File(filename, "r")
reader = HDF5Reader(handle.id.id, flex.std_string(["/entry/data/data"]))
image = reader.image(0)
data1 = image.as_int().tile(0).data()
dataset = handle["/entry/data/data"]
N, height, width = dataset.shape
data2 = dataset_as_flex_int(
dataset.id.id,
(slice(0, 1, 1), slice(0, height, 1), slice(0, width, 1)))
data2.reshape(flex.grid(data2.all()[1:]))
assert N == len(reader)
assert data1.all()[0] == data2.all()[0]
assert data1.all()[1] == data2.all()[1]
diff = flex.abs(data1 - data2)
assert flex.max(diff) < 1e-7
def make_kappa_goniometer(alpha, omega, kappa, phi, direction, scan_axis):
omega_axis = (1, 0, 0)
phi_axis = (1, 0, 0)
c = math.cos(alpha * math.pi / 180)
s = math.sin(alpha * math.pi / 180)
if direction == "+y":
kappa_axis = (c, s, 0.0)
elif direction == "+z":
kappa_axis = (c, 0.0, s)
elif direction == "-y":
kappa_axis = (c, -s, 0.0)
elif direction == "-z":
kappa_axis = (c, 0.0, -s)
else:
raise RuntimeError("Invalid direction")
if scan_axis == "phi":
scan_axis = 0
else:
scan_axis = 2
axes = flex.vec3_double((phi_axis, kappa_axis, omega_axis))
angles = flex.double((phi, kappa, omega))
names = flex.std_string(("PHI", "KAPPA", "OMEGA"))
return GoniometerFactory.make_multi_axis_goniometer(
axes, angles, names, scan_axis)
def _goniometer(self):
'''Return a model for a simple single-axis goniometer. This should
probably be checked against the image header, though for miniCBF
there are limited options for this.'''
if 'Phi' in self._cif_header_dictionary:
phi_value = float(self._cif_header_dictionary['Phi'].split()[0])
else:
phi_value = 0.0
if 'Kappa' in self._cif_header_dictionary:
kappa_value = float(
self._cif_header_dictionary['Kappa'].split()[0])
else:
kappa_value = 0.0
if 'Omega' in self._cif_header_dictionary:
omega_value = float(
self._cif_header_dictionary['Omega'].split()[0])
else:
omega_value = 0.0
from scitbx import matrix
from scitbx.array_family import flex
phi = (1.0, 0.0, 0.0)
kappa = (0.914, 0.279, -0.297)
omega = (1.0, 0.0, 0.0)
axes = flex.vec3_double((phi, kappa, omega))
angles = flex.double((phi_value, kappa_value, omega_value))
names = flex.std_string(("GON_PHI", "GON_KAPPA", "GON_OMEGA"))
return self._goniometer_factory.make_multi_axis_goniometer(axes,
angles,
names,
scan_axis=2)
def exercise_00():
d = iaa.residue_dict()
assert len(d) == 48
for aac in iotbx.pdb.amino_acid_codes.one_letter_given_three_letter:
assert aac.lower() in d
#
mon_lib_srv = monomer_library.server.server()
ener_lib = monomer_library.server.ener_lib()
for aac in iotbx.pdb.amino_acid_codes.one_letter_given_three_letter:
aac = aac.lower()
for aac_ in [aac, aac + "_h"]:
residue_as_string = iaa.__dict__[aac_]
rs = flex.std_string(residue_as_string.splitlines())
processed_pdb_file = monomer_library.pdb_interpretation.process(
mon_lib_srv=mon_lib_srv, ener_lib=ener_lib, raw_records=rs)
sites_cart = processed_pdb_file.xray_structure().sites_cart()
grm = processed_pdb_file.geometry_restraints_manager(
show_energies=False, plain_pairs_radius=5.0)
es = grm.energies_sites(sites_cart=sites_cart)
b = es.bond_deviations()
a = es.angle_deviations()
b_z = es.bond_deviations_z()
a_z = es.angle_deviations_z()
print("%5s"%aac_, "bonds : %5.3f %5.3f %5.3f"%b, \
"angles : %5.3f %5.3f %5.3f"%a)
assert a[2] < 1.2, a[2]
assert b[2] < 0.005, b[2]
print("%5s"%aac_, "bonds rmsZ: %5.3f %5.3f %5.3f"%b_z, \
"angles rmsZ: %5.3f %5.3f %5.3f"%a_z)
assert a_z[2] < 0.7, a_z[2]
assert b_z[2] < 0.7, b_z[2]
def write_ccp4_map(sites_cart,
unit_cell,
map_data,
n_real,
file_name,
buffer=10):
import iotbx.ccp4_map
from cctbx import sgtbx
from scitbx.array_family import flex
if sites_cart is not None:
frac_min, frac_max = unit_cell.box_frac_around_sites(
sites_cart=sites_cart, buffer=buffer)
else:
frac_min, frac_max = (0.0, 0.0, 0.0), (1.0, 1.0, 1.0)
gridding_first = tuple([ifloor(f * n) for f, n in zip(frac_min, n_real)])
gridding_last = tuple([iceil(f * n) for f, n in zip(frac_max, n_real)])
space_group = sgtbx.space_group_info("P1").group()
iotbx.ccp4_map.write_ccp4_map(
file_name=file_name,
unit_cell=unit_cell,
space_group=space_group,
gridding_first=gridding_first,
gridding_last=gridding_last,
map_data=map_data,
labels=flex.std_string(["iotbx.map_conversion.write_ccp4_map_box"]))
def run(args, log=sys.stdout):
# print "args", args
inputs = mmtbx.utils.process_command_line_args(args=args,
master_params=master_phil)
work_params = inputs.params.extract()
inputs.params.show(prefix=" ", out=log)
pdb_file_names = list(inputs.pdb_file_names)
if len(pdb_file_names) == 0:
raise Sorry("No PDB file specified")
work_params.loop_idealization.enabled=True
work_params.loop_idealization.number_of_ccd_trials=1
work_params.loop_idealization.minimize_whole=False
work_params.loop_idealization.variant_search_level=1
# print work_params.loop_idealization.output_prefix
# STOP()
# work_params.ss_idealization.file_name_before_regularization="before.pdb"
pdb_combined = iotbx.pdb.combine_unique_pdb_files(file_names=pdb_file_names)
pdb_input = iotbx.pdb.input(source_info=None,
lines=flex.std_string(pdb_combined.raw_records))
pdb_h = pdb_input.construct_hierarchy()
loop_ideal = loop_idealization(
pdb_hierarchy=pdb_h,
params=work_params.loop_idealization,
log=log)
loop_ideal.resulting_pdb_h.write_pdb_file(
file_name="%s_very_final.pdb" % work_params.loop_idealization.output_prefix)
print >> log, "Outlier percentages: initial, after ccd, after minimization, berkeley after ccd, berkeley after minimization:"
print >> log, loop_ideal.p_initial_rama_outliers,
print >> log, loop_ideal.p_before_minimization_rama_outliers,
print >> log, loop_ideal.p_after_minimiaztion_rama_outliers,
print >> log, loop_ideal.berkeley_p_before_minimization_rama_outliers,
print >> log, loop_ideal.berkeley_p_after_minimiaztion_rama_outliers
def _goniometer(self):
"""Return a model for a simple single-axis goniometer. This should
probably be checked against the image header, though for miniCBF
there are limited options for this."""
if "Phi" in self._cif_header_dictionary:
phi_value = float(self._cif_header_dictionary["Phi"].split()[0])
else:
phi_value = 0.0
if "Kappa" in self._cif_header_dictionary:
kappa_value = float(
self._cif_header_dictionary["Kappa"].split()[0])
else:
kappa_value = 0.0
if "Omega" in self._cif_header_dictionary:
omega_value = float(
self._cif_header_dictionary["Omega"].split()[0])
else:
omega_value = 0.0
phi = (1.0, 0.0, 0.0)
kappa = (0.914, 0.279, -0.297)
omega = (1.0, 0.0, 0.0)
axes = flex.vec3_double((phi, kappa, omega))
angles = flex.double((phi_value, kappa_value, omega_value))
names = flex.std_string(("GON_PHI", "GON_KAPPA", "GON_OMEGA"))
return self._goniometer_factory.make_multi_axis_goniometer(axes,
angles,
names,
scan_axis=2)
def prepare_user_map(self):
print >> self.log, "Preparing user map..."
self.map_shift_manager = mmtbx.utils.shift_origin(
map_data=self.user_supplied_map,
xray_structure=self.model.get_xray_structure(),
crystal_symmetry=self.cs)
if (self.map_shift_manager.shift_cart is not None):
# Need to figure out way to save the shift to shift back
# and apply it to whole_pdb, master_pdb, etc. Don't forget about
# boxing hierarchy when symmetry is not available or corrupted...
raise Sorry(
"Map origin is not at (0,0,0). This is not implemented for model_idealization"
)
map_data = self.map_shift_manager.map_data
self.reference_map = map_data
self.master_map = self.reference_map.deep_copy()
if self.model.ncs_constraints_present():
mask = maptbx.mask(
xray_structure=self.model.get_xray_structure().select(
self.model.get_master_selection()),
n_real=self.master_map.focus(),
mask_value_inside_molecule=1,
mask_value_outside_molecule=-1,
solvent_radius=0,
atom_radius=1.)
self.master_map = self.reference_map * mask
if self.params.debug:
iotbx.ccp4_map.write_ccp4_map(
file_name="%s_3_master.map" % self.params.output_prefix,
unit_cell=self.cs.unit_cell(),
space_group=self.cs.space_group(),
map_data=self.master_map,
labels=flex.std_string([""]))
self.master_map = map_data
def get_inputs(args, log, master_params):
"""
Eventually, this will be centralized.
"""
cmdline = process_command_line_with_files(args=args,
master_phil=master_params,
pdb_file_def='model_file_name')
params = cmdline.work.extract()
# Model
file_names = params.model_file_name
pdb_combined = combine_unique_pdb_files(file_names=file_names)
pdb_inp = iotbx.pdb.input(source_info=None,
lines=flex.std_string(pdb_combined.raw_records),
raise_sorry_if_format_error=True)
# Crystal symmetry
fake_crystal_symmetry = False
crystal_symmetry = pdb_inp.crystal_symmetry()
if (crystal_symmetry is None or crystal_symmetry.is_empty()
or crystal_symmetry.is_nonsence()):
fake_crystal_symmetry = True
from cctbx import uctbx
crystal_symmetry = \
uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center(
sites_cart=pdb_inp.atoms().extract_xyz(),
buffer_layer=5).crystal_symmetry()
#
model = mmtbx.model.manager(model_input=pdb_inp,
crystal_symmetry=crystal_symmetry)
#
return group_args(params=params,
pdb_file_names=file_names,
model=model,
fake_crystal_symmetry=fake_crystal_symmetry)
def make_kappa_goniometer(alpha, omega, kappa, phi, direction, scan_axis):
import math
omega_axis = (1, 0, 0)
phi_axis = (1, 0, 0)
c = math.cos(alpha * math.pi / 180);
s = math.sin(alpha * math.pi / 180);
if direction == "+y":
kappa_axis = (c, s, 0.0)
elif direction == "+z":
kappa_axis = (c, 0.0, s)
elif direction == "-y":
kappa_axis = (c, -s, 0.0)
elif direction == "-z":
kappa_axis = (c, 0.0, -s)
else:
raise RuntimeError("Invalid direction")
if scan_axis == "phi":
scan_axis = 0
else:
scan_axis = 2
from scitbx.array_family import flex
axes = flex.vec3_double((phi_axis, kappa_axis, omega_axis))
angles = flex.double((phi, kappa, omega))
names = flex.std_string(("PHI", "KAPPA", "OMEGA"))
return goniometer_factory.make_multi_axis_goniometer(
axes, angles, names, scan_axis)
def to_file(self, filename, space_group):
map_data = self.get_map_data(sparse=False)
iotbx.ccp4_map.write_ccp4_map(
file_name = filename,
unit_cell = self.unit_cell,
space_group = space_group,
map_data = self.embed(map_data),
labels = flex.std_string(['Output map from giant/pandda']) )
def write_ccp4_map(map_data, cs, file_name):
from iotbx import ccp4_map
ccp4_map.write_ccp4_map(
file_name=file_name,
unit_cell=cs.unit_cell(),
space_group=cs.space_group(),
map_data=map_data,
labels=flex.std_string([""]))
def run(args, log = sys.stdout):
if(len(args)==0):
print >> log, legend
defaults(log=log)
return
#
parsed = defaults(log=log)
processed_args = mmtbx.utils.process_command_line_args(args = args,
log = sys.stdout, master_params = parsed)
params = processed_args.params.extract()
unit_cell = processed_args.crystal_symmetry.unit_cell()
reflection_files = processed_args.reflection_files
#
atoms_with_labels = None
if(len(processed_args.pdb_file_names)==1):
pdb_combined = combine_unique_pdb_files(
file_names=processed_args.pdb_file_names)
pdb_combined.report_non_unique()
pdb_inp = iotbx.pdb.input(source_info = None,
lines = flex.std_string(pdb_combined.raw_records))
atoms_with_labels = pdb_inp.atoms_with_labels()
if(len(params.point)==0 and atoms_with_labels is None):
raise Sorry("No points given to compute map value at.")
if(len(reflection_files) == 0 and processed_args.ccp4_map is None):
raise Sorry("No reflection or map files found.")
if(len(reflection_files) > 1):
raise Sorry("More than one reflection file found.")
crystal_symmetry = processed_args.crystal_symmetry
if(crystal_symmetry is None):
raise Sorry("No crystal symmetry found.")
if(len(reflection_files) != 0):
map_3d = map_from_reflection_file(reflection_files=reflection_files, params=params)
else:
map_3d = processed_args.ccp4_map.data.as_double()
print "Map values at specified points:"
for point in params.point:
point_frac = unit_cell.fractionalize(point)
point_formatted = ",".join([str("%10.3f"%p).strip() for p in point])
point_frac_formatted = \
",".join([str("%10.3f"%p).strip() for p in point_frac])
map_value = str(
"%10.3f"%map_3d.eight_point_interpolation(point_frac)).strip()
print " Input point: (%s) Fractionalized: (%s) Map value: %s"%(
point_formatted, point_frac_formatted, map_value)
#
if(atoms_with_labels is not None):
for point in atoms_with_labels:
point_frac = processed_args.crystal_symmetry.unit_cell().fractionalize(point.xyz)
point_formatted = ",".join([str("%8.3f"%p) for p in point.xyz])
map_value = str(
"%10.3f"%map_3d.eight_point_interpolation(point_frac)).strip()
print point.quote(), "Point: %s Map value: %s"%(point_formatted,map_value)
#
print
print "All done."
def get_map_from_hkl(hkl_file_object, params, xrs, log):
print("Processing input hkl file...", file=log)
crystal_symmetry = hkl_file_object.crystal_symmetry()
rfs = reflection_file_utils.reflection_file_server(
crystal_symmetry = crystal_symmetry,
force_symmetry = True,
reflection_files = [hkl_file_object.file_content],
err = StringIO())
parameters = mmtbx.utils.data_and_flags_master_params().extract()
if (params.data_labels is not None):
parameters.labels = params.data_labels
if (params.r_free_flags_labels is not None):
parameters.r_free_flags.label = params.r_free_flags_labels
determined_data_and_flags = mmtbx.utils.determine_data_and_flags(
reflection_file_server = rfs,
parameters = parameters,
keep_going = True,
working_point_group = crystal_symmetry.space_group().build_derived_point_group(),
log = StringIO(),
symmetry_safety_check = True)
f_obs = determined_data_and_flags.f_obs
if (params.data_labels is None):
params.data_labels = f_obs.info().label_string()
r_free_flags = determined_data_and_flags.r_free_flags
assert f_obs is not None
print("Input data:", file=log)
print(" Iobs or Fobs:", f_obs.info().labels, file=log)
if (r_free_flags is not None):
print(" Free-R flags:", r_free_flags.info().labels, file=log)
params.r_free_flags_labels = r_free_flags.info().label_string()
else:
print(" Free-R flags: Not present", file=log)
fmodel = mmtbx.f_model.manager(
f_obs = f_obs,
r_free_flags = r_free_flags,
xray_structure = xrs)
fmodel.update_all_scales()
fft_map = fmodel.electron_density_map().fft_map(
resolution_factor = 0.25,
map_type = "2mFo-DFc",
use_all_data = False) # Exclude free reflections
fft_map.apply_sigma_scaling()
map_data = fft_map.real_map_unpadded(in_place=False)
if params.debug:
fft_map.as_xplor_map(file_name="%s_21.map" % params.output_prefix)
iotbx.mrcfile.write_ccp4_map(
file_name="%s_21.ccp4" % params.output_prefix,
unit_cell=crystal_symmetry.unit_cell(),
space_group=crystal_symmetry.space_group(),
map_data=map_data,
labels=flex.std_string([""]))
return map_data, crystal_symmetry
def get_pdb_inputs(pdb_str):
raw_records = flex.std_string(pdb_str.splitlines())
processed_pdb_file = rs.get_processed_pdb_object(raw_records=raw_records, rama_potential=None, log=None)
xrs = processed_pdb_file.xray_structure(show_summary=False)
geometry_restraints_manager = rs.get_geometry_restraints_manager(
processed_pdb_file=processed_pdb_file, xray_structure=xrs
)
pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy
return group_args(ph=pdb_hierarchy, grm=geometry_restraints_manager, xrs=xrs)
def run(args, log = sys.stdout):
if(len(args)==0):
print(legend, file=log)
defaults(log=log)
return
#
parsed = defaults(log=log)
processed_args = mmtbx.utils.process_command_line_args(args = args,
log = sys.stdout, master_params = parsed)
params = processed_args.params.extract()
unit_cell = processed_args.crystal_symmetry.unit_cell()
reflection_files = processed_args.reflection_files
#
atoms_with_labels = None
if(len(processed_args.pdb_file_names)==1):
pdb_combined = combine_unique_pdb_files(
file_names=processed_args.pdb_file_names)
pdb_combined.report_non_unique()
pdb_inp = iotbx.pdb.input(source_info = None,
lines = flex.std_string(pdb_combined.raw_records))
atoms_with_labels = pdb_inp.atoms_with_labels()
if(len(params.point)==0 and atoms_with_labels is None):
raise Sorry("No points given to compute map value at.")
if(len(reflection_files) == 0 and processed_args.ccp4_map is None):
raise Sorry("No reflection or map files found.")
if(len(reflection_files) > 1):
raise Sorry("More than one reflection file found.")
crystal_symmetry = processed_args.crystal_symmetry
if(crystal_symmetry is None):
raise Sorry("No crystal symmetry found.")
if(len(reflection_files) != 0):
map_3d = map_from_reflection_file(reflection_files=reflection_files, params=params)
else:
map_3d = processed_args.ccp4_map.map_data()
print("Map values at specified points:")
for point in params.point:
point_frac = unit_cell.fractionalize(point)
point_formatted = ",".join([str("%10.3f"%p).strip() for p in point])
point_frac_formatted = \
",".join([str("%10.3f"%p).strip() for p in point_frac])
map_value = str(
"%10.3f"%map_3d.eight_point_interpolation(point_frac)).strip()
print(" Input point: (%s) Fractionalized: (%s) Map value: %s"%(
point_formatted, point_frac_formatted, map_value))
#
if(atoms_with_labels is not None):
for point in atoms_with_labels:
point_frac = processed_args.crystal_symmetry.unit_cell().fractionalize(point.xyz)
point_formatted = ",".join([str("%8.3f"%p) for p in point.xyz])
map_value = str(
"%10.3f"%map_3d.eight_point_interpolation(point_frac)).strip()
print(point.quote(), "Point: %s Map value: %s"%(point_formatted,map_value))
#
print()
print("All done.")
def main(filenames, map_file, npoints=192, max_resolution=6, reverse_phi=False):
rec_range = 1 / max_resolution
image = ImageFactory(filenames[0])
panel = image.get_detector()[0]
beam = image.get_beam()
s0 = beam.get_s0()
pixel_size = panel.get_pixel_size()
xlim, ylim = image.get_raw_data().all()
xy = recviewer.get_target_pixels(panel, s0, xlim, ylim, max_resolution)
s1 = panel.get_lab_coord(xy * pixel_size[0]) # FIXME: assumed square pixel
s1 = s1 / s1.norms() * (1 / beam.get_wavelength()) # / is not supported...
S = s1 - s0
grid = flex.double(flex.grid(npoints, npoints, npoints), 0)
cnts = flex.int(flex.grid(npoints, npoints, npoints), 0)
for filename in filenames:
print "Processing image", filename
try:
fill_voxels(ImageFactory(filename), grid, cnts, S, xy, reverse_phi, rec_range)
except:
print " Failed to process. Skipped this."
recviewer.normalize_voxels(grid, cnts)
uc = uctbx.unit_cell((npoints, npoints, npoints, 90, 90, 90))
ccp4_map.write_ccp4_map(map_file, uc, sgtbx.space_group("P1"),
(0, 0, 0), grid.all(), grid,
flex.std_string(["cctbx.miller.fft_map"]))
return
from scitbx import fftpack
fft = fftpack.complex_to_complex_3d(grid.all())
grid_complex = flex.complex_double(
reals=flex.pow2(grid),
imags=flex.double(grid.size(), 0))
grid_transformed = flex.abs(fft.backward(grid_complex))
print flex.max(grid_transformed), flex.min(grid_transformed), grid_transformed.all()
ccp4_map.write_ccp4_map(map_file, uc, sgtbx.space_group("P1"),
(0, 0, 0), grid.all(), grid_transformed,
flex.std_string(["cctbx.miller.fft_map"]))
def _construct_goniometer(phi, kappa, omega):
phi_axis = (1.0, 0.0, 0.0)
kappa_axis = (0.914, 0.279, -0.297)
omega_axis = (1.0, 0.0, 0.0)
axes = flex.vec3_double((phi_axis, kappa_axis, omega_axis))
angles = flex.double((phi, kappa, omega))
names = flex.std_string(("GON_PHI", "GON_KAPPA", "GON_OMEGA"))
return GoniometerFactory.make_multi_axis_goniometer(
axes, angles, names, scan_axis=2
)
def ccp4_map(crystal_symmetry, file_name, map_data):
from iotbx import ccp4_map
ccp4_map.write_ccp4_map(
file_name=file_name,
unit_cell=crystal_symmetry.unit_cell(),
space_group=crystal_symmetry.space_group(),
#gridding_first=(0,0,0),# This causes a bug (map gets shifted)
#gridding_last=n_real, # This causes a bug (map gets shifted)
map_data=map_data,
labels=flex.std_string([""]))
def _construct_goniometer(phi, chi, omega):
phi_axis = (1.0, 0.0, 0.0)
chi_axis = (0, 0, -1)
omega_axis = (1.0, 0.0, 0.0)
axes = flex.vec3_double((phi_axis, chi_axis, omega_axis))
angles = flex.double((phi, chi, omega))
names = flex.std_string(("GON_PHI", "GON_CHI", "GON_OMEGA"))
return GoniometerFactory.make_multi_axis_goniometer(
axes, angles, names, scan_axis=2
)
def run(args):
log = sys.stdout
if len(args) == 0:
format_usage_message(log)
return
inputs = mmtbx.utils.process_command_line_args(args=args,
master_params=master_params())
work_params = inputs.params.extract()
inputs.params.show(prefix=" ", out=log)
pdb_file_names = list(inputs.pdb_file_names)
if work_params.file_name is not None:
pdb_file_names += work_params.file_name
if len(pdb_file_names) == 0:
raise Sorry("No PDB file specified")
work_params.model_idealization.enabled=True
# work_params.model_idealization.file_name_before_regularization="before.pdb"
pdb_combined = iotbx.pdb.combine_unique_pdb_files(file_names=pdb_file_names)
pdb_input = iotbx.pdb.input(source_info=None,
lines=flex.std_string(pdb_combined.raw_records))
pdb_h = pdb_input.construct_hierarchy()
# couple checks if combined pdb_h is ok
o_c = pdb_h.overall_counts()
o_c.raise_duplicate_atom_labels_if_necessary()
o_c.raise_residue_groups_with_multiple_resnames_using_same_altloc_if_necessary()
o_c.raise_chains_with_mix_of_proper_and_improper_alt_conf_if_necessary()
o_c.raise_improper_alt_conf_if_necessary()
ann = ioss.annotation.from_phil(
phil_helices=work_params.secondary_structure.protein.helix,
phil_sheets=work_params.secondary_structure.protein.sheet,
pdb_hierarchy=pdb_h)
if ann.get_n_helices() + ann.get_n_sheets() == 0:
ann = pdb_input.extract_secondary_structure()
if ann is None or ann.get_n_helices() + ann.get_n_sheets() == 0:
raise Sorry("No secondary structure annotations found.")
ssb.substitute_ss(
real_h=pdb_h,
xray_structure=pdb_input.xray_structure_simple(),
ss_annotation=ann,
params=work_params.model_idealization,
cif_objects=inputs.cif_objects,
verbose=True,
log=log,
)
# Write resulting pdb file.
write_whole_pdb_file(
file_name="%s_idealized.pdb" % os.path.basename(pdb_file_names[0]),
pdb_hierarchy=pdb_h,
crystal_symmetry=pdb_input.crystal_symmetry(),
ss_annotation=ann)
print >> log, "All done."
def ccp4_map(cg, file_name, mc=None, map_data=None):
assert [mc, map_data].count(None)==1
if(map_data is None):
map_data = get_map(mc=mc, cg=cg)
from iotbx import ccp4_map
ccp4_map.write_ccp4_map(
file_name=file_name,
unit_cell=cg.unit_cell(),
space_group=cg.space_group(),
#gridding_first=(0,0,0),# This causes a bug (map gets shifted)
#gridding_last=n_real, # This causes a bug (map gets shifted)
map_data=map_data,
labels=flex.std_string([""]))
def write_mtz_file(self, file_name, mtz_history_buffer = None,
r_free_flags=None):
from cctbx.array_family import flex
if(self.mtz_dataset is not None):
if (r_free_flags is not None) :
self.mtz_dataset.add_miller_array(r_free_flags,
column_root_label="FreeR_flag")
if(mtz_history_buffer is None):
mtz_history_buffer = flex.std_string()
mtz_history_buffer.append(date_and_time())
mtz_history_buffer.append("> file name: %s" % os.path.basename(file_name))
mtz_object = self.mtz_dataset.mtz_object()
mtz_object.add_history(mtz_history_buffer)
mtz_object.write(file_name = file_name)
return True
return False
def run(self):
from dials.util.command_line import Command
from dials.util.options import flatten_datablocks
# Parse the command line
params, options = self.parser.parse_args(show_diff_phil=True)
# Ensure we have a data block
datablocks = flatten_datablocks(params.input.datablock)
if len(datablocks) == 0:
self.parser.print_help()
return
elif len(datablocks) != 1:
raise RuntimeError("only 1 datablock can be processed at a time")
if not params.rs_mapper.map_file:
raise RuntimeError("Please specify output map file (map_file=)")
else:
self.map_file = params.rs_mapper.map_file
self.datablocks = flatten_datablocks(params.input.datablock)
if len(self.datablocks) == 0:
self.parser.print_help()
return
self.reverse_phi = params.rs_mapper.reverse_phi
self.grid_size = params.rs_mapper.grid_size
self.max_resolution = params.rs_mapper.max_resolution
self.grid = flex.double(flex.grid(self.grid_size, self.grid_size, self.grid_size), 0)
self.cnts = flex.int(flex.grid(self.grid_size, self.grid_size, self.grid_size), 0)
for datablock in self.datablocks:
for imageset in datablock.extract_imagesets():
self.process_imageset(imageset)
recviewer.normalize_voxels(self.grid, self.cnts)
uc = uctbx.unit_cell((self.grid_size, self.grid_size, self.grid_size, 90, 90, 90))
ccp4_map.write_ccp4_map(
self.map_file,
uc,
sgtbx.space_group("P1"),
(0, 0, 0),
self.grid.all(),
self.grid,
flex.std_string(["cctbx.miller.fft_map"]),
)
def format_column(key, data, format_strings=None):
if isinstance(data, flex.vec3_double):
c_strings = [c.as_string(format_strings[i].strip()) for i, c in enumerate(data.parts())]
elif isinstance(data, flex.miller_index):
c_strings = [c.as_string(format_strings[i].strip()) for i, c in enumerate(data.as_vec3_double().parts())]
elif isinstance(data, flex.size_t):
c_strings = [data.as_int().as_string(format_strings[0].strip())]
else:
c_strings = [data.as_string(format_strings[0].strip())]
column = flex.std_string()
max_element_lengths = [c.max_element_length() for c in c_strings]
for i in range(len(c_strings[0])):
column.append(('%%%is' %len(key)) %', '.join(
('%%%is' %max_element_lengths[j]) %c_strings[j][i]
for j in range(len(c_strings))))
return column
def __init__ (self,
fofc_map,
two_fofc_map,
sites_cart=None,
atom_names=None,
unit_cell=None,
atom_selection=None,
xray_structure=None,
radius=2.5) :
from cctbx import maptbx
from scitbx.array_family import flex
assert ((len(fofc_map) == len(two_fofc_map)) and
(fofc_map.focus() == two_fofc_map.focus()))
self.atom_selection = atom_selection # assumes no HD already
self.sites_cart = sites_cart
if (atom_names is not None) and (type(atom_names).__name__!='std_string'):
atom_names = flex.std_string(atom_names)
self.atom_names = atom_names
self.unit_cell = unit_cell
if (atom_selection is not None) :
assert (xray_structure is not None) and (len(self.atom_selection) > 0)
self.sites_cart = xray_structure.sites_cart().select(self.atom_selection)
self.unit_cell = xray_structure.unit_cell()
labels = xray_structure.scatterers().extract_labels()
self.atom_names = labels.select(self.atom_selection)
self.map_sel = maptbx.grid_indices_around_sites(
unit_cell=self.unit_cell,
fft_n_real=fofc_map.focus(),
fft_m_real=fofc_map.all(),
sites_cart=self.sites_cart,
site_radii=flex.double(self.sites_cart.size(), radius))
assert (len(self.map_sel) > 0)
self.fofc_map_sel = fofc_map.select(self.map_sel)
self.two_fofc_map_sel = two_fofc_map.select(self.map_sel)
self.fofc_map_levels = flex.double()
self.two_fofc_map_levels = flex.double()
for site_cart in self.sites_cart :
site_frac = self.unit_cell.fractionalize(site_cart=site_cart)
fofc_map_value = fofc_map.tricubic_interpolation(site_frac)
two_fofc_map_value = two_fofc_map.tricubic_interpolation(site_frac)
self.fofc_map_levels.append(fofc_map_value)
self.two_fofc_map_levels.append(two_fofc_map_value)
self._atom_lookup = { n.strip():i for i,n in enumerate(self.atom_names) }
def exercise_00(prefix="tst_rank_scale_map"):
xrs = iotbx.pdb.input(source_info=None, lines=pdb_str).xray_structure_simple()
fc = xrs.structure_factors(d_min=2).f_calc()
cs = fc.crystal_symmetry()
fft_map = fc.fft_map(resolution_factor=0.25)
m = fft_map.real_map_unpadded()
iotbx.ccp4_map.write_ccp4_map(
file_name="%s.ccp4"%prefix,
unit_cell=cs.unit_cell(),
space_group=cs.space_group(),
#gridding_first=(0,0,0),# This causes a bug (map gets shifted)
#gridding_last=n_real, # This causes a bug (map gets shifted)
map_data=m,
labels=flex.std_string([""]))
easy_run.call("phenix.rank_scale_map %s.ccp4"%prefix)
#
ccp4_map = iotbx.ccp4_map.map_reader(
file_name="%s.ccp4_rank_scaled.ccp4"%prefix)
m = ccp4_map.data.as_double()
mmm = m.as_1d().min_max_mean().as_tuple()
assert approx_equal(mmm, [0,1,0.5], 0.01)
def residue_density_quality (
atom_group,
unit_cell,
two_fofc_map,
fofc_map) :
from scitbx.array_family import flex
sites_cart = flex.vec3_double()
atom_names = flex.std_string()
for atom in atom_group.atoms() :
if (not atom.element.strip() in ["H","D"]) :
sites_cart.append(atom.xyz)
atom_names.append(atom.name)
if (len(sites_cart) == 0) :
raise RuntimeError("No non-hydrogen atoms in %s" % atom_group.id_str())
density = local_density_quality(
fofc_map=fofc_map,
two_fofc_map=two_fofc_map,
sites_cart=sites_cart,
atom_names=atom_names,
unit_cell=unit_cell)
return density
def _goniometer(self):
'''Return a model for a simple single-axis goniometer. This should
probably be checked against the image header, though for miniCBF
there are limited options for this.'''
phi_value = 0.0
chi_value = 0.0
omega_value = 0.0
from scitbx import matrix
from scitbx.array_family import flex
phi = (1.0, 0.0, 0.0)
chi = (0.0, 0.0, 1.0)
omega = (-1.0, 0.0, 0.0)
axes = flex.vec3_double((phi, chi, omega))
angles = flex.double((phi_value, chi_value, omega_value))
names = flex.std_string(("GON_PHI", "GON_CHI", "GON_OMEGA"))
return self._goniometer_factory.make_multi_axis_goniometer(
axes, angles, names, scan_axis=2)
def run(args):
# processing command-line stuff, out of the object
log = multi_out()
log.register("stdout", sys.stdout)
if len(args) == 0:
format_usage_message(log)
return
inputs = mmtbx.utils.process_command_line_args(args=args,
master_params=master_params())
work_params = inputs.params.extract()
inputs.params.show(prefix=" ", out=log)
pdb_file_names = list(inputs.pdb_file_names)
if work_params.file_name is not None:
pdb_file_names += work_params.file_name
if len(pdb_file_names) == 0:
raise Sorry("No PDB file specified")
if work_params.output_prefix is None:
work_params.output_prefix = os.path.basename(pdb_file_names[0])
log_file_name = "%s.log" % work_params.output_prefix
logfile = open(log_file_name, "w")
log.register("logfile", logfile)
if work_params.loop_idealization.output_prefix is None:
work_params.loop_idealization.output_prefix = "%s_rama_fixed" % work_params.output_prefix
pdb_combined = iotbx.pdb.combine_unique_pdb_files(file_names=pdb_file_names)
pdb_input = iotbx.pdb.input(source_info=None,
lines=flex.std_string(pdb_combined.raw_records))
mi_object = model_idealization(
pdb_input=pdb_input,
cif_objects=inputs.cif_objects,
params=work_params,
log=log,
verbose=True)
mi_object.run()
mi_object.print_stat_comparison()
print >> log, "RMSD from starting model (backbone, all): %.4f, %.4f" % (
mi_object.get_rmsd_from_start(), mi_object.get_rmsd_from_start2())
mi_object.print_runtime()
# add hydrogens if needed ?
print >> log, "All done."
log.close()
def write_ccp4_map (sites_cart, unit_cell, map_data, n_real, file_name,
buffer=10) :
import iotbx.ccp4_map
from cctbx import sgtbx
from scitbx.array_family import flex
if sites_cart is not None :
frac_min, frac_max = unit_cell.box_frac_around_sites(
sites_cart=sites_cart,
buffer=buffer)
else :
frac_min, frac_max = (0.0, 0.0, 0.0), (1.0, 1.0, 1.0)
gridding_first = tuple([ifloor(f*n) for f,n in zip(frac_min,n_real)])
gridding_last = tuple([iceil(f*n) for f,n in zip(frac_max,n_real)])
space_group = sgtbx.space_group_info("P1").group()
iotbx.ccp4_map.write_ccp4_map(
file_name=file_name,
unit_cell=unit_cell,
space_group=space_group,
gridding_first=gridding_first,
gridding_last=gridding_last,
map_data=map_data,
labels=flex.std_string(["iotbx.map_conversion.write_ccp4_map_box"]))
def run(args):
processed = iotbx.phil.process_command_line(
args=args, master_string=master_phil_str)
args = processed.remaining_args
work_params = processed.work.extract().smoothing
savitzky_golay_half_window = work_params.savitzky_golay.half_window
savitzky_golay_degree = work_params.savitzky_golay.degree
fourier_cutoff = work_params.fourier_filter_cutoff
#assert (fourier_cutoff is not None or
#[savitzky_golay_degree, savitzky_golay_half_window].count(None) == 0)
method = work_params.method
if method == "fourier_filter":
assert work_params.fourier_filter_cutoff is not None
for i, filename in enumerate(args):
print filename
f = open(filename, 'rb')
x, y = zip(*[line.split() for line in f.readlines() if not line.startswith("#")])
x = flex.double(flex.std_string(x))
y = flex.double(flex.std_string(y))
x = x[:-2]
y = y[:-2]
x_orig = x.deep_copy()
y_orig = y.deep_copy()
x, y = interpolate(x, y)
if method == "savitzky_golay":
x, y_smoothed = smoothing.savitzky_golay_filter(
x, y, savitzky_golay_half_window, savitzky_golay_degree)
elif method == "fourier_filter":
x, y_smoothed = fourier_filter(x, y, cutoff_frequency=fourier_cutoff)
from matplotlib import pyplot
fontsize = 20
pyplot.plot(x_orig, y_orig, color='black', linestyle='dotted', linewidth=2)
#pyplot.plot(x_orig, y_orig, color='black', linewidth=2)
pyplot.plot(x, y_smoothed, linewidth=2, color='red')
pyplot_label_axes()
pyplot.show()
#pyplot.plot(x[:385], (y - y_smoothed)[:385], linewidth=2)
#pyplot_label_axes()
#pyplot.show()
filename = os.path.join(os.path.dirname(filename), "smoothed_spectrum.txt")
f = open(filename, "wb")
print >> f, "\n".join(["%i %f" %(xi, yi)
for xi, yi in zip(x, y_smoothed)])
f.close()
print "Smoothed spectrum written to %s" %filename
x_interp_size = x.size()
for i, x_i in enumerate(reversed(x)):
if x_i not in x_orig:
assert x[x_interp_size - i - 1] == x_i
del x[x_interp_size - i - 1]
del y[x_interp_size - i - 1]
del y_smoothed[x_interp_size - i - 1]
x = x[10:-10]
y = y[10:-10]
y_smoothed = y_smoothed[10:-10]
signal_to_noise = estimate_signal_to_noise(x, y, y_smoothed, plot=False)
def test_multi_axis_goniometer():
from libtbx.test_utils import approx_equal
from scitbx.array_family import flex
alpha = 50
omega = -10
kappa = 30
phi = 20
direction = '-y'
from dxtbx.model.goniometer import KappaGoniometer
kappa_omega_scan = KappaGoniometer(
alpha, omega, kappa, phi, direction, 'omega')
axes = (kappa_omega_scan.get_phi_axis(), kappa_omega_scan.get_kappa_axis(),
kappa_omega_scan.get_omega_axis())
angles = (kappa_omega_scan.get_phi_angle(), kappa_omega_scan.get_kappa_angle(),
kappa_omega_scan.get_omega_angle())
# First test a kappa goniometer with omega as the scan axis
axes = flex.vec3_double(axes)
angles = flex.double(angles)
names = flex.std_string(('phi', 'kappa', 'omega'))
scan_axis = 2
multi_axis_omega_scan = goniometer_factory.multi_axis(
axes, angles, names, scan_axis)
assert approx_equal(multi_axis_omega_scan.get_fixed_rotation(), kappa_omega_scan.get_fixed_rotation())
assert approx_equal(multi_axis_omega_scan.get_rotation_axis(), kappa_omega_scan.get_rotation_axis())
recycle_omega = MultiAxisGoniometer.from_dict(multi_axis_omega_scan.to_dict())
assert approx_equal(recycle_omega.get_axes(), multi_axis_omega_scan.get_axes())
assert approx_equal(recycle_omega.get_angles(), multi_axis_omega_scan.get_angles())
assert recycle_omega.get_scan_axis() == multi_axis_omega_scan.get_scan_axis()
# Now test a kappa goniometer with phi as the scan axis
kappa_phi_scan = KappaGoniometer(
alpha, omega, kappa, phi, direction, 'phi')
scan_axis = 0
multi_axis_phi_scan = goniometer_factory.multi_axis(
axes, angles, names, scan_axis)
assert approx_equal(multi_axis_phi_scan.get_fixed_rotation(), kappa_phi_scan.get_fixed_rotation())
from scitbx import matrix
assert approx_equal(matrix.sqr(multi_axis_phi_scan.get_setting_rotation()) * multi_axis_phi_scan.get_rotation_axis(), kappa_phi_scan.get_rotation_axis())
recycle_phi = MultiAxisGoniometer.from_dict(multi_axis_phi_scan.to_dict())
assert approx_equal(recycle_phi.get_axes(), multi_axis_phi_scan.get_axes())
assert approx_equal(recycle_phi.get_angles(), multi_axis_phi_scan.get_angles())
assert recycle_phi.get_scan_axis() == multi_axis_phi_scan.get_scan_axis()
s = easy_pickle.dumps(multi_axis_phi_scan)
recycle = easy_pickle.loads(s)
assert recycle == multi_axis_phi_scan
assert approx_equal(recycle.get_axes(), multi_axis_phi_scan.get_axes())
assert approx_equal(recycle.get_angles(), multi_axis_phi_scan.get_angles())
assert recycle.get_scan_axis() == multi_axis_phi_scan.get_scan_axis()
recycle.set_angles((0,90,180))
assert approx_equal(recycle.get_angles(), (0, 90, 180))
new_axes = (0.9, 0.1, 0.0), (0.6427876096865394, -0.766044443118978, 0.0), (1.0, 0.0, 0.0)
new_axes = flex.vec3_double(
((0.99996, -0.00647, -0.00659), (0.91314, 0.27949, -0.29674),
(1.00000, -0.00013, -0.00064)))
recycle.set_axes(new_axes)
assert approx_equal(recycle.get_axes(), new_axes)
# Check exception is raised if scan axis is out range
try: goniometer_factory.multi_axis(axes, angles, names, 3)
except RuntimeError, e: pass
else: raise Exception_expected
# Single axis is just a special case of a multi axis goniometer
single_axis = goniometer_factory.multi_axis(
flex.vec3_double(((1,0,0),)), flex.double((0,)), flex.std_string(('PHI',)), 0)
assert single_axis.get_fixed_rotation() == (1,0,0,0,1,0,0,0,1)
assert single_axis.get_setting_rotation() == (1,0,0,0,1,0,0,0,1)
assert single_axis.get_rotation_axis() == (1,0,0)
print 'OK'
def get_pdb_hierarchy (file_names) :
assert 0, "Hopefully is not used"
pdb_combined = iotbx.pdb.combine_unique_pdb_files(file_names=file_names)
pdb_structure = iotbx.pdb.input(source_info=None,
lines=flex.std_string(pdb_combined.raw_records))
return pdb_structure.construct_hierarchy()
def run (args, params=None, out=sys.stdout, log=sys.stderr) :
# params keyword is for running program from GUI dialog
if ( ((len(args) == 0) and (params is None)) or
((len(args) > 0) and ((args[0] == "-h") or (args[0] == "--help"))) ):
show_usage()
return
# parse command-line arguments
if (params is None):
pcl = iotbx.phil.process_command_line_with_files(
args=args,
master_phil_string=master_phil_str,
pdb_file_def="file_name")
work_params = pcl.work.extract()
# or use parameters defined by GUI
else:
work_params = params
pdb_files = work_params.file_name
work_params.secondary_structure.enabled=True
assert work_params.format in ["phenix", "phenix_refine", "phenix_bonds",
"pymol", "refmac", "kinemage", "pdb"]
if work_params.quiet :
out = cStringIO.StringIO()
pdb_combined = iotbx.pdb.combine_unique_pdb_files(file_names=pdb_files)
pdb_structure = iotbx.pdb.input(source_info=None,
lines=flex.std_string(pdb_combined.raw_records))
cs = pdb_structure.crystal_symmetry()
corrupted_cs = False
if cs is not None:
if [cs.unit_cell(), cs.space_group()].count(None) > 0:
corrupted_cs = True
cs = None
elif cs.unit_cell().volume() < 10:
corrupted_cs = True
cs = None
if cs is None:
if corrupted_cs:
print >> out, "Symmetry information is corrupted, "
else:
print >> out, "Symmetry information was not found, "
print >> out, "putting molecule in P1 box."
from cctbx import uctbx
atoms = pdb_structure.atoms()
box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center(
sites_cart=atoms.extract_xyz(),
buffer_layer=3)
atoms.set_xyz(new_xyz=box.sites_cart)
cs = box.crystal_symmetry()
from mmtbx.monomer_library import pdb_interpretation, server
import mmtbx
import mmtbx.command_line.geometry_minimization
mon_lib_srv = server.server()
ener_lib = server.ener_lib()
defpars = mmtbx.command_line.geometry_minimization.master_params().extract()
defpars.pdb_interpretation.automatic_linking.link_carbohydrates=False
defpars.pdb_interpretation.c_beta_restraints=False
defpars.pdb_interpretation.clash_guard.nonbonded_distance_threshold=None
processed_pdb_file = pdb_interpretation.process(
mon_lib_srv = mon_lib_srv,
ener_lib = ener_lib,
pdb_inp = pdb_structure,
crystal_symmetry = cs,
params = defpars.pdb_interpretation,
force_symmetry = True)
pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy
geometry = processed_pdb_file.geometry_restraints_manager()
geometry.pair_proxies(processed_pdb_file.xray_structure().sites_cart())
pdb_hierarchy.atoms().reset_i_seq()
if len(pdb_hierarchy.models()) != 1 :
raise Sorry("Multiple models not supported.")
ss_from_file = None
if hasattr(pdb_structure, "extract_secondary_structure"):
ss_from_file = pdb_structure.extract_secondary_structure()
m = manager(pdb_hierarchy=pdb_hierarchy,
geometry_restraints_manager=geometry,
sec_str_from_pdb_file=ss_from_file,
params=work_params.secondary_structure,
verbose=work_params.verbose)
# bp_p = nucleic_acids.get_basepair_plane_proxies(
# pdb_hierarchy,
# m.params.secondary_structure.nucleic_acid.base_pair,
# geometry)
# st_p = nucleic_acids.get_stacking_proxies(
# pdb_hierarchy,
# m.params.secondary_structure.nucleic_acid.stacking_pair,
# geometry)
# hb_b, hb_a = nucleic_acids.get_basepair_hbond_proxies(pdb_hierarchy,
# m.params.secondary_structure.nucleic_acid.base_pair)
result_out = cStringIO.StringIO()
# prefix_scope="refinement.pdb_interpretation"
# prefix_scope=""
prefix_scope=""
if work_params.format == "phenix_refine":
prefix_scope = "refinement.pdb_interpretation"
elif work_params.format == "phenix":
prefix_scope = "pdb_interpretation"
ss_phil = None
working_phil = m.as_phil_str(master_phil=sec_str_master_phil)
phil_diff = sec_str_master_phil.fetch_diff(source=working_phil)
if work_params.format in ["phenix", "phenix_refine"]:
comment = "\n".join([
"# These parameters are suitable for use in e.g. phenix.real_space_refine",
"# or geometry_minimization. To use them in phenix.refine add ",
"# 'refinement.' if front of pdb_interpretation."])
if work_params.format == "phenix_refine":
comment = "\n".join([
"# These parameters are suitable for use in phenix.refine only.",
"# To use them in other Phenix tools remove ",
"# 'refinement.' if front of pdb_interpretation."])
print >> result_out, comment
if (prefix_scope != "") :
print >> result_out, "%s {" % prefix_scope
if work_params.show_all_params :
working_phil.show(prefix=" ", out=result_out)
else :
phil_diff.show(prefix=" ", out=result_out)
if (prefix_scope != "") :
print >> result_out, "}"
elif work_params.format == "pdb":
print >> result_out, m.actual_sec_str.as_pdb_str()
elif work_params.format == "phenix_bonds" :
raise Sorry("Not yet implemented.")
elif work_params.format in ["pymol", "refmac", "kinemage"] :
m.show_summary(log=out)
(hb_proxies, hb_angle_proxies, planarity_proxies,
parallelity_proxies) = m.create_all_new_restraints(
pdb_hierarchy=pdb_hierarchy,
grm=geometry,
log=out)
if hb_proxies.size() > 0:
if work_params.format == "pymol" :
bonds_in_format = hb_proxies.as_pymol_dashes(
pdb_hierarchy=pdb_hierarchy)
elif work_params.format == "kinemage" :
bonds_in_format = hb_proxies.as_kinemage(
pdb_hierarchy=pdb_hierarchy)
else :
bonds_in_format = hb_proxies.as_refmac_restraints(
pdb_hierarchy=pdb_hierarchy)
print >> result_out, bonds_in_format
result = result_out.getvalue()
filename = "%s_ss.eff" %os.path.basename(work_params.file_name[0])
outf = open(filename, "w")
outf.write(result)
outf.close()
print >> out, result
return os.path.abspath(filename)
