def setup(self):
self.suppdir = tmpdir(__file__)
self.daltgz = self.suppdir/"mc_h2.tar.gz"
self.sirrst = SiriusRestart(tgz=self.daltgz)
self.sirifc = sirifc(self.suppdir/"SIRIFC")
self.sirifc3 = sirifc(self.suppdir/"SIRIFC3")
self.sirifc4 = sirifc(self.suppdir/"alt4/SIRIFC")
self.xindx4 = list(self.sirifc4.xindx())
def s2n(N, tmpdir='/tmp', Sg=1, Sv=1):
"""
S[2]*N linear transformation:
<[q,k]> = <[E(Sg)_{ij}, k_{kl}, E(Sv)_{kl}]> =
= k_{kl} [E_{il}d(kj) - E(kj)d(il)]
= k(jl)E(SgSv)(il) - k(ki)E(SgSv)(kj)
= D(SgSv)k.T(ij) - k.TD(SgSv)(ij)
= [D(SgSv), k.T](ij)
"""
SIRIFC = os.path.join(tmpdir, 'SIRIFC')
AOONEINT = os.path.join(tmpdir, 'AOONEINT')
AOTWOINT = os.path.join(tmpdir, 'AOTWOINT')
LUINDF = os.path.join(tmpdir, 'LUINDF')
ifc = sirifc.sirifc(SIRIFC)
cmo = ifc.cmo.unblock()
S = one.read('OVERLAP', filename=AOONEINT).unblock().unpack()
da, db = dens.Dab(SIRIFC)
kN = rspvec.tomat(N, ifc, tmpdir=tmpdir).T
kn = cmo*kN*cmo.T
dak = (kn.T*S*da - da*S*kn.T)
dbk = (kn.T*S*db - db*S*kn.T)*Sv
gv = -rspvec.tovec(cmo.T*S*(dak+Sg*dbk)*S*cmo, ifc)
return gv
def e2n(N, tmpdir='/tmp', hfx=1, Sg=1, Sv=1):
"""
E[2]*N linear transformation:
[k,F] = [k(pq)E(Sv)(pq), F(rs)E(rs)]
= k(pq)F(rs) (E(ps)d(rq) - E(rq)d(ps))
= k(pq)F(ps)E(ps) - k(pq)F(rp)E(rq)
= [k,F](pq)E(pq)
= kF
<[q,kF]> = <[E_{pq}, kF(rs)E(rs)]>
= kF(rs) <E(ps)d(rq) - E(rq)d(ps)>
= kF(qs)D(ps) - kF(rp)D(rq)
= [D, kF.T](pq)
kD = <[k, E(pq)]>
= <[k(rs) E(rs), E(pq)]>
= k(rs) (E(rq)d(ps) - E(ps)d(rq))
= k(rp)D(rq) - k(qs)D(ps)
= [k.T, D](p,q)
Fk = F[kD]
"""
SIRIFC = os.path.join(tmpdir, 'SIRIFC')
AOONEINT = os.path.join(tmpdir, 'AOONEINT')
AOTWOINT = os.path.join(tmpdir, 'AOTWOINT')
LUINDF = os.path.join(tmpdir, 'LUINDF')
ifc = sirifc.sirifc(SIRIFC)
cmo = get_cmo(AOONEINT, SIRIFC)
h = one.read('ONEHAMIL', filename=AOONEINT).unblock().unpack()
S = one.read('OVERLAP', filename=AOONEINT).unblock().unpack().view(util.full.matrix)
da, db = get_densities(SIRIFC)
kN = rspvec.tomat(N, ifc, tmpdir=tmpdir).view(util.full.matrix).T
kn = (cmo*kN*cmo.T).view(util.full.matrix)
dak = (kn.T*S*da - da*S*kn.T)
dbk = (kn.T*S*db - db*S*kn.T)*Sv
(fa, fb), = two.fockab((da, db), filename=AOTWOINT, hfx=hfx)
fa += h; fb += h
(fak, fbk), = two.fockab((dak, dbk), filename=AOTWOINT, hfx=hfx)
kfa = (S*kn*fa - fa*kn*S)
kfb = (S*kn*fb - fb*kn*S)*Sv
fa = fak + kfa
fb = fbk + kfb
gao = S*(da*fa.T + Sg*db*fb.T) - (fa.T*da + Sg*fb.T*db)*S
gm = cmo.T*gao*cmo
# sign convention <[q,[k,F]]> = -E[2]*N
gv = - rspvec.tovec(gm, ifc)
return gv
def __init__(self, tmpdir, **kwargs):
super().__init__(tmpdir, **kwargs)
#
# Dalton files
#
self.aooneint = os.path.join(tmpdir, "AOONEINT")
self.dalton_bas = os.path.join(tmpdir, "DALTON.BAS")
self.sirifc = os.path.join(tmpdir, "SIRIFC")
assert sirifc.sirifc(name=self.sirifc).nsym == 1
self.get_basis_info()
self.get_molecule_info()
def main(*args, **kwargs):
labs = args
tmpdir = kwargs.get("tmpdir", ".")
ranks = kwargs.get('rank', (0, 0, 0))
pars = [ (-1)**r for r in ranks]
ifc = sirifc.sirifc(os.path.join(tmpdir, "SIRIFC"))
cmo = ifc.cmo.unblock()
AOONEINT = os.path.join(tmpdir, "AOONEINT")
AOPROPER = os.path.join(tmpdir, "AOPROPER")
RSPVEC = os.path.join(tmpdir, "RSPVEC")
vecs = rspvec.read(*labs, propfile=RSPVEC)[0]
kappa = [rspvec.tomat(vec, ifc).T for vec in vecs]
kappa[0] = kappa[0].T
a, b, c = [cmo.T*x*cmo for x in prop.read(*labs, filename=AOPROPER)]
NA = vecs[0]
kA, kB, kC = kappa
pA, pB, pC = [{ "lab":lab, "rank":rank, 'kappa':k} for lab, rank, k in zip(labs, ranks, kappa)]
da, db = dens.Dab(ifc_=ifc)
d = da + db
S = one.read(label = "OVERLAP", filename = AOONEINT).unblock().unpack()
D = cmo.T*S*d*S*cmo
E3BC = E3(pB, pC, ifc, tmpdir=tmpdir)
AE3BC = -NA&E3BC
B2C = (-(kA^(kC^b))&D)
C2B = (-(kA^(kB^c))&D)
A2B = (.5*(kC^(kB^a))&D)
A2C = (.5*(kB^(kC^a))&D)
#print "E3BC",E3BC
val = AE3BC
print("E3 %14.8f %14.8f" % (AE3BC, val))
val += B2C
print("B2C %14.8f %14.8f" % (B2C, val))
val += C2B
print("C2B %14.8f %14.8f" % (C2B, val))
val += A2B
print("A2B %14.8f %14.8f" % (A2B, val))
val += A2C
print("A2C %14.8f %14.8f" % (A2C, val))
return val
def setUp(self):
n, e = os.path.splitext(__file__)
self.suppdir = n + ".d"
self.A = "XDIPLEN"
self.B = "YDIPLEN"
self.C = "XDIPLEN"
AOONEINT = os.path.join(self.suppdir, 'AOONEINT')
S = one.read(label="OVERLAP", filename=AOONEINT).unblock().unpack()
SIRIFC = os.path.join(self.suppdir, 'SIRIFC')
self.ifc = sirifc.sirifc(SIRIFC)
cmo = self.ifc.cmo.unblock()
da, db = dens.Dab(ifc_=self.ifc)
self.D = cmo.T * S * (da + db) * S * cmo
RSPVEC = os.path.join(self.suppdir, 'RSPVEC')
rspvecs = rspvec.read(self.A, self.B, self.C, propfile=RSPVEC)
self.NA = rspvecs[(self.A, 0)]
self.NB = rspvecs[(self.B, 0)]
self.NC = rspvecs[(self.C, 0)]
self.kA = rspvec.tomat(self.NA, self.ifc, tmpdir=self.suppdir)
self.kB = rspvec.tomat(self.NB, self.ifc, tmpdir=self.suppdir).T
self.kC = rspvec.tomat(self.NC, self.ifc, tmpdir=self.suppdir).T
AOPROPER = os.path.join(self.suppdir, 'AOPROPER')
#a, b, c = [cmo.T*x*cmo for x in prop.read(A, B, C, filename=AOPROPER, unpack=True)]
global pmat
pmat = prop.read(self.A,
self.B,
self.C,
filename=AOPROPER,
unpack=True)
self.a, self.b, self.c = [cmo.T * x * cmo for x in pmat]
def a2bc(A, B, C):
AOONEINT = os.path.join(tmp, "AOONEINT")
AOPROPER = os.path.join(tmp, "AOPROPER")
RSPVEC = os.path.join(tmp, "RSPVEC")
SIRIFC = os.path.join(tmp, "SIRIFC")
NB = rspvec.read(B, RSPVEC)
NC = rspvec.read(C, RSPVEC)
ifc = sirifc.sirifc(SIRIFC)
cmo = ifc.cmo.unblock()
dc,do = dens.ifc(ifc=ifc)
d = dc+do
a = cmo.T*prop.read(A, AOPROPER).unpack()*cmo
kB = rspvec.tomat(NB, ifc, tmpdir = tmp).T
kC = rspvec.tomat(NC, ifc, tmpdir = tmp).T
S = one.read(label = "OVERLAP", filename = AOONEINT).unblock().unpack()
D = cmo.T*S*d*S*cmo
A2B = (.5*(kC^(kB^a))&D)
A2C = (.5*(kB^(kC^a))&D)
return A2B + A2C
def __init__(
self, tmpdir, max_l=0, pol=0, freqs=None, pf=penalty_function, sf=shift_function, gc=None,
damping=False, real_pol=False, imag_pol=False
):
"""Constructur of MolFrac class objects
input: tmpdir, scratch directory of Dalton calculation
"""
self.max_l = max_l
self.pol = pol
self.tmpdir = tmpdir
if freqs is None:
self.freqs = (0,)
self.nfreqs = 1
else:
self.freqs = freqs
self.nfreqs = len(freqs)
self.rfreqs = range(self.nfreqs)
self.damping = damping
self._real_pol = real_pol
self._imag_pol = imag_pol
self.pf = pf
self.sf = sf
self.gc = gc
#
# Dalton files
#
self.aooneint = os.path.join(tmpdir,'AOONEINT')
self.dalton_bas = os.path.join(tmpdir,'DALTON.BAS')
self.sirifc = os.path.join(tmpdir,'SIRIFC')
assert sirifc.sirifc(name=self.sirifc).nsym == 1
self._T = None
self._D = None
self._Dk = None
self._D2k = None
self.get_basis_info()
self.get_isordk()
self._x = None
self._Rc = None
self._Qab = None
self._Da = None
self._Dab = None
self._Dsym = None
self._QUab = None
self._QUa = None
self._QUsym = None
self._QUN = None
self._QUc = None
self._dQa = None
self._d2Qa = None
self._dQab = None
self._d2Qab = None
self._Fab = None
self._la = None
self._l2a = None
self._Aab = None
self._Bab = None
self._Am = None
self._Bm = None
self._dAab = None
self._dBab = None
def get_cmo(AOONEINT, SIRIFC):
ifc = sirifc.sirifc(SIRIFC).cmo.unblock()
return ifc.view(util.full.matrix)
def setup(self):
self.tmpdir = tmpdir(__file__)
self.ifc = sirifc.sirifc(self.tmpdir / "SIRIFC")
def test_wrong_file_header(self):
with raises(RuntimeError):
sirifc.sirifc(name=self.tmpdir / "AOONEINT")
def test_raise_exception_if_symmetry(self):
nsym = sirifc.sirifc(name=os.path.join(self.tmpdir, "SIRIFC")).nsym
self.assertRaises(AssertionError, MolFrag, self.tmpdir)
def setup(self):
self.tmpdir = tmpdir(__file__)
self.RSPVEC = self.tmpdir/"RSPVEC"
self.SIRIFC = self.tmpdir/"SIRIFC"
self.E3VEC = self.tmpdir/"E3VEC"
self.ifc = sirifc.sirifc(name=self.SIRIFC)
def calculate_uhf(
dalton_tmpdir,
hamiltonian=None,
spin=None,
operator_label=None,
operator=None,
source_moenergies=None,
source_mocoeffs=None,
source_operator=None,
):
if operator_label:
# TODO add dipvel
assert operator_label in ("dipole", "angmom", "spinorb")
assert source_moenergies in ("pyscf", "dalton")
assert source_mocoeffs in ("pyscf", "dalton")
dalton_molecule = dalmol.readin(dalton_tmpdir / "DALTON.BAS")
lines = []
for atom in dalton_molecule:
label = atom["label"][0]
center = atom["center"][0]
center_str = " ".join(["{:f}".format(pos) for pos in center])
line = "{:3} {}".format(label, center_str)
lines.append(line)
lines = "\n".join(lines)
# PySCF molecule setup, needed for generating the TEIs in the MO
# basis.
mol = pyscf.gto.Mole()
verbose = 1
mol.verbose = verbose
mol.atom = lines
mol.unit = "Bohr"
# TODO read basis from DALTON molecule
mol.basis = "sto-3g"
mol.symmetry = False
# TODO read charge from DALTON molecule?
mol.charge = 1
# TODO read spin from DALTON molecule?
mol.spin = 1
mol.build()
ifc = sirifc.sirifc(dalton_tmpdir / "SIRIFC")
occupations = utils.occupations_from_sirifc(ifc)
if source_moenergies == "pyscf" or source_mocoeffs == "pyscf":
mf = pyscf.scf.UHF(mol)
mf.kernel()
if source_moenergies == "pyscf":
E_alph = np.diag(mf.mo_energy[0])
E_beta = np.diag(mf.mo_energy[1])
E = np.stack((E_alph, E_beta), axis=0)
elif source_moenergies == "dalton":
job = ccopen(dalton_tmpdir / "DALTON.OUT")
data = job.parse()
# pylint: disable=no-member
E = np.diag([
convertor(x, "eV", "hartree") for x in data.moenergies[0]
])[np.newaxis, ...]
E = np.concatenate((E, E), axis=0)
else:
pass
if source_mocoeffs == "pyscf":
C = mf.mo_coeff
elif source_mocoeffs == "dalton":
C = ifc.cmo[0][np.newaxis, ...]
C = np.concatenate((C, C), axis=0)
else:
pass
solver = iterators.ExactInv(C, E, occupations)
solver.tei_mo = ao2mo.perform_tei_ao2mo_uhf_partial(mol, C)
solver.tei_mo_type = "partial"
driver = cphf.CPHF(solver)
if operator:
driver.add_operator(operator)
elif operator_label:
if operator_label == "dipole":
operator_dipole = operators.Operator(label="dipole",
is_imaginary=False,
is_spin_dependent=False,
triplet=False)
integrals_dipole_ao = mol.intor("cint1e_r_sph", comp=3)
operator_dipole.ao_integrals = integrals_dipole_ao
driver.add_operator(operator_dipole)
elif operator_label == "angmom":
operator_angmom = operators.Operator(label="angmom",
is_imaginary=True,
is_spin_dependent=False,
triplet=False)
integrals_angmom_ao = mol.intor("cint1e_cg_irxp_sph", comp=3)
operator_angmom.ao_integrals = integrals_angmom_ao
driver.add_operator(operator_angmom)
elif operator_label == "spinorb":
operator_spinorb = operators.Operator(label="spinorb",
is_imaginary=True,
is_spin_dependent=False,
triplet=False)
integrals_spinorb_ao = 0
for atm_id in range(mol.natm):
mol.set_rinv_orig(mol.atom_coord(atm_id))
chg = mol.atom_charge(atm_id)
integrals_spinorb_ao += chg * mol.intor("cint1e_prinvxp_sph",
comp=3)
operator_spinorb.ao_integrals = integrals_spinorb_ao
driver.add_operator(operator_spinorb)
else:
pass
else:
pass
driver.set_frequencies()
driver.run(solver_type="exact", hamiltonian=hamiltonian, spin=spin)
return driver.results[0]
