def test_autoz_error(self): shutil.copyfile(os.path.join(test_dir, "qunino_vinyl.qcinp"), os.path.join(scr_dir, "qunino_vinyl.qcinp")) shutil.copyfile(os.path.join(test_dir, "qunino_vinyl.qcout"), os.path.join(scr_dir, "qunino_vinyl.qcout")) h = QChemErrorHandler(input_file="qunino_vinyl.qcinp", output_file="qunino_vinyl.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual(d, {'errors': ['Bad SCF convergence', 'Geometry optimization failed', 'Molecular charge is not found', 'autoz error'], 'actions': ['disable symmetry']}) with open(os.path.join(test_dir, "qunino_vinyl_nosymm.qcinp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "qunino_vinyl.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans) shutil.copyfile(os.path.join(test_dir, "qunino_vinyl_nosymm.qcinp"), os.path.join(scr_dir, "qunino_vinyl_nosymm.qcinp")) shutil.copyfile(os.path.join(test_dir, "qunino_vinyl.qcout"), os.path.join(scr_dir, "qunino_vinyl.qcout")) h = QChemErrorHandler(input_file="qunino_vinyl_nosymm.qcinp", output_file="qunino_vinyl.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual(d, {'errors': ['Bad SCF convergence', 'Geometry optimization failed', 'Molecular charge is not found', 'autoz error'], 'actions': None})
def test_linear_dependent_basis(self): for ii in range(1, 3): shutil.copyfile( os.path.join(test_dir, "unable_to_determine_lamda.qin." + str(ii)), os.path.join(scr_dir, "unable_to_determine_lamda.qin." + str(ii))) shutil.copyfile( os.path.join(test_dir, "unable_to_determine_lamda.qout." + str(ii)), os.path.join(scr_dir, "unable_to_determine_lamda.qout." + str(ii))) h = QChemErrorHandler(input_file="unable_to_determine_lamda.qin.1", output_file="unable_to_determine_lamda.qout.1") h.check() d = h.correct() self.assertEqual(d["errors"], ['linear_dependent_basis']) self.assertEqual(d["actions"], [{"scf_algorithm": "rca_diis"}]) self._check_equivalent_inputs("unable_to_determine_lamda.qin.1", "unable_to_determine_lamda.qin.2") h = QChemErrorHandler(input_file="unable_to_determine_lamda.qin.2", output_file="unable_to_determine_lamda.qout.2") self.assertEqual(h.check(), False)
def test_scf_failed_to_converge(self): for ii in range(3): shutil.copyfile( os.path.join(test_dir, "crowd_gradient.qin." + str(ii)), os.path.join(scr_dir, "crowd_gradient.qin." + str(ii)), ) shutil.copyfile( os.path.join(test_dir, "crowd_gradient.qout." + str(ii)), os.path.join(scr_dir, "crowd_gradient.qout." + str(ii)), ) h = QChemErrorHandler(input_file="crowd_gradient.qin.0", output_file="crowd_gradient.qout.0") h.check() d = h.correct() self.assertEqual(d["errors"], ["SCF_failed_to_converge"]) self.assertEqual(d["actions"], [{"max_scf_cycles": 200}]) self._check_equivalent_inputs("crowd_gradient.qin.0", "crowd_gradient.qin.1") h = QChemErrorHandler(input_file="crowd_gradient.qin.1", output_file="crowd_gradient.qout.1") h.check() d = h.correct() self.assertEqual(d["errors"], ["SCF_failed_to_converge"]) self.assertEqual(d["actions"], [{"thresh": "14"}])
def test_failed_to_transform(self): for ii in range(2): shutil.copyfile( os.path.join(test_dir, "qunino_vinyl.qin." + str(ii)), os.path.join(scr_dir, "qunino_vinyl.qin." + str(ii)), ) shutil.copyfile( os.path.join(test_dir, "qunino_vinyl.qout." + str(ii)), os.path.join(scr_dir, "qunino_vinyl.qout." + str(ii)), ) h = QChemErrorHandler(input_file="qunino_vinyl.qin.0", output_file="qunino_vinyl.qout.0") h.check() d = h.correct() self.assertEqual(d["errors"], ["failed_to_transform_coords"]) self.assertEqual(d["actions"], [{ "sym_ignore": True }, { "symmetry": False }]) self._check_equivalent_inputs("qunino_vinyl.qin.0", "qunino_vinyl.qin.1") h = QChemErrorHandler(input_file="qunino_vinyl.qin.1", output_file="qunino_vinyl.qout.1") self.assertEqual(h.check(), False)
def test_freq_job_too_small(self): shutil.copyfile(os.path.join(test_dir, "freq_seg_too_small.qcinp"), os.path.join(scr_dir, "freq_seg_too_small.qcinp")) shutil.copyfile(os.path.join(test_dir, "freq_seg_too_small.qcout"), os.path.join(scr_dir, "freq_seg_too_small.qcout")) h = QChemErrorHandler(input_file="freq_seg_too_small.qcinp", output_file="freq_seg_too_small.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual(d, {'errors': ['Exit Code 134', 'Freq Job Too Small'], 'actions': ['use 31 segment in CPSCF']}) with open(os.path.join(test_dir, "freq_seg_too_small_31_segments.qcinp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "freq_seg_too_small.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans) shutil.copyfile(os.path.join(test_dir, "freq_seg_too_small_31_segments.qcinp"), os.path.join(scr_dir, "freq_seg_too_small_31_segments.qcinp")) shutil.copyfile(os.path.join(test_dir, "freq_seg_too_small.qcout"), os.path.join(scr_dir, "freq_seg_too_small.qcout")) h = QChemErrorHandler(input_file="freq_seg_too_small_31_segments.qcinp", output_file="freq_seg_too_small.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual(d, {'errors': ['Exit Code 134', 'Freq Job Too Small'], 'actions': None})
def test_exit_code_134_after_scf_fix(self): shutil.copyfile(os.path.join(test_dir, "exit_134_after_scf_fix.qcinp"), os.path.join(scr_dir, "exit_134_after_scf_fix.qcinp")) shutil.copyfile(os.path.join(test_dir, "exit_134_after_scf_fix.qcout"), os.path.join(scr_dir, "exit_134_after_scf_fix.qcout")) h = QChemErrorHandler(input_file="exit_134_after_scf_fix.qcinp", output_file="exit_134_after_scf_fix.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual( d, { 'errors': [ 'Bad SCF convergence', 'Exit Code 134', 'Geometry optimization failed', 'Molecular charge is not found' ], 'actions': ['use tight integral threshold'] }) with open( os.path.join( test_dir, "exit_134_after_scf_fix_tight_thresh.qcinp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "exit_134_after_scf_fix.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans) shutil.copyfile( os.path.join(test_dir, "exit_134_after_scf_fix_tight_thresh.qcinp"), os.path.join(scr_dir, "exit_134_after_scf_fix_tight_thresh.qcinp")) shutil.copyfile(os.path.join(test_dir, "exit_134_after_scf_fix.qcout"), os.path.join(scr_dir, "exit_134_after_scf_fix.qcout")) qchem_job = QchemJob( qchem_cmd=shlex.split("qchem -np 24"), input_file="exit_134_after_scf_fix_tight_thresh.qcinp", output_file="exit_134_after_scf_fix.qcout", alt_cmd={ "half_cpus": shlex.split("qchem -np 12"), "openmp": shlex.split("qchem -nt 24") }) h = QChemErrorHandler( input_file="exit_134_after_scf_fix_tight_thresh.qcinp", output_file="exit_134_after_scf_fix.qcout", qchem_job=qchem_job) has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual( d, { 'errors': [ 'Bad SCF convergence', 'Exit Code 134', 'Geometry optimization failed', 'Molecular charge is not found' ], 'actions': ['openmp'] })
def test_nan_error(self): shutil.copyfile(os.path.join(test_dir, "thiane_nan.inp"), os.path.join(scr_dir, "thiane_nan.inp")) shutil.copyfile(os.path.join(test_dir, "thiane_nan.out"), os.path.join(scr_dir, "thiane_nan.out")) h = QChemErrorHandler(input_file="thiane_nan.inp", output_file="thiane_nan.out") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual(d, { 'errors': ['NAN values'], 'actions': ['use tighter grid'] }) with open(os.path.join(test_dir, "thiane_nan_dense_grid.inp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "thiane_nan.inp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans) shutil.copyfile(os.path.join(test_dir, "thiane_nan_dense_grid.inp"), os.path.join(scr_dir, "thiane_nan_dense_grid.inp")) shutil.copyfile(os.path.join(test_dir, "thiane_nan.out"), os.path.join(scr_dir, "thiane_nan.out")) h = QChemErrorHandler(input_file="thiane_nan_dense_grid.inp", output_file="thiane_nan.out") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual(d, {'errors': ['NAN values'], 'actions': None}) shutil.copyfile(os.path.join(test_dir, "h2o_nan.qcinp"), os.path.join(scr_dir, "h2o_nan.qcinp")) shutil.copyfile(os.path.join(test_dir, "h2o_nan.qcout"), os.path.join(scr_dir, "h2o_nan.qcout")) h = QChemErrorHandler(input_file="h2o_nan.qcinp", output_file="h2o_nan.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual(d, { 'errors': ['NAN values'], 'actions': ['use tighter grid'] }) with open(os.path.join(test_dir, "h2o_nan_dense_grid.qcinp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "h2o_nan.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans)
def test_advanced_out_of_opt_cycles(self): shutil.copyfile( os.path.join(test_dir, "2564_complete/error1/mol.qin"), os.path.join(scr_dir, "mol.qin"), ) shutil.copyfile( os.path.join(test_dir, "2564_complete/error1/mol.qout"), os.path.join(scr_dir, "mol.qout"), ) shutil.copyfile( os.path.join(test_dir, "2564_complete/mol.qin.opt_0"), os.path.join(scr_dir, "mol.qin.opt_0"), ) h = QChemErrorHandler(input_file="mol.qin", output_file="mol.qout") h.check() d = h.correct() self.assertEqual(d["errors"], ["out_of_opt_cycles"]) self.assertEqual(d["actions"], [{ "molecule": "molecule_from_last_geometry" }]) self._check_equivalent_inputs("mol.qin.opt_0", "mol.qin") self.assertEqual(h.opt_error_history[0], "more_bonds") shutil.copyfile( os.path.join(test_dir, "2564_complete/mol.qin.opt_0"), os.path.join(scr_dir, "mol.qin"), ) shutil.copyfile( os.path.join(test_dir, "2564_complete/mol.qout.opt_0"), os.path.join(scr_dir, "mol.qout"), ) h.check() self.assertEqual(h.opt_error_history, [])
def test_out_of_opt_cycles(self): shutil.copyfile( os.path.join(test_dir, "crowd_gradient.qin.2"), os.path.join(scr_dir, "crowd_gradient.qin.2"), ) shutil.copyfile( os.path.join(test_dir, "crowd_gradient.qout.2"), os.path.join(scr_dir, "crowd_gradient.qout.2"), ) shutil.copyfile( os.path.join(test_dir, "crowd_gradient.qin.3"), os.path.join(scr_dir, "crowd_gradient.qin.3"), ) h = QChemErrorHandler(input_file="crowd_gradient.qin.2", output_file="crowd_gradient.qout.2") h.check() d = h.correct() self.assertEqual(d["errors"], ["out_of_opt_cycles"]) self.assertEqual( d["actions"], [{ "geom_max_cycles:": 200 }, { "molecule": "molecule_from_last_geometry" }], ) self._check_equivalent_inputs("crowd_gradient.qin.2", "crowd_gradient.qin.3")
def test_unable_to_determine_lamda(self): for ii in range(2): shutil.copyfile( os.path.join(test_dir, "unable_to_determine_lamda.qin." + str(ii)), os.path.join(scr_dir, "unable_to_determine_lamda.qin." + str(ii)), ) shutil.copyfile( os.path.join(test_dir, "unable_to_determine_lamda.qout." + str(ii)), os.path.join(scr_dir, "unable_to_determine_lamda.qout." + str(ii)), ) h = QChemErrorHandler( input_file="unable_to_determine_lamda.qin.0", output_file="unable_to_determine_lamda.qout.0", ) h.check() d = h.correct() self.assertEqual(d["errors"], ["unable_to_determine_lamda"]) self.assertEqual(d["actions"], [{ "molecule": "molecule_from_last_geometry" }]) self._check_equivalent_inputs("unable_to_determine_lamda.qin.0", "unable_to_determine_lamda.qin.1")
def test_unable_to_determine_lambda(self): shutil.copyfile( os.path.join(test_dir, "unable_to_determine_lambda_in_geom_opt.qcinp"), os.path.join(scr_dir, "unable_to_determine_lambda_in_geom_opt.qcinp")) shutil.copyfile( os.path.join(test_dir, "unable_to_determine_lambda_in_geom_opt.qcout"), os.path.join(scr_dir, "unable_to_determine_lambda_in_geom_opt.qcout")) h = QChemErrorHandler( input_file="unable_to_determine_lambda_in_geom_opt.qcinp", output_file="unable_to_determine_lambda_in_geom_opt.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual( d, { 'errors': ['Geometry optimization failed', 'Lamda Determination Failed'], 'actions': ['reset'] }) with open( os.path.join( test_dir, "unable_to_determine_lambda_in_geom_opt_reset.qcinp") ) as f: ref = [line.strip() for line in f.readlines()] with open( os.path.join( scr_dir, "unable_to_determine_lambda_in_geom_opt.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans)
def test_advanced_out_of_opt_cycles1(self): shutil.copyfile(os.path.join(test_dir, "2620_complete/mol.qin.opt_0"), os.path.join(scr_dir, "mol.qin")) shutil.copyfile(os.path.join(test_dir, "2620_complete/mol.qout.opt_0"), os.path.join(scr_dir, "mol.qout")) h = QChemErrorHandler(input_file="mol.qin", output_file="mol.qout") self.assertEqual(h.check(), False)
def test_RunQChemCustodian_basic_defaults(self): with patch("atomate.qchem.firetasks.run_calc.Custodian" ) as custodian_patch: firetask = RunQChemCustodian( qchem_cmd="qchem", input_file=os.path.join(module_dir, "..", "..", "test_files", "co_qc.in"), max_cores=32) firetask.run_task(fw_spec={}) custodian_patch.assert_called_once() self.assertEqual(custodian_patch.call_args[0][0][0].as_dict(), QChemErrorHandler( input_file=os.path.join( module_dir, "..", "..", "test_files", "co_qc.in"), output_file="mol.qout").as_dict()) self.assertEqual(custodian_patch.call_args[0][1][0].as_dict(), QCJob( qchem_command="qchem", max_cores=32, multimode="openmp", input_file=os.path.join( module_dir, "..", "..", "test_files", "co_qc.in"), output_file="mol.qout").as_dict()) self.assertEqual(custodian_patch.call_args[1], { "max_errors": 5, "gzipped_output": True })
def test_RunQChemCustodian_using_fw_spec_defaults(self): with patch("atomate.qchem.firetasks.run_calc.Custodian" ) as custodian_patch: firetask = RunQChemCustodian(qchem_cmd=">>qchem_cmd<<", scratch_dir=">>scratch_dir<<", input_file=os.path.join( module_dir, "..", "..", "test_files", "co_qc.in")) firetask.run_task( fw_spec={ "_fw_env": { "qchem_cmd": "qchem -slurm", "scratch_dir": "/this/is/a/test" } }) custodian_patch.assert_called_once() self.assertEqual( custodian_patch.call_args[0][0][0].as_dict(), QChemErrorHandler(input_file=os.path.join( module_dir, "..", "..", "test_files", "co_qc.in"), output_file="mol.qout").as_dict()) self.assertEqual( custodian_patch.call_args[0][1][0].as_dict(), QCJob(qchem_command="qchem -slurm", multimode="openmp", input_file=os.path.join(module_dir, "..", "..", "test_files", "co_qc.in"), output_file="mol.qout", scratch_dir="/this/is/a/test").as_dict()) self.assertEqual(custodian_patch.call_args[1], { "max_errors": 5, "gzipped_output": True })
def test_OOS_read_hess(self): shutil.copyfile( os.path.join(test_dir, "OOS_read_hess.qin"), os.path.join(scr_dir, "mol.qin"), ) shutil.copyfile( os.path.join(test_dir, "OOS_read_hess.qout"), os.path.join(scr_dir, "mol.qout"), ) h = QChemErrorHandler(input_file="mol.qin", output_file="mol.qout") h.check() d = h.correct() self.assertEqual(d["errors"], ["out_of_opt_cycles"]) self.assertEqual( d["actions"], [ { "molecule": "molecule_from_last_geometry" }, { "geom_opt_hessian": "deleted" }, ], ) self._check_equivalent_inputs( os.path.join(test_dir, "OOS_read_hess_next.qin"), "mol.qin")
def test_pcm_solvent_deprecated(self): shutil.copyfile(os.path.join(test_dir, "pcm_solvent_deprecated.qcinp"), os.path.join(scr_dir, "pcm_solvent_deprecated.qcinp")) shutil.copyfile(os.path.join(test_dir, "pcm_solvent_deprecated.qcout"), os.path.join(scr_dir, "pcm_solvent_deprecated.qcout")) h = QChemErrorHandler(input_file="pcm_solvent_deprecated.qcinp", output_file="pcm_solvent_deprecated.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual( d, { 'errors': [ 'Bad SCF convergence', 'Molecular charge is not found', 'No input text', 'pcm_solvent deprecated' ], 'actions': ['use keyword solvent instead'] }) with open( os.path.join( test_dir, "pcm_solvent_deprecated_use_qc42_format.qcinp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "pcm_solvent_deprecated.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans)
def test_RunQChemCustodian_FF_basic_defaults(self): with patch("atomate.qchem.firetasks.run_calc.Custodian" ) as custodian_patch: with patch( "atomate.qchem.firetasks.run_calc.QCJob.opt_with_frequency_flattener" ) as FF_patch: firetask = RunQChemCustodian( qchem_cmd="qchem", max_cores=32, input_file=os.path.join(module_dir, "..", "..", "test_files", "FF_before_run", "test.qin"), output_file=os.path.join(module_dir, "..", "..", "test_files", "FF_before_run", "test.qout"), job_type="opt_with_frequency_flattener", ) firetask.run_task(fw_spec={}) custodian_patch.assert_called_once() self.assertEqual( custodian_patch.call_args[0][0][0].as_dict(), QChemErrorHandler( input_file=os.path.join(module_dir, "..", "..", "test_files", "FF_before_run", "test.qin"), output_file=os.path.join(module_dir, "..", "..", "test_files", "FF_before_run", "test.qout")).as_dict()) self.assertEqual(custodian_patch.call_args[1], { "max_errors": 5, "gzipped_output": True }) self.assertEqual( FF_patch.call_args[1], { "qchem_command": "qchem", "multimode": "openmp", "input_file": os.path.join(module_dir, "..", "..", "test_files", "FF_before_run", "test.qin"), "output_file": os.path.join(module_dir, "..", "..", "test_files", "FF_before_run", "test.qout"), "qclog_file": "mol.qclog", "max_iterations": 10, "max_molecule_perturb_scale": 0.3, "scratch_dir": "/dev/shm/qcscratch/", "save_scratch": False, "save_name": "default_save_name", "max_cores": 32 })
def run_qchem(cls, qcinp, implicit_solvent, mixed_aux_basis, mixed_basis, input_file="mol.qcinp", output_file="mol.qcout", gzipped=True, run_name=None): mol = qcinp.jobs[0].mol num_atoms = len(mol) for qj in qcinp.jobs: if qj.params["rem"]["jobtype"] != "sp": if mixed_basis is not None: qj.set_basis_set(mixed_basis) if mixed_aux_basis is not None: qj.set_aux_basis_set(mixed_aux_basis) prev_qchem_dir = os.getcwd() qc_exe, half_cpus_cmd, openmp_cmd = cls.get_qchem_cmd(qcinp, mol) logging.basicConfig(level=logging.INFO) qchem_logger = logging.getLogger('QChemDrone') qchem_logger.setLevel(logging.INFO) sh = logging.StreamHandler(stream=sys.stdout) sh.setLevel(getattr(logging, 'INFO')) qchem_logger.addHandler(sh) scf_max_cycles = 200 geom_max_cycles = 200 alt_cmd = {"half_cpus": half_cpus_cmd, "openmp": openmp_cmd} if cls._is_openmp_only_job(qcinp): qc_exe = openmp_cmd alt_cmd["half_cpus"] = shlex.split(" ".join(half_cpus_cmd).replace("-np", "-nt")) alt_cmd.pop("openmp") elif cls._is_openmp_compatible_job(qcinp): qc_exe = openmp_cmd alt_cmd.pop("openmp") else: alt_cmd.pop("openmp") if num_atoms > 50: scf_max_cycles = 300 geom_max_cycles = 500 qcinp.write_file(input_file) if implicit_solvent is not None: solvent_data = implicit_solvent.get('solvent_data', None) if solvent_data is not None: values = ['{:.4f}'.format(solvent_data[t]) for t in ['Dielec', 'SolN', 'SolA', 'SolB', 'SolG', 'SolC', 'SolH']] solvent_text = ' '.join(values) with open('solvent_data', 'w') as f: f.write(solvent_text) qclog_file = os.path.splitext(output_file)[0] + ".qclog" total_physical_memory = cls.get_physical_memory() job = QchemJob(qc_exe, input_file=input_file, output_file=output_file, qclog_file=qclog_file, alt_cmd=alt_cmd, gzipped=gzipped, total_physical_memory=total_physical_memory, run_name=run_name) handler = QChemErrorHandler(qchem_job=job, input_file=input_file, output_file=output_file, scf_max_cycles=scf_max_cycles, geom_max_cycles=geom_max_cycles) c = Custodian(handlers=[handler], jobs=[job], max_errors=50) custodian_out = c.run() cls.clean_up(qcinp) return custodian_out, prev_qchem_dir
def test_not_enough_total_memory(self): shutil.copyfile(os.path.join(test_dir, "not_enough_total_memory.qcinp"), os.path.join(scr_dir, "not_enough_total_memory.qcinp")) shutil.copyfile(os.path.join(test_dir, "not_enough_total_memory.qcout"), os.path.join(scr_dir, "not_enough_total_memory.qcout")) qchem_job = QchemJob(qchem_cmd=shlex.split("qchem -np 24"), input_file="not_enough_total_memory.qcinp", output_file="not_enough_total_memory.qcout", alt_cmd={"half_cpus": shlex.split("qchem -np 12"), "openmp": shlex.split("qchem -nt 24")}, total_physical_memory=120) h = QChemErrorHandler(input_file="not_enough_total_memory.qcinp", output_file="not_enough_total_memory.qcout", qchem_job=qchem_job) has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual(d, {'errors': ['Exit Code 134', 'Not Enough Total Memory'], 'actions': ['Use 48 CPSCF segments']}) with open(os.path.join(test_dir, "not_enough_total_memory_48_segments.qcinp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "not_enough_total_memory.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans) shutil.copyfile(os.path.join(test_dir, "not_enough_total_memory_48_segments.qcinp"), os.path.join(scr_dir, "not_enough_total_memory_48_segments.qcinp")) shutil.copyfile(os.path.join(test_dir, "not_enough_total_memory.qcout"), os.path.join(scr_dir, "not_enough_total_memory.qcout")) qchem_job = QchemJob(qchem_cmd=["qchem", "-np", "24"], alt_cmd={"openmp": ["qchem", "-seq", "-nt", "24"], "half_cpus": ["qchem", "-np", "12"]}, input_file="not_enough_total_memory_48_segments.qcinp") h = QChemErrorHandler(input_file="not_enough_total_memory_48_segments.qcinp", output_file="not_enough_total_memory.qcout", qchem_job=qchem_job) has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual(d, {'errors': ['Exit Code 134', 'Not Enough Total Memory'], 'actions': ['Use half CPUs and 60 CPSCF segments']}) with open(os.path.join(test_dir, "not_enough_total_memory_60_segments.qcinp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "not_enough_total_memory_48_segments.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans)
def test_negative_eigen(self): shutil.copyfile(os.path.join(test_dir, "negative_eigen.qcinp"), os.path.join(scr_dir, "negative_eigen.qcinp")) shutil.copyfile(os.path.join(test_dir, "negative_eigen.qcout"), os.path.join(scr_dir, "negative_eigen.qcout")) h = QChemErrorHandler(input_file="negative_eigen.qcinp", output_file="negative_eigen.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual( d, { 'errors': [ 'Bad SCF convergence', 'Molecular charge is not found', 'Negative Eigen' ], 'actions': ['use tight integral threshold'] }) with open(os.path.join(test_dir, "negative_eigen_tried_1.qcinp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "negative_eigen.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans) shutil.copyfile(os.path.join(test_dir, "negative_eigen_tried_1.qcinp"), os.path.join(scr_dir, "negative_eigen_tried_1.qcinp")) shutil.copyfile(os.path.join(test_dir, "negative_eigen.qcout"), os.path.join(scr_dir, "negative_eigen.qcout")) h = QChemErrorHandler(input_file="negative_eigen_tried_1.qcinp", output_file="negative_eigen.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual( d, { 'errors': [ 'Bad SCF convergence', 'Molecular charge is not found', 'Negative Eigen' ], 'actions': ['use even tighter integral threshold'] }) with open(os.path.join(test_dir, "negative_eigen_tried_2.qcinp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "negative_eigen_tried_1.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans)
def test_no_error(self): shutil.copyfile(os.path.join(test_dir, "hf_no_error.inp"), os.path.join(scr_dir, "hf_no_error.inp")) shutil.copyfile(os.path.join(test_dir, "hf_no_error.out"), os.path.join(scr_dir, "hf_no_error.out")) h = QChemErrorHandler(input_file="hf_no_error.inp", output_file="hf_no_error.out") has_error = h.check() self.assertFalse(has_error)
def test_json_serializable(self): q1 = QChemErrorHandler() str1 = json.dumps(q1, cls=MontyEncoder) q2 = json.loads(str1, cls=MontyDecoder) self.assertEqual(q1.as_dict(), q2.as_dict()) shutil.copyfile(os.path.join(test_dir, "qunino_vinyl.qcinp"), os.path.join(scr_dir, "qunino_vinyl.qcinp")) shutil.copyfile(os.path.join(test_dir, "qunino_vinyl.qcout"), os.path.join(scr_dir, "qunino_vinyl.qcout")) q3 = QChemErrorHandler(input_file="qunino_vinyl.qcinp", output_file="qunino_vinyl.qcout") q3.check() q3.correct() for od in q3.outdata: od.pop("input") str3 = json.dumps(q3, cls=MontyEncoder) q4 = json.loads(str3, cls=MontyDecoder) self.assertEqual(q3.as_dict(), q4.as_dict())
def run_QChem(label, encode=None, rem=None, pcm=None, solvent=None, more_info=None, self_correct=True): inname = label + '.inp' outname = label + '.out' logname = label + '.log' command = 'qchem' handlers = [QChemErrorHandler(input_file=inname, output_file=outname)] """If no encoding provided, assume this is the first Firework in workflow and that input file is already written. 'label' is the name of the file without the extension (e.g. .inp, .out). otherwise, take encoding, form new QCInput and write input file, then run. """ if encode != None: qcin = encode_to_QCInput(encode=encode, rem=rem, pcm=pcm, solvent=solvent) qcin.write_file(inname) if self_correct: jobs = [ QCJob(input_file=inname, output_file=outname, qchem_command=command, max_cores=multiprocessing.cpu_count(), qclog_file=logname) ] c = Custodian(handlers, jobs, max_errors=10) c.run() else: job = QCJob(input_file=inname, output_file=outname, qchem_command=command, max_cores=multiprocessing.cpu_count(), qclog_file=logname) job.setup() p = job.run() p.wait() """ qclog = open(logname, "w") current_command = ['qchem', '-nt', '20',inname] print(current_command) subprocess.run(current_command, stdout=qclog, shell=True) """ try: output = [QCOutput(filename=outname)] except: output = QCOutput.multiple_outputs_from_file(QCOutput, filename) return QCOutput_to_encode(output, more_info=more_info)
def test_input_file_error(self): shutil.copyfile(os.path.join(test_dir, "bad_input.qin"), os.path.join(scr_dir, "bad_input.qin")) shutil.copyfile(os.path.join(test_dir, "bad_input.qout"), os.path.join(scr_dir, "bad_input.qout")) h = QChemErrorHandler(input_file="bad_input.qin", output_file="bad_input.qout") h.check() d = h.correct() self.assertEqual(d["errors"], ['input_file_error']) self.assertEqual(d["actions"], None)
def test_never_called_qchem_error(self): shutil.copyfile(os.path.join(test_dir, "mpi_error/mol.qin"), os.path.join(scr_dir, "mol.qin")) shutil.copyfile(os.path.join(test_dir, "mpi_error/mol.qout"), os.path.join(scr_dir, "mol.qout")) h = QChemErrorHandler(input_file="mol.qin", output_file="mol.qout") h.check() d = h.correct() self.assertEqual(d["errors"], ['never_called_qchem']) self.assertEqual(d["actions"], [{"rerun job as-is"}]) self._check_equivalent_inputs("mol.qin.last", "mol.qin")
def test_failed_to_read_input(self): shutil.copyfile(os.path.join(test_dir, "unable_lamda_weird.qin"), os.path.join(scr_dir, "unable_lamda_weird.qin")) shutil.copyfile(os.path.join(test_dir, "unable_lamda_weird.qout"), os.path.join(scr_dir, "unable_lamda_weird.qout")) h = QChemErrorHandler(input_file="unable_lamda_weird.qin", output_file="unable_lamda_weird.qout") h.check() d = h.correct() self.assertEqual(d["errors"], ['failed_to_read_input']) self.assertEqual(d["actions"], [{"rerun job as-is"}]) self._check_equivalent_inputs("unable_lamda_weird.qin.last", "unable_lamda_weird.qin")
def test_read_error(self): shutil.copyfile( os.path.join(test_dir, "molecule_read_error/mol.qin"), os.path.join(scr_dir, "mol.qin"), ) shutil.copyfile( os.path.join(test_dir, "molecule_read_error/mol.qout"), os.path.join(scr_dir, "mol.qout"), ) h = QChemErrorHandler(input_file="mol.qin", output_file="mol.qout") h.check() d = h.correct() self.assertEqual(d["errors"], ["read_molecule_error"]) self.assertEqual(d["actions"], [{"rerun_job_no_changes": True}]) self._check_equivalent_inputs("mol.qin.last", "mol.qin")
def test_basis_not_supported(self): shutil.copyfile( os.path.join(test_dir, "basis_not_supported.qin"), os.path.join(scr_dir, "basis_not_supported.qin"), ) shutil.copyfile( os.path.join(test_dir, "basis_not_supported.qout"), os.path.join(scr_dir, "basis_not_supported.qout"), ) h = QChemErrorHandler(input_file="basis_not_supported.qin", output_file="basis_not_supported.qout") h.check() d = h.correct() self.assertEqual(d["errors"], ["basis_not_supported"]) self.assertEqual(d["actions"], None)
def test_NLebdevPts(self): shutil.copyfile( os.path.join(test_dir, "lebdevpts.qin"), os.path.join(scr_dir, "lebdevpts.qin"), ) shutil.copyfile( os.path.join(test_dir, "lebdevpts.qout"), os.path.join(scr_dir, "lebdevpts.qout"), ) h = QChemErrorHandler(input_file="lebdevpts.qin", output_file="lebdevpts.qout") h.check() d = h.correct() self.assertEqual(d["errors"], ["NLebdevPts"]) self.assertEqual(d["actions"], [{"esp_surface_density": "250"}])
def test_scf_in_aimd_reset(self): shutil.copyfile(os.path.join(test_dir, "h2o_aimd.qcinp"), os.path.join(scr_dir, "h2o_aimd.qcinp")) shutil.copyfile(os.path.join(test_dir, "h2o_aimd.qcout"), os.path.join(scr_dir, "h2o_aimd.qcout")) h = QChemErrorHandler(input_file="h2o_aimd.qcinp", output_file="h2o_aimd.qcout") has_error = h.check() self.assertTrue(has_error) d = h.correct() self.assertEqual(d, {'errors': ['Bad SCF convergence'], 'actions': ['reset']}) with open(os.path.join(test_dir, "h2o_aimd_reset.qcinp")) as f: ref = [line.strip() for line in f.readlines()] with open(os.path.join(scr_dir, "h2o_aimd.qcinp")) as f: ans = [line.strip() for line in f.readlines()] self.assertEqual(ref, ans)