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')
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')
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')
real3, imag3 = projrot_io.reader.rpht_output(out_str3)
assert numpy.allclose(real3, ref_real3)
assert numpy.allclose(imag3, ref_imag3)
def test__ts_variational_writer():
""" ts mess_io.writer.rxnchan.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.rxnchan.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')
ts_var2_str = mess_io.writer.rxnchan.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')
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=True,
**CONDITIONS_DCT)
with open('data/divsur1.inp', 'w') as f:
f.write(divsur_inp1_str)
with open('data/divsur2.inp', 'w') as f:
f.write(divsur_inp2_str)
assert divsur_inp1_str == read_text_file(['data'], 'divsur1.inp')
assert divsur_inp2_str == read_text_file(['data'], 'divsur2.inp')
def test__dummy_writer():
""" tests mess_io.writer.dummy
"""
dummy1_str = mess_io.writer.rxnchan.dummy(BIMOL_LABEL)
assert dummy1_str == read_text_file(['data', 'inp'], 'dummy1.inp')
dummy2_str = mess_io.writer.rxnchan.dummy(BIMOL_LABEL, zero_ene=ENE)
assert dummy2_str == read_text_file(['data', 'inp'], 'dummy2.inp')
def test__flux_mode():
""" test mess_io.writer.monte_carlo.fluxional_mode
"""
# Write the fluxional mode string
flux_mode1_str = mess_io.writer.monte_carlo.fluxional_mode(FLUX_IDX)
flux_mode2_str = mess_io.writer.monte_carlo.fluxional_mode(FLUX_IDX,
span=FLUX_SPAN)
assert flux_mode1_str == read_text_file(['data', 'inp'], 'flux_mode1.inp')
assert flux_mode2_str == read_text_file(['data', 'inp'], 'flux_mode2.inp')
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')
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')
def test__monte_carlo_dat():
""" test mess_io.writer.monte_carlo.mc_data
"""
mc_dat1_str = mess_io.writer.monte_carlo.mc_data(GEOS, ENES)
mc_dat2_str = mess_io.writer.monte_carlo.mc_data(GEOS,
ENES,
grads=GRADS,
hessians=HESSES)
assert mc_dat1_str == read_text_file(['data', 'inp'], 'mc_dat1.inp')
assert mc_dat2_str == read_text_file(['data', 'inp'], 'mc_dat2.inp')
def test__global_reaction():
""" test mess_io.writer.global_reaction
"""
glob_rxn1_str = mess_io.writer.global_reaction(TEMPS, PRESSURES)
glob_rxn2_str = mess_io.writer.global_reaction(
TEMPS,
PRESSURES,
excess_ene_temp=EXCESS_ENE_TEMP,
well_extend=WELL_EXTEND)
assert glob_rxn1_str == read_text_file(['data', 'inp'], 'glob_rxn1.inp')
assert glob_rxn2_str == read_text_file(['data', 'inp'], 'glob_rxn2.inp')
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')
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')
def test__tunnel_sct_writer():
""" test mess_io.writer.mol_data.tunnel_sct
"""
tunnel_sct1_str = mess_io.writer.mol_data.tunnel_sct(
IMAG_FREQ, TUNNEL_FILE)
tunnel_sct2_str = mess_io.writer.mol_data.tunnel_sct(
IMAG_FREQ, TUNNEL_FILE, cutoff_energy=CUTOFF_ENE)
assert tunnel_sct1_str == read_text_file(['data', 'inp'],
'tunnel_sct1.inp')
assert tunnel_sct2_str == read_text_file(['data', 'inp'],
'tunnel_sct2.inp')
def test__species_writer():
""" Writes the MESS input for a Well
"""
spc1_str = mess_io.writer.rxnchan.species(SPC1_LABEL,
MOL_MESS_STR,
zero_ene=None)
assert spc1_str == read_text_file(['data', 'inp'], 'spc1.inp')
spc2_str = mess_io.writer.rxnchan.species(SPC2_LABEL,
MOL_MESS_STR,
zero_ene=ENE)
assert spc2_str == read_text_file(['data', 'inp'], 'spc2.inp')
def test__core_multirotor_writer():
""" test mess_io.writer.mol_data.rotor_internal
test mess_io.writer.mol_data.mdhr_data
test mess_io.writer.mol_data.core_multirotor
"""
# Internal Rotor Sections
rotor_int1_str = mess_io.writer.mol_data.rotor_internal(
HR_GROUP, HR_AXIS, HR_SYMMETRY, HR_GRID_SIZE, HR_MASS_EXP_SIZE)
rotor_int2_str = mess_io.writer.mol_data.rotor_internal(
HR_GROUP,
HR_AXIS,
HR_SYMMETRY,
HR_GRID_SIZE,
HR_MASS_EXP_SIZE,
pot_exp_size=POT_EXP_SIZE,
hmin=HMIN,
hmax=HMAX,
remdummy=REMDUMMY,
geom=GEO1,
rotor_id=HR_ID)
assert rotor_int1_str == read_text_file(['data', 'inp'], 'rotor_int1.inp')
assert rotor_int2_str == read_text_file(['data', 'inp'], 'rotor_int2.inp')
mdhr_dat_1d_str = mess_io.writer.mol_data.mdhr_data(ONEDPOT)
mdhr_dat_2dfr_str = mess_io.writer.mol_data.mdhr_data(TWODPOT,
freqs=TWODFREQ,
nrot=3)
mdhr_dat_3dfr_str = mess_io.writer.mol_data.mdhr_data(THREEDPOT,
freqs=THREEDFREQ,
nrot=3)
mdhr_dat_4dfr_str = mess_io.writer.mol_data.mdhr_data(FOURDPOT,
freqs=FOURDFREQ,
nrot=3)
assert mdhr_dat_1d_str == read_text_file(['data', 'inp'],
'mdhr_dat_1d.inp')
assert mdhr_dat_2dfr_str == read_text_file(['data', 'inp'],
'mdhr_dat_2dfr.inp')
assert mdhr_dat_3dfr_str == read_text_file(['data', 'inp'],
'mdhr_dat_3dfr.inp')
assert mdhr_dat_4dfr_str == read_text_file(['data', 'inp'],
'mdhr_dat_4dfr.inp')
# MultiRotor Core Sections
core_multirot1_str = mess_io.writer.mol_data.core_multirotor(
GEO1, SYM_FACTOR1, POT_SURF_FILE, rotor_int1_str)
core_multirot2_str = mess_io.writer.mol_data.core_multirotor(
GEO1,
SYM_FACTOR1,
POT_SURF_FILE,
rotor_int1_str,
interp_emax=INTERP_EMAX,
quant_lvl_emax=QUANT_LVL_EMAX)
assert core_multirot1_str == read_text_file(['data', 'inp'],
'core_multirot1.inp')
assert core_multirot2_str == read_text_file(['data', 'inp'],
'core_multirot2.inp')
def test__submission_script():
""" test onedmin_io.writer.submission_script
"""
subscript1_str = onedmin_io.writer.submission_script(
NJOBS, JOB_PATH, ONEDMIN_PATH)
subscript2_str = onedmin_io.writer.submission_script(NJOBS,
JOB_PATH,
ONEDMIN_PATH,
exe_name=EXE_NAME)
assert subscript1_str == read_text_file(['data'], 'subscript1.inp')
assert subscript2_str == read_text_file(['data'], 'subscript2.inp')
def test__well_writer():
""" Writes the MESS input for a Well
"""
# fix
well1_str = mess_io.writer.rxnchan.well(WELL_LABEL, MOL_MESS_STR)
assert well1_str == read_text_file(['data', 'inp'], 'well1.inp')
well2_str = mess_io.writer.rxnchan.well(WELL_LABEL,
MOL_MESS_STR,
zero_ene=ENE,
edown_str=EDOWN_STR,
collid_freq_str=COLLID_STR)
assert well2_str == read_text_file(['data', 'inp'], 'well2.inp')
def test__core_rigidrotor_writer():
""" test mess_io.writer.mol_data.core_rigidrotor
"""
core_rigrot1_str = mess_io.writer.mol_data.core_rigidrotor(
GEO1, SYM_FACTOR1)
core_rigrot2_str = mess_io.writer.mol_data.core_rigidrotor(
GEO1, SYM_FACTOR1, interp_emax=INTERP_EMAX)
assert core_rigrot1_str == read_text_file(['data', 'inp'],
'core_rigrot1.inp')
assert core_rigrot2_str == read_text_file(['data', 'inp'],
'core_rigrot2.inp')
def test__umbrella_writer():
""" test mess_io.writer.mol_data.umbrella
"""
umbrella1_str = mess_io.writer.mol_data.umbrella_mode(
UMBR_GROUP, UMBR_PLANE, UMBR_REF, ONEDPOT)
umbrella2_str = mess_io.writer.mol_data.umbrella_mode(UMBR_GROUP,
UMBR_PLANE,
UMBR_REF,
ONEDPOT,
remdummy=REMDUMMY,
geom=GEO1)
assert umbrella1_str == read_text_file(['data', 'inp'], 'umbrella1.inp')
assert umbrella2_str == read_text_file(['data', 'inp'], 'umbrella2.inp')
def test__global_pf():
""" tests writing the section to a file for messpf
"""
glob_pf1_str = mess_io.writer.global_pf(temperatures=TEMPS)
glob_pf2_str = mess_io.writer.global_pf(temperatures=())
glob_pf3_str = mess_io.writer.global_pf(temperatures=(),
temp_step=TEMP_STEP,
ntemps=NTEMPS,
rel_temp_inc=REL_TEMP_INC,
atom_dist_min=ATOM_DIST_MIN)
assert glob_pf1_str == read_text_file(['data', 'inp'], 'glob_pf1.inp')
assert glob_pf2_str == read_text_file(['data', 'inp'], 'glob_pf2.inp')
assert glob_pf3_str == read_text_file(['data', 'inp'], 'glob_pf3.inp')
def test__ts_sadpt_writer():
""" ts sadpt writer
"""
# fix
ts_sadpt1_str = mess_io.writer.rxnchan.ts_sadpt(TS_LABEL, WELL_LABEL,
BIMOL_LABEL, MOL_MESS_STR)
assert ts_sadpt1_str == read_text_file(['data', 'inp'], 'ts_sadpt1.inp')
ts_sadpt2_str = mess_io.writer.rxnchan.ts_sadpt(TS_LABEL,
WELL_LABEL,
BIMOL_LABEL,
MOL_MESS_STR,
zero_ene=ENE,
tunnel=TUNNEL_STR)
assert ts_sadpt2_str == read_text_file(['data', 'inp'], 'ts_sadpt2.inp')
def test__configs_union_writer():
""" tests mess_io.writer.rxnchan.configs_union
"""
mol_strings = [MOL_MESS_STR for _ in range(3)]
union_str = mess_io.writer.rxnchan.configs_union(mol_strings)
assert union_str == read_text_file(['data', 'inp'], 'union.inp')
def test__core_rotd_writer():
""" test mess_io.writer.mol_data.core_rotd
"""
core_rotd_str = mess_io.writer.mol_data.core_rotd(SYM_FACTOR1, FLUX_FILE,
STOICH)
assert core_rotd_str == read_text_file(['data', 'inp'], 'core_rotd.inp')
def test__bimolecular_writer():
""" Writes the MESS input for a bimolecular set
"""
bimol_str = mess_io.writer.rxnchan.bimolecular(BIMOL_LABEL, SPC1_LABEL,
ATOM_MESS_STR, SPC2_LABEL,
MOL_MESS_STR, ENE)
assert bimol_str == read_text_file(['data', 'inp'], 'bimol.inp')
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)
with open('data/makefile1', 'w') as f:
f.write(makefile1_str)
with open('data/makefile', 'w') as f:
f.write(makefile2_str)
assert makefile1_str == read_text_file(['data'], 'makefile1')
assert makefile2_str == read_text_file(['data'], 'makefile')
def test__auxiliary_writer():
""" tests varecof_io.writer.corr_potentials.auxiliary
"""
pot_aux_str = varecof_io.writer.corr_potentials.auxiliary()
with open('data/pot_aux.f', 'w') as f:
f.write(pot_aux_str)
assert pot_aux_str == read_text_file(['data'], 'pot_aux.f')
def test__tunnel_eckart_writer():
""" test mess_io.writer.mol_data.tunnel_eckart
"""
tunnel_eckart_str = mess_io.writer.mol_data.tunnel_eckart(
IMAG_FREQ, WELL_DEPTH1, WELL_DEPTH2)
assert tunnel_eckart_str == read_text_file(['data', 'inp'],
'tunnel_eckart.inp')
def test__input_file():
""" test onedmin_io.writer.input_file
"""
onedmin_inp1_str = onedmin_io.writer.input_file(RANSEED, NSAMP, SMIN, SMAX,
TARGET_XYZ_NAME,
BATH_XYZ_NAME)
onedmin_inp2_str = onedmin_io.writer.input_file(RANSEED,
NSAMP,
SMIN,
SMAX,
TARGET_XYZ_NAME,
BATH_XYZ_NAME,
spin_method=1)
assert onedmin_inp1_str == read_text_file(['data'], 'onedmin1.inp')
assert onedmin_inp2_str == read_text_file(['data'], 'onedmin2.inp')
def test__convert_writer():
""" tests varecof_io.writer.input_file.convert
"""
conv_inp_str = varecof_io.writer.input_file.convert()
with open('data/conv.inp', 'w') as f:
f.write(conv_inp_str)
assert conv_inp_str == read_text_file(['data'], 'conv.inp')
def test__mcflux_writer():
""" tests varecof_io.writer.input_file.mc_flux
"""
mc_flux_inp_str = varecof_io.writer.input_file.mc_flux()
with open('data/mc_flux.inp', 'w') as f:
f.write(mc_flux_inp_str)
assert mc_flux_inp_str == read_text_file(['data'], 'mc_flux.inp')
def test__structure_writer():
""" tests varecof_io.writer.input_file.structure
"""
struct_inp_str = varecof_io.writer.input_file.structure(C2H5_GEO, OH_GEO)
with open('data/structure.inp', 'w') as f:
f.write(struct_inp_str)
assert struct_inp_str == read_text_file(['data'], 'structure.inp')
def test__full_str():
""" test mess_io.writer.messrates_inp_str
test mess_io.writer.messpf_inp_str
"""
glob_rxn_str = read_text_file(['data', 'inp'], 'glob_pf1.inp')
glob_pf_str = read_text_file(['data', 'inp'], 'glob_pf1.inp')
glob_etrans_str = read_text_file(['data', 'inp'], 'glob_etrans.inp')
rxn_chan_str = '<FAKE REACTION CHANNEL_STR>'
pf_str = '<FAKE PF CHANNEL_STR>'
rates_inp_str = mess_io.writer.messrates_inp_str(glob_rxn_str,
glob_etrans_str,
rxn_chan_str)
pf_inp_str = mess_io.writer.messpf_inp_str(glob_pf_str, pf_str)
assert rates_inp_str == read_text_file(['data', 'inp'], 'full_rates.inp')
assert pf_inp_str == read_text_file(['data', 'inp'], 'full_pf.inp')
def test__dummy_writer():
""" tests varecof_io.writer.corr_potentials.dummy
"""
dummy_corr_str = varecof_io.writer.corr_potentials.dummy()
with open('data/dummy_corr.f', 'w') as f:
f.write(dummy_corr_str)
assert dummy_corr_str == read_text_file(['data'], 'dummy_corr.f')
