SYMBOL INDEX (1555 symbols across 97 files)

FILE: doc/conf.py
  class Mock (line 22) | class Mock(MagicMock):
    method __getattr__ (line 24) | def __getattr__(cls, name):

FILE: examples/example_00_LJ_simple.py
  function lennard_jones_potential (line 13) | def lennard_jones_potential(pos, dim=3):
  function lennard_jones_force (line 32) | def lennard_jones_force(pos, dim=3):
  function optimize_cluster (line 58) | def optimize_cluster(pos):

FILE: examples/example_01_3D_VASP.py
  function generate_random_crystal (line 35) | def generate_random_crystal() -> pyxtal:
  function optimize_and_save (line 59) | def optimize_and_save(crystal: pyxtal, index: int) -> None:
  function main (line 81) | def main() -> None:

FILE: examples/example_02_LJ_cluster.py
  function single_optimize (line 26) | def single_optimize(pos, dim=3, kt=0.5, mu=0.1, beta=1.001, shift=False,...
  class LJ_prediction (line 60) | class LJ_prediction:
    method __init__ (line 63) | def __init__(self, numIons):
    method generate_cluster (line 71) | def generate_cluster(self, pgs: tuple[int, int], cluster_factor=0.6, s...
    method predict (line 83) | def predict(self, maxN: int = 100, ncpu: int = 2, pgs: tuple[int, int]...
    method relaxation (line 100) | def relaxation(self, pgs: tuple[int, int], **kwargs):

FILE: examples/example_03_LJ_optalg.py
  function LJ (line 30) | def LJ(pos, dim, mu=0.1):
  function LJ_force (line 59) | def LJ_force(pos, dim, mu=0.1):
  function single_optimize (line 81) | def single_optimize(pos, dim=3, kt=0.5, mu=0.1, method="CG", seed=None):
  function parse_symmetry (line 113) | def parse_symmetry(pos):
  class LJ_prediction (line 123) | class LJ_prediction:
    method __init__ (line 126) | def __init__(self, numIons):
    method generate_cluster (line 134) | def generate_cluster(self, pgs, cluster_factor=0.7, seed=None):
    method predict (line 146) | def predict(self, dim=3, maxN=100, ncpu=2, pgs=(2, 33), method="CG"):
    method relaxation (line 171) | def relaxation(self, dim, pgs, method, ind):

FILE: examples/example_04_LJ_38.py
  function LJ (line 26) | def LJ(pos, dim, mu=0.1):
  function LJ_force (line 55) | def LJ_force(pos, dim, mu=0.1):
  function single_optimize (line 77) | def single_optimize(pos, dim=3, kt=0.5, mu=0.1, seed=None):
  function parse_symmetry (line 108) | def parse_symmetry(pos):
  class LJ_prediction (line 118) | class LJ_prediction:
    method __init__ (line 121) | def __init__(self, numIons):
    method generate_cluster (line 129) | def generate_cluster(self, pgs, cluster_factor=1.0, seed=None):
    method predict (line 141) | def predict(self, dim=3, maxN=100, ncpu=2, pgs=(2, 33)):
    method relaxation (line 166) | def relaxation(self, dim, pgs, ind):

FILE: examples/example_05_LJ_4D.py
  function LJ (line 26) | def LJ(pos, dim, mu=0.1):
  function LJ_force (line 55) | def LJ_force(pos, dim, mu=0.1):
  function single_optimize (line 77) | def single_optimize(pos, dim=3, kt=0.5, mu=0.1):
  function parse_symmetry (line 106) | def parse_symmetry(pos):
  class LJ_prediction (line 116) | class LJ_prediction:
    method __init__ (line 119) | def __init__(self, numIons):
    method generate_cluster (line 127) | def generate_cluster(self, pgs, cluster_factor=0.6, seed=None):
    method predict (line 139) | def predict(self, dim=3, maxN=100, ncpu=2, pgs=(2, 33)):
    method relaxation (line 164) | def relaxation(self, dim, pgs, ind):

FILE: examples/example_06_C_2D_lammps.py
  function new_struc (line 16) | def new_struc(db, s, eng):

FILE: flask/app/errors.py
  function not_found_error (line 6) | def not_found_error(error):
  function internal_error (line 11) | def internal_error(error):

FILE: flask/app/forms.py
  class MainForm (line 7) | class MainForm(FlaskForm):

FILE: flask/app/routes.py
  function index (line 16) | def index():
  function individual (line 21) | def individual():
  function comparison (line 50) | def comparison():
  function structure (line 81) | def structure(type: str):
  function structure2 (line 97) | def structure2(type: str):
  function process_upload (line 112) | def process_upload(form, comp=False):
  function process_form (line 155) | def process_form(form, comp=True):
  function plot (line 194) | def plot():
  function compare (line 228) | def compare():
  function read (line 290) | def read(savepath):

FILE: flask/app/static/jsmol.js
  function repeatCell (line 30) | function repeatCell(n1, n2, n3, num) {

FILE: flask/config.py
  class Config (line 4) | class Config:

FILE: pyxtal/XRD.py
  class XRD (line 21) | class XRD:
    method __init__ (line 38) | def __init__(
    method save (line 72) | def save(self, filename):
    method load (line 79) | def load(self, filename):
    method __str__ (line 102) | def __str__(self):
    method __repr__ (line 105) | def __repr__(self):
    method by_hkl (line 108) | def by_hkl(self, hkl=None, N_max=None):
    method all_dhkl (line 137) | def all_dhkl(self, crystal):
    method intensity (line 177) | def intensity(self, crystal):
    method pxrdf (line 331) | def pxrdf(self):
    method get_unique_families (line 361) | def get_unique_families(self, hkls, verbose=False):
    method draw_hkl (line 387) | def draw_hkl(hkl):
    method plot_pxrd (line 403) | def plot_pxrd(
    method plotly_pxrd (line 476) | def plotly_pxrd(
    method get_profile (line 537) | def get_profile(self, method="gaussian", res=0.01, user_kwargs=None):
    method get_plot (line 549) | def get_plot(self, grainsize=20, orientation=0.1, thermo=0.1,
  function add_peak (line 635) | def add_peak(twotheta, mu, gamma, sigma2, L, H, S, step=0.02, width=0.1,...
  function axial_div_bak (line 700) | def axial_div_bak(x, mu, L, H, S):
  function axial_div (line 728) | def axial_div(x, mu, L, H, S):
  function map_intensity (line 770) | def map_intensity(peak, x, twotheta):
  function _map_int_nearest_neighbor (line 809) | def _map_int_nearest_neighbor(peak, x, twotheta):
  class Profile (line 833) | class Profile:
    method __init__ (line 844) | def __init__(self, method="mod_pseudo-voigt", res=0.02, user_kwargs=No...
    method get_profile (line 873) | def get_profile(self, two_thetas, intensities, min2theta, max2theta):
  class Similarity (line 944) | class Similarity:
    method __init__ (line 945) | def __init__(self, f, g, N=None, x_range=None, l=2.0, weight="cosine"):
    method __str__ (line 1001) | def __str__(self):
    method __repr__ (line 1004) | def __repr__(self):
    method triangleFunction (line 1007) | def triangleFunction(self):
    method cosineFunction (line 1017) | def cosineFunction(self):
    method show (line 1028) | def show(self, filename=None, fontsize=None, labels=None):
  function mod_pseudo_voigt (line 1064) | def mod_pseudo_voigt(x, fwhm, A, eta_h, eta_l, N):
  function gaussian (line 1100) | def gaussian(theta2, alpha, fwhm):
  function lorentzian (line 1109) | def lorentzian(theta2, alpha, fwhm):
  function pseudo_voigt (line 1118) | def pseudo_voigt(theta2, alpha, fwhm, eta):
  function similarity_calculate (line 1129) | def similarity_calculate(r, w, d, Npts, fy, gy):
  function create_index (line 1151) | def create_index(imax=1, jmax=1, kmax=1):
  function get_intensity (line 1165) | def get_intensity(positions, hkl, s2, coeffs, z):
  function get_all_intensity (line 1195) | def get_all_intensity(N_cycles, N_atom, per_N, positions, hkls, s2s, coe...
  function get_all_intensity_par (line 1208) | def get_all_intensity_par(cpu, queue, cycles, Start, End, hkl_per_proc, ...
  function gaussian_integrated (line 1219) | def gaussian_integrated(bin_left, bin_right, center, fwhm):
  function pxrd_refine (line 1225) | def pxrd_refine(xtal, ref_pxrd, thetas, steps=50):
  function check_pxrd_match (line 1266) | def check_pxrd_match(xtal, ref_pxrd, s_tol=0.8, top_n=3, peak_tol=0.1, a...
  function is_multiple (line 1323) | def is_multiple(hkl, ref_hkl):
  function get_para_from_pxrd (line 1344) | def get_para_from_pxrd(ref_pxd, spg, wave_length=1.5406):

FILE: pyxtal/XRD_indexer.py
  function find_wp_assignments (line 12) | def find_wp_assignments(comp, ids, nums):
  function get_cell_params (line 107) | def get_cell_params(bravais, hkls, two_thetas, wave_length=1.54184):
  function get_d_hkl_from_cell (line 239) | def get_d_hkl_from_cell(bravais, cells, h, k, l):
  function calc_two_theta_from_cell (line 271) | def calc_two_theta_from_cell(bravais, hkls, cells, wave_length=1.54184):
  function get_seeds (line 311) | def get_seeds(bravais, hkls, two_thetas):
  function get_unique_thetas (line 395) | def get_unique_thetas(xrd, bravais):
  function get_cell_from_multi_hkls (line 434) | def get_cell_from_multi_hkls(bravais, hkls, two_thetas, long_thetas=None...
  function get_cell_from_thetas (line 538) | def get_cell_from_thetas(spg, long_thetas, N_add=5, max_mismatch=20, the...
  class XtalManager (line 619) | class XtalManager:
    method __init__ (line 620) | def __init__(self, spg, species, numIons, cell, WPs):
    method generate_structure (line 644) | def generate_structure(self):
  class WPManager (line 653) | class WPManager:
    method __init__ (line 654) | def __init__(self, spg, cell, composition={'Si': 1, 'O': 2}, max_wp=8,...
    method get_wyckoff_positions_bak (line 692) | def get_wyckoff_positions_bak(self):
    method get_wyckoff_positions (line 727) | def get_wyckoff_positions(self):
  class CellManager (line 771) | class CellManager:
    method __init__ (line 772) | def __init__(self, spg, params, missing):
    method is_supercell_of (line 784) | def is_supercell_of(self, other, tol=0.05):
    method is_similar_to (line 795) | def is_similar_to(self, other, tol=0.04):
    method __repr__ (line 800) | def __repr__(self):
    method consolidate (line 804) | def consolidate(cls, raw_data, merge_tol=0.04, supercell_tol=0.05, max...

FILE: pyxtal/__init__.py
  function print_logo (line 39) | def print_logo():
  class pyxtal (line 61) | class pyxtal:
    method __init__ (line 179) | def __init__(self, molecular=False, random_state=None):
    method __str__ (line 201) | def __str__(self):
    method __repr__ (line 229) | def __repr__(self):
    method get_dof (line 232) | def get_dof(self):
    method get_bounds (line 243) | def get_bounds(self, vec=(2.0, 50.0), ang=(30, 150)):
    method get_site_labels (line 253) | def get_site_labels(self):
    method from_random (line 273) | def from_random(
    method from_seed (line 410) | def from_seed(
    method _from_pymatgen (line 490) | def _from_pymatgen(self, struc, tol=1e-3, a_tol=5.0, style="pyxtal", h...
    method are_valid_numIons (line 561) | def are_valid_numIons(self):
    method check_H_coordination (line 574) | def check_H_coordination(self, r=1.12):
    method check_short_distances (line 595) | def check_short_distances(self, r=0.7, exclude_H=True):
    method check_short_distances_by_dict (line 620) | def check_short_distances_by_dict(self, dicts):
    method to_file (line 652) | def to_file(
    method supergroup (line 696) | def supergroup(self, G=None, d_tol=1.0):
    method supergroups (line 714) | def supergroups(self, G=None, d_tol=1.0):
    method subgroup (line 731) | def subgroup(
    method subgroup_by_path (line 823) | def subgroup_by_path(self, gtypes, ids, eps=0, mut_lat=False):
    method subgroup_once (line 853) | def subgroup_once(
    method _apply_substitution (line 960) | def _apply_substitution(self, splitter, perms):
    method _get_subgroup_ids (line 1000) | def _get_subgroup_ids(self, H, group_type, idx, max_cell, min_cell):
    method _subgroup_by_splitter (line 1067) | def _subgroup_by_splitter(self, splitter, eps=0.05, mut_lat=False):
    method apply_perturbation (line 1181) | def apply_perturbation(self, d_lat=0.05, d_coor=0.05, d_rot=1):
    method copy (line 1203) | def copy(self):
    method _get_coords_and_species (line 1209) | def _get_coords_and_species(self, absolute=False, unitcell=True):
    method _get_formula (line 1244) | def _get_formula(self):
    method get_reduced_composition (line 1277) | def get_reduced_composition(self):
    method get_min_values (line 1284) | def get_min_values(self):
    method get_zprime (line 1296) | def get_zprime(self, integer=False):
    method get_1D_comp (line 1306) | def get_1D_comp(self):
    method get_num_torsions (line 1320) | def get_num_torsions(self):
    method to_ase (line 1329) | def to_ase(self, resort=True, center_only=False, add_vaccum=True):
    method to_pymatgen (line 1385) | def to_pymatgen(self, resort=True):
    method to_pyxtal_center (line 1421) | def to_pyxtal_center(self):
    method get_XRD (line 1459) | def get_XRD(self, **kwargs):
    method optimize_lattice (line 1477) | def optimize_lattice(self, iterations=5, force=False, standard=False):
    method update_wyckoffs (line 1531) | def update_wyckoffs(self):
    method get_std_representation (line 1541) | def get_std_representation(self, trans):
    method get_1D_representation (line 1548) | def get_1D_representation(self, standard=False):
    method transform (line 1558) | def transform(self, trans, lattice=None):
    method to_json (line 1617) | def to_json(self, filename="pyxtal.json"):
    method from_json (line 1627) | def from_json(self, filename):
    method save_dict (line 1636) | def save_dict(self):
    method load_dict (line 1660) | def load_dict(self, dict0):
    method build (line 1689) | def build(self, group, species, numIons, lattice, sites, tol=1e-2, dim...
    method get_alternatives (line 1795) | def get_alternatives(self, include_self=True, same_letters=False, ref_...
    method to_standard_setting (line 1835) | def to_standard_setting(self):
    method resort_species (line 1843) | def resort_species(self, species):
    method resort (line 1867) | def resort(self):
    method _get_alternative (line 1886) | def _get_alternative(self, wyc_sets, index, ref_lat=None, d_tol=2.0, f...
    method _get_alternative_back (line 1947) | def _get_alternative_back(self, index):
    method check_distance (line 1994) | def check_distance(self):
    method get_density (line 2002) | def get_density(self):
    method has_special_site (line 2008) | def has_special_site(self, species=None):
    method to_subgroup_zp2 (line 2029) | def to_subgroup_zp2(self):
    method to_subgroup (line 2052) | def to_subgroup(self, path=None, t_only=True, iterate=False, species=N...
    method show (line 2106) | def show(self, **kwargs):
    method get_free_axis (line 2115) | def get_free_axis(self):
    method find_matched_lattice (line 2130) | def find_matched_lattice(self, ref_struc, d_tol=2.0, f_tol=0.15):
    method check_mapping (line 2179) | def check_mapping(self, ref_struc):
    method get_disps_single (line 2205) | def get_disps_single(self, ref_struc, trans, d_tol=1.2):
    method get_disps_optim (line 2270) | def get_disps_optim(self, ref_struc, trans, d_tol):
    method get_init_translations (line 2302) | def get_init_translations(self, ref_struc, tol=0.75):
    method is_duplicate (line 2346) | def is_duplicate(self, ref_strucs):
    method get_disps_sets (line 2366) | def get_disps_sets(self, ref_struc, d_tol, d_tol2=0.3, ld_tol=2.0, fd_...
    method _get_elements_and_sites (line 2447) | def _get_elements_and_sites(self):
    method sort_sites_by_mult (line 2469) | def sort_sites_by_mult(self):
    method sort_sites_by_numIons (line 2474) | def sort_sites_by_numIons(self, seq=None):
    method get_transition (line 2481) | def get_transition(self, ref_struc, d_tol=1.0, d_tol2=0.3, N_images=2,...
    method get_transition_by_path (line 2570) | def get_transition_by_path(self, ref_struc, path, d_tol, d_tol2=0.5, N...
    method translate (line 2699) | def translate(self, trans, reset_wp=False):
    method make_transitions (line 2713) | def make_transitions(self, disps, lattice=None, translation=None, N_im...
    method get_intermolecular_energy (line 2757) | def get_intermolecular_energy(self, factor=2.0, max_d=10.0):
    method get_neighboring_molecules (line 2780) | def get_neighboring_molecules(self, site_id=0, factor=1.5, max_d=5.0, ...
    method get_spherical_images (line 2829) | def get_spherical_images(self, **kwargs):
    method get_neighboring_dists (line 2845) | def get_neighboring_dists(self, site_id=0, factor=1.5, max_d=5.0):
    method show_mol_cluster (line 2878) | def show_mol_cluster(
    method substitute_1_2 (line 2940) | def substitute_1_2(
    method _substitute_1_2 (line 3022) | def _substitute_1_2(self, dicts, ratio=None):
    method substitute (line 3113) | def substitute(self, dicts):
    method remove_species (line 3131) | def remove_species(self, species):
    method substitute_linear (line 3160) | def substitute_linear(self, dicts):
    method remove_water (line 3225) | def remove_water(self):
    method substitute_molecules (line 3253) | def substitute_molecules(self, smiles):
    method set_cutoff (line 3270) | def set_cutoff(self, exclude_ii=False, value=None):
    method set_site_coordination (line 3296) | def set_site_coordination(self, cutoff=None, verbose=False, exclude_ii...
    method get_dimensionality (line 3322) | def get_dimensionality(self, cutoff=None):
    method from_CSD (line 3337) | def from_CSD(self, csd_code):
    method get_structure_factor (line 3473) | def get_structure_factor(self, hkl, coeffs=None):
    method to_molecular_xtal (line 3488) | def to_molecular_xtal(self, molecules, oris=None, reflects=None):
    method to_atomic_xtal (line 3513) | def to_atomic_xtal(self):
    method get_forcefield (line 3532) | def get_forcefield(self, ff_style="openff", code="lammps", chargemetho...
    method update_from_1d_rep (line 3617) | def update_from_1d_rep(self, x):
    method get_1d_rep_x (line 3654) | def get_1d_rep_x(self):
    method from_spg_wps_rep (line 3674) | def from_spg_wps_rep(self, spg, wps, x, elements=None):
    method from_1d_rep (line 3712) | def from_1d_rep(self, x, sites, dim=3):
    method check_validity (line 3764) | def check_validity(self, criteria, verbose=False):
    method get_xtal_string (line 3838) | def get_xtal_string(self, dicts=None, header=None):
    method get_tabular_representations (line 3878) | def get_tabular_representations(
    method get_tabular_representation (line 3935) | def get_tabular_representation(
    method from_tabular_representation (line 4022) | def from_tabular_representation(
    method get_Pearson_Symbol (line 4150) | def get_Pearson_Symbol(self):
    method resymmetrize (line 4176) | def resymmetrize(self, tol=1e-3):
    method from_prototype (line 4193) | def from_prototype(self, prototype):
    method optimize_orientation_by_energy (line 4284) | def optimize_orientation_by_energy(self, max_iter=20, verbose=False):
    method get_orientation_energy (line 4290) | def get_orientation_energy(self):
    method get_separations (line 4297) | def get_separations(self, hkls=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]):
    method cut_lattice (line 4312) | def cut_lattice(self, max_separation=3.0, verbose=False):
    method optimize_lattice_and_rotation (line 4328) | def optimize_lattice_and_rotation(self, iterations=3, verbose=False):
    method get_rms_dist (line 4342) | def get_rms_dist(self, xtal1, ltol=0.3, stol=0.3, angle_tol=5.0, scale...

FILE: pyxtal/asu_constraints.py
  class ASUCondition (line 22) | class ASUCondition:
    method __init__ (line 32) | def __init__(self, condition: Callable, description: str):
    method check (line 43) | def check(self, coords: np.ndarray) -> bool:
    method __repr__ (line 55) | def __repr__(self):
  class ASU (line 59) | class ASU:
    method __init__ (line 65) | def __init__(self,
    method x_min (line 83) | def x_min(self): return self.bounds[0]
    method x_max (line 86) | def x_max(self): return self.bounds[1]
    method y_min (line 89) | def y_min(self): return self.bounds[2]
    method y_max (line 92) | def y_max(self): return self.bounds[3]
    method z_min (line 95) | def z_min(self): return self.bounds[4]
    method z_max (line 98) | def z_max(self): return self.bounds[5]
    method check_box_bounds (line 100) | def check_box_bounds(self, coords: np.ndarray) -> np.ndarray:
    method check_conditions (line 121) | def check_conditions(self, coords: np.ndarray) -> np.ndarray:
    method is_valid (line 142) | def is_valid(self, coords: np.ndarray) -> np.ndarray:
    method generate_random_points (line 154) | def generate_random_points(self, n: int, max_attempts: int = 10000) ->...
    method project_to_asu (line 186) | def project_to_asu(self, coords: np.ndarray, method: str = 'clamp') ->...
    method __repr__ (line 236) | def __repr__(self):
  function create_asu_for_space_group (line 251) | def create_asu_for_space_group(space_group: int) -> ASU:
  function parse_fraction (line 336) | def parse_fraction(frac_str: str) -> float:
  function test_asu_implementation (line 344) | def test_asu_implementation():

FILE: pyxtal/block_crystal.py
  function block_crystal (line 16) | def block_crystal(

FILE: pyxtal/constants.py
  function get_additional_asu_conditions (line 483) | def get_additional_asu_conditions(space_group: int):

FILE: pyxtal/crystal.py
  class random_crystal (line 28) | class random_crystal:
    method __init__ (line 49) | def __init__(
    method __str__ (line 130) | def __str__(self):
    method __repr__ (line 143) | def __repr__(self):
    method set_sites (line 146) | def set_sites(self, sites):
    method set_elemental_volumes (line 183) | def set_elemental_volumes(self):
    method set_volume (line 193) | def set_volume(self):
    method set_lattice (line 218) | def set_lattice(self, lattice):
    method set_crystal (line 282) | def set_crystal(self):
    method _set_coords (line 318) | def _set_coords(self):
    method _set_ion_wyckoffs (line 337) | def _set_ion_wyckoffs(self, numIon, specie, cell, wyks):
    method check_wp (line 433) | def check_wp(self, wyckoff_sites_tmp, wyks, cell, new_site, tol):
    method _check_consistency (line 440) | def _check_consistency(self, site, numIon):

FILE: pyxtal/database/collection.py
  class Collection (line 7) | class Collection:
    method __init__ (line 27) | def __init__(self, name="molecules"):
    method __getitem__ (line 51) | def __getitem__(self, name):
    method __iter__ (line 64) | def __iter__(self):
    method _read (line 68) | def _read(self, name):
    method show_names (line 83) | def show_names(self):

FILE: pyxtal/database/element.py
  class Element (line 6) | class Element:
    method __init__ (line 14) | def __init__(self, input_value):
    method get_all (line 281) | def get_all(self, pos):
    method get_sf (line 296) | def get_sf(self, pos):
    method all_z (line 311) | def all_z(self):
    method all_short_names (line 314) | def all_short_names(self):
    method all_long_names (line 317) | def all_long_names(self):
    method all_masses (line 320) | def all_masses(self):
    method all_valences (line 323) | def all_valences(self):
    method all_valence_electrons (line 326) | def all_valence_electrons(self):
    method all_covalent_radii (line 329) | def all_covalent_radii(self):
    method all_vdw_radii (line 332) | def all_vdw_radii(self):
    method all_metallic_radii (line 335) | def all_metallic_radii(self):
    method get_sf (line 338) | def get_sf(self):
    method number_from_specie (line 341) | def number_from_specie(specie):

FILE: pyxtal/db.py
  function setup_worker_logger (line 17) | def setup_worker_logger(log_file):
  function call_opt_single (line 26) | def call_opt_single(p):
  function opt_single (line 51) | def opt_single(id, xtal, calc, *args):
  function dftb_opt_single (line 83) | def dftb_opt_single(id, xtal, skf_dir, steps, symmetrize, criteria, kres...
  function vasp_opt_single (line 157) | def vasp_opt_single(id, xtal, path, cmd, criteria):
  function gulp_opt_single (line 184) | def gulp_opt_single(id, xtal, ff_lib, path, criteria):
  function mace_opt_single (line 231) | def mace_opt_single(id, xtal, step, fmax, criteria):
  function process_xtal (line 275) | def process_xtal(id, xtal, eng, criteria):
  function make_entry_from_pyxtal (line 285) | def make_entry_from_pyxtal(xtal):
  function make_entry_from_CSD_web (line 358) | def make_entry_from_CSD_web(code, number, smiles, name=None):
  function make_entry_from_CSD (line 375) | def make_entry_from_CSD(code):
  function make_db_from_CSD (line 394) | def make_db_from_CSD(dbname, codes):
  class database (line 414) | class database:
    method __init__ (line 422) | def __init__(self, db_name):
    method vacuum (line 450) | def vacuum(self):
    method get_all_codes (line 453) | def get_all_codes(self, group=None):
    method add (line 471) | def add(self, entry):
    method add_from_code (line 478) | def add_from_code(self, code):
    method process_kvp (line 485) | def process_kvp(self, kvp):
    method check_status (line 495) | def check_status(self, show=False):
    method copy (line 510) | def copy(self, db_name, csd_codes):
    method view (line 526) | def view(self, row_info):
    method get_row_info (line 559) | def get_row_info(self, id=None, code=None):
    method get_row (line 586) | def get_row(self, code):
    method get_pyxtal (line 592) | def get_pyxtal(self, code):
    method compute (line 613) | def compute(self, row, work_dir, skf_dir):
  class database_topology (line 629) | class database_topology:
    method __init__ (line 643) | def __init__(self, db_name, rank=0, size=1, ltol=0.05, stol=0.05, atol=3,
    method vacuum (line 681) | def vacuum(self):
    method print_memory_usage (line 684) | def print_memory_usage(self):
    method get_pyxtal (line 691) | def get_pyxtal(self, id, use_relaxed=None, tol=1e-4):
    method get_all_xtals (line 738) | def get_all_xtals(self, include_energy=False):
    method add_xtal (line 751) | def add_xtal(self, xtal, kvp={}):
    method add_strucs_from_db (line 770) | def add_strucs_from_db(self, db_file, check=False,
    method check_new_structure (line 866) | def check_new_structure(self, xtal, eng=None, same_group=False,
    method clean_structures_spg_topology (line 920) | def clean_structures_spg_topology(self, dim=None):
    method get_row (line 977) | def get_row(self, id):
    method clean_structures (line 982) | def clean_structures(self, ids=(None, None), dtol=2e-3, etol=1e-3, cri...
    method clean_structures_pmg (line 1096) | def clean_structures_pmg(self, ids=(None, None), min_id=None, dtol=5e-...
    method get_max_id (line 1223) | def get_max_id(self):
    method select_xtals (line 1233) | def select_xtals(self, ids, N_atoms=(None, None), overwrite=False, att...
    method select_xtal (line 1267) | def select_xtal(self, ids, N_atoms=(None, None), overwrite=False, attr...
    method update_row_energy (line 1303) | def update_row_energy(
    method update_row_energy_serial (line 1385) | def update_row_energy_serial(self, generator, write_freq, args, args_up):
    method update_row_energy_mproc (line 1418) | def update_row_energy_mproc(self, ncpu, generator, args, args_up):
    method _update_db (line 1499) | def _update_db(self, results, calc, *args):
    method update_row_topology (line 1535) | def update_row_topology(self, StructureType="Auto", overwrite=True, pr...
    method update_db_description (line 1768) | def update_db_description(self):
    method export_structures (line 1804) | def export_structures(
    method get_label (line 1955) | def get_label(self, i):
    method get_db_unique (line 1964) | def get_db_unique(self, db_name=None, prec=3, key='ff_energy', max_N_a...
    method get_db_unique_topology (line 2039) | def get_db_unique_topology(self, db_name=None, prec=3, update_topology...
    method check_overlap (line 2102) | def check_overlap(self, reference_db, etol=2e-3, verbose=True):
    method print_info (line 2167) | def print_info(self, excluded_ids=None, cutoff=100):
    method plot_histogram (line 2200) | def plot_histogram(self, prop, ax=None, filename=None, xlim=None, nbin...
    method get_properties (line 2243) | def get_properties(self, prop):

FILE: pyxtal/descriptor.py
  function _qlm (line 12) | def _qlm(dists, l=4):
  function correlation (line 57) | def correlation(coef1, coef2, angle=None, s=0):
  function correlation_opt (line 77) | def correlation_opt(coef1, coef2, angle, s=0):
  function correlation_go (line 105) | def correlation_go(coef1, coef2, M=6, s=0, d_cut=0.92):
  function fibonacci_sphere (line 135) | def fibonacci_sphere(N=1000):
  function cart2sph (line 158) | def cart2sph(x, y, z):
  function sph2cart (line 177) | def sph2cart(phi, theta, r):
  function xyz2sph (line 196) | def xyz2sph(xyzs, radian=True):
  function expand_sph (line 235) | def expand_sph(pts, l_max, norm=4, csphase=-1):
  function get_alignment (line 279) | def get_alignment(pts, degrees=True):
  class spherical_image (line 328) | class spherical_image:
    method __init__ (line 343) | def __init__(self, xtal, model="molecule", max_d=10, factor=2.2, lmax=...
    method calculate_density (line 373) | def calculate_density(self, pt, xyzs):
    method get_molecules (line 385) | def get_molecules(self):
    method get_contacts (line 409) | def get_contacts(self):
    method plot_sph_images (line 425) | def plot_sph_images(self, lmax=None, figname=None, molecule=False):
    method plot_real_image (line 488) | def plot_real_image(self, id=0):
    method align (line 494) | def align(self, M=6):
    method rotate (line 512) | def rotate(self, alpha=0, beta=0, gamma=0):
    method get_similarity (line 524) | def get_similarity(self, sph2, M=6, cutoff=0.95):
  class orientation_order (line 543) | class orientation_order:
    method __init__ (line 553) | def __init__(self, xtal, max_CN=14):
    method get_neighbors (line 558) | def get_neighbors(self):
    method get_parameters (line 579) | def get_parameters(self, ls=None):

FILE: pyxtal/elasticity.py
  function full_3x3_to_Voigt_6_index (line 46) | def full_3x3_to_Voigt_6_index(i, j):
  function Voigt_6_to_full_3x3_strain (line 55) | def Voigt_6_to_full_3x3_strain(strain_vector):
  function Voigt_6_to_full_3x3_stress (line 69) | def Voigt_6_to_full_3x3_stress(stress_vector):
  function full_3x3_to_Voigt_6_strain (line 77) | def full_3x3_to_Voigt_6_strain(strain_matrix):
  function full_3x3_to_Voigt_6_stress (line 94) | def full_3x3_to_Voigt_6_stress(stress_matrix):
  function Voigt_6x6_to_full_3x3x3x3 (line 111) | def Voigt_6x6_to_full_3x3x3x3(C):
  function full_3x3x3x3_to_Voigt_6x6 (line 136) | def full_3x3x3x3_to_Voigt_6x6(C):
  function Voigt_6x6_to_cubic (line 189) | def Voigt_6x6_to_cubic(C):
  function cubic_to_Voigt_6x6 (line 217) | def cubic_to_Voigt_6x6(C11, C12, C44):
  function _invariants (line 230) | def _invariants(
  function invariants (line 279) | def invariants(
  function rotate_cubic_elastic_constants (line 308) | def rotate_cubic_elastic_constants(C11, C12, C44, A, tol=1e-6):
  function rotate_elastic_constants (line 359) | def rotate_elastic_constants(C, A, tol=1e-6):
  class CubicElasticModuli (line 390) | class CubicElasticModuli:
    method __init__ (line 393) | def __init__(self, C11, C12, C44):
    method rotate (line 410) | def rotate(self, A):
    method _rotate_explicit (line 438) | def _rotate_explicit(self, A):
    method stiffness (line 474) | def stiffness(self):
    method compliance (line 481) | def compliance(self):
  function measure_triclinic_elastic_constants (line 492) | def measure_triclinic_elastic_constants(a, delta=0.001, optimizer=None, ...
  function _dec (line 635) | def _dec(pattern):
  function generate_strained_configs (line 729) | def generate_strained_configs(at0, symmetry="triclinic", N_steps=5, delt...
  function fit_elastic_constants (line 802) | def fit_elastic_constants(
  function youngs_modulus (line 1096) | def youngs_modulus(C, l):
  function poisson_ratio (line 1136) | def poisson_ratio(C, l, m):
  function elastic_moduli (line 1174) | def elastic_moduli(C, l=np.array([1, 0, 0]), R=None, tol=1e-6):
  function elastic_properties (line 1281) | def elastic_properties(C):

FILE: pyxtal/interface/LATTE_templates/latte_calc.py
  class LATTECalc (line 11) | class LATTECalc:
    method __init__ (line 24) | def __init__(
    method run (line 75) | def run(self):
    method to_ase (line 88) | def to_ase(self):
    method to_pyxtal (line 96) | def to_pyxtal(self):
    method _write_inputblock (line 110) | def _write_inputblock(self):
    method _apply_control_overrides (line 131) | def _apply_control_overrides(self):
    method _read_relax_from_control (line 205) | def _read_relax_from_control(self):
    method _execute (line 224) | def _execute(self):
    method _read_output (line 250) | def _read_output(self):
    method _read_restart_geometry (line 281) | def _read_restart_geometry(self):
  function latte_single_optimize (line 293) | def latte_single_optimize(

FILE: pyxtal/interface/LJ.py
  function get_neighbors (line 18) | def get_neighbors(struc, i, rcut):
  class LJ (line 33) | class LJ:
    method __init__ (line 38) | def __init__(self, epsilon=1.0, sigma=1.0, rcut=8.0):
    method calc (line 50) | def calc(self, struc, press=1e-4):
  class FIRE (line 80) | class FIRE:
    method __init__ (line 85) | def __init__(
    method initialize (line 125) | def initialize(self):
    method update (line 134) | def update(self, freq=50):
    method step (line 142) | def step(self):
    method run (line 198) | def run(self, max_steps=1000):
    method check_convergence (line 210) | def check_convergence(self):
    method symmetrized_coords (line 223) | def symmetrized_coords(self, coords):
    method symmetrized_force (line 256) | def symmetrized_force(self, coords):
    method symmetrized_stress (line 287) | def symmetrized_stress(self, stress):

FILE: pyxtal/interface/ase_opt.py
  function get_calculator (line 18) | def get_calculator(calculator):
  function ASE_relax (line 64) | def ASE_relax(

FILE: pyxtal/interface/ase_opt2.py
  function get_calculator (line 26) | def get_calculator(calculator):
  class ASE_optimizer (line 59) | class ASE_optimizer:
    method __init__ (line 71) | def __init__(self, struc, calculator="FAIRChem", opt_lat=True, logfile...
    method run (line 83) | def run(self, fmax_target=0.01):

FILE: pyxtal/interface/charmm.py
  class CHARMM (line 7) | class CHARMM:
    method __init__ (line 28) | def __init__(
    method run (line 106) | def run(self, clean=True):
    method execute (line 126) | def execute(self):
    method clean (line 154) | def clean(self):
    method write (line 161) | def write(self, cutoff=14.0):
    method read (line 280) | def read(self):
    method FFTGrid (line 353) | def FFTGrid(self, ABC):
  function check_prm (line 424) | def check_prm(path):
  class RTF (line 504) | class RTF:
    method __init__ (line 509) | def __init__(self, input):
    method parse (line 530) | def parse(self, rtf):
    method to_string (line 572) | def to_string(self):
    method to_file (line 598) | def to_file(self, filename="test.rtf"):
    method parse_mass (line 607) | def parse_mass(self, mass):
    method merge (line 615) | def merge(self, rtf1=None, single=None):
  class PRM (line 705) | class PRM:
    method __init__ (line 710) | def __init__(self, input):
    method parse (line 722) | def parse(self, prm):
    method to_string (line 782) | def to_string(self):
    method to_file (line 802) | def to_file(self, filename="test.prm"):
    method merge (line 811) | def merge(self, prm1=None, single=None):

FILE: pyxtal/interface/dftb.py
  function make_Hamiltonian (line 18) | def make_Hamiltonian(
  function DFTB_relax (line 174) | def DFTB_relax(
  function DFTB_SCF (line 240) | def DFTB_SCF(struc, skf_dir, kresol=0.10, folder="tmp", disp=None, filen...
  class DFTB (line 280) | class DFTB:
    method __init__ (line 294) | def __init__(
    method get_calculator (line 321) | def get_calculator(self, mode, step=500, ftol=1e-3, FixAngles=False, e...
    method run (line 405) | def run(self, mode, step=500, ftol=1e-3, FixAngles=False, md_params=No...
  class Dftb (line 435) | class Dftb(FileIOCalculator):
    method __init__ (line 450) | def __init__(
    method write_dftb_in (line 597) | def write_dftb_in(self, outfile):
    method check_state (line 640) | def check_state(self, atoms):
    method write_input (line 647) | def write_input(self, atoms, properties=None, system_changes=None):
    method read_results (line 659) | def read_results(self):
    method read_energy (line 696) | def read_energy(self):
    method read_forces (line 720) | def read_forces(self):
    method read_eigenvalues (line 742) | def read_eigenvalues(self):
    method read_fermi_levels (line 771) | def read_fermi_levels(self):
    method read_electrons (line 796) | def read_electrons(self):

FILE: pyxtal/interface/gulp.py
  class GULP (line 100) | class GULP:
    method __init__ (line 114) | def __init__(
    method set_catlow (line 172) | def set_catlow(self):
    method run (line 180) | def run(self, clean=True):
    method execute (line 193) | def execute(self):
    method clean (line 209) | def clean(self):
    method to_ase (line 219) | def to_ase(self):
    method to_pymatgen (line 222) | def to_pymatgen(self):
    method to_pyxtal (line 227) | def to_pyxtal(self):
    method write (line 240) | def write(self):
    method read (line 302) | def read(self):
  class GULP_OC (line 435) | class GULP_OC:
    method __init__ (line 452) | def __init__(
    method run (line 494) | def run(self, clean=True, pause=False):
    method execute (line 509) | def execute(self):
    method clean (line 520) | def clean(self):
    method write (line 524) | def write(self):
    method read (line 606) | def read(self):
  function single_optimize (line 686) | def single_optimize(
  function optimize (line 721) | def optimize(

FILE: pyxtal/interface/lammpslib.py
  function opt_lammpslib (line 16) | def opt_lammpslib(
  function run_lammpslib (line 75) | def run_lammpslib(
  function is_upper_triangular (line 149) | def is_upper_triangular(arr, atol=1e-8):
  function convert_cell (line 157) | def convert_cell(ase_cell):
  class LAMMPSlib (line 187) | class LAMMPSlib(Calculator):
    method __init__ (line 188) | def __init__(
    method calculate (line 222) | def calculate(self, atoms):
    method write_lammps_in (line 312) | def write_lammps_in(self):
    method write_lammps_data (line 362) | def write_lammps_data(self, atoms):
    method write_lammps_data_water (line 385) | def write_lammps_data_water(self, atoms):
    method update (line 451) | def update(self, atoms):
    method get_potential_energy (line 455) | def get_potential_energy(self, atoms, force_consistent=False):
    method get_forces (line 462) | def get_forces(self, atoms):
    method get_stress (line 466) | def get_stress(self, atoms):
  class LAMMPS_collections (line 471) | class LAMMPS_collections:
    method __init__ (line 476) | def __init__(self, temp=500):

FILE: pyxtal/interface/latte_calculator.py
  class LATTECalculator (line 15) | class LATTECalculator(Calculator):
    method __init__ (line 33) | def __init__(self, exe="./LATTE_DOUBLE", workdir=".", timeout=3600, **...
    method calculation_required (line 41) | def calculation_required(self, atoms, properties):
    method calculate (line 44) | def calculate(self, atoms=None, properties=("energy",), system_changes...
    method _write_inputblock (line 70) | def _write_inputblock(self, atoms):
    method _set_single_point_mode (line 87) | def _set_single_point_mode(self):
    method _run_latte (line 110) | def _run_latte(self):
    method _read_energy_from_log (line 120) | def _read_energy_from_log(self):
    method _read_stress_from_log (line 133) | def _read_stress_from_log(self):
    method _read_forces_from_cfg (line 153) | def _read_forces_from_cfg(self):
  function reorder_cif_and_fix_formula (line 205) | def reorder_cif_and_fix_formula(infile, outfile, desired_order=("O", "H"...
  function log_stress (line 263) | def log_stress(atoms, filename="stress_log.txt"):

FILE: pyxtal/interface/vasp.py
  class VASP (line 17) | class VASP:
    method __init__ (line 29) | def __init__(self, struc, path="tmp", cmd="mpirun -np 16 vasp_std"):
    method set_vasp (line 50) | def set_vasp(self, level=0, pstress=0.0000, setup=None):
    method read_OUTCAR (line 113) | def read_OUTCAR(self, path="OUTCAR"):
    method read_OSZICAR (line 125) | def read_OSZICAR(self, path="OSZICAR"):
    method read_bandgap (line 133) | def read_bandgap(self, path="vasprun.xml"):
    method run (line 139) | def run(self, setup=None, pstress=0, level=0, clean=True, read_gap=Fal...
    method clean (line 178) | def clean(self):
    method to_pymatgen (line 191) | def to_pymatgen(self):
    method to_pyxtal (line 196) | def to_pyxtal(self):
  function single_optimize (line 202) | def single_optimize(
  function single_point (line 242) | def single_point(struc, setup=None, path=None, clean=True):
  function optimize (line 261) | def optimize(
  function VASP_relax (line 299) | def VASP_relax(struc, opt_cell=False, step=100, kspacing=0.25, pstress=0...

FILE: pyxtal/io.py
  function in_merged_coords (line 24) | def in_merged_coords(wp, pt, pts, cell):
  function get_cif_str_for_pyxtal (line 46) | def get_cif_str_for_pyxtal(struc, header: str = "", sym_num=None, style:...
  function write_cif (line 179) | def write_cif(struc, filename=None, header="", permission="w", sym_num=N...
  function read_cif (line 203) | def read_cif(filename):
  class structure_from_ext (line 262) | class structure_from_ext:
    method __init__ (line 263) | def __init__(self, struc, ref_mols, tol=0.2, ignore_HH=False, add_H=Fa...
    method resort (line 317) | def resort(self, molecules):
    method add_Hydrogens (line 417) | def add_Hydrogens(self, smile, xyz):
    method make_mol_sites (line 458) | def make_mol_sites(self):
    method align (line 476) | def align(self):
    method show (line 503) | def show(self, overlay=True):
  function search_molecules_in_crystal (line 512) | def search_molecules_in_crystal(struc, tol=0.2, once=False, ignore_HH=Tr...

FILE: pyxtal/lattice.py
  class Lattice (line 13) | class Lattice:
    method __init__ (line 51) | def __init__(
    method _get_dof (line 150) | def _get_dof(self):
    method get_bounds (line 165) | def get_bounds(self, min_vec=2.0, max_vec=50.0, min_ang=30, max_ang=150):
    method get_dofs (line 184) | def get_dofs(self, ltype):
    method copy (line 202) | def copy(self):
    method get_lengths (line 210) | def get_lengths(self):
    method scale (line 215) | def scale(self, factor=1.1):
    method get_permutation_matrices (line 220) | def get_permutation_matrices(self):
    method get_transformation_matrices (line 243) | def get_transformation_matrices(self):
    method search_transformations (line 287) | def search_transformations(self, lat_ref, d_tol=1.0, f_tol=0.1):
    method search_transformation (line 337) | def search_transformation(self, lat_ref, d_tol=1.0, f_tol=0.1):
    method optimize_once (line 404) | def optimize_once(self, reset=False):
    method get_worst_angle (line 428) | def get_worst_angle(self):
    method optimize_multi (line 434) | def optimize_multi(self, iterations=5):
    method standardize (line 455) | def standardize(self):
    method transform (line 479) | def transform(self, trans_mat=None, reset=False):
    method transform_multi (line 493) | def transform_multi(self, trans, reset=True):
    method encode (line 502) | def encode(self):
    method from_1d_representation (line 516) | def from_1d_representation(self, v, ltype):
    method update_from_1d_representation (line 535) | def update_from_1d_representation(self, v):
    method mutate (line 560) | def mutate(self, degree=0.10, frozen=False):
    method generate_para (line 599) | def generate_para(self):
    method generate_matrix (line 610) | def generate_matrix(self):
    method get_matrix (line 621) | def get_matrix(self, shape="upper"):
    method get_para (line 627) | def get_para(self, degree=False):
    method set_matrix (line 643) | def set_matrix(self, matrix=None):
    method set_para (line 666) | def set_para(self, para=None, radians=False):
    method update_para (line 676) | def update_para(self, id, change):
    method reset_matrix (line 681) | def reset_matrix(self, shape="upper"):
    method set_volume (line 707) | def set_volume(self, volume):
    method swap_axis (line 711) | def swap_axis(self, random=False, ids=None):
    method swap_angle (line 765) | def swap_angle(self, random=True, ids=None):
    method add_vacuum (line 798) | def add_vacuum(self, coor, frac=True, vacuum=15, PBC=None):
    method generate_point (line 825) | def generate_point(self):
    method from_para (line 846) | def from_para(
    method from_matrix (line 932) | def from_matrix(
    method is_valid_matrix (line 1014) | def is_valid_matrix(self):
    method is_valid_lattice (line 1026) | def is_valid_lattice(self, tol=1e-3):
    method check_mismatch (line 1057) | def check_mismatch(self, trans, l_type, tol=1.0, a_tol=10):
    method get_diff (line 1081) | def get_diff(self, l_ref):
    method __str__ (line 1102) | def __str__(self, fmt='8.4f', ltype=True):
    method __repr__ (line 1108) | def __repr__(self):
    method find_transition_to_orthoslab (line 1111) | def find_transition_to_orthoslab(self, c=(0, 0, 1), a=(1, 0, 0), m=5):
    method apply_transformation (line 1180) | def apply_transformation(self, trans):
  function generate_cellpara (line 1188) | def generate_cellpara(
  function generate_cellpara_2D (line 1352) | def generate_cellpara_2D(
  function generate_cellpara_1D (line 1558) | def generate_cellpara_1D(
  function generate_cellpara_0D (line 1767) | def generate_cellpara_0D(
  function matrix2para (line 1828) | def matrix2para(matrix, radians=True):
  function para2matrix (line 1868) | def para2matrix(cell_para, radians=True, format="upper"):
  function gaussian_random_variable (line 1940) | def gaussian_random_variable(min, max, sigma=3.0, random_state: None | i...
  function random_vector (line 1971) | def random_vector(minvec=None, maxvec=None, width=0.35, unit=False, rand...
  function random_shear_matrix (line 2006) | def random_shear_matrix(width=1.0, unitary=False, random_state: None | i...

FILE: pyxtal/lego/SO3.py
  class SO3 (line 7) | class SO3:
    method __init__ (line 21) | def __init__(self, nmax=3, lmax=3, rcut=3.5, alpha=2.0,
    method __str__ (line 40) | def __str__(self):
    method __repr__ (line 45) | def __repr__(self):
    method load_from_dict (line 48) | def load_from_dict(self, dict0):
    method save_dict (line 55) | def save_dict(self):
    method nmax (line 69) | def nmax(self):
    method nmax (line 73) | def nmax(self, nmax):
    method lmax (line 84) | def lmax(self):
    method lmax (line 88) | def lmax(self, lmax):
    method rcut (line 99) | def rcut(self):
    method rcut (line 103) | def rcut(self, rcut):
    method alpha (line 112) | def alpha(self):
    method alpha (line 116) | def alpha(self, alpha):
    method cutoff_function (line 125) | def cutoff_function(self):
    method cutoff_function (line 129) | def cutoff_function(self, cutoff_function):
    method clear_memory (line 132) | def clear_memory(self):
    method init_atoms (line 142) | def init_atoms(self, atoms, atom_ids=None):
    method compute_p (line 150) | def compute_p(self, atoms, atom_ids=None, return_rdf=False, CN_max=12,...
    method dist2rdf (line 192) | def dist2rdf(self, dists, num_bins=20, sigma=0.5):
    method compute_dpdr (line 227) | def compute_dpdr(self, atoms, atom_ids=None):
    method compute_dpdr_5d (line 290) | def compute_dpdr_5d(self, atoms, atom_ids=None):
    method calculate (line 349) | def calculate(self, atoms, atom_ids=None, derivative=False):
    method build_neighbor_list (line 373) | def build_neighbor_list(self, atom_ids=None):
  function Cosine (line 454) | def Cosine(Rij, Rc, derivative=False):
  function W (line 462) | def W(nmax):
  function phi (line 477) | def phi(r, alpha, rcut):
  function g (line 483) | def g(r, n, nmax, rcut, w):
  function GaussChebyshevQuadrature (line 491) | def GaussChebyshevQuadrature(nmax, lmax):
  function compute_cs (line 500) | def compute_cs(pos, nmax, lmax, rcut, alpha, cutoff):
  function compute_dcs (line 575) | def compute_dcs(pos, nmax, lmax, rcut, alpha, cutoff):

FILE: pyxtal/lego/basinhopping.py
  class Storage (line 19) | class Storage:
    method __init__ (line 23) | def __init__(self, minres):
    method _add (line 26) | def _add(self, minres):
    method update (line 30) | def update(self, minres):
    method get_lowest (line 39) | def get_lowest(self):
  class BasinHoppingRunner (line 43) | class BasinHoppingRunner:
    method __init__ (line 66) | def __init__(self, x0, minimizer, step_taking, accept_tests, disp=False):
    method _monte_carlo_step (line 105) | def _monte_carlo_step(self):
    method one_cycle (line 165) | def one_cycle(self):
    method print_report (line 196) | def print_report(self, energy_trial, accept):
  class AdaptiveStepsize (line 204) | class AdaptiveStepsize:
    method __init__ (line 227) | def __init__(self, takestep, accept_rate=0.5, interval=50, factor=0.9,
    method __call__ (line 239) | def __call__(self, x):
    method _adjust_step_size (line 242) | def _adjust_step_size(self):
    method take_step (line 258) | def take_step(self, x):
    method report (line 265) | def report(self, accept, **kwargs):
  class RandomDisplacement (line 271) | class RandomDisplacement:
    method __init__ (line 292) | def __init__(self, stepsize=0.5, random_gen=None):
    method __call__ (line 296) | def __call__(self, x):
  class MinimizerWrapper (line 301) | class MinimizerWrapper:
    method __init__ (line 306) | def __init__(self, minimizer, func=None, **kwargs):
    method __call__ (line 311) | def __call__(self, x0):
  class Metropolis (line 333) | class Metropolis:
    method __init__ (line 353) | def __init__(self, T, random_gen=None):
    method accept_reject (line 360) | def accept_reject(self, res_new, res_old):
    method __call__ (line 383) | def __call__(self, *, res_new, res_old):
  function basinhopping (line 390) | def basinhopping(func, x0, niter=100, T=1.0, stepsize=0.5,

FILE: pyxtal/lego/builder.py
  function generate_wp_lib_par (line 42) | def generate_wp_lib_par(spgs, composition, num_wp, num_fu, num_dof):
  function generate_xtal_par (line 54) | def generate_xtal_par(wp_libs, niter, dim, elements, calculator, ref_env...
  function minimize_from_x_par (line 70) | def minimize_from_x_par(*args):
  function generate_xtal (line 89) | def generate_xtal(dim, spg, wps, niter, elements, calculator,
  function minimize_from_x (line 137) | def minimize_from_x(x, dim, spg, wps, elements, calculator, ref_environm...
  class builder (line 352) | class builder(object):
    method __init__ (line 372) | def __init__(self, elements, composition, dim=3, prefix='mof',
    method __str__ (line 405) | def __str__(self):
    method __repr__ (line 423) | def __repr__(self):
    method print_memory_usage (line 426) | def print_memory_usage(self):
    method set_descriptor_calculator (line 433) | def set_descriptor_calculator(self, dtype='SO3', mykwargs={}):
    method set_reference_enviroments (line 452) | def set_reference_enviroments(self, cif_file, substitute=None):
    method set_criteria (line 487) | def set_criteria(self, CN=None, dimension=None, min_density=None, excl...
    method get_input_from_letters (line 510) | def get_input_from_letters(self, spg, wps):
    method get_input_from_ref_xtal (line 520) | def get_input_from_ref_xtal(self, xtal, substitute=None):
    method get_similarity (line 550) | def get_similarity(self, xtal):
    method process_xtals (line 565) | def process_xtals(self, xtals, xs, add_db, symmetrize):
    method optimize_xtals (line 586) | def optimize_xtals(self, xtals, ncpu=1, opt_type='local',
    method optimize_xtals_serial (line 606) | def optimize_xtals_serial(self, xtals, args):
    method optimize_xtals_mproc (line 622) | def optimize_xtals_mproc(self, xtals, ncpu, args):
    method optimize_reps (line 682) | def optimize_reps(self, reps, ncpu=1, opt_type='local',
    method optimize_reps_serial (line 701) | def optimize_reps_serial(self, reps, args, N_grids):
    method optimize_reps_mproc (line 729) | def optimize_reps_mproc(self, reps, ncpu, args, N_grids):
    method optimize_xtal (line 799) | def optimize_xtal(self, xtal, count=0, opt_type='local',
    method generate_xtal (line 860) | def generate_xtal(self, spg, wps, niter, T=0.2, N_max=5,
    method generate_xtals_from_wp_libs (line 892) | def generate_xtals_from_wp_libs(self, wp_libs, N_max=5, ncpu=1,
    method get_wp_libs_from_spglist (line 948) | def get_wp_libs_from_spglist(self, spg_list,
    method get_wp_libs_from_xtals (line 1025) | def get_wp_libs_from_xtals(self, db_file=None,
    method import_structures (line 1073) | def import_structures(self, db_file, ids=(None, None),
    method process_xtal (line 1131) | def process_xtal(self, xtal, sim, count=0, xs=None, energy=None,
  class RandomDispBounds (line 1180) | class RandomDispBounds(object):
    method __init__ (line 1186) | def __init__(self, xmin, xmax, id1, id2, stepsize=0.1, dumpfile=None):
    method __call__ (line 1194) | def __call__(self, x):

FILE: pyxtal/lego/util.py
  function get_input_from_letters (line 5) | def get_input_from_letters(spg, sites, dim=3):
  function create_trajectory (line 32) | def create_trajectory(dumpfile, trjfile, modes=['Init', 'Iter'], dim=3):
  function calculate_dSdx (line 96) | def calculate_dSdx(x, xtal, des_ref, f, eps=1e-4, symmetry=True, verbose...
  function calculate_S (line 151) | def calculate_S(x, xtal, des_ref, f, return_rdf=False):

FILE: pyxtal/miscellaneous/LJ_bug.py
  function LJ (line 27) | def LJ(pos, dim, method=1, mu=0.1):
  function LJ_force (line 53) | def LJ_force(pos, dim, method=1, mu=0.1):
  function single_optimize (line 76) | def single_optimize(pos, dim=3, method=1, mu=0.1):
  function hyper_optimize (line 105) | def hyper_optimize(pos, dim, method=1, mu=0.1):
  function parse_symmetry (line 129) | def parse_symmetry(pos):
  class LJ_prediction (line 138) | class LJ_prediction:
    method __init__ (line 147) | def __init__(self, numIons, seed=None):
    method generate_cluster (line 155) | def generate_cluster(self, pgs=(2, 33)):
    method predict (line 164) | def predict(self, dim=3, maxN=100, ncpu=2, pgs=(2, 33), method=1):
    method relaxation (line 188) | def relaxation(self, dim, pgs, method, ind):

FILE: pyxtal/miscellaneous/Random_vasp_ase.py
  function pymatgen2ase (line 32) | def pymatgen2ase(struc):
  function ase2pymatgen (line 38) | def ase2pymatgen(struc):
  function symmetrize_cell (line 45) | def symmetrize_cell(struc, mode="C"):
  function set_vasp (line 59) | def set_vasp(level=0, pstress=0.0000, setup=None):
  function read_OUTCAR (line 124) | def read_OUTCAR(path="OUTCAR"):
  function good_lattice (line 137) | def good_lattice(struc):
  function optimize (line 142) | def optimize(struc, dir1):

FILE: pyxtal/miscellaneous/check_cluster_distances.py
  function check_cluster_distances (line 4) | def check_cluster_distances(cluster, tol):

FILE: pyxtal/miscellaneous/compatibility.py
  function get_ase_mol (line 11) | def get_ase_mol(molname):

FILE: pyxtal/miscellaneous/create_generators.py
  function rounded (line 9) | def rounded(op):

FILE: pyxtal/miscellaneous/debug_charmm.py
  function parse_input (line 1) | def parse_input(input_file):
  function parse_crd (line 24) | def parse_crd(crd_file):
  function parse_pdb (line 44) | def parse_pdb(pdb_file):
  function write_cif (line 65) | def write_cif(atoms, cell_params, symops, spgnum, outfile):

FILE: pyxtal/miscellaneous/distance_bug.py
  function find_short (line 6) | def find_short(dm):

FILE: pyxtal/miscellaneous/from_ase_molecule.py
  function get_ase_mol (line 11) | def get_ase_mol(molname):

FILE: pyxtal/miscellaneous/get_lj_cluster.py
  function parse_symmetry (line 23) | def parse_symmetry(pos):
  function get_lj_from_url (line 29) | def get_lj_from_url(N, address="http://doye.chem.ox.ac.uk/jon/structures...
  function parse_url_text (line 46) | def parse_url_text(data_str):
  function LJ (line 54) | def LJ(pos):

FILE: pyxtal/miscellaneous/get_molecule_from_pubchem.py
  class NumpyEncoder (line 12) | class NumpyEncoder(json.JSONEncoder):
    method default (line 13) | def default(self, obj):
  function read_molecule (line 19) | def read_molecule(mol, name):

FILE: pyxtal/miscellaneous/grid.py
  function op1 (line 18) | def op1(p): return p                           # (x, y)
  function op2 (line 19) | def op2(p): return np.array([-p[1], p[0] - p[1]])  # (-y, x-y)
  function op3 (line 20) | def op3(p): return np.array([-p[0] + p[1], -p[0]])  # (-x+y, -x)
  function op4 (line 21) | def op4(p): return -p                          # (-x, -y)
  function op5 (line 22) | def op5(p): return np.array([p[1], -p[0] + p[1]])   # (y, -x+y)
  function op6 (line 23) | def op6(p): return np.array([p[0] - p[1], p[0]])    # (x-y, x)
  function op7 (line 24) | def op7(p): return np.array([-p[1], -p[0]])         # (-y, -x)
  function op8 (line 25) | def op8(p): return np.array([-p[0] + p[1], p[1]])   # (-x+y, y)
  function op9 (line 26) | def op9(p): return np.array([p[0], p[0] - p[1]])    # (x, x-y)
  function op10 (line 27) | def op10(p): return np.array([p[1], p[0]])          # (y, x)
  function op11 (line 28) | def op11(p): return np.array([p[0] - p[1], -p[1]])   # (x-y, -y)
  function op12 (line 29) | def op12(p): return np.array([-p[0], -p[0] + p[1]])  # (-x, -x+y)
  function frac_to_cart (line 31) | def frac_to_cart(f):

FILE: pyxtal/miscellaneous/regen_wyckoffs_list.py
  function so (line 4) | def so(string):
  function extras (line 8) | def extras(sg):

FILE: pyxtal/miscellaneous/search_csd_from_pubchem.py
  function get_similar_cids (line 8) | def get_similar_cids(base, MaxRecords):
  function check_for_ccdc_structures (line 39) | def check_for_ccdc_structures(cid):

FILE: pyxtal/miscellaneous/test_all.py
  function newprint (line 11) | def newprint(text):
  class Logger (line 29) | class Logger:
    method __init__ (line 30) | def __init__(self):
    method write (line 34) | def write(self, message):
    method flush (line 38) | def flush(self):
  function compare_wyckoffs (line 48) | def compare_wyckoffs(num1, num2, dim=3):
  function check_struct_group (line 92) | def check_struct_group(crystal, group, dim=3, tol=1e-2):
  function passed (line 179) | def passed():
  function reset (line 186) | def reset():
  function fail (line 194) | def fail(*argv):
  function check (line 213) | def check():
  function end (line 221) | def end(condition=1):
  function test_atomic (line 234) | def test_atomic():
  function test_molecular (line 322) | def test_molecular():
  function test_atomic_2D (line 411) | def test_atomic_2D():
  function test_molecular_2D (line 467) | def test_molecular_2D():
  function test_atomic_1D (line 523) | def test_atomic_1D():
  function test_molecular_1D (line 597) | def test_molecular_1D():
  function test_cluster (line 671) | def test_cluster():
  function test_modules (line 726) | def test_modules():

FILE: pyxtal/miscellaneous/test_db.py
  function get_wyckoffs (line 32) | def get_wyckoffs(sg):

FILE: pyxtal/miscellaneous/test_euclidean.py
  function test (line 7) | def test(spg, pt, cell):

FILE: pyxtal/miscellaneous/test_matrix.py
  function mat_a (line 14) | def mat_a(a):
  function mat_b (line 18) | def mat_b(b):
  function mat_c (line 22) | def mat_c(c):
  function strain_matrix (line 26) | def strain_matrix(a, b, c):
  function shear_matrix (line 34) | def shear_matrix(a, b, c):
  function random_strain (line 38) | def random_strain():
  function random_matrix (line 46) | def random_matrix(width=1.0, unitary=False):

FILE: pyxtal/miscellaneous/web_scalping_script/pubchem_import.py
  function get_similar_cids (line 9) | def get_similar_cids(base, MaxRecords):
  function check_for_ccdc_structures (line 26) | def check_for_ccdc_structures(cids):
  function ccdcid_scalper (line 63) | def ccdcid_scalper(cids):

FILE: pyxtal/molecular_crystal.py
  class molecular_crystal (line 20) | class molecular_crystal:
    method __init__ (line 49) | def __init__(
    method __str__ (line 135) | def __str__(self):
    method __repr__ (line 148) | def __repr__(self):
    method set_sites (line 151) | def set_sites(self, sites):
    method set_molecules (line 183) | def set_molecules(self, molecules, torsions):
    method set_orientations (line 221) | def set_orientations(self):
    method set_volume (line 251) | def set_volume(self):
    method set_lattice (line 260) | def set_lattice(self, lattice):
    method set_crystal (line 318) | def set_crystal(self):
    method _set_coords (line 352) | def _set_coords(self):
    method _set_mol_wyckoffs (line 372) | def _set_mol_wyckoffs(self, id, numMol, pyxtal_mol, valid_ori, mol_wyks):
    method _set_orientation (line 457) | def _set_orientation(self, pyxtal_mol, pt, oris, wp):
    method _check_consistency (line 491) | def _check_consistency(self, site, numMol):

FILE: pyxtal/molecule.py
  function find_rotor_from_smile (line 34) | def find_rotor_from_smile(smile):
  function has_non_aromatic_ring (line 130) | def has_non_aromatic_ring(smiles):
  function generate_molecules (line 159) | def generate_molecules(smile, wps=None, N_iter=5, N_conf=10, tol=0.5, us...
  class pyxtal_molecule (line 234) | class pyxtal_molecule:
    method list_molecules (line 266) | def list_molecules():
    method __init__ (line 272) | def __init__(
    method __str__ (line 365) | def __str__(self):
    method save_str (line 368) | def save_str(self):
    method load_str (line 375) | def load_str(cls, string):
    method copy (line 382) | def copy(self):
    method swap_axis (line 388) | def swap_axis(self, ax):
    method get_box (line 397) | def get_box(self, padding=None):
    method get_lengths (line 425) | def get_lengths(self):
    method get_max_length (line 430) | def get_max_length(self):
    method get_box_coordinates (line 434) | def get_box_coordinates(self, xyz, padding=0, resolution=1.0):
    method get_radius (line 504) | def get_radius(self):
    method get_symbols (line 520) | def get_symbols(self):
    method get_tols_matrix (line 523) | def get_tols_matrix(self, mol2=None, tm=None):
    method set_labels (line 559) | def set_labels(self):
    method get_coefs_matrix (line 675) | def get_coefs_matrix(self, mol2=None, ignore_error=True):
    method show (line 815) | def show(self):
    method show_box (line 823) | def show_box(self):
    method rdkit_mol (line 831) | def rdkit_mol(self, N_confs=1):
    method rdkit_mol_init (line 844) | def rdkit_mol_init(self, smile, fix, torsions):
    method perturb_torsion (line 919) | def perturb_torsion(self, xyz):
    method align (line 929) | def align(self, conf, reflect=False, torsionlist=None):
    method get_center (line 967) | def get_center(self, xyz, geometry=False):
    method get_principle_axes (line 1006) | def get_principle_axes(self, xyz, rdmt=True):
    method get_torsion_angles (line 1025) | def get_torsion_angles(self, xyz=None, torsionlist=None):
    method set_torsion_angles (line 1060) | def set_torsion_angles(self, conf, angles, reflect=False, torsionlist=...
    method relax (line 1074) | def relax(self, xyz, align=False):
    method get_rmsd2 (line 1103) | def get_rmsd2(self, xyz0, xyz1):
    method get_rmsd (line 1134) | def get_rmsd(self, xyz, debug=False):
    method get_orientation (line 1186) | def get_orientation(self, xyz, rtol=0.15):
    method to_ase (line 1258) | def to_ase(self):
    method reset_positions (line 1264) | def reset_positions(self, coors):
    method apply_inversion (line 1278) | def apply_inversion(self):
    method get_symmetry (line 1289) | def get_symmetry(self, xyz=None, symmetrize=False, rtol=0.30):
    method get_orientations_in_wps (line 1359) | def get_orientations_in_wps(self, wps=None, rtol=1e-2):
    method get_orientations_in_wp (line 1380) | def get_orientations_in_wp(self, wp, rtol=1e-2):
    method get_energy (line 1577) | def get_energy(self, xyz1, xyz2):
  class Box (line 1584) | class Box:
    method __init__ (line 1592) | def __init__(self, dims):
    method __str__ (line 1598) | def __str__(self):
    method operate (line 1601) | def operate(self, rot=np.eye(3), center=np.zeros(3)):
  class Orientation (line 1612) | class Orientation:
    method __init__ (line 1632) | def __init__(self, matrix=None, degrees=2, axis=None, random_state=None):
    method __str__ (line 1651) | def __str__(self):
    method reset_matrix (line 1663) | def reset_matrix(self, matrix):
    method __repr__ (line 1667) | def __repr__(self):
    method copy (line 1670) | def copy(self):
    method save_dict (line 1673) | def save_dict(self):
    method load_dict (line 1677) | def load_dict(cls, dicts):
    method change_orientation (line 1683) | def change_orientation(self, angle="random", flip=False, update=True):
    method set_axis (line 1729) | def set_axis(self):
    method rotate_by_matrix (line 1736) | def rotate_by_matrix(self, matrix, ignore_constraint=True):
    method get_matrix (line 1759) | def get_matrix(self, angle="random"):
    method get_op (line 1791) | def get_op(self):  # , angle=None):
    method random_orientation (line 1810) | def random_orientation(self):
    method get_Euler_angles (line 1822) | def get_Euler_angles(self):
  function get_inertia_tensor (line 1829) | def get_inertia_tensor(coords, weights=None):
  function reoriented_molecule (line 1853) | def reoriented_molecule(mol):
  function is_compatible_symmetry (line 1880) | def is_compatible_symmetry(mol, wp):
  function make_graph (line 1895) | def make_graph(mol, tol=0.2, ignore_HH=False):
  function compare_mol_connectivity (line 1932) | def compare_mol_connectivity(mol1, mol2, ignore_name=False, ignore_HH=Fa...

FILE: pyxtal/msg.py
  function printx (line 6) | def printx(text, priority=1):
  class Error (line 29) | class Error(Exception):
  class ConformerError (line 33) | class ConformerError(Error):
    method __init__ (line 41) | def __init__(self, message):
  class Symm_CompatibilityError (line 45) | class Symm_CompatibilityError(Error):
    method __init__ (line 53) | def __init__(self, message):
  class Comp_CompatibilityError (line 57) | class Comp_CompatibilityError(Error):
    method __init__ (line 65) | def __init__(self, message):
  class ReadSeedError (line 69) | class ReadSeedError(Error):
    method __init__ (line 77) | def __init__(self, message):
  class VolumeError (line 81) | class VolumeError(Error):
    method __init__ (line 89) | def __init__(self, message):
  class CSDError (line 93) | class CSDError(Error):
    method __init__ (line 101) | def __init__(self, message):
  class AtomTypeError (line 105) | class AtomTypeError(Error):
    method __init__ (line 113) | def __init__(self, message):

FILE: pyxtal/operations.py
  function check_distance (line 24) | def check_distance(
  function verify_distances (line 78) | def verify_distances(coordinates, species, lattice, factor=1.0, PBC=None):
  function check_images (line 111) | def check_images(
  function distance (line 174) | def distance(xyz, lattice, PBC=None):
  function distance_matrix (line 200) | def distance_matrix(pts1, pts2, lattice, PBC=None, single=False, metric=...
  function distance_matrix_no_PBC (line 245) | def distance_matrix_no_PBC(pts1, pts2, lattice, single=False, metric="eu...
  function create_matrix (line 271) | def create_matrix(PBC=None, omit=False):
  function filtered_coords (line 300) | def filtered_coords(coords, PBC=None):
  function filtered_coords_euclidean (line 328) | def filtered_coords_euclidean(coords, PBC=None):
  function get_inverse (line 358) | def get_inverse(op):
  function get_inverse_ops (line 416) | def get_inverse_ops(ops):
  function apply_ops (line 435) | def apply_ops(coord, ops):
  function apply_ops_diagonal (line 453) | def apply_ops_diagonal(coords, ops):
  function angle (line 470) | def angle(v1, v2, radians=True):
  function is_orthogonal (line 499) | def is_orthogonal(m, tol=0.001):
  function aa2matrix (line 516) | def aa2matrix(axis, angle, radians=True, random=False):
  function rotate_vector (line 564) | def rotate_vector(v1, v2, rtol=1e-4):
  function are_equal (line 598) | def are_equal(op1, op2, PBC=None, rtol=1e-3, atol=1e-3):
  class OperationAnalyzer (line 637) | class OperationAnalyzer(SymmOp):
    method get_order (line 659) | def get_order(angle, rotoinversion=False, tol=1e-2):
    method __init__ (line 681) | def __init__(self, op, parse_trans=False, hexagonal=False):
    method parse_screw_symmetry (line 806) | def parse_screw_symmetry(self, tol=1e-2):
    method parse_glide_symmetry (line 865) | def parse_glide_symmetry(self, tol=1e-2):
    method parse_axis (line 913) | def parse_axis(self):
    method __str__ (line 928) | def __str__(self):
    method is_conjugate (line 948) | def is_conjugate(self, op2):
    method are_conjugate (line 987) | def are_conjugate(op1, op2):
  function find_ids (line 1006) | def find_ids(coords, ref, tol=1e-3):
  function get_best_match (line 1024) | def get_best_match(positions, ref, cell):

FILE: pyxtal/optimize/DFS.py
  class DFS (line 18) | class DFS(GlobalOptimize):
    method __init__ (line 53) | def __init__(
    method full_str (line 151) | def full_str(self):
    method _run (line 159) | def _run(self, pool=None):
    method load (line 271) | def load(cls, filename):

FILE: pyxtal/optimize/QRS.py
  function generate_qrs_cell (line 19) | def generate_qrs_cell(sampler, cell_bounds, ref_volume, ltype):
  function generate_qrs_xtals (line 38) | def generate_qrs_xtals(cell, wp_bounds, N_pop, smiles, comp, sampler_wp=...
  class QRS (line 85) | class QRS(GlobalOptimize):
    method __init__ (line 119) | def __init__(
    method full_str (line 205) | def full_str(self):
    method _run (line 212) | def _run(self, pool=None):

FILE: pyxtal/optimize/WFS.py
  class WFS (line 18) | class WFS(GlobalOptimize):
    method __init__ (line 55) | def __init__(
    method full_str (line 160) | def full_str(self):
    method _run (line 168) | def _run(self, pool=None):
    method _selTournament (line 260) | def _selTournament(self, fitness, factor=0.35):
    method load (line 272) | def load(cls, filename):

FILE: pyxtal/optimize/base.py
  function setup_worker_logger (line 34) | def setup_worker_logger(log_file):
  function run_optimizer_with_timeout (line 44) | def run_optimizer_with_timeout(args, logger):
  function process_task (line 74) | def process_task(args):
  class GlobalOptimize (line 85) | class GlobalOptimize:
    method __init__ (line 118) | def __init__(
    method print (line 323) | def print(self, *args, **kwargs):
    method __str__ (line 328) | def __str__(self):
    method __repr__ (line 362) | def __repr__(self):
    method new_struc (line 365) | def new_struc(self, xtal, xtals):
    method run (line 368) | def run(self, ref_pmg=None, ref_pxrd=None):
    method select_xtals (line 410) | def select_xtals(self, ref_xtals, ids, N_max):
    method count_pxrd_match (line 424) | def count_pxrd_match(self, xtals, matches):
    method success_count (line 447) | def success_count(self, xtals, matches):
    method early_termination (line 482) | def early_termination(self, success_rate):
    method export_references (line 501) | def export_references(self, xtals, engs, N_min=50, dE=2.5, FMSE=2.5):
    method _prep_chm_info (line 575) | def _prep_chm_info(self, params0, params1=None, folder="calc", suffix=...
    method get_label (line 610) | def get_label(self, i, label='cpu'):
    method print_matches (line 619) | def print_matches(self, header=None):
    method _print_match (line 667) | def _print_match(self, xtal, ref_pmg):
    method _apply_gaussian (line 688) | def _apply_gaussian(self, reps, engs, h1=0.1, h2=0.1, w1=0.2, w2=3):
    method check_ref (line 745) | def check_ref(self, reps=None, reference=None, filename="pyxtal.cif"):
    method _get_local_optimization_args (line 800) | def _get_local_optimization_args(self):
    method local_optimization (line 830) | def local_optimization(self, xtals, qrs=False, pool=None):
    method local_optimization_serial (line 846) | def local_optimization_serial(self, xtals, qrs=False):
    method local_optimization_mpi (line 872) | def local_optimization_mpi(self, xtals, qrs, pool):
    method local_optimization_mproc (line 920) | def local_optimization_mproc(self, xtals, ncpu, ids=None, qrs=False, p...
    method gen_summary (line 966) | def gen_summary(self, t0, gen_results, xtals):
    method plot_results (line 1060) | def plot_results(self, save=True, figsize=(8.0, 5.0), figname=None, yl...
    method save (line 1146) | def save(self, filename):
  function load_xml (line 1192) | def load_xml(filename, tag='GO'):
  function text_to_list (line 1247) | def text_to_list(text, dtype=float):
  function text_to_arr (line 1258) | def text_to_arr(text, dtype=float):
  function text_to_2darr (line 1268) | def text_to_2darr(text, dtype=float):
  function text_to_float (line 1278) | def text_to_float(text):
  function text_to_bool (line 1287) | def text_to_bool(text):
  function arr_to_text (line 1296) | def arr_to_text(arr):

FILE: pyxtal/optimize/benchmark.py
  class benchmark (line 13) | class benchmark:
    method __init__ (line 23) | def __init__(self, struc, smiles, clean=True, work_dir="tmp", **kwargs):
    method calc (line 90) | def calc(self, calculator, show=True):
    method dftb (line 114) | def dftb(self, disp, show=True, logfile="ase.log"):
    method vasp (line 143) | def vasp(self, show=True):
    method ani (line 163) | def ani(self, show=True, logfile="ase-ani.log"):
    method charmm (line 191) | def charmm(self, show=True, steps=None):
    method gulp (line 216) | def gulp(self, show=True, step=None, stepmx=None):
    method charmm_md (line 263) | def charmm_md(self):
    method summary (line 266) | def summary(self, calc=None):

FILE: pyxtal/optimize/common.py
  function get_rmsd_with_timeout (line 25) | def get_rmsd_with_timeout(matcher, ref_pmg, structure, timeout=10):
  function sweep (line 45) | def sweep(xtal, comp, c_info, w_dir, job_tag, mlp, skip_mlp, optimizer, ...
  function check_stable_structure (line 110) | def check_stable_structure(xtal, c_info, w_dir, job_tag, mlp, skip_mlp, ...
  function mutator (line 153) | def mutator(xtal, smiles, opt_lat, ref_pxrd=None, dr=0.125, random_state...
  function randomizer (line 227) | def randomizer(
  function optimizer (line 311) | def optimizer(
  function optimizer_par (line 470) | def optimizer_par(
  function optimizer_single (line 543) | def optimizer_single(
  function refine_struc (line 665) | def refine_struc(xtal, smiles, calculator, mlp):
  function compute_par (line 686) | def compute_par(row, pmg, work_dir, skf_dir, queue, compute):
  function compute (line 698) | def compute(row, pmg, work_dir, skf_dir, info=None):
  function load_reference_from_db (line 760) | def load_reference_from_db(db_name, code=None):

FILE: pyxtal/plane.py
  function has_reduction (line 9) | def has_reduction(hkl):
  function reduced_hkl (line 20) | def reduced_hkl(hkl):
  function structure_factor (line 28) | def structure_factor(pos, hkl, total=True):
  function get_dspacing (line 36) | def get_dspacing(inv_matrix, hkl):
  class planes (line 39) | class planes:
    method __init__ (line 53) | def __init__(self, extent=6, d_min=1.5, cp_factor=0.5):
    method set_xtal (line 60) | def set_xtal(self, xtal):
    method set_planes (line 65) | def set_planes(self):
    method get_cp_factor (line 72) | def get_cp_factor(self, hkl):
    method search_close_packing_planes (line 87) | def search_close_packing_planes(self, N_max=10):
    method get_structure_factor (line 114) | def get_structure_factor(self, hkl):
    method get_separation (line 117) | def get_separation(self, hkl):
    method group_slabs (line 165) | def group_slabs(self, slabs, tol):
    method find_unique_separations (line 204) | def find_unique_separations(self, groups, d):
    method gather (line 213) | def gather(self, planes, tol=-0.1):
  class plane (line 229) | class plane:
    method __init__ (line 234) | def __init__(self, hkl, cell_reciprocal, separation=None):
    method __str__ (line 241) | def __str__(self):

FILE: pyxtal/potentials/LJ_cluster.py
  function LJ (line 9) | def LJ(pos, dim, mu=0.1, shift=False):
  function LJ_force (line 35) | def LJ_force(pos, dim, mu=0.1, shift=False):

FILE: pyxtal/reciprocal.py
  function bessel_basis (line 17) | def bessel_basis(r, nmax=6, r_cut=0.24):
  function gto_basis (line 35) | def gto_basis(r, nmax=6, r_cut=0.24):
  function chebyshev_basis (line 64) | def chebyshev_basis(r, nmax=6, r_cut=0.24):
  class RECP (line 84) | class RECP:
    method __init__ (line 95) | def __init__(self, dmax=6.0, nmax=4, lmax=4, rbasis='chebyshev', res=0...
    method __str__ (line 106) | def __str__(self):
    method __repr__ (line 111) | def __repr__(self):
    method build_reciprocal (line 114) | def build_reciprocal(self, atoms):
    method compute (line 184) | def compute(self, atoms, norm=False):
    method compute_rdf (line 197) | def compute_rdf(self, ds, vals):
    method compute_sph_torch (line 210) | def compute_sph_torch(self, xyz, v, norm=False):
    method plot (line 274) | def plot(self, data, filename='reciprocal.png'):
    method reconstruction (line 307) | def reconstruction(self, spg, wps, elements, rep0, P_ref, rdf_ref, ver...
    method loss (line 354) | def loss(self, spg, wps, elements, P_ref, RDF_ref):

FILE: pyxtal/representation.py
  class representation_atom (line 8) | class representation_atom:
    method __init__ (line 17) | def __init__(self, x):
    method __str__ (line 20) | def __str__(self):
    method from_pyxtal (line 24) | def from_pyxtal(cls, struc, standard=True):
    method to_standard_setting (line 41) | def to_standard_setting(self):
    method to_pyxtal (line 45) | def to_pyxtal(self):
    method to_array (line 114) | def to_array(self):
    method to_string (line 124) | def to_string(self, time=None, eng=None, tag=None):
  class representation (line 169) | class representation:
    method __init__ (line 179) | def __init__(self, x, smiles=None):
    method __str__ (line 190) | def __str__(self):
    method from_pyxtal (line 194) | def from_pyxtal(cls, struc, standard=False):
    method from_string (line 217) | def from_string(cls, inputs, smiles, composition=None):
    method to_standard_setting (line 269) | def to_standard_setting(self):
    method to_pyxtal (line 275) | def to_pyxtal(self, smiles=None, composition=None):
    method to_string (line 375) | def to_string(self, time=None, eng=None, tag=None):
    method same_smiles (line 421) | def same_smiles(self, smiles):
    method get_dist (line 427) | def get_dist(self, rep):
    method update_smiles (line 478) | def update_smiles(self, smiles):

FILE: pyxtal/supergroup.py
  function write_poscars (line 35) | def write_poscars(H_struc, G_struc, mappings, splitters, wyc_sets, N_ima...
  function new_structure (line 56) | def new_structure(struc, refs):
  function new_path (line 71) | def new_path(path, paths):
  function find_mapping_per_element (line 78) | def find_mapping_per_element(sites1, sites2):
  function find_mapping (line 119) | def find_mapping(atom_sites, splitter):
  function search_G1 (line 175) | def search_G1(G, rot, tran, pos, wp1, op):
  function search_G2 (line 216) | def search_G2(rot, tran, pos1, pos2, cell=None):
  function find_xyz (line 261) | def find_xyz(G2_op, coord, quadrant=None):
  class supergroup (line 330) | class supergroup:
    method __init__ (line 339) | def __init__(self, struc, G, random_state=None):
    method search_supergroup (line 365) | def search_supergroup(self, d_tol=0.9, max_per_G=2500, max_solutions=N...
    method make_supergroup (line 400) | def make_supergroup(self, solutions, show_detail=False):
    method calc_disps (line 427) | def calc_disps(self, split_id, solution, d_tol):
    method get_initial_mask (line 493) | def get_initial_mask(self, splitter):
    method get_coord_H (line 503) | def get_coord_H(self, splitter, id, atom_sites_H, mapping):
    method symmetrize_dist (line 525) | def symmetrize_dist(self, splitter, mapping, mask, translation=None, d...
    method symmetrize (line 577) | def symmetrize(self, splitter, mapping, translation):
    method print_wp (line 627) | def print_wp(self, sp, id):
    method symmetrize_site_single (line 637) | def symmetrize_site_single(self, splitter, id, base, translation, run_...
    method symmetrize_site_double_k (line 705) | def symmetrize_site_double_k(self, splitter, id, coord_H, translation,...
    method symmetrize_site_double_t (line 767) | def symmetrize_site_double_t(self, splitter, id, coord_H, translation,...
    method symmetrize_site_multi (line 831) | def symmetrize_site_multi(self, splitter, id, coord_H, translation, ru...
    method print_detail (line 926) | def print_detail(self, solution, coords_H, coords_G, elements):
    method sort_solutions (line 955) | def sort_solutions(self, solutions):
    method make_pyxtals_in_subgroup (line 961) | def make_pyxtals_in_subgroup(self, solution, N_images=5):
    method make_pyxtal_in_supergroup (line 1000) | def make_pyxtal_in_supergroup(self, solution):
    method _make_pyxtal (line 1018) | def _make_pyxtal(self, sp, coords, elements=None, run_type=0, check=Tr...
  class supergroups (line 1101) | class supergroups:
    method __init__ (line 1125) | def __init__(
    method __str__ (line 1170) | def __str__(self):
    method __repr__ (line 1183) | def __repr__(self):
    method print_solutions (line 1186) | def print_solutions(self):
    method get_transformation (line 1204) | def get_transformation(self, N_images=2):
    method struc_along_path (line 1235) | def struc_along_path(self, path):
    method write_cifs (line 1284) | def write_cifs(self):

FILE: pyxtal/symmetry.py
  function rf (line 38) | def rf(package_name, resource_path):
  class SymmetryData (line 46) | class SymmetryData:
    method __init__ (line 51) | def __init__(self):
    method get_t_subgroup (line 69) | def get_t_subgroup(cls):
    method get_k_subgroup (line 75) | def get_k_subgroup(cls):
    method get_wyckoff_sg (line 80) | def get_wyckoff_sg(self):
    method get_wyckoff_lg (line 85) | def get_wyckoff_lg(self):
    method get_wyckoff_rg (line 90) | def get_wyckoff_rg(self):
    method get_wyckoff_pg (line 95) | def get_wyckoff_pg(self):
    method get_symmetry_sg (line 100) | def get_symmetry_sg(self):
    method get_symmetry_lg (line 105) | def get_symmetry_lg(self):
    method get_symmetry_rg (line 110) | def get_symmetry_rg(self):
    method get_symmetry_pg (line 115) | def get_symmetry_pg(self):
    method get_generator_sg (line 120) | def get_generator_sg(self):
    method get_generator_lg (line 125) | def get_generator_lg(self):
    method get_generator_rg (line 130) | def get_generator_rg(self):
    method get_generator_pg (line 135) | def get_generator_pg(self):
    method get_hall_table (line 140) | def get_hall_table(self):
  class Hall (line 258) | class Hall:
    method __init__ (line 269) | def __init__(self, spgnum, style="pyxtal", permutation=False):
  class Group (line 295) | class Group:
    method __init__ (line 383) | def __init__(self, group, dim=3, use_hall=False, style="pyxtal", quick...
    method _initialize_hall_data (line 408) | def _initialize_hall_data(self, group, use_hall, style, dim):
    method _initialize_wyckoff_data (line 423) | def _initialize_wyckoff_data(self, dim):
    method __str__ (line 464) | def __str__(self):
    method __repr__ (line 480) | def __repr__(self):
    method __iter__ (line 483) | def __iter__(self):
    method __getitem__ (line 486) | def __getitem__(self, index):
    method __len__ (line 489) | def __len__(self):
    method get_ferroelectric_groups (line 492) | def get_ferroelectric_groups(self):
    method get_site_dof (line 498) | def get_site_dof(self, sites):
    method get_orders (line 517) | def get_orders(self):
    method get_spg_representation (line 530) | def get_spg_representation(self):
    method get_subgroup_composition (line 541) | def get_subgroup_composition(self, ids, g_types=['t', 'k'], max_atoms=...
    method get_lattice_id (line 597) | def get_lattice_id(self):
    method get_ASU (line 660) | def get_ASU(self):
    method get_ASU_instance (line 669) | def get_ASU_instance(self):
    method get_lattice_dof (line 678) | def get_lattice_dof(self):
    method is_valid_hkl (line 695) | def is_valid_hkl(self, h, k, l):
    method get_reflection_conditions (line 711) | def get_reflection_conditions(self):
    method generate_possible_hkls (line 769) | def generate_possible_hkls(self, h_max, k_max=None, l_max=None, max_sq...
    method generate_hkl_guesses (line 861) | def generate_hkl_guesses(self, h_max=2, k_max=None, l_max=None, max_sq...
    method reduce_hkl_guesses (line 958) | def reduce_hkl_guesses(self, hkls):
    method check_hkl_in_list (line 1054) | def check_hkl_in_list(self, hkl, hkl_list):
    method is_valid_combination (line 1067) | def is_valid_combination(self, sites):
    method list_wyckoff_combinations (line 1091) | def list_wyckoff_combinations(self, numIons, quick=False, numWp=(None,...
    method get_spg_symmetry_object (line 1246) | def get_spg_symmetry_object(self):
    method get_wyckoff_position (line 1268) | def get_wyckoff_position(self, index):
    method get_wyckoff_position_from_xyz (line 1286) | def get_wyckoff_position_from_xyz(self, xyz, decimals=4):
    method get_alternatives (line 1308) | def get_alternatives(self):
    method _get_max_k_subgroup (line 1320) | def _get_max_k_subgroup(cls, number=None):
    method _get_max_t_subgroup (line 1330) | def _get_max_t_subgroup(cls, number=None):
    method get_max_k_subgroup (line 1339) | def get_max_k_subgroup(self):
    method get_max_t_subgroup (line 1342) | def get_max_t_subgroup(self):
    method get_max_subgroup (line 1345) | def get_max_subgroup(self, H):
    method get_wp_list (line 1362) | def get_wp_list(self, reverse=False):
    method get_splitters_from_structure (line 1372) | def get_splitters_from_structure(self, struc, group_type="t"):
    method get_splitters_from_relation (line 1403) | def get_splitters_from_relation(self, struc, relation):
    method get_min_supergroup (line 1479) | def get_min_supergroup(self, group_type="t", G=None):
    method _get_max_subgroup_numbers (line 1516) | def _get_max_subgroup_numbers(cls, number, max_cell=9):
    method get_max_subgroup_numbers (line 1533) | def get_max_subgroup_numbers(self, max_cell=9):
    method check_compatible (line 1554) | def check_compatible(self, numIons, verbose=False):
    method _get_base_and_upper_bounds (line 1589) | def _get_base_and_upper_bounds(self):
    method search_supergroup_paths (line 1619) | def search_supergroup_paths(self, H, max_layer=5):
    method path_to_subgroup (line 1680) | def path_to_subgroup(self, H):
    method search_subgroup_paths (line 1707) | def search_subgroup_paths(self, G, max_layer=5):
    method add_k_transitions (line 1728) | def add_k_transitions(self, path, n=1):
    method path_to_general_wp (line 1764) | def path_to_general_wp(self, index=1, max_steps=1):
    method path_to_zp2 (line 1831) | def path_to_zp2(self):
    method short_path_to_general_wp (line 1852) | def short_path_to_general_wp(self, index=1, t_only=False):
    method get_valid_solutions (line 1870) | def get_valid_solutions(self, solutions):
    method cellsize (line 1890) | def cellsize(self):
    method get_free_axis (line 1916) | def get_free_axis(self):
    method list_groups (line 1965) | def list_groups(cls, dim=3):
    method get_index_by_letter (line 1989) | def get_index_by_letter(self, letter):
    method get_wp_by_letter (line 1998) | def get_wp_by_letter(self, letter):
    method get_symmetry_directions (line 2004) | def get_symmetry_directions(self):
  class Wyckoff_position (line 2016) | class Wyckoff_position:
    method from_dict (line 2033) | def from_dict(cls, dictionary):
    method from_group_and_letter (line 2049) | def from_group_and_letter(cls, group, letter, dim=3, style="pyxtal", h...
    method from_group_and_index (line 2076) | def from_group_and_index(cls, group, index, dim=3, use_hall=False, sty...
    method from_symops_wo_group (line 2140) | def from_symops_wo_group(cls, ops):
    method from_symops (line 2162) | def from_symops(cls, ops, G):
    method from_index_quick (line 2189) | def from_index_quick(self, wyckoffs, index, P=None, P1=None):
    method __str__ (line 2219) | def __str__(self, supress=False):
    method __repr__ (line 2244) | def __repr__(self):
    method __iter__ (line 2247) | def __iter__(self):
    method __getitem__ (line 2250) | def __getitem__(self, index):
    method __len__ (line 2253) | def __len__(self):
    method copy (line 2256) | def copy(self):
    method save_dict (line 2262) | def save_dict(self):
    method load_dict (line 2271) | def load_dict(cls, dicts):
    method set_ops (line 2278) | def set_ops(self):
    method get_ops_from_transformation (line 2281) | def get_ops_from_transformation(self):
    method update (line 2306) | def update(self):
    method update_hall (line 2322) | def update_hall(self, hall_numbers=None):
    method update_index (line 2371) | def update_index(self):
    method transform_from_matrices (line 2391) | def transform_from_matrices(self, trans):
    method transform_from_matrix (line 2399) | def transform_from_matrix(self, trans=None, reset=True, update=False):
    method process_ops (line 2427) | def process_ops(self):
    method equivalent_set (line 2448) | def equivalent_set(self, index):
    method get_site_symm_wo_translation (line 2468) | def get_site_symm_wo_translation(self):
    method get_site_symmetry_object (line 2471) | def get_site_symmetry_object(self, idx=0):
    method get_site_symmetry (line 2475) | def get_site_symmetry(self, idx=0):
    method get_site_symm_ops (line 2480) | def get_site_symm_ops(self, idx=0):
    method get_hm_number (line 2483) | def get_hm_number(self, tol=1e-5):
    method get_hm_symbol (line 2490) | def get_hm_symbol(self):
    method get_dof (line 2496) | def get_dof(self):
    method get_label (line 2502) | def get_label(self):
    method get_frozen_axis (line 2508) | def get_frozen_axis(self):
    method get_euclidean_symmetries (line 2538) | def get_euclidean_symmetries(self, idx=0):
    method get_euclidean_ops (line 2554) | def get_euclidean_ops(self):
    method get_euclidean_generator (line 2571) | def get_euclidean_generator(self, cell, idx=0):
    method get_free_xyzs (line 2592) | def get_free_xyzs(self, pos, perturb=False, eps=0.1, random_state: int...
    method get_position_from_free_xyzs (line 2617) | def get_position_from_free_xyzs(self, xyz):
    method get_all_positions (line 2632) | def get_all_positions(self, pos):
    method is_standard_setting (line 2661) | def is_standard_setting(self):
    method has_equivalent_ops (line 2675) | def has_equivalent_ops(self, wp2, tol=1e-3):
    method is_pure_translation (line 2697) | def is_pure_translation(self, id):
    method swap_axis (line 2709) | def swap_axis(self, swap_id):
    method print_ops (line 2744) | def print_ops(self, ops=None):
    method gen_pos (line 2750) | def gen_pos(self):
    method are_equivalent_pts (line 2756) | def are_equivalent_pts(self, pt1, pt2, cell=None, tol=0.05):
    method distance_check (line 2781) | def distance_check(self, pt, lattice, tol):
    method short_distances (line 2797) | def short_distances(self, pt, lattice, tol):
    method merge (line 2819) | def merge(self, pt, lattice, tol, orientations=None, group=None):
    method set_generators (line 2911) | def set_generators(self):
    method set_euclidean (line 2922) | def set_euclidean(self):
    method search_generator_dist (line 2937) | def search_generator_dist(self, pt, lattice=None, group=None):
    method search_generator (line 2974) | def search_generator(self, pos, ops=None, tol=1e-2, symmetrize=False):
    method search_all_generators (line 3012) | def search_all_generators(self, pos, ops=None, tol=1e-2):
    method apply_ops (line 3040) | def apply_ops(self, pt):
    method project (line 3046) | def project(self, point, cell=None, PBC=None, id=0):
    method to_discrete_grid (line 3108) | def to_discrete_grid(self, xyz, N_grids=50):
    method from_discrete_grid (line 3118) | def from_discrete_grid(self, xyz, N_grids=50):
  function choose_wyckoff (line 3129) | def choose_wyckoff(G, number=None, site=None, dim=3, random_state: int |...
  function choose_wyckoff_mol (line 3176) | def choose_wyckoff_mol(
  function swap_xyz_string (line 3240) | def swap_xyz_string(xyzs, permutation):
  function swap_xyz_ops (line 3279) | def swap_xyz_ops(ops, permutation):
  function op_transform (line 3305) | def op_transform(ops, affine_matrix):
  function op_translation (line 3323) | def op_translation(op, tran):
  function are_equivalent_ops (line 3356) | def are_equivalent_ops(op1, op2, tol=1e-2):
  function letter_from_index (line 3365) | def letter_from_index(index, group, dim=3):
  function index_from_letter (line 3390) | def index_from_letter(letter, group, dim=3):
  function jk_from_i (line 3414) | def jk_from_i(i, olist):
  class site_symmetry (line 3440) | class site_symmetry:
    method __init__ (line 3461) | def __init__(self, ops, lattice_type, Bravis, number, wp_id=0, parse_t...
    method to_one_hot (line 3488) | def to_one_hot(self, verbose=False):
    method to_matrix_representation (line 3498) | def to_matrix_representation(self, verbose=False):
    method set_table (line 3582) | def set_table(self, skip=False):
    method set_full_hm_symbols (line 3613) | def set_full_hm_symbols(self, tables):
    method unique_symmetry (line 3638) | def unique_symmetry(self, symbols, symmetry):
    method ref_symmetry (line 3641) | def ref_symmetry(self, symbols, reference):
    method set_short_symbols (line 3644) | def set_short_symbols(self):
    method get_name (line 3817) | def get_name(self):
    method to_beautiful_matrix_representation (line 3830) | def to_beautiful_matrix_representation(self, skip=True):
    method get_highest_symmetry (line 3843) | def get_highest_symmetry(self, row):
    method correct_matrix (line 3926) | def correct_matrix(self, matrix):
  function organized_wyckoffs (line 3976) | def organized_wyckoffs(group):
  function symmetry_element_from_axis (line 4000) | def symmetry_element_from_axis(axis):
  function get_wyckoffs (line 4029) | def get_wyckoffs(num, organized=False, dim=3):
  function _get_wyckoffs_cached (line 4076) | def _get_wyckoffs_cached(num, dim):
  function get_wyckoff_symmetry (line 4097) | def get_wyckoff_symmetry(num, dim=3):
  function _get_wyckoff_symmetry_cached (line 4116) | def _get_wyckoff_symmetry_cached(num, dim):
  function get_generators (line 4139) | def get_generators(num, dim=3):
  function _get_generators_cached (line 4162) | def _get_generators_cached(num, dim):
  function site_symm (line 4183) | def site_symm(point, gen_pos, tol=1e-3, lattice=None, PBC=None):
  function check_wyckoff_position (line 4249) | def check_wyckoff_position(points, group, tol=1e-3):
  function get_symbol_and_number (line 4325) | def get_symbol_and_number(input_group, dim=3):
  function check_symmetry_and_dim (line 4365) | def check_symmetry_and_dim(number, dim=3):
  function get_pbc_and_lattice (line 4388) | def get_pbc_and_lattice(number, dim):
  function search_cloest_wp (line 4437) | def search_cloest_wp(G, wp, op, pos):
  function get_point_group (line 4494) | def get_point_group(number):
  function get_close_packed_groups (line 4585) | def get_close_packed_groups(pg):
  function para2ferro (line 4611) | def para2ferro(pg):
  function get_all_polar_space_groups (line 4701) | def get_all_polar_space_groups():
  function abc2matrix (line 4712) | def abc2matrix(abc):
  function get_symmetry_from_ops (line 4763) | def get_symmetry_from_ops(ops, tol=1e-5):
  function identity_ops (line 4782) | def identity_ops(op):
  function transform_ops (line 4790) | def transform_ops(ops, P, P1):
  function trim_ops (line 4824) | def trim_ops(ops):
  function find_axis_order (line 4873) | def find_axis_order(axis, directions):
  function get_symmetry_directions (line 4881) | def get_symmetry_directions(lattice_type, symbol="P", unique_axis="b"):
  function is_hkl_allowed (line 4916) | def is_hkl_allowed(h, k, l, spg):
  function get_canonical_hkl (line 5057) | def get_canonical_hkl(h, k, l, spg):
  function get_canonical_hkl_series (line 5100) | def get_canonical_hkl_series(hkl_series, spg):
  function get_bravais_lattice (line 5233) | def get_bravais_lattice(spg):
  function get_lattice_type (line 5287) | def get_lattice_type(bravais):
  function is_hkl_allowed_by_bravais (line 5304) | def is_hkl_allowed_by_bravais(h, k, l, bravais):
  function generate_possible_hkls (line 5340) | def generate_possible_hkls(bravais, h_max=50, k_max=50, l_max=50):

FILE: pyxtal/symmetry_sampler.py
  class Sampler (line 5) | class Sampler:
    method __init__ (line 11) | def __init__(self, composition=[1, 2], max_atoms=100, max_wp=20, verbo...
    method generate_combinations (line 29) | def generate_combinations(self):
    method augment_data (line 66) | def augment_data(self, train_data, weight=10):
    method add_composition (line 89) | def add_composition(self, data, multiplier=1):
    method get_top_combinations (line 109) | def get_top_combinations(self, top_n=10):
    method sample (line 122) | def sample(self, N=1):

FILE: pyxtal/tolerance.py
  class Tol_matrix (line 5) | class Tol_matrix:
    method __init__ (line 23) | def __init__(self, *tuples, prototype="atomic", factor=1.0):
    method get_tol (line 79) | def get_tol(self, specie1, specie2):
    method set_tol (line 99) | def set_tol(self, specie1, specie2, value):
    method from_matrix (line 125) | def from_matrix(self, matrix, prototype="atomic", factor=1.0, begin_wi...
    method from_radii (line 155) | def from_radii(self, radius_list, prototype="atomic", factor=1.0, begi...
    method from_single_value (line 183) | def from_single_value(self, value):
    method __getitem__ (line 201) | def __getitem__(self, index):
    method __str__ (line 205) | def __str__(self):
    method to_file (line 223) | def to_file(self, filename=None):
    method from_file (line 254) | def from_file(self, filename):

FILE: pyxtal/util.py
  function find_dir (line 19) | def find_dir(dirs):
  function listToString (line 29) | def listToString(s):
  function pymatgen2ase (line 37) | def pymatgen2ase(struc):
  function ase2pymatgen (line 47) | def ase2pymatgen(struc):
  function symmetrize_cell (line 57) | def symmetrize_cell(struc, mode="C"):
  function good_lattice (line 74) | def good_lattice(struc, maxvec=50.0, minvec=1.2, maxang=150, minang=30):
  function symmetrize (line 86) | def symmetrize(pmg, tol=1e-3, a_tol=5.0, style="pyxtal", hn=None):
  function get_symmetrized_pmg (line 115) | def get_symmetrized_pmg(pmg, tol=1e-3, a_tol=5.0, style="pyxtal", hn=None):
  function extract_ase_db (line 143) | def extract_ase_db(db_file, id):
  function parse_cif (line 166) | def parse_cif(filename, header=False, spg=False, eng=False, csd=False, s...
  function process_csd_cif (line 236) | def process_csd_cif(cif, remove_H=False):
  function get_similar_cids_from_pubchem (line 261) | def get_similar_cids_from_pubchem(base, MaxRecords):
  function search_csd_code_by_pubchem (line 292) | def search_csd_code_by_pubchem(cid):
  function search_csd_entries_by_code (line 334) | def search_csd_entries_by_code(code):
  function get_struc_from__parser (line 370) | def get_struc_from__parser(p):
  function Kgrid (line 438) | def Kgrid(struc, Kresol=0.10, dimension=3):
  function sort_by_dimer (line 461) | def sort_by_dimer(atoms, N_mols, id=10, tol=4.0):
  function generate_wp_lib (line 515) | def generate_wp_lib(
  function reset_lammps_cell (line 583) | def reset_lammps_cell(atoms0):
  function new_struc (line 598) | def new_struc(xtal, xtals):
  function new_struc_wo_energy (line 633) | def new_struc_wo_energy(xtal, xtals, ltol=0.2, stol=0.3, angle_tol=5.0, ...
  function split_list_by_ratio (line 670) | def split_list_by_ratio(nums, ratio):
  function prettify (line 709) | def prettify(elem):
  function get_pmg_dist (line 720) | def get_pmg_dist(pmg1, pmg2, ltol=0.3, stol=0.3, angle_tol=5.0, scale=Tr...
  function get_wyc_from_comp (line 733) | def get_wyc_from_comp(composition: int,
  function check_upper_bounds (line 784) | def check_upper_bounds(solutions: List[Tuple[int]], upper_bounds: List[i...

FILE: pyxtal/viz.py
  function addBox (line 6) | def addBox(view, vecs, viewer=None):
  function addlines (line 70) | def addlines(view, orig, axes, viewer=None):
  function display_atomic (line 90) | def display_atomic(struc, size=(600, 300), scale=0.25, radius=0.10, supe...
  function display_molecular (line 129) | def display_molecular(
  function display_molecular_site (line 187) | def display_molecular_site(site, id=None, size=(400, 300), axis=True, ax...
  function display_molecules (line 235) | def display_molecules(molecules, size=(400, 300), animation=False, cente...
  function display_molecule (line 266) | def display_molecule(molecule, center, cell, size=(400, 300)):
  function display_mol_crystals (line 304) | def display_mol_crystals(
  function display_crystals (line 350) | def display_crystals(strucs, size=(600, 300), supercell=(1, 1, 1), label...
  function display_cluster (line 379) | def display_cluster(molecules, cell, Ps, cmap="YlGn", s_opacity=0.5, siz...

FILE: pyxtal/wyckoff_site.py
  class atom_site (line 27) | class atom_site:
    method __init__ (line 38) | def __init__(self, wp=None, coordinate=None, specie=1, search=False):
    method __str__ (line 53) | def __str__(self):
    method __repr__ (line 65) | def __repr__(self):
    method copy (line 68) | def copy(self):
    method save_dict (line 75) | def save_dict(self):
    method _get_dof (line 82) | def _get_dof(self):
    method get_bounds (line 89) | def get_bounds(self):
    method load_dict (line 99) | def load_dict(cls, dicts):
    method perturbate (line 115) | def perturbate(self, lattice, magnitude=0.1):
    method search_position (line 129) | def search_position(self, tol=1e-3):
    method encode (line 154) | def encode(self):
    method shift_by_swap (line 165) | def shift_by_swap(self, swap_id):
    method equivalent_set (line 183) | def equivalent_set(self, tran, indices):
    method update (line 199) | def update(self, pos=None, reset_wp=False):
    method get_translations (line 211) | def get_translations(self, pos, axis):
    method get_disp (line 229) | def get_disp(self, pos, lattice, translation):
    method check_with_ws2 (line 250) | def check_with_ws2(self, ws2, lattice, tol, same_group=True):
    method substitute_with_single (line 291) | def substitute_with_single(self, ele):
    method substitute_with_linear (line 301) | def substitute_with_linear(self, eles, direction, lattice):
    method to_mol_site (line 324) | def to_mol_site(self, lattice, molecule, ori=None, reflect=False, type...
  class mol_site (line 350) | class mol_site:
    method __init__ (line 384) | def __init__(self, mol, position, orientation, wp, lattice=None, stype...
    method update_molecule (line 404) | def update_molecule(self, mol):
    method update_orientation (line 411) | def update_orientation(self, angles):
    method get_min_dist (line 416) | def get_min_dist(self, angle=None):
    method optimize_orientation_by_dist (line 435) | def optimize_orientation_by_dist(self, ori_attempts=10, verbose=False):
    method get_energy (line 476) | def get_energy(self, angle=None, wps=[], k1=1.0, r1=1.0, k2=2.0, k3=1....
    method get_dist_angle_AD (line 551) | def get_dist_angle_AD(self, d_total, ids_total, A_id, D_ids, H_ids, rA):
    method get_dist_angle_DA (line 610) | def get_dist_angle_DA(self, d_total, ids_total, D_id, A_ids, rD, rH):
    method optimize_orientation_by_energy (line 640) | def optimize_orientation_by_energy(self, wps=[], max_ax=20, max_ori=5,...
    method cut_lattice (line 683) | def cut_lattice(self, ax, cut):
    method __str__ (line 703) | def __str__(self):
    method __repr__ (line 718) | def __repr__(self):
    method _get_dof (line 721) | def _get_dof(self):
    method get_bounds (line 730) | def get_bounds(self):
    method save_dict (line 746) | def save_dict(self):
    method load_dict (line 763) | def load_dict(cls, dicts):
    method encode (line 778) | def encode(self):
    method to_1D_dicts (line 792) | def to_1D_dicts(self):
    method from_1D_dicts (line 820) | def from_1D_dicts(cls, dicts):
    method show (line 860) | def show(self, id=None, **kwargs):
    method _get_coords_and_species (line 868) | def _get_coords_and_species(self, absolute=False, PBC=False,
    method get_coords_and_species (line 930) | def get_coords_and_species(self, absolute=False, PBC=False, unitcell=F...
    method perturbate (line 947) | def perturbate(self, lattice, trans=0.1, rot=5):
    method translate (line 965) | def translate(self, disp=np.zeros(3), absolute=False):
    method rotate (line 975) | def rotate(self, ax_id=0, ax_vector=None, angle=180):
    method is_valid_orientation (line 1010) | def is_valid_orientation(self):
    method get_mol_object (line 1013) | def get_mol_object(self, id=0):
    method show_molecule_in_box (line 1050) | def show_molecule_in_box(self, id=0):
    method update (line 1064) | def update(self, coords=None, lattice=None, absolute=False, update_mol...
    method _create_matrix (line 1136) | def _create_matrix(self, center=False, ignore=False):
    method get_distances (line 1179) | def get_distances(self, coord1, coord2, m2=None, center=True, ignore=F...
    method get_dists_auto (line 1217) | def get_dists_auto(self, matrix=None, ignore=False, cutoff=None):
    method extract_short_distances (line 1238) | def extract_short_distances(self, ds, coords, cutoff, label1, label2):
    method get_dists_WP (line 1251) | def get_dists_WP(self, matrix=None, ignore=False, idx=None, cutoff=None):
    method get_dists_WP2 (line 1272) | def get_dists_WP2(self, wp2, matrix=None, ignore=False, cutoff=None):
    method short_dist (line 1288) | def short_dist(self):
    method short_dist_with_wp2 (line 1312) | def short_dist_with_wp2(self, wp2, tm=Tol_matrix(prototype="molecular")):
    method get_neighbors_auto (line 1354) | def get_neighbors_auto(self, factor=1.1, max_d=4.0, ignore_E=True, det...
    method get_neighbors_wp2 (line 1508) | def get_neighbors_wp2(self, wp2, factor=1.1, max_d=4.0, ignore_E=True,...
    method get_ijk_lists (line 1572) | def get_ijk_lists(self, value=None):
    method to_atom_site (line 1598) | def to_atom_site(self, specie=1):

FILE: pyxtal/wyckoff_split.py
  class wyckoff_split (line 10) | class wyckoff_split:
    method __init__ (line 25) | def __init__(self, G=197, idx=None, wp1=None, group_type="t",
    method sort (line 94) | def sort(self):
    method parse_wp2 (line 108) | def parse_wp2(self, idx):
    method split_t (line 140) | def split_t(self, wp1, wp2_lists, quadrant=None):
    method split_k (line 319) | def split_k(self, wp1, wp2_lists, tol=1e-5):
    method translation_generator (line 416) | def translation_generator(self):
    method check_orbits (line 479) | def check_orbits(self, g1_orbits, wp2, wp2_lists):
    method __str__ (line 492) | def __str__(self):
    method __repr__ (line 509) | def __repr__(self):
  function in_lists (line 513) | def in_lists(mat1, mat2, eps=1e-2, PBC=True):

FILE: scripts/pyxtal_csp_rank.py
  function new_struc (line 11) | def new_struc(xtal, xtals, max_num=100):

FILE: scripts/rank.py
  function new_struc (line 11) | def new_struc(xtal, xtals, max_num=100):

FILE: setup.py
  class CustomInstallCommand (line 5) | class CustomInstallCommand(install):
    method run (line 6) | def run(self):

FILE: tests/test_SO3.py
  function calculate_S (line 9) | def calculate_S(atoms, P_ref):
  function numerical_dSdx (line 15) | def numerical_dSdx(x, xtal,  P_ref, eps=1e-4):
  function calculate_dSdx_supercell (line 39) | def calculate_dSdx_supercell(x, xtal, P_ref, eps=1e-4):
  function get_rotated_cluster (line 78) | def get_rotated_cluster(struc, angle=0, axis='x'):
  function get_perturbed_cluster (line 85) | def get_perturbed_cluster(struc, p0, p1, eps):
  function get_perturbed_xtal (line 93) | def get_perturbed_xtal(struc, p0, p1, eps):
  function get_dPdR_xtal (line 100) | def get_dPdR_xtal(xtal, eps):
  class TestCluster (line 135) | class TestCluster(unittest.TestCase):
    method test_SO3_rotation_variance (line 141) | def test_SO3_rotation_variance(self):
    method test_dPdR_vs_numerical (line 146) | def test_dPdR_vs_numerical(self):
  class TestXtal (line 157) | class TestXtal(unittest.TestCase):
    method test_dPdR_diamond (line 159) | def test_dPdR_diamond(self):
    method test_dPdR_graphite (line 164) | def test_dPdR_graphite(self):
    method test_dPdR_random (line 169) | def test_dPdR_random(self):
    method test_dPdR_random_P (line 175) | def test_dPdR_random_P(self):
  class TestSimilarity (line 186) | class TestSimilarity(unittest.TestCase):
    method test_sim_diamond (line 188) | def test_sim_diamond(self):
    method test_dPdR_random (line 199) | def test_dPdR_random(self):

FILE: tests/test_all.py
  function resource_filename (line 18) | def resource_filename(package_name, resource_path):
  class TestNeighbour (line 30) | class TestNeighbour(unittest.TestCase):
    method test_packing (line 31) | def test_packing(self):
  class TestSubgroup (line 56) | class TestSubgroup(unittest.TestCase):
    method test_cubic_cubic (line 57) | def test_cubic_cubic(self):
    method test_from_seed (line 80) | def test_from_seed(self):
    method test_molecules (line 91) | def test_molecules(self):
    method test_hydrate (line 119) | def test_hydrate(self):
    method test_special (line 128) | def test_special(self):
  class TestLoad (line 136) | class TestLoad(unittest.TestCase):
    method test_atomic (line 137) | def test_atomic(self):
    method test_molecular (line 146) | def test_molecular(self):
  class TestPartial (line 156) | class TestPartial(unittest.TestCase):
    method test_Al2SiO5 (line 157) | def test_Al2SiO5(self):
  class Test_resort (line 189) | class Test_resort(unittest.TestCase):
    method test_molecule (line 190) | def test_molecule(self):
    method test_atom (line 204) | def test_atom(self):
  class Test_operations (line 263) | class Test_operations(unittest.TestCase):
    method test_inverse (line 264) | def test_inverse(self):
    method test_swap_wp (line 314) | def test_swap_wp(self):
    method test_alternative (line 325) | def test_alternative(self):
    method test_wyc_sets (line 335) | def test_wyc_sets(self):
    method test_trans (line 339) | def test_trans(self):
    class TestSubstitution (line 367) | class TestSubstitution(unittest.TestCase):
      method test_substitute_1_2 (line 368) | def test_substitute_1_2(self):
      method test_criteria (line 385) | def test_criteria(self):

FILE: tests/test_crystal.py
  function resource_filename (line 14) | def resource_filename(package_name, resource_path):
  class TestDof (line 26) | class TestDof(unittest.TestCase):
    method test_atomic (line 27) | def test_atomic(self):
  class TestAtomic3D (line 35) | class TestAtomic3D(unittest.TestCase):
    method test_partial (line 37) | def test_partial(self):
    method test_single_specie (line 54) | def test_single_specie(self):
    method test_mutiple_species (line 62) | def test_mutiple_species(self):
    method test_preassigned_sites (line 70) | def test_preassigned_sites(self):
    method test_read (line 86) | def test_read(self):
    method test_read_spglib (line 96) | def test_read_spglib(self):
    method test_read_by_HN (line 114) | def test_read_by_HN(self):
    method test_from_tabular (line 124) | def test_from_tabular(self):
  class TestAtomic2D (line 150) | class TestAtomic2D(unittest.TestCase):
    method test_single_specie (line 151) | def test_single_specie(self):
    method test_mutiple_species (line 158) | def test_mutiple_species(self):
  class TestAtomic1D (line 164) | class TestAtomic1D(unittest.TestCase):
    method test_single_specie (line 165) | def test_single_specie(self):
    method test_mutiple_species (line 172) | def test_mutiple_species(self):
  class TestCluster (line 178) | class TestCluster(unittest.TestCase):
    method test_multi_sites (line 179) | def test_multi_sites(self):
    method test_single_specie (line 188) | def test_single_specie(self):
    method test_mutiple_species (line 193) | def test_mutiple_species(self):

FILE: tests/test_group.py
  function resource_filename (line 12) | def resource_filename(package_name, resource_path):
  class TestGroup (line 24) | class TestGroup(unittest.TestCase):
    method test_generate_wp_lib (line 25) | def test_generate_wp_lib(self):
    method test_list_wyckoff_combinations (line 31) | def test_list_wyckoff_combinations(self):
    method test_print_group_and_dof (line 38) | def test_print_group_and_dof(self):
    method test_get_spg_symmetry_object (line 45) | def test_get_spg_symmetry_object(self):
    method test_short_path (line 54) | def test_short_path(self):
    method test_spg_symmetry (line 59) | def test_spg_symmetry(self):
    method test_ferroelectric (line 74) | def test_ferroelectric(self):
    method test_check_compatible (line 80) | def test_check_compatible(self):
    method test_subgroup_composition (line 88) | def test_subgroup_composition(self):
    method test_search_supergroup_paths (line 97) | def test_search_supergroup_paths(self):
    method test_get_splitters (line 101) | def test_get_splitters(self):
    method test_add_k_transitions (line 108) | def test_add_k_transitions(self):
    method test_to_subgroup (line 123) | def test_to_subgroup(self):
    method test_get_wyckoff_position_from_xyz (line 129) | def test_get_wyckoff_position_from_xyz(self):
    method test_short_path_to_general_wp (line 148) | def test_short_path_to_general_wp(self):

FILE: tests/test_lattice.py
  function resource_filename (line 15) | def resource_filename(package_name, resource_path):
  class TestLattice (line 27) | class TestLattice(unittest.TestCase):
    method test_para_matrix (line 28) | def test_para_matrix(self):
    method test_swap (line 31) | def test_swap(self):
    method test_optimize_once (line 36) | def test_optimize_once(self):
    method test_optimize_multi (line 41) | def test_optimize_multi(self):
    method test_setpara (line 46) | def test_setpara(self):
    method test_search_transformation (line 51) | def test_search_transformation(self):
    method test_is_valid_lattice (line 59) | def test_is_valid_lattice(self):
    method test_from_1d_representation (line 67) | def test_from_1d_representation(self):
  class TestOptimizeLattice (line 74) | class TestOptimizeLattice(unittest.TestCase):
    method test_atomic (line 75) | def test_atomic(self):
    method test_molecular_from_seed (line 94) | def test_molecular_from_seed(self):
    method test_molecular_trans (line 106) | def test_molecular_trans(self):
    method test_molecular_nonstd (line 117) | def test_molecular_nonstd(self):
    method test_molecular_from_random (line 132) | def test_molecular_from_random(self):
    method test_transform (line 145) | def test_transform(self):
    method test_build (line 161) | def test_build(self):
    method test_build_1D (line 185) | def test_build_1D(self):
    method test_build_2D (line 197) | def test_build_2D(self):
    method test_transforms (line 211) | def test_transforms(self):
    method test_optlat_setting (line 242) | def test_optlat_setting(self):

FILE: tests/test_lego.py
  class TestBuilder (line 24) | class TestBuilder(unittest.TestCase):
    method test_opt_xtal (line 36) | def test_opt_xtal(self):
    method test_opt_xtal2 (line 49) | def test_opt_xtal2(self):
    method test_opt_xtals (line 58) | def test_opt_xtals(self):
    method test_opt_diamond (line 73) | def test_opt_diamond(self):
    method test_diamond (line 90) | def test_diamond(self):

FILE: tests/test_mem.py
  function print_memory_usage (line 4) | def print_memory_usage():

FILE: tests/test_molecule.py
  function resource_filename (line 16) | def resource_filename(package_name, resource_path):
  class TestMolecule (line 28) | class TestMolecule(unittest.TestCase):
    method test_get_orientations_in_wp (line 29) | def test_get_orientations_in_wp(self):
  class TestMolecular (line 37) | class TestMolecular(unittest.TestCase):
    method test_single_specie (line 38) | def test_single_specie(self):
    method test_sites (line 60) | def test_sites(self):
    method test_sites_xyz (line 73) | def test_sites_xyz(self):
    method test_read (line 80) | def test_read(self):
    method test_big_molecule (line 92) | def test_big_molecule(self):
    method test_from_random_site (line 105) | def test_from_random_site(self):
    method test_c60 (line 113) | def test_c60(self):
    method test_mutiple_species (line 118) | def test_mutiple_species(self):
    method test_distance (line 135) | def test_distance(self):
    method test_molecular_2d (line 168) | def test_molecular_2d(self):
    method test_molecular_1d (line 174) | def test_molecular_1d(self):
    method test_preassigned_sites (line 179) | def test_preassigned_sites(self):
    method test_special_sites (line 185) | def test_special_sites(self):

FILE: tests/test_site_symm.py
  function csv_to_rst (line 4) | def csv_to_rst(csv_path, rst_path):

FILE: tests/test_supergroup.py
  function resource_filename (line 14) | def resource_filename(package_name, resource_path):
  class TestSupergroup (line 26) | class TestSupergroup(unittest.TestCase):
    method test_supergroup (line 27) | def test_supergroup(self):
    method test_make_pyxtal (line 41) | def test_make_pyxtal(self):
    method test_by_group (line 62) | def test_by_group(self):
    method test_by_path (line 75) | def test_by_path(self):
    method test_long (line 85) | def test_long(self):
    method test_long2 (line 115) | def test_long2(self):
    method test_multi (line 152) | def test_multi(self):
    method test_similarity (line 177) | def test_similarity(self):
    method test_get_disp_sets (line 204) | def test_get_disp_sets(self):

FILE: tests/test_symmetry.py
  function resource_filename (line 9) | def resource_filename(package_name, resource_path):
  class TestSymmetry (line 20) | class TestSymmetry(unittest.TestCase):
    method test_hexagonal_canonical_hkl_equivalence (line 21) | def test_hexagonal_canonical_hkl_equivalence(self):
    method test_hexagonal_canonical_hkl_series_equivalence (line 35) | def test_hexagonal_canonical_hkl_series_equivalence(self):
    method test_from_symops_wo_grou (line 46) | def test_from_symops_wo_grou(self):
    method test_from_symops (line 59) | def test_from_symops(self):
    method test_reflections (line 72) | def test_reflections(self):
    method test_site_symms (line 110) | def test_site_symms(self):

FILE: tests/test_wyckoff.py
  function resource_filename (line 13) | def resource_filename(package_name, resource_path):
  class TestWP (line 25) | class TestWP(unittest.TestCase):
    method test_wp_check_translation (line 26) | def test_wp_check_translation(self):
    method test_wp_site_symm_obj (line 29) | def test_wp_site_symm_obj(self):
    method test_wp_site_symm (line 37) | def test_wp_site_symm(self):
    method test_wp_dof (line 61) | def test_wp_dof(self):
    method test_wp_label (line 68) | def test_wp_label(self):
    method test_merge (line 74) | def test_merge(self):
    method test_search_generator (line 94) | def test_search_generator(self):
    method test_get_wyckoff (line 100) | def test_get_wyckoff(self):
    method test_setting (line 105) | def test_setting(self):
    method test_standarize (line 110) | def test_standarize(self):
    method test_is_equivalent (line 113) | def test_is_equivalent(self):
    method test_project (line 131) | def test_project(self):
    method test_euclidean (line 139) | def test_euclidean(self):
  class Test_wyckoff_site (line 188) | class Test_wyckoff_site(unittest.TestCase):
    method test_atom_site (line 189) | def test_atom_site(self):

FILE: tests/test_xrd.py
  function resource_filename (line 9) | def resource_filename(package_name, resource_path):
  class TestPXRD (line 15) | class TestPXRD(unittest.TestCase):
    method test_similarity (line 16) | def test_similarity(self):
    method test_match (line 33) | def test_match(self):