def test_missing_exec(self): """ Ensure failure if exec misses. """ cell_dict, s = cell2dict(REAL_PATH + "/data/LiAs_tests/LiAs.cell", verbosity=VERBOSITY, db=False) assert s param_dict, s = param2dict(REAL_PATH + "/data/LiAs_tests/LiAs.param", verbosity=VERBOSITY, db=False) assert s node = None nnodes = None seed = REAL_PATH + "/data/structures/LiAs_testcase.res" fall_over = False try: ComputeTask( ncores=NCORES, nnodes=nnodes, node=node, res=seed, param_dict=param_dict, cell_dict=cell_dict, verbosity=VERBOSITY, killcheck=True, reopt=False, executable="THIS WAS MEANT TO FAIL, DON'T WORRY", start=True, ) except CriticalError: fall_over = True self.assertTrue(fall_over)
def test_dont_restart_completed_calc(self): """ Set a relaxation up to fail. """ shutil.copy( REAL_PATH + "data/no_steps_left_todo/cache/NaP_intermediates_stopped_early.res", ".", ) shutil.copy( REAL_PATH + "data/no_steps_left_todo/cache/NaP_intermediates_stopped_early.castep", ".", ) cell_dict, s = cell2dict( REAL_PATH + "data/no_steps_left_todo/NaP.cell", verbosity=VERBOSITY, db=False, ) self.assertTrue(s) param_dict, s = param2dict( REAL_PATH + "data/no_steps_left_todo/NaP.param", verbosity=VERBOSITY, db=False, ) self.assertTrue(s) executable = "castep" node = None seed = "NaP_intermediates_stopped_early.res" with self.assertRaises(CalculationError): ComputeTask( ncores=NCORES, nnodes=None, node=node, res=seed, param_dict=param_dict, cell_dict=cell_dict, verbosity=VERBOSITY, killcheck=True, memcheck=False, exec_test=False, reopt=True, executable=executable, max_walltime=5, start=True, ) print("Process completed!") bad_exists = [] bad_exists.append( isfile("bad_castep/NaP_intermediates_stopped_early.res")) bad_exists.append( isfile("bad_castep/NaP_intermediates_stopped_early.castep")) bad_exists = all(bad_exists) good_exists = all( isdir(path) for path in ["input", "bad_castep", "logs"]) self.assertTrue(bad_exists) self.assertTrue(good_exists)
def test_benchmark_dual_core_scf(self): """ Test the time taken to perform a set number of SCF steps on 2 cores. CASTEP prints no total timing data for single core jobs. """ from os import makedirs seed = "_LiC.res" shutil.copy(REAL_PATH + "data/structures/LiC.res", "_LiC.res") cell_dict, s = cell2dict( REAL_PATH + "/data/benchmark/LiC_scf/LiC_scf.cell", verbosity=VERBOSITY, db=False, ) self.assertTrue(s) param_dict, s = param2dict( REAL_PATH + "/data/benchmark/LiC_scf/LiC_scf.param", verbosity=VERBOSITY, db=False, ) self.assertTrue(s) shutil.copy(REAL_PATH + "data/pspots/Li_00PBE.usp", ".") shutil.copy(REAL_PATH + "data/pspots/C_00PBE.usp", ".") with self.assertRaises(CalculationError): ComputeTask( ncores=2, nnodes=None, node=None, res=seed, param_dict=param_dict, cell_dict=cell_dict, verbosity=0, executable=EXECUTABLE, start=True, ) outputs_exist = [ isfile("bad_castep/_LiC.res"), isfile("bad_castep/_LiC.castep"), ] results, s = castep2dict("bad_castep/_LiC.castep", db=False) makedirs(REAL_PATH + "/data/benchmark/results", exist_ok=True) shutil.copy( "bad_castep/_LiC.castep", REAL_PATH + "/data/benchmark/results/_LiC_2core_castep{}.castep".format( results.get("castep_version", "xxx") ), ) self.assertTrue(all(outputs_exist), "couldn't find output files!") self.assertTrue(s, "couldn't read output files!") self.assertLess(results["_time_estimated"], 8)
def test_magres(self): for _f in glob.glob(REAL_PATH + "data/magres_workflow/*"): shutil.copy(_f, ".") cell_dict, _ = cell2dict("Si.cell", db=False) param_dict, _ = param2dict("Si.param", db=False) _ = ComputeTask( res="Si2.res", ncores=NCORES, nnodes=None, node=None, cell_dict=cell_dict, param_dict=param_dict, verbosity=VERBOSITY, compute_dir="tmpier_tst", workflow_kwargs={"final_elec_energy_tol": 1e-9}, ) self.assertTrue(os.path.isfile("completed/Si2.check")) self.assertTrue(os.path.isfile("completed/Si2.bands")) self.assertTrue(os.path.isfile("completed/Si2.castep")) self.assertTrue(os.path.isfile("completed/Si2.magres")) self.assertTrue(os.path.isfile("completed/Si2.cell_magres")) self.assertTrue(os.path.isfile("completed/Si2.param_magres")) self.assertTrue(os.path.isfile("completed/Si2.cell_scf")) self.assertTrue(os.path.isfile("completed/Si2.param_scf")) param, s = param2dict("completed/Si2.param_scf") self.assertTrue(s, msg="Failed to read param file") self.assertEqual(param["elec_energy_tol"], 1e-12) param, s = param2dict("completed/Si2.param_magres") self.assertEqual(param["elec_energy_tol"], 1e-12) self.assertTrue(s, msg="Failed to read param file") magres, s = magres2dict("completed/Si2.magres") self.assertTrue(s, msg="Failed to read magres file") a = 3.866895 np.testing.assert_array_almost_equal(magres["lattice_abc"], np.array([[a, a, a], [60, 60, 60]]), decimal=3) np.testing.assert_array_almost_equal(magres["chemical_shielding_isos"], np.array([129.577, 129.577]), decimal=2) self.assertTrue(os.path.isfile("completed/Si2.cell")) self.assertTrue(os.path.isfile("completed/Si2.res"))
def test_bulk_mod(self): for _f in glob.glob(REAL_PATH + "data/elastic_workflow/*"): shutil.copy(_f, ".") cell_dict, _ = cell2dict("bulk_mod.cell", db=False) param_dict, _ = param2dict("bulk_mod.param", db=False) _ = ComputeTask( res="Si2.res", ncores=NCORES, nnodes=None, node=None, cell_dict=cell_dict, param_dict=param_dict, verbosity=VERBOSITY, compute_dir="/tmp/scratch_test", workflow_kwargs={ "plot": False, "num_volumes": 5 }, ) self.assertFalse(os.path.isfile("completed/Si2.bib")) self.assertTrue(os.path.isfile("completed/Si2.check")) self.assertTrue(os.path.isfile("completed/Si2.bulk_mod.results")) self.assertTrue(os.path.isfile("completed/Si2.bulk_mod.res")) self.assertTrue(os.path.isfile("completed/Si2.bulk_mod.castep")) with open("completed/Si2.bulk_mod.results", "r") as f: flines = f.readlines() B = [] for line in flines: if "bulk modulus" in line: B.append(float(line.split()[3])) # check all computed bulk mods are between 88-92 self.assertEqual(len(B), 3) self.assertTrue(all(abs(b - 90) < 2) for b in B) self.assertFalse(os.path.isfile("completed/Si2.bulk_mod.pdf")) self.assertTrue(os.path.isfile("completed/Si2.res")) self.assertTrue(os.path.isfile("completed/Si2.geom")) self.assertTrue(os.path.isfile("completed/Si2.castep")) self.assertTrue(os.path.isfile("completed/Si2.bulk_mod.cell")) self.assertFalse(os.path.exists("/tmp/scratch_test")) self.assertFalse(os.path.exists("scratch_test_link"))
def test_faked_error_recovery(self): """ Run a calculation that *should* throw a symmetry error, and try to recover from the error. If CASTEP is not present, monkey patch such that ComputeTask copies the output files it would have expected. """ seed = REAL_PATH + "data/symmetry_failure/Sb.res" cell_dict, s = cell2dict(REAL_PATH + "/data/symmetry_failure/KSb.cell", verbosity=VERBOSITY, db=False) assert s param_dict, s = param2dict( REAL_PATH + "/data/symmetry_failure/KSb.param", verbosity=VERBOSITY, db=False, ) assert s ncores = 1 executable = REAL_PATH + "data/symmetry_failure/monkey_patch_move.sh" node = None relaxer = ComputeTask( ncores=ncores, nnodes=None, node=node, res=seed, param_dict=param_dict, cell_dict=cell_dict, verbosity=VERBOSITY, executable=executable, exec_test=False, polltime=1, start=False, ) with self.assertRaises(CalculationError): relaxer.begin() bad_castep_exists = isdir("bad_castep") completed_exists = isdir("completed") self.assertTrue(bad_castep_exists) self.assertFalse(completed_exists) self.assertTrue(relaxer.final_result is None) self.assertEqual(relaxer._num_retries, 3) self.assertTrue("symmetry_generate" not in relaxer.calc_doc) self.assertTrue("snap_to_symmetry" not in relaxer.calc_doc) self.assertTrue("symmetry_tol" not in relaxer.calc_doc)
def test_failed_relaxation(self): """ Set a relaxation up to fail. """ seed = "_LiAs_testcase.res" shutil.copy( REAL_PATH + "data/structures/LiAs_testcase_bad.res", "_LiAs_testcase.res" ) cell_dict, s = cell2dict( REAL_PATH + "/data/LiAs_tests/LiAs.cell", verbosity=VERBOSITY, db=False ) assert s param_dict, s = param2dict( REAL_PATH + "/data/LiAs_tests/LiAs.param", verbosity=VERBOSITY, db=False ) assert s param_dict["geom_max_iter"] = 3 executable = "castep" node = None shutil.copy(REAL_PATH + "data/pspots/Li_00PBE.usp", ".") shutil.copy(REAL_PATH + "data/pspots/As_00PBE.usp", ".") relaxer = ComputeTask( ncores=NCORES, nnodes=None, node=node, res=seed, param_dict=param_dict, cell_dict=cell_dict, verbosity=VERBOSITY, killcheck=True, memcheck=False, reopt=True, executable=executable, rough=0, fine_iter=3, start=False, ) with self.assertRaises(CalculationError): relaxer.begin() bad_exists = isfile("bad_castep/_LiAs_testcase.res") num = reset_job_folder() self.assertTrue(bad_exists, "couldn't find output file!") self.assertEqual(num, 0)
def test_scf(self): """ Perform SCF on structure from file. """ seed = "_LiC.res" shutil.copy(REAL_PATH + "data/structures/LiC.res", "_LiC.res") cell_dict, s = cell2dict(REAL_PATH + "/data/LiC_tests/LiC_scf.cell", verbosity=VERBOSITY, db=False) assert s param_dict, s = param2dict(REAL_PATH + "/data/LiC_tests/LiC_scf.param", verbosity=VERBOSITY, db=False) assert s executable = "castep" node = None shutil.copy(REAL_PATH + "data/pspots/Li_00PBE.usp", ".") shutil.copy(REAL_PATH + "data/pspots/C_00PBE.usp", ".") ComputeTask( ncores=NCORES, nnodes=None, node=node, res=seed, param_dict=param_dict, cell_dict=cell_dict, verbosity=VERBOSITY, killcheck=True, reopt=True, executable=executable, compute_dir="/tmp/compute_test", start=True, ) completed_exists = [ isfile("completed/_LiC.res"), isfile("completed/_LiC.castep"), isfile("completed/_LiC-out.cell"), ] base_file_exists = [ isfile("_LiC.res"), isfile("_LiC.castep"), isfile("_LiC.res.lock"), ] self.assertFalse(any(base_file_exists), "failed to clean up files!") self.assertTrue(all(completed_exists), "couldn't find output files!")
def test_memcheck(self): """ Test the memory checker will not proceed with huge jobs. """ shutil.copy( REAL_PATH + "data/structures/LiAs_testcase.res", "_LiAs_testcase.res" ) shutil.copy(REAL_PATH + "data/pspots/Li_00PBE.usp", ".") shutil.copy(REAL_PATH + "data/pspots/As_00PBE.usp", ".") cell_dict, s = cell2dict( REAL_PATH + "data/LiAs_tests/LiAs.cell", verbosity=VERBOSITY, db=False ) self.assertTrue(s) param_dict, s = param2dict( REAL_PATH + "data/LiAs_tests/LiAs.param", verbosity=VERBOSITY, db=False ) self.assertTrue(s) with self.assertRaises(MaxMemoryEstimateExceeded): ComputeTask( ncores=NCORES, nnodes=None, node=None, res="_LiAs_testcase.res", param_dict=param_dict, cell_dict=cell_dict, verbosity=VERBOSITY, killcheck=True, memcheck=True, maxmem=1, start=True, ) files_that_should_not_exist = ["_LiAs_testcase.res.lock", "jobs.txt"] folders_that_should_exist = ["logs"] folders_that_should_not_exist = ["bad_castep", "input", "completed"] correct_files = all( [not isfile(_file) for _file in files_that_should_not_exist] ) correct_folders = all([isdir(folder) for folder in folders_that_should_exist]) correct_folders *= all( [not isdir(folder) for folder in folders_that_should_not_exist] ) self.assertTrue(correct_folders) self.assertTrue(correct_files)
def test_relax_to_file(self): """ Relax structure from file to file. """ seed = "_Li.res" shutil.copy(REAL_PATH + "data/structures/Li.res", "_Li.res") cell_dict, s = cell2dict(REAL_PATH + "/data/LiAs_tests/LiAs.cell", verbosity=VERBOSITY, db=False) assert s param_dict, s = param2dict(REAL_PATH + "/data/LiAs_tests/LiAs.param", verbosity=VERBOSITY, db=False) assert s executable = "castep" node = None shutil.copy(REAL_PATH + "data/pspots/Li_00PBE.usp", ".") shutil.copy(REAL_PATH + "data/pspots/As_00PBE.usp", ".") ComputeTask( ncores=NCORES, nnodes=None, node=node, res=seed, param_dict=param_dict, cell_dict=cell_dict, verbosity=VERBOSITY, killcheck=True, reopt=True, executable=executable, exec_test=False, start=True, ) print("Process completed!") completed_exists = isfile("completed/_Li.res") base_files_exist = [ isfile("_Li.res"), isfile("_Li.res.lock"), isfile("_Li.castep"), ] self.assertTrue(completed_exists, "couldn't find output file!") self.assertFalse(any(base_files_exist), "couldn't clean input files")
def test_phonon(self): for _f in glob.glob(REAL_PATH + "data/phonon_workflow/*"): shutil.copy(_f, ".") cell_dict, _ = cell2dict("Si.cell", db=False) param_dict, _ = param2dict("Si.param", db=False) _ = ComputeTask( res="Si2.res", ncores=NCORES, nnodes=None, node=None, cell_dict=cell_dict, param_dict=param_dict, verbosity=VERBOSITY, compute_dir="tmpier_tst", ) self.assertFalse(os.path.isfile("completed/Si2.bib")) self.assertTrue(os.path.isfile("completed/Si2.check")) self.assertTrue(os.path.isfile("completed/Si2.bands")) self.assertTrue(os.path.isfile("completed/Si2.castep")) self.assertTrue(os.path.isfile("completed/Si2.phonon")) self.assertTrue(os.path.isfile("completed/Si2.phonon_dos")) phon, s = phonon2dict("completed/Si2.phonon") a = 2.7355124 np.testing.assert_array_almost_equal(phon["lattice_cart"], np.array([[0, a, a], [a, 0, a], [a, a, 0]]), decimal=3) a = 3.869 np.testing.assert_array_almost_equal(phon["lattice_abc"], np.array([[a, a, a], [60, 60, 60]]), decimal=3) self.assertTrue(s, msg="Failed to read phonon file") self.assertGreater(np.min(phon["eigenvalues_q"]), -0.05) self.assertTrue(os.path.isfile("completed/Si2.cell")) self.assertTrue(os.path.isfile("completed/Si2.res"))
def test_scf_max_walltime(self): """ Perform SCF on structure from file. """ seed = "_LiC.res" shutil.copy(REAL_PATH + "data/structures/LiC.res", "_LiC.res") cell_dict, s = cell2dict(REAL_PATH + "/data/LiC_tests/LiC_scf.cell", verbosity=VERBOSITY, db=False) assert s param_dict, s = param2dict(REAL_PATH + "/data/LiC_tests/LiC_scf.param", verbosity=VERBOSITY, db=False) assert s executable = "castep" node = None shutil.copy(REAL_PATH + "data/pspots/Li_00PBE.usp", ".") shutil.copy(REAL_PATH + "data/pspots/C_00PBE.usp", ".") with self.assertRaises(WalltimeError): ComputeTask( ncores=NCORES, nnodes=None, node=node, res=seed, param_dict=param_dict, cell_dict=cell_dict, verbosity=VERBOSITY, timings=(5, time.time()), polltime=2, executable=executable, compute_dir="/tmp/compute_test", start=True, ) base_file_exists = [ isfile("_LiC.res"), isfile("_LiC.castep"), ] self.assertFalse(isfile("_LiC.res.lock"), "failed to clean up lock") self.assertTrue(all(base_file_exists), "failed to keep valid files!")
def test_old_file(self): """ Run a calculation with an executable that only does "sleep", in the presence of a file that was written previouisly, and check that run3 will stop the calculation early as no file is written. """ seed = REAL_PATH + "data/symmetry_failure/Sb.res" with open("Sb.castep", "w") as f: f.write("I am a CASTEP file, for sure.") cell_dict, s = cell2dict(REAL_PATH + "/data/symmetry_failure/KSb.cell", verbosity=VERBOSITY, db=False) assert s param_dict, s = param2dict( REAL_PATH + "/data/symmetry_failure/KSb.param", verbosity=VERBOSITY, db=False, ) assert s executable = REAL_PATH + "data/missing_file_test/monkey_patch_sleep.sh" node = None relaxer = ComputeTask( ncores=NCORES, nnodes=None, node=node, res=seed, param_dict=param_dict, cell_dict=cell_dict, verbosity=VERBOSITY, executable=executable, exec_test=False, polltime=1, start=False, ) with self.assertRaises(CalculationError): relaxer.begin() self.assertTrue(relaxer.final_result is None)
def test_full_spectral(self): for _f in glob.glob(REAL_PATH + "data/spectral_workflow/*"): shutil.copy(_f, ".") cell_dict, _ = cell2dict("Si.cell") param_dict, _ = param2dict("Si.param", db=False) _ = ComputeTask( res="Si2.res", ncores=NCORES, nnodes=None, node=None, cell_dict=cell_dict, param_dict=param_dict, verbosity=VERBOSITY, compute_dir=None, ) self.assertFalse(os.path.isfile("completed/Si2.bib")) self.assertTrue(os.path.isfile("completed/Si2.check")) self.assertTrue(os.path.isfile("completed/Si2-out.cell_dispersion")) self.assertTrue(os.path.isfile("completed/Si2-out.cell_dos")) self.assertTrue(os.path.isfile("completed/Si2-out.cell_scf")) self.assertTrue(os.path.isfile("completed/Si2.adaptive.agr")) self.assertTrue(os.path.isfile("completed/Si2.adaptive.dat")) self.assertTrue(os.path.isfile("completed/Si2.bands")) self.assertTrue(os.path.isfile("completed/Si2.bands_dispersion")) self.assertTrue(os.path.isfile("completed/Si2.bands_dos")) self.assertTrue(os.path.isfile("completed/Si2.castep")) self.assertTrue(os.path.isfile("completed/Si2.castep_bin")) self.assertTrue(os.path.isfile("completed/Si2.castep_dispersion")) self.assertTrue(os.path.isfile("completed/Si2.castep_dos")) self.assertTrue(os.path.isfile("completed/Si2.castep_scf")) self.assertTrue(os.path.isfile("completed/Si2.cell")) self.assertTrue(os.path.isfile("completed/Si2.cell_dispersion")) self.assertTrue(os.path.isfile("completed/Si2.cell_dos")) self.assertTrue(os.path.isfile("completed/Si2.cell_scf")) self.assertTrue(os.path.isfile("completed/Si2.cst_esp")) self.assertTrue(os.path.isfile("completed/Si2.dome_bin")) self.assertTrue(os.path.isfile("completed/Si2.dome_bin_broadening")) self.assertTrue(os.path.isfile("completed/Si2.dome_bin_dispersion")) self.assertTrue(os.path.isfile("completed/Si2.dome_bin_dos")) self.assertTrue(os.path.isfile("completed/Si2.dome_bin_pdos")) self.assertTrue(os.path.isfile("completed/Si2.odi")) self.assertTrue(os.path.isfile("completed/Si2.odi_broadening")) self.assertTrue(os.path.isfile("completed/Si2.odi_pdis")) self.assertTrue(os.path.isfile("completed/Si2.odi_pdos")) self.assertTrue(os.path.isfile("completed/Si2.odo")) self.assertTrue(os.path.isfile("completed/Si2.odo_broadening")) self.assertTrue(os.path.isfile("completed/Si2.odo_pdis")) self.assertTrue(os.path.isfile("completed/Si2.odo_pdos")) self.assertTrue(os.path.isfile("completed/Si2.param")) self.assertTrue(os.path.isfile("completed/Si2.param_dispersion")) self.assertTrue(os.path.isfile("completed/Si2.param_dos")) self.assertTrue(os.path.isfile("completed/Si2.param_scf")) self.assertTrue(os.path.isfile("completed/Si2.pdis.dat")) self.assertTrue(os.path.isfile("completed/Si2.pdos.dat")) self.assertTrue(os.path.isfile("completed/Si2.pdos_bin")) self.assertTrue(os.path.isfile("completed/Si2.pdos_bin_broadening")) self.assertTrue(os.path.isfile("completed/Si2.pdos_bin_dispersion")) self.assertTrue(os.path.isfile("completed/Si2.pdos_bin_dos")) self.assertTrue(os.path.isfile("completed/Si2.pdos_bin_pdis")) self.assertTrue(os.path.isfile("completed/Si2.pdos_bin_pdos")) self.assertTrue(os.path.isfile("completed/Si2.res"))
def test_relax_to_queue(self): """ Mimic GA and test Queue relaxations. """ newborn, s = res2dict( REAL_PATH + "/data/structures/LiAs_testcase.res", verbosity=VERBOSITY, db=False, ) assert s cell_dict, s = cell2dict(REAL_PATH + "/data/LiAs_tests/LiAs.cell", verbosity=VERBOSITY, db=False) assert s param_dict, s = param2dict(REAL_PATH + "/data/LiAs_tests/LiAs.param", verbosity=VERBOSITY, db=False) assert s node = None executable = "castep" newborn["source"] = [REAL_PATH + "/data/GA_TESTCASE.res"] shutil.copy(REAL_PATH + "data/pspots/Li_00PBE.usp", ".") shutil.copy(REAL_PATH + "data/pspots/As_00PBE.usp", ".") queue = mp.Queue() relaxer = ComputeTask( ncores=NCORES, nnodes=None, node=node, res=newborn, param_dict=param_dict, cell_dict=cell_dict, verbosity=VERBOSITY, killcheck=True, reopt=False, executable=executable, output_queue=queue, start=True, ) # store proc object with structure ID, node name, output queue and number of cores proc = (1, node, mp.Process(target=relaxer.relax), NCORES) proc[2].start() while proc[2].is_alive(): time.sleep(1) result, success = castep2dict("completed/GA_TESTCASE.castep") queue_result = queue.get() match_dict = dict() for key in queue_result: if key in ["source", "site_occupancy", "geom_iter"]: continue match_dict[key] = queue_result[key] == result[key] if not match_dict[key]: print(key, queue_result[key], result[key]) completed_exists = isfile("completed/GA_TESTCASE.res") input_exists = isfile("input/GA_TESTCASE.res") self.assertTrue(completed_exists, "couldn't find output file!") self.assertTrue(input_exists, "couldn't find shutil.copy of input file!") self.assertTrue(success, "couldn't parse output file!") self.assertTrue(all([match_dict[key] for key in match_dict]))
def test_benchmark_manycore_scf(self): """ Test the time taken to perform a set number of SCF steps on many cores. """ from os import makedirs seed = "_LiC.res" shutil.copy(REAL_PATH + "data/structures/LiC.res", "_LiC.res") cell_dict, s = cell2dict( REAL_PATH + "/data/benchmark/LiC_scf/LiC_scf.cell", verbosity=VERBOSITY, db=False, ) self.assertTrue(s) param_dict, s = param2dict( REAL_PATH + "/data/benchmark/LiC_scf/LiC_scf.param", verbosity=VERBOSITY, db=False, ) self.assertTrue(s) shutil.copy(REAL_PATH + "data/pspots/Li_00PBE.usp", ".") shutil.copy(REAL_PATH + "data/pspots/C_00PBE.usp", ".") with self.assertRaises(CalculationError): ComputeTask( ncores=NCORES, nnodes=None, node=None, res=seed, param_dict=param_dict, cell_dict=cell_dict, verbosity=0, executable=EXECUTABLE, start=True, ) outputs_exist = [ isfile("bad_castep/_LiC.res"), isfile("bad_castep/_LiC.castep"), ] results, s = castep2dict("bad_castep/_LiC.castep", db=False) makedirs(REAL_PATH + "/data/benchmark/results", exist_ok=True) shutil.copy( "bad_castep/_LiC.castep", REAL_PATH + "/data/benchmark/results/_LiC_{}core_castep{}.castep".format( results.get("num_mpi_processes", 0), results.get("castep_version", "xxx"), ), ) self.assertTrue(all(outputs_exist), "couldn't find output files!") self.assertTrue(s, "couldn't read output files!") print(results["_time_estimated"]) benchmark_data = {2: 2 * 7.4, 4: 4 * 4.0, 12: 16.8, 14: 22.4, 18: 23.4} warnings.warn( RuntimeWarning( "Run took {} s with {} MPI processes, with cumulative CPU time of {:.1f} s. Benchmark data\n = {}" .format( results["_time_estimated"], results["num_mpi_processes"], results["_time_estimated"] * results["num_mpi_processes"], benchmark_data, )))