smtbx.development
index
/net/chevy/raid1/nat/src/cctbx_project/smtbx/development.py

 
Modules
       
smtbx.refinement.constraints.adp
smtbx.refinement.constraints
cctbx.crystal
cctbx.array_family.flex
smtbx.refinement.constraints.geometrical.hydrogens
cctbx.development.random_structure
cctbx.xray

 
Classes
       
__builtin__.object
test_case
cctbx.development.random_structure.xray_structure(cctbx.xray.structure.structure)
random_xray_structure

 
class random_xray_structure(cctbx.development.random_structure.xray_structure)
    
Method resolution order:
random_xray_structure
cctbx.development.random_structure.xray_structure
cctbx.xray.structure.structure
cctbx.crystal.special_position_settings
cctbx.crystal.symmetry
__builtin__.object

Methods defined here:
__init__(self, space_group_info, u_iso_xor_u_aniso=True, **kwds)

Methods inherited from cctbx.development.random_structure.xray_structure:
build_scatterers(self, elements, sites_frac=None, grid=None, t_centre_of_inversion=None)
random_modify_fdp(self, fdp, gauss_sigma)
random_modify_fp(self, fp, gauss_sigma)
random_modify_occupancy(self, occupancy, gauss_sigma)
random_modify_parameters(self, parameter_name, gauss_sigma=0.1, vary_z_only=False)
random_modify_site(self, site, gauss_sigma, max_distance=0, vary_z_only=False, max_trials=100)
random_modify_u_iso(self, u_iso, gauss_sigma)
random_modify_u_star(self, u_star, gauss_sigma, max_relative_difference=0.3333333333333333, max_trials=100)

Methods inherited from cctbx.xray.structure.structure:
__getitem__(self, slice_object)
add_scatterer(self, scatterer, site_symmetry_ops=None, insert_at_index=None)
add_scatterers(self, scatterers, site_symmetry_table=None, non_unit_occupancy_implies_min_distance_sym_equiv_zero=False)
adjust_occupancy(self, occ_max, occ_min, selection=None)
Adjust site occupancy factor for selected sites to be between occ_min and
occ_max.
 
:param occ_max: maximal site occupancy factor
:type occ_max: float
:param occ_min: minimal site occupancy factor
:type occ_min: float
:param selection: an array of bools to select scatterers to be adjusted
:type selection: boolean[]
 
:returns: none
adjust_u_iso(self)
all_selection(self)
Get a selector array for all scatterers of the structure.
 
:returns: an array to select all scatterers of the structure
:rtype: boolean[]
apply_rigid_body_shift(self, rot, trans, selection=None, recompute_site_symmetries=True)
apply_rigid_body_shift_obj(self, sites_cart, sites_frac, rot, trans, selection, unit_cell, atomic_weights)
apply_shift(self, shift, recompute_site_symmetries=False)
apply_special_position_ops_d_target_d_site(self, d_target_d_site)
apply_symmetry_sites(self)
apply_symmetry_u_stars(self)
as_cif_block(self, covariance_matrix=None, cell_covariance_matrix=None)
as_cif_simple(self, out=None, data_name='global')
as_cns_sdb_file = xray_structure_as_cns_sdb_file(self, file=None, description=None, comment=None, action=None, segid=None, group=None)
as_emma_model(self)
as_pdb_file(self, remark=None, remarks=[], fractional_coordinates=False, resname=None, connect=None)
as_py_code(self, indent='')
eval(as_py_code()) is similar (but sometimes not identical)
to self and meant to enable quick formatting of self as Python code
for unit tests.
asu_mappings(self, buffer_thickness, asu_is_inside_epsilon=None)
asymmetric_unit_in_p1(self)
atom_names_selection(self, atom_names=['C', 'O', 'CA', 'N'], ignore_atoms_with_alternative_conformations=False, include_only_atoms_with_alternative_conformations=False)
Get a selector array for scatterers of the structure by "atom" names.
 
:param atom_names: list of labels of scatterers to select
:type atom_names: list(string)
:param ignore_atoms_with_alternative_conformations: select normal atoms/conformations only
:type ignore_atoms_with_alternative_conformations: boolean
:param include_only_atoms_with_alternative_conformations: select only scatterers with alternative conformations
:type include_only_atoms_with_alternative_conformations: boolean
 
:returns: an array to select the desired scatterers of the structure
:rtype: boolean[]
atomic_weights(self)
b_iso_min_max_mean(self)
Get the minimal, maximal and mean isotropic Debye-Waller/temperature/B     factors of all scatterers in this structure.
 
