def _populate_driver_result_basis_transform(
self, driver_result: ElectronicStructureDriverResult) -> None:
# pylint: disable=import-error
from pyscf.tools import dump_mat
mo_coeff, mo_coeff_b = self._extract_mo_data("mo_coeff",
array_dimension=3)
if logger.isEnabledFor(logging.DEBUG):
# Add some more to PySCF output...
# First analyze() which prints extra information about MO energy and occupation
self._mol.stdout.write("\n")
self._calc.analyze()
# Now labelled orbitals for contributions to the MOs for s,p,d etc of each atom
self._mol.stdout.write("\n\n--- Alpha Molecular Orbitals ---\n\n")
dump_mat.dump_mo(self._mol, mo_coeff, digits=7, start=1)
if mo_coeff_b is not None:
self._mol.stdout.write("\n--- Beta Molecular Orbitals ---\n\n")
dump_mat.dump_mo(self._mol, mo_coeff_b, digits=7, start=1)
self._mol.stdout.flush()
driver_result.add_property(
ElectronicBasisTransform(
ElectronicBasis.AO,
ElectronicBasis.MO,
mo_coeff,
mo_coeff_b,
))
def dump_mo(filename, key='scf'):
'''Read scf/mcscf information from chkfile, then dump the orbital
coefficients.
'''
from pyscf.tools import dump_mat
if key.lower() == 'mcscf':
mol = chkfile.load_mol(filename)
mo_coeff = chkfile.load(filename, 'mcscf/mo_coeff')
else:
mol, mf = chkfile.load_scf(filename)
mo_coeff = mf['mo_coeff']
dump_mat.dump_mo(mol, mo_coeff)
def dump_mo(filename, key='scf'):
'''Read scf/mcscf information from chkfile, then dump the orbital
coefficients.
'''
from pyscf.tools import dump_mat
if key.lower() == 'mcscf':
mol = chkfile.load_mol(filename)
mo_coeff = chkfile.load(filename, 'mcscf/mo_coeff')
else:
mol, mf = chkfile.load_scf(filename)
mo_coeff = mf['mo_coeff']
dump_mat.dump_mo(mol, mo_coeff)
def _calculate_integrals(mol,
hf_method='rhf',
conv_tol=1e-9,
max_cycle=50,
init_guess='minao'):
"""Function to calculate the one and two electron terms. Perform a Hartree-Fock calculation in
the given basis.
Args:
mol (gto.Mole) : A PySCF gto.Mole object.
hf_method (str): rhf, uhf, rohf
conv_tol (float): Convergence tolerance
max_cycle (int): Max convergence cycles
init_guess (str): Initial guess for SCF
Returns:
QMolecule: QMolecule populated with driver integrals etc
"""
enuke = gto.mole.energy_nuc(mol)
if hf_method == 'rhf':
mf = scf.RHF(mol)
elif hf_method == 'rohf':
mf = scf.ROHF(mol)
elif hf_method == 'uhf':
mf = scf.UHF(mol)
else:
raise QiskitChemistryError(
'Invalid hf_method type: {}'.format(hf_method))
mf.conv_tol = conv_tol
mf.max_cycle = max_cycle
mf.init_guess = init_guess
ehf = mf.kernel()
logger.info('PySCF kernel() converged: {}, e(hf): {}'.format(
mf.converged, mf.e_tot))
if type(mf.mo_coeff) is tuple:
mo_coeff = mf.mo_coeff[0]
mo_coeff_B = mf.mo_coeff[1]
# mo_occ = mf.mo_occ[0]
# mo_occ_B = mf.mo_occ[1]
else:
# With PySCF 1.6.2, instead of a tuple of 2 dimensional arrays, its a 3 dimensional
# array with the first dimension indexing to the coeff arrays for alpha and beta
if len(mf.mo_coeff.shape) > 2:
mo_coeff = mf.mo_coeff[0]
mo_coeff_B = mf.mo_coeff[1]
# mo_occ = mf.mo_occ[0]
# mo_occ_B = mf.mo_occ[1]
else:
mo_coeff = mf.mo_coeff
mo_coeff_B = None
# mo_occ = mf.mo_occ
# mo_occ_B = None
norbs = mo_coeff.shape[0]
if type(mf.mo_energy) is tuple:
orbs_energy = mf.mo_energy[0]
orbs_energy_B = mf.mo_energy[1]
else:
# See PYSCF 1.6.2 comment above - this was similarly changed
if len(mf.mo_energy.shape) > 1:
orbs_energy = mf.mo_energy[0]
orbs_energy_B = mf.mo_energy[1]
else:
orbs_energy = mf.mo_energy
orbs_energy_B = None
if logger.isEnabledFor(logging.DEBUG):
# Add some more to PySCF output...
# First analyze() which prints extra information about MO energy and occupation
mol.stdout.write('\n')
mf.analyze()
# Now labelled orbitals for contributions to the MOs for s,p,d etc of each atom
mol.stdout.write('\n\n--- Alpha Molecular Orbitals ---\n\n')
dump_mat.dump_mo(mol, mo_coeff, digits=7, start=1)
if mo_coeff_B is not None:
mol.stdout.write('\n--- Beta Molecular Orbitals ---\n\n')
dump_mat.dump_mo(mol, mo_coeff_B, digits=7, start=1)
mol.stdout.flush()
hij = mf.get_hcore()
mohij = np.dot(np.dot(mo_coeff.T, hij), mo_coeff)
mohij_B = None
if mo_coeff_B is not None:
mohij_B = np.dot(np.dot(mo_coeff_B.T, hij), mo_coeff_B)
eri = mol.intor('int2e', aosym=1)
mo_eri = ao2mo.incore.full(mf._eri, mo_coeff, compact=False)
mohijkl = mo_eri.reshape(norbs, norbs, norbs, norbs)
mohijkl_BB = None
mohijkl_BA = None
if mo_coeff_B is not None:
mo_eri_B = ao2mo.incore.full(mf._eri, mo_coeff_B, compact=False)
mohijkl_BB = mo_eri_B.reshape(norbs, norbs, norbs, norbs)
mo_eri_BA = ao2mo.incore.general(
mf._eri, (mo_coeff_B, mo_coeff_B, mo_coeff, mo_coeff),
compact=False)
mohijkl_BA = mo_eri_BA.reshape(norbs, norbs, norbs, norbs)
# dipole integrals
mol.set_common_orig((0, 0, 0))
ao_dip = mol.intor_symmetric('int1e_r', comp=3)
x_dip_ints = ao_dip[0]
y_dip_ints = ao_dip[1]
z_dip_ints = ao_dip[2]
dm = mf.make_rdm1(mf.mo_coeff, mf.mo_occ)
if hf_method == 'rohf' or hf_method == 'uhf':
dm = dm[0]
elec_dip = np.negative(np.einsum('xij,ji->x', ao_dip, dm).real)
elec_dip = np.round(elec_dip, decimals=8)
nucl_dip = np.einsum('i,ix->x', mol.atom_charges(), mol.atom_coords())
nucl_dip = np.round(nucl_dip, decimals=8)
logger.info("HF Electronic dipole moment: {}".format(elec_dip))
logger.info("Nuclear dipole moment: {}".format(nucl_dip))
logger.info("Total dipole moment: {}".format(nucl_dip + elec_dip))
# Create driver level molecule object and populate
_q_ = QMolecule()
_q_.origin_driver_version = pyscf_version
# Energies and orbits
_q_.hf_energy = ehf
_q_.nuclear_repulsion_energy = enuke
_q_.num_orbitals = norbs
_q_.num_alpha = mol.nelec[0]
_q_.num_beta = mol.nelec[1]
_q_.mo_coeff = mo_coeff
_q_.mo_coeff_B = mo_coeff_B
_q_.orbital_energies = orbs_energy
_q_.orbital_energies_B = orbs_energy_B
# Molecule geometry
_q_.molecular_charge = mol.charge
_q_.multiplicity = mol.spin + 1
_q_.num_atoms = mol.natm
_q_.atom_symbol = []
_q_.atom_xyz = np.empty([mol.natm, 3])
atoms = mol.atom_coords()
for _n in range(0, _q_.num_atoms):
xyz = mol.atom_coord(_n)
_q_.atom_symbol.append(mol.atom_pure_symbol(_n))
_q_.atom_xyz[_n][0] = xyz[0]
_q_.atom_xyz[_n][1] = xyz[1]
_q_.atom_xyz[_n][2] = xyz[2]
# 1 and 2 electron integrals AO and MO
_q_.hcore = hij
_q_.hcore_B = None
_q_.kinetic = mol.intor_symmetric('int1e_kin')
_q_.overlap = mf.get_ovlp()
_q_.eri = eri
_q_.mo_onee_ints = mohij
_q_.mo_onee_ints_B = mohij_B
_q_.mo_eri_ints = mohijkl
_q_.mo_eri_ints_BB = mohijkl_BB
_q_.mo_eri_ints_BA = mohijkl_BA
# dipole integrals AO and MO
_q_.x_dip_ints = x_dip_ints
_q_.y_dip_ints = y_dip_ints
_q_.z_dip_ints = z_dip_ints
_q_.x_dip_mo_ints = QMolecule.oneeints2mo(x_dip_ints, mo_coeff)
_q_.x_dip_mo_ints_B = None
_q_.y_dip_mo_ints = QMolecule.oneeints2mo(y_dip_ints, mo_coeff)
_q_.y_dip_mo_ints_B = None
_q_.z_dip_mo_ints = QMolecule.oneeints2mo(z_dip_ints, mo_coeff)
_q_.z_dip_mo_ints_B = None
if mo_coeff_B is not None:
_q_.x_dip_mo_ints_B = QMolecule.oneeints2mo(x_dip_ints, mo_coeff_B)
_q_.y_dip_mo_ints_B = QMolecule.oneeints2mo(y_dip_ints, mo_coeff_B)
_q_.z_dip_mo_ints_B = QMolecule.oneeints2mo(z_dip_ints, mo_coeff_B)
# dipole moment
_q_.nuclear_dipole_moment = nucl_dip
_q_.reverse_dipole_sign = True
return _q_
def _calculate_integrals(mol, hf_method="rhf", conv_tol=1e-9, max_cycle=50, init_guess="minao"):
"""Function to calculate the one and two electron terms. Perform a Hartree-Fock calculation in
the given basis.
Args:
mol (gto.Mole) : A PySCF gto.Mole object.
hf_method (str): rhf, uhf, rohf
conv_tol (float): Convergence tolerance
max_cycle (int): Max convergence cycles
init_guess (str): Initial guess for SCF
Returns:
QMolecule: QMolecule populated with driver integrals etc
Raises:
QiskitNatureError: Invalid hf method type
"""
enuke = gto.mole.energy_nuc(mol)
if hf_method == "rhf":
m_f = scf.RHF(mol)
elif hf_method == "rohf":
m_f = scf.ROHF(mol)
elif hf_method == "uhf":
m_f = scf.UHF(mol)
else:
raise QiskitNatureError(f"Invalid hf_method type: {hf_method}")
m_f.conv_tol = conv_tol
m_f.max_cycle = max_cycle
m_f.init_guess = init_guess
ehf = m_f.kernel()
logger.info("PySCF kernel() converged: %s, e(hf): %s", m_f.converged, m_f.e_tot)
if isinstance(m_f.mo_coeff, tuple):
mo_coeff = m_f.mo_coeff[0]
mo_coeff_b = m_f.mo_coeff[1]
mo_occ = m_f.mo_occ[0]
mo_occ_b = m_f.mo_occ[1]
else:
# With PySCF 1.6.2, instead of a tuple of 2 dimensional arrays, its a 3 dimensional
# array with the first dimension indexing to the coeff arrays for alpha and beta
if len(m_f.mo_coeff.shape) > 2:
mo_coeff = m_f.mo_coeff[0]
mo_coeff_b = m_f.mo_coeff[1]
mo_occ = m_f.mo_occ[0]
mo_occ_b = m_f.mo_occ[1]
else:
mo_coeff = m_f.mo_coeff
mo_coeff_b = None
mo_occ = m_f.mo_occ
mo_occ_b = None
norbs = mo_coeff.shape[0]
if isinstance(m_f.mo_energy, tuple):
orbs_energy = m_f.mo_energy[0]
orbs_energy_b = m_f.mo_energy[1]
else:
# See PYSCF 1.6.2 comment above - this was similarly changed
if len(m_f.mo_energy.shape) > 1:
orbs_energy = m_f.mo_energy[0]
orbs_energy_b = m_f.mo_energy[1]
else:
orbs_energy = m_f.mo_energy
orbs_energy_b = None
if logger.isEnabledFor(logging.DEBUG):
# Add some more to PySCF output...
# First analyze() which prints extra information about MO energy and occupation
mol.stdout.write("\n")
m_f.analyze()
# Now labelled orbitals for contributions to the MOs for s,p,d etc of each atom
mol.stdout.write("\n\n--- Alpha Molecular Orbitals ---\n\n")
dump_mat.dump_mo(mol, mo_coeff, digits=7, start=1)
if mo_coeff_b is not None:
mol.stdout.write("\n--- Beta Molecular Orbitals ---\n\n")
dump_mat.dump_mo(mol, mo_coeff_b, digits=7, start=1)
mol.stdout.flush()
hij = m_f.get_hcore()
mohij = np.dot(np.dot(mo_coeff.T, hij), mo_coeff)
mohij_b = None
if mo_coeff_b is not None:
mohij_b = np.dot(np.dot(mo_coeff_b.T, hij), mo_coeff_b)
eri = mol.intor("int2e", aosym=1)
mo_eri = ao2mo.incore.full(m_f._eri, mo_coeff, compact=False)
mohijkl = mo_eri.reshape(norbs, norbs, norbs, norbs)
mohijkl_bb = None
mohijkl_ba = None
if mo_coeff_b is not None:
mo_eri_b = ao2mo.incore.full(m_f._eri, mo_coeff_b, compact=False)
mohijkl_bb = mo_eri_b.reshape(norbs, norbs, norbs, norbs)
mo_eri_ba = ao2mo.incore.general(
m_f._eri, (mo_coeff_b, mo_coeff_b, mo_coeff, mo_coeff), compact=False
)
mohijkl_ba = mo_eri_ba.reshape(norbs, norbs, norbs, norbs)
# dipole integrals
mol.set_common_orig((0, 0, 0))
ao_dip = mol.intor_symmetric("int1e_r", comp=3)
x_dip_ints = ao_dip[0]
y_dip_ints = ao_dip[1]
z_dip_ints = ao_dip[2]
d_m = m_f.make_rdm1(m_f.mo_coeff, m_f.mo_occ)
if not (isinstance(d_m, np.ndarray) and d_m.ndim == 2):
d_m = d_m[0] + d_m[1]
elec_dip = np.negative(np.einsum("xij,ji->x", ao_dip, d_m).real)
elec_dip = np.round(elec_dip, decimals=8)
nucl_dip = np.einsum("i,ix->x", mol.atom_charges(), mol.atom_coords())
nucl_dip = np.round(nucl_dip, decimals=8)
logger.info("HF Electronic dipole moment: %s", elec_dip)
logger.info("Nuclear dipole moment: %s", nucl_dip)
logger.info("Total dipole moment: %s", nucl_dip + elec_dip)
# Create driver level molecule object and populate
_q_ = QMolecule()
_q_.origin_driver_version = pyscf_version
# Energies and orbits
_q_.hf_energy = ehf
_q_.nuclear_repulsion_energy = enuke
_q_.num_molecular_orbitals = norbs
_q_.num_alpha = mol.nelec[0]
_q_.num_beta = mol.nelec[1]
_q_.mo_coeff = mo_coeff
_q_.mo_coeff_b = mo_coeff_b
_q_.orbital_energies = orbs_energy
_q_.orbital_energies_b = orbs_energy_b
_q_.mo_occ = mo_occ
_q_.mo_occ_b = mo_occ_b
# Molecule geometry
_q_.molecular_charge = mol.charge
_q_.multiplicity = mol.spin + 1
_q_.num_atoms = mol.natm
_q_.atom_symbol = []
_q_.atom_xyz = np.empty([mol.natm, 3])
_ = mol.atom_coords()
for n_i in range(0, _q_.num_atoms):
xyz = mol.atom_coord(n_i)
_q_.atom_symbol.append(mol.atom_pure_symbol(n_i))
_q_.atom_xyz[n_i][0] = xyz[0]
_q_.atom_xyz[n_i][1] = xyz[1]
_q_.atom_xyz[n_i][2] = xyz[2]
# 1 and 2 electron integrals AO and MO
_q_.hcore = hij
_q_.hcore_b = None
_q_.kinetic = mol.intor_symmetric("int1e_kin")
_q_.overlap = m_f.get_ovlp()
_q_.eri = eri
_q_.mo_onee_ints = mohij
_q_.mo_onee_ints_b = mohij_b
_q_.mo_eri_ints = mohijkl
_q_.mo_eri_ints_bb = mohijkl_bb
_q_.mo_eri_ints_ba = mohijkl_ba
# dipole integrals AO and MO
_q_.x_dip_ints = x_dip_ints
_q_.y_dip_ints = y_dip_ints
_q_.z_dip_ints = z_dip_ints
_q_.x_dip_mo_ints = QMolecule.oneeints2mo(x_dip_ints, mo_coeff)
_q_.x_dip_mo_ints_b = None
_q_.y_dip_mo_ints = QMolecule.oneeints2mo(y_dip_ints, mo_coeff)
_q_.y_dip_mo_ints_b = None
_q_.z_dip_mo_ints = QMolecule.oneeints2mo(z_dip_ints, mo_coeff)
_q_.z_dip_mo_ints_b = None
if mo_coeff_b is not None:
_q_.x_dip_mo_ints_b = QMolecule.oneeints2mo(x_dip_ints, mo_coeff_b)
_q_.y_dip_mo_ints_b = QMolecule.oneeints2mo(y_dip_ints, mo_coeff_b)
_q_.z_dip_mo_ints_b = QMolecule.oneeints2mo(z_dip_ints, mo_coeff_b)
# dipole moment
_q_.nuclear_dipole_moment = nucl_dip
_q_.reverse_dipole_sign = True
return _q_
def _calculate_integrals(mol, hf_method='rhf', conv_tol=1e-9, max_cycle=50, init_guess='minao',outfile=None):
"""Function to calculate the one and two electron terms. Perform a Hartree-Fock calculation in
the given basis.
Args:
mol (gto.Mole) : A PySCF gto.Mole object.
hf_method (str): rhf, uhf, rohf
conv_tol (float): Convergence tolerance
max_cycle (int): Max convergence cycles
init_guess (str): Initial guess for SCF
Returns:
QMolecule: QMolecule populated with driver integrals etc
Raises:
QiskitChemistryError: Invalid hf method type
"""
enuke = gto.mole.energy_nuc(mol)
if hf_method == 'rhf':
m_f = scf.RHF(mol)
elif hf_method == 'rohf':
m_f = scf.ROHF(mol)
elif hf_method == 'uhf':
m_f = scf.UHF(mol)
else:
raise QiskitChemistryError('Invalid hf_method type: {}'.format(hf_method))
m_f.conv_tol = conv_tol
m_f.max_cycle = max_cycle
m_f.init_guess = init_guess
ehf = m_f.kernel()
from pyscf import tools
from prettytable import PrettyTable
C = m_f.mo_coeff
irr = get_irreps(mol,C)
table_ancillary_info = [[str(round(m_f.mo_energy[i],4)),irr[i],str(int(m_f.mo_occ[i]))] for i in range(mol.nao_nr())]
outfile.write("SCF orbitals\n")
t = PrettyTable(['MO']+mol.ao_labels()+['E','irr','occ'])
for i in range(C.shape[1]):
if(C[np.argmax(np.abs(C[:,i])),i]<0): C[:,i] *= -1
t.add_row([str(i)]+[str(round(x,4)) for x in C[:,i]]+table_ancillary_info[i])
outfile.write(str(t))
filename = 'mos'
for i in range(m_f.mo_coeff.shape[1]):
moldenfile = filename+'-'+str(i)+'.molden'
tools.molden.from_mo(mol,moldenfile,m_f.mo_coeff)
jmol_script = filename+'-'+str(i)+'.spt'
fspt = open(jmol_script,'w')
fspt.write('''
initialize;
set background [xffffff];
set frank off
set autoBond true;
set bondRadiusMilliAngstroms 66;
set bondTolerance 0.5;
set forceAutoBond false;
load %s
''' % moldenfile)
fspt.write('''
zoom 130;
rotate -20 z
rotate -60 x
axes
MO COLOR [xff0020] [x0060ff];
MO COLOR translucent 0.25;
MO fill noDots noMesh;
MO titleformat "";
''')
fspt.write('MO %d cutoff 0.02;\n' % (i+1))
fspt.write('write IMAGE 400 400 PNG 180 "%s-%02d.png";\n' % (filename,i+1))
fspt.close()
logger.info('PySCF kernel() converged: %s, e(hf): %s', m_f.converged, m_f.e_tot)
if isinstance(m_f.mo_coeff, tuple):
mo_coeff = m_f.mo_coeff[0]
mo_coeff_b = m_f.mo_coeff[1]
# mo_occ = m_f.mo_occ[0]
# mo_occ_b = m_f.mo_occ[1]
else:
# With PySCF 1.6.2, instead of a tuple of 2 dimensional arrays, its a 3 dimensional
# array with the first dimension indexing to the coeff arrays for alpha and beta
if len(m_f.mo_coeff.shape) > 2:
mo_coeff = m_f.mo_coeff[0]
mo_coeff_b = m_f.mo_coeff[1]
# mo_occ = m_f.mo_occ[0]
# mo_occ_b = m_f.mo_occ[1]
else:
mo_coeff = m_f.mo_coeff
mo_coeff_b = None
# mo_occ = mf.mo_occ
# mo_occ_b = None
norbs = mo_coeff.shape[0]
if isinstance(m_f.mo_energy, tuple):
orbs_energy = m_f.mo_energy[0]
orbs_energy_b = m_f.mo_energy[1]
else:
# See PYSCF 1.6.2 comment above - this was similarly changed
if len(m_f.mo_energy.shape) > 1:
orbs_energy = m_f.mo_energy[0]
orbs_energy_b = m_f.mo_energy[1]
else:
orbs_energy = m_f.mo_energy
orbs_energy_b = None
if logger.isEnabledFor(logging.DEBUG):
# Add some more to PySCF output...
# First analyze() which prints extra information about MO energy and occupation
mol.stdout.write('\n')
m_f.analyze()
# Now labelled orbitals for contributions to the MOs for s,p,d etc of each atom
mol.stdout.write('\n\n--- Alpha Molecular Orbitals ---\n\n')
dump_mat.dump_mo(mol, mo_coeff, digits=7, start=1)
if mo_coeff_b is not None:
mol.stdout.write('\n--- Beta Molecular Orbitals ---\n\n')
dump_mat.dump_mo(mol, mo_coeff_b, digits=7, start=1)
mol.stdout.flush()
hij = m_f.get_hcore()
mohij = np.dot(np.dot(mo_coeff.T, hij), mo_coeff)
mohij_b = None
if mo_coeff_b is not None:
mohij_b = np.dot(np.dot(mo_coeff_b.T, hij), mo_coeff_b)
eri = mol.intor('int2e', aosym=1)
mo_eri = ao2mo.incore.full(m_f._eri, mo_coeff, compact=False)
mohijkl = mo_eri.reshape(norbs, norbs, norbs, norbs)
mohijkl_bb = None
mohijkl_ba = None
if mo_coeff_b is not None:
mo_eri_b = ao2mo.incore.full(m_f._eri, mo_coeff_b, compact=False)
mohijkl_bb = mo_eri_b.reshape(norbs, norbs, norbs, norbs)
mo_eri_ba = ao2mo.incore.general(m_f._eri,
(mo_coeff_b, mo_coeff_b, mo_coeff, mo_coeff),
compact=False)
mohijkl_ba = mo_eri_ba.reshape(norbs, norbs, norbs, norbs)
# dipole integrals
mol.set_common_orig((0, 0, 0))
ao_dip = mol.intor_symmetric('int1e_r', comp=3)
x_dip_ints = ao_dip[0]
y_dip_ints = ao_dip[1]
z_dip_ints = ao_dip[2]
d_m = m_f.make_rdm1(m_f.mo_coeff, m_f.mo_occ)
if hf_method in ('rohf', 'uhf'):
d_m = d_m[0]
elec_dip = np.negative(np.einsum('xij,ji->x', ao_dip, d_m).real)
elec_dip = np.round(elec_dip, decimals=8)
nucl_dip = np.einsum('i,ix->x', mol.atom_charges(), mol.atom_coords())
nucl_dip = np.round(nucl_dip, decimals=8)
logger.info("HF Electronic dipole moment: %s", elec_dip)
logger.info("Nuclear dipole moment: %s", nucl_dip)
logger.info("Total dipole moment: %s", nucl_dip+elec_dip)
# Create driver level molecule object and populate
_q_ = QMolecule()
_q_.origin_driver_version = pyscf_version
# Energies and orbits
_q_.hf_energy = ehf
_q_.nuclear_repulsion_energy = enuke
_q_.num_orbitals = norbs
_q_.num_alpha = mol.nelec[0]
_q_.num_beta = mol.nelec[1]
_q_.mo_coeff = mo_coeff
_q_.mo_coeff_b = mo_coeff_b
_q_.orbital_energies = orbs_energy
_q_.orbital_energies_b = orbs_energy_b
# Molecule geometry
_q_.molecular_charge = mol.charge
_q_.multiplicity = mol.spin + 1
_q_.num_atoms = mol.natm
_q_.atom_symbol = []
_q_.atom_xyz = np.empty([mol.natm, 3])
_ = mol.atom_coords()
for n_i in range(0, _q_.num_atoms):
xyz = mol.atom_coord(n_i)
_q_.atom_symbol.append(mol.atom_pure_symbol(n_i))
_q_.atom_xyz[n_i][0] = xyz[0]
_q_.atom_xyz[n_i][1] = xyz[1]
_q_.atom_xyz[n_i][2] = xyz[2]
# 1 and 2 electron integrals AO and MO
_q_.hcore = hij
_q_.hcore_b = None
_q_.kinetic = mol.intor_symmetric('int1e_kin')
_q_.overlap = m_f.get_ovlp()
_q_.eri = eri
_q_.mo_onee_ints = mohij
_q_.mo_onee_ints_b = mohij_b
_q_.mo_eri_ints = mohijkl
_q_.mo_eri_ints_bb = mohijkl_bb
_q_.mo_eri_ints_ba = mohijkl_ba
# dipole integrals AO and MO
_q_.x_dip_ints = x_dip_ints
_q_.y_dip_ints = y_dip_ints
_q_.z_dip_ints = z_dip_ints
_q_.x_dip_mo_ints = QMolecule.oneeints2mo(x_dip_ints, mo_coeff)
_q_.x_dip_mo_ints_b = None
_q_.y_dip_mo_ints = QMolecule.oneeints2mo(y_dip_ints, mo_coeff)
_q_.y_dip_mo_ints_b = None
_q_.z_dip_mo_ints = QMolecule.oneeints2mo(z_dip_ints, mo_coeff)
_q_.z_dip_mo_ints_b = None
if mo_coeff_b is not None:
_q_.x_dip_mo_ints_b = QMolecule.oneeints2mo(x_dip_ints, mo_coeff_b)
_q_.y_dip_mo_ints_b = QMolecule.oneeints2mo(y_dip_ints, mo_coeff_b)
_q_.z_dip_mo_ints_b = QMolecule.oneeints2mo(z_dip_ints, mo_coeff_b)
# dipole moment
_q_.nuclear_dipole_moment = nucl_dip
_q_.reverse_dipole_sign = True
return _q_
