def test__ts_variational_writer():
""" ts mess_io.writer.ts_variational
"""
# fix
var_pt_strings = []
for i in range(10):
var_pt_string = '+++++++++++++++++++++++++++++++++++'
var_pt_string += '! Path Point {0}\n'.format(str(i + 1))
var_pt_string += MOL_MESS_STR
var_pt_strings.append(var_pt_string)
ts_var1_str = mess_io.writer.ts_variational(TS_LABEL,
WELL_LABEL,
BIMOL_LABEL,
var_pt_strings,
zero_enes=PATH_ENES,
tunnel='')
assert ts_var1_str == read_text_file(['data', 'inp'], 'ts_var1.inp', PATH)
ts_var2_str = mess_io.writer.ts_variational(TS_LABEL,
WELL_LABEL,
BIMOL_LABEL,
var_pt_strings,
zero_enes=PATH_ENES,
tunnel=TUNNEL_STR)
assert ts_var2_str == read_text_file(['data', 'inp'], 'ts_var2.inp', PATH)
def test__energy_trans_writer():
""" tests writing the section to a file
"""
edown_str = mess_io.writer.energy_down(
exp_factor=150.0,
exp_power=50.0,
exp_cutoff=80.0
)
assert edown_str == read_text_file(
['data', 'inp'], 'etrans_edown.inp', PATH)
collid_str = mess_io.writer.collision_frequency(
eps1=100.0,
eps2=200.0,
sig1=10.0,
sig2=20.0,
mass1=15.0,
mass2=25.0)
assert collid_str == read_text_file(
['data', 'inp'], 'etrans_collid.inp', PATH)
glob_etrans_str = mess_io.writer.global_energy_transfer_input(
edown_str, collid_str)
assert glob_etrans_str == read_text_file(
['data', 'inp'], 'glob_etrans.inp', PATH)
def test__rotor_hindered_writer():
""" test mess_io.writer.rotor_hindered
"""
rotor_hind1_str = mess_io.writer.rotor_hindered(HR_GROUP, HR_AXIS,
HR_SYMMETRY, ONEDPOT)
rotor_hind2_str = mess_io.writer.rotor_hindered(
HR_GROUP,
HR_AXIS,
HR_SYMMETRY,
ONEDPOT,
hmin=HMIN,
hmax=HMAX,
lvl_ene_max=LVL_ENE_MAX,
therm_pow_max=THERM_POW_MAX,
geo=GEO1,
rotor_id=HR_ID)
assert rotor_hind1_str == read_text_file(['data', 'inp'],
'rotor_hind1.inp',
path=PATH)
assert rotor_hind2_str == read_text_file(['data', 'inp'],
'rotor_hind2.inp',
path=PATH)
def test__divsur_writer():
""" tests varecof_io.writer.input_file.divsur
"""
divsur_inp1_str = varecof_io.writer.input_file.divsur(
RDISTS, NPIVOT1, NPIVOT2, XYZ_PIVOT1, XYZ_PIVOT2)
divsur_inp2_str = varecof_io.writer.input_file.divsur(RDISTS,
NPIVOT1,
NPIVOT2,
XYZ_PIVOT1,
XYZ_PIVOT2,
frame1=FRAME1,
frame2=FRAME2,
r2dists=R2DISTS,
d1dists=D1DISTS,
d2dists=D2DISTS,
t1angs=T1ANGS,
t2angs=T2ANGS,
p1angs=P1ANGS,
p2angs=P2ANGS,
phi_dependence=False,
**CONDITIONS_DCT)
assert divsur_inp1_str == read_text_file(['data'], 'divsur1.inp', PATH)
assert divsur_inp2_str == read_text_file(['data'], 'divsur2.inp', PATH)
def test__reader():
""" test projrot_io.reader.rpht_output
"""
ref_real1 = (1000.0, 2000.0, 3000.0, 4000.0, 5000.0)
out_str1 = read_text_file(['data'], 'min.out', PATH)
real1, imag1 = projrot_io.reader.rpht_output(out_str1)
assert numpy.allclose(real1, ref_real1)
assert not imag1
ref_real2 = (2000.0, 3000.0, 4000.0, 5000.0)
ref_imag2 = (1111.11, )
out_str2 = read_text_file(['data'], 'one_imag.out', PATH)
real2, imag2 = projrot_io.reader.rpht_output(out_str2)
assert numpy.allclose(real2, ref_real2)
assert numpy.allclose(imag2, ref_imag2)
ref_real3 = (3000.0, 4000.0, 5000.0)
ref_imag3 = (1111.11, 2222.22)
out_str3 = read_text_file(['data'], 'two_imag.out', PATH)
real3, imag3 = projrot_io.reader.rpht_output(out_str3)
assert numpy.allclose(real3, ref_real3)
assert numpy.allclose(imag3, ref_imag3)
def test__dummy_writer():
""" tests mess_io.writer.dummy
"""
dummy1_str = mess_io.writer.dummy(BIMOL_LABEL)
assert dummy1_str == read_text_file(['data', 'inp'], 'dummy1.inp', PATH)
dummy2_str = mess_io.writer.dummy(BIMOL_LABEL, zero_ene=ENE)
assert dummy2_str == read_text_file(['data', 'inp'], 'dummy2.inp', PATH)
def test__species_writer():
""" Writes the MESS input for a Well
"""
spc1_str = mess_io.writer.species(SPC1_LABEL, MOL_MESS_STR, zero_ene=None)
assert spc1_str == read_text_file(['data', 'inp'], 'spc1.inp', PATH)
spc2_str = mess_io.writer.species(SPC2_LABEL, MOL_MESS_STR, zero_ene=ENE)
assert spc2_str == read_text_file(['data', 'inp'], 'spc2.inp', PATH)
def test__polynomial():
""" test pac99_io.reader.__
"""
pac99_poly = pac99_io.reader.nasa_polynomial(OUT_STR)
assert pac99_poly == read_text_file(['data'], 'pac99_poly.dat', PATH)
name = 'mol'
atom_dct = {'C': 2, 'H': 4, 'N': 2, 'O': 6}
ckin_poly = pac99_io.pac2ckin_poly(name, atom_dct, pac99_poly)
assert ckin_poly == read_text_file(['data'], 'ckin_poly.dat', PATH)
def test__():
""" test mess_io.writer._lump.well_lump_scheme
"""
ref_lump1_str = read_text_file(['data', 'inp'], 'well_lump1.inp', PATH)
ref_lump2_str = read_text_file(['data', 'inp'], 'well_lump2.inp', PATH)
lump1_str = mess_io.writer.well_lump_scheme(WELL_MERGE_LST)
lump2_str = mess_io.writer.well_lump_scheme(WELL_MERGE_LST, separator='-')
assert lump1_str == ref_lump1_str.rstrip()
assert lump2_str == ref_lump2_str.rstrip()
def test__rotor_dist_cutoffs():
""" test projrot_io.writer.projection_distance_aux
"""
dist_cutoff_dct = {('H', 'O'): 2.26767, ('H', 'C'): 2.26767}
rotor_dist1_str = projrot_io.writer.projection_distance_aux()
rotor_dist2_str = projrot_io.writer.projection_distance_aux(
dist_cutoff_dct=dist_cutoff_dct)
assert rotor_dist1_str == read_text_file(['data'], 'rotor_dist1.inp', PATH)
assert rotor_dist2_str == read_text_file(['data'], 'rotor_dist2.inp', PATH)
def test__global_rates_input():
""" test mess_io.writer.global_rates_input
"""
glob1_str = mess_io.writer.global_rates_input(TEMPS, PRESSURES)
glob2_str = mess_io.writer.global_rates_input(
TEMPS,
PRESSURES,
excess_ene_temp=EXCESS_ENE_TEMP,
well_extend=WELL_EXTEND)
assert glob1_str == read_text_file(['data', 'inp'], 'glob_rxn1.inp', PATH)
assert glob2_str == read_text_file(['data', 'inp'], 'glob_rxn2.inp', PATH)
def test__makefile_writer():
""" tests varecof_io.writer.corr_potentials.makefile
"""
makefile1_str = varecof_io.writer.corr_potentials.makefile(
FORTRAN_COMPILER)
makefile2_str = varecof_io.writer.corr_potentials.makefile(
FORTRAN_COMPILER,
pot_file_names=SPECIES_CORR_POTENTIALS)
assert makefile1_str == read_text_file(['data'], 'makefile1', PATH)
assert makefile2_str == read_text_file(['data'], 'makefile', PATH)
def test__tunnel_read_writer():
""" test mess_io.writer.tunnel_read
"""
tunnel_read1_str = mess_io.writer.tunnel_read(IMAG_FREQ, TUNNEL_FILE)
tunnel_read2_str = mess_io.writer.tunnel_read(IMAG_FREQ,
TUNNEL_FILE,
cutoff_energy=CUTOFF_ENE)
assert tunnel_read1_str == read_text_file(['data', 'inp'],
'tunnel_read1.inp', PATH)
assert tunnel_read2_str == read_text_file(['data', 'inp'],
'tunnel_read2.inp', PATH)
def test__flux_mode():
""" test mess_io.writer.fluxional_mode
"""
# Write the fluxional mode string
flux_mode1_str = mess_io.writer.fluxional_mode(
FLUX_IDX)
flux_mode2_str = mess_io.writer.fluxional_mode(
FLUX_IDX, span=FLUX_SPAN)
assert flux_mode1_str == read_text_file(
['data', 'inp'], 'flux_mode1.inp', PATH)
assert flux_mode2_str == read_text_file(
['data', 'inp'], 'flux_mode2.inp', PATH)
def test__species_writer():
""" tests varecof_io.writer.corr_potentials.species
"""
spc_corr1_str = varecof_io.writer.corr_potentials.species(
RVALS, POTENTIALS, BND_IDXS)
spc_corr2_str = varecof_io.writer.corr_potentials.species(
RVALS, POTENTIALS, BND_IDXS,
species_name=SPECIES_NAME,
pot_labels=POT_LABELS,
dist_restrict_idxs=DIST_RESTRICT_IDXS)
assert spc_corr1_str == read_text_file(['data'], 'mol_corr2.f', PATH)
assert spc_corr2_str == read_text_file(['data'], 'mol_corr.f', PATH)
def test_sct_coord_en():
""" test projrot_io.writer.rpht_path_coord_en
"""
en1_str = projrot_io.writer.rpht_path_coord_en(RXN_PATH_COORDS,
RXN_PATH_ENERGIES,
bnd1=(),
bnd2=())
assert en1_str == read_text_file(['data'], 'rpht_en1.inp', PATH)
en2_str = projrot_io.writer.rpht_path_coord_en(RXN_PATH_COORDS,
RXN_PATH_ENERGIES,
bnd1=RCT_DISTS,
bnd2=PRD_DISTS)
assert en2_str == read_text_file(['data'], 'rpht_en2.inp', PATH)
def test__compile_correction_potential():
""" test varecof_io.writer.corr_potentials.compile_correction_pot
"""
write_text_file([TMP_PATH], 'mol_corr.f',
read_text_file(['data'], 'mol_corr.f', PATH), PATH)
write_text_file([TMP_PATH], 'pot_aux.f',
read_text_file(['data'], 'pot_aux.f', PATH), PATH)
write_text_file([TMP_PATH], 'dummy_corr.f',
read_text_file(['data'], 'dummy_corr.f', PATH), PATH)
write_text_file([TMP_PATH], 'makefile',
read_text_file(['data'], 'makefile', PATH), PATH)
varecof_io.writer.corr_potentials.compile_corr_pot(TMP_PATH)
assert os.path.exists(os.path.join(TMP_PATH, 'libcorrpot.so'))
def test__thermo():
""" test
"""
ref_hform298 = -0.028389069688367432
formula_str = automol.formula.string(FORMULA)
thermp_script_str = autorun.SCRIPT_DCT['thermp']
pac99_script_str = autorun.SCRIPT_DCT['pac99'].format(formula_str)
with tempfile.TemporaryDirectory(dir=PATH) as run_dir:
hform298, nasa_poly = autorun.thermo(thermp_script_str,
pac99_script_str,
run_dir,
PF_STR,
NAME,
FORMULA,
HFORM0,
enthalpyt=ENTHALPYT,
breakt=BREAKT,
convert=True)
assert numpy.isclose(hform298, ref_hform298)
assert nasa_poly == read_text_file(['data'], 'ch4nasa.ckin', path=PATH)
def test__vec():
""" test automol.automol.util.cart.vec
"""
# Test angle calculators
ref_perp = (-0.90180687, -0.40614043, -0.14762896)
perp = automol.util.vec.unit_perpendicular(
MAT[0], MAT[1], allow_parallel=False)
assert numpy.allclose(perp, ref_perp)
ref_perp = (0.000, 0.000, 0.000)
perp = automol.util.vec.unit_perpendicular(
MAT[0], MAT[0], allow_parallel=True)
assert numpy.allclose(perp, ref_perp)
with pytest.raises(ValueError):
automol.util.vec.unit_perpendicular(
MAT[0], MAT[0], allow_parallel=False)
ref_angle = 0.28211376550390677
angle = automol.util.vec.projected_central_angle(
MAT[0], MAT[1], MAT[2])
assert numpy.isclose(angle, ref_angle)
# Test the string writer
ref_vec_str = read_text_file(['data'], 'vec.dat', path=PATH)
vec_str = automol.util.vec.string((MAT[0] + MAT[1]), num_per_row=3)
assert vec_str == ref_vec_str
def test__umbrella_writer():
""" test mess_io.writer.umbrella
"""
umbrella1_str = mess_io.writer.umbrella_mode(UMBR_GROUP, UMBR_PLANE,
UMBR_REF, ONEDPOT)
umbrella2_str = mess_io.writer.umbrella_mode(UMBR_GROUP,
UMBR_PLANE,
UMBR_REF,
ONEDPOT,
geo=GEO1)
assert umbrella1_str == read_text_file(['data', 'inp'], 'umbrella1.inp',
PATH)
assert umbrella2_str == read_text_file(['data', 'inp'], 'umbrella2.inp',
PATH)
def test__structure_writer():
""" tests varecof_io.writer.input_file.structure
"""
struct_inp_str = varecof_io.writer.input_file.structure(C2H5_GEO, OH_GEO)
assert struct_inp_str == read_text_file(['data'], 'structure.inp', PATH)
def test__mcflux_writer():
""" tests varecof_io.writer.input_file.mc_flux
"""
mc_flux_inp_str = varecof_io.writer.input_file.mc_flux()
assert mc_flux_inp_str == read_text_file(['data'], 'mc_flux.inp', PATH)
def test__dummy_writer():
""" tests varecof_io.writer.corr_potentials.dummy
"""
dummy_corr_str = varecof_io.writer.corr_potentials.dummy()
assert dummy_corr_str == read_text_file(['data'], 'dummy_corr.f', PATH)
def test__pot40():
""" test polyrate_io.writer.potential_file
"""
inp_str = polyrate_io.writer.potential_file(RCT_INFO, SADPT_INFO,
MEP_INFOS)
assert inp_str == read_text_file(['data'], 'pot.fu40', PATH)
def test__convert_writer():
""" tests varecof_io.writer.input_file.convert
"""
conv_inp_str = varecof_io.writer.input_file.convert()
assert conv_inp_str == read_text_file(['data'], 'conv.inp', PATH)
def test__full_str():
""" test mess_io.writer.messrates_inp_str
test mess_io.writer.messpf_inp_str
"""
glob_keys_str = '<FAKE GLOB KEYS STR>'
glob_etrans_str = '<FAKE ETRANS STR>'
rxn_chan_str = '<FAKE REACTION CHANNEL STR>'
pf_str = '<FAKE PF CHANNEL STR>'
rates_str = mess_io.writer.messrates_inp_str(glob_keys_str,
glob_etrans_str, rxn_chan_str)
pf_str = mess_io.writer.messpf_inp_str(glob_keys_str, pf_str)
assert rates_str == read_text_file(['data', 'inp'], 'full_rates.inp', PATH)
assert pf_str == read_text_file(['data', 'inp'], 'full_pf.inp', PATH)
def test__dat():
""" test mess_io.writer.mc_data
"""
mc_dat1_str = mess_io.writer.mc_data(
GEOS, ENES)
mc_dat2_str = mess_io.writer.mc_data(
GEOS, ENES,
grads=GRADS,
hessians=HESSES)
print(mc_dat2_str)
print(read_text_file(['data', 'inp'], 'mc_dat2.inp', PATH))
assert mc_dat1_str == read_text_file(['data', 'inp'], 'mc_dat1.inp', PATH)
assert mc_dat2_str == read_text_file(['data', 'inp'], 'mc_dat2.inp', PATH)
def test__submission_script():
""" test onedmin_io.writer.submission_script
"""
subscript_str = onedmin_io.writer.submission_script(
NJOBS, RUN_DIR, EXE_PATH)
assert subscript_str == read_text_file(['data'], 'subscript.inp', PATH)
def test__core_rotd_writer():
""" test mess_io.writer.core_rotd
"""
core_rotd_str = mess_io.writer.core_rotd(SYM_FACTOR1, FLUX_FILE, STOICH)
assert core_rotd_str == read_text_file(['data', 'inp'], 'core_rotd.inp',
PATH)
def __configs_union_writer():
""" tests mess_io.writer.configs_union
"""
mol_strings = [MOL_MESS_STR for _ in range(3)]
zero_enes = (1.00, 2.00, 3.00)
union_str = mess_io.writer.configs_union(mol_strings, zero_enes)
assert union_str == read_text_file(['data', 'inp'], 'union.inp', PATH)
