wavefunction_analysis.utils package

Submodules

wavefunction_analysis.utils.cg_coeffs module

clebsch_gordan_coeff_direct(j1, m1, j2, m2, j3, m3, sqrt=False)

j3 is in {|j_1 - j_2|, dots, j_1 + j_2} m3 = m_1 + m_2 in {-J, -J+1, dots, J-1, J}

clebsch_gordan_coeff_recur(j1, m1, j2, m2)

j3 is in {|j_1 - j_2|, dots, j_1 + j_2} m3 = m_1 + m_2 in {-J, -J+1, dots, J-1, J}

ladder_coeff(j, m, operator)

j could be 0, pm 1/2, pm 1, pm 3/2, pm 2, etc m is in {-j, -j+1, dots, j-1, j} C_pm = sqrt(j (j + 1) - m (m pm 1)) = sqrt((j mp m) (j pm m + 1)) j`_pm |jm> = C_pm |j(mpm1)>`

print_cg_coeff(j1=0, m1=0, j2=0, m2=0, j3=0, m3=0, cg=0, header=False, ic=0)

wavefunction_analysis.utils.chiral_geom module

run_gtensor(symbols, coords, charge=1, spin=1, functional='hf', basis='3-21g')

spin_square_biortho(mf)

swap_atoms_coords(coords, atoms_idx)

change two atoms a, b positions from the center atom c

wavefunction_analysis.utils.fdiff module

change_matrix_phase_c(matrix0, matrix1)

change_matrix_phase_rc(matrix0, matrix1)

change_number_phase(num0, num1)

change_wf_phase(C0, X0, Y0, C1, X1, Y1)

class fdiff(norder=2, step_size=0.001, unit=1.0)

Bases: object

property coeff

compute(fx, unit=1.0)

get_d(ndim, idx)

get_x(x0, idx)

wavefunction_analysis.utils.get_cx module

wavefunction_analysis.utils.monitor_performance module

monitor_performance(func)

decorator for monitoring memory of CPU (GPU) and timing of wall, CPU (GPU). use only as @monitor_performance above function definitions.

set_performance_log(debug=True, filename=None)

turn on/off performance monitoring and optionally change the output destination for performance logs. - debug = True/False: enable/disable performance monitoring - filename = none: set log to stdout (default)

wavefunction_analysis.utils.ortho_basis module

get_ortho_basis(S, method='lowdin', eigen=False)

S is symmetric overlap matrix of atomic basis L = S^(1/2) Z = S^(-1/2) S = L * L^T S^-1 = Z^T * Z inv = S^(-1)

get_ortho_basis_deriv(S, dS, method='lowdin', l_or_z='L', solver='iter')

wavefunction_analysis.utils.print_matrix module

print_matrix(keyword, matrix, nwidth=6, nind=0, digits=[13, 8, 'f'], trans=False, dtype=<class 'float'>)

wavefunction_analysis.utils.pyscf_parser module

build_atom(atmsym, coords)

build_molecule(atom, basis, charge=0, spin=0, unit='angstrom', max_memory=60000, verbose=0)

convert_string(string)

final_print_energy(td, title='tddft', nwidth=6, iprint=0)

find_oscillator_strength(td, nroots, nfrag=1)

find_transition_dipole(td, nroots, nfrag=1)

get_basis_info(mol)

get_center_of_mass(mol, nfrag=1)

get_frgm_idx(parameters)

get_jobtype(parameters)

get_photon_info(photon_key)

get_rem_info(rem_keys)

justify_photon_info(td, nroots, nstate='max_dipole', func='average', nwidth=10)

parser(file_name)

read_keyword_block(data)

read_molecule(data)

run_pyscf_dft(charge, spin, atom, basis, functional, nfrag=1, verbose=0, h=None, scf_method='RKS')

run_pyscf_dft_tddft(charge, spin, atom, basis, functional, td_model, nroots, nfrag=1, verbose=0, debug=0, h=None, scf_method='RKS')

run_pyscf_final(parameters)

run_pyscf_tddft(mf, td_model, nroots, nfrag=1, verbose=0)

run_pyscf_tdqed(mf, td, qed_model, cavity_model, key, nfrag=1)

