Trees       Indices       Help   
2017-2 Schrodinger Python API
Package schrodinger :: Package application :: Package matsci :: Package nano :: Module xtal
[hide private]
[frames] | no frames]

Module xtal

Classes and functions for creating crystals by unit cell.

Copyright Schrodinger, LLC. All rights reserved.

Classes [hide private]
  ParserWrapper
Manages the argparse module to parse user command line arguments.
  CheckInput
Check user input.
  CrystalSystems
Manage the properties of the seven crystal systems.
  SpaceGroup
Collect the properties of a space group.
  SpaceGroups
Manage space group objects.
  Crystal
Main class for generating crystals.
  PBCBond
Class to manage a PBC bond, i.e.
  PBCBonds
Class to manage a collection of PBC bonds.
Functions [hide private]
bool
is_infinite(astructure)
Return a boolean indicating whether the given structure is infinitely bonded, meaning that it has bonds that cross the periodic boundary which can not be eliminated by means of molecule contraction.
 
store_chorus_box_props(struct, ax, ay=0.0, az=0.0, bx=0.0, by=None, bz=0.0, cx=0.0, cy=0.0, cz=None)
Add properties to the structure that define the periodic boundary condition in the way Desmond wants it defined.
 
clear_asu_and_fractional_properties(struct)
Clear the atomic ASU and Fractional coordinate properties
dict
get_cov_radii()
Return a dictionary of atomic covalent radii.
list
get_params_from_vectors(a_vec, b_vec, c_vec)
Return the lattice parameters from the given lattice vectors.
numpy.array, numpy.array, numpy.array
get_lattice_vectors(a_param, b_param, c_param, alpha_param, beta_param, gamma_param)
Get the lattice vectors of the specified parallelepiped.
dict
delete_duplicate_atoms(astructure, atoms_to_check=None, duplicate_thresh=0.25, transform=None, fract_offset=0.0001)
Delete duplicate atoms that are within the defined threshold.
float
max_connect_distance(cov_rad_a, cov_rad_b, cov_factor=1.0, cov_offset=0.45)
Return the maximum bonding distance for the given covalent radii and distance equation parameters.
list, dict, dict
connect_atoms(astructure, atoms_to_connect=None, cov_min=0.4, cov_offset=0.45, cov_factor=1.0, delete_existing=True, organic_structure=None, cov_radii_props=True, pbc_bonding=True, only_pbc_bonds=False, check_also_reg_bond=False)
Connect the atoms in a structure.
bool
before_lower_edge(coord, lower_bound)
Return True if this fractional coordinate value is before the lower edge of the cell.
bool
on_lower_edge(coord, lower_bound, fract_offset=0.0001)
Return True if this fractional coordinate value is on the lower edge of the cell.
bool
inside_cell(coord, lower_bound, upper_bound, fract_offset=0.0001)
Return True if this fractional coordinate value is inside the cell.
bool
on_upper_edge(coord, lower_bound, fract_offset=0.0001)
Return True if this fractional coordinate value is on the upper edge of the cell.
bool
after_upper_edge(coord, lower_bound, fract_offset=0.0001)
Return True if this fractional coordinate value is after the upper edge of the cell.
 
translate_to_cell(astructure, fract_offset=0.0001, origin=[0.0, 0.0, 0.0], transform=None, extents=None)
Translate the fractional coordinate definitions of the atoms of the given structure so that they are all in the cell defined with the given origin and given extents and optionally also actually transform the Cartesian coordinates of the atoms using the specified fractional-to-Cartesian transform.
 
trans_atoms_fract_to_cart(astructure, transform)
Transform the atoms in a structure from the fractional basis to the Cartesian basis.
 
trans_atoms_cart_to_fract(astructure, transform)
Transform the atoms in a structure from the Cartesian basis to the fractional basis.
int
get_gcd_list_ints(list_of_ints)
Return the greatest common divisor (GCD) of a list of integers.
bool
is_organic_structure(astructure, percent_metal_threshold=25.0)
Return True if the structure contains more than one type of element and no more than the given percentage of metal elements.
bool
is_closed_shell_organic_structure(astructure, percent_metal_threshold=25.0)
Return True if the structure is both organic and closed shell, i.e.
bool
has_organic_molecule(astructure, percent_metal_threshold=25.0)
Return True if the provided structure contains at least one organic molecule.
bool
has_closed_shell_organic_molecule(astructure, percent_metal_threshold=25.0)
Return True if the provided structure contains at least one closed-shell organic molecule.
bool
has_closed_shell_organic_molecules(astructure, percent_metal_threshold=25.0)
Return True if the provided structure contains only closed-shell organic molecules.
list
get_carts_from_anchor_string(anchor)
Return the Cartesian coordinates from the given 's_mae_pbc_position' anchor string, i.e.
three numpy.array
get_reciprocal_lattice_vectors(a_vec, b_vec, c_vec)
Return the reciprocal lattice vectors.
int
get_collapsed_index(abc, alimit, blimit, climit)
Given a three dimensional grid of integers defined on [1, limit] for the given a, b, and c limits and a traversal path of c then b then a return the number of integers traversed in order to reach the given abc integer index triple.
int
modified_sawtooth(n, x)
Given a positive integer variable x in [0, n+1] return a signal from a modified sawtooth function.
schrodinger.Structure.structure
assign_bond_orders(astructure, logger=None)
Return a copy of the input structure that has bond orders assigned.
 
fix_metal_bonding(astructure)
Fix metal bonding in the given structure.
schrodinger.Structure.structure
assign_bond_orders_w_mmlewis(astructure, fix_metals=True, logger=None)
Return a copy of the input structure that has bond orders assigned.
tuple
get_chorus_properties(astructure)
Return a tuple containing the nine chorus properties of the given structure.
list
get_params_from_chorus(chorus_properties)
Return the a, b, c, alpha, beta, and gamma lattice properties from the nine chorus properties.
list
get_chorus_from_params(params)
Return the nine chorus properties, i.e.
float
get_volume_from_params(params)
Return cell volume (in Angstrom^3) from cell parameters.
float
get_volume_from_vecs(vecs)
Return cell volume (in Angstrom^3) from lattice vectors.
set
get_cell_pairs(astructure, cell_distance, pbc_bonding=True, atom_indices=None, chorus_properties=None)
Using a distance cell that optionally honors a PBC return a list of tuples of atom index pairs that are within the specified distance.
 
