def run_json(json_data, clean=True): warnings.warn( "Using `psi4.schema_wrapper.run_json` or `psi4.json_wrapper.run_json` instead of `psi4.schema_wrapper.run_qcschema` is deprecated, and in 1.7 it will stop working\n", category=FutureWarning) # Set scratch if "scratch_location" in json_data: psi4_io = core.IOManager.shared_object() psi4_io.set_default_path(json_data["scratch_location"]) # Direct output outfile = os.path.join(core.IOManager.shared_object().get_default_path(), str(uuid.uuid4()) + ".json_out") core.set_output_file(outfile, False) # Set memory if "memory" in json_data: p4util.set_memory(json_data["memory"]) # Do we return the output? return_output = json_data.pop("return_output", False) if return_output: json_data["raw_output"] = "Not yet run." # Set a few flags json_data["raw_output"] = None json_data["success"] = False json_data["provenance"] = { "creator": "Psi4", "version": __version__, "routine": "psi4.json_wrapper.run_json" } # Attempt to run the computer try: # qcschema should be copied json_data = run_json_qcschema(copy.deepcopy(json_data), clean, True) except Exception as exc: json_data["error"] = { 'error_type': type(exc).__name__, 'error_message': ''.join(traceback.format_exception(*sys.exc_info())), } json_data["success"] = False json_data["raw_output"] = _read_output(outfile) if return_output: json_data["raw_output"] = _read_output(outfile) atexit.register(_quiet_remove, outfile) return json_data
def run_json(json_data, clean=True): # Set scratch if "scratch_location" in json_data: psi4_io = core.IOManager.shared_object() psi4_io.set_default_path(json_data["scratch_location"]) # Direct output outfile = os.path.join(core.IOManager.shared_object().get_default_path(), str(uuid.uuid4()) + ".json_out") core.set_output_file(outfile, False) # Set memory if "memory" in json_data: psi4.set_memory(json_data["memory"]) # Do we return the output? return_output = json_data.pop("return_output", False) if return_output: json_data["raw_output"] = "Not yet run." # Set a few flags json_data["raw_output"] = None json_data["success"] = False # Attempt to run the computer try: # qcschema should be copied json_data = run_json_qcschema(copy.deepcopy(json_data), clean) except Exception as exc: json_data["error"] = { 'error_type': type(exc).__name__, 'error_message': ''.join(traceback.format_exception(*sys.exc_info())), } json_data["success"] = False json_data["raw_output"] = _read_output(outfile) if return_output: json_data["raw_output"] = _read_output(outfile) # Destroy the created file at exit def _quiet_remove(filename): try: os.unlink(filename) except OSError: pass atexit.register(_quiet_remove, outfile) return json_data
def run_qcschema(input_data, clean=True): outfile = os.path.join(core.IOManager.shared_object().get_default_path(), str(uuid.uuid4()) + ".qcschema_tmpout") core.set_output_file(outfile, False) print_header() start_time = datetime.datetime.now() try: input_model = qcng.util.model_wrapper(input_data, qcel.models.AtomicInput) keep_wfn = input_model.protocols.wavefunction != 'none' # qcschema should be copied ret_data = run_json_qcschema(input_model.dict(), clean, False, keep_wfn=keep_wfn) ret_data["provenance"] = { "creator": "Psi4", "version": __version__, "routine": "psi4.schema_runner.run_qcschema" } exit_printing(start_time=start_time, success=True) ret = qcel.models.AtomicResult(**ret_data, stdout=_read_output(outfile)) except Exception as exc: if not isinstance(input_data, dict): input_data = input_data.dict() input_data = input_data.copy() input_data["stdout"] = _read_output(outfile) ret = qcel.models.FailedOperation( input_data=input_data, success=False, error={ 'error_type': type(exc).__name__, 'error_message': ''.join(traceback.format_exception(*sys.exc_info())), }) atexit.register(_quiet_remove, outfile) return ret
def run_json(json_data, clean=True): # Set scratch if "scratch_location" in json_data: psi4_io = core.IOManager.shared_object() psi4_io.set_default_path(json_data["scratch_location"]) # Direct output outfile = os.path.join(core.IOManager.shared_object().get_default_path(), str(uuid.uuid4()) + ".json_out") core.set_output_file(outfile, False) # Set memory if "memory" in json_data: psi4.set_memory(json_data["memory"]) # Do we return the output? return_output = json_data.pop("return_output", False) if return_output: json_data["raw_output"] = "Not yet run." # Set a few flags json_data["raw_output"] = None json_data["success"] = False # Attempt to run the computer try: if json_data.get("schema_name", "").startswith("qc_schema"): # qc_schema should be copied json_data = run_json_qc_schema(copy.deepcopy(json_data), clean) else: # Original run updates inplace run_json_original_v1_1(json_data, clean) except Exception as error: json_data["error"] = repr(error) json_data["success"] = False if return_output: with open(outfile, 'r') as f: json_data["raw_output"] = f.read() atexit.register(os.unlink, outfile) return json_data
def run_json(json_data, clean=True): # Set scratch if "scratch_location" in json_data: psi4_io = core.IOManager.shared_object() psi4_io.set_default_path(json_data["scratch_location"]) # Direct output outfile = os.path.join(core.IOManager.shared_object().get_default_path(), str(uuid.uuid4()) + ".json_out") core.set_output_file(outfile, False) # Set memory if "memory" in json_data: psi4.set_memory(json_data["memory"]) # Do we return the output? return_output = json_data.pop("return_output", False) if return_output: json_data["raw_output"] = "Not yet run." # Set a few flags json_data["raw_output"] = None json_data["success"] = False # Attempt to run the computer try: # qc_schema should be copied json_data = run_json_qc_schema(copy.deepcopy(json_data), clean) except Exception as error: exc_type, exc_value, exc_traceback = sys.exc_info() json_data["error"] = repr(traceback.format_exception(exc_type, exc_value, exc_traceback)) json_data["success"] = False with open(outfile, 'r') as f: json_data["raw_output"] = f.read() if return_output: with open(outfile, 'r') as f: json_data["raw_output"] = f.read() atexit.register(os.unlink, outfile) return json_data
def run_json(json_data, clean=True): # Set scratch if "scratch_location" in json_data: psi4_io = core.IOManager.shared_object() psi4_io.set_default_path(json_data["scratch_location"]) # Direct output outfile = os.path.join(core.IOManager.shared_object().get_default_path(), str(uuid.uuid4()) + ".json_out") core.set_output_file(outfile, False) # Set memory if "memory" in json_data: psi4.set_memory(json_data["memory"]) # Do we return the output? return_output = json_data.pop("return_output", False) if return_output: json_data["raw_output"] = "Not yet run." # Set a few flags json_data["raw_output"] = None json_data["success"] = False # Attempt to run the computer try: if json_data.get("schema_name", "").startswith("qc_schema"): # qc_schema should be copied json_data = run_json_qc_schema(copy.deepcopy(json_data), clean) else: # Original run updates inplace run_json_original_v1_1(json_data, clean) except Exception as error: json_data["error"] = repr(error) json_data["success"] = False if return_output: with open(outfile, 'r') as f: json_data["raw_output"] = f.read() os.unlink(outfile) return json_data
def run_json(json_data, clean=True): # Set scratch if "scratch_location" in json_data: psi4_io = core.IOManager.shared_object() psi4_io.set_default_path(json_data["scratch_location"]) # Set memory if "memory" in json_data: psi4.set_memory(json_data["memory"]) # Do we return the output? return_output = json_data.pop("return_output", False) if return_output: outfile = os.path.join( core.IOManager.shared_object().get_default_path(), str(uuid.uuid4()) + ".json_out") core.set_output_file(outfile, False) json_data["raw_output"] = "Not yet run." # Set a few flags json_data["raw_output"] = None json_data["success"] = False # Attempt to run the computer try: if ("schema_name" in json_data) and (json_data["schema_name"] == "QC_JSON"): run_json_qc_schema(json_data, clean) else: run_json_original_v1_1(json_data, clean) except Exception as error: json_data["error"] = repr(error) json_data["success"] = False if return_output: with open(outfile, 'r') as f: json_data["raw_output"] = f.read() os.unlink(outfile) return json_data
def run_qcschema( input_data: Union[Dict[str, Any], qcel.models.AtomicInput], clean: bool = True, postclean: bool = True ) -> Union[qcel.models.AtomicResult, qcel.models.FailedOperation]: """Run a quantum chemistry job specified by :py:class:`qcelemental.models.AtomicInput` **input_data** in |PSIfour|. Parameters ---------- input_data Quantum chemistry job in either AtomicInput class or dictionary form. clean Reset global QCVariables, options, and scratch files to default state. postclean When ``False``, *remove* the output file since absorbed into AtomicResult. When ``True``, simply *close* the output file. True is useful when calling from a Psi4 session to avoid removing the parent Psi4's output file. Returns ------- qcelemental.models.AtomicResult Full record of quantum chemistry calculation, including output text. Returned upon job success. qcelemental.models.FailedOperation Record to diagnose calculation failure, including output text and input specification. Returned upon job failure. """ outfile = os.path.join(core.IOManager.shared_object().get_default_path(), str(uuid.uuid4()) + ".qcschema_tmpout") core.set_output_file(outfile, False) print_header() start_time = datetime.datetime.now() try: input_model = qcng.util.model_wrapper(input_data, qcel.models.AtomicInput) # Echo the infile on the outfile core.print_out("\n ==> Input QCSchema <==\n") core.print_out( "\n--------------------------------------------------------------------------\n" ) core.print_out(pp.pformat(json.loads(input_model.json()))) core.print_out( "\n--------------------------------------------------------------------------\n" ) keep_wfn = input_model.protocols.wavefunction != 'none' # qcschema should be copied ret_data = run_json_qcschema(input_model.dict(), clean, False, keep_wfn=keep_wfn) ret_data["provenance"].update({ "creator": "Psi4", "version": __version__, "routine": "psi4.schema_runner.run_qcschema" }) ret_data["native_files"]["input"] = json.dumps(json.loads( input_model.json()), indent=1) exit_printing(start_time=start_time, success=True) ret = qcel.models.AtomicResult(**ret_data, stdout=_read_output(outfile)) except Exception as exc: if not isinstance(input_data, dict): input_data = input_data.dict() input_data = input_data.copy() input_data["stdout"] = _read_output(outfile) ret = qcel.models.FailedOperation( input_data=input_data, success=False, error={ 'error_type': type(exc).__name__, 'error_message': ''.join(traceback.format_exception(*sys.exc_info())), }) _clean_psi_output(postclean, outfile) return ret
def run_json(json_data): """ Runs and updates the input JSON data. Parameters ---------- json_data : JSON input Required input fields: - molecule : str A string representation of the molecule. Any valid psi4 synatx is valid. - driver : str The driver method to use valid arguments are "energy", "gradient", "property" - args : str Input arguments to the driver function - kwargs : dict Input dictionary to the driver function Optional input fields: - kwargs : dict Additional kwargs to be passed to the driver. - options : dict Global options to set in the Psi4 run. - scratch_location : str Overide the default scratch location. - return_output : bool Return the full string reprsentation of the output or not. Output fields: - return_value : float, psi4.core.Vector, psi4.core.Matrix The return value of the input function. - variables : dict The list of Psi4 variables generated from the run. - success : bool Indicates if the run was successful or not. - error : str If an error is raised the result is returned here. - raw_output : str The full Psi4 output if requested. Notes ----- !Warning! This function is experimental and likely to change in the future. Please report any suggestions or uses of this function on github.com/psi4/psi4. Examples -------- # CP corrected Helium dimer energy in the STO-3G basis. >>> json_data = {} >>> json_data["molecule"] = "He 0 0 0\n--\nHe 0 0 1" >>> json_data["driver"] = "energy" >>> json_data["method"] = 'SCF' >>> json_data["kwargs"] = {"bsse_type": "cp"} >>> json_data["options"] = {"BASIS": "STO-3G"} >>> run_json(json_data) { "raw_output": "Output storing was not requested.", "options": { "BASIS": "STO-3G" }, "driver": "energy", "molecule": "He 0 0 0\n--\nHe 0 0 1", "method": "SCF", "variables": { "SCF N ITERS": 2.0, "SCF DIPOLE Y": 0.0, "CURRENT DIPOLE Y": 0.0, "CP-CORRECTED 2-BODY INTERACTION ENERGY": 0.1839360538612116, "HF TOTAL ENERGY": -5.433191881443323, "SCF TOTAL ENERGY": -5.433191881443323, "TWO-ELECTRON ENERGY": 4.124089347186247, "SCF ITERATION ENERGY": -5.433191881443323, "CURRENT DIPOLE X": 0.0, "CURRENT DIPOLE Z": 0.0, "CURRENT REFERENCE ENERGY": -5.433191881443323, "CURRENT ENERGY": 0.1839360538612116, "COUNTERPOISE CORRECTED TOTAL ENERGY": -5.433191881443323, "SCF DIPOLE Z": 0.0, "COUNTERPOISE CORRECTED INTERACTION ENERGY": 0.1839360538612116, "NUCLEAR REPULSION ENERGY": 2.11670883436, "SCF DIPOLE X": 0.0, "ONE-ELECTRON ENERGY": -11.67399006298957 }, "return_value": 0.1839360538612116, "error": "", "success": true, "provenance": { "creator": "Psi4", "routine": "psi4.run_json", "version": "1.1a1" }, "kwargs": { "bsse_type": "cp" } } """ # Set a few variables json_data["error"] = "" json_data["raw_output"] = "Output storing was not requested." json_data["success"] = False json_data["raw_output"] = None # Check input for check in ["driver", "method", "molecule"]: if check not in list(json_data): json_data["error"] = "Minimum input requires the %s field." % check return json_data # Check driver call if json_data["driver"] not in list(methods_dict): json_data["error"] = "Driver parameters '%s' not recognized" % str(json_data["driver"]) return json_data # Set scratch if "scratch_location" in list(json_data): psi4_io = core.IOManager.shared_object() psi4_io.set_default_path(json_data["scratch_location"]) # Set memory if "memory" in list(json_data): psi4.core.set_memory(int(json_data["memory"])) # Do we return the output? return_output = json_data.pop("return_output", False) if return_output: outfile = str(uuid.uuid4()) + ".json_out" core.set_output_file(outfile, False) json_data["raw_output"] = "Not yet run." try: # Set options if "options" in json_data.keys() and (json_data["options"] is not None): for k, v in json_data["options"].items(): core.set_global_option(k, v) # Rework args args = json_data["method"] if not isinstance(args, (list, tuple)): args = [args] # Deep copy kwargs if "kwargs" in list(json_data): kwargs = copy.deepcopy(json_data["kwargs"]) else: kwargs = {} kwargs["molecule"] = molutil.geometry(json_data["molecule"]) # Full driver call kwargs["return_wfn"] = True val, wfn = methods_dict[json_data["driver"]](*args, **kwargs) if isinstance(val, (float)): json_data["return_value"] = val elif isinstance(val, (core.Matrix, core.Vector)): json_data["return_value"] = val.to_serial() else: json_data["error"] += "Unrecognized return value of type %s\n" % type(val) json_data["return_value"] = val json_data["variables"] = core.get_variables() json_data["success"] = True prov = {} prov["version"] = psi4.__version__ prov["routine"] = "psi4.run_json" prov["creator"] = "Psi4" json_data["provenance"] = prov except Exception as error: json_data["error"] += repr(error) json_data["success"] = False if return_output: with open(outfile, 'r') as f: json_data["raw_output"] = f.read() os.unlink(outfile) return json_data
def compute(self, client: Optional["FractalClient"] = None): """Run quantum chemistry.""" from psi4.driver import pp if self.computed: return if client: self.computed = True from qcportal.models import KeywordSet, Molecule # Build the keywords keyword_id = client.add_keywords( [KeywordSet(values=self.keywords)])[0] # Build the molecule mol = Molecule(**self.molecule.to_schema(dtype=2)) r = client.add_compute("psi4", self.method, self.basis, self.driver, keyword_id, [mol]) self.result_id = r.ids[0] # NOTE: The following will re-run errored jobs by default if self.result_id in r.existing: ret = client.query_tasks(base_result=self.result_id) if ret: if ret[0].status == "ERROR": client.modify_tasks("restart", base_result=self.result_id) logger.info("Resubmitting Errored Job {}".format( self.result_id)) elif ret[0].status == "COMPLETE": logger.debug("Job already completed {}".format( self.result_id)) else: logger.debug("Job already completed {}".format( self.result_id)) else: logger.debug("Submitting AtomicResult {}".format( self.result_id)) return logger.info( f'<<< JSON launch ... {self.molecule.schoenflies_symbol()} {self.molecule.nuclear_repulsion_energy()}' ) gof = core.get_output_file() # EITHER ... # from psi4.driver import schema_wrapper # self.result = schema_wrapper.run_qcschema(self.plan()) # ... OR ... self.result = qcng.compute( self.plan(), "psi4", raise_error=True, # local_options below suitable for serial mode where each job takes all the resources of the parent Psi4 job. # distributed runs through QCFractal will likely need a different setup. local_options={ # B -> GiB "memory": core.get_memory() / (2**30), "ncores": core.get_num_threads(), }, ) # ... END #pp.pprint(self.result.dict()) #print("... JSON returns >>>") core.set_output_file(gof, True) core.reopen_outfile() logger.debug(pp.pformat(self.result.dict())) core.print_out(_drink_filter(self.result.dict()["stdout"])) self.computed = True
def run_json(json_data): """ Runs and updates the input JSON data. Parameters ---------- json_data : JSON input Required input fields: - molecule : str A string representation of the molecule. Any valid psi4 synatx is valid. - driver : str The driver method to use valid arguments are "energy", "gradient", "property" - args : str Input arguments to the driver function - kwargs : dict Input dictionary to the driver function Optional input fields: - kwargs : dict Additional kwargs to be passed to the driver. - options : dict Global options to set in the Psi4 run. - scratch_location : str Overide the default scratch location. - return_output : bool Return the full string reprsentation of the output or not. Output fields: - return_value : float, psi4.core.Vector, psi4.core.Matrix The return value of the input function. - variables : dict The list of Psi4 variables generated from the run. - success : bool Indicates if the run was successful or not. - error : str If an error is raised the result is returned here. - output : str The full Psi4 output if requested. Notes ----- !Warning! This function is experimental and likely to change in the future. Please report any suggestions or uses of this function on github.com/psi4/psi4. Examples -------- # CP corrected Helium dimer energy in the STO-3G basis. >>> json_data = {} >>> json_data["molecule"] = "He 0 0 0\n--\nHe 0 0 1" >>> json_data["driver"] = "energy" >>> json_data["args"] = 'SCF' >>> json_data["kwargs"] = {"bsse_type": "cp"} >>> json_data["options"] = {"BASIS": "STO-3G"} >>> run_json(json_data) {'status': 'finished', 'success': True, 'kwargs': {'bsse_type': 'cp'}, 'molecule': 'He 0 0 0\n--\nHe 0 0 1', 'variables': {u'CURRENT REFERENCE ENERGY': -5.433191881443323, u'HF TOTAL ENERGY': -5.433191881443323, u'CURRENT DIPOLE Z': 0.0, u'COUNTERPOISE CORRECTED INTERACTION ENERGY': 0.1839360538612116, u'CURRENT DIPOLE X': 0.0, u'CURRENT DIPOLE Y': 0.0, u'NUCLEAR REPULSION ENERGY': 2.11670883436, u'TWO-ELECTRON ENERGY': 4.124089347186247, u'SCF ITERATION ENERGY': -5.433191881443323, u'CP-CORRECTED 2-BODY INTERACTION ENERGY': 0.1839360538612116, u'SCF DIPOLE Y': 0.0, u'COUNTERPOISE CORRECTED TOTAL ENERGY': -5.433191881443323, u'CURRENT ENERGY': 0.1839360538612116, u'SCF TOTAL ENERGY': -5.433191881443323, u'SCF DIPOLE Z': 0.0, u'ONE-ELECTRON ENERGY': -11.67399006298957, u'SCF DIPOLE X': 0.0}, 'args': 'SCF', 'driver': 'energy', 'return_value': 0.1839360538612116, 'error': '', 'output': '', 'options': {'BASIS': 'STO-3G'}} """ # Set a few variables json_data["error"] = "" json_data["output"] = "" # Check input for check in ["driver", "args", "molecule"]: if check not in list(json_data): json_data["error"] = "Minimum input requires the %s field." % check return False if json_data["driver"] not in list(methods_dict): json_data["error"] = "Driver parameters '%s' not recognized" % str( json_data["driver"]) return False if "scratch_location" in list(json_data): psi4_io = core.IOManager.shared_object() psi4_io.set_default_path(json_data["scratch_location"]) # Do we return the output? return_output = json_data.pop("return_output", False) if return_output: outfile = str(uuid.uuid4()) + ".json_out" core.set_output_file(outfile, False) json_data["output"] = "Not yet run." try: # Set options if "options" in json_data.keys() and (json_data["options"] is not None): for k, v in json_data["options"].items(): core.set_global_option(k, v) # Rework args args = json_data["args"] if not isinstance(args, (list, tuple)): args = [args] # Deep copy kwargs if "kwargs" in list(json_data): kwargs = copy.deepcopy(json_data["kwargs"]) kwargs["molecule"] = molutil.geometry(json_data["molecule"]) else: kwargs = {} # Full driver call kwargs["return_wfn"] = True val, wfn = methods_dict[json_data["driver"]](*args, **kwargs) if isinstance(val, (float)): json_data["return_value"] = val elif isinstance(val, (core.Matrix, core.Vector)): json_data["return_value"] = val.to_serial() else: json_data[ "error"] += "Unrecognized return value of type %s\n" % type( val) json_data["return_value"] = val json_data["variables"] = core.get_variables() json_data["success"] = True except Exception as error: json_data["error"] += repr(error) json_data["success"] = False if return_output: with open(outfile, 'r') as f: json_data["output"] = f.read() os.unlink(outfile) return json_data
def run_psi4(self): core.set_output_file(self.output + '.dat') import psi4 psi4.set_memory('1 GB') psi_molecule = psi4.geometry(self.psi_geom) psi4.set_options({ 'basis': self.basis, 'molden_write': False, 'WRITER_FILE_LABEL': str(self.output) + '.dat', 'maxiter': 500, 'fail_on_maxiter': False }) if self.multiplicity != 1: psi4.set_options({'reference': 'ROHF'}) e, wfn = psi4.energy('scf', return_wfn=True) self.molecule.hf_energy = e if os.path.exists('./scr.molden'): os.system('rm scr.molden') if self.active != None: cb = wfn.Cb().to_array() ca = wfn.Ca().to_array() self.molecule.n_orbitals = len(ca) ca[:, self.active + self.reorder] = ca[:, self.reorder + self.active] cb[:, self.active + self.reorder] = cb[:, self.reorder + self.active] if self.loc == 'True': acs = psi4.core.Matrix('null') acs = acs.from_array(ca[:, self.active]) Local = psi4.core.Localizer.build("BOYS", wfn.basisset(), acs) Local.localize() acs = Local.L ca[:, self.active] = acs acs2 = psi4.core.Matrix('null2') acs2 = acs2.from_array(cb[:, self.active]) Local = psi4.core.Localizer.build("BOYS", wfn.basisset(), acs2) Local.localize() acs2 = Local.L cb[:, self.active] = acs2 ca = psi4.core.Matrix.from_array(ca) cb = psi4.core.Matrix.from_array(cb) wfn.Cb().copy(cb) wfn.Ca().copy(ca) psi4.molden(wfn, 'scr.molden') psi4.set_options({'frozen_docc': [self.n_fdoccs]}) self.n_fnoccs = self.molecule.n_orbitals - self.n_fdoccs - len( self.active) psi4.set_options({'frozen_uocc': [self.n_fnoccs]}) self.CASCI = psi4.energy('fci', ref_wfn=wfn) self.molecule.CASCI = self.CASCI self.fci_energy = self.CASCI self.molecule.fci_energy = self.CASCI else: self.CASCI = psi4.energy('fci', ref_wfn=wfn) self.molecule.CASCI = self.CASCI self.fci_energy = self.CASCI self.molecule.fci_energy = self.CASCI self.molecule.n_orbitals = len(wfn.Ca().to_array()) psi4.molden(wfn, 'scr.molden') self.molecule.nuclear_repulsion = psi_molecule.nuclear_repulsion_energy( ) self.molecule.canonical_orbitals = np.asarray(wfn.Ca()) if self.active == None: self.active = [i for i in range(0, self.molecule.n_orbitals)] self.molecule.overlap_integrals = np.asarray(wfn.S()) self.molecule.n_qubits = 2 * self.molecule.n_orbitals self.molecule.orbital_energies = np.asarray(wfn.epsilon_a()) self.molecule.fock_matrix = np.asarray(wfn.Fa()) mints = psi4.core.MintsHelper(wfn.basisset()) self.molecule.one_body_integrals = general_basis_change( np.asarray(mints.ao_kinetic()), self.molecule.canonical_orbitals, (1, 0)) self.molecule.one_body_integrals += general_basis_change( np.asarray(mints.ao_potential()), self.molecule.canonical_orbitals, (1, 0)) two_body_integrals = np.asarray(mints.ao_eri()) two_body_integrals.reshape( (self.molecule.n_orbitals, self.molecule.n_orbitals, self.molecule.n_orbitals, self.molecule.n_orbitals)) two_body_integrals = np.einsum('psqr', two_body_integrals) two_body_integrals = general_basis_change( two_body_integrals, self.molecule.canonical_orbitals, (1, 1, 0, 0)) self.molecule.two_body_integrals = two_body_integrals doccs = [i for i in range(0, self.n_fdoccs)] if self.active != None: self.molecule.n_orbitals = len(self.active) self.molecule.n_qubits = 2 * self.molecule.n_orbitals else: self.molecule.n_orbitals = len(self.molecule.canonical_orbitals) self.molecule.n_qubits = 2 * self.molecule.n_orbitals self.molecule.n_fdoccs = self.n_fdoccs self.molecule.hamiltonian = self.molecule.get_molecular_hamiltonian( occupied_indices=doccs, active_indices=self.active) self.molecule.save() return self.molecule
def pre_processing(self): """ Process local run dictionary to create the input directory and identify the command to be passed Returns: :py:class:`dict`: dictionary containing the command to be passed to :meth:`process_run` """ from psi4 import set_options, energy, optimize, frequency from psi4.core import set_output_file from BigDFT.Systems import System from os.path import join # Check Arguments try: self.sys = self.run_options["sys"] except KeyError: raise ValueError("sys= must be provided as an argument") try: action = self.run_options["action"] except KeyError: raise ValueError("You must specify a valid action=(energy," " optimize, frequency") try: method = self.run_options["method"] except KeyError: raise ValueError("You must specify an ab initio method=") try: basis = self.run_options["basis"] except KeyError: raise ValueError("You must specify a basis=") # Run directory self._ensure_run_directory() # Check skip if self.run_options["skip"]: try: log = PSI4Logfile(self.sys, self._get_logname(True), action, method) return {"command": None} except ValueError: # invalid logfile, so we can't skip. pass except IOError: # no logfile, so we can't skip. pass # Convert system if "sapt" in method: keys = list(self.sys) if len(keys) != 2: raise ValueError("For SAPT method, your system must be" " composed of exactly two fragments.") sysA = System() sysA[keys[0]] = self.sys[keys[0]] sysB = System() sysB[keys[1]] = self.sys[keys[1]] mol = bigdft_to_psi4(sysA=sysA, sysB=sysB) else: mol = bigdft_to_psi4(sysA=self.sys) # Set extra options. if "psi4_options" in self.run_options: set_options(self.run_options["psi4_options"]) set_output_file(self._get_logname(True), False) # Instead of a command, we return a closure. if action == "energy": def cmd(method, mol): energy(method, molecule=mol) elif action == "optimize": def cmd(method, mol): optimize(method, molecule=mol) elif action == "frequency": def cmd(method, mol): frequency(method, molecule=mol) return {"command": cmd(join(method, basis), mol)}