wavefunction_analysis.utils.read_files module

istype(data, dtype=<class 'float'>)

read_array(filename, keyword=None, nline=0, ncol=4, nrange=[0, 4], dtype=<class 'float'>, same=True)

read_matrix(filename, nrow, ncol, keyword, nwidth=6, nind=0, nskip=0, dtype=<class 'float'>)

read_number(filename, keyword, n=-1, o=1, dtype=<class 'int'>)

o takes 1 or -1 for the reading order when n>=0 when n == -1: o takes the begin and end indices ftype can be int, float, or simply string

read_time(filename)

wavefunction_analysis.utils.sec_mole module

align_principal_axes(charges, coords)

cal_dihedral_angle(vectors)

get_center_property(weights, props, itype='charge', isotope_avg=True)

get_charge_or_mass(symbols, itype='charge', isotope_avg=True)

get_molecular_center(weights, coords, itype='charge', isotope_avg=True)

get_moment_of_inertia(weights, coords, fix_sign=False)

make sure to use coordinates in bohr

get_rotation_matrix(theta, axis='x')

[cos -sin] [sin cos]

get_symbols_coords(geometry, string=False)

read_geometries_standard(infile, screen='User input: 2 of 2')

read_geometry(infile, probe=1)

read_symbols_coords(infile, probe=1)

rotate_molecule(coords0, axis, theta)

standard_orientation(symbols, coords, tol=4)

standard_orientation2(symbols, coords, var, tol=4)

we need the intermediate translation and principal matrices

switch_atoms(geometry, atom_list)

translate_molecule(symbols, coords, origin=None, itype='charge', isotope_avg=True)

write_geometry(infile, geometry, energy=None, open_file_method='w')

write_mol_info(infile, charge='0', multiplicity='1', open_file_method='w', itype=0)

itype: 0 normal job; 1 second job; 2 fragment

write_mol_info_geometry(infile, charge='0', multiplicity='1', frgm=False, **kwargs)

write_rem_info(infile, method='pbe0', basis='6-31g', open_file_method='a+')

write_symbols_coords(infile, symbols, coords, energy=None, open_file_method='w')

wavefunction_analysis.utils.sec_rem module

put_keys_kwargs_to_object(obj, key={}, **kwargs)

put the individual keys in the dictionary first then use dictionary to assign the obj class attributes

put_keys_to_kwargs(key, **kwargs)

put the values in key dict to kwargs dict

put_keys_to_object(obj, key)

put all the keywords and values into the obj class

put_kwargs_to_keys(key={}, **kwargs)

put all the individual keyword and value into the key dictionary

put_kwargs_to_object(obj, **kwargs)

put all the keywords and values into the obj class

wavefunction_analysis.utils.unit_conversion module

convert_different_units(value, prop, index)

convert_other_property(value, unit0='au')

convert_property_to_energy(value, prop, index)

convert_same_units(value, prop, index)

convert_units(value, unit0='au', unit1='fs')

default_unit_index(prop)

find_properties(unit0='au', unit1='fs')

wavefunction_analysis.utils.utils module

ishermitian(keyword, matrix, digits=[2, 13, 8, 'f'], debug=0)

random_matrix(n=10, mean=0.0, width=0.1, func='uniform', sym=True, diag=True)

swap_largest_to_diagonal(matrix)

wavefunction_analysis.utils.wf_overlap module

assemble_amplitudes(xys, nocc, nroots=None, rpa=False, itype='r')

cal_wf_overlap(Xm, Ym, Xn, Yn, Cm, Cn, S, itype='r')

cal_wf_overlap_r(Xm, Ym, Xn, Yn, Cm, Cn, S)

cal_wf_overlap_r0(Xm, Ym, Xn, Yn, Cm, Cn, S)

cal_wf_overlap_sf(Xm, Ym, Xn, Yn, Cm, Cn, S, extype=0)

cal_wf_overlap_u(Xm, Ym, Xn, Yn, Cm, Cn, S)

change_phase(x0, y0, x1, y1, mo0, mo1, ovlp)

sign_fixing(mat)

refer Zhou, Subotnik JCTC 2020, 10.1021/acs.jctc.9b00952

Module contents