def show_summary(self, out=None):
if out is None: out = sys.stdout
n_total = self.n_cif + self.n_hkl
print >> out, "Number of cif: %7i" % self.n_cif
print >> out, "Number of hkl: %7i" % self.n_hkl
print >> out, "Number of hkl+cif pairs: ", self.n_hkl_cif_pairs
print >> out
print >> out, "%i parsing error%s" % plural_s(len(self.parsing_errors))
print >> out, "%i exception%s" % plural_s(len(self.build_errors))
print >> out, "%i ignored exception%s" % plural_s(
len(self.ignored_errors))
print >> out, "%i skipping" % len(self.skipped)
print >> out
rev = get_svn_revision()
cod_path = os.environ.get("COD_SVN_WORKING_COPY")
cod_rev = None
if cod_path is not None:
cod_rev = get_svn_revision(path=cod_path)
build_tag = get_build_tag()
if cod_rev is not None:
print >> out, "COD svn revision: %i" % cod_rev
if rev is not None:
print >> out, "cctbx svn revision: %i" % rev
if build_tag is not None:
print >> out, "cctbx build tag: ", build_tag
def show_summary(self, out=None):
if out is None: out = sys.stdout
n_total = self.n_cif + self.n_hkl
print >> out, "Number of cif: %7i" % self.n_cif
print >> out, "Number of hkl: %7i" % self.n_hkl
print >> out, "Number of hkl+cif pairs: ", self.n_hkl_cif_pairs
print >> out
print >> out, "%i parsing error%s" % plural_s(len(self.parsing_errors))
print >> out, "%i exception%s" % plural_s(len(self.build_errors))
print >> out, "%i ignored exception%s" % plural_s(len(self.ignored_errors))
print >> out, "%i skipping" % len(self.skipped)
print >> out
rev = get_svn_revision()
cod_path = os.environ.get("COD_SVN_WORKING_COPY")
cod_rev = None
if cod_path is not None:
cod_rev = get_svn_revision(path=cod_path)
build_tag = get_build_tag()
if cod_rev is not None:
print >> out, "COD svn revision: %i" %cod_rev
if rev is not None:
print >> out, "cctbx svn revision: %i" %rev
if build_tag is not None:
print >> out, "cctbx build tag: ", build_tag
def show_summary(O, vertex_labels, out=None, prefix=""):
from libtbx.utils import xlen, plural_s
import sys
if (out is None): out = sys.stdout
if (vertex_labels is None):
fmt = "%%0%dd" % len(str(max(0, O.n_vertices - 1)))
vertex_labels = [fmt % i for i in range(O.n_vertices)]
else:
assert len(vertex_labels) == O.n_vertices
print(prefix + "number of vertices:", O.n_vertices, file=out)
print(prefix + "number of edges:", xlen(O.edge_list), file=out)
if (O.find_cluster_loop_repeats is None):
print(prefix + "find cluster loops: None", file=out)
else:
print(prefix+"find cluster loops: %d repeat%s" % \
plural_s(O.find_cluster_loop_repeats), file=out)
cm = O.cluster_manager
cm.show_summary(out=out, prefix=prefix)
if (cm.fixed_hinges is not None):
for i, j in cm.fixed_hinges:
print(prefix + "tardy fixed hinge:",
vertex_labels[i],
file=out)
print(prefix + " ",
vertex_labels[j],
file=out)
return O
def run(args, command_name=libtbx.env.dispatcher_name):
parser = argparse.ArgumentParser(
prog=command_name,
usage='%s pdb_file "atom_selection" [...]' % command_name)
parser.add_argument("file_name",
nargs=1,
help="File name of the model file")
parser.add_argument(
"inselections",
help="Atom selection strings",
nargs='+',
)
parser.add_argument("--write-pdb-file",
action="store",
help="write selected atoms to new PDB file",
default=None)
parser.add_argument(
"--cryst1-replacement-buffer-layer",
action="store",
type=float,
help="replace CRYST1 with pseudo unit cell covering the selected"
" atoms plus a surrounding buffer layer",
default=None)
co = parser.parse_args(args)
mon_lib_srv = server.server()
ener_lib = server.ener_lib()
processed_pdb_file = pdb_interpretation.process(mon_lib_srv=mon_lib_srv,
ener_lib=ener_lib,
file_name=co.file_name[0],
log=sys.stdout)
print
acp = processed_pdb_file.all_chain_proxies
selection_cache = acp.pdb_hierarchy.atom_selection_cache()
atoms = acp.pdb_atoms
all_bsel = flex.bool(atoms.size(), False)
for selection_string in co.inselections:
print selection_string
isel = acp.iselection(string=selection_string, cache=selection_cache)
all_bsel.set_selected(isel, True)
if (not co.write_pdb_file):
print " %d atom%s selected" % plural_s(isel.size())
for atom in atoms.select(isel):
print " %s" % atom.format_atom_record()
print
if (co.write_pdb_file):
print "Writing file:", show_string(co.write_pdb_file)
sel_hierarchy = acp.pdb_hierarchy.select(all_bsel)
if (co.cryst1_replacement_buffer_layer is None):
crystal_symmetry = acp.special_position_settings
else:
import cctbx.crystal
crystal_symmetry = cctbx.crystal.non_crystallographic_symmetry(
sites_cart=sel_hierarchy.atoms().extract_xyz(),
buffer_layer=co.cryst1_replacement_buffer_layer)
write_whole_pdb_file(file_name=co.write_pdb_file,
processed_pdb_file=processed_pdb_file,
pdb_hierarchy=sel_hierarchy,
crystal_symmetry=crystal_symmetry)
print
def __init__(self, f_obs, asu_contents, e_statistics=False):
assert f_obs.is_real_array()
self.info = f_obs.info()
f_obs_selected = f_obs.select(f_obs.data() > 0)
f_obs_selected.use_binning_of(f_obs)
# compute <fobs^2> in resolution shells
self.mean_fobs_sq = f_obs_selected.mean_sq(
use_binning=True,
use_multiplicities=True).data[1:-1]
n_none = self.mean_fobs_sq.count(None)
if (n_none > 0):
error_message = "wilson_plot error: %d empty bin%s:" % plural_s(n_none)
if (self.info is not None):
error_message += "\n Info: " + str(self.info)
error_message += "\n Number of bins: %d" % len(self.mean_fobs_sq)
error_message += "\n Number of f_obs > 0: %d" % (
f_obs_selected.indices().size())
error_message += "\n Number of f_obs <= 0: %d" % (
f_obs.indices().size() - f_obs_selected.indices().size())
raise RuntimeError(error_message)
self.mean_fobs_sq = flex.double(self.mean_fobs_sq)
# compute <s^2> = <(sin(theta)/lambda)^2> in resolution shells
stol_sq = f_obs_selected.sin_theta_over_lambda_sq()
stol_sq.use_binner_of(f_obs_selected)
self.mean_stol_sq = flex.double(stol_sq.mean(
use_binning=True,
use_multiplicities=True).data[1:-1])
# cache scattering factor info
gaussians = {}
for chemical_type in asu_contents.keys():
gaussians[chemical_type] = eltbx.xray_scattering.wk1995(
chemical_type).fetch()
# compute expected f_calc^2 in resolution shells
self.expected_f_sq = flex.double()
for stol_sq in self.mean_stol_sq:
sum_fj_sq = 0
for chemical_type, n_atoms in asu_contents.items():
f0 = gaussians[chemical_type].at_stol_sq(stol_sq)
sum_fj_sq += f0 * f0 * n_atoms
self.expected_f_sq.append(sum_fj_sq)
self.expected_f_sq *= f_obs_selected.space_group().order_z() \
* f_obs_selected.space_group().n_ltr()
# fit to straight line
self.x = self.mean_stol_sq
self.y = flex.log(self.mean_fobs_sq / self.expected_f_sq)
fit = flex.linear_regression(self.x, self.y)
assert fit.is_well_defined()
self.fit_y_intercept = fit.y_intercept()
self.fit_slope = fit.slope()
self.wilson_intensity_scale_factor = math.exp(self.fit_y_intercept) # intensity scale factor
self.wilson_k = math.sqrt(self.wilson_intensity_scale_factor) # conversion to amplitude scale factor
self.wilson_b = -self.fit_slope / 2
self.fit_correlation = flex.linear_correlation(self.x,self.y).coefficient()
if e_statistics:
normalised = f_obs_selected.normalised_amplitudes(asu_contents, self)
self.normalised_f_obs = normalised.array()
self.mean_e_sq_minus_1 = normalised.mean_e_sq_minus_1()
self.percent_e_sq_gt_2 = normalised.percent_e_sq_gt_2()
def run(self):
# I'm guessing self.data_manager, self.params and self.logger
# are already defined here...
# this must be mmtbx.model.manager?
model = self.data_manager.get_model()
atoms = model.get_atoms()
all_bsel = flex.bool(atoms.size(), False)
for selection_string in self.params.atom_selection_program.inselection:
print("Selecting '%s'" % selection_string, file=self.logger)
isel = model.iselection(string=selection_string)
all_bsel.set_selected(isel, True)
if self.params.atom_selection_program.write_pdb_file is None:
print(" %d atom%s selected" % plural_s(isel.size()),
file=self.logger)
for atom in atoms.select(isel):
print(" %s" % atom.format_atom_record(),
file=self.logger)
print("", file=self.logger)
if self.params.atom_selection_program.write_pdb_file is not None:
print("Writing file:",
show_string(
self.params.atom_selection_program.write_pdb_file),
file=self.logger)
ss_ann = model.get_ss_annotation()
if not model.crystal_symmetry() or \
(not model.crystal_symmetry().unit_cell()):
model = shift_and_box_model(model, shift_model=False)
selected_model = model.select(all_bsel)
if (ss_ann is not None):
selected_model.set_ss_annotation(ss_ann.\
filter_annotation(
hierarchy=selected_model.get_hierarchy(),
asc=selected_model.get_atom_selection_cache(),
remove_short_annotations=False,
remove_3_10_helices=False,
remove_empty_annotations=True,
concatenate_consecutive_helices=False,
split_helices_with_prolines=False,
filter_sheets_with_long_hbonds=False))
if self.params.atom_selection_program.cryst1_replacement_buffer_layer is not None:
box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center(
sites_cart=selected_model.get_atoms().extract_xyz(),
buffer_layer=self.params.atom_selection_program.
cryst1_replacement_buffer_layer)
sp = crystal.special_position_settings(box.crystal_symmetry())
sites_frac = box.sites_frac()
xrs_box = selected_model.get_xray_structure(
).replace_sites_frac(box.sites_frac())
xray_structure_box = xray.structure(sp, xrs_box.scatterers())
selected_model.set_xray_structure(xray_structure_box)
pdb_str = selected_model.model_as_pdb()
f = open(self.params.atom_selection_program.write_pdb_file, 'w')
f.write(pdb_str)
f.close()
print("", file=self.logger)
def run(args, command_name=libtbx.env.dispatcher_name):
parser = argparse.ArgumentParser(
prog=command_name,
usage='%s pdb_file "atom_selection" [...]' % command_name)
parser.add_argument("file_name",
nargs=1,
help="File name of the model file")
parser.add_argument(
"inselections",
help="Atom selection strings",
nargs='+',
)
parser.add_argument("--write-pdb-file",
action="store",
help="write selected atoms to new PDB file",
default=None)
parser.add_argument(
"--cryst1-replacement-buffer-layer",
action="store",
type=float,
help="replace CRYST1 with pseudo unit cell covering the selected"
" atoms plus a surrounding buffer layer",
default=None)
co = parser.parse_args(args)
pdb_inp = iotbx.pdb.input(file_name=co.file_name[0])
model = mmtbx.model.manager(model_input=pdb_inp, process_input=True)
atoms = model.get_atoms()
all_bsel = flex.bool(atoms.size(), False)
for selection_string in co.inselections:
print selection_string
isel = model.iselection(selstr=selection_string)
all_bsel.set_selected(isel, True)
if (not co.write_pdb_file):
print " %d atom%s selected" % plural_s(isel.size())
for atom in atoms.select(isel):
print " %s" % atom.format_atom_record()
print
if (co.write_pdb_file):
print "Writing file:", show_string(co.write_pdb_file)
selected_model = model.select(all_bsel)
if (co.cryst1_replacement_buffer_layer is not None):
box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center(
sites_cart=selected_model.get_atoms().extract_xyz(),
buffer_layer=co.cryst1_replacement_buffer_layer)
sp = crystal.special_position_settings(box.crystal_symmetry())
sites_frac = box.sites_frac()
xrs_box = selected_model.get_xray_structure().replace_sites_frac(
box.sites_frac())
xray_structure_box = xray.structure(sp, xrs_box.scatterers())
selected_model.set_xray_structure(xray_structure_box)
pdb_str = selected_model.model_as_pdb()
f = open(co.write_pdb_file, 'w')
f.write(pdb_str)
f.close()
print
def run_dps(args):
imageset, spots_mm, max_cell, params = args
detector = imageset.get_detector()
beam = imageset.get_beam()
goniometer = imageset.get_goniometer()
scan = imageset.get_scan()
from rstbx.indexing_api.lattice import DPS_primitive_lattice
# max_cell: max possible cell in Angstroms; set to None, determine from data
# recommended_grid_sampling_rad: grid sampling in radians; guess for now
DPS = DPS_primitive_lattice(max_cell=max_cell,
recommended_grid_sampling_rad=None,
horizon_phil=params)
from scitbx import matrix
DPS.S0_vector = matrix.col(beam.get_s0())
DPS.inv_wave = 1./beam.get_wavelength()
if goniometer is None:
DPS.axis = matrix.col((1,0,0))
else:
DPS.axis = matrix.col(goniometer.get_rotation_axis())
DPS.set_detector(detector)
# transform input into what Nick needs
# i.e., construct a flex.vec3 double consisting of mm spots, phi in degrees
data = flex.vec3_double()
for spot in spots_mm:
data.append((spot['xyzobs.mm.value'][0],
spot['xyzobs.mm.value'][1],
spot['xyzobs.mm.value'][2]*180./math.pi))
#from matplotlib import pyplot as plt
#plt.plot([spot.centroid_position[0] for spot in spots_mm] , [spot.centroid_position[1] for spot in spots_mm], 'ro')
#plt.show()
logger.info("Running DPS using %i reflections" %len(data))
DPS.index(raw_spot_input=data,
panel_addresses=flex.int([s['panel'] for s in spots_mm]))
solutions = DPS.getSolutions()
from libtbx.utils import plural_s
logger.info("Found %i solution%s with max unit cell %.2f Angstroms." %(
len(solutions), plural_s(len(solutions))[1], DPS.amax))
if len(solutions) < 3:
from libtbx.utils import Sorry
raise Sorry("Not enough solutions: found %i, need at least 3" %(
len(solutions)))
return dict(solutions=flex.vec3_double(
[s.dvec for s in solutions]), amax=DPS.amax)
def __init__(self, f_obs, asu_contents, e_statistics=False):
assert f_obs.is_real_array()
self.info = f_obs.info()
f_obs_selected = f_obs.select(f_obs.data() > 0)
f_obs_selected.use_binning_of(f_obs)
# compute <fobs^2> in resolution shells
self.mean_fobs_sq = f_obs_selected.mean_sq(use_binning=True, use_multiplicities=True).data[1:-1]
n_none = self.mean_fobs_sq.count(None)
if n_none > 0:
error_message = "wilson_plot error: %d empty bin%s:" % plural_s(n_none)
if self.info is not None:
error_message += "\n Info: " + str(self.info)
error_message += "\n Number of bins: %d" % len(self.mean_fobs_sq)
error_message += "\n Number of f_obs > 0: %d" % (f_obs_selected.indices().size())
error_message += "\n Number of f_obs <= 0: %d" % (f_obs.indices().size() - f_obs_selected.indices().size())
raise RuntimeError(error_message)
self.mean_fobs_sq = flex.double(self.mean_fobs_sq)
# compute <s^2> = <(sin(theta)/lambda)^2> in resolution shells
stol_sq = f_obs_selected.sin_theta_over_lambda_sq()
stol_sq.use_binner_of(f_obs_selected)
self.mean_stol_sq = flex.double(stol_sq.mean(use_binning=True, use_multiplicities=True).data[1:-1])
# cache scattering factor info
gaussians = {}
for chemical_type in asu_contents.keys():
gaussians[chemical_type] = eltbx.xray_scattering.wk1995(chemical_type).fetch()
# compute expected f_calc^2 in resolution shells
self.expected_f_sq = flex.double()
for stol_sq in self.mean_stol_sq:
sum_fj_sq = 0
for chemical_type, n_atoms in asu_contents.items():
f0 = gaussians[chemical_type].at_stol_sq(stol_sq)
sum_fj_sq += f0 * f0 * n_atoms
self.expected_f_sq.append(sum_fj_sq)
self.expected_f_sq *= f_obs_selected.space_group().order_z() * f_obs_selected.space_group().n_ltr()
# fit to straight line
self.x = self.mean_stol_sq
self.y = flex.log(self.mean_fobs_sq / self.expected_f_sq)
fit = flex.linear_regression(self.x, self.y)
assert fit.is_well_defined()
self.fit_y_intercept = fit.y_intercept()
self.fit_slope = fit.slope()
self.wilson_intensity_scale_factor = math.exp(self.fit_y_intercept) # intensity scale factor
self.wilson_k = math.sqrt(self.wilson_intensity_scale_factor) # conversion to amplitude scale factor
self.wilson_b = -self.fit_slope / 2
self.fit_correlation = flex.linear_correlation(self.x, self.y).coefficient()
if e_statistics:
normalised = f_obs_selected.normalised_amplitudes(asu_contents, self)
self.normalised_f_obs = normalised.array()
self.mean_e_sq_minus_1 = normalised.mean_e_sq_minus_1()
self.percent_e_sq_gt_2 = normalised.percent_e_sq_gt_2()
def run_dps(args):
imageset, spots_mm, max_cell, params = args
detector = imageset.get_detector()
beam = imageset.get_beam()
goniometer = imageset.get_goniometer()
# max_cell: max possible cell in Angstroms; set to None, determine from data
# recommended_grid_sampling_rad: grid sampling in radians; guess for now
DPS = DPS_primitive_lattice(max_cell=max_cell,
recommended_grid_sampling_rad=None,
horizon_phil=params)
DPS.S0_vector = matrix.col(beam.get_s0())
DPS.inv_wave = 1.0 / beam.get_wavelength()
if goniometer is None:
DPS.axis = matrix.col((1, 0, 0))
else:
DPS.axis = matrix.col(goniometer.get_rotation_axis())
DPS.set_detector(detector)
# transform input into what Nick needs
# i.e., construct a flex.vec3 double consisting of mm spots, phi in degrees
data = flex.vec3_double()
for spot in spots_mm.rows():
data.append((
spot["xyzobs.mm.value"][0],
spot["xyzobs.mm.value"][1],
spot["xyzobs.mm.value"][2] * 180.0 / math.pi,
))
logger.info("Running DPS using %i reflections" % len(data))
DPS.index(
raw_spot_input=data,
panel_addresses=flex.int(s["panel"] for s in spots_mm.rows()),
)
solutions = DPS.getSolutions()
logger.info("Found %i solution%s with max unit cell %.2f Angstroms." %
(len(solutions), plural_s(len(solutions))[1], DPS.amax))
if len(solutions) < 3:
raise Sorry("Not enough solutions: found %i, need at least 3" %
(len(solutions)))
return dict(solutions=flex.vec3_double([s.dvec for s in solutions]),
amax=DPS.amax)
def run_dps(experiment, spots_mm, max_cell):
# max_cell: max possible cell in Angstroms; set to None, determine from data
# recommended_grid_sampling_rad: grid sampling in radians; guess for now
horizon_phil = iotbx.phil.parse(input_string=indexing_api_defs).extract()
DPS = DPS_primitive_lattice(max_cell=max_cell,
recommended_grid_sampling_rad=None,
horizon_phil=horizon_phil)
DPS.S0_vector = matrix.col(experiment.beam.get_s0())
DPS.inv_wave = 1.0 / experiment.beam.get_wavelength()
if experiment.goniometer is None:
DPS.axis = matrix.col((1, 0, 0))
else:
DPS.axis = matrix.col(experiment.goniometer.get_rotation_axis())
DPS.set_detector(experiment.detector)
# transform input into what DPS needs
# i.e., construct a flex.vec3 double consisting of mm spots, phi in degrees
data = flex.vec3_double()
for spot in spots_mm.rows():
data.append((
spot["xyzobs.mm.value"][0],
spot["xyzobs.mm.value"][1],
spot["xyzobs.mm.value"][2] * 180.0 / math.pi,
))
logger.info("Running DPS using %i reflections", len(data))
DPS.index(
raw_spot_input=data,
panel_addresses=flex.int(s["panel"] for s in spots_mm.rows()),
)
solutions = DPS.getSolutions()
logger.info(
"Found %i solution%s with max unit cell %.2f Angstroms.",
len(solutions),
plural_s(len(solutions))[1],
DPS.amax,
)
# There must be at least 3 solutions to make a set, otherwise return empty result
if len(solutions) < 3:
return {}
return {
"solutions": flex.vec3_double(s.dvec for s in solutions),
"amax": DPS.amax
}
def show_summary(O, out=None, prefix=""):
from libtbx.utils import xlen, plural_s
import sys
if (out is None): out = sys.stdout
print >> out, prefix+"number of fixed vertex lists:", \
len(O.fixed_vertex_lists)
print >> out, prefix+"number of fixed vertices:", \
sum([len(fixed_vertices) for fixed_vertices in O.fixed_vertex_lists])
print >> out, prefix + "number of clusters:", len(O.clusters)
print >> out, prefix+"merge clusters with multiple connections: %d pass%s"\
% plural_s(O.merge_clusters_with_multiple_connections_passes, "es")
print >> out, prefix + "number of hinge edges:", xlen(O.hinge_edges)
print >> out, prefix + "number of loop edges:", xlen(O.loop_edges)
print >> out, prefix+"number of loop edge bendings:", \
xlen(O.loop_edge_bendings)
print >> out, prefix + "number of fixed hinges:", xlen(O.fixed_hinges)
return O
def show_summary(O, out=None, prefix=""):
from libtbx.utils import xlen, plural_s
import sys
if (out is None): out = sys.stdout
print >> out, prefix+"number of fixed vertex lists:", \
len(O.fixed_vertex_lists)
print >> out, prefix+"number of fixed vertices:", \
sum([len(fixed_vertices) for fixed_vertices in O.fixed_vertex_lists])
print >> out, prefix+"number of clusters:", len(O.clusters)
print >> out, prefix+"merge clusters with multiple connections: %d pass%s"\
% plural_s(O.merge_clusters_with_multiple_connections_passes, "es")
print >> out, prefix+"number of hinge edges:", xlen(O.hinge_edges)
print >> out, prefix+"number of loop edges:", xlen(O.loop_edges)
print >> out, prefix+"number of loop edge bendings:", \
xlen(O.loop_edge_bendings)
print >> out, prefix+"number of fixed hinges:", xlen(O.fixed_hinges)
return O
def run(self):
# I'm guessing self.data_manager, self.params and self.logger
# are already defined here...
# this must be mmtbx.model.manager?
model = self.data_manager.get_model()
atoms = model.get_atoms()
all_bsel = flex.bool(atoms.size(), False)
for selection_string in self.params.atom_selection_program.inselection:
print("Selecting '%s'" % selection_string, file=self.logger)
isel = model.iselection(selstr=selection_string)
all_bsel.set_selected(isel, True)
if self.params.atom_selection_program.write_pdb_file is None:
print(" %d atom%s selected" % plural_s(isel.size()),
file=self.logger)
for atom in atoms.select(isel):
print(" %s" % atom.format_atom_record(),
file=self.logger)
print("", file=self.logger)
if self.params.atom_selection_program.write_pdb_file is not None:
print("Writing file:",
show_string(
self.params.atom_selection_program.write_pdb_file),
file=self.logger)
selected_model = model.select(all_bsel)
if self.params.atom_selection_program.cryst1_replacement_buffer_layer is not None:
box = uctbx.non_crystallographic_unit_cell_with_the_sites_in_its_center(
sites_cart=selected_model.get_atoms().extract_xyz(),
buffer_layer=self.params.atom_selection_program.
cryst1_replacement_buffer_layer)
sp = crystal.special_position_settings(box.crystal_symmetry())
sites_frac = box.sites_frac()
xrs_box = selected_model.get_xray_structure(
).replace_sites_frac(box.sites_frac())
xray_structure_box = xray.structure(sp, xrs_box.scatterers())
selected_model.set_xray_structure(xray_structure_box)
pdb_str = selected_model.model_as_pdb()
f = open(self.params.atom_selection_program.write_pdb_file, 'w')
f.write(pdb_str)
f.close()
print("", file=self.logger)
def process(params, pickle_file_name):
cod_id = op.basename(pickle_file_name).split(".", 1)[0]
print "cod_id:", cod_id
c_obs, structure_prep, edge_list = easy_pickle.load(
file_name=pickle_file_name)
changes = structure_prep.make_scatterer_labels_shelx_compatible_in_place()
if (params.sites_mod_short):
structure_prep = structure_prep.sites_mod_short()
from iotbx.shelx import fvar_encoding
structure_prep = \
fvar_encoding.move_sites_if_necessary_for_shelx_fvar_encoding(
xray_structure=structure_prep)
structure_prep.show_summary().show_scatterers()
if (len(changes) != 0):
from libtbx.utils import plural_s
print "INFO: %d atom name%s changed for compatibility with SHELXL:" \
% plural_s(len(changes))
for change in changes:
print ' changed: "%s" -> "%s"' % change
structure_prep.scattering_type_registry(table="it1992").show()
fvar_encoding.dev_build_shelx76_fvars(structure_prep) # only an exercise
print "." * 79
#
if (len(params.optimizers) == 0):
return
#
assert c_obs.is_xray_intensity_array() or c_obs.is_xray_amplitude_array()
if (c_obs.is_xray_intensity_array()):
i_obs = c_obs
f_obs = c_obs.f_sq_as_f(algorithm="xtal_3_7")
else:
f_obs = c_obs
i_obs = c_obs.f_as_f_sq(algorithm="shelxl")
process_continue(params=params,
cod_id=cod_id,
c_obs=c_obs,
i_obs=i_obs,
f_obs=f_obs,
structure_prep=structure_prep)
def exercise_syminfo_lib_pdb_cryst1_recycling():
# this call is to build _syminfo_lib_cache
assert extract_from_symmetry_lib.ccp4_symbol(
space_group_info=sgtbx.space_group_info("P 1"),
lib_name="syminfo.lib") == "P 1"
#
import iotbx.pdb.cryst1_interpretation
n_need_more_special = 0
for number in xrange(1,230+1):
for hall,ccp4_symbol in \
extract_from_symmetry_lib._syminfo_lib_cache[number]:
sgi_hall = sgtbx.space_group_info(symbol="Hall: "+hall)
if (sgi_hall.group().is_centric()):
continue
sgroup = iotbx.pdb.format_cryst1_sgroup(space_group_info=sgi_hall)
if (len(sgroup) > 11):
print "ccp4 syminfo.lib setting leads to pdb CRYST1 overflow:",\
ccp4_symbol, sgroup
cs = sgi_hall.any_compatible_crystal_symmetry(volume=1000)
pdb_str = iotbx.pdb.format_cryst1_record(crystal_symmetry=cs)
cs2 = iotbx.pdb.cryst1_interpretation.crystal_symmetry(
cryst1_record=pdb_str)
if (cs2.space_group_info() is None):
if (n_need_more_special == 0): print
print '"%s": "Hall: %s",' % (
ccp4_symbol.replace(" ", "").upper(), hall)
n_need_more_special += 1
else:
assert cs2.is_similar_symmetry(other=cs)
if (ccp4io_adaptbx is not None):
exercise_mmdb_cryst1_interpretation(
sgi_hall=sgi_hall, pdb_str=pdb_str)
if (n_need_more_special != 0):
print
from libtbx.utils import plural_s
raise RuntimeError("""\
Please edit iotbx/pdb/cryst1_interpretation.py:
Add the %d line%s above with "Hall:" to the "special" dictionary.
""" % plural_s(n_need_more_special))
def exercise_syminfo_lib_pdb_cryst1_recycling():
# this call is to build _syminfo_lib_cache
assert extract_from_symmetry_lib.ccp4_symbol(
space_group_info=sgtbx.space_group_info("P 1"),
lib_name="syminfo.lib") == "P 1"
#
import iotbx.pdb.cryst1_interpretation
n_need_more_special = 0
for number in range(1, 230 + 1):
for hall,ccp4_symbol in \
extract_from_symmetry_lib._syminfo_lib_cache[number]:
sgi_hall = sgtbx.space_group_info(symbol="Hall: " + hall)
if (sgi_hall.group().is_centric()):
continue
sgroup = iotbx.pdb.format_cryst1_sgroup(space_group_info=sgi_hall)
if (len(sgroup) > 11):
print("ccp4 syminfo.lib setting leads to pdb CRYST1 overflow:",\
ccp4_symbol, sgroup)
cs = sgi_hall.any_compatible_crystal_symmetry(volume=1000)
pdb_str = iotbx.pdb.format_cryst1_record(crystal_symmetry=cs)
cs2 = iotbx.pdb.cryst1_interpretation.crystal_symmetry(
cryst1_record=pdb_str)
if (cs2.space_group_info() is None):
if (n_need_more_special == 0): print()
print('"%s": "Hall: %s",' %
(ccp4_symbol.replace(" ", "").upper(), hall))
n_need_more_special += 1
else:
assert cs2.is_similar_symmetry(other=cs)
if (ccp4io_adaptbx is not None):
exercise_mmdb_cryst1_interpretation(sgi_hall=sgi_hall,
pdb_str=pdb_str)
if (n_need_more_special != 0):
print()
from libtbx.utils import plural_s
raise RuntimeError("""\
Please edit iotbx/pdb/cryst1_interpretation.py:
Add the %d line%s above with "Hall:" to the "special" dictionary.
""" % plural_s(n_need_more_special))
def process(params, pickle_file_name):
cod_id = op.basename(pickle_file_name).split(".",1)[0]
print "cod_id:", cod_id
c_obs, structure_prep, edge_list = easy_pickle.load(
file_name=pickle_file_name)
changes = structure_prep.make_scatterer_labels_shelx_compatible_in_place()
if (params.sites_mod_short):
structure_prep = structure_prep.sites_mod_short()
from iotbx.shelx import fvar_encoding
structure_prep = \
fvar_encoding.move_sites_if_necessary_for_shelx_fvar_encoding(
xray_structure=structure_prep)
structure_prep.show_summary().show_scatterers()
if (len(changes) != 0):
from libtbx.utils import plural_s
print "INFO: %d atom name%s changed for compatibility with SHELXL:" \
% plural_s(len(changes))
for change in changes:
print ' changed: "%s" -> "%s"' % change
structure_prep.scattering_type_registry(table="it1992").show()
fvar_encoding.dev_build_shelx76_fvars(structure_prep) # only an exercise
print "."*79
#
if (len(params.optimizers) == 0):
return
#
assert c_obs.is_xray_intensity_array() or c_obs.is_xray_amplitude_array()
if (c_obs.is_xray_intensity_array()):
i_obs = c_obs
f_obs = c_obs.f_sq_as_f(algorithm="xtal_3_7")
else:
f_obs = c_obs
i_obs = c_obs.f_as_f_sq(algorithm="shelxl")
process_continue(
params=params,
cod_id=cod_id,
c_obs=c_obs, i_obs=i_obs, f_obs=f_obs,
structure_prep=structure_prep)
def show_summary(O, vertex_labels, out=None, prefix=""):
from libtbx.utils import xlen, plural_s
import sys
if (out is None): out = sys.stdout
if (vertex_labels is None):
fmt = "%%0%dd" % len(str(max(0, O.n_vertices-1)))
vertex_labels = [fmt % i for i in xrange(O.n_vertices)]
else:
assert len(vertex_labels) == O.n_vertices
print >> out, prefix+"number of vertices:", O.n_vertices
print >> out, prefix+"number of edges:", xlen(O.edge_list)
if (O.find_cluster_loop_repeats is None):
print >> out, prefix+"find cluster loops: None"
else:
print >> out, prefix+"find cluster loops: %d repeat%s" % \
plural_s(O.find_cluster_loop_repeats)
cm = O.cluster_manager
cm.show_summary(out=out, prefix=prefix)
if (cm.fixed_hinges is not None):
for i,j in cm.fixed_hinges:
print >> out, prefix+"tardy fixed hinge:", vertex_labels[i]
print >> out, prefix+" ", vertex_labels[j]
return O
def run(args, command_name=libtbx.env.dispatcher_name):
if (len(args) == 0): args = ["--help"]
command_line = (option_parser(
usage='%s pdb_file "atom_selection" [...]' % command_name).option(
None,
"--write_pdb_file",
action="store",
type="string",
default=None,
help="write selected atoms to new PDB file",
metavar="FILE"
).option(
None,
"--cryst1_replacement_buffer_layer",
action="store",
type="float",
default=None,
help="replace CRYST1 with pseudo unit cell covering the selected"
" atoms plus a surrounding buffer layer",
metavar="WIDTH")).process(args=args, min_nargs=2)
co = command_line.options
mon_lib_srv = server.server()
ener_lib = server.ener_lib()
processed_pdb_file = pdb_interpretation.process(
mon_lib_srv=mon_lib_srv,
ener_lib=ener_lib,
file_name=command_line.args[0],
log=sys.stdout)
print
acp = processed_pdb_file.all_chain_proxies
hierarchy = acp.pdb_hierarchy
asc = hierarchy.atom_selection_cache()
sel = asc.selection(string="chain 'A' and resid 1 through 8 and icode ' '")
h1 = hierarchy.select(sel) # keep original hierarchy too
print h1.as_pdb_string()
selection_cache = acp.pdb_hierarchy.atom_selection_cache()
atoms = acp.pdb_atoms
all_bsel = flex.bool(atoms.size(), False)
for selection_string in command_line.args[1:]:
print selection_string
isel = acp.iselection(string=selection_string, cache=selection_cache)
all_bsel.set_selected(isel, True)
if (not co.write_pdb_file):
print " %d atom%s selected" % plural_s(isel.size())
for atom in atoms.select(isel):
print " %s" % atom.format_atom_record()
print
if (co.write_pdb_file):
print "Writing file:", show_string(co.write_pdb_file)
sel_hierarchy = acp.pdb_hierarchy.select(all_bsel)
if (co.cryst1_replacement_buffer_layer is None):
crystal_symmetry = acp.special_position_settings
else:
import cctbx.crystal
crystal_symmetry = cctbx.crystal.non_crystallographic_symmetry(
sites_cart=sel_hierarchy.atoms().extract_xyz(),
buffer_layer=co.cryst1_replacement_buffer_layer)
write_whole_pdb_file(file_name=co.write_pdb_file,
processed_pdb_file=processed_pdb_file,
pdb_hierarchy=sel_hierarchy,
crystal_symmetry=crystal_symmetry)
print
else:
l = line.strip().replace(" ","")
if (l == "){-endblockparameterdefinition-}"):
lines_out.append(line)
end_block_parameter_definition = True
else:
line_out = line
for p in parameter_names:
if (l.startswith("{===>}%s=" % p) and l.endswith(";")):
parameters_found[p] += 1
line_out = '{===>} %s=%s;' % (p, vars()[p])
if (line_out != line): parameters_changed.append(p)
break
lines_out.append(line_out)
if (parameters_found.values().count(1) != 7):
raise Sorry("Unexpected set of variable names in %s:\n counts: %s" % (
show_string(target), str(parameters_found)))
elif (len(parameters_changed) == 0):
print "Info: no changes, %s was not modified." % show_string(target)
else:
string_out = "\n".join(lines_out)
print "Info: %d change%s" % plural_s(len(parameters_changed)), \
"(%s)," % ", ".join(parameters_changed), \
"writing modified file %s." % show_string(target)
try: print >> open(target, "w"), string_out
except IOError, e:
raise Sorry("Error writing file %s (%s)" % (show_string(target), str(e)))
if (__name__ == "__main__"):
run(sys.argv[1:])
def unit_cell_info(sub_clusters):
"""
Print unit cell information for a list of clusters.
:param sub_clusters: a list of cluster objects
:return: a string containing median unit cells, standard deviations and
point group composition of each cluster.
"""
from libtbx.utils import plural_s
# 3. print out some information that is useful.
out_str = "\n\n{:<16} {:<8} {:<13} {:<13} {:<13} {:<12} {:<12} {:<12}{:<8}\n".format(
"Cluster_id", "N_xtals", "Med_a", "Med_b", "Med_c", "Med_alpha",
"Med_beta", "Med_gamma", "Delta(deg)")
singletons = []
for cluster in sub_clusters:
if len(cluster.members) != 1:
# New approach, takes niggli setting of the cluster median and converts
# back to reference setting for cluster report. Fixes cctbx#97.
from cctbx import crystal
from cctbx.uctbx import unit_cell
from cctbx.sgtbx.lattice_symmetry import metric_subgroups
input_symmetry = crystal.symmetry(unit_cell=unit_cell(
cluster.medians[0:6]),
space_group_symbol="P 1")
groups = metric_subgroups(
input_symmetry,
3.00,
enforce_max_delta_for_generated_two_folds=True)
group = groups.result_groups[0]
# suppress stdout output for now
from StringIO import StringIO
SS = StringIO()
import sys
sys.stdout = SS
group['best_subsym'].space_group_info().show_summary()
sys.stdout = sys.__stdout__
print " Unit cell:", group[
'best_subsym'].unit_cell()
uc_params_conv = group['best_subsym'].unit_cell().parameters()
sorted_pg_comp = sorted(cluster.pg_composition.items(),
key=lambda x: -1 * x[1])
pg_strings = [
"{} in {}".format(pg[1], pg[0]) for pg in sorted_pg_comp
]
point_group_string = ", ".join(pg_strings) + "."
out_str += point_group_string
out_str += ("\n{:<16} {:<8} {:<6.2f}({:<5.2f}) {:<6.2f}({:<5.2f})"
" {:<6.2f}({:<5.2f}) {:<6.2f}({:<4.2f}) {:<6.2f}"
"({:<4.2f}) {:<6.2f}({:<4.2f})").format(
cluster.cname, len(cluster.members),
cluster.medians[0], cluster.stdevs[0],
cluster.medians[1], cluster.stdevs[1],
cluster.medians[2], cluster.stdevs[2],
cluster.medians[3], cluster.stdevs[3],
cluster.medians[4], cluster.stdevs[4],
cluster.medians[5], cluster.stdevs[5])
out_str += ("\n{:>24} {:<6.2f}{:<7} {:<6.2f}{:<7}"
" {:<6.2f}{:<7} {:<6.2f}{:<6} {:<6.2f}"
"{:<6} {:<6.2f}{:<6} {:<6.2}").format(
SS.getvalue().strip()[13:], uc_params_conv[0], "",
uc_params_conv[1], "", uc_params_conv[2], "",
uc_params_conv[3], "", uc_params_conv[4], "",
uc_params_conv[5], "",
group["max_angular_difference"]) + "\n\n"
else:
singletons.append("".join([
("{:<14} {:<11.2f} {:<11.2f} {:<11.2f}"
"{:<12.1f} {:<12.1f} {:<12.1f}").format(
cluster.pg_composition.keys()[0],
cluster.members[0].uc[0], cluster.members[0].uc[1],
cluster.members[0].uc[2], cluster.members[0].uc[3],
cluster.members[0].uc[4], cluster.members[0].uc[5]), '\n'
]))
out_str += "\nStandard deviations are in brackets."
explanation = """\nEach cluster:
Input lattice count, with integration Bravais setting space group.
Cluster median with Niggli cell parameters (std dev in brackets).
Highest possible metric symmetry and unit cell using LePage (J Appl Cryst 1982, 15:255) method, maximum delta 3deg."""
out_str += explanation
singleton_str = "\n%i singleton%s:" % plural_s(len(singletons))
singleton_str += "\n\n{:<14} {:<11} {:<11} {:<11}{:<12} {:<12} {:<12}\n".format(
"Point group", "a", "b", "c", "alpha", "beta", "gamma")
singleton_str += "".join(singletons)
n_clusters = len(sub_clusters) - len(singletons)
out_str = "\n%i cluster%s:" % plural_s(n_clusters) + out_str
return singleton_str + out_str
def run(
args,
command_name="phenix.reflection_file_converter",
simply_return_all_miller_arrays=False):
command_line = (option_parser(
usage="%s [options] reflection_file ..." % command_name,
description="Example: %s w1.sca --mtz ." % command_name)
.enable_symmetry_comprehensive()
.option(None, "--weak_symmetry",
action="store_true",
default=False,
help="symmetry on command line is weaker than symmetry found in files")
.enable_resolutions()
.option(None, "--label",
action="store",
type="string",
help="Substring of reflection data label or number",
metavar="STRING")
.option(None, "--non_anomalous",
action="store_true",
default=False,
help="Averages Bijvoet mates to obtain a non-anomalous array")
.option(None, "--r_free_label",
action="store",
type="string",
help="Substring of reflection data label or number",
metavar="STRING")
.option(None, "--r_free_test_flag_value",
action="store",
type="int",
help="Value in R-free array indicating assignment to free set.",
metavar="FLOAT")
.option(None, "--generate_r_free_flags",
action="store_true",
default=False,
help="Generates a new array of random R-free flags"
" (MTZ and CNS output only).")
.option(None, "--use_lattice_symmetry_in_r_free_flag_generation",
dest="use_lattice_symmetry_in_r_free_flag_generation",
action="store_true",
default=True,
help="group twin/pseudo symmetry related reflections together"
" in r-free set (this is the default).")
.option(None, "--no_lattice_symmetry_in_r_free_flag_generation",
dest="use_lattice_symmetry_in_r_free_flag_generation",
action="store_false",
help="opposite of --use-lattice-symmetry-in-r-free-flag-generation")
.option(None, "--r_free_flags_fraction",
action="store",
default=0.10,
type="float",
help="Target fraction free/work reflections (default: 0.10).",
metavar="FLOAT")
.option(None, "--r_free_flags_max_free",
action="store",
default=2000,
type="int",
help="Maximum number of free reflections (default: 2000).",
metavar="INT")
.option(None, "--r_free_flags_format",
choices=("cns", "ccp4", "shelx"),
default="cns",
help="Convention for generating R-free flags",
metavar="cns|ccp4")
.option(None, "--output_r_free_label",
action="store",
type="string",
help="Label for newly generated R-free flags (defaults to R-free-flags)",
default="R-free-flags",
metavar="STRING")
.option(None, "--random_seed",
action="store",
type="int",
help="Seed for random number generator (affects generation of"
" R-free flags).",
metavar="INT")
.option(None, "--change_of_basis",
action="store",
type="string",
help="Change-of-basis operator: h,k,l or x,y,z"
" or to_reference_setting, to_primitive_setting, to_niggli_cell,"
" to_inverse_hand",
metavar="STRING")
.option(None, "--eliminate_invalid_indices",
action="store_true",
default=False,
help="Remove indices which are invalid given the change of basis desired")
.option(None, "--expand_to_p1",
action="store_true",
default=False,
help="Generates all symmetrically equivalent reflections."
" The space group symmetry is reset to P1."
" May be used in combination with --change_to_space_group to"
" lower the symmetry.")
.option(None, "--change_to_space_group",
action="store",
type="string",
help="Changes the space group and merges equivalent reflections"
" if necessary",
metavar="SYMBOL|NUMBER")
.option(None, "--write_mtz_amplitudes",
action="store_true",
default=False,
help="Converts intensities to amplitudes before writing MTZ format;"
" requires --mtz_root_label")
.option(None, "--write_mtz_intensities",
action="store_true",
default=False,
help="Converts amplitudes to intensities before writing MTZ format;"
" requires --mtz_root_label")
.option(None,"--remove_negatives",
action="store_true",
default=False,
help="Remove negative intensities or amplitudes from the data set" )
.option(None,"--massage_intensities",
action="store_true",
default=False,
help="'Treat' negative intensities to get a positive amplitude."
" |Fnew| = sqrt((Io+sqrt(Io**2 +2sigma**2))/2.0). Requires"
" intensities as input and the flags --mtz,"
" --write_mtz_amplitudes and --mtz_root_label.")
.option(None, "--scale_max",
action="store",
type="float",
help="Scales data such that the maximum is equal to the given value",
metavar="FLOAT")
.option(None, "--scale_factor",
action="store",
type="float",
help="Multiplies data with the given factor",
metavar="FLOAT")
.option(None, "--sca",
action="store",
type="string",
help=
"write data to Scalepack FILE ('--sca .' copies name of input file)",
metavar="FILE")
.option(None, "--mtz",
action="store",
type="string",
help="write data to MTZ FILE ('--mtz .' copies name of input file)",
metavar="FILE")
.option(None, "--mtz_root_label",
action="store",
type="string",
help="Root label for MTZ file (e.g. Fobs)",
metavar="STRING")
.option(None, "--cns",
action="store",
type="string",
help="write data to CNS FILE ('--cns .' copies name of input file)",
metavar="FILE")
.option(None, "--shelx",
action="store",
type="string",
help="write data to SHELX FILE ('--shelx .' copies name of input file)",
metavar="FILE")
).process(args=args)
co = command_line.options
if (co.random_seed is not None):
random.seed(co.random_seed)
flex.set_random_seed(value=co.random_seed)
if ( co.write_mtz_amplitudes
and co.write_mtz_intensities):
print
print "--write_mtz_amplitudes and --write_mtz_intensities" \
" are mutually exclusive."
print
return None
if ( co.write_mtz_amplitudes
or co.write_mtz_intensities):
if (co.mtz_root_label is None):
print
print "--write_mtz_amplitudes and --write_mtz_intensities" \
" require --mtz_root_label."
print
return None
if ( co.scale_max is not None
and co.scale_factor is not None):
print
print "--scale_max and --scale_factor are mutually exclusive."
print
return None
if (len(command_line.args) == 0):
command_line.parser.show_help()
return None
all_miller_arrays = reflection_file_reader.collect_arrays(
file_names=command_line.args,
crystal_symmetry=None,
force_symmetry=False,
merge_equivalents=False,
discard_arrays=False,
verbose=1)
if (simply_return_all_miller_arrays):
return all_miller_arrays
if (len(all_miller_arrays) == 0):
print
print "No reflection data found in input file%s." % (
plural_s(len(command_line.args))[1])
print
return None
label_table = reflection_file_utils.label_table(
miller_arrays=all_miller_arrays)
selected_array = label_table.select_array(
label=co.label, command_line_switch="--label")
if (selected_array is None): return None
r_free_flags = None
r_free_info = None
if (co.r_free_label is not None):
r_free_flags = label_table.match_data_label(
label=co.r_free_label,
command_line_switch="--r_free_label")
if (r_free_flags is None):
return None
r_free_info = str(r_free_flags.info())
if (not r_free_flags.is_bool_array()):
test_flag_value = reflection_file_utils.get_r_free_flags_scores(
miller_arrays=[r_free_flags],
test_flag_value=co.r_free_test_flag_value).test_flag_values[0]
if (test_flag_value is None):
if (co.r_free_test_flag_value is None):
raise Sorry(
"Cannot automatically determine r_free_test_flag_value."
" Please use --r_free_test_flag_value to specify a value.")
else:
raise Sorry("Invalid --r_free_test_flag_value.")
r_free_flags = r_free_flags.customized_copy(
data=(r_free_flags.data() == test_flag_value))
print "Selected data:"
print " ", selected_array.info()
print " Observation type:", selected_array.observation_type()
print
if (r_free_info is not None):
print "R-free flags:"
print " ", r_free_info
print
processed_array = selected_array.customized_copy(
crystal_symmetry=selected_array.join_symmetry(
other_symmetry=command_line.symmetry,
force=not co.weak_symmetry)).set_observation_type(
selected_array.observation_type())
if (r_free_flags is not None):
r_free_flags = r_free_flags.customized_copy(
crystal_symmetry=processed_array)
print "Input crystal symmetry:"
crystal.symmetry.show_summary(processed_array, prefix=" ")
print
if (processed_array.unit_cell() is None):
command_line.parser.show_help()
print "Unit cell parameters unknown. Please use --symmetry or --unit_cell."
print
return None
if (processed_array.space_group_info() is None):
command_line.parser.show_help()
print "Space group unknown. Please use --symmetry or --space_group."
print
return None
if (r_free_flags is not None):
r_free_flags = r_free_flags.customized_copy(
crystal_symmetry=processed_array)
if (co.change_of_basis is not None):
processed_array, cb_op = processed_array.apply_change_of_basis(
change_of_basis=co.change_of_basis,
eliminate_invalid_indices=co.eliminate_invalid_indices)
if (r_free_flags is not None):
r_free_flags = r_free_flags.change_basis(cb_op=cb_op)
if (not processed_array.is_unique_set_under_symmetry()):
print "Merging symmetry-equivalent values:"
merged = processed_array.merge_equivalents()
merged.show_summary(prefix=" ")
print
processed_array = merged.array()
del merged
processed_array.show_comprehensive_summary(prefix=" ")
print
if (r_free_flags is not None
and not r_free_flags.is_unique_set_under_symmetry()):
print "Merging symmetry-equivalent R-free flags:"
merged = r_free_flags.merge_equivalents()
merged.show_summary(prefix=" ")
print
r_free_flags = merged.array()
del merged
r_free_flags.show_comprehensive_summary(prefix=" ")
print
if (co.expand_to_p1):
print "Expanding symmetry and resetting space group to P1:"
if (r_free_flags is not None):
raise Sorry(
"--expand_to_p1 not supported for arrays of R-free flags.")
processed_array = processed_array.expand_to_p1()
processed_array.show_comprehensive_summary(prefix=" ")
print
if (co.change_to_space_group is not None):
if (r_free_flags is not None):
raise Sorry(
"--change_to_space_group not supported for arrays of R-free flags.")
new_space_group_info = sgtbx.space_group_info(
symbol=co.change_to_space_group)
print "Change to space group:", new_space_group_info
new_crystal_symmetry = crystal.symmetry(
unit_cell=processed_array.unit_cell(),
space_group_info=new_space_group_info,
assert_is_compatible_unit_cell=False)
if (not new_crystal_symmetry.unit_cell()
.is_similar_to(processed_array.unit_cell())):
print " *************"
print " W A R N I N G"
print " *************"
print " Unit cell parameters adapted to new space group symmetry are"
print " significantly different from input unit cell parameters:"
print " Input unit cell parameters:", \
processed_array.unit_cell()
print " Adapted unit cell parameters:", \
new_crystal_symmetry.unit_cell()
processed_array = processed_array.customized_copy(
crystal_symmetry=new_crystal_symmetry)
print
if (not processed_array.is_unique_set_under_symmetry()):
print " Merging values symmetry-equivalent under new symmetry:"
merged = processed_array.merge_equivalents()
merged.show_summary(prefix=" ")
print
processed_array = merged.array()
del merged
processed_array.show_comprehensive_summary(prefix=" ")
print
if (processed_array.anomalous_flag() and co.non_anomalous):
print "Converting data array from anomalous to non-anomalous."
if (not processed_array.is_xray_intensity_array()):
processed_array = processed_array.average_bijvoet_mates()
else:
processed_array = processed_array.f_sq_as_f()
processed_array = processed_array.average_bijvoet_mates()
processed_array = processed_array.f_as_f_sq()
processed_array.set_observation_type_xray_intensity()
if (r_free_flags is not None
and r_free_flags.anomalous_flag()
and co.non_anomalous):
print "Converting R-free flags from anomalous to non-anomalous."
r_free_flags = r_free_flags.average_bijvoet_mates()
d_max = co.low_resolution
d_min = co.resolution
if (d_max is not None or d_min is not None):
if (d_max is not None):
print "Applying low resolution cutoff: d_max=%.6g" % d_max
if (d_min is not None):
print "Applying high resolution cutoff: d_min=%.6g" % d_min
processed_array = processed_array.resolution_filter(
d_max=d_max, d_min=d_min)
print "Number of reflections:", processed_array.indices().size()
print
if (co.scale_max is not None):
print "Scaling data such that the maximum value is: %.6g" % co.scale_max
processed_array = processed_array.apply_scaling(target_max=co.scale_max)
print
if (co.scale_factor is not None):
print "Multiplying data with the factor: %.6g" % co.scale_factor
processed_array = processed_array.apply_scaling(factor=co.scale_factor)
print
if (([co.remove_negatives, co.massage_intensities]).count(True) == 2):
raise Sorry(
"It is not possible to use --remove_negatives and"
" --massage_intensities at the same time.")
if (co.remove_negatives):
if processed_array.is_real_array():
print "Removing negatives items"
processed_array = processed_array.select(
processed_array.data() > 0)
if processed_array.sigmas() is not None:
processed_array = processed_array.select(
processed_array.sigmas() > 0)
else:
raise Sorry("--remove_negatives not applicable to complex data arrays.")
if (co.massage_intensities):
if processed_array.is_real_array():
if processed_array.is_xray_intensity_array():
if (co.mtz is not None):
if (co.write_mtz_amplitudes):
print "The supplied intensities will be used to estimate"
print " amplitudes in the following way: "
print " Fobs = Sqrt[ (Iobs + Sqrt(Iobs**2 + 2sigmaIobs**2))/2 ]"
print " Sigmas are estimated in a similar manner."
print
processed_array = processed_array.enforce_positive_amplitudes()
else:
raise Sorry(
"--write_mtz_amplitudes has to be specified when using"
" --massage_intensities")
else:
raise Sorry("--mtz has to be used when using --massage_intensities")
else:
raise Sorry(
"Intensities must be supplied when using the option"
" --massage_intensities")
else:
raise Sorry(
"--massage_intensities not applicable to complex data arrays.")
if (not co.generate_r_free_flags):
if (r_free_flags is None):
r_free_info = []
else:
if (r_free_flags.anomalous_flag() != processed_array.anomalous_flag()):
if (processed_array.anomalous_flag()): is_not = ("", " not")
else: is_not = (" not", "")
raise Sorry(
"The data array is%s anomalous but the R-free array is%s.\n"
% is_not
+ " Please try --non_anomalous.")
r_free_info = ["R-free flags source: " + r_free_info]
if (not r_free_flags.indices().all_eq(processed_array.indices())):
processed_array = processed_array.map_to_asu()
r_free_flags = r_free_flags.map_to_asu().common_set(processed_array)
n_missing_r_free_flags = processed_array.indices().size() \
- r_free_flags.indices().size()
if (n_missing_r_free_flags != 0):
raise Sorry("R-free flags not compatible with data array:"
" missing flag for %d reflections selected for output." %
n_missing_r_free_flags)
else:
if (r_free_flags is not None):
raise Sorry(
"--r_free_label and --generate_r_free_flags are mutually exclusive.")
print "Generating a new array of R-free flags:"
r_free_flags = processed_array.generate_r_free_flags(
fraction=co.r_free_flags_fraction,
max_free=co.r_free_flags_max_free,
use_lattice_symmetry=co.use_lattice_symmetry_in_r_free_flag_generation,
format=co.r_free_flags_format)
test_flag_value = True
if (co.r_free_flags_format == "ccp4") :
test_flag_value = 0
elif (co.r_free_flags_format == "shelx") :
test_flag_value = -1
r_free_as_bool = r_free_flags.customized_copy(
data=r_free_flags.data()==test_flag_value)
r_free_info = [
"R-free flags generated by %s:" % command_name]
r_free_info.append(" "+date_and_time())
r_free_info.append(" fraction: %.6g" % co.r_free_flags_fraction)
r_free_info.append(" max_free: %s" % str(co.r_free_flags_max_free))
r_free_info.append(" size of work set: %d" %
r_free_as_bool.data().count(False))
r_free_info.append(" size of free set: %d" %
r_free_as_bool.data().count(True))
r_free_info_str = StringIO()
r_free_as_bool.show_r_free_flags_info(prefix=" ", out=r_free_info_str)
if (co.r_free_flags_format == "ccp4") :
r_free_info.append(" convention: CCP4 (test=0, work=1-%d)" %
flex.max(r_free_flags.data()))
elif (co.r_free_flags_format == "shelx") :
r_free_info.append(" convention: SHELXL (test=-1, work=1)")
else :
r_free_info.append(" convention: CNS/X-PLOR (test=1, work=0)")
print "\n".join(r_free_info[2:4])
print r_free_info[-1]
print r_free_info_str.getvalue()
print
n_output_files = 0
if (co.sca is not None):
if (co.generate_r_free_flags):
raise Sorry("Cannot write R-free flags to Scalepack file.")
file_name = reflection_file_utils.construct_output_file_name(
input_file_names=[selected_array.info().source],
user_file_name=co.sca,
file_type_label="Scalepack",
file_extension="sca")
print "Writing Scalepack file:", file_name
iotbx.scalepack.merge.write(
file_name=file_name,
miller_array=processed_array)
n_output_files += 1
print
if (co.mtz is not None):
file_name = reflection_file_utils.construct_output_file_name(
input_file_names=[selected_array.info().source],
user_file_name=co.mtz,
file_type_label="MTZ",
file_extension="mtz")
print "Writing MTZ file:", file_name
mtz_history_buffer = flex.std_string()
mtz_history_buffer.append(date_and_time())
mtz_history_buffer.append("> program: %s" % command_name)
mtz_history_buffer.append("> input file name: %s" %
os.path.basename(selected_array.info().source))
mtz_history_buffer.append("> input directory: %s" %
os.path.dirname(os.path.abspath(selected_array.info().source)))
mtz_history_buffer.append("> input labels: %s" %
selected_array.info().label_string())
mtz_output_array = processed_array
if (co.write_mtz_amplitudes):
if (not mtz_output_array.is_xray_amplitude_array()):
print " Converting intensities to amplitudes."
mtz_output_array = mtz_output_array.f_sq_as_f()
mtz_history_buffer.append("> Intensities converted to amplitudes.")
elif (co.write_mtz_intensities):
if (not mtz_output_array.is_xray_intensity_array()):
print " Converting amplitudes to intensities."
mtz_output_array = mtz_output_array.f_as_f_sq()
mtz_history_buffer.append("> Amplitudes converted to intensities.")
column_root_label = co.mtz_root_label
if (column_root_label is None):
# XXX 2013-03-29: preserve original root label by default
# XXX 2014-12-16: skip trailing "(+)" in root_label if anomalous
column_root_label = selected_array.info().labels[0]
column_root_label=remove_anomalous_suffix_if_necessary(
miller_array=selected_array,
column_root_label=column_root_label)
mtz_dataset = mtz_output_array.as_mtz_dataset(
column_root_label=column_root_label)
del mtz_output_array
if (r_free_flags is not None):
mtz_dataset.add_miller_array(
miller_array=r_free_flags,
column_root_label=co.output_r_free_label)
for line in r_free_info:
mtz_history_buffer.append("> " + line)
mtz_history_buffer.append("> output file name: %s" %
os.path.basename(file_name))
mtz_history_buffer.append("> output directory: %s" %
os.path.dirname(os.path.abspath(file_name)))
mtz_object = mtz_dataset.mtz_object()
mtz_object.add_history(mtz_history_buffer)
mtz_object.write(file_name=file_name)
n_output_files += 1
print
if (co.cns is not None):
file_name = reflection_file_utils.construct_output_file_name(
input_file_names=[selected_array.info().source],
user_file_name=co.cns,
file_type_label="CNS",
file_extension="cns")
print "Writing CNS file:", file_name
processed_array.export_as_cns_hkl(
file_object=open(file_name, "w"),
file_name=file_name,
info=["source of data: "+str(selected_array.info())] + r_free_info,
r_free_flags=r_free_flags)
n_output_files += 1
print
if (co.shelx is not None):
if (co.generate_r_free_flags):
raise Sorry("Cannot write R-free flags to SHELX file.")
file_name = reflection_file_utils.construct_output_file_name(
input_file_names=[selected_array.info().source],
user_file_name=co.shelx,
file_type_label="SHELX",
file_extension="shelx")
print "Writing SHELX file:", file_name
processed_array.as_amplitude_array().export_as_shelx_hklf(
open(file_name, "w"))
n_output_files += 1
print
if (n_output_files == 0):
command_line.parser.show_help()
print "Please specify at least one output file format,",
print "e.g. --mtz, --sca, etc."
print
return None
return processed_array
def run(args, command_name=libtbx.env.dispatcher_name):
if (len(args) == 0): args = ["--help"]
command_line = (option_parser(
usage='%s pdb_file "atom_selection" [...]' % command_name)
.option(None, "--write_pdb_file",
action="store",
type="string",
default=None,
help="write selected atoms to new PDB file",
metavar="FILE")
.option(None, "--cryst1_replacement_buffer_layer",
action="store",
type="float",
default=None,
help="replace CRYST1 with pseudo unit cell covering the selected"
" atoms plus a surrounding buffer layer",
metavar="WIDTH")
).process(args=args, min_nargs=2)
co = command_line.options
mon_lib_srv = server.server()
ener_lib = server.ener_lib()
processed_pdb_file = pdb_interpretation.process(
mon_lib_srv=mon_lib_srv,
ener_lib=ener_lib,
file_name=command_line.args[0],
log=sys.stdout)
print
acp = processed_pdb_file.all_chain_proxies
hierarchy=acp.pdb_hierarchy
asc=hierarchy.atom_selection_cache()
sel=asc.selection(string = "chain 'A' and resid 1 through 8 and icode ' '")
h1=hierarchy.select(sel) # keep original hierarchy too
print h1.as_pdb_string()
selection_cache = acp.pdb_hierarchy.atom_selection_cache()
atoms = acp.pdb_atoms
all_bsel = flex.bool(atoms.size(), False)
for selection_string in command_line.args[1:]:
print selection_string
isel = acp.iselection(string=selection_string, cache=selection_cache)
all_bsel.set_selected(isel, True)
if (not co.write_pdb_file):
print " %d atom%s selected" % plural_s(isel.size())
for atom in atoms.select(isel):
print " %s" % atom.format_atom_record()
print
if (co.write_pdb_file):
print "Writing file:", show_string(co.write_pdb_file)
sel_hierarchy = acp.pdb_hierarchy.select(all_bsel)
if (co.cryst1_replacement_buffer_layer is None):
crystal_symmetry = acp.special_position_settings
else:
import cctbx.crystal
crystal_symmetry = cctbx.crystal.non_crystallographic_symmetry(
sites_cart=sel_hierarchy.atoms().extract_xyz(),
buffer_layer=co.cryst1_replacement_buffer_layer)
write_whole_pdb_file(
file_name=co.write_pdb_file,
processed_pdb_file=processed_pdb_file,
pdb_hierarchy=sel_hierarchy,
crystal_symmetry=crystal_symmetry)
print
def __init__(self,
mtz_object,
custom_cif_labels_dict=None,
log=None,
test_flag_value=None):
self.cif_blocks = {'xray': None, 'neutron': None}
if log is None: log = sys.stdout
miller_arrays = mtz_object.as_miller_arrays()
miller_arrays_as_cif_block = None
input_observations_xray = None
input_observations_neutron = None
r_free_xray = None
r_free_neutron = None
f_obs_filtered_xray = None
f_obs_filtered_neutron = None
mtz_to_cif_labels_dict = {}
mtz_to_cif_labels_dict.update(phenix_to_cif_labels_dict)
mtz_to_cif_labels_dict.update(ccp4_to_cif_labels_dict)
if custom_cif_labels_dict is not None:
mtz_to_cif_labels_dict.update(custom_cif_labels_dict)
unknown_mtz_labels = []
for array in miller_arrays:
labels = array.info().labels
label = labels[0]
if reflection_file_utils.looks_like_r_free_flags_info(
array.info()):
if "(+)" in label:
array = array.average_bijvoet_mates()
labels = [label.replace("(+)", "")]
if label.endswith(("neutron", "_N")):
r_free_neutron = array
else:
r_free_xray = array
continue # deal with these later
elif label.startswith("F-obs-filtered"):
if label.endswith(("neutron", "_N")):
f_obs_filtered_neutron = array
else:
f_obs_filtered_xray = array
elif label.startswith("F-obs") or label.startswith("I-obs"):
if label.strip("(+)").endswith(("neutron", "_N")):
input_observations_neutron = array
else:
input_observations_xray = array
#elif label.startswith("R-free-flags"):
column_names = []
for mtz_label in labels:
cif_label = mtz_to_cif_label(mtz_to_cif_labels_dict, mtz_label)
column_names.append(cif_label)
if column_names.count(None) > 0:
# I don't know what to do with this array
for i, mtz_label in enumerate(labels):
if column_names[i] is None:
unknown_mtz_labels.append(mtz_label)
continue
assert column_names.count(None) == 0
if labels[0].strip("(+)").endswith(("neutron", "_N")):
data_type = "neutron"
else:
data_type = "xray"
if column_names[0].startswith(
("_refln.F_meas", "_refln.F_squared_meas", "_refln.pdbx_F_",
"_refln.pdbx_I_")):
if data_type == "neutron":
input_observations_neutron = array
else:
input_observations_xray = array
if self.cif_blocks.get(data_type) is None:
self.cif_blocks[
data_type] = iotbx.cif.miller_arrays_as_cif_block(
array=array, column_names=column_names, format="mmcif")
else:
self.cif_blocks[data_type].add_miller_array(
array, column_names=column_names)
if len(unknown_mtz_labels):
print >> log, "Warning: Unknown mtz label%s: %s" % (plural_s(
len(unknown_mtz_labels))[1], ", ".join(unknown_mtz_labels))
print >> log, " Use mtz_labels and cif_labels keywords to provide translation for custom labels."
data_types = set(["xray"])
if self.cif_blocks['neutron'] is not None:
data_types.add("neutron")
if input_observations_xray is None and f_obs_filtered_xray is not None:
self.cif_blocks["xray"].add_miller_array(
array=f_obs_filtered_xray,
column_names=('_refln.F_meas_au', '_refln.F_meas_sigma_au'))
if input_observations_neutron is None and f_obs_filtered_neutron is not None:
self.cif_blocks["neutron"].add_miller_array(
array=f_obs_filtered_neutron,
column_names=('_refln.F_meas_au', '_refln.F_meas_sigma_au'))
for data_type in data_types:
if data_type == "xray":
r_free = r_free_xray
input_obs = input_observations_xray
f_obs_filtered = f_obs_filtered_xray
if (self.cif_blocks["xray"] is None and r_free_xray is not None
and self.cif_blocks["neutron"] is not None
and r_free_neutron is None):
r_free_neutron = r_free_xray
elif data_type == "neutron":
r_free = r_free_neutron
input_obs = input_observations_neutron
f_obs_filtered = f_obs_filtered_neutron
if self.cif_blocks[data_type] is not None and r_free is not None:
self.cif_blocks[data_type].add_miller_array(
array=r_free, column_name='_refln.pdbx_r_free_flag')
if input_obs is None or r_free is None: continue
if (test_flag_value is None):
test_flag_value = reflection_file_utils.guess_r_free_flag_value(
miller_array=r_free)
assert (test_flag_value is not None)
refln_status = r_free.array(
data=flex.std_string(r_free.size(), "."))
input_obs_non_anom = input_obs.average_bijvoet_mates()
match = r_free.match_indices(input_obs_non_anom)
refln_status.data().set_selected(match.pair_selection(0), "o")
refln_status.data().set_selected(r_free.data() == test_flag_value,
"f")
if f_obs_filtered is not None:
f_obs_filtered_non_anom = f_obs_filtered.average_bijvoet_mates(
)
match = r_free.match_indices(f_obs_filtered_non_anom)
refln_status.data().set_selected(match.single_selection(0),
"<") # XXX
self.cif_blocks[data_type].add_miller_array(
array=refln_status, column_name="_refln.status")
lines_out.append(line)
end_block_parameter_definition = True
else:
line_out = line
for p in parameter_names:
if (l.startswith("{===>}%s=" % p) and l.endswith(";")):
parameters_found[p] += 1
line_out = '{===>} %s=%s;' % (p, vars()[p])
if (line_out != line): parameters_changed.append(p)
break
lines_out.append(line_out)
if (parameters_found.values().count(1) != 7):
raise Sorry("Unexpected set of variable names in %s:\n counts: %s" %
(show_string(target), str(parameters_found)))
elif (len(parameters_changed) == 0):
print "Info: no changes, %s was not modified." % show_string(target)
else:
string_out = "\n".join(lines_out)
print "Info: %d change%s" % plural_s(len(parameters_changed)), \
"(%s)," % ", ".join(parameters_changed), \
"writing modified file %s." % show_string(target)
try:
print >> open(target, "w"), string_out
except IOError, e:
raise Sorry("Error writing file %s (%s)" %
(show_string(target), str(e)))
if (__name__ == "__main__"):
run(sys.argv[1:])
def __init__(self, mtz_object, custom_cif_labels_dict=None, log=None,
test_flag_value=None):
self.cif_blocks = {
'xray': None,
'neutron': None
}
if log is None: log = sys.stdout
miller_arrays = mtz_object.as_miller_arrays()
miller_arrays_as_cif_block = None
input_observations_xray = None
input_observations_neutron = None
r_free_xray = None
r_free_neutron = None
f_obs_filtered_xray = None
f_obs_filtered_neutron = None
mtz_to_cif_labels_dict = {}
mtz_to_cif_labels_dict.update(phenix_to_cif_labels_dict)
mtz_to_cif_labels_dict.update(ccp4_to_cif_labels_dict)
if custom_cif_labels_dict is not None:
mtz_to_cif_labels_dict.update(custom_cif_labels_dict)
unknown_mtz_labels = []
for array in miller_arrays:
labels = array.info().labels
label = labels[0]
if reflection_file_utils.looks_like_r_free_flags_info(array.info()):
if "(+)" in label:
array = array.average_bijvoet_mates()
labels = [label.replace("(+)", "")]
if label.endswith(("neutron", "_N")):
r_free_neutron = array
else:
r_free_xray = array
continue # deal with these later
elif label.startswith("F-obs-filtered"):
if label.endswith(("neutron", "_N")):
f_obs_filtered_neutron = array
else:
f_obs_filtered_xray = array
elif label.startswith("F-obs") or label.startswith("I-obs"):
if label.strip("(+)").endswith(("neutron", "_N")):
input_observations_neutron = array
else:
input_observations_xray = array
#elif label.startswith("R-free-flags"):
column_names = []
for mtz_label in labels:
cif_label = mtz_to_cif_label(mtz_to_cif_labels_dict, mtz_label)
column_names.append(cif_label)
if column_names.count(None) > 0:
# I don't know what to do with this array
for i, mtz_label in enumerate(labels):
if column_names[i] is None:
unknown_mtz_labels.append(mtz_label)
continue
assert column_names.count(None) == 0
if labels[0].strip("(+)").endswith(("neutron", "_N")):
data_type = "neutron"
else:
data_type = "xray"
if column_names[0].startswith(("_refln.F_meas",
"_refln.F_squared_meas",
"_refln.pdbx_F_",
"_refln.pdbx_I_")):
if data_type == "neutron":
input_observations_neutron = array
else:
input_observations_xray = array
if self.cif_blocks.get(data_type) is None:
self.cif_blocks[data_type] = iotbx.cif.miller_arrays_as_cif_block(
array=array, column_names=column_names, format="mmcif")
else:
self.cif_blocks[data_type].add_miller_array(array, column_names=column_names)
if len(unknown_mtz_labels):
print >> log, "Warning: Unknown mtz label%s: %s" %(
plural_s(len(unknown_mtz_labels))[1], ", ".join(unknown_mtz_labels))
print >> log, " Use mtz_labels and cif_labels keywords to provide translation for custom labels."
data_types = set(["xray"])
if self.cif_blocks['neutron'] is not None:
data_types.add("neutron")
if input_observations_xray is None and f_obs_filtered_xray is not None:
self.cif_blocks["xray"].add_miller_array(
array=f_obs_filtered_xray,
column_names=('_refln.F_meas_au','_refln.F_meas_sigma_au'))
if input_observations_neutron is None and f_obs_filtered_neutron is not None:
self.cif_blocks["neutron"].add_miller_array(
array=f_obs_filtered_neutron,
column_names=('_refln.F_meas_au','_refln.F_meas_sigma_au'))
for data_type in data_types:
if data_type == "xray":
r_free = r_free_xray
input_obs = input_observations_xray
f_obs_filtered = f_obs_filtered_xray
if (self.cif_blocks["xray"] is None and r_free_xray is not None and
self.cif_blocks["neutron"] is not None and r_free_neutron is None):
r_free_neutron = r_free_xray
elif data_type == "neutron":
r_free = r_free_neutron
input_obs = input_observations_neutron
f_obs_filtered = f_obs_filtered_neutron
if self.cif_blocks[data_type] is not None and r_free is not None:
self.cif_blocks[data_type].add_miller_array(
array=r_free, column_name='_refln.pdbx_r_free_flag')
if input_obs is None or r_free is None: continue
if (test_flag_value is None) :
test_flag_value = reflection_file_utils.guess_r_free_flag_value(
miller_array=r_free)
assert (test_flag_value is not None)
refln_status = r_free.array(data=flex.std_string(r_free.size(), "."))
input_obs_non_anom = input_obs.average_bijvoet_mates()
match = r_free.match_indices(input_obs_non_anom)
refln_status.data().set_selected(match.pair_selection(0), "o")
refln_status.data().set_selected(r_free.data() == test_flag_value, "f")
if f_obs_filtered is not None:
f_obs_filtered_non_anom = f_obs_filtered.average_bijvoet_mates()
match = r_free.match_indices(f_obs_filtered_non_anom)
refln_status.data().set_selected(match.single_selection(0), "<") # XXX
self.cif_blocks[data_type].add_miller_array(
array=refln_status, column_name="_refln.status")
def run(args):
if (len(args) != 2):
raise Usage("""\
iotbx.cns.transfer_crystal_symmetry any_symmetry_source_file cns_input_file
*********************************************
NOTE: the cns_input_file is changed in place.
*********************************************""")
#
for file_name in args:
if (not os.path.exists(file_name)):
raise Sorry("No such file: %s" % show_string(file_name))
source, target = args
crystal_symmetry = crystal_symmetry_from_any.extract_from(source)
if (crystal_symmetry is None):
raise Sorry("Unknown file format or unit cell and/or space group"
" missing from file: " + show_string(source))
cns_space_group_symbol = cns.space_group_symbols.cns_format(
space_group_info=crystal_symmetry.space_group_info())
if (cns_space_group_symbol is None):
raise Sorry("Space group not available in CNS: %s" %
show_string(str(crystal_symmetry.space_group_info())))
sg = '"%s"' % cns_space_group_symbol
a, b, c, alpha, beta, gamma = [
"%.6g" % p for p in crystal_symmetry.unit_cell().parameters()
]
parameter_names = ["sg", "a", "b", "c", "alpha", "beta", "gamma"]
parameters_found = dict(zip(parameter_names, [0] * len(parameter_names)))
parameters_changed = []
lines_out = []
detect_binary = detect_binary_file(monitor_initial=100)
try:
cns_inp = open(target).read().splitlines()
except IOError as e:
raise Sorry("Error reading file %s (%s)" %
(show_string(target), str(e)))
end_block_parameter_definition = False
for line in cns_inp:
if (detect_binary is not None):
is_binary = detect_binary.is_binary_file(block=line)
if (is_binary is not None):
if (is_binary):
raise Sorry("%s appears to be a binary file." %
show_string(target))
detect_binary = None
if (end_block_parameter_definition):
lines_out.append(line)
else:
l = line.strip().replace(" ", "")
if (l == "){-endblockparameterdefinition-}"):
lines_out.append(line)
end_block_parameter_definition = True
else:
line_out = line
for p in parameter_names:
if (l.startswith("{===>}%s=" % p) and l.endswith(";")):
parameters_found[p] += 1
line_out = '{===>} %s=%s;' % (p, vars()[p])
if (line_out != line): parameters_changed.append(p)
break
lines_out.append(line_out)
if (list(parameters_found.values()).count(1) != 7):
raise Sorry("Unexpected set of variable names in %s:\n counts: %s" %
(show_string(target), str(parameters_found)))
elif (len(parameters_changed) == 0):
print("Info: no changes, %s was not modified." % show_string(target))
else:
string_out = "\n".join(lines_out)
print("Info: %d change%s" % plural_s(len(parameters_changed)), \
"(%s)," % ", ".join(parameters_changed), \
"writing modified file %s." % show_string(target))
try:
print(string_out, file=open(target, "w"))
except IOError as e:
raise Sorry("Error writing file %s (%s)" %
(show_string(target), str(e)))
