def adp_volume_similarity_as_cif_loops(xray_structure, proxies):
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4e"
loop = model.loop(header=(
"_restr_U_volume_similar_atom_site_label_1",
"_restr_U_volume_similar_diff",
"_restr_U_volume_similar_class_id",
))
class_loop = model.loop(header=(
"_restr_U_volume_similar_class_class_id",
"_restr_U_volume_similar_class_target_weight_param",
"_restr_U_volume_similar_class_average",
"_restr_U_volume_similar_class_esd",
"_restr_U_volume_similar_class_diff_max",
))
unit_cell = xray_structure.unit_cell()
params = adp_restraints.adp_restraint_params(
u_cart=xray_structure.scatterers().extract_u_cart(unit_cell),
u_iso=xray_structure.scatterers().extract_u_iso(),
use_u_aniso=xray_structure.use_u_aniso())
class_id = 0
for proxy in proxies:
restraint = adp_restraints.adp_volume_similarity(params=params,
proxy=proxy)
class_id += 1
class_loop.add_row(
(class_id, fmt % math.sqrt(1 / proxy.weight),
fmt % restraint.mean_u_volume, fmt % restraint.rms_deltas(),
fmt % flex.max_absolute(restraint.deltas())))
for i, i_seq in enumerate(proxy.i_seqs):
loop.add_row(
(site_labels[i_seq], fmt % restraint.deltas()[i], class_id))
return class_loop, loop
def save_CIF(self, fpath):
"""Saving model into cif file"""
cif_object = model.cif()
cif_block = model.block()
cif_object["BEA"] = cif_block
space_group = sgtbx.space_group(self.iucr_structure.space_group())
#unit cell:
cell_pars = self.iucr_structure.unit_cell().parameters()
cif_block["_cell_length_a"] = cell_pars[0]
cif_block["_cell_length_b"] = cell_pars[1]
cif_block["_cell_length_c"] = cell_pars[2]
cif_block["_cell_angle_alpha"] = cell_pars[3]
cif_block["_cell_angle_beta"] = cell_pars[4]
cif_block["_cell_angle_gamma"] = cell_pars[5]
space_group_type = self.iucr_structure.space_group_info().type()
cif_block["_symmetry_cell_setting"] = \
space_group.crystal_system().lower()
cif_block["_symmetry_Int_Tables_number"] = space_group_type.number()
cif_block["_symmetry_space_group_name_H-M"] = \
space_group_type.lookup_symbol()
#cif_block["_space_group.name_Hall"] = space_group_type.hall_symbol()
symop_loop = model.loop(
header = ("_symmetry_equiv_pos_as_xyz",)
)
for symop_id, symop in enumerate(space_group):
symop_loop.add_row(("'{}'".format(symop.as_xyz()),))
struct_loop = model.loop(
header = ("_atom_site_label",
"_atom_site_type_symbol",
"_atom_site_fract_x",
"_atom_site_fract_y",
"_atom_site_fract_z",
"_atom_site_U_iso_or_equiv"))
for scatterer in self.iucr_structure.scatterers():
struct_loop.add_row(
(scatterer.label,
scatterer.scattering_type,
scatterer.site[0],
scatterer.site[1],
scatterer.site[2],
scatterer.u_iso))
cif_block.add_loop(symop_loop)
cif_block.add_loop(struct_loop)
with open(fpath,'w') as fobj:
fobj.write(cif_object.__str__())
def fixed_u_eq_adp_as_cif_loop(xray_structure, proxies):
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_U_Ueq_atom_site_label_1",
"_restr_U_Ueq_weight_param",
"_restr_U_Ueq_target",
"_restr_U_Ueq_diff"
))
unit_cell = xray_structure.unit_cell()
params = adp_restraints.adp_restraint_params(
u_cart=xray_structure.scatterers().extract_u_cart(unit_cell),
u_iso=xray_structure.scatterers().extract_u_iso(),
use_u_aniso=xray_structure.use_u_aniso()
)
for proxy in proxies:
restraint = adp_restraints.fixed_u_eq_adp(
params=params,
proxy=proxy)
for i, i_seq in enumerate(proxy.i_seqs):
loop.add_row((site_labels[i_seq],
fmt % math.sqrt(1/proxy.weight),
fmt % proxy.u_eq_ideal,
fmt % restraint.delta()))
return loop
def distances_as_cif_loop(xray_structure, proxies):
space_group_info = sgtbx.space_group_info(group=xray_structure.space_group())
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_distance_atom_site_label_1",
"_restr_distance_atom_site_label_2",
"_restr_distance_site_symmetry_2",
"_restr_distance_target",
"_restr_distance_target_weight_param",
"_restr_distance_diff"
))
for proxy in proxies:
restraint = geometry_restraints.bond(
unit_cell=unit_cell,
sites_cart=sites_cart,
proxy=proxy)
i_seqs = proxy.i_seqs
sym_op = proxy.rt_mx_ji
if sym_op is None: sym_op = sgtbx.rt_mx()
loop.add_row((site_labels[i_seqs[0]],
site_labels[i_seqs[1]],
space_group_info.cif_symmetry_code(sym_op),
fmt % restraint.distance_ideal,
fmt % math.sqrt(1/restraint.weight),
fmt % restraint.delta))
return loop
def __init__(self,
pair_asu_table,
site_labels,
sites_frac=None,
sites_cart=None,
covariance_matrix=None,
cell_covariance_matrix=None,
parameter_map=None,
include_bonds_to_hydrogen=False,
fixed_angles=None,
conformer_indices=None,
eps=2e-16):
assert [sites_frac, sites_cart].count(None) == 1
fmt = "%.1f"
asu_mappings = pair_asu_table.asu_mappings()
space_group_info = sgtbx.space_group_info(
group=asu_mappings.space_group())
unit_cell = asu_mappings.unit_cell()
if sites_cart is not None:
sites_frac = unit_cell.fractionalize(sites_cart)
self.loop = model.loop(header=("_geom_angle_atom_site_label_1",
"_geom_angle_atom_site_label_2",
"_geom_angle_atom_site_label_3",
"_geom_angle",
"_geom_angle_site_symmetry_1",
"_geom_angle_site_symmetry_3"))
angles = crystal.calculate_angles(
pair_asu_table,
sites_frac,
covariance_matrix=covariance_matrix,
cell_covariance_matrix=cell_covariance_matrix,
parameter_map=parameter_map,
conformer_indices=conformer_indices)
for a in angles:
i_seq, j_seq, k_seq = a.i_seqs
if (not include_bonds_to_hydrogen
and (site_labels[i_seq].startswith('H')
or site_labels[k_seq].startswith('H'))):
continue
sym_code_ji = space_group_info.cif_symmetry_code(a.rt_mx_ji)
sym_code_ki = space_group_info.cif_symmetry_code(a.rt_mx_ki)
if sym_code_ji == "1": sym_code_ji = "."
if sym_code_ki == "1": sym_code_ki = "."
if (a.variance is not None and a.variance > eps
and not (fixed_angles is not None and
((i_seq, j_seq, k_seq) in fixed_angles or
(k_seq, j_seq, i_seq) in fixed_angles))):
angle = format_float_with_su(a.angle, math.sqrt(a.variance))
else:
angle = fmt % a.angle
self.loop.add_row((
site_labels[i_seq],
site_labels[j_seq],
site_labels[k_seq],
angle,
sym_code_ji,
sym_code_ki,
))
self.angles = angles.angles
self.variances = angles.variances
def fixed_u_eq_adp_as_cif_loop(xray_structure, proxies):
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_U_Ueq_atom_site_label_1",
"_restr_U_Ueq_weight_param",
"_restr_U_Ueq_target",
"_restr_U_Ueq_diff"
))
unit_cell = xray_structure.unit_cell()
params = adp_restraints.adp_restraint_params(
u_cart=xray_structure.scatterers().extract_u_cart(unit_cell),
u_iso=xray_structure.scatterers().extract_u_iso(),
use_u_aniso=xray_structure.use_u_aniso()
)
for proxy in proxies:
restraint = adp_restraints.fixed_u_eq_adp(
params=params,
proxy=proxy)
for i, i_seq in enumerate(proxy.i_seqs):
loop.add_row((site_labels[i_seq],
fmt % math.sqrt(1/proxy.weight),
fmt % proxy.u_eq_ideal,
fmt % restraint.delta()))
return loop
def distances_as_cif_loop(xray_structure, proxies):
space_group_info = sgtbx.space_group_info(
group=xray_structure.space_group())
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=("_restr_distance_atom_site_label_1",
"_restr_distance_atom_site_label_2",
"_restr_distance_site_symmetry_2",
"_restr_distance_target",
"_restr_distance_target_weight_param",
"_restr_distance_diff"))
for proxy in proxies:
restraint = geometry_restraints.bond(unit_cell=unit_cell,
sites_cart=sites_cart,
proxy=proxy)
i_seqs = proxy.i_seqs
sym_op = proxy.rt_mx_ji
if sym_op is None: sym_op = sgtbx.rt_mx()
loop.add_row(
(site_labels[i_seqs[0]], site_labels[i_seqs[1]],
space_group_info.cif_symmetry_code(sym_op),
fmt % restraint.distance_ideal,
fmt % math.sqrt(1 / restraint.weight), fmt % restraint.delta))
return loop
def angles_as_cif_loop(xray_structure, proxies):
space_group_info = sgtbx.space_group_info(
group=xray_structure.space_group())
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_angle_atom_site_label_1",
"_restr_angle_atom_site_label_2",
"_restr_angle_atom_site_label_3",
"_restr_angle_site_symmetry_1",
"_restr_angle_site_symmetry_2",
"_restr_angle_site_symmetry_3",
"_restr_angle_target",
"_restr_angle_target_weight_param",
"_restr_angle_diff",
))
unit_mxs = [sgtbx.rt_mx()] * 3
for proxy in proxies:
restraint = geometry_restraints.angle(unit_cell=unit_cell,
sites_cart=sites_cart,
proxy=proxy)
sym_ops = proxy.sym_ops
if sym_ops is None: sym_ops = unit_mxs
i_seqs = proxy.i_seqs
loop.add_row(
(site_labels[i_seqs[0]], site_labels[i_seqs[1]],
site_labels[i_seqs[2]],
space_group_info.cif_symmetry_code(sym_ops[0]),
space_group_info.cif_symmetry_code(sym_ops[1]),
space_group_info.cif_symmetry_code(sym_ops[2]),
fmt % restraint.angle_ideal,
fmt % math.sqrt(1 / restraint.weight), fmt % restraint.delta))
return loop
def rigu_as_cif_loop(xray_structure, proxies):
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
u_cart = xray_structure.scatterers().extract_u_cart(unit_cell)
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.6f"
loop = model.loop(header=(
"_restr_RIGU_atom_site_label_1",
"_restr_RIGU_atom_site_label_2",
"_restr_RIGU_target_weight_param",
"_restr_RIGU_U13_diff",
"_restr_RIGU_U23_diff",
"_restr_RIGU_U33_diff"
))
for proxy in proxies:
restraint = adp_restraints.rigu(
adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
proxy=proxy)
loop.add_row((site_labels[proxy.i_seqs[0]],
site_labels[proxy.i_seqs[1]],
fmt % math.sqrt(1/proxy.weight),
fmt % restraint.delta_13(),
fmt % restraint.delta_23(),
fmt % restraint.delta_33()
))
return loop
def __init__(self,
pair_asu_table,
site_labels,
sites_frac=None,
sites_cart=None,
covariance_matrix=None,
cell_covariance_matrix=None,
parameter_map=None,
include_bonds_to_hydrogen=False,
fixed_angles=None,
conformer_indices=None,
eps=2e-16):
assert [sites_frac, sites_cart].count(None) == 1
fmt = "%.1f"
asu_mappings = pair_asu_table.asu_mappings()
space_group_info = sgtbx.space_group_info(group=asu_mappings.space_group())
unit_cell = asu_mappings.unit_cell()
if sites_cart is not None:
sites_frac = unit_cell.fractionalize(sites_cart)
self.loop = model.loop(header=(
"_geom_angle_atom_site_label_1",
"_geom_angle_atom_site_label_2",
"_geom_angle_atom_site_label_3",
"_geom_angle",
"_geom_angle_site_symmetry_1",
"_geom_angle_site_symmetry_3"
))
angles = crystal.calculate_angles(
pair_asu_table, sites_frac,
covariance_matrix=covariance_matrix,
cell_covariance_matrix=cell_covariance_matrix,
parameter_map=parameter_map,
conformer_indices=conformer_indices)
for a in angles:
i_seq, j_seq, k_seq = a.i_seqs
if (not include_bonds_to_hydrogen
and (site_labels[i_seq].startswith('H') or
site_labels[k_seq].startswith('H'))):
continue
sym_code_ji = space_group_info.cif_symmetry_code(a.rt_mx_ji)
sym_code_ki = space_group_info.cif_symmetry_code(a.rt_mx_ki)
if sym_code_ji == "1": sym_code_ji = "."
if sym_code_ki == "1": sym_code_ki = "."
if (a.variance is not None and a.variance > eps
and not(fixed_angles is not None and
((i_seq, j_seq, k_seq) in fixed_angles or
(k_seq, j_seq, i_seq) in fixed_angles))):
angle = format_float_with_su(a.angle, math.sqrt(a.variance))
else:
angle = fmt % a.angle
self.loop.add_row((site_labels[i_seq],
site_labels[j_seq],
site_labels[k_seq],
angle,
sym_code_ji,
sym_code_ki,
))
self.angles = angles.angles
self.variances = angles.variances
def bond_similarity_as_cif_loops(xray_structure, proxies):
space_group_info = sgtbx.space_group_info(
group=xray_structure.space_group())
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_equal_distance_atom_site_label_1",
"_restr_equal_distance_atom_site_label_2",
"_restr_equal_distance_site_symmetry_2",
"_restr_equal_distance_class_id",
))
class_loop = model.loop(header=(
"_restr_equal_distance_class_class_id",
"_restr_equal_distance_class_target_weight_param",
"_restr_equal_distance_class_average",
"_restr_equal_distance_class_esd",
"_restr_equal_distance_class_diff_max",
))
class_id = 0
for proxy in proxies:
restraint = geometry_restraints.bond_similarity(unit_cell=unit_cell,
sites_cart=sites_cart,
proxy=proxy)
class_id += 1
esd = math.sqrt(
flex.sum(flex.pow2(restraint.deltas())) *
(1. / proxy.i_seqs.size()))
class_loop.add_row((
class_id,
fmt % math.sqrt(1 / proxy.weights[0]), # assume equal weights
fmt % restraint.mean_distance(),
fmt % esd,
fmt % flex.max_absolute(restraint.deltas())))
for i in range(proxy.i_seqs.size()):
i_seq, j_seq = proxy.i_seqs[i]
if proxy.sym_ops is None:
sym_op = sgtbx.rt_mx()
else:
sym_op = proxy.sym_ops[i]
loop.add_row(
(site_labels[i_seq], site_labels[j_seq],
space_group_info.cif_symmetry_code(sym_op), class_id))
return class_loop, loop
def bond_similarity_as_cif_loops(xray_structure, proxies):
space_group_info = sgtbx.space_group_info(group=xray_structure.space_group())
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_equal_distance_atom_site_label_1",
"_restr_equal_distance_atom_site_label_2",
"_restr_equal_distance_site_symmetry_2",
"_restr_equal_distance_class_id",
))
class_loop = model.loop(header=(
"_restr_equal_distance_class_class_id",
"_restr_equal_distance_class_target_weight_param",
"_restr_equal_distance_class_average",
"_restr_equal_distance_class_esd",
"_restr_equal_distance_class_diff_max",
))
class_id = 0
for proxy in proxies:
restraint = geometry_restraints.bond_similarity(
unit_cell=unit_cell,
sites_cart=sites_cart,
proxy=proxy)
class_id += 1
esd = math.sqrt(flex.sum(flex.pow2(restraint.deltas())) *
(1./proxy.i_seqs.size()))
class_loop.add_row((class_id,
fmt % math.sqrt(1/proxy.weights[0]),# assume equal weights
fmt % restraint.mean_distance(),
fmt % esd,
fmt % flex.max_absolute(restraint.deltas())))
for i in range(proxy.i_seqs.size()):
i_seq, j_seq = proxy.i_seqs[i]
if proxy.sym_ops is None:
sym_op = sgtbx.rt_mx()
else:
sym_op = proxy.sym_ops[i]
loop.add_row((site_labels[i_seq],
site_labels[j_seq],
space_group_info.cif_symmetry_code(sym_op),
class_id))
return class_loop, loop
def isotropic_adp_as_cif_loop(xray_structure, proxies):
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_U_iso_atom_site_label",
"_restr_U_iso_weight_param",
))
for proxy in proxies:
loop.add_row((site_labels[proxy.i_seqs[0]], fmt % math.sqrt(1/proxy.weight)))
return loop
def isotropic_adp_as_cif_loop(xray_structure, proxies):
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_U_iso_atom_site_label",
"_restr_U_iso_weight_param",
))
for proxy in proxies:
loop.add_row((site_labels[proxy.i_seqs[0]], fmt % math.sqrt(1/proxy.weight)))
return loop
def add_loop(self, header, columns):
if self._current_save is not None:
block = self._current_save
else:
block = self._current_block
loop = model.loop()
assert len(header) == len(columns)
n_columns = len(columns)
for i in range(n_columns):
loop[header[i]] = columns[i]
block.add_loop(loop)
def add_loop(self, header, columns):
if self._current_save is not None:
block = self._current_save
else:
block = self._current_block
loop = model.loop()
assert len(header) == len(columns)
n_columns = len(columns)
for i in range(n_columns):
loop[header[i]] = columns[i]
block.add_loop(loop)
def __init__(self,
pair_asu_table,
site_labels,
sites_frac=None,
sites_cart=None,
covariance_matrix=None,
cell_covariance_matrix=None,
parameter_map=None,
include_bonds_to_hydrogen=False,
fixed_distances=None,
eps=2e-16):
assert [sites_frac, sites_cart].count(None) == 1
fmt = "%.4f"
asu_mappings = pair_asu_table.asu_mappings()
space_group_info = sgtbx.space_group_info(group=asu_mappings.space_group())
unit_cell = asu_mappings.unit_cell()
if sites_cart is not None:
sites_frac = unit_cell.fractionalize(sites_cart)
self.loop = model.loop(header=(
"_geom_bond_atom_site_label_1",
"_geom_bond_atom_site_label_2",
"_geom_bond_distance",
"_geom_bond_site_symmetry_2"
))
distances = crystal.calculate_distances(
pair_asu_table, sites_frac,
covariance_matrix=covariance_matrix,
cell_covariance_matrix=cell_covariance_matrix,
parameter_map=parameter_map)
for d in distances:
if (not include_bonds_to_hydrogen
and (site_labels[d.i_seq].startswith('H') or
site_labels[d.j_seq].startswith('H'))):
continue
if (d.variance is not None and d.variance > eps
and not(fixed_distances is not None and
((d.i_seq, d.j_seq) in fixed_distances or
(d.j_seq, d.i_seq) in fixed_distances))):
distance = format_float_with_su(d.distance, math.sqrt(d.variance))
else:
distance = fmt % d.distance
sym_code = space_group_info.cif_symmetry_code(d.rt_mx_ji)
if sym_code == "1": sym_code = "."
self.loop.add_row((site_labels[d.i_seq],
site_labels[d.j_seq],
distance,
sym_code))
self.distances = distances.distances
self.variances = distances.variances
self.pair_counts = distances.pair_counts
def __init__(self,
pair_asu_table,
site_labels,
sites_frac=None,
sites_cart=None,
covariance_matrix=None,
cell_covariance_matrix=None,
parameter_map=None,
include_bonds_to_hydrogen=False,
fixed_distances=None,
eps=2e-16):
assert [sites_frac, sites_cart].count(None) == 1
fmt = "%.4f"
asu_mappings = pair_asu_table.asu_mappings()
space_group_info = sgtbx.space_group_info(group=asu_mappings.space_group())
unit_cell = asu_mappings.unit_cell()
if sites_cart is not None:
sites_frac = unit_cell.fractionalize(sites_cart)
self.loop = model.loop(header=(
"_geom_bond_atom_site_label_1",
"_geom_bond_atom_site_label_2",
"_geom_bond_distance",
"_geom_bond_site_symmetry_2"
))
distances = crystal.calculate_distances(
pair_asu_table, sites_frac,
covariance_matrix=covariance_matrix,
cell_covariance_matrix=cell_covariance_matrix,
parameter_map=parameter_map)
for d in distances:
if (not include_bonds_to_hydrogen
and (site_labels[d.i_seq].startswith('H') or
site_labels[d.j_seq].startswith('H'))):
continue
if (d.variance is not None and d.variance > eps
and not(fixed_distances is not None and
((d.i_seq, d.j_seq) in fixed_distances or
(d.j_seq, d.i_seq) in fixed_distances))):
distance = format_float_with_su(d.distance, math.sqrt(d.variance))
else:
distance = fmt % d.distance
sym_code = space_group_info.cif_symmetry_code(d.rt_mx_ji)
if sym_code == "1": sym_code = "."
self.loop.add_row((site_labels[d.i_seq],
site_labels[d.j_seq],
distance,
sym_code))
self.distances = distances.distances
self.variances = distances.variances
self.pair_counts = distances.pair_counts
def adp_volume_similarity_as_cif_loops(xray_structure, proxies):
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4e"
loop = model.loop(header=(
"_restr_U_volume_similar_atom_site_label_1",
"_restr_U_volume_similar_diff",
"_restr_U_volume_similar_class_id",
))
class_loop = model.loop(header=(
"_restr_U_volume_similar_class_class_id",
"_restr_U_volume_similar_class_target_weight_param",
"_restr_U_volume_similar_class_average",
"_restr_U_volume_similar_class_esd",
"_restr_U_volume_similar_class_diff_max",
))
unit_cell = xray_structure.unit_cell()
params = adp_restraints.adp_restraint_params(
u_cart=xray_structure.scatterers().extract_u_cart(unit_cell),
u_iso=xray_structure.scatterers().extract_u_iso(),
use_u_aniso=xray_structure.use_u_aniso()
)
class_id = 0
for proxy in proxies:
restraint = adp_restraints.adp_volume_similarity(
params=params,
proxy=proxy)
class_id += 1
class_loop.add_row((class_id,
fmt % math.sqrt(1/proxy.weight),
fmt % restraint.mean_u_volume,
fmt % restraint.rms_deltas(),
fmt % flex.max_absolute(restraint.deltas())))
for i, i_seq in enumerate(proxy.i_seqs):
loop.add_row((site_labels[i_seq],
fmt % restraint.deltas()[i],
class_id))
return class_loop, loop
def __init__(self,
angles,
space_group_info,
site_labels,
include_bonds_to_hydrogen=False,
eps=2e-16):
fmt = "%.1f"
self.loop = model.loop(header=(
"_geom_torsion_atom_site_label_1",
"_geom_torsion_atom_site_label_2",
"_geom_torsion_atom_site_label_3",
"_geom_torsion_atom_site_label_4",
"_geom_torsion",
"_geom_torsion_site_symmetry_1",
"_geom_torsion_site_symmetry_2",
"_geom_torsion_site_symmetry_3",
"_geom_torsion_site_symmetry_4"
))
for a in angles:
i_seq, j_seq, k_seq, l_seq = a.i_seqs
if (not include_bonds_to_hydrogen
and (site_labels[i_seq].startswith('H') or
site_labels[j_seq].startswith('H') or
site_labels[k_seq].startswith('H') or
site_labels[l_seq].startswith('H'))):
continue
sym_code_i = space_group_info.cif_symmetry_code(a.rt_mxs[0])
sym_code_j = space_group_info.cif_symmetry_code(a.rt_mxs[1])
sym_code_k = space_group_info.cif_symmetry_code(a.rt_mxs[2])
sym_code_l = space_group_info.cif_symmetry_code(a.rt_mxs[3])
if sym_code_i == "1": sym_code_i = "."
if sym_code_j == "1": sym_code_j = "."
if sym_code_k == "1": sym_code_k = "."
if sym_code_l == "1": sym_code_l = "."
if a.variance is not None and a.variance > eps:
angle = format_float_with_su(a.angle, math.sqrt(a.variance))
else:
angle = fmt % a.angle
self.loop.add_row((site_labels[i_seq],
site_labels[j_seq],
site_labels[k_seq],
site_labels[l_seq],
angle,
sym_code_i,
sym_code_j,
sym_code_k,
sym_code_l,
))
def dihedrals_as_cif_loop(xray_structure, proxies):
space_group_info = sgtbx.space_group_info(group=xray_structure.space_group())
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_torsion_atom_site_label_1",
"_restr_torsion_atom_site_label_2",
"_restr_torsion_atom_site_label_3",
"_restr_torsion_atom_site_label_4",
"_restr_torsion_site_symmetry_1",
"_restr_torsion_site_symmetry_2",
"_restr_torsion_site_symmetry_3",
"_restr_torsion_site_symmetry_4",
"_restr_torsion_angle_target",
"_restr_torsion_weight_param",
"_restr_torsion_diff",
))
unit_mxs = [sgtbx.rt_mx()]*4
for proxy in proxies:
restraint = geometry_restraints.dihedral(
unit_cell=unit_cell,
sites_cart=sites_cart,
proxy=proxy)
sym_ops = proxy.sym_ops
if sym_ops is None: sym_ops = unit_mxs
i_seqs = proxy.i_seqs
loop.add_row((site_labels[i_seqs[0]],
site_labels[i_seqs[1]],
site_labels[i_seqs[2]],
site_labels[i_seqs[3]],
space_group_info.cif_symmetry_code(sym_ops[0]),
space_group_info.cif_symmetry_code(sym_ops[1]),
space_group_info.cif_symmetry_code(sym_ops[2]),
space_group_info.cif_symmetry_code(sym_ops[3]),
fmt % restraint.angle_ideal,
fmt % math.sqrt(1/restraint.weight),
fmt % restraint.delta))
return loop
def rigid_bond_as_cif_loop(xray_structure, proxies):
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
u_cart = xray_structure.scatterers().extract_u_cart(unit_cell)
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_U_rigid_atom_site_label_1",
"_restr_U_rigid_atom_site_label_2",
"_restr_U_rigid_target_weight_param",
"_restr_U_rigid_U_parallel",
"_restr_U_rigid_diff",
))
for proxy in proxies:
restraint = adp_restraints.rigid_bond(
adp_restraint_params(sites_cart=sites_cart, u_cart=u_cart),
proxy=proxy)
loop.add_row((site_labels[proxy.i_seqs[0]],
site_labels[proxy.i_seqs[1]],
fmt % math.sqrt(1/proxy.weight),
fmt % (0.5*(restraint.z_12()+restraint.z_21())),
fmt % restraint.delta_z()))
return loop
def rigid_bond_as_cif_loop(xray_structure, proxies):
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
u_cart = xray_structure.scatterers().extract_u_cart(unit_cell)
site_labels = xray_structure.scatterers().extract_labels()
fmt = "%.4f"
loop = model.loop(header=(
"_restr_U_rigid_atom_site_label_1",
"_restr_U_rigid_atom_site_label_2",
"_restr_U_rigid_target_weight_param",
"_restr_U_rigid_U_parallel",
"_restr_U_rigid_diff",
))
for proxy in proxies:
restraint = adp_restraints.rigid_bond(adp_restraint_params(
sites_cart=sites_cart, u_cart=u_cart),
proxy=proxy)
loop.add_row(
(site_labels[proxy.i_seqs[0]], site_labels[proxy.i_seqs[1]],
fmt % math.sqrt(1 / proxy.weight),
fmt % (0.5 * (restraint.z_12() + restraint.z_21())),
fmt % restraint.delta_z()))
return loop
def exercise_cif_model():
import iotbx.cif
from iotbx.cif import model
loop = model.loop()
loop["_loop_a"] = flex.double((1, 2, 3))
loop.add_columns({'_loop_c': [4, 5, 6], '_loop_b': ['7', '8', '9']})
loop.add_row((4, 7, '0'))
try:
loop["_loop_invalid"] = (7, 8)
except AssertionError:
pass
else:
raise Exception_expected
assert len(loop) == 3 # the number of columns (keys)
assert loop.size() == 4 # the number of rows (loop iterations)
assert loop.keys() == ['_loop_a', '_loop_c', '_loop_b']
try:
loop["no_leading_underscore"] = 3
except Sorry:
pass
else:
raise Exception_expected
loop2 = model.loop(header=("_loop2_a", "_loop2_b"),
data=(1, 2, 3, 4, 5, 6))
assert loop2.keys() == ["_loop2_a", "_loop2_b"]
assert loop2.values() == [
flex.std_string(['1', '3', '5']),
flex.std_string(['2', '4', '6'])
]
assert list(loop2.iterrows()) == [{
'_loop2_a': '1',
'_loop2_b': '2'
}, {
'_loop2_a': '3',
'_loop2_b': '4'
}, {
'_loop2_a': '5',
'_loop2_b': '6'
}]
#
block = model.block()
block["_tag"] = 3
block["_tag1"] = "'a string'"
block["_another_tag"] = 3.142
assert "_tag" in block
assert "_tag1" in block
assert "_another_tag" in block
assert block["_tag"] == '3'
assert block["_tag1"] == "'a string'"
assert block["_another_tag"] == "3.142"
assert block.keys() == ['_tag', '_tag1', '_another_tag']
assert block.values() == ["3", "'a string'", "3.142"]
try:
block["no_leading_underscore"] = 3
except Sorry:
pass
else:
raise Exception_expected
block.add_loop(loop)
assert len(block) == 6
assert block.items() == [('_tag', '3'), ('_tag1', "'a string'"),
('_another_tag', '3.142'),
('_loop_a', flex.std_string(['1', '2', '3',
'4'])),
('_loop_c', flex.std_string(['4', '5', '6',
'7'])),
('_loop_b', flex.std_string(['7', '8', '9',
'0']))]
block['_loop_c'] = [11, 12, 13, 14]
assert '_loop_c' in block.loops['_loop'].keys()
assert list(block['_loop_c']) == ['11', '12', '13', '14']
#
block1 = model.block()
block1["_tag"] = 2
block1["_tag2"] = 1.2
loop3 = model.loop(header=("_loop_a", "_loop_b"), data=(6, 5, 4, 3, 2, 1))
block1.add_loop(loop2)
block1.add_loop(loop3)
block.update(block1)
assert block._items.keys() == ['_another_tag', '_tag2', '_tag', '_tag1']
assert block._items.values() == ['3.142', '1.2', '2', "'a string'"]
assert block.loops.keys() == ['_loop', '_loop2']
assert block.keys() == [
'_tag', '_tag1', '_another_tag', '_loop_a', '_loop_b', '_tag2',
'_loop2_a', '_loop2_b'
]
assert list(block['_loop_a']) == ['6', '4', '2']
assert list(block['_loop_b']) == ['5', '3', '1']
assert list(block['_loop2_a']) == ['1', '3', '5']
assert list(block['_loop2_b']) == ['2', '4', '6']
try:
block['_loop_c']
except KeyError:
pass
else:
raise Exception_expected
bad_loop = model.loop(header=("_a", "_b"), data=(1, 2, 3, 4, 5, 6))
block1.add_loop(bad_loop)
assert "_a" in block1
assert "_b" in block1
assert list(block.get_looped_item("_loop_a")) == ['6', '4', '2']
try:
block.get_looped_item("_tag", value_error=ValueError)
except ValueError:
pass
else:
raise Exception_expected
assert list(block.get_looped_item("_tag", value_error=None)) == ['2']
try:
block.get_looped_item("_none_existent")
except KeyError:
pass
else:
raise Exception_expected
assert block.get_looped_item("_none_existent",
key_error=None,
default="my_default") == "my_default"
assert block.get_single_item("_tag") == "2"
try:
block.get_single_item("_loop_a")
except ValueError:
pass
else:
raise Exception_expected
assert block.get_single_item("_loop_a",
value_error=None,
default="default") == "default"
try:
block.get_single_item("_none_existent")
except KeyError:
pass
else:
raise Exception_expected
assert block.get_single_item("_none_existent", key_error=None) is None
#
cif_model = model.cif()
cif_model["fred"] = block
assert "fred" in cif_model
assert cif_model["frEd"] is block
assert cif_model["fred"]["_Tag"] == '2'
cif_model["fred"]["_tag"] = 4
assert cif_model["fred"]["_tag"] == '4'
del cif_model["fred"]["_tAg"]
try:
cif_model["fred"]["_tag"]
except KeyError:
pass
else:
raise Exception_expected
cm = cif_model.deepcopy()
l = cm["fred"]["_loop"]
del cm["Fred"]["_loop_B"]
assert not cm["fred"].has_key("_loop_b")
assert not l.has_key("_loop_b")
assert cm["fred"].loops.has_key("_loop")
del cm["fred"]["_loop_a"]
assert not cm["fred"].loops.has_key("_loop")
del cm["fred"]["_loop2"]
assert not cm["fred"].loops.has_key("_loop2")
s = StringIO()
print >> s, cm
assert not show_diff(
s.getvalue(), """\
data_fred
_tag1 'a string'
_another_tag 3.142
_tag2 1.2
""")
#
cm2 = cif_model.copy()
cm3 = cif_model.deepcopy()
assert cm2['fred']['_loop_a'] is cif_model['fred']['_loop_a']
assert cm3['fred']['_loop_a'] is not cif_model['fred']['_loop_a']
b2 = copy.copy(block)
b3 = copy.deepcopy(block)
assert b2['_loop_b'] is block['_loop_b']
assert b3['_loop_b'] is not block['_loop_b']
l2 = loop.copy()
l3 = loop.deepcopy()
assert l2['_loop_b'] is loop['_loop_b']
assert l3['_loop_b'] is not loop['_loop_b']
#
s = StringIO()
cif_model.show(out=s)
assert not show_diff(
s.getvalue(), """\
data_fred
_tag1 'a string'
_another_tag 3.142
loop_
_loop_a
_loop_b
6 5
4 3
2 1
_tag2 1.2
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
s = StringIO()
cif_model.show(out=s, indent=" ", data_name_field_width=0)
assert not show_diff(
s.getvalue(), """\
data_fred
_tag1 'a string'
_another_tag 3.142
loop_
_loop_a
_loop_b
6 5
4 3
2 1
_tag2 1.2
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
s = StringIO()
cif_model.show(out=s, indent="", indent_row=" ", data_name_field_width=0)
assert not show_diff(
s.getvalue(), """\
data_fred
_tag1 'a string'
_another_tag 3.142
loop_
_loop_a
_loop_b
6 5
4 3
2 1
_tag2 1.2
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
cif_model.sort(recursive=True)
s = StringIO()
cif_model.show(out=s)
assert not show_diff(
s.getvalue(), """\
data_fred
_another_tag 3.142
_tag1 'a string'
_tag2 1.2
loop_
_loop_a
_loop_b
6 5
4 3
2 1
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
save = model.save()
save.add_loop(l3)
save['_tag1'] = 3
block = model.block()
block['bob'] = save
cm = model.cif({'fred': block})
s = StringIO()
cm.show(out=s)
assert not show_diff(
s.getvalue(), """data_fred
save_bob
loop_
_loop_a
_loop_c
_loop_b
1 11 7
2 12 8
3 13 9
4 14 0
_tag1 3
save_
""")
b1 = model.block()
b1['_a'] = 1
b1['_b'] = 2
b1['_c'] = 3
b2 = model.block()
b2['_a'] = 2
b2['_c'] = 3
b2['_d'] = 4
b3 = b1.difference(b2)
b4 = b2.difference(b1)
assert b3.items() == [('_b', '2'), ('_a', '2')]
assert b4.items() == [('_d', '4'), ('_a', '1')]
l = model.loop(data=dict(_loop_d=(1, 2), _loop_e=(3, 4), _loop_f=(5, 6)))
assert l == l
assert l == l.deepcopy()
assert l != l2
assert l != l3
l2 = model.loop(
data=dict(_loop_d=(1, 2, 3), _loop_e=(3, 4, 5), _loop_f=(5, 6, 7)))
b1.add_loop(l)
b2.add_loop(l2)
b5 = b1.difference(b2)
assert b5['_loop'] == l2
l = model.loop(data=OrderedDict((('_loop_a', (1, 21, -13)),
('_loop_b', (-221.3, 3.01, 4.246)),
('_loop_c', ("a", "b", "cc")))))
b = model.block()
b.add_loop(l)
cm = model.cif({'fred': b})
s = StringIO()
cm.show(out=s, loop_format_strings={'_loop': '% 4i% 8.2f %s'})
assert not show_diff(
s.getvalue(), """\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.30 a
21 3.01 b
-13 4.25 cc
""")
s = StringIO()
cm.show(out=s)
assert not show_diff(
s.getvalue(), """\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.3 a
21 3.01 b
-13 4.246 cc
""")
l.add_row((".", "?", "."))
s = StringIO()
cm.show(out=s)
assert not show_diff(
s.getvalue(), """\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.3 a
21 3.01 b
-13 4.246 cc
. ? .
""")
l.delete_row(index=1)
s = StringIO()
cm.show(out=s)
assert not show_diff(
s.getvalue(), """\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.3 a
-13 4.246 cc
. ? .
""")
l2 = l.deepcopy()
l2.delete_row(index=0)
l2.delete_row(index=0)
l2.delete_row(index=0)
try:
l2.show(out=s)
except AssertionError, e:
pass
try:
l2.show(out=s)
except AssertionError, e:
pass
else:
raise Exception_expected
l.clear()
try:
l.show(out=s)
except AssertionError, e:
pass
else:
raise Exception_expected
#
loop = model.loop(data={
"_a_1": ('string with spaces', 'nospaces'),
"_a_2": ('a', 'b')
})
s = StringIO()
loop.show(out=s, align_columns=True)
assert not show_diff(
s.getvalue(), """\
loop_
_a_1
_a_2
'string with spaces' a
nospaces b
""")
#
cb = model.block()
cm = model.cif()
cm["a"] = cb
def __init__(self, crystal_symmetry, cell_covariance_matrix=None, format="coreCIF", numeric_format="%.3f"):
self.format = format.lower()
assert self.format in ("corecif", "mmcif")
if self.format == "mmcif":
self.separator = "."
else:
self.separator = "_"
assert numeric_format.startswith("%")
self.cif_block = model.block()
cell_prefix = "_cell%s" % self.separator
if crystal_symmetry.space_group() is not None:
sym_loop = model.loop(
data=OrderedDict(
(
(
"_space_group_symop" + self.separator + "id",
range(1, len(crystal_symmetry.space_group()) + 1),
),
(
"_space_group_symop" + self.separator + "operation_xyz",
[s.as_xyz() for s in crystal_symmetry.space_group()],
),
)
)
)
self.cif_block.add_loop(sym_loop)
sg_prefix = "_space_group%s" % self.separator
sg_type = crystal_symmetry.space_group_info().type()
sg = sg_type.group()
self.cif_block[sg_prefix + "crystal_system"] = sg.crystal_system().lower()
self.cif_block[sg_prefix + "IT_number"] = sg_type.number()
self.cif_block[sg_prefix + "name_H-M_alt"] = sg_type.lookup_symbol()
self.cif_block[sg_prefix + "name_Hall"] = sg_type.hall_symbol()
sg_prefix = "_symmetry%s" % self.separator
self.cif_block[sg_prefix + "space_group_name_H-M"] = sg_type.lookup_symbol()
self.cif_block[sg_prefix + "space_group_name_Hall"] = sg_type.hall_symbol()
self.cif_block[sg_prefix + "Int_Tables_number"] = sg_type.number()
if crystal_symmetry.unit_cell() is not None:
uc = crystal_symmetry.unit_cell()
params = list(uc.parameters())
volume = uc.volume()
if cell_covariance_matrix is not None:
diag = cell_covariance_matrix.matrix_packed_u_diagonal()
for i in range(6):
if diag[i] > 0:
params[i] = format_float_with_su(params[i], math.sqrt(diag[i]))
d_v_d_params = matrix.row(uc.d_volume_d_params())
vcv = matrix.sqr(cell_covariance_matrix.matrix_packed_u_as_symmetric())
var_v = (d_v_d_params * vcv).dot(d_v_d_params)
volume = format_float_with_su(volume, math.sqrt(var_v))
numeric_format = "%s"
a, b, c, alpha, beta, gamma = params
self.cif_block[cell_prefix + "length_a"] = numeric_format % a
self.cif_block[cell_prefix + "length_b"] = numeric_format % b
self.cif_block[cell_prefix + "length_c"] = numeric_format % c
self.cif_block[cell_prefix + "angle_alpha"] = numeric_format % alpha
self.cif_block[cell_prefix + "angle_beta"] = numeric_format % beta
self.cif_block[cell_prefix + "angle_gamma"] = numeric_format % gamma
self.cif_block[cell_prefix + "volume"] = numeric_format % volume
def __init__(self,
hbonds,
pair_asu_table,
site_labels,
sites_frac=None,
sites_cart=None,
min_dha_angle=150, # degrees
max_da_distance=2.9, # angstrom
covariance_matrix=None,
cell_covariance_matrix=None,
parameter_map=None,
eps=2e-16,
fixed_distances=None,
fixed_angles=None):
assert [sites_frac, sites_cart].count(None) == 1
fmt_a = "%.1f"
pair_asu_table = pair_asu_table
asu_mappings = pair_asu_table.asu_mappings()
space_group_info = sgtbx.space_group_info(group=asu_mappings.space_group())
self.unit_cell = asu_mappings.unit_cell()
self.fixed_distances = fixed_distances
self.fixed_angles = fixed_angles
if sites_cart is not None:
sites_frac = self.unit_cell.fractionalize(sites_cart)
if sites_frac is not None:
sites_cart = self.unit_cell.orthogonalize(sites_frac)
if covariance_matrix is not None:
assert parameter_map is not None
self.covariance_matrix_cart = covariance.orthogonalize_covariance_matrix(
covariance_matrix, self.unit_cell, parameter_map)
else: self.covariance_matrix_cart = None
self.cell_covariance_matrix = cell_covariance_matrix
self.eps = eps
self.parameter_map = parameter_map
self.loop = model.loop(header=(
"_geom_hbond_atom_site_label_D",
"_geom_hbond_atom_site_label_H",
"_geom_hbond_atom_site_label_A",
"_geom_hbond_distance_DH",
"_geom_hbond_distance_HA",
"_geom_hbond_distance_DA",
"_geom_hbond_angle_DHA",
"_geom_hbond_site_symmetry_A",
))
for hbond in hbonds:
d_seq, a_seq = hbond.d_seq, hbond.a_seq
site_cart_d = sites_cart[d_seq]
if hbond.rt_mx is not None:
site_frac_a = sites_frac[a_seq]
site_frac_a = hbond.rt_mx * site_frac_a
site_cart_a = self.unit_cell.orthogonalize(site_frac_a)
else:
site_cart_a = sites_cart[a_seq]
distance_da = geometry.distance((site_cart_d, site_cart_a))
for h_seq, h_sym_groups in pair_asu_table.table()[hbond.d_seq].items():
if site_labels[h_seq][0] not in ('H','D'):
# XXX better to pass scattering types instead?
continue
site_cart_h = sites_cart[h_seq]
distance_dh = geometry.distance((site_cart_d, site_cart_h))
distance_ha = geometry.distance((site_cart_h, site_cart_a))
angle_dha = geometry.angle((site_cart_d, site_cart_h, site_cart_a))
if (angle_dha.angle_model < min_dha_angle or
distance_da.distance_model > max_da_distance):
continue
if hbond.rt_mx is not None:
sym_code = space_group_info.cif_symmetry_code(hbond.rt_mx)
else: sym_code = '.'
self.loop.add_row((
site_labels[d_seq],
site_labels[h_seq],
site_labels[a_seq],
self.formatted_distance(d_seq, h_seq, distance_dh, unit_mx),
self.formatted_distance(h_seq, a_seq, distance_ha, unit_mx),
self.formatted_distance(d_seq, a_seq, distance_da, hbond.rt_mx),
self.formatted_angle(d_seq, h_seq, a_seq, angle_dha, hbond.rt_mx),
sym_code
))
def run():
quartz_as_cif = """\
data_quartz
_space_group_name_H-M_alt 'P 62 2 2'
_cell_length_a 5.01
_cell_length_b 5.01
_cell_length_c 5.47
_cell_angle_alpha 90
_cell_angle_beta 90
_cell_angle_gamma 120
loop_
_atom_site_label
_atom_site_type_symbol
_atom_site_fract_x
_atom_site_fract_y
_atom_site_fract_z
_atom_site_U_iso_or_equiv
Si Si 0.500 0.500 0.333 0.200
O O 0.197 -0.197 0.833 0.200
"""
import iotbx.cif
quartz_structure = iotbx.cif.reader(
input_string=quartz_as_cif).build_crystal_structures()["quartz"]
quartz_structure.show_summary().show_scatterers()
print
# Examine the site symmetry of each scatterer
for scatterer in quartz_structure.scatterers():
print "%s:" % scatterer.label, "%8.4f %8.4f %8.4f" % scatterer.site
site_symmetry = quartz_structure.site_symmetry(scatterer.site)
print " point group type:", site_symmetry.point_group_type()
print " special position operator:", site_symmetry.special_op_simplified()
# Let's use scattering factors from the International Tables
quartz_structure.scattering_type_registry(table="it1992")
# Now calculate some structure factors
f_calc = quartz_structure.structure_factors(d_min=2).f_calc()
f_calc_sq = f_calc.as_intensity_array()
f_calc_sq.show_summary().show_array()
# Output the intensities to a CIF file
f_calc_sq.as_cif_simple(
array_type="calc", data_name="quartz", out=open("quartz.hkl", "wb"))
from iotbx.cif import model
# Create an instance of model.cif, equivalent to a full CIF file
cif = model.cif()
# Create an instance of model.block, equivalent to a CIF data block
cif_block = model.block()
# Add the unit cell parameters to the cif_block
unit_cell = quartz_structure.unit_cell()
params = unit_cell.parameters()
cif_block["_cell_length_a"] = params[0]
cif_block["_cell_length_b"] = params[1]
cif_block["_cell_length_c"] = params[2]
cif_block["_cell_angle_alpha"] = params[3]
cif_block["_cell_angle_beta"] = params[4]
cif_block["_cell_angle_gamma"] = params[5]
cif_block["_cell_volume"] = unit_cell.volume()
# now we will create a CIF loop containing the space group symmetry operations
space_group = quartz_structure.space_group()
symop_loop = model.loop(header=("_space_group_symop_id",
"_space_group_symop_operation_xyz"))
for symop_id, symop in enumerate(space_group):
symop_loop.add_row((symop_id + 1, symop.as_xyz()))
# add the symop_loop and space group items to the cif_block
space_group_type = quartz_structure.space_group_info().type()
cif_block["_space_group_crystal_system"] = space_group.crystal_system().lower()
cif_block["_space_group_IT_number"] = space_group_type.number()
cif_block["_space_group_name_H-M_alt"] = space_group_type.lookup_symbol()
cif_block["_space_group_name_Hall"] = space_group_type.hall_symbol()
cif_block.add_loop(symop_loop)
# add cif_block to the cif object with the data block name "quartz"
cif["quartz"] = cif_block
# print the cif object to standard output
print cif
from iotbx.cif import validation
cif_model = iotbx.cif.reader(input_string=quartz_as_cif).model()
cif_model["quartz"]["_diffrn_radiation_probe"] = "xray"
cif_model["quartz"]["_space_group_crystal_system"] = "Monoclinic"
cif_model["quartz"]["_space_group_IT_number"] = "one hundred and eighty"
symop_loop.add_column("_space_group_symop_sg_id", [1]*12)
cif_model["quartz"].add_loop(symop_loop)
cif_core_dic = validation.smart_load_dictionary(name="cif_core.dic")
cif_model.validate(cif_core_dic, show_warnings=True)
def __init__(self,
hbonds,
pair_asu_table,
site_labels,
sites_frac=None,
sites_cart=None,
min_dha_angle=150, # degrees
max_da_distance=2.9, # angstrom
covariance_matrix=None,
cell_covariance_matrix=None,
parameter_map=None,
eps=2e-16,
fixed_distances=None,
fixed_angles=None):
assert [sites_frac, sites_cart].count(None) == 1
fmt_a = "%.1f"
pair_asu_table = pair_asu_table
asu_mappings = pair_asu_table.asu_mappings()
space_group_info = sgtbx.space_group_info(group=asu_mappings.space_group())
self.unit_cell = asu_mappings.unit_cell()
self.fixed_distances = fixed_distances
self.fixed_angles = fixed_angles
if sites_cart is not None:
sites_frac = self.unit_cell.fractionalize(sites_cart)
if sites_frac is not None:
sites_cart = self.unit_cell.orthogonalize(sites_frac)
if covariance_matrix is not None:
assert parameter_map is not None
self.covariance_matrix_cart = covariance.orthogonalize_covariance_matrix(
covariance_matrix, self.unit_cell, parameter_map)
else: self.covariance_matrix_cart = None
self.cell_covariance_matrix = cell_covariance_matrix
self.eps = eps
self.parameter_map = parameter_map
self.loop = model.loop(header=(
"_geom_hbond_atom_site_label_D",
"_geom_hbond_atom_site_label_H",
"_geom_hbond_atom_site_label_A",
"_geom_hbond_distance_DH",
"_geom_hbond_distance_HA",
"_geom_hbond_distance_DA",
"_geom_hbond_angle_DHA",
"_geom_hbond_site_symmetry_A",
))
for hbond in hbonds:
d_seq, a_seq = hbond.d_seq, hbond.a_seq
site_cart_d = sites_cart[d_seq]
if hbond.rt_mx is not None:
site_frac_a = sites_frac[a_seq]
site_frac_a = hbond.rt_mx * site_frac_a
site_cart_a = self.unit_cell.orthogonalize(site_frac_a)
else:
site_cart_a = sites_cart[a_seq]
distance_da = geometry.distance((site_cart_d, site_cart_a))
for h_seq, h_sym_groups in pair_asu_table.table()[hbond.d_seq].items():
if site_labels[h_seq][0] not in ('H','D'):
# XXX better to pass scattering types instead?
continue
site_cart_h = sites_cart[h_seq]
distance_dh = geometry.distance((site_cart_d, site_cart_h))
distance_ha = geometry.distance((site_cart_h, site_cart_a))
angle_dha = geometry.angle((site_cart_d, site_cart_h, site_cart_a))
if (angle_dha.angle_model < min_dha_angle or
distance_da.distance_model > max_da_distance):
continue
if hbond.rt_mx is not None:
sym_code = space_group_info.cif_symmetry_code(hbond.rt_mx)
else: sym_code = '.'
self.loop.add_row((
site_labels[d_seq],
site_labels[h_seq],
site_labels[a_seq],
self.formatted_distance(d_seq, h_seq, distance_dh, unit_mx),
self.formatted_distance(h_seq, a_seq, distance_ha, unit_mx),
self.formatted_distance(d_seq, a_seq, distance_da, hbond.rt_mx),
self.formatted_angle(d_seq, h_seq, a_seq, angle_dha, hbond.rt_mx),
sym_code
))
def miller_indices_as_cif_loop(indices, prefix="_refln_"):
refln_loop = model.loop(header=("%sindex_h" % prefix, "%sindex_k" % prefix, "%sindex_l" % prefix))
for hkl in indices:
refln_loop.add_row(hkl)
return refln_loop
def atom_type_cif_loop(xray_structure, format="mmcif"):
format = format.lower()
assert format in ("corecif", "mmcif")
if format == "mmcif": separator = '.'
else: separator = '_'
sources = {
"it1992": "International Tables Volume C Table 6.1.1.4 (pp. 500-502)",
"wk1995": "Waasmaier & Kirfel (1995), Acta Cryst. A51, 416-431",
}
inelastic_references = {
"henke":
"Henke, Gullikson and Davis, At. Data and Nucl. Data Tables, 1993, 54, 2",
"sasaki": "Sasaki, KEK Report, 1989, 88-14, 1",
}
scattering_type_registry = xray_structure.scattering_type_registry()
unique_gaussians = scattering_type_registry.unique_gaussians_as_list()
max_n_gaussians = max(
[gaussian.n_terms() for gaussian in unique_gaussians])
max_n_gaussians = max(max_n_gaussians,
4) # Need for compliance with mmcif_pdbx_v50
# _atom_type_* loop
header = [
'_atom_type%ssymbol' % separator,
'_atom_type%sscat_dispersion_real' % separator,
'_atom_type%sscat_dispersion_imag' % separator
]
header.extend([
'_atom_type%sscat_Cromer_Mann_a%i' % (separator, i + 1)
for i in range(max_n_gaussians)
])
header.extend([
'_atom_type%sscat_Cromer_Mann_b%i' % (separator, i + 1)
for i in range(max_n_gaussians)
])
header.extend([
'_atom_type%sscat_Cromer_Mann_c' % separator,
'_atom_type%sscat_source' % separator,
'_atom_type%sscat_dispersion_source' % separator
])
atom_type_loop = model.loop(header=header)
gaussian_dict = scattering_type_registry.as_type_gaussian_dict()
scattering_type_registry = xray_structure.scattering_type_registry()
params = xray_structure.scattering_type_registry_params
fp_fdp_table = {}
for sc in xray_structure.scatterers():
fp_fdp_table.setdefault(sc.scattering_type, (sc.fp, sc.fdp))
disp_source = inelastic_references.get(
xray_structure.inelastic_form_factors_source)
# custom?
if disp_source is None:
disp_source = xray_structure.inelastic_form_factors_source
if disp_source is None:
disp_source = "."
for atom_type, gaussian in scattering_type_registry.as_type_gaussian_dict(
).iteritems():
scat_source = sources.get(params.table)
if params.custom_dict and atom_type in params.custom_dict:
scat_source = "Custom %i-Gaussian" % gaussian.n_terms()
elif scat_source is None:
scat_source = """\
%i-Gaussian fit: Grosse-Kunstleve RW, Sauter NK, Adams PD:
Newsletter of the IUCr Commission on Crystallographic Computing 2004, 3, 22-31."""
scat_source = scat_source % gaussian.n_terms()
if disp_source == ".":
fp, fdp = ".", "."
else:
fp, fdp = fp_fdp_table[atom_type]
fp = "%.5f" % fp
fdp = "%.5f" % fdp
row = [atom_type, fp, fdp]
#gaussian = gaussian_dict[sc.scattering_type]
gaussian_a = ["%.5f" % a for a in gaussian.array_of_a()]
gaussian_b = ["%.5f" % a for a in gaussian.array_of_b()]
gaussian_a.extend(["."] * (max_n_gaussians - gaussian.n_terms()))
gaussian_b.extend(["."] * (max_n_gaussians - gaussian.n_terms()))
row.extend(gaussian_a + gaussian_b)
row.extend([gaussian.c(), scat_source, disp_source])
atom_type_loop.add_row(row)
return atom_type_loop
def __init__(self, xray_structure, covariance_matrix=None, cell_covariance_matrix=None):
crystal_symmetry_as_cif_block.__init__(
self, xray_structure.crystal_symmetry(), cell_covariance_matrix=cell_covariance_matrix
)
scatterers = xray_structure.scatterers()
uc = xray_structure.unit_cell()
if covariance_matrix is not None:
param_map = xray_structure.parameter_map()
covariance_diagonal = covariance_matrix.matrix_packed_u_diagonal()
u_star_to_u_cif_linear_map_pow2 = flex.pow2(flex.double(uc.u_star_to_u_cif_linear_map()))
u_star_to_u_iso_linear_form = matrix.row(uc.u_star_to_u_iso_linear_form())
fmt = "%.6f"
# _atom_site_* loop
atom_site_loop = model.loop(
header=(
"_atom_site_label",
"_atom_site_type_symbol",
"_atom_site_fract_x",
"_atom_site_fract_y",
"_atom_site_fract_z",
"_atom_site_U_iso_or_equiv",
"_atom_site_adp_type",
"_atom_site_occupancy",
)
)
for i_seq, sc in enumerate(scatterers):
site = occu = u_iso_or_equiv = None
# site
if covariance_matrix is not None:
params = param_map[i_seq]
if sc.flags.grad_site() and params.site >= 0:
site = []
for i in range(3):
site.append(format_float_with_su(sc.site[i], math.sqrt(covariance_diagonal[params.site + i])))
# occupancy
if sc.flags.grad_occupancy() and params.occupancy >= 0:
occu = format_float_with_su(sc.occupancy, math.sqrt(covariance_diagonal[params.occupancy]))
# Uiso/eq
if sc.flags.grad_u_iso() or sc.flags.grad_u_aniso():
if sc.flags.grad_u_iso():
u_iso_or_equiv = format_float_with_su(
sc.u_iso, math.sqrt(covariance.variance_for_u_iso(i_seq, covariance_matrix, param_map))
)
else:
cov = covariance.extract_covariance_matrix_for_u_aniso(
i_seq, covariance_matrix, param_map
).matrix_packed_u_as_symmetric()
var = (u_star_to_u_iso_linear_form * matrix.sqr(cov)).dot(u_star_to_u_iso_linear_form)
u_iso_or_equiv = format_float_with_su(sc.u_iso_or_equiv(uc), math.sqrt(var))
if site is None:
site = [fmt % sc.site[i] for i in range(3)]
if occu is None:
occu = fmt % sc.occupancy
if u_iso_or_equiv is None:
u_iso_or_equiv = fmt % sc.u_iso_or_equiv(uc)
if sc.flags.use_u_aniso():
adp_type = "Uani"
else:
adp_type = "Uiso"
atom_site_loop.add_row(
(sc.label, sc.scattering_type, site[0], site[1], site[2], u_iso_or_equiv, adp_type, occu)
)
self.cif_block.add_loop(atom_site_loop)
# _atom_site_aniso_* loop
aniso_scatterers = scatterers.select(scatterers.extract_use_u_aniso())
if aniso_scatterers.size():
labels = list(scatterers.extract_labels())
aniso_loop = model.loop(
header=(
"_atom_site_aniso_label",
"_atom_site_aniso_U_11",
"_atom_site_aniso_U_22",
"_atom_site_aniso_U_33",
"_atom_site_aniso_U_12",
"_atom_site_aniso_U_13",
"_atom_site_aniso_U_23",
)
)
for sc in aniso_scatterers:
u_cif = adptbx.u_star_as_u_cif(uc, sc.u_star)
if covariance_matrix is not None:
row = [sc.label]
idx = param_map[labels.index(sc.label)].u_aniso
if idx > -1:
var = covariance_diagonal[idx : idx + 6] * u_star_to_u_cif_linear_map_pow2
for i in range(6):
if var[i] > 0:
row.append(format_float_with_su(u_cif[i], math.sqrt(var[i])))
else:
row.append(fmt % u_cif[i])
else:
row = [sc.label] + [fmt % u_cif[i] for i in range(6)]
else:
row = [sc.label] + [fmt % u_cif[i] for i in range(6)]
aniso_loop.add_row(row)
self.cif_block.add_loop(aniso_loop)
self.cif_block.add_loop(atom_type_cif_loop(xray_structure))
def exercise_cif_model():
loop = model.loop()
loop["_loop_a"] = flex.double((1,2,3))
loop.add_columns({'_loop_c': [4,5,6],
'_loop_b': ['7','8','9']})
loop.add_row((4,7,'0'))
try: loop["_loop_invalid"] = (7,8)
except AssertionError: pass
else: raise Exception_expected
assert len(loop) == 3 # the number of columns (keys)
assert loop.size() == 4 # the number of rows (loop iterations)
assert list(loop.keys()) == ['_loop_a', '_loop_c', '_loop_b']
try: loop["no_leading_underscore"] = 3
except Sorry: pass
else: raise Exception_expected
loop2 = model.loop(header=("_loop2_a", "_loop2_b"), data=(1,2,3,4,5,6))
assert list(loop2.keys()) == ["_loop2_a", "_loop2_b"]
assert list(loop2.values()) == [flex.std_string(['1', '3', '5']),
flex.std_string(['2', '4', '6'])]
assert list(loop2.iterrows()) == [
{'_loop2_a': '1', '_loop2_b': '2'},
{'_loop2_a': '3', '_loop2_b': '4'},
{'_loop2_a': '5', '_loop2_b': '6'}]
loop3 = model.loop(
data={
"_loop3_a": flex.int((-1, 2, 3)),
"_loop3_b": flex.double((1.1, 2.2, 3.3)),
"_loop3_c": flex.size_t((1, 2, 3)),
}
)
for k in "abc":
assert isinstance(loop3["_loop3_%s" % k], flex.std_string)
#
block = model.block()
block["_tag"] = 3
block["_tag1"] = "'a string'"
block["_another_tag"] = 3.142
assert "_tag" in block
assert "_tag1" in block
assert "_another_tag" in block
assert block["_tag"] == '3'
assert block["_tag1"] == "'a string'"
assert block["_another_tag"] == "3.142"
assert list(block.keys()) == ['_tag', '_tag1', '_another_tag']
assert list(block.values()) == ["3", "'a string'", "3.142"]
try: block["no_leading_underscore"] = 3
except Sorry: pass
else: raise Exception_expected
block.add_loop(loop)
assert len(block) == 6
assert list(block.items()) == [
('_tag', '3'), ('_tag1', "'a string'"), ('_another_tag', '3.142'),
('_loop_a', flex.std_string(['1', '2', '3', '4'])),
('_loop_c', flex.std_string(['4', '5', '6', '7'])),
('_loop_b', flex.std_string(['7', '8', '9', '0']))]
block['_loop_c'] = [11, 12, 13, 14]
assert '_loop_c' in list(block.loops['_loop'].keys())
assert list(block['_loop_c']) == ['11', '12', '13', '14']
#
block1 = model.block()
block1["_tag"] = 2
block1["_tag2"] = 1.2
loop3 = model.loop(header=("_loop_a", "_loop_b"), data=(6,5,4,3,2,1))
block1.add_loop(loop2)
block1.add_loop(loop3)
block.update(block1)
for key in block._items.keys():
assert key in ['_another_tag', '_tag2', '_tag', '_tag1']
for value in block._items.values():
assert value in ['3.142', '1.2', '2', "'a string'"]
assert list(block.loops.keys()) == ['_loop', '_loop2']
assert list(block.keys()) == ['_tag', '_tag1', '_another_tag', '_loop_a',
'_loop_b','_tag2', '_loop2_a', '_loop2_b']
assert list(block['_loop_a']) == ['6', '4', '2']
assert list(block['_loop_b']) == ['5', '3', '1']
assert list(block['_loop2_a']) == ['1', '3', '5']
assert list(block['_loop2_b']) == ['2', '4', '6']
try: block['_loop_c']
except KeyError: pass
else: raise Exception_expected
bad_loop = model.loop(header=("_a", "_b"), data=(1,2,3,4,5,6))
block1.add_loop(bad_loop)
assert "_a" in block1
assert "_b" in block1
assert list(block.get_looped_item("_loop_a")) == ['6', '4', '2']
try: block.get_looped_item("_tag", value_error=ValueError)
except ValueError: pass
else: raise Exception_expected
assert list(block.get_looped_item("_tag", value_error=None)) == ['2']
try: block.get_looped_item("_none_existent")
except KeyError: pass
else: raise Exception_expected
assert block.get_looped_item(
"_none_existent", key_error=None, default="my_default") == "my_default"
assert block.get_single_item("_tag") == "2"
try: block.get_single_item("_loop_a")
except ValueError: pass
else: raise Exception_expected
assert block.get_single_item(
"_loop_a", value_error=None, default="default") == "default"
try: block.get_single_item("_none_existent")
except KeyError: pass
else: raise Exception_expected
assert block.get_single_item("_none_existent", key_error=None) is None
#
cif_model = model.cif()
cif_model["fred"] = block
assert "fred" in cif_model
assert cif_model["frEd"] is block
assert cif_model["fred"]["_Tag"] == '2'
cif_model["fred"]["_tag"] = 4
assert cif_model["fred"]["_tag"] == '4'
del cif_model["fred"]["_tAg"]
try: cif_model["fred"]["_tag"]
except KeyError: pass
else: raise Exception_expected
cm = cif_model.deepcopy()
l = cm["fred"]["_loop"]
del cm["Fred"]["_loop_B"]
assert "_loop_b" not in cm["fred"]
assert "_loop_b" not in l
assert "_loop" in cm["fred"].loops
del cm["fred"]["_loop_a"]
assert "_loop" not in cm["fred"].loops
del cm["fred"]["_loop2"]
assert "_loop2" not in cm["fred"].loops
s = StringIO()
print(cm, file=s)
assert not show_diff(s.getvalue(),
"""\
data_fred
_tag1 'a string'
_another_tag 3.142
_tag2 1.2
""")
#
cm2 = cif_model.copy()
cm3 = cif_model.deepcopy()
assert cm2['fred']['_loop_a'] is cif_model ['fred']['_loop_a']
assert cm3['fred']['_loop_a'] is not cif_model ['fred']['_loop_a']
b2 = copy.copy(block)
b3 = copy.deepcopy(block)
assert b2['_loop_b'] is block['_loop_b']
assert b3['_loop_b'] is not block['_loop_b']
l2 = loop.copy()
l3 = loop.deepcopy()
assert l2['_loop_b'] is loop['_loop_b']
assert l3['_loop_b'] is not loop['_loop_b']
#
s = StringIO()
cif_model.show(out=s)
assert not show_diff(s.getvalue(),
"""\
data_fred
_tag1 'a string'
_another_tag 3.142
loop_
_loop_a
_loop_b
6 5
4 3
2 1
_tag2 1.2
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
s = StringIO()
cif_model.show(out=s, indent=" ", data_name_field_width=0)
assert not show_diff(s.getvalue(),
"""\
data_fred
_tag1 'a string'
_another_tag 3.142
loop_
_loop_a
_loop_b
6 5
4 3
2 1
_tag2 1.2
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
s = StringIO()
cif_model.show(out=s, indent="", indent_row=" ", data_name_field_width=0)
assert not show_diff(s.getvalue(),
"""\
data_fred
_tag1 'a string'
_another_tag 3.142
loop_
_loop_a
_loop_b
6 5
4 3
2 1
_tag2 1.2
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
cif_model.sort(recursive=True)
s = StringIO()
cif_model.show(out=s)
assert not show_diff(s.getvalue(),
"""\
data_fred
_another_tag 3.142
_tag1 'a string'
_tag2 1.2
loop_
_loop_a
_loop_b
6 5
4 3
2 1
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
save = model.save()
save.add_loop(l3)
save['_tag1'] = 3
block = model.block()
block['bob'] = save
cm = model.cif({'fred': block})
s = StringIO()
cm.show(out=s)
assert not show_diff(s.getvalue(),
"""data_fred
save_bob
loop_
_loop_a
_loop_c
_loop_b
1 11 7
2 12 8
3 13 9
4 14 0
_tag1 3
save_
""")
b1 = model.block()
b1['_a'] = 1
b1['_b'] = 2
b1['_c'] = 3
b2 = model.block()
b2['_a'] = 2
b2['_c'] = 3
b2['_d'] = 4
b3 = b1.difference(b2)
b4 = b2.difference(b1)
for item in b3.items():
assert item in [('_b', '2'), ('_a', '2')]
for item in b4.items():
assert item in [('_d', '4'), ('_a', '1')]
l = model.loop(data=dict(_loop_d=(1,2),_loop_e=(3,4),_loop_f=(5,6)))
assert l == l
assert l == l.deepcopy()
assert l != l2
assert l != l3
l2 = model.loop(data=dict(_loop_d=(1,2,3),_loop_e=(3,4,5),_loop_f=(5,6,7)))
b1.add_loop(l)
b2.add_loop(l2)
b5 = b1.difference(b2)
assert b5['_loop'] == l2
l = model.loop(data=OrderedDict((('_loop_a',(1,21,-13)),
('_loop_b',(-221.3,3.01,4.246)),
('_loop_c',("a","b","cc")))))
b = model.block()
b.add_loop(l)
cm = model.cif({'fred':b})
s = StringIO()
cm.show(out=s, loop_format_strings={'_loop':'% 4i% 8.2f %s'})
assert not show_diff(s.getvalue(),"""\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.30 a
21 3.01 b
-13 4.25 cc
""")
s = StringIO()
cm.show(out=s)
assert not show_diff(s.getvalue(),"""\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.3 a
21 3.01 b
-13 4.246 cc
""")
l.add_row((".", "?", "."))
s = StringIO()
cm.show(out=s)
assert not show_diff(s.getvalue(),"""\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.3 a
21 3.01 b
-13 4.246 cc
. ? .
""")
l.delete_row(index=1)
s = StringIO()
cm.show(out=s)
assert not show_diff(s.getvalue(),"""\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.3 a
-13 4.246 cc
. ? .
""")
l2 = l.deepcopy()
l2.delete_row(index=0)
l2.delete_row(index=0)
l2.delete_row(index=0)
try: l2.show(out=s)
except AssertionError as e: pass
else: raise Exception_expected
l.clear()
try: l.show(out=s)
except AssertionError as e: pass
else: raise Exception_expected
#
loop = model.loop(data={"_a_1": ('string with spaces','nospaces'),
"_a_2": ('a', 'b')})
s = StringIO()
loop.show(out=s, align_columns=True)
assert not show_diff(s.getvalue(), """\
loop_
_a_1
_a_2
'string with spaces' a
nospaces b
""")
#
cb = model.block()
cm = model.cif()
cm["a"] = cb
cb["_b"] = ""
s = StringIO()
cm.show(out=s)
assert not show_diff(s.getvalue(), """\
data_a
_b ''
""")
#
loop = model.loop(data=OrderedDict((
("_entity_poly.entity_id", ('1', '2', '3')),
("_entity_poly.pdbx_seq_one_letter_code", (
"TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR",
"""\
IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM
THVFRLKKWIQKVIDQFGE""",
"NGDFEEIPEE(TYS)LQ",
)),
("_entity_poly.pdbx_seq_one_letter_code_can", (
"TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR",
"""\
IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM
THVFRLKKWIQKVIDQFGE""",
"NGDFEEIPEEYLQ",
)),
("_entity_poly.pdbx_strand_id", ('L', 'H', 'I'))
)))
s = StringIO()
loop.show(out=s, align_columns=True)
s.seek(0)
assert not show_diff("\n".join(l.rstrip() for l in s.readlines()),"""\
loop_
_entity_poly.entity_id
_entity_poly.pdbx_seq_one_letter_code
_entity_poly.pdbx_seq_one_letter_code_can
_entity_poly.pdbx_strand_id
1 TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR L
2
;
IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM
THVFRLKKWIQKVIDQFGE
;
;
IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM
THVFRLKKWIQKVIDQFGE
;
H
3 NGDFEEIPEE(TYS)LQ NGDFEEIPEEYLQ I\
""")
#
cb = model.block()
cm = model.cif()
cm["a"] = cb
cb["_a"] = '1 "a" 2'
cb["_b"] = "1 'b' 3"
cb["_c"] = "O1'"
cb["_d"] = 'O2"'
cb["_e"] = """1 'a' "b" 3"""
s = StringIO()
print(cm, file=s)
s.seek(0)
assert not show_diff("\n".join(l.rstrip() for l in s.readlines()), """\
data_a
_a '1 "a" 2'
_b "1 'b' 3"
_c O1'
_d O2"
_e
;
1 'a' "b" 3
;
""")
# verify that what we wrote out above is valid CIF and we can read it back in
cm2 = iotbx.cif.reader(input_string=s.getvalue()).model()
cb2 = cm2["a"]
assert cb2["_a"] == cb["_a"]
assert cb2["_b"] == cb["_b"]
assert cb2["_c"] == cb["_c"]
assert cb2["_d"] == cb["_d"]
assert cb2["_e"].strip() == cb["_e"]
#
cm = iotbx.cif.reader(input_string="""\
data_a
loop_
_pdbx_refine_tls_group.id
_pdbx_refine_tls_group.refine_tls_id
_pdbx_refine_tls_group.selection
_pdbx_refine_tls_group.selection_details
1 1 ? "chain 'A' and (resid 2 through 15 )"
2 2 ? "chain 'A' and (resid 16 through 26 )"
3 3 ? "chain 'A' and (resid 27 through 43 )"
4 4 ? "chain 'B' and (resid 1 through 14 )"
5 5 ? "chain 'B' and (resid 15 through 20 )"
""").model()
print(cm)
#
cif_block = model.block()
loop_a = model.loop(header=("_a.1", "_a.2"), data=(1,2,3,4,5,6))
cif_block.add_loop(loop_a)
assert cif_block.get_loop("_a") is loop_a
assert cif_block.get_loop_or_row("_a") is loop_a
assert cif_block.get_loop("_b") is None
assert cif_block.get_loop_or_row("_b") is None
assert cif_block.get_loop("_b", default=loop_a) is loop_a
assert cif_block.get_loop_or_row("_b", default=loop_a) is loop_a
loop_a = cif_block.get_loop_with_defaults(
"_a", default_dict={"_a.2":".", "_a.3":"?", "_a.4":"."})
assert list(cif_block["_a.1"]) == ['1', '3', '5']
assert list(cif_block["_a.2"]) == ['2', '4', '6']
assert list(cif_block["_a.3"]) == ['?', '?', '?']
assert list(cif_block["_a.4"]) == ['.', '.', '.']
loop_a.add_row({"_a.3":"a", "_a.4":"b"})
loop_a.add_row({"_a.3":"c", "_a.4":"d"}, default_value=".")
assert list(cif_block["_a.1"]) == ['1', '3', '5', '?', '.']
assert list(cif_block["_a.2"]) == ['2', '4', '6', '?', '.']
assert list(cif_block["_a.3"]) == ['?', '?', '?', 'a', 'c']
assert list(cif_block["_a.4"]) == ['.', '.', '.', 'b', 'd']
loop_B = model.loop(header=("_B.1", "_B.2", "_B.3"), data=(1,2,3,4,5,6))
cif_block.add_loop(loop_B)
assert cif_block.get_loop("_B") is loop_B
assert cif_block.get_loop_or_row("_B") is loop_B
assert cif_block.get_loop("_b") is loop_B
assert cif_block.get_loop_or_row("_b") is loop_B
#
cif_block = model.block()
cif_block['_a'] = """\
123
456"""
s = StringIO()
cif_block.show(out=s)
s.seek(0)
assert not show_diff("\n".join([l.strip() for l in s.readlines()]), """\
_a
;
123
456
;
""")
cm = iotbx.cif.reader(input_string="""\
data_a
_test_row.id 1
_test_row.data2 2
_test_row.data3 3
_test_row.data4 44
#
loop_
_test_row_range.sheet_id
_test_row_range.id
_test_row_range.beg_label_comp_id
_test_row_range.beg_label_asym_id
A 1 SER A
A 2 MET A
#
""").model()
#
cif_block = list(cm.values())[0]
loop_or_row = cif_block.get_loop_or_row('_test_row')
assert loop_or_row.n_rows() == 1
assert loop_or_row.n_columns() == 4
assert list(loop_or_row['_test_row.id']) == ['1']
assert list(loop_or_row['_test_row.data2']) == ['2']
assert list(loop_or_row['_test_row.data3']) == ['3']
assert list(loop_or_row['_test_row.data4']) == ['44']
for r in loop_or_row.iterrows():
assert list(r['_test_row.id']) == ['1']
assert list(r['_test_row.data2']) == ['2']
assert list(r['_test_row.data3']) == ['3']
assert list(r['_test_row.data4']) == ['4','4']
def atom_type_cif_loop(xray_structure, format="coreCIF"):
format = format.lower()
assert format in ("corecif", "mmcif")
if format == "mmcif": separator = '.'
else: separator = '_'
sources = {
"it1992": "International Tables Volume C Table 6.1.1.4 (pp. 500-502)",
"wk1995": "Waasmaier & Kirfel (1995), Acta Cryst. A51, 416-431",
}
inelastic_references = {
"henke" : "Henke, Gullikson and Davis, At. Data and Nucl. Data Tables, 1993, 54, 2",
"sasaki" : "Sasaki, KEK Report, 1989, 88-14, 1",
}
scattering_type_registry = xray_structure.scattering_type_registry()
unique_gaussians = scattering_type_registry.unique_gaussians_as_list()
max_n_gaussians = max([gaussian.n_terms() for gaussian in unique_gaussians])
# _atom_type_* loop
header = ['_atom_type%ssymbol' %separator,
'_atom_type%sscat_dispersion_real' %separator,
'_atom_type%sscat_dispersion_imag' %separator]
header.extend(['_atom_type%sscat_Cromer_Mann_a%i' %(separator, i+1)
for i in range(max_n_gaussians)])
header.extend(['_atom_type%sscat_Cromer_Mann_b%i' %(separator, i+1)
for i in range(max_n_gaussians)])
header.extend(['_atom_type%sscat_Cromer_Mann_c' %separator,
'_atom_type%sscat_source' %separator,
'_atom_type%sscat_dispersion_source' %separator])
atom_type_loop = model.loop(header=header)
gaussian_dict = scattering_type_registry.as_type_gaussian_dict()
scattering_type_registry = xray_structure.scattering_type_registry()
params = xray_structure.scattering_type_registry_params
fp_fdp_table = {}
for sc in xray_structure.scatterers():
fp_fdp_table.setdefault(sc.scattering_type, (sc.fp, sc.fdp))
disp_source = inelastic_references.get(
xray_structure.inelastic_form_factors_source)
# custom?
if disp_source is None:
disp_source = xray_structure.inelastic_form_factors_source
if disp_source is None:
disp_source = "."
for atom_type, gaussian in scattering_type_registry.as_type_gaussian_dict().iteritems():
scat_source = sources.get(params.table)
if params.custom_dict and atom_type in params.custom_dict:
scat_source = "Custom %i-Gaussian" %gaussian.n_terms()
elif scat_source is None:
scat_source = """\
%i-Gaussian fit: Grosse-Kunstleve RW, Sauter NK, Adams PD:
Newsletter of the IUCr Commission on Crystallographic Computing 2004, 3, 22-31."""
scat_source = scat_source %gaussian.n_terms()
if disp_source == ".":
fp, fdp = ".", "."
else:
fp, fdp = fp_fdp_table[atom_type]
fp = "%.5f" %fp
fdp = "%.5f" %fdp
row = [atom_type, fp, fdp]
#gaussian = gaussian_dict[sc.scattering_type]
gaussian_a = ["%.5f" %a for a in gaussian.array_of_a()]
gaussian_b = ["%.5f" %a for a in gaussian.array_of_b()]
gaussian_a.extend(["."]*(max_n_gaussians-gaussian.n_terms()))
gaussian_b.extend(["."]*(max_n_gaussians-gaussian.n_terms()))
row.extend(gaussian_a + gaussian_b)
row.extend([gaussian.c(), scat_source, disp_source])
atom_type_loop.add_row(row)
return atom_type_loop
def run():
inp = iotbx.pdb.input(source_info=None, lines=quartz_as_cif.split('\n'))
modelm = mmtbx.model.manager(model_input=inp)
quartz_structure = modelm.get_xray_structure()
# Examine the site symmetry of each scatterer
for scatterer in quartz_structure.scatterers():
print "%s:" % scatterer.label, "%8.4f %8.4f %8.4f" % scatterer.site
site_symmetry = quartz_structure.site_symmetry(scatterer.site)
print " point group type:", site_symmetry.point_group_type()
print " special position operator:", site_symmetry.special_op_simplified(
)
# Let's use scattering factors from the International Tables
modelm.setup_scattering_dictionaries(scattering_table="it1992")
quartz_structure = modelm.get_xray_structure()
# Now calculate some structure factors
f_calc = quartz_structure.structure_factors(d_min=2).f_calc()
f_calc_sq = f_calc.as_intensity_array()
f_calc_sq.show_summary().show_array()
# Output the intensities to a CIF file
# This probably should be deprecated as well
f_calc_sq.as_cif_simple(array_type="calc",
data_name="quartz",
out=open("quartz-intensities.cif", "wb"))
# Create an instance of model.cif, equivalent to a full CIF file
cif = model.cif()
# Create an instance of model.block, equivalent to a CIF data block
cif_block = model.block()
# Add the unit cell parameters to the cif_block
unit_cell = quartz_structure.unit_cell()
params = unit_cell.parameters()
cif_block["_cell_length_a"] = params[0]
cif_block["_cell_length_b"] = params[1]
cif_block["_cell_length_c"] = params[2]
cif_block["_cell_angle_alpha"] = params[3]
cif_block["_cell_angle_beta"] = params[4]
cif_block["_cell_angle_gamma"] = params[5]
cif_block["_cell_volume"] = unit_cell.volume()
# now we will create a CIF loop containing the space group symmetry operations
space_group = quartz_structure.space_group()
symop_loop = model.loop(header=("_space_group_symop_id",
"_space_group_symop_operation_xyz"))
for symop_id, symop in enumerate(space_group):
symop_loop.add_row((symop_id + 1, symop.as_xyz()))
# add the symop_loop and space group items to the cif_block
space_group_type = quartz_structure.space_group_info().type()
cif_block["_space_group_crystal_system"] = space_group.crystal_system(
).lower()
cif_block["_space_group_IT_number"] = space_group_type.number()
cif_block["_space_group_name_H-M_alt"] = space_group_type.lookup_symbol()
cif_block["_space_group_name_Hall"] = space_group_type.hall_symbol()
cif_block.add_loop(symop_loop)
# add cif_block to the cif object with the data block name "quartz"
cif["quartz"] = cif_block
# print the cif object to standard output
print cif
cif_model = iotbx.cif.reader(input_string=quartz_as_cif).model()
cif_model["quartz"]["_diffrn_radiation_probe"] = "xray"
cif_model["quartz"]["_space_group_crystal_system"] = "Monoclinic"
cif_model["quartz"]["_space_group_IT_number"] = "one hundred and eighty"
symop_loop.add_column("_space_group_symop_sg_id", [1] * 12)
cif_model["quartz"].add_loop(symop_loop)
pdbx_v50 = validation.smart_load_dictionary(name="mmcif_pdbx_v50.dic")
print "validation"
cif_model.validate(pdbx_v50, show_warnings=True)
def miller_indices_as_cif_loop(indices, prefix='_refln_'):
refln_loop = model.loop(header=(
'%sindex_h' %prefix, '%sindex_k' %prefix, '%sindex_l' %prefix))
for hkl in indices:
refln_loop.add_row(hkl)
return refln_loop
def miller_indices_as_cif_loop(indices, prefix='_refln_'):
refln_loop = model.loop(header=('%sindex_h' % prefix, '%sindex_k' % prefix,
'%sindex_l' % prefix))
for hkl in indices:
refln_loop.add_row(hkl)
return refln_loop
def exercise_cif_model():
import iotbx.cif
from iotbx.cif import model
loop = model.loop()
loop["_loop_a"] = flex.double((1,2,3))
loop.add_columns({'_loop_c': [4,5,6],
'_loop_b': ['7','8','9']})
loop.add_row((4,7,'0'))
try: loop["_loop_invalid"] = (7,8)
except AssertionError: pass
else: raise Exception_expected
assert len(loop) == 3 # the number of columns (keys)
assert loop.size() == 4 # the number of rows (loop iterations)
assert loop.keys() == ['_loop_a', '_loop_c', '_loop_b']
try: loop["no_leading_underscore"] = 3
except Sorry: pass
else: raise Exception_expected
loop2 = model.loop(header=("_loop2_a", "_loop2_b"), data=(1,2,3,4,5,6))
assert loop2.keys() == ["_loop2_a", "_loop2_b"]
assert loop2.values() == [flex.std_string(['1', '3', '5']),
flex.std_string(['2', '4', '6'])]
assert list(loop2.iterrows()) == [
{'_loop2_a': '1', '_loop2_b': '2'},
{'_loop2_a': '3', '_loop2_b': '4'},
{'_loop2_a': '5', '_loop2_b': '6'}]
#
block = model.block()
block["_tag"] = 3
block["_tag1"] = "'a string'"
block["_another_tag"] = 3.142
assert "_tag" in block
assert "_tag1" in block
assert "_another_tag" in block
assert block["_tag"] == '3'
assert block["_tag1"] == "'a string'"
assert block["_another_tag"] == "3.142"
assert block.keys() == ['_tag', '_tag1', '_another_tag']
assert block.values() == ["3", "'a string'", "3.142"]
try: block["no_leading_underscore"] = 3
except Sorry: pass
else: raise Exception_expected
block.add_loop(loop)
assert len(block) == 6
assert block.items() == [
('_tag', '3'), ('_tag1', "'a string'"), ('_another_tag', '3.142'),
('_loop_a', flex.std_string(['1', '2', '3', '4'])),
('_loop_c', flex.std_string(['4', '5', '6', '7'])),
('_loop_b', flex.std_string(['7', '8', '9', '0']))]
block['_loop_c'] = [11, 12, 13, 14]
assert '_loop_c' in block.loops['_loop'].keys()
assert list(block['_loop_c']) == ['11', '12', '13', '14']
#
block1 = model.block()
block1["_tag"] = 2
block1["_tag2"] = 1.2
loop3 = model.loop(header=("_loop_a", "_loop_b"), data=(6,5,4,3,2,1))
block1.add_loop(loop2)
block1.add_loop(loop3)
block.update(block1)
assert block._items.keys() == ['_another_tag', '_tag2', '_tag', '_tag1']
assert block._items.values() == ['3.142', '1.2', '2', "'a string'"]
assert block.loops.keys() == ['_loop', '_loop2']
assert block.keys() == ['_tag', '_tag1', '_another_tag', '_loop_a',
'_loop_b','_tag2', '_loop2_a', '_loop2_b']
assert list(block['_loop_a']) == ['6', '4', '2']
assert list(block['_loop_b']) == ['5', '3', '1']
assert list(block['_loop2_a']) == ['1', '3', '5']
assert list(block['_loop2_b']) == ['2', '4', '6']
try: block['_loop_c']
except KeyError: pass
else: raise Exception_expected
bad_loop = model.loop(header=("_a", "_b"), data=(1,2,3,4,5,6))
block1.add_loop(bad_loop)
assert "_a" in block1
assert "_b" in block1
assert list(block.get_looped_item("_loop_a")) == ['6', '4', '2']
try: block.get_looped_item("_tag", value_error=ValueError)
except ValueError: pass
else: raise Exception_expected
assert list(block.get_looped_item("_tag", value_error=None)) == ['2']
try: block.get_looped_item("_none_existent")
except KeyError: pass
else: raise Exception_expected
assert block.get_looped_item(
"_none_existent", key_error=None, default="my_default") == "my_default"
assert block.get_single_item("_tag") == "2"
try: block.get_single_item("_loop_a")
except ValueError: pass
else: raise Exception_expected
assert block.get_single_item(
"_loop_a", value_error=None, default="default") == "default"
try: block.get_single_item("_none_existent")
except KeyError: pass
else: raise Exception_expected
assert block.get_single_item("_none_existent", key_error=None) is None
#
cif_model = model.cif()
cif_model["fred"] = block
assert "fred" in cif_model
assert cif_model["frEd"] is block
assert cif_model["fred"]["_Tag"] == '2'
cif_model["fred"]["_tag"] = 4
assert cif_model["fred"]["_tag"] == '4'
del cif_model["fred"]["_tAg"]
try: cif_model["fred"]["_tag"]
except KeyError: pass
else: raise Exception_expected
cm = cif_model.deepcopy()
l = cm["fred"]["_loop"]
del cm["Fred"]["_loop_B"]
assert not cm["fred"].has_key("_loop_b")
assert not l.has_key("_loop_b")
assert cm["fred"].loops.has_key("_loop")
del cm["fred"]["_loop_a"]
assert not cm["fred"].loops.has_key("_loop")
del cm["fred"]["_loop2"]
assert not cm["fred"].loops.has_key("_loop2")
s = StringIO()
print >> s, cm
assert not show_diff(s.getvalue(),
"""\
data_fred
_tag1 'a string'
_another_tag 3.142
_tag2 1.2
""")
#
cm2 = cif_model.copy()
cm3 = cif_model.deepcopy()
assert cm2['fred']['_loop_a'] is cif_model ['fred']['_loop_a']
assert cm3['fred']['_loop_a'] is not cif_model ['fred']['_loop_a']
b2 = copy.copy(block)
b3 = copy.deepcopy(block)
assert b2['_loop_b'] is block['_loop_b']
assert b3['_loop_b'] is not block['_loop_b']
l2 = loop.copy()
l3 = loop.deepcopy()
assert l2['_loop_b'] is loop['_loop_b']
assert l3['_loop_b'] is not loop['_loop_b']
#
s = StringIO()
cif_model.show(out=s)
assert not show_diff(s.getvalue(),
"""\
data_fred
_tag1 'a string'
_another_tag 3.142
loop_
_loop_a
_loop_b
6 5
4 3
2 1
_tag2 1.2
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
s = StringIO()
cif_model.show(out=s, indent=" ", data_name_field_width=0)
assert not show_diff(s.getvalue(),
"""\
data_fred
_tag1 'a string'
_another_tag 3.142
loop_
_loop_a
_loop_b
6 5
4 3
2 1
_tag2 1.2
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
s = StringIO()
cif_model.show(out=s, indent="", indent_row=" ", data_name_field_width=0)
assert not show_diff(s.getvalue(),
"""\
data_fred
_tag1 'a string'
_another_tag 3.142
loop_
_loop_a
_loop_b
6 5
4 3
2 1
_tag2 1.2
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
cif_model.sort(recursive=True)
s = StringIO()
cif_model.show(out=s)
assert not show_diff(s.getvalue(),
"""\
data_fred
_another_tag 3.142
_tag1 'a string'
_tag2 1.2
loop_
_loop_a
_loop_b
6 5
4 3
2 1
loop_
_loop2_a
_loop2_b
1 2
3 4
5 6
""")
save = model.save()
save.add_loop(l3)
save['_tag1'] = 3
block = model.block()
block['bob'] = save
cm = model.cif({'fred': block})
s = StringIO()
cm.show(out=s)
assert not show_diff(s.getvalue(),
"""data_fred
save_bob
loop_
_loop_a
_loop_c
_loop_b
1 11 7
2 12 8
3 13 9
4 14 0
_tag1 3
save_
""")
b1 = model.block()
b1['_a'] = 1
b1['_b'] = 2
b1['_c'] = 3
b2 = model.block()
b2['_a'] = 2
b2['_c'] = 3
b2['_d'] = 4
b3 = b1.difference(b2)
b4 = b2.difference(b1)
assert b3.items() == [('_b', '2'), ('_a', '2')]
assert b4.items() == [('_d', '4'), ('_a', '1')]
l = model.loop(data=dict(_loop_d=(1,2),_loop_e=(3,4),_loop_f=(5,6)))
assert l == l
assert l == l.deepcopy()
assert l != l2
assert l != l3
l2 = model.loop(data=dict(_loop_d=(1,2,3),_loop_e=(3,4,5),_loop_f=(5,6,7)))
b1.add_loop(l)
b2.add_loop(l2)
b5 = b1.difference(b2)
assert b5['_loop'] == l2
l = model.loop(data=OrderedDict((('_loop_a',(1,21,-13)),
('_loop_b',(-221.3,3.01,4.246)),
('_loop_c',("a","b","cc")))))
b = model.block()
b.add_loop(l)
cm = model.cif({'fred':b})
s = StringIO()
cm.show(out=s, loop_format_strings={'_loop':'% 4i% 8.2f %s'})
assert not show_diff(s.getvalue(),"""\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.30 a
21 3.01 b
-13 4.25 cc
""")
s = StringIO()
cm.show(out=s)
assert not show_diff(s.getvalue(),"""\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.3 a
21 3.01 b
-13 4.246 cc
""")
l.add_row((".", "?", "."))
s = StringIO()
cm.show(out=s)
assert not show_diff(s.getvalue(),"""\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.3 a
21 3.01 b
-13 4.246 cc
. ? .
""")
l.delete_row(index=1)
s = StringIO()
cm.show(out=s)
assert not show_diff(s.getvalue(),"""\
data_fred
loop_
_loop_a
_loop_b
_loop_c
1 -221.3 a
-13 4.246 cc
. ? .
""")
l2 = l.deepcopy()
l2.delete_row(index=0)
l2.delete_row(index=0)
l2.delete_row(index=0)
try: l2.show(out=s)
except AssertionError, e: pass
else: raise Exception_expected
l.clear()
try: l.show(out=s)
except AssertionError, e: pass
else: raise Exception_expected
#
loop = model.loop(data={"_a_1": ('string with spaces','nospaces'),
"_a_2": ('a', 'b')})
s = StringIO()
loop.show(out=s, align_columns=True)
assert not show_diff(s.getvalue(), """\
loop_
_a_1
_a_2
'string with spaces' a
nospaces b
""")
#
cb = model.block()
cm = model.cif()
cm["a"] = cb
cb["_b"] = ""
s = StringIO()
cm.show(out=s)
assert not show_diff(s.getvalue(), """\
data_a
_b ''
""")
#
loop = model.loop(data=OrderedDict((
("_entity_poly.entity_id", ('1', '2', '3')),
("_entity_poly.pdbx_seq_one_letter_code", (
"TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR",
"""\
IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM
THVFRLKKWIQKVIDQFGE""",
"NGDFEEIPEE(TYS)LQ",
)),
("_entity_poly.pdbx_seq_one_letter_code_can", (
"TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR",
"""\
IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM
THVFRLKKWIQKVIDQFGE""",
"NGDFEEIPEEYLQ",
)),
("_entity_poly.pdbx_strand_id", ('L', 'H', 'I'))
)))
s = StringIO()
loop.show(out=s, align_columns=True)
s.seek(0)
assert not show_diff("\n".join(l.rstrip() for l in s.readlines()),"""\
loop_
_entity_poly.entity_id
_entity_poly.pdbx_seq_one_letter_code
_entity_poly.pdbx_seq_one_letter_code_can
_entity_poly.pdbx_strand_id
1 TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR L
2
;
IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM
THVFRLKKWIQKVIDQFGE
;
;
IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM
THVFRLKKWIQKVIDQFGE
;
H
3 NGDFEEIPEE(TYS)LQ NGDFEEIPEEYLQ I\
""")
#
cb = model.block()
cm = model.cif()
cm["a"] = cb
cb["_a"] = '1 "a" 2'
cb["_b"] = "1 'b' 3"
cb["_c"] = "O1'"
cb["_d"] = 'O2"'
cb["_e"] = """1 'a' "b" 3"""
s = StringIO()
print >> s, cm
s.seek(0)
assert not show_diff("\n".join(l.rstrip() for l in s.readlines()), """\
data_a
_a '1 "a" 2'
_b "1 'b' 3"
_c O1'
_d O2"
_e
;
1 'a' "b" 3
;
""")
# verify that what we wrote out above is valid CIF and we can read it back in
cm2 = iotbx.cif.reader(input_string=s.getvalue()).model()
cb2 = cm2["a"]
assert cb2["_a"] == cb["_a"]
assert cb2["_b"] == cb["_b"]
assert cb2["_c"] == cb["_c"]
assert cb2["_d"] == cb["_d"]
assert cb2["_e"].strip() == cb["_e"]
#
cm = iotbx.cif.reader(input_string="""\
data_a
loop_
_pdbx_refine_tls_group.id
_pdbx_refine_tls_group.refine_tls_id
_pdbx_refine_tls_group.selection
_pdbx_refine_tls_group.selection_details
1 1 ? "chain 'A' and (resid 2 through 15 )"
2 2 ? "chain 'A' and (resid 16 through 26 )"
3 3 ? "chain 'A' and (resid 27 through 43 )"
4 4 ? "chain 'B' and (resid 1 through 14 )"
5 5 ? "chain 'B' and (resid 15 through 20 )"
""").model()
print cm
#
cif_block = model.block()
loop_a = model.loop(header=("_a.1", "_a.2"), data=(1,2,3,4,5,6))
cif_block.add_loop(loop_a)
assert cif_block.get_loop("_a") is loop_a
assert cif_block.get_loop("_b") is None
assert cif_block.get_loop("_b", default=loop_a) is loop_a
loop_a = cif_block.get_loop_with_defaults(
"_a", default_dict={"_a.2":".", "_a.3":"?", "_a.4":"."})
assert list(cif_block["_a.1"]) == ['1', '3', '5']
assert list(cif_block["_a.2"]) == ['2', '4', '6']
assert list(cif_block["_a.3"]) == ['?', '?', '?']
assert list(cif_block["_a.4"]) == ['.', '.', '.']
loop_a.add_row({"_a.3":"a", "_a.4":"b"})
loop_a.add_row({"_a.3":"c", "_a.4":"d"}, default_value=".")
assert list(cif_block["_a.1"]) == ['1', '3', '5', '?', '.']
assert list(cif_block["_a.2"]) == ['2', '4', '6', '?', '.']
assert list(cif_block["_a.3"]) == ['?', '?', '?', 'a', 'c']
assert list(cif_block["_a.4"]) == ['.', '.', '.', 'b', 'd']
#
cif_block = model.block()
cif_block['_a'] = """\
123
456"""
s = StringIO()
cif_block.show(out=s)
s.seek(0)
assert not show_diff("\n".join([l.strip() for l in s.readlines()]), """\
_a
;
123
456
;
""")