add_labeled_pbc_bond(astructure, atom1, atom2, order, is_pbc_bond=False, also_reg_bond=False, color=4)
Add the specified bond to the provided structure and label it depending on if it is a PBC bond.
int
get_natom_btw_two_cells(cell1, cell2, extents, size)
Using a traversal path of c then b then a, return the number of atoms between two cells, of the given size, in a super cell with the given extents.
 
delete_pbc_bonds(astructure)
Delete any PBC bonds from the given structure.
tuple
is_pbc_bond(astructure, atom1, atom2, check_also_reg_bond=False, unit_lattice_vectors=None)
Return a (is_pbc_bond, also_reg_bond, bond_distance) tuple that indicates (1) whether the specified bond is a PBC bond, (2) if checked whether that PBC bond is also a regular bond, and (3) the bond length.
tuple
get_lattice_param_properties(astructure)
Return a tuple containing the six lattice parameter properties of the given structure.
dict
get_normalized_spanning_vectors(lattice_vectors)
Return the thirteen unique normalized spanning vectors for the cell.
int
get_element_priority(pair)
Return the formula ordering priority of the element in the given pair.
str
get_unit_cell_formula(unit_cell)
Return the formatted unit cell formula of the given unit cell.
numpy.array
trans_cart_to_fract(cart_vec, a_param, b_param, c_param, alpha_param, beta_param, gamma_param)
Transform the given vector in the Cartesian basis to the fractional basis.
numpy.array
trans_fract_to_cart(fract_vec, a_param, b_param, c_param, alpha_param, beta_param, gamma_param)
Transform the given vector in the fractional basis to the Cartesian basis.
numpy array
trans_cart_to_frac_from_vecs(coords, a_vec, b_vec, c_vec, rec=False)
Transform coordinates from (reciprocal) Cartesian to (reciprocal) fractional using lattice vectors.
numpy array
trans_frac_to_cart_from_vecs(coords, a_vec, b_vec, c_vec, rec=False)
Transform coordinates from (reciprocal) fractional to (reciprocal) Cartesian using lattice vectors.
schrodinger.structure.Structure
get_cell(asu, space_group=None, lattice_params=None, extents=None, xtal_kwargs=None)
Build and return a crystalline cell using the given asymmetric unit, space group, lattice parameters, and extents.
list
get_vectors_from_chorus(astructure)
Return the three lattice vectors from the nine lattice chorus properties.
tuple of matrices
get_conv_from_vecs(a_vec, b_vec, c_vec)
Generate matrices to convert from fractional to Cartesian and back.
 
create_new_box(struct)
Create a new box that is large enough to encompass the X, Y and Z lengths of the system
 
set_lattice_properties(astructure, lattice_properties)
Set the given lattice properties on the structure.
schrodinger.structure.Structure
make_p1(astructure, logger=None)
Make a P1 cell.
structure.Structure or bool
sync_pbc(st, create_pbc=False)
Return the given structure with a synchronized PBC, if create_pbc is True and the structure lacks a PBC then one will be created, otherwise this function will return False if there is no PBC.
dict
get_pbc_bonds_dict(astructure)
Return a PBC bonds dict for the given structure.
 
set_representation_bond(abond)
Set the representation of the given bond.
 
set_pbc_properties(astructure, chorus_properties)
Set the chorus and PDB properties on the given structure using the given chorus properties.
 
transform_pbc(struct_in, supercell_matrix, scale_only=False, cell_only=False, origin_shift=None)
Create a new structure based on the transformation matrix.
list of three ints
get_simple_supercell_matrix(supercell_matrix)
Get minimal diagonal elements of a simple supercell matrix starting from (non)-diagonal supercell matrix.
structure.Structure
get_simple_supercell(struct, supercell_matrix)
Get supercell structure.
3 x 3 float list
get_transformation_matrix(vecs, new_vecs)
Get transformation matrix between old and new set of lattice vectors.
 
set_physical_properties(struct)
Set cell formula, volume and density to struct.
structure.Structure
move_atoms_into_cell(struct, frac_coords=None, overlap_tresh=0.25, fract_offset=0.0001)
Get structure with all the atoms moved into the first cell.
list of tuples
get_unit_lattice_vector_info(astructure)
Return a list of tuples containing unit lattice vector information, i.e.
 
label_pbc_bonds(astructure)
Label PBC bonds.
 