:returns: minimal b_iso, maximal b_iso, mean b_iso
:rtype: float, float, float
backbone_selection(self, atom_names=['C', 'O', 'CA', 'N'], ignore_atoms_with_alternative_conformations=False, include_only_atoms_with_alternative_conformations=False)
Get a selector array for scatterers of the backbone of the structure.
(This is just an alias for atom_names_selection.)
 
:param atom_names: list of labels of scatterers to select
:type atom_names: list(string)
:param ignore_atoms_with_alternative_conformations: select normal atoms/conformations only
:type ignore_atoms_with_alternative_conformations: boolean
:param include_only_atoms_with_alternative_conformations: select only scatterers with alternative conformations
:type include_only_atoms_with_alternative_conformations: boolean
 
:returns: an array to select the desired scatterers of the structure
:rtype: boolean[]
by_index_selection(self, selected_scatterers)
Get a selector array for scatterers with specified index from the
structure. For example you can select scatterers 1,4 and 5 by passing
(1,4,5) as argument.
 
:param selected_scatterers: list of scatterers to select
:type selected_scatterers: list(int)
 
:returns: an array to select the desired scatterers of the structure
:rtype: flex.bool[]
center_of_mass(self, atomic_weights=None)
change_basis(self, cb_op)
change_hand(self)
closest_distances(self, sites_frac, distance_cutoff, use_selection=None)
concatenate(self, other)
concatenate_inplace(self, other)
conservative_pair_proxies(self, bond_sym_table, conserve_angles)
convert_to_anisotropic(self, selection=None)
convert_to_isotropic(self, selection=None)
coordinate_degrees_of_freedom_counts(self, selection=None)
crystal_density(self)
Get the value of the diffraction-determined density for the crystal,
suitable for the CIF item _exptl_crystal_density_diffrn
 
Density values are calculated from the crystal cell and contents. The
units are megagrams per cubic metre (=grams per cubic centimetre).
 
Equivalent to:
  1.66042 * _chemical_formula_weight * _cell_formula_units_Z / _cell_volume
 
:returns: chemical density in megagrams per cubic metre (=grams per cm^3)
:rtype: float
crystal_symmetry(self)
Get crystal symmetry of the structure
 
:returns: a new crystal symmetry object
:rtype: cctbx.crystal.symmetry
cubic_unit_cell_around_centered_scatterers(self, buffer_size)
customized_copy(self, crystal_symmetry=<class libtbx.utils.Keep>, unit_cell=<class libtbx.utils.Keep>, space_group_info=<class libtbx.utils.Keep>, non_unit_occupancy_implies_min_distance_sym_equiv_zero=<class libtbx.utils.Keep>)
deep_copy_scatterers(self)
Create a deep copy of the structure with all scatterers
 
:returns: a new cctbx.xray.structure object
:rtype: cctbx.xray.structure
difference_vectors_cart(self, other)
discard_scattering_type_registry(self)
distances(self, other, selection=None)
Calculates pairwise distances between the atoms of this structure and
another structure with the same number of scatterers.
 
:param other: the other structure
:type other: cctbx.xray.structure
:param selection: an array of bools to select scatterers to be taken into     calculation
:type selection: boolean[]
 
:returns: an array of distances for the selected scatterers
:rtype: float[]
element_selection(self, *elements)
Get a selector array for scatterers of specified element type(s) of the structure.
 
:param elements: tuple of element symbols to select
:type elements: list(string) or set(string) or tuple(string)
 
:returns: an array to select the desired scatterers of the structure
:rtype: boolean[]
erase_scatterers(self)
Remove all scatterers from structure
 
:returns: none
expand_to_p1(self, append_number_to_labels=False, sites_mod_positive=False)
Get the current structure expanded into spacegroup P1.
This turns all symmetry induced scatterers into independent
individual scatterers. The expanded structure may have sites
with negative or > 1.0 coordinates. Use '.sites_mod_positive()'
or '.sites_mod_short()' on the result, or alternatively
set sites_mod_positive to 'True' in case you want to change this behaviour.
 
