def init_guess_by_chkfile(self, chk=None, project=True):
from pyscf.scf import addons
if isinstance(chk, pyscf.gto.Mole):
raise RuntimeError('''
You see this error message because of the API updates.
The first argument is chk file name.''')
if chk is None: chk = self.chkfile
chk_mol, scf_rec = chkfile.load_scf(chk)
def fproj(mo):
if project:
return addons.project_mo_nr2nr(chk_mol, mo, self.mol)
else:
return mo
if scf_rec['mo_coeff'].ndim == 2:
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if numpy.iscomplexobj(mo):
raise RuntimeError('TODO: project DHF orbital to ROHF orbital')
dm = self.make_rdm1(fproj(mo), mo_occ)
else: # UHF
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
dm =(make_rdm1(fproj(mo[0]), mo_occ[0]),
make_rdm1(fproj(mo[1]), mo_occ[1]))
return dm
def init_guess_by_chkfile(mol, chkfile_name, project=True):
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
def fproj(mo):
if project:
return addons.project_mo_nr2nr(chk_mol, mo, mol)
else:
return mo
if scf_rec["mo_coeff"].ndim == 2:
mo = scf_rec["mo_coeff"]
mo_occ = scf_rec["mo_occ"]
if numpy.iscomplexobj(mo):
raise RuntimeError("TODO: project DHF orbital to UHF orbital")
mo_coeff = fproj(mo)
mo_a = mo_coeff[:, mo_occ > 0]
mo_b = mo_coeff[:, mo_occ > 1]
dm_a = numpy.dot(mo_a, mo_a.T)
dm_b = numpy.dot(mo_b, mo_b.T)
dm = numpy.array((dm_a, dm_b))
else: # UHF
mo = scf_rec["mo_coeff"]
mo_occ = scf_rec["mo_occ"]
dm = make_rdm1([fproj(mo[0]), fproj(mo[1])], mo_occ)
return dm
def init_guess_by_chkfile(mol, chkfile_name, project=None):
'''Read SCF chkfile and make the density matrix for UHF initial guess.
Kwargs:
project : None or bool
Whether to project chkfile's orbitals to the new basis. Note when
the geometry of the chkfile and the given molecule are very
different, this projection can produce very poor initial guess.
In PES scanning, it is recommended to swith off project.
If project is set to None, the projection is only applied when the
basis sets of the chkfile's molecule are different to the basis
sets of the given molecule (regardless whether the geometry of
the two molecules are different). Note the basis sets are
considered to be different if the two molecules are derived from
the same molecule with different ordering of atoms.
'''
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
if project is None:
project = not gto.same_basis_set(chk_mol, mol)
# Check whether the two molecules are similar
im1 = scipy.linalg.eigvalsh(mol.inertia_moment())
im2 = scipy.linalg.eigvalsh(chk_mol.inertia_moment())
# im1+1e-7 to avoid 'divide by zero' error
if abs((im1 - im2) / (im1 + 1e-7)).max() > 0.01:
logger.warn(
mol, "Large deviations found between the input "
"molecule and the molecule from chkfile\n"
"Initial guess density matrix may have large error.")
if project:
s = hf.get_ovlp(mol)
def fproj(mo):
if project:
mo = addons.project_mo_nr2nr(chk_mol, mo, mol)
norm = numpy.einsum('pi,pi->i', mo.conj(), s.dot(mo))
mo /= numpy.sqrt(norm)
return mo
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if getattr(mo[0], 'ndim', None) == 1: # RHF
if numpy.iscomplexobj(mo):
raise NotImplementedError(
'TODO: project DHF orbital to UHF orbital')
mo_coeff = fproj(mo)
mo_occa = (mo_occ > 1e-8).astype(numpy.double)
mo_occb = mo_occ - mo_occa
dm = make_rdm1([mo_coeff, mo_coeff], [mo_occa, mo_occb])
else: #UHF
if getattr(mo[0][0], 'ndim', None) == 2: # KUHF
logger.warn(
mol, 'k-point UHF results are found. Density matrix '
'at Gamma point is used for the molecular SCF initial guess')
mo = mo[0]
dm = make_rdm1([fproj(mo[0]), fproj(mo[1])], mo_occ)
return dm
def init_guess_by_chkfile(mol, chkfile_name, project=True):
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
def fproj(mo):
if project:
return addons.project_mo_nr2nr(chk_mol, mo, mol)
else:
return mo
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if hasattr(mo[0], 'ndim') and mo[0].ndim == 1: # RHF
if numpy.iscomplexobj(mo):
raise NotImplementedError('TODO: project DHF orbital to UHF orbital')
mo_coeff = fproj(mo)
mo_occa = (mo_occ>1e-8).astype(numpy.double)
mo_occb = mo_occ - mo_occa
dm = make_rdm1([mo_coeff,mo_coeff], [mo_occa,mo_occb])
else: #UHF
if hasattr(mo[0][0], 'ndim') and mo[0][0].ndim == 2: # KUHF
logger.warn(mol, 'k-point UHF results are found. The gamma point '
'density matrix is used for the molecular SCF initial guess')
mo = mo[0]
dm = make_rdm1([fproj(mo[0]),fproj(mo[1])], mo_occ)
return dm
def init_guess_by_chkfile(mol, chkfile_name, project=True):
'''Read the HF results from checkpoint file, then project it to the
basis defined by ``mol``
Returns:
Density matrix, 2D ndarray
'''
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
def fproj(mo):
if project:
return addons.project_mo_nr2nr(chk_mol, mo, mol)
else:
return mo
if scf_rec['mo_coeff'].ndim == 2:
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if numpy.iscomplexobj(mo):
raise NotImplementedError(
'TODO: project DHF orbital to RHF orbital')
dm = make_rdm1(fproj(mo), mo_occ)
else: # UHF
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
dm = make_rdm1(fproj(mo[0]), mo_occ[0]) \
+ make_rdm1(fproj(mo[1]), mo_occ[1])
return dm
def init_guess_by_chkfile(mol, chkfile_name, project=True):
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
def fproj(mo):
if project:
return addons.project_mo_nr2nr(chk_mol, mo, mol)
else:
return mo
if scf_rec['mo_coeff'].ndim == 2:
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if numpy.iscomplexobj(mo):
raise NotImplementedError(
'TODO: project DHF orbital to UHF orbital')
mo_coeff = fproj(mo)
mo_a = mo_coeff[:, mo_occ > 0]
mo_b = mo_coeff[:, mo_occ > 1]
dm_a = numpy.dot(mo_a, mo_a.T)
dm_b = numpy.dot(mo_b, mo_b.T)
dm = numpy.array((dm_a, dm_b))
else: #UHF
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
dm = make_rdm1([fproj(mo[0]), fproj(mo[1])], mo_occ)
return dm
def init_guess_by_chkfile(mol, chkfile_name, project=True):
'''Read the HF results from checkpoint file, then project it to the
basis defined by ``mol``
Returns:
Density matrix, 2D ndarray
'''
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
def fproj(mo):
if project:
return addons.project_mo_nr2nr(chk_mol, mo, mol)
else:
return mo
if scf_rec['mo_coeff'].ndim == 2:
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if numpy.iscomplexobj(mo):
raise RuntimeError('TODO: project DHF orbital to RHF orbital')
dm = make_rdm1(fproj(mo), mo_occ)
else: # UHF
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
dm = make_rdm1(fproj(mo[0]), mo_occ[0]) \
+ make_rdm1(fproj(mo[1]), mo_occ[1])
return dm
def init_guess_by_chkfile(mol, chkfile_name, project=None):
'''Read SCF chkfile and make the density matrix for 4C-DHF initial guess.
Kwargs:
project : None or bool
Whether to project chkfile's orbitals to the new basis. Note when
the geometry of the chkfile and the given molecule are very
different, this projection can produce very poor initial guess.
In PES scanning, it is recommended to swith off project.
If project is set to None, the projection is only applied when the
basis sets of the chkfile's molecule are different to the basis
sets of the given molecule (regardless whether the geometry of
the two molecules are different). Note the basis sets are
considered to be different if the two molecules are derived from
the same molecule with different ordering of atoms.
'''
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
if project is None:
project = not gto.same_basis_set(chk_mol, mol)
# Check whether the two molecules are similar
def inertia_momentum(mol):
im = gto.inertia_momentum(mol._atom, mol.atom_charges(),
mol.atom_coords())
return scipy.linalg.eigh(im)[0]
if abs(inertia_momentum(mol) - inertia_momentum(chk_mol)).sum() > 0.5:
logger.warn(
mol, "Large deviations found between the input "
"molecule and the molecule from chkfile\n"
"Initial guess density matrix may have large error.")
if project:
s = get_ovlp(mol)
def fproj(mo):
#TODO: check if mo is GHF orbital
if project:
mo = addons.project_mo_r2r(chk_mol, mo, mol)
norm = numpy.einsum('pi,pi->i', mo.conj(), s.dot(mo))
mo /= numpy.sqrt(norm)
return mo
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if numpy.iscomplexobj(mo[0]): # DHF
dm = make_rdm1(fproj(mo), mo_occ)
else:
if mo[0].ndim == 1: # nr-RHF
dm = reduce(numpy.dot, (mo * mo_occ, mo.T))
else: # nr-UHF
dm = reduce(numpy.dot, (mo[0]*mo_occ[0], mo[0].T)) \
+ reduce(numpy.dot, (mo[1]*mo_occ[1], mo[1].T))
dm = _proj_dmll(chk_mol, dm, mol)
return dm
def init_guess_by_chkfile(mol, chkfile_name, project=None):
'''Read SCF chkfile and make the density matrix for UHF initial guess.
Kwargs:
project : None or bool
Whether to project chkfile's orbitals to the new basis. Note when
the geometry of the chkfile and the given molecule are very
different, this projection can produce very poor initial guess.
In PES scanning, it is recommended to swith off project.
If project is set to None, the projection is only applied when the
basis sets of the chkfile's molecule are different to the basis
sets of the given molecule (regardless whether the geometry of
the two molecules are different). Note the basis sets are
considered to be different if the two molecules are derived from
the same molecule with different ordering of atoms.
'''
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
if project is None:
project = not gto.same_basis_set(chk_mol, mol)
# Check whether the two molecules are similar
im1 = scipy.linalg.eigvalsh(mol.inertia_moment())
im2 = scipy.linalg.eigvalsh(chk_mol.inertia_moment())
# im1+1e-7 to avoid 'divide by zero' error
if abs((im1-im2)/(im1+1e-7)).max() > 0.01:
logger.warn(mol, "Large deviations found between the input "
"molecule and the molecule from chkfile\n"
"Initial guess density matrix may have large error.")
if project:
s = hf.get_ovlp(mol)
def fproj(mo):
if project:
mo = addons.project_mo_nr2nr(chk_mol, mo, mol)
norm = numpy.einsum('pi,pi->i', mo.conj(), s.dot(mo))
mo /= numpy.sqrt(norm)
return mo
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if getattr(mo[0], 'ndim', None) == 1: # RHF
if numpy.iscomplexobj(mo):
raise NotImplementedError('TODO: project DHF orbital to UHF orbital')
mo_coeff = fproj(mo)
mo_occa = (mo_occ>1e-8).astype(numpy.double)
mo_occb = mo_occ - mo_occa
dm = make_rdm1([mo_coeff,mo_coeff], [mo_occa,mo_occb])
else: #UHF
if getattr(mo[0][0], 'ndim', None) == 2: # KUHF
logger.warn(mol, 'k-point UHF results are found. Density matrix '
'at Gamma point is used for the molecular SCF initial guess')
mo = mo[0]
dm = make_rdm1([fproj(mo[0]),fproj(mo[1])], mo_occ)
return dm
def compute(self, atoms):
if 'pyscf.chkpt' in os.listdir('.') and self.skip_calculated:
print('Re-using results')
mol, results = load_scf('pyscf.chkpt')
e = results['e_tot']
else:
mf, mol = compute_KS(atoms, basis=self.basis, xc=self.xc, nxc=self.nxc, **self.engine_kwargs)
e = mf.energy_tot()
atoms.calc = SinglePointCalculator(atoms)
atoms.calc.results = {'energy': e * Hartree}
return atoms
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 init_guess_by_chkfile(mol, chkfile_name, project=None):
'''Read SCF chkfile and make the density matrix for 4C-DHF initial guess.
Kwargs:
project : None or bool
Whether to project chkfile's orbitals to the new basis. Note when
the geometry of the chkfile and the given molecule are very
different, this projection can produce very poor initial guess.
In PES scanning, it is recommended to swith off project.
If project is set to None, the projection is only applied when the
basis sets of the chkfile's molecule are different to the basis
sets of the given molecule (regardless whether the geometry of
the two molecules are different). Note the basis sets are
considered to be different if the two molecules are derived from
the same molecule with different ordering of atoms.
'''
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
if project is None:
project = not gto.same_basis_set(chk_mol, mol)
# Check whether the two molecules are similar
if abs(mol.inertia_moment() - chk_mol.inertia_moment()).sum() > 0.5:
logger.warn(mol, "Large deviations found between the input "
"molecule and the molecule from chkfile\n"
"Initial guess density matrix may have large error.")
if project:
s = get_ovlp(mol)
def fproj(mo):
#TODO: check if mo is GHF orbital
if project:
mo = addons.project_mo_r2r(chk_mol, mo, mol)
norm = numpy.einsum('pi,pi->i', mo.conj(), s.dot(mo))
mo /= numpy.sqrt(norm)
return mo
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if numpy.iscomplexobj(mo[0]): # DHF
dm = make_rdm1(fproj(mo), mo_occ)
else:
if mo[0].ndim == 1: # nr-RHF
dm = reduce(numpy.dot, (mo*mo_occ, mo.T))
else: # nr-UHF
dm = reduce(numpy.dot, (mo[0]*mo_occ[0], mo[0].T)) \
+ reduce(numpy.dot, (mo[1]*mo_occ[1], mo[1].T))
dm = _proj_dmll(chk_mol, dm, mol)
return dm
def mulliken(filename, key='scf'):
'''Reading scf/mcscf information from chkfile, then do Mulliken population
analysis for the density matrix
'''
if key.lower() == 'mcscf':
mol = chkfile.load_mol(filename)
mo_coeff = chkfile.load(filename, 'mcscf/mo_coeff')
mo_occ = chkfile.load(filename, 'mcscf/mo_occ')
else:
mol, mf = chkfile.load_scf(filename)
mo_coeff = mf['mo_coeff']
mo_occ = mf['mo_occ']
dm = numpy.dot(mo_coeff*mo_occ, mo_coeff.T)
hf.mulliken_meta(mol, dm)
def mulliken(filename, key='scf'):
'''Reading scf/mcscf information from chkfile, then do Mulliken population
analysis for the density matrix
'''
if key.lower() == 'mcscf':
mol = chkfile.load_mol(filename)
mo_coeff = chkfile.load(filename, 'mcscf/mo_coeff')
mo_occ = chkfile.load(filename, 'mcscf/mo_occ')
else:
mol, mf = chkfile.load_scf(filename)
mo_coeff = mf['mo_coeff']
mo_occ = mf['mo_occ']
dm = numpy.dot(mo_coeff * mo_occ, mo_coeff.T)
hf.mulliken_meta(mol, dm)
def init_guess_by_chkfile(mol, chkfile_name, project=True):
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
def fproj(mo):
if project:
return addons.project_mo_nr2nr(chk_mol, mo, mol)
else:
return mo
if scf_rec['mo_coeff'].ndim == 2:
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if numpy.iscomplexobj(mo):
raise RuntimeError('TODO: project DHF orbital to UHF orbital')
dm = make_rdm1([fproj(mo),]*2, [mo_occ*.5,]*2)
else: #UHF
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
dm = make_rdm1([fproj(mo[0]),fproj(mo[1])], mo_occ)
return dm
def init_guess_by_chkfile(mol, chkfile_name, project=True):
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if numpy.iscomplexobj(mo[0]): # DHF
#TODO: check if mo is GHF orbital
if project:
dm = make_rdm1(addons.project_mo_r2r(chk_mol, mo, mol), mo_occ)
else:
dm = make_rdm1(mo, mo_occ)
else:
if mo[0].ndim == 1: # nr-RHF
dm = reduce(numpy.dot, (mo * mo_occ, mo.T))
else: # nr-UHF
dm = reduce(numpy.dot, (mo[0]*mo_occ[0], mo[0].T)) \
+ reduce(numpy.dot, (mo[1]*mo_occ[1], mo[1].T))
dm = _proj_dmll(chk_mol, dm, mol)
return dm
def init_guess_by_chkfile(mol, chkfile_name, project=True):
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
if numpy.iscomplexobj(scf_rec['mo_coeff']):
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if project:
dm = make_rdm1(addons.project_mo_r2r(chk_mol, mo, mol), mo_occ)
else:
dm = make_rdm1(mo, mo_occ)
else:
if scf_rec['mo_coeff'].ndim == 2: # nr-RHF
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
dm = reduce(numpy.dot, (mo*mo_occ, mo.T))
else: # nr-UHF
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
dm = reduce(numpy.dot, (mo[0]*mo_occ[0], mo[0].T)) \
+ reduce(numpy.dot, (mo[1]*mo_occ[1], mo[1].T))
dm = _proj_dmll(chk_mol, dm, mol)
return dm
def get_density(self, file_path):
mol, results = load_scf(file_path)
return get_dm(results['mo_coeff'],
results['mo_occ']), mol, (results['mo_coeff'],
results['mo_occ'])
def init_guess_by_chkfile(mol, chkfile_name, project=None):
'''Read SCF chkfile and make the density matrix for GHF initial guess.
Kwargs:
project : None or bool
Whether to project chkfile's orbitals to the new basis. Note when
the geometry of the chkfile and the given molecule are very
different, this projection can produce very poor initial guess.
In PES scanning, it is recommended to swith off project.
If project is set to None, the projection is only applied when the
basis sets of the chkfile's molecule are different to the basis
sets of the given molecule (regardless whether the geometry of
the two molecules are different). Note the basis sets are
considered to be different if the two molecules are derived from
the same molecule with different ordering of atoms.
'''
from pyscf.scf import addons
chk_mol, scf_rec = chkfile.load_scf(chkfile_name)
if project is None:
project = not gto.same_basis_set(chk_mol, mol)
# Check whether the two molecules are similar enough
def inertia_momentum(mol):
im = gto.inertia_momentum(mol._atom, mol.atom_charges(),
mol.atom_coords())
return scipy.linalg.eigh(im)[0]
if abs(inertia_momentum(mol) - inertia_momentum(chk_mol)).sum() > 0.5:
logger.warn(
mol, "Large deviations found between the input "
"molecule and the molecule from chkfile\n"
"Initial guess density matrix may have large error.")
if project:
s = hf.get_ovlp(mol)
def fproj(mo):
if project:
mo = addons.project_mo_nr2nr(chk_mol, mo, mol)
norm = numpy.einsum('pi,pi->i', mo.conj(), s.dot(mo))
mo /= numpy.sqrt(norm)
return mo
nao = chk_mol.nao_nr()
mo = scf_rec['mo_coeff']
mo_occ = scf_rec['mo_occ']
if hasattr(mo[0], 'ndim') and mo[0].ndim == 1: # RHF/GHF/DHF
if nao * 2 == mo.shape[0]: # GHF or DHF
if project:
raise NotImplementedError('Project initial guess from '
'different geometry')
else:
dm = hf.make_rdm1(mo, mo_occ)
else: # RHF
mo_coeff = fproj(mo)
mo_occa = (mo_occ > 1e-8).astype(numpy.double)
mo_occb = mo_occ - mo_occa
dma, dmb = uhf.make_rdm1([mo_coeff] * 2, (mo_occa, mo_occb))
dm = scipy.linalg.block_diag(dma, dmb)
else: #UHF
if hasattr(mo[0][0], 'ndim') and mo[0][0].ndim == 2: # KUHF
logger.warn(
mol, 'k-point UHF results are found. Density matrix '
'at Gamma point is used for the molecular SCF initial guess')
mo = mo[0]
dma, dmb = uhf.make_rdm1([fproj(mo[0]), fproj(mo[1])], mo_occ)
dm = scipy.linalg.block_diag(dma, dmb)
return dm
