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)