:param append_number_to_labels: If set to 'True' scatterers generated from     symmetry will be labelled with a numerical suffix
:type append_number_to_labels: boolean
:param sites_mod_positive: If set to 'True' xyz coordinates of the     scatterers will be kept inside [0,1[
:type sites_mod_positive: boolean
 
:returns: a new instance of the structure expanded into P1
:rtype: cctbx.xray.structure
extract_u_cart_plus_u_iso(self)
extract_u_iso_or_u_equiv(self)
f_000(self, include_inelastic_part=False)
Get the effective number of electrons in the crystal unit cell
contributing to F(000), suitable for the CIF item _exptl_crystal_F_000.
 
According to the CIF definition, this item **may** contain dispersion
contributions.
 
:param include_inelastic_part: If 'True' contributions due to dispersion     are included in F(000).
:type include_inelastic_part: boolean
 
:returns: F(000)
:rtype: float
grads_and_curvs_target_simple(self, miller_indices, da_db, daa_dbb_dab)
guess_scattering_type_is_a_mixture_of_xray_and_neutron(self)
guess_scattering_type_neutron(self)
hd_selection(self)
Get a selector array for all hydrogen and deuterium scatterers of the structure.
 
:returns: an array to select all H and D scatterers of the structure
:rtype: boolean[]
heavy_selection(self, ignore_atoms_with_alternative_conformations=False, include_only_atoms_with_alternative_conformations=False, only_protein=False)
Get a selector array for heavy (= non H or D) scatterers of the structure.
 
:param ignore_atoms_with_alternative_conformations: select normal atoms/conformations only
:type ignore_atoms_with_alternative_conformations: boolean
:param include_only_atoms_with_alternative_conformations: select only scatterers with alternative conformations
:type include_only_atoms_with_alternative_conformations: boolean
:param only_protein: select only protein scatterers
:type only_protein: boolean
 
:returns: an array to select the desired scatterers of the structure
:rtype: boolean[]
intersection_of_scatterers(self, i_seq, j_seq)
For a pair of scatterers, calculates their overlap given the coordinates
and displacement parameters (using adptbx.intersection).
is_positive_definite_u(self, u_cart_tolerance=None)
label_regex_selection(self, label_regex)
Get a selector array for scatterers of specified labels (via regular
expression) from the structure.
 
:param label_regex: a regular expression matching scatterer labels to select
:type label_regex: string or re
 
:returns: an array to select the desired scatterers of the structure
:rtype: boolean[]
label_selection(self, *labels)
Get a selector array for scatterers of specified labels from the structure.
 
:param labels: tuple of scatterer labels to select
:type labels: list(string) or set(string) or tuple(string)
 
:returns: an array to select the desired scatterers of the structure
:rtype: boolean[]
main_chain_selection(self, atom_names=['C', 'O', 'CA', 'N', 'CB'], ignore_atoms_with_alternative_conformations=False, include_only_atoms_with_alternative_conformations=False)
Get a selector array for scatterers of the main chain of the structure.
(This is just an alias for atom_names_selection with a different default selection.)
 
:param atom_names: list of labels of scatterers to select
:type atom_names: list(string)
:param ignore_atoms_with_alternative_conformations: select normal atoms/conformations only
:type ignore_atoms_with_alternative_conformations: boolean
:param include_only_atoms_with_alternative_conformations: select only scatterers with alternative conformations
:type include_only_atoms_with_alternative_conformations: boolean
 
:returns: an array to select the desired scatterers of the structure
:rtype: boolean[]
make_scatterer_labels_shelx_compatible_in_place(self)
max_distance(self, other, selection=None)
Calculates the maximum pairwise distance between the atoms of this
structure and another structure with the same number of scatterers.
 
:param other: the other structure
:type other: cctbx.xray.structure
:param selection: an array of bools to select scatterers to be taken into     calculation
:type selection: boolean[]
 
:returns: the maximum distance of two corresponding scatterers out of the     selected scatterers
:rtype: float
mean_distance(self, other, selection=None)
Calculates the arithmetic mean pairwise distance between the atoms
of this structure and another structure with the same number of scatterers.
 
:param other: the other structure
:type other: cctbx.xray.structure
:param selection: an array of bools to select scatterers to be taken into     calculation
:type selection: boolean[]
 
:returns: the mean pairwise distance of the selected scatterers
:rtype: float
mean_scattering_density(self)
min_distance(self, other, selection=None)
Calculates the minimum pairwise distance between the atoms of this
structure and another structure with the same number of scatterers.
 
:param other: the other structure
:type other: cctbx.xray.structure
:param selection: an array of bools to select scatterers to be taken into     calculation
:type selection: boolean[]
 
:returns: the minimum distance of two corresponding scatterers out of the     selected scatterers
:rtype: float
min_u_cart_eigenvalue(self)
n_grad_u_aniso(self)
n_grad_u_iso(self)
n_parameters(self, considering_site_symmetry_constraints=False)
n_undefined_multiplicities(self)
non_unit_occupancy_implies_min_distance_sym_equiv_zero(self)
orthorhombic_unit_cell_around_centered_scatterers(self, buffer_size)
pair_asu_table(self, distance_cutoff=None, asu_mappings_buffer_thickness=None, asu_is_inside_epsilon=None, min_cubicle_edge=5)
pair_sym_table_show(self, pair_sym_table, is_full_connectivity=False, out=None)
pair_sym_table_show_distances(self, pair_sym_table, show_cartesian=False, skip_j_seq_less_than_i_seq=False, skip_sym_equiv=False, out=None)
parameter_map(self)
peptide_dihedral_selection(self, atom_names=['C', 'CA', 'N'], ignore_atoms_with_alternative_conformations=False, include_only_atoms_with_alternative_conformations=False)
Get a selector array for peptide dihedral scatterers of the structure.
(This is just an alias for atom_names_selection with a different default selection.)
 
:param atom_names: list of labels of scatterers to select
:type atom_names: list(string)
:param ignore_atoms_with_alternative_conformations: select normal atoms/conformations only
:type ignore_atoms_with_alternative_conformations: boolean
:param include_only_atoms_with_alternative_conformations: select only scatterers with alternative conformations
:type include_only_atoms_with_alternative_conformations: boolean
 
:returns: an array to select the desired scatterers of the structure
:rtype: boolean[]
principal_axes_of_inertia(self, atomic_weights=None)
random_remove_sites_selection(self, fraction)
random_shift_sites(self, max_shift_cart=0.2)
re_apply_symmetry(self, i_scatterer)
replace_scatterers(self, scatterers, site_symmetry_table='existing')
replace_sites_cart(self, new_sites, selection=None)
replace_sites_frac(self, new_sites, selection=None)
rms_difference(self, other)
scale_adp(self, factor, selection=None)
Scale the atomic displacement parameters of the selected scatterers
of the structure with the specified factor.
If no selection is given, all scatterers will be handled as if selected.
 
:param factor: scale factor to apply to the adps of the selected scatterers
:type factor: float
:param selection: an array of bools to select the scatterers to have their     adps scaled
:type selection: boolean[]
 
:returns: none
scale_adps(self, scale_factor)
scatterer_flags(self)
scatterers(self)
Get all scatterers of the structure
 
:returns: a reference to an array of cctbx.xray.scatterer
:rtype: cctbx.xray.scatterer[]
scattering_dictionary_as_string(self)
scattering_type_registry(self, custom_dict=None, d_min=None, table=None, types_without_a_scattering_contribution=None, explicitly_allow_mixing=False)
scattering_types(self)
scattering_types_counts_and_occupancy_sums(self)
select(self, selection, negate=False)
select_inplace(self, selection)
selection_within(self, radius, selection)
set_b_iso(self, value=None, values=None, selection=None)
Set isotropic Debye-Waller/temperature/B factors with automatic conversion
to u_iso
 
:param value: a single double value to set all b_iso of selected     scatterers to
:type value: double
:param values: an array of double values to set all b_iso of selected     scatterers to
:type values: double[]
:param selection: an array of bools to select scatterers to be updated with     new b_iso values
:type selection: boolean[]
 
:returns: the modified base object
:rtype: cctbx.xray.structure
set_custom_inelastic_form_factors(self, table, set_use_fp_fdp=True, source='custom')
Expects a dictionary of tuples like 'C' : (fp, fdp). If an element is
not in the dictionary, the fp and fdp are reset to 0 and the use_fp_fdp is
set to false.
set_inelastic_form_factors(self, photon, table, set_use_fp_fdp=True)
set_occupancies(self, value, selection=None)
set_scatterer_flags(self, scatterer_flags)
set_sites_cart(self, sites_cart)
Set the the cartesian coordinates of all sites of the structure to     'sites_cart'.
 
:param sites_cart: a list of the cartesian coordinates for all scatterers
:type sites_cart: scitbx.array_family.flex.vec3_double
 
:returns: none
set_sites_frac(self, sites_frac)
Set the the fractional coordinates of all sites of the structure to     'sites_frac'.
 
:param sites_frac: a list of the fractional coordinates for all scatterers
:type sites_frac: scitbx.array_family.flex.vec3_double
 
:returns: none
set_u_cart(self, u_cart, selection=None)
set_u_iso(self, value=None, values=None, selection=None)
Set isotropic mean thermic displacements of scatterers
 
:param value: a single double value to set all u_iso of selected     scatterers to
:type value: double
:param values: an array of double values to set all u_iso of selected     scatterers to
:type values: double[]
:param selection: an array of bools to select scatterers to be updated     with new u_iso values
:type selection: boolean[]
 
:returns: the modified base object
:rtype: cctbx.xray.structure
shake_adp(self, b_max=None, b_min=None, spread=10.0, aniso_spread=0.1, keep_anisotropic=False, random_u_cart_scale=1.0, selection=None)
shake_adp_if_all_equal(self, b_iso_tolerance=0.1)
shake_occupancies(self, selection=None)
shake_sites_in_place(self, rms_difference=None, mean_distance=None, selection=None, allow_all_fixed=False, random_double=None)
Shake the coordinates of the selected scatterers in this structure.
 
:param rms_difference: radial mean square displacement (>=0) to apply to     selected scatterers
:type rms_difference: float
:param mean_distance: a mean distance shift (>=0) to apply to selected     scatterers
:type mean_distance: float
:param selection: an array of bools to select scatterers to be shaken
:type selection: boolean[]
:param allow_all_fixed: if set to 'True' shaking a structure with all     scatterers on fixed special positions will not cause an error
:type allow_all_fixed: boolean
:param random_double: "random" numbers to use for displacements
:type random_double: float[]
 
:returns: 'True' if at least one scatterer was moved, 'False' otherwise
:rtype: boolean
shift_occupancies(self, q_shift, selection=None)
shift_sites_in_place(self, shift_length, mersenne_twister=None)
Shifts the coordinates of all scatterers in this structure.
 
:param shift_length: the distance to shift each scatterer with
:type shift_length: float
:param mersenne_twister: a mersenne twister to use as entropy source
:type mersenne_twister: flex.mersenne_twister
 
:returns: none
shift_us(self, u_shift=None, b_shift=None, selection=None)
show_angles(self, distance_cutoff=None, asu_mappings_buffer_thickness=None, asu_is_inside_epsilon=None, pair_asu_table=None, keep_pair_asu_table=False, out=None)
show_distances(self, distance_cutoff=None, asu_mappings_buffer_thickness=None, asu_is_inside_epsilon=None, min_cubicle_edge=5, pair_asu_table=None, show_cartesian=False, keep_pair_asu_table=False, out=None)
show_scatterer_flags_summary(self, out=None)
show_scatterers(self, f=None, special_positions_only=False)
show_special_position_shifts(self, sites_frac_original=None, sites_cart_original=None, out=None, prefix='')
show_summary(self, f=None, prefix='')
show_u_statistics(self, text='', out=None, use_hydrogens=False)
site_symmetry_table(self)
sites_cart(self)
Get the the cartesian coordinates of all sites of the structure.
 
:returns: a list of the sites of the structure in cartesian coordinates
:rtype: scitbx.array_family.flex.vec3_double
sites_frac(self)
sites_mod_positive(self)
Get the current structure converted into a structure with x,y,z of all
scatterers in the interval [0,1[
 
:returns: the same instance of the structure with only posive coordinates     of its scatterers
:rtype: cctbx.xray.structure
sites_mod_short(self)
Get the current structure converted into a structure with short
coordinates vectors of all scatterers
 
:returns: the same instance of the structure with only short coordinates     vectors of its scatterers
:rtype: cctbx.xray.structure
sort(self, by_value='occupancy', reverse=False)
special_position_indices(self)
structure_factors(self, anomalous_flag=None, d_min=None, algorithm=None, cos_sin_table=False, quality_factor=None, u_base=None, b_base=None, wing_cutoff=None)
Calculate structure factors for the current scatterers using either direct
summation or FFT method; by default the appropriate method will be guessed
automatically.
 
:param anomalous_flag: toggles whether the returned structure factors are
  anomalous or not
:type anomalous_flag: bool
:param d_min: resolution cutoff (required)
:type d_min: float
:param algorithm: specifies 'direct' or 'fft', or if None (default), the
  algorithm will be chosen automatically
:type algorithm: str or None
:param cos_sin_table: if True, uses interpolation of values from a
  pre-calculated lookup table for trigonometric function calls in the
  structure factor calculations in preference to calling the system
  libraries
:type cos_sin_table: bool
:param quality_factor: determines accuracy of sampled density in fft method
:type quality_factor: float
:param u_base: additional smearing B-factor for scatterers which have too
  small Bs so they fall between the grid nodes
:type u_base: float
:param b_base: same as u_base (but 8*pi^2 larger)
:type b_base: float
:param wing_cutoff: is how far away from atomic center you sample density
  around atom
:type wing_cutoff: float
 
:returns: a custom Python object (exact type depends on method used), from
  which f_calc() may be called
:rtype: derived from cctbx.xray.structure_factors.manager.managed_calculation_base
switch_to_neutron_scattering_dictionary(self)
tidy_us(self, u_min=1e-06, u_max=6.965831375410722, anisotropy_min=0.25)
Clean up atomic displacements so they fall within a sensible range (this
is especially important when writing out PDB format).
translate(self, x=0, y=0, z=0)
Translates all scatterers of this structure by x,y,z.
 
:param x: x component of the translation vector
:type x: float
:param y: y component of the translation vector
:type y: float
:param z: z component of the translation vector
:type z: float
 
:returns: a new translated copy of the structure
:rtype: cctbx.xray.structure
truncate_at_pdb_format_precision(self)
unit_cell_content(self, omit=None)
The content of the unit cell as a chemical formula
use_u_aniso(self)
use_u_iso(self)

Class methods inherited from cctbx.xray.structure.structure:
from_cif(cls, file_object=None, file_path=None, data_block_name=None) from __builtin__.type
from_shelx(cls, *args, **kwds) from __builtin__.type

Methods inherited from cctbx.crystal.special_position_settings:
assert_min_distance_sym_equiv(self)
incremental_pairs(self, distance_cutoff, asu_is_inside_epsilon=None, asu_mappings_buffer_thickness=-1, cubicle_epsilon=-1)
min_distance_sym_equiv(self)
pair_generator(self, distance_cutoff, sites_frac=None, sites_cart=None, site_symmetry_table=None, asu_mappings_buffer_thickness=None, asu_is_inside_epsilon=None, minimal=False)
site_cluster_analysis(self, min_distance=None, min_cross_distance=None, min_self_distance=None, general_positions_only=False, estimated_reduction_factor=4, asu_is_inside_epsilon=None, asu_mappings_buffer_thickness=-1, min_cubicle_edge=5, cubicle_epsilon=-1)
site_symmetry(self, site=None, site_cart=None)
sym_equiv_sites(self, site)
u_star_tolerance(self)
xray_structure(self, scatterers=None)

Methods inherited from cctbx.crystal.symmetry:
as_reference_setting(self)
average_b_cart(self, b_cart)
average_u_cart(self, u_cart)
best_cell(self, angular_tolerance=None)
build_miller_set(self, anomalous_flag, d_min, d_max=None)
cell_equivalent_p1(self)
change_of_basis_op_to_best_cell(self, angular_tolerance=None, best_monoclinic_beta=True)
change_of_basis_op_to_inverse_hand(self)
change_of_basis_op_to_minimum_cell(self)
change_of_basis_op_to_niggli_cell(self, relative_epsilon=None, iteration_limit=None)
change_of_basis_op_to_primitive_setting(self)
change_of_basis_op_to_reference_setting(self)
direct_space_asu(self)
gridding(self, d_min=None, resolution_factor=None, step=None, symmetry_flags=None, mandatory_factors=None, max_prime=5, assert_shannon_sampling=True)
inverse_hand(self)
is_compatible_unit_cell(self)
is_patterson_symmetry(self)
is_similar_symmetry(self, other, relative_length_tolerance=0.01, absolute_angle_tolerance=1.0)
join_symmetry(self, other_symmetry, force=False, raise_sorry_if_incompatible_unit_cell=False)
miller_set(self, indices, anomalous_flag)
minimum_cell(self)
niggli_cell(self, relative_epsilon=None, iteration_limit=None)
patterson_symmetry(self)
primitive_setting(self)
reflection_intensity_symmetry(self, anomalous_flag)
space_group(self)
space_group_info(self)
special_position_settings(self, min_distance_sym_equiv=0.5, u_star_tolerance=0, assert_min_distance_sym_equiv=True)
subtract_continuous_allowed_origin_shifts(self, translation_cart)
unit_cell(self)

Data descriptors inherited from cctbx.crystal.symmetry:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class test_case(__builtin__.object)
     Class methods defined here:
run(cls, verbose=False, *args, **kwds) from __metaclass__

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
__metaclass__ = <class 'smtbx.development.__metaclass__'>
exercises = []

 
Functions
       
generate_hydrogen_constraints(structure, connectivity_table)
sucrose()

 
Data
        division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)