label_pbc_bond(abond, also_reg_bond=False, color=4)
Label this PBC bond.
SpaceGroup, namedtuple or None, namedtuple
get_spg_from_spglib(space_groups, spg_type_in, spg_symm, double_named_groups=set(['Bbcb', 'Bbeb', 'Pcna', 'Pmnm', 'Pncb', 'Pnmm']))
Get space group from mmspg given space group type obtained from spglib.
bool
equal_rotations(rotations1, rotations2)
Check if rotations are equal.
str or None
assign_space_group(struct_in, symprec=0.01, space_groups=None, update_title=False)
Set space group and space group id to the input structure.
bool, matrix 3 x 3 of integers
get_normal_surf_from_HKL(hkl, vecs, max_normal_search=10, normal_c=True)
Calculate transformation matrix with c-axis most normal to a-b plane from HKL plane indices and lattice vectors.
int
lcm(numbers)
Get the lowest common multiple of a sequence of numbers.
list of integers
reduce_vector(vector)
Get reduced vector of a transformation matrix.
list of symmetry operators
get_symmops_from_spglib(symm)
Get set of symmetry operators from a set of rotations and translations.
schrodinger.structure.Structure
get_struct_from_CIF(cif_fn)
Get structure from CIF file.
Variables [hide private]
  __doc__ = ...
  _version = '$Revision 0.0 $'
  PRESERVE_BONDING_KEY = 'b_matsci_Preserve_Bonding'
  P1_SPACE_GROUP_SYMBOL = 'P 1'
  P1_SPACE_GROUP_ID = 1
  COV_RADIUS_KEY = 'r_matsci_COV_radius/Ang.'
  FRACT_OFFSET = 0.0001
  PERCENT_METAL_THRESHOLD = 25.0
  OVERLAP_ATOM_THRESHOLD = 0.25
  METAL_ASL = 'metals'
  PROTEIN_ASL = 'protein'
  MMPDB_MAX_ELEMENTS = 103
  AHEAD_BASE_TRIPLES = [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
  AHEAD_TRIPLES = [(1, 0, 0), (0, 1, 0), (0, 0, 1), (0, 1, 1), (...
  LATTICE_PARAMS_KEYS = ['a_param', 'b_param', 'c_param', 'alpha...
  EXTENTS_KEYS = ['ncella', 'ncellb', 'ncellc']
  ATOM_TO_BOND_REPR_DICT = {0: 1, 1: 1, 2: 2, 3: 3}
  PBC_POSITION_KEY = 's_mae_pbc_position'
  CENTER_PBC_POSITION = 'center_structure'
  ANCHOR_PREFIX = 'anchor_'
  ANCHOR_PBC_POSITION = 'anchor_%s_%s_%s'
  SPGLIB_DOUBLY_NAMED_SHORT = set(['Bbcb', 'Bbeb', 'Pcna', 'Pmnm...
  ASSIGN_SPG_SYMPREC = 0.01
  NORMAL_SURF_HKL_THR = 1e-08
  SPG_TO_HALL_NUMBER = [1, 2, 3, 6, 9, 18, 21, 30, 39, 57, 60, 6...
  SYMMOP_ROUND = 2
  LAST_ELEMENTS = ('H', 'C', 'N', 'O', 'F', 'P', 'S', 'Cl', 'Se'...
  MMPDB_COV_RADII = {1: 0.32, 2: 0.93, 3: 1.23, 4: 0.9, 5: 0.82,...
  MAX_MMPDB_COV_RADIUS = 2.6
  __package__ = 'schrodinger.application.matsci.nano'
Function Details [hide private]

is_infinite(astructure)

 

Return a boolean indicating whether the given structure is infinitely bonded, meaning that it has bonds that cross the periodic boundary which can not be eliminated by means of molecule contraction. If any molecule in the given structure is infinitely bonded then the structure itself is considered infinite. As examples of infinite systems consider graphene, gold, infinite polymer, etc.

Parameters:
Returns: bool
True if infinite, False otherwise
Raises:
  • ValueError - if there is an issue with the input

store_chorus_box_props(struct, ax, ay=0.0, az=0.0, bx=0.0, by=None, bz=0.0, cx=0.0, cy=0.0, cz=None)

 

Add properties to the structure that define the periodic boundary condition in the way Desmond wants it defined.

Parameters:
  • struct (schrodinger.structure.Structure) - The structure to add the properties to
  • ax - The value of the ax box property
  • ay - The value of the ay box property. Defaults to 0.
  • az - The value of the az box property. Defaults to 0.
  • bx - The value of the bx box property. Defaults to 0.
  • by - The value of the by box property. If not given, this value is set the same as ax.
  • bz - The value of the bz box property. Defaults to 0.
  • cx - The value of the cx box property. Defaults to 0.
  • cy - The value of the cy box property. Defaults to 0.
  • cz - The value of the cz box property. If not given, this value is set the same as ax.

clear_asu_and_fractional_properties(struct)

 

Clear the atomic ASU and Fractional coordinate properties

Parameters:

get_cov_radii()

 

Return a dictionary of atomic covalent radii.

Returns: dict
dictionary where keys are atomic numbers and values are atomic covalent radii in Angstrom

get_params_from_vectors(a_vec, b_vec, c_vec)

 

Return the lattice parameters from the given lattice vectors.

Parameters:
  • a_vec (numpy.array) - the a lattice vector
  • b_vec (numpy.array) - the b lattice vector
  • c_vec (numpy.array) - the c lattice vector
Returns: list
contains the a, b, c, alpha, beta, and gamma parameters

get_lattice_vectors(a_param, b_param, c_param, alpha_param, beta_param, gamma_param)

 

Get the lattice vectors of the specified parallelepiped.

Parameters:
  • a_param (float) - the length of the parallelepiped along edge a
  • b_param (float) - the length of the parallelepiped along edge b
  • c_param (float) - the length of the parallelepiped along edge c
  • alpha_param (float) - the angle between edges b and c
  • beta_param (float) - the angle between edges a and c
  • gamma_param (float) - the angle between edges a and b
Returns: numpy.array, numpy.array, numpy.array
the lattice vectors of the parallelepiped

delete_duplicate_atoms(astructure, atoms_to_check=None, duplicate_thresh=0.25, transform=None, fract_offset=0.0001)

 

Delete duplicate atoms that are within the defined threshold. Of the redundant atoms that with the lowest index is kept. If transform is not None then this function will use the periodic boundary conditions defined in transform when determining redundant atoms.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object from which the duplicate atoms will be deleted
  • atoms_to_check (set) - indices of atoms that are to be checked for duplicate copies, for a given redundant set of atoms any index can be passed in
  • duplicate_thresh (float) - distance used to define duplicate atoms, conservatively chosen based on considering the resolutions of some crystal structures and the wavelengths of light used to obtain the diffraction patterns
  • transform (numpy.array or None) - if not None then specifies that the Cartesians also be transformed using this fractional-to-Cartesian transformation matrix
  • fract_offset (float) - the threshold used to compare floating point fractional coordinate values and in particular those that are on the cell boundary
Returns: dict
renumber_map, keys are original indices, values are new indices or None if the atom was deleted

max_connect_distance(cov_rad_a, cov_rad_b, cov_factor=1.0, cov_offset=0.45)

 

Return the maximum bonding distance for the given covalent radii and distance equation parameters.

Parameters:
  • cov_rad_a (float) - covalent radii for atom a
  • cov_rad_b (float) - covalent radii for atom b
  • cov_factor (float) - the maximum distance for a connection is the sum of the covalent radii of the two atoms weighted by this factor plus the cov_offset in angstrom, increasing this value will increase the number of connections, this value is unit-less
  • cov_offset (float) - the maximum distance for a connection is the sum of the covalent radii of the two atoms weighted by cov_factor plus this offset in angstrom, increasing this value will increase the number of connections
Returns: float
the maximum bonding distance

connect_atoms(astructure, atoms_to_connect=None, cov_min=0.4, cov_offset=0.45, cov_factor=1.0, delete_existing=True, organic_structure=None, cov_radii_props=True, pbc_bonding=True, only_pbc_bonds=False, check_also_reg_bond=False)

 

Connect the atoms in a structure.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object for which the connections are wanted
  • atoms_to_connect (list) - atom indices to consider connecting, if None then all atoms will be considered
  • cov_min (float) - the minimum distance for a connection in angstrom
  • cov_offset (float) - the maximum distance for a connection is the sum of the covalent radii of the two atoms weighted by cov_factor plus this offset in angstrom, increasing this value will increase the number of connections
  • cov_factor (float) - the maximum distance for a connection is the sum of the covalent radii of the two atoms weighted by this factor plus the cov_offset in angstrom, increasing this value will increase the number of connections, this value is unit-less
  • delete_existing (bool) - indicates whether existing connections should first be deleted, i.e. any bonds to atoms in atoms_to_connect will be deleted
  • organic_structure (bool or None) - True if this structure is known to be organic, False if this structure is known to not be organic, and None if it is unknown in which case it will be determined, this information is used to assign single, rather than zero-order, bonds for metal atoms in non-organic structures
  • cov_radii_props (bool) - set the atomic covalent radii used in the connectivity protocol as atom properties
  • pbc_bonding (bool) - if True and if the input structure has the chorus properties defined, then PBC bonds will be created
  • only_pbc_bonds (bool) - if True then only PBC bonds will be created, i.e. regular bonds will not be created
  • check_also_reg_bond (bool) - if True then PBC bonds will be checked to see if they are also regular bonds, meaning that one of the atoms of the PBC bond is covalently bound to two copies of the other atom, one inside the cell and one outside the cell
Returns: list, dict, dict
maximally_bonded_atoms, contains the indices of any maximally bonded atoms, there is currently a hard coded limit on the number of bonds an atom can have according to mm.MMCT_MAXBOND which has a value of 16, and two dictionaries (one for regular bonds and one for PBC bonds) where keys are tuples of bonding atom indices and values are bond orders (for regular bonds) or tuples of bond orders and booleans indicating whether the PBC bond is also a regular bond (for PBC bonds)

before_lower_edge(coord, lower_bound)

 

Return True if this fractional coordinate value is before the lower edge of the cell.

Parameters:
  • coord (float) - the fractional coordinate being tested
  • lower_bound (float) - the lower bound for this fractional coordinate
Returns: bool
True if the coordinate is before the lower edge, False otherwise

on_lower_edge(coord, lower_bound, fract_offset=0.0001)

 

Return True if this fractional coordinate value is on the lower edge of the cell.

Parameters:
  • coord (float) - the fractional coordinate being tested
  • lower_bound (float) - the lower bound for this fractional coordinate
  • fract_offset (float) - used to make floating point comparisons
Returns: bool
True if the coordinate is on the lower edge, False otherwise

inside_cell(coord, lower_bound, upper_bound, fract_offset=0.0001)

 

Return True if this fractional coordinate value is inside the cell.

Parameters:
  • coord (float) - the fractional coordinate being tested
  • lower_bound (float) - the lower bound for this fractional coordinate
  • upper_bound (float) - the upper bound for this fractional coordinate
  • fract_offset (float) - used to make floating point comparisons
Returns: bool
True if the coordinate is inside the cell, False otherwise

on_upper_edge(coord, lower_bound, fract_offset=0.0001)

 

Return True if this fractional coordinate value is on the upper edge of the cell.

Parameters:
  • coord (float) - the fractional coordinate being tested
  • lower_bound (float) - the lower bound for this fractional coordinate
  • fract_offset (float) - used to make floating point comparisons
Returns: bool
True if the coordinate is on the upper edge, False otherwise

after_upper_edge(coord, lower_bound, fract_offset=0.0001)

 

Return True if this fractional coordinate value is after the upper edge of the cell.

Parameters:
  • coord (float) - the fractional coordinate being tested
  • lower_bound (float) - the lower bound for this fractional coordinate
  • fract_offset (float) - used to make floating point comparisons
Returns: bool
True if the coordinate is after the upper edge, False otherwise

translate_to_cell(astructure, fract_offset=0.0001, origin=[0.0, 0.0, 0.0], transform=None, extents=None)

 

Translate the fractional coordinate definitions of the atoms of the given structure so that they are all in the cell defined with the given origin and given extents and optionally also actually transform the Cartesian coordinates of the atoms using the specified fractional-to-Cartesian transform.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object whose atoms will be translated
  • fract_offset (float) - the threshold used to compare floating point fractional coordinate values and in particular those that are on the cell boundary
  • origin (list) - the origin of the cell to which to translate in fractional coordinates
  • transform (numpy.array or None) - if not None then specifies that the Cartesians also be transformed using this fractional-to-Cartesian transformation matrix
  • extents (list) - the number of cells along each lattice vector

trans_atoms_fract_to_cart(astructure, transform)

 

Transform the atoms in a structure from the fractional basis to the Cartesian basis.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object to be transformed
  • transform (numpy.array) - the fractional-to-Cartesian transformation matrix

trans_atoms_cart_to_fract(astructure, transform)

 

Transform the atoms in a structure from the Cartesian basis to the fractional basis.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object to be transformed
  • transform (numpy.array) - the Cartesian-to-fractional transformation

get_gcd_list_ints(list_of_ints)

 

Return the greatest common divisor (GCD) of a list of integers.

Parameters:
  • list_of_ints (list) - the list of ints for which the GCD is desired
Returns: int
gcd, the GCD

is_organic_structure(astructure, percent_metal_threshold=25.0)

 

Return True if the structure contains more than one type of element and no more than the given percentage of metal elements.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object to be tested
  • percent_metal_threshold (float) - a structure can contain up to this percentage of metal elements and still be considered organic
Returns: bool
True if organic, False otherwise

is_closed_shell_organic_structure(astructure, percent_metal_threshold=25.0)

 

Return True if the structure is both organic and closed shell, i.e. all non-metal atoms have complete valencies. Note that proteins are automatically considered closed-shell to safeguard against the possible lack of hydrogens.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object to be tested
  • percent_metal_threshold (float) - a structure can contain up to this percentage of metal elements and still be considered organic
Returns: bool
True if closed shell organic, False otherwise

has_organic_molecule(astructure, percent_metal_threshold=25.0)

 

Return True if the provided structure contains at least one organic molecule.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object to be tested
  • percent_metal_threshold (float) - a structure can contain up to this percentage of metal elements and still be considered organic
Returns: bool
True if the structure has an organic molecule

has_closed_shell_organic_molecule(astructure, percent_metal_threshold=25.0)

 

Return True if the provided structure contains at least one closed-shell organic molecule.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object to be tested
  • percent_metal_threshold (float) - a structure can contain up to this percentage of metal elements and still be considered organic
Returns: bool
True if the structure has a closed-shell organic molecule

has_closed_shell_organic_molecules(astructure, percent_metal_threshold=25.0)

 

Return True if the provided structure contains only closed-shell organic molecules.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object to be tested
  • percent_metal_threshold (float) - a structure can contain up to this percentage of metal elements and still be considered organic
Returns: bool
True if the structure contains only closed-shell organic molecules

get_carts_from_anchor_string(anchor)

 

Return the Cartesian coordinates from the given 's_mae_pbc_position' anchor string, i.e. 'anchor_x_y_z'.

Parameters:
  • anchor (str) - the anchor string
Returns: list
the Cartesians floats
Raises:
  • ValueError - if the given string is not an anchor string

get_reciprocal_lattice_vectors(a_vec, b_vec, c_vec)

 

Return the reciprocal lattice vectors.

Parameters:
  • a_vec (numpy.array) - the a lattice vector
  • b_vec (numpy.array) - the b lattice vector
  • c_vec (numpy.array) - the c lattice vector
Returns: three numpy.array
the three reciprocal lattice vectors

get_collapsed_index(abc, alimit, blimit, climit)

 

Given a three dimensional grid of integers defined on [1, limit] for the given a, b, and c limits and a traversal path of c then b then a return the number of integers traversed in order to reach the given abc integer index triple.

Parameters:
  • abc (tuple) - the integer indices
  • alimit (int) - the upper bound on a (unused)
  • blimit (int) - the upper bound on b
  • climit (int) - the upper bound on c
Returns: int
the number of integers traversed

modified_sawtooth(n, x)

 

Given a positive integer variable x in [0, n+1] return a signal from a modified sawtooth function. This function is linear on [1, n] but is n for x = 0 and is 1 for x = n+1.

Parameters:
  • n (int) - the period
  • x (int) - the variable
Returns: int
the signal

assign_bond_orders(astructure, logger=None)

 

Return a copy of the input structure that has bond orders assigned.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object for which bond orders will be assigned
  • logger (logging.getLogger or None) - output logger or None if there isn't one
Returns: schrodinger.Structure.structure
a copy of the input structure with the bond orders assigned

fix_metal_bonding(astructure)

 

Fix metal bonding in the given structure.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object for which metal bonding will be fixed

assign_bond_orders_w_mmlewis(astructure, fix_metals=True, logger=None)

 

Return a copy of the input structure that has bond orders assigned.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure object for which bond orders will be assigned
  • fix_metals (bool) - fix metals coming from mmlewis
  • logger (logging.getLogger or None) - output logger or None if there isn't one
Returns: schrodinger.Structure.structure
a copy of the input structure with the bond orders assigned

get_chorus_properties(astructure)

 

Return a tuple containing the nine chorus properties of the given structure.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure that has the chorus properties defined
Returns: tuple
contains the nine chorus properties

get_params_from_chorus(chorus_properties)

 

Return the a, b, c, alpha, beta, and gamma lattice properties from the nine chorus properties.

Parameters:
  • chorus_properties (list) - contains the nine chorus properties, i.e. ax, ay, az, bx, ..., cz
Returns: list
a, b, c, alpha, beta, and gamma lattice properties

get_chorus_from_params(params)

 

Return the nine chorus properties, i.e. [ax, ay, az, bx, ..., cz], from the six lattice parameters a, b, c, alpha, beta, and gamma.

Parameters:
  • params (list) - contains the a, b, c, alpha, beta, and gamma lattice parameters
Returns: list
contains the nine chorus properties

get_volume_from_params(params)

 

Return cell volume (in Angstrom^3) from cell parameters.

Parameters:
  • params (list) - contains the a, b, c, alpha, beta, and gamma lattice parameters
Returns: float
Cell volume in Angstrom^3

get_volume_from_vecs(vecs)

 

Return cell volume (in Angstrom^3) from lattice vectors.

Parameters:
  • params (list) - lattice vectors parameters
Returns: float
Cell volume in Angstrom^3

get_cell_pairs(astructure, cell_distance, pbc_bonding=True, atom_indices=None, chorus_properties=None)

 

Using a distance cell that optionally honors a PBC return a list of tuples of atom index pairs that are within the specified distance.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure containing the pairs
  • cell_distance (float) - the distance used in the distance cell, if using a PBC then min([cell_distance, a, b, c]) is actually what is used
  • pbc_bonding (bool) - if True and the chorus box properties exist on the incoming structure then the distance cell will honor the PBC, otherwise any PBC is not considered
  • atom_indices (list or None) - a list of atom indices to search for pairs, each atom is searched for pairs that may or may not already be in this list, if None then all atoms are searched
  • chorus_properties (list or None) - contains the nine chorus box properties that define a PBC, i.e. [ax, ay, az, bx, ..., cz], if None then the chorus structure properties will be used if available and if not available then no PBC will be used in the DistanceCell
Returns: set
contains tuples of unique atom index pairs within the specified distance

add_labeled_pbc_bond(astructure, atom1, atom2, order, is_pbc_bond=False, also_reg_bond=False, color=4)

 

Add the specified bond to the provided structure and label it depending on if it is a PBC bond.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure to which the bond will be added
  • atom1 (int) - the first atom index of the bond
  • atom2 (int) - the second atom index of the bond
  • order (int) - the bond order
  • is_pbc_bond (bool) - if True then the specified bond is a PBC bond so we will label it as so
  • also_reg_bond (bool) - if True indicates that the given PBC bond is also a regular bond, meaning that one of the atoms of the PBC bond is covalently bound to two copies of the other atom, one inside the cell and one outside the cell
  • color (int or None) - if integer specifies that PBC bonds, that are not also regular bonds, should be colored with this color

get_natom_btw_two_cells(cell1, cell2, extents, size)

 

Using a traversal path of c then b then a, return the number of atoms between two cells, of the given size, in a super cell with the given extents.

Parameters:
  • cell1 (tuple) - a triple of cell indices for the first cell
  • cell2 (tuple) - a triple of cell indices for the second cell
  • extents (list) - contains the number of cells along a, b, and c lattice vectors in the super cell
  • size (int) - the number of atoms in a cell
Returns: int
the number of atoms between the two cells

delete_pbc_bonds(astructure)

 

Delete any PBC bonds from the given structure.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure from which the bonds will be deleted

is_pbc_bond(astructure, atom1, atom2, check_also_reg_bond=False, unit_lattice_vectors=None)

 

Return a (is_pbc_bond, also_reg_bond, bond_distance) tuple that indicates (1) whether the specified bond is a PBC bond, (2) if checked whether that PBC bond is also a regular bond, and (3) the bond length.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure that has the bond
  • atom1 (schrodinger.structure._StructureAtom) - the first atom of the bond
  • atom2 (schrodinger.structure._StructureAtom) - the second atom of the bond
  • check_also_reg_bond (bool) - check if the PBC bond is also a regular bond, meaning that one of the atoms of the PBC bond is covalently bound to two copies of the other atom, one inside the cell and one outside the cell
  • unit_lattice_vectors (list of (numpy.array, float) tuples or None) - contains normalized a, b, and c lattice vectors and their original lengths, is None if no check for PBC bonds that are also regular bonds is being performed
Returns: tuple
a (is_pbc_bond, also_reg_bond, bond_distance) tuple

get_lattice_param_properties(astructure)

 

Return a tuple containing the six lattice parameter properties of the given structure.

Parameters:
  • astructure (schrodinger.Structure.structure) - the structure that has the lattice parameter properties defined
Returns: tuple
contains the six lattice parameter properties

get_normalized_spanning_vectors(lattice_vectors)

 

Return the thirteen unique normalized spanning vectors for the cell.

Parameters:
  • lattice_vectors (list of numpy.array) - the lattice a, b, and c vectors
Returns: dict
keys are tuples of cell index triples, values are tuples of normalized spanning vectors and their original lengths

get_element_priority(pair)

 

Return the formula ordering priority of the element in the given pair.

Parameters:
  • pair (tuple) - (element, number) tuple
Returns: int
the element priority

get_unit_cell_formula(unit_cell)

 

Return the formatted unit cell formula of the given unit cell.

Parameters:
  • unit_cell (schrodinger.Structure.structure) - the structure object for the unit cell
Returns: str
the formatted unit cell formula

trans_cart_to_fract(cart_vec, a_param, b_param, c_param, alpha_param, beta_param, gamma_param)

 

Transform the given vector in the Cartesian basis to the fractional basis.

Parameters:
  • cart_vec (numpy.array) - the vector to be transformed from the Cartesian basis to the fractional basis
  • a_param (float) - the lattice a parameter
  • b_param (float) - the lattice b parameter
  • c_param (float) - the lattice c parameter
  • alpha_param (float) - the lattice alpha parameter
  • beta_param (float) - the lattice beta parameter
  • gamma_param (float) - the lattice gamma parameter
Returns: numpy.array
the given vector in the fractional basis

trans_fract_to_cart(fract_vec, a_param, b_param, c_param, alpha_param, beta_param, gamma_param)

 

Transform the given vector in the fractional basis to the Cartesian basis.

Parameters:
  • fract_vec (numpy.array) - the vector to be transformed from the fractional basis to the Cartesian basis
  • a_param (float) - the lattice a parameter
  • b_param (float) - the lattice b parameter
  • c_param (float) - the lattice c parameter
  • alpha_param (float) - the lattice alpha parameter
  • beta_param (float) - the lattice beta parameter
  • gamma_param (float) - the lattice gamma parameter
Returns: numpy.array
the given vector in the Cartesian basis

trans_cart_to_frac_from_vecs(coords, a_vec, b_vec, c_vec, rec=False)

 

Transform coordinates from (reciprocal) Cartesian to (reciprocal) fractional using lattice vectors.

Parameters:
  • coords (numpy.array) - a list of Cartesian coordinates
  • a_vec (list of 3 floats) - 'a' lattice vector
  • b_vec (list of 3 floats) - 'b' lattice vector
  • c_vec (list of 3 floats) - 'c' lattice vector
  • rec (bool) - If True, work in reciprocal space
Returns: numpy array

trans_frac_to_cart_from_vecs(coords, a_vec, b_vec, c_vec, rec=False)

 

Transform coordinates from (reciprocal) fractional to (reciprocal) Cartesian using lattice vectors.

Parameters:
  • coords (numpy.array) - a list of fractional coordinates
  • a_vec (list of 3 floats) - 'a' lattice vector
  • b_vec (list of 3 floats) - 'b' lattice vector
  • c_vec (list of 3 floats) - 'c' lattice vector
  • rec (bool) - If True, work in reciprocal space
Returns: numpy array

get_cell(asu, space_group=None, lattice_params=None, extents=None, xtal_kwargs=None)

 

Build and return a crystalline cell using the given asymmetric unit, space group, lattice parameters, and extents.

Parameters:
  • asu (schrodinger.structure.Structure) - the asymmetric unit
  • space_group (str or None) - the full or short Hermann-Mauguin symbol of the space group or None in which case the asu structure property Crystal.SPACE_GROUP_KEY will be used
  • lattice_params (list or None) - the six lattice parameters or None in which case the asu structure properties Crystal.A_KEY, Crystal.B_KEY, Crystal.C_KEY, Crystal.ALPHA_KEY, Crystal.BETA_KEY, and Crystal.GAMMA_KEY will be used
  • extents (list or None) - the integer extents along the a, b, and c lattice vectors or None if there are none
  • xtal_kwargs (dict or None) - extra xtal.Crystal kwargs or None if there are none
Returns: schrodinger.structure.Structure
the built cell

get_vectors_from_chorus(astructure)

 

Return the three lattice vectors from the nine lattice chorus properties.

Parameters:
Returns: list
the three lattice vectors
Raises:
  • ValueError - if any chorus property is missing

get_conv_from_vecs(a_vec, b_vec, c_vec)

 

Generate matrices to convert from fractional to Cartesian and back.

Parameters:
  • a_vec (list of 3 floats) - 'a' lattice vector
  • b_vec (list of 3 floats) - 'b' lattice vector
  • c_vec (list of 3 floats) - 'c' lattice vector
Returns: tuple of matrices

create_new_box(struct)

 

Create a new box that is large enough to encompass the X, Y and Z lengths of the system

Parameters:

set_lattice_properties(astructure, lattice_properties)

 

Set the given lattice properties on the structure.

Parameters:
  • astructure (schrodinger.structure.Structure) - the structure on which to set the lattice properties
  • lattice_properties (list) - a, b, c, alpha, beta, and gamma lattice properties

make_p1(astructure, logger=None)

 

Make a P1 cell.

Parameters:
Returns: schrodinger.structure.Structure
the P1 cell

sync_pbc(st, create_pbc=False)

 

Return the given structure with a synchronized PBC, if create_pbc is True and the structure lacks a PBC then one will be created, otherwise this function will return False if there is no PBC.

Parameters:
  • st (structure.Structure) - the structure with the PBC to be synchronized
  • create_pbc (bool) - if True and the given structure lacks a PBC then a minimal PBC will be created, if False and if the given structure lacks a PBC then this function will return False
Returns: structure.Structure or bool
the structure with a synchronized PBC or False if there was no PBC and one wasn't created

get_pbc_bonds_dict(astructure)

 

Return a PBC bonds dict for the given structure.

Parameters:
Returns: dict
keys are tuples of PBC bond atom index pairs, values are tuples of bond orders and booleans indicating whether the PBC bond is also a regular bond

set_representation_bond(abond)

 

Set the representation of the given bond.

Parameters:
  • abond (schrodinger.structure._StructureBond) - the bond to set the representation for

set_pbc_properties(astructure, chorus_properties)

 

Set the chorus and PDB properties on the given structure using the given chorus properties.

Parameters:
  • astructure (schrodinger.structure.Structure) - the structure on which the properties are set
  • chorus_properties (list) - contains the nine chorus properties, i.e. ax, ay, az, bx, ..., cz

transform_pbc(struct_in, supercell_matrix, scale_only=False, cell_only=False, origin_shift=None)

 

Create a new structure based on the transformation matrix. If both 'scale_only' and 'cell_only' are False (default behavior), atoms will be added or subtracted based on the expansion/contraction of the PBC.

Parameters:
  • struct_in (schrodinger.structure.Structure) - Structure to which transformation will be applied
  • supercell_matrix (3 x 3 floats) - Transformation matrix
  • scale_only (bool) - If True, scale atoms to the new cell defined by supercell_matrix, this keeps constant fractional coordinates and number of atoms from the original 'struct'
  • cell_only (bool) - If True, change cell frame to a new cell. This keeps constant Cartesian coordinates and number of atoms from the original 'struct'. Note that if supercell cell is smaller than original cell, atoms could be cut by the new smaller cell frame
  • origin_shift (list of 3 floats) - Origin shift in fractional coordinates
  • struct - Transformed structure

get_simple_supercell_matrix(supercell_matrix)

 

Get minimal diagonal elements of a simple supercell matrix starting from (non)-diagonal supercell matrix. Supercell matrix can be: -1, 1, 1 2, -3, 4 -5, 6, 7 Resulting simple supercell (described by the matrix) must be able to hold the supercell above.

In the case of a smaller lattice, for example: 0.5 0 0 0 0.5 0 0 0 0.5

[1, 1, 1] will be returned

Parameters:
  • supercell_matrix (3 x 3 list of floats) - Supercell matrix
Returns: list of three ints
Diagonal elements of the simple supercell matrix (must be positive nonzero integers)

get_simple_supercell(struct, supercell_matrix)

 

Get supercell structure.

Parameters:
  • struct (structure.Structure) - Input structure
  • supercell_matrix (List of 3 floats) - Diagonal elements of the supercell matrix
Returns: structure.Structure
Supercell structure

get_transformation_matrix(vecs, new_vecs)

 

Get transformation matrix between old and new set of lattice vectors.

Parameters:
  • vecs (3 x 3 float list) - Old lattice vectors
  • new_vecs (3 x 3 float list) - New lattice vectors
Returns: 3 x 3 float list
Transformation matrix

move_atoms_into_cell(struct, frac_coords=None, overlap_tresh=0.25, fract_offset=0.0001)

 

Get structure with all the atoms moved into the first cell.

Parameters:
  • frac_coords (numpy arrays of arrays of 3 floats or None) - Fractional coordinates
  • overlap_tresh (float) - Distance between two atoms, such that they are considered overlapping
  • fract_offset (float) - The threshold used to compare floating point fractional coordinate values and in particular those that are on the cell boundary
Returns: structure.Structure
Structure with all the atoms moved inside first unit cell

get_unit_lattice_vector_info(astructure)

 

Return a list of tuples containing unit lattice vector information, i.e. the unit lattice vectors and their original lengths.

Parameters:
Returns: list of tuples
each (numpy.array, float) tuple contains (1) the unit lattice vector and (2) the length of the original vector

label_pbc_bonds(astructure)

 

Label PBC bonds.

Parameters:

label_pbc_bond(abond, also_reg_bond=False, color=4)

 

Label this PBC bond.

Parameters:
  • abond (schrodinger.structure._StructureBond) - the PBC bond to label
  • also_reg_bond (bool) - if True indicates that the given PBC bond is also a regular bond, meaning that one of the atoms of the PBC bond is covalently bound to two copies of the other atom, one inside the cell and one outside the cell
  • color (int or None) - if integer specifies that a PBC bond, that is not also a regular bond, should be colored with this color, if None then no coloring is performed

get_spg_from_spglib(space_groups, spg_type_in, spg_symm, double_named_groups=set(['Bbcb', 'Bbeb', 'Pcna', 'Pmnm', 'Pncb', 'Pnmm']))

 

Get space group from mmspg given space group type obtained from spglib.

Parameters:
  • space_groups (SpaceGroups) - SpaceGroups object containing space groups known to mmspg
  • spg_type_in (dict) - Dataset containing space group properties, for keys see: https://atztogo.github.io/spglib/python-spglib.html#get-symmetry-dataset String values are in *unicode* !
  • spg_symm (dict of two keys: 'rotations': list of 3 x 3 matrices, 'translations': list of 1 x 3 matrices) - dictionary of list of rotations and translations
  • double_named_groups (set) - Doubly named space groups in spglib
Returns: SpaceGroup, namedtuple or None, namedtuple
If space group from spglib matched one from mmspg, return SpaceGroup object and named tuple formed from spg_type_in dict. Otherwise, None and named tuple formed from spg_type_in dict is returned

equal_rotations(rotations1, rotations2)

 

Check if rotations are equal.

Parameters:
  • rotations1 (3D numpy.array) - Array of rotation matrices (2D arrays) associated with a space group
  • rotations2 (3D numpy.array) - Array of rotation matrices (2D arrays) associated with a space group
Returns: bool
True, if rotations are the same, otherwise False

assign_space_group(struct_in, symprec=0.01, space_groups=None, update_title=False)

 

Set space group and space group id to the input structure. An error message is returned on failure.

Parameters:
  • symprec (float) - Symmetry tolerance used for atomic coordinates to assign space group
  • space_groups (SpaceGroups or None) - SpaceGroups object containing space groups known to mmspg or None if default SpaceGroups instance is desired
  • update_title (bool) - Update structure title with a newly assigned space group
Returns: str or None
Error message if something went wrong. Otherwise None is returned.

get_normal_surf_from_HKL(hkl, vecs, max_normal_search=10, normal_c=True)

 

Calculate transformation matrix with c-axis most normal to a-b plane from HKL plane indices and lattice vectors.

Parameters:
  • hkl (list of 3 integers) - Miller plane indices
  • vecs (list of 3 lists of floats) - Lattice vectors
  • max_normal_search (int) - Maximum number of linear combinations of lattice vectors to be considered when search most normal surface
  • normal_c (bool) - If True and normal is found, swap axis so that c-axis is normal
Returns: bool, matrix 3 x 3 of integers
True, if normal is found, otherwise False and transformation matrix

lcm(numbers)

 

Get the lowest common multiple of a sequence of numbers.

Parameters:
  • numbers (list of integers) - Sequence of integers
Returns: int
Lowest common multiple

reduce_vector(vector)

 

Get reduced vector of a transformation matrix.

Parameters:
  • vector (list of integers) - Components of a vector of transformation matrix
Returns: list of integers
Components of a reduced vector of transformation matrix

get_symmops_from_spglib(symm)

 

Get set of symmetry operators from a set of rotations and translations. Symmetry operator is defined with a 4 x 4 matrix, top left 3 x 3 is rotation matrix, top right column 1 x 3 is translation, rest, bottom row is [0 0 0 1]

Parameters:
  • symm (dict of two keys: 'rotations': list of 3 x 3 matrices, 'translations': list of 1 x 3 matrices) - dictionary of list of rotations and translations
Returns: list of symmetry operators
list of 4x4 matrices

get_struct_from_CIF(cif_fn)

 

Get structure from CIF file.

Parameters:
  • cif_fn (str) - CIF file name
Returns: schrodinger.structure.Structure
Structure from CIF file

Variables Details [hide private]

__doc__

Value:
"""
Classes and functions for creating crystals by unit cell.

Copyright Schrodinger, LLC. All rights reserved."""

AHEAD_TRIPLES

Value:
[(1, 0, 0),
 (0, 1, 0),
 (0, 0, 1),
 (0, 1, 1),
 (0, 1, -1),
 (1, 0, 1),
 (1, 1, 0),
 (1, 1, 1),
...

LATTICE_PARAMS_KEYS

Value:
['a_param',
 'b_param',
 'c_param',
 'alpha_param',
 'beta_param',
 'gamma_param']

SPGLIB_DOUBLY_NAMED_SHORT

Value:
set(['Bbcb', 'Bbeb', 'Pcna', 'Pmnm', 'Pncb', 'Pnmm'])

SPG_TO_HALL_NUMBER

Value:
[1,
 2,
 3,
 6,
 9,
 18,
 21,
 30,
...

LAST_ELEMENTS

Value:
('H', 'C', 'N', 'O', 'F', 'P', 'S', 'Cl', 'Se', 'Br', 'I', 'At')

MMPDB_COV_RADII

Value:
{1: 0.32,
 2: 0.93,
 3: 1.23,
 4: 0.9,
 5: 0.82,
 6: 0.77,
 7: 0.75,
 8: 0.73,
...

   Trees       Indices       Help   
2017-2 Schrodinger Python API
Generated by Epydoc 3.0.1 on Tue May 2 06:32:47 2017 http://epydoc.sourceforge.net