pyscf 2.6.2__py3-none-macosx_11_0_arm64.whl → 2.8.0__py3-none-macosx_11_0_arm64.whl

pyscf/tdscf/uks.py

@@ -21,9 +21,8 @@ import numpy
 from pyscf import symm
 from pyscf import lib
 from pyscf.lib import logger
-from pyscf.tdscf import uhf
-from pyscf.scf import uhf_symm
-from pyscf.data import nist
+from pyscf.tdscf import uhf, rhf
+from pyscf.tdscf._lr_eig import eigh as lr_eigh
 from pyscf.dft.rks import KohnShamDFT
 from pyscf import __config__
 
@@ -46,6 +45,7 @@ class CasidaTDDFT(TDDFT, TDA):
     '''
 
     init_guess = TDA.init_guess
+    get_precond = TDA.get_precond
 
     def gen_vind(self, mf=None):
         if mf is None:
@@ -74,13 +74,9 @@ class CasidaTDDFT(TDDFT, TDA):
         if wfnsym is not None and mol.symmetry:
             if isinstance(wfnsym, str):
                 wfnsym = symm.irrep_name2id(mol.groupname, wfnsym)
-            orbsyma, orbsymb = uhf_symm.get_orbsym(mol, mo_coeff)
             wfnsym = wfnsym % 10  # convert to D2h subgroup
-            orbsyma_in_d2h = numpy.asarray(orbsyma) % 10
-            orbsymb_in_d2h = numpy.asarray(orbsymb) % 10
-            sym_forbida = (orbsyma_in_d2h[occidxa,None] ^ orbsyma_in_d2h[viridxa]) != wfnsym
-            sym_forbidb = (orbsymb_in_d2h[occidxb,None] ^ orbsymb_in_d2h[viridxb]) != wfnsym
-            sym_forbid = numpy.hstack((sym_forbida.ravel(), sym_forbidb.ravel()))
+            x_sym_a, x_sym_b = uhf._get_x_sym_table(mf)
+            sym_forbid = numpy.append(x_sym_a.ravel(), x_sym_b.ravel()) != wfnsym
 
         e_ia_a = (mo_energy[0][viridxa,None] - mo_energy[0][occidxa]).T
         e_ia_b = (mo_energy[1][viridxb,None] - mo_energy[1][occidxb]).T
@@ -102,15 +98,15 @@ class CasidaTDDFT(TDDFT, TDA):
 
             dmsa = (zs[:,:nocca*nvira] * d_ia[:nocca*nvira]).reshape(nz,nocca,nvira)
             dmsb = (zs[:,nocca*nvira:] * d_ia[nocca*nvira:]).reshape(nz,noccb,nvirb)
-            dmsa = lib.einsum('xov,po,qv->xpq', dmsa, orboa, orbva.conj())
-            dmsb = lib.einsum('xov,po,qv->xpq', dmsb, orbob, orbvb.conj())
-            dmsa = dmsa + dmsa.conj().transpose(0,2,1)
-            dmsb = dmsb + dmsb.conj().transpose(0,2,1)
+            dmsa = lib.einsum('xov,pv,qo->xpq', dmsa, orbva, orboa)
+            dmsb = lib.einsum('xov,pv,qo->xpq', dmsb, orbvb, orbob)
+            dmsa = dmsa + dmsa.transpose(0,2,1)
+            dmsb = dmsb + dmsb.transpose(0,2,1)
 
             v1ao = vresp(numpy.asarray((dmsa,dmsb)))
 
-            v1a = lib.einsum('xpq,po,qv->xov', v1ao[0], orboa.conj(), orbva)
-            v1b = lib.einsum('xpq,po,qv->xov', v1ao[1], orbob.conj(), orbvb)
+            v1a = lib.einsum('xpq,qo,pv->xov', v1ao[0], orboa, orbva)
+            v1b = lib.einsum('xpq,qo,pv->xov', v1ao[1], orbob, orbvb)
 
             hx = numpy.hstack((v1a.reshape(nz,-1), v1b.reshape(nz,-1)))
             hx += ed_ia * zs
@@ -123,6 +119,7 @@ class CasidaTDDFT(TDDFT, TDA):
         '''TDDFT diagonalization solver
         '''
         cpu0 = (logger.process_clock(), logger.perf_counter())
+        mol = self.mol
         mf = self._scf
         if mf._numint.libxc.is_hybrid_xc(mf.xc):
             raise RuntimeError('%s cannot be used with hybrid functional'
@@ -142,16 +139,19 @@ class CasidaTDDFT(TDDFT, TDA):
             idx = numpy.where(w > self.positive_eig_threshold)[0]
             return w[idx], v[:,idx], idx
 
+        x0sym = None
         if x0 is None:
-            x0 = self.init_guess(self._scf, self.nstates)
-
-        self.converged, w2, x1 = \
-                lib.davidson1(vind, x0, precond,
-                              tol=self.conv_tol,
-                              nroots=nstates, lindep=self.lindep,
-                              max_cycle=self.max_cycle,
-                              max_space=self.max_space, pick=pickeig,
-                              verbose=log)
+            x0, x0sym = self.init_guess(
+                self._scf, self.nstates, return_symmetry=True)
+        elif mol.symmetry:
+            x_sym_a, x_sym_b = uhf._get_x_sym_table(self._scf)
+            x_sym = numpy.append(x_sym_a.ravel(), x_sym_b.ravel())
+            x0sym = [rhf._guess_wfnsym_id(self, x_sym, x) for x in x0]
+
+        self.converged, w2, x1 = lr_eigh(
+            vind, x0, precond, tol_residual=self.conv_tol, lindep=self.lindep,
+            nroots=nstates, x0sym=x0sym, pick=pickeig, max_cycle=self.max_cycle,
+            max_memory=self.max_memory, verbose=log)
 
         mo_energy = self._scf.mo_energy
         mo_occ = self._scf.mo_occ
@@ -179,13 +179,14 @@ class CasidaTDDFT(TDDFT, TDA):
             x = (zp + zm) * .5
             y = (zp - zm) * .5
             norm = lib.norm(x)**2 - lib.norm(y)**2
-            if norm > 0:
-                norm = 1/numpy.sqrt(norm)
-                e.append(w)
-                xy.append(((x[:nocca*nvira].reshape(nocca,nvira) * norm,  # X_alpha
-                            x[nocca*nvira:].reshape(noccb,nvirb) * norm), # X_beta
-                           (y[:nocca*nvira].reshape(nocca,nvira) * norm,  # Y_alpha
-                            y[nocca*nvira:].reshape(noccb,nvirb) * norm)))# Y_beta
+            if norm < 0:
+                log.warn('TDDFT amplitudes |X| smaller than |Y|')
+            norm = abs(norm)**-.5
+            e.append(w)
+            xy.append(((x[:nocca*nvira].reshape(nocca,nvira) * norm,  # X_alpha
+                        x[nocca*nvira:].reshape(noccb,nvirb) * norm), # X_beta
+                       (y[:nocca*nvira].reshape(nocca,nvira) * norm,  # Y_alpha
+                        y[nocca*nvira:].reshape(noccb,nvirb) * norm)))# Y_beta
         self.e = numpy.array(e)
         self.xy = xy
 

pyscf/tools/fcidump.py

@@ -372,6 +372,9 @@ def to_scf(filename, molpro_orbsym=MOLPRO_ORBSYM, mf=None, **kwargs):
     mf.get_hcore = lambda *args: h1
     mf.get_ovlp = lambda *args: numpy.eye(norb)
     mf._eri = ctx['H2']
+    intor_symmetric = mf.mol.intor_symmetric
+    mf.mol.intor_symmetric = lambda intor, **kwargs: numpy.eye(norb) \
+        if intor == 'int1e_ovlp' else intor_symmetric(intor, **kwargs)
 
     return mf
 

pyscf/tools/qcschema.py

@@ -0,0 +1,265 @@
+'''
+This lib loads results that are in a QCSchema format json.
+Funcs below can recreate the mol and scf objects from the info in the json.
+'''
+import json
+import numpy as np
+import pyscf
+from pyscf.lib.parameters import BOHR
+
+def load_qcschema_json( file_name ):
+    '''
+    Does: loads qcschema format json into a dictionary
+    Input:
+        file_name: qcschema format json file
+
+    Returns: dict in qcschema format
+    '''
+    # load qcschema output json file
+    data = None
+    with open(file_name,'r') as f:
+        data = json.load(f)
+    return data
+
+def load_qcschema_go_final_json( file_name ):
+    '''
+    Does: loads qcschema format geometry optimization json
+          and returns only the optimized 'final' geometry
+          qcschema info as a dictionary.
+
+    Input:
+        file_name: qcschema format json file
+
+    Returns: dict in qcschema format
+    '''
+    # load qcschema GO output json file
+    # and return last 'trajectory' point's entries
+    # (this is the optimized molecule)
+    data = None
+    temp = None
+    with open(file_name,'r') as f:
+        temp = json.load(f)
+    data = temp["trajectory"][-1]
+    return data
+
+def load_qcschema_molecule(qcschema_dict, to_Angstrom=False, xyz=False, mol_select=1, step=0):
+    '''
+    Does: Loads molecule from qcschema format dict.
+          Molecule may be single point molecule or from a geometry optimization/trajectory.
+
+    Input:
+        syms: atom symbols (qcschema format)
+        coords: x y z coordinates (in qcschema format)
+        mol_select: specifies which molecule to load from qcschema format results.
+                    Default loads 'molecule' from qcschema.
+                    Geometry optimizations or trajectories have mutliple geometries saved in the schema.
+                    mol_select = 1 (default) molecule from standard qcschema format
+                               = 2 initial_molecule in GO or traj qcschema
+                               = 3 final_molecule in GO or traj qcschema
+                               = 4 a specific step in the GO or traj qcschema, specify with 'step' arg.
+        step: for geometry optimization or trajectory, which have multiple molecules in a qcschema output.
+              This specifies which step to load the molecule from.
+        to_Angstrom (optional): convert coordinates to Angstrom (default is Bohr)
+        xyz (optional): controls output (see below)
+
+    Returns:
+        xyz=False (default): 'atom x y z' format string
+        xyz=True: output a string in xyz file format
+                  i.e. first line is number of atoms.
+    '''
+    if(mol_select == 1):
+        syms = np.array(qcschema_dict["molecule"]["symbols"])
+        geo = np.array(qcschema_dict["molecule"]["geometry"])
+    elif(mol_select == 2):
+        syms = np.array(qcschema_dict["initial_molecule"]["symbols"])
+        geo = np.array(qcschema_dict["initial_molecule"]["geometry"])
+    elif(mol_select == 3):
+        syms = np.array(qcschema_dict["final_molecule"]["symbols"])
+        geo = np.array(qcschema_dict["final_molecule"]["geometry"])
+    elif(mol_select == 4):
+        # for geometry or md, can load a specific geometry
+        syms = np.array(qcschema_dict["trajectory"][step]["molecule"]["symbols"])
+        geo = np.array(qcschema_dict["trajectory"][step]["molecule"]["geometry"])
+
+    if(to_Angstrom):
+        # convert Bohr to Angstrom
+        geo = geo*BOHR
+
+    NAtoms = len(syms)
+    geo = np.reshape(geo, (NAtoms,3))
+
+    PySCF_atoms = list(zip(syms, geo))
+
+    # Return as string or return as xyz-format string (i.e. top is NAtoms,blankline)
+    if(xyz):
+        bldstr = f'{NAtoms}\n\n'
+        for element, coordinates in PySCF_atoms:
+            bldstr += f'{element} {coordinates[0]}, {coordinates[1]}, {coordinates[2]}\n'
+            PySCF_atoms = bldstr
+    return PySCF_atoms
+
+def load_qcschema_hessian(qcschema_dict):
+    '''
+    Does: loads hessian from qcschema format dictionary
+    Input:
+        qcschema_dict
+
+    Returns: hessian with format (N,N,3,3)
+    '''
+    # qcschema_dict: pass in dict that has the qcschema output json loaded into it
+
+    # load qcschema hessian
+    qc_h = []
+    qc_h = qcschema_dict["return_result"]
+
+    # Get Number of atoms N
+    syms = np.array(qcschema_dict["molecule"]["symbols"])
+    NAtom = len(syms)
+
+    # reshape from (3N)**2 array to (N,N,3,3)
+    hessian = np.array(qc_h).reshape(NAtom,NAtom,3,3)
+    return hessian
+
+def load_qcschema_scf_info(qcschema_dict):
+    '''
+    Does: loads scf info from qcschema format dictionary
+    Input:
+        qcschema_dict
+
+    Returns:
+        scf_dict: contains the relevent scf info only
+    '''
+
+    # Restricted wfn has schema scf_occupations_a occ of 1 or 0.
+    # Need to double if rhf/rks/rohf
+    method = qcschema_dict["keywords"]["scf"]["method"]
+    if(method == 'rks' or method == 'roks' or method == 'rhf' or method == 'rohf'):
+        OccFactor = 2.0
+        have_beta = False
+    elif(method == 'uks' or method == 'uhf'):
+        OccFactor = 1.0
+        have_beta = True
+    elif(method == 'gks' or method == 'ghf'):
+        OccFactor = 1.0
+        have_beta = False
+    else:
+        raise RuntimeError('qcschema: cannot determine method..exit')
+        return
+
+    # need to reshape MO coefficients for PySCF shape.
+    nao = qcschema_dict["properties"]["calcinfo_nbasis"]
+    # nmo info often missing
+    try:
+        nmo = qcschema_dict["properties"]["calcinfo_nmo"]
+    except KeyError:
+        # key not provided..so we make an assumption
+        # note: assumes nmo=nao which isn't the case if linear dependencies etc.
+        # ..so may give error when reading coeffs
+        nmo = nao
+    assert nmo == nao
+
+    # get the 4 things that PySCF wants
+    # ...remembering to reshape coeffs and scale occupancies.
+    e_tot = float( qcschema_dict["properties"]["return_energy"] )
+    mo_coeff = np.reshape(qcschema_dict["wavefunction"]["scf_orbitals_a"],(nao,nmo))
+    mo_occ = np.array( qcschema_dict["wavefunction"]["scf_occupations_a"] )*OccFactor
+    mo_energy = np.array( qcschema_dict["wavefunction"]["scf_eigenvalues_a"] )
+    if(have_beta):
+        # for each useful piece of info we need to combine alpha and beta into 2d array, with alpha first
+        # MO occupations
+        mo_occ_beta = qcschema_dict["wavefunction"]["scf_occupations_b"]
+        mo_occ = np.vstack( (mo_occ, mo_occ_beta) )
+        # MO coefficients
+        mo_coeff_beta = np.reshape(qcschema_dict["wavefunction"]["scf_orbitals_b"],(nao,nmo))
+        mo_coeff = np.vstack( (mo_coeff,mo_coeff_beta))
+        mo_coeff = np.reshape(mo_coeff,(2,nao,nmo))
+        # MO energies
+        mo_energy_beta = np.array( qcschema_dict["wavefunction"]["scf_eigenvalues_b"] )
+        mo_energy = np.vstack( (mo_energy, mo_energy_beta) )
+        # etot obviously doesn't need manipulation
+
+    # convert to dictionary for PySCF
+    scf_dic = {'e_tot'    : e_tot,
+               'mo_energy': mo_energy,
+               'mo_occ'   : mo_occ,
+               'mo_coeff' : mo_coeff}
+
+    return scf_dic
+
+
+def recreate_mol_obj(qcschema_dict,to_Angstrom=False):
+    '''
+    Does: recreates mol object from qcschema format dictionary
+    Input:
+        qcschema_dict
+        to_Angstrom: optional bool to convert geometry to Angstrom (default is Bohr)
+
+    Returns: mol object
+    '''
+
+    ## Mol info: ##
+    PySCF_charge = int( qcschema_dict["molecule"]["molecular_charge"] )
+    # PySCF 'spin' is number of unpaired electrons, it will be mult-1
+    PySCF_spin = int( qcschema_dict["molecule"]["molecular_multiplicity"] ) - 1
+    PySCF_basis = str( qcschema_dict["model"]["basis"] )
+
+    # Cartesian/Pure basis
+    PySCF_cart = bool( qcschema_dict["keywords"]["basisSet"]["cartesian"] )
+
+    # Get molecular structure.
+    PySCF_atoms = load_qcschema_molecule(qcschema_dict, to_Angstrom,False)
+
+    # Unit Bohr or Angstrom. QCSchema default is Bohr but can change here.
+    if(to_Angstrom):
+        units='A'
+    else:
+        units='B'
+
+    ## Create mol ##
+    mol = pyscf.gto.Mole(atom=PySCF_atoms,basis=PySCF_basis,ecp=PySCF_basis,
+                         charge=PySCF_charge,spin=PySCF_spin,cart=PySCF_cart,unit=units)
+    mol.build(False,False)
+
+    return mol
+
+def recreate_scf_obj(qcschema_dict,mol):
+    '''
+    Does: recreates scf object from qcschema format dictionary
+    Input:
+        qcschema_dict
+        mol object
+
+    Returns: scf object
+    '''
+    # load info from qcschema needed for scf obj
+    scf_dict = load_qcschema_scf_info(qcschema_dict)
+
+    # create scf object
+    method =  qcschema_dict["keywords"]["scf"]["method"]
+    if(method =='rks'):
+        ks = mol.RKS()
+    elif(method =='uks'):
+        ks = mol.UKS()
+    elif(method =='rhf'):
+        ks = mol.RHF()
+    elif(method =='uhf'):
+        ks = mol.UHF()
+    elif(method =='gks'):
+        ks = mol.GKS()
+    elif(method =='ghf'):
+        ks = mol.GHF()
+    else:
+        raise RuntimeError('qcschema: cannot determine method..exit')
+        return
+
+    # get functional
+    if(method == 'rks' or method == 'uks' or method == 'gks'):
+        functional = qcschema_dict["keywords"]["xcFunctional"]["name"]
+        ks.xc = functional
+
+    # Load 4 key pieces of info we got from json into SCF object
+    ks.mo_coeff = scf_dict["mo_coeff"]
+    ks.mo_energy = scf_dict["mo_energy"]
+    ks.mo_occ = scf_dict["mo_occ"]
+    ks.e_tot = scf_dict["e_tot"]
+    return ks

pyscf/x2c/sfx2c1e.py

@@ -117,7 +117,7 @@ class SFX2C1E_SCF(x2c._X2C_SCF):
         log = logger.new_logger(mol, verbose)
 
         if not (isinstance(dm, numpy.ndarray) and dm.ndim == 2):
-            # UHF denisty matrices
+            # UHF density matrices
             dm = dm[0] + dm[1]
 
         if isinstance(self, ghf.GHF):

pyscf/x2c/tdscf.py

@@ -38,8 +38,8 @@ gen_tda_hop = gen_tda_operation
 def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
     r'''A and B matrices for TDDFT response function.
 
-    A[i,a,j,b] = \delta_{ab}\delta_{ij}(E_a - E_i) + (ia||bj)
-    B[i,a,j,b] = (ia||jb)
+    A[i,a,j,b] = \delta_{ab}\delta_{ij}(E_a - E_i) + (ai||jb)
+    B[i,a,j,b] = (ai||bj)
     '''
     if mo_energy is None: mo_energy = mf.mo_energy
     if mo_coeff is None: mo_coeff = mf.mo_coeff
@@ -56,7 +56,7 @@ def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
     nmo = nocc + nvir
     mo = numpy.hstack((orbo, orbv))
 
-    e_ia = lib.direct_sum('a-i->ia', mo_energy[viridx], mo_energy[occidx])
+    e_ia = mo_energy[viridx] - mo_energy[occidx,None]
     a = numpy.diag(e_ia.ravel()).reshape(nocc,nvir,nocc,nvir)
     b = numpy.zeros_like(a)
 
@@ -64,10 +64,10 @@ def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
         eri_mo = ao2mo.kernel(mol, [orbo, mo, mo, mo], intor='int2e_spinor')
         eri_mo = eri_mo.reshape(nocc,nmo,nmo,nmo)
 
-        a = a + numpy.einsum('iabj->iajb', eri_mo[:nocc,nocc:,nocc:,:nocc])
-        a = a - numpy.einsum('ijba->iajb', eri_mo[:nocc,:nocc,nocc:,nocc:]) * hyb
-        b = b + numpy.einsum('iajb->iajb', eri_mo[:nocc,nocc:,:nocc,nocc:])
-        b = b - numpy.einsum('jaib->iajb', eri_mo[:nocc,nocc:,:nocc,nocc:]) * hyb
+        a = a + numpy.einsum('iabj->iajb', eri_mo[:nocc,nocc:,nocc:,:nocc].conj())
+        a = a - numpy.einsum('ijba->iajb', eri_mo[:nocc,:nocc,nocc:,nocc:].conj()) * hyb
+        b = b + numpy.einsum('iajb->iajb', eri_mo[:nocc,nocc:,:nocc,nocc:].conj())
+        b = b - numpy.einsum('jaib->iajb', eri_mo[:nocc,nocc:,:nocc,nocc:].conj()) * hyb
         return a, b
 
     if isinstance(mf, dft.KohnShamDFT):
@@ -123,9 +123,9 @@ def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
                     rho_ov_bb = numpy.einsum('ri,ra->ria', mo_ob.conj(), mo_vb)
                     rho_ov = ud2tm(rho_ov_aa, rho_ov_ab, rho_ov_ba, rho_ov_bb)
                     rho_vo = rho_ov.conj()
-                    w_ov = numpy.einsum('tsr,tria->sria', wfxc, rho_ov)
-                    a += lib.einsum('sria,srjb->iajb', w_ov, rho_vo)
-                    b += lib.einsum('sria,srjb->iajb', w_ov, rho_ov)
+                    w_vo = numpy.einsum('tsr,tria->sria', wfxc, rho_vo)
+                    a += lib.einsum('sria,srjb->iajb', w_vo, rho_ov)
+                    b += lib.einsum('sria,srjb->iajb', w_vo, rho_vo)
                 elif ni.collinear[0] == 'c':
                     rho = ni.eval_rho(mol, ao, dm0, mask, xctype, hermi=1)
                     fxc = ni.eval_xc_eff(mf.xc, rho, deriv=2)[2]
@@ -135,13 +135,13 @@ def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
                     rho_ov_b = numpy.einsum('ri,ra->ria', mo_ob.conj(), mo_vb)
                     rho_vo_a = rho_ov_a.conj()
                     rho_vo_b = rho_ov_b.conj()
-                    w_ov  = wv_a[:,:,None,None] * rho_ov_a
-                    w_ov += wv_b[:,:,None,None] * rho_ov_b
-                    wa_ov, wb_ov = w_ov
-                    a += lib.einsum('ria,rjb->iajb', wa_ov, rho_vo_a)
-                    a += lib.einsum('ria,rjb->iajb', wb_ov, rho_vo_b)
-                    b += lib.einsum('ria,rjb->iajb', wa_ov, rho_ov_a)
-                    b += lib.einsum('ria,rjb->iajb', wb_ov, rho_ov_b)
+                    w_vo  = wv_a[:,:,None,None] * rho_vo_a
+                    w_vo += wv_b[:,:,None,None] * rho_vo_b
+                    wa_vo, wb_vo = w_vo
+                    a += lib.einsum('ria,rjb->iajb', wa_vo, rho_ov_a)
+                    a += lib.einsum('ria,rjb->iajb', wb_vo, rho_ov_b)
+                    b += lib.einsum('ria,rjb->iajb', wa_vo, rho_vo_a)
+                    b += lib.einsum('ria,rjb->iajb', wb_vo, rho_vo_b)
                 else:
                     raise NotImplementedError(ni.collinear)
 
@@ -166,9 +166,9 @@ def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
                     rho_ov_bb[1:4] += numpy.einsum('xri,ra->xria', mo_ob[1:4].conj(), mo_vb[0])
                     rho_ov = ud2tm(rho_ov_aa, rho_ov_ab, rho_ov_ba, rho_ov_bb)
                     rho_vo = rho_ov.conj()
-                    w_ov = numpy.einsum('txsyr,txria->syria', wfxc, rho_ov)
-                    a += lib.einsum('syria,syrjb->iajb', w_ov, rho_vo)
-                    b += lib.einsum('syria,syrjb->iajb', w_ov, rho_ov)
+                    w_vo = numpy.einsum('txsyr,txria->syria', wfxc, rho_vo)
+                    a += lib.einsum('syria,syrjb->iajb', w_vo, rho_ov)
+                    b += lib.einsum('syria,syrjb->iajb', w_vo, rho_vo)
                 elif ni.collinear[0] == 'c':
                     rho = ni.eval_rho(mol, ao, dm0, mask, xctype, hermi=1)
                     fxc = ni.eval_xc_eff(mf.xc, rho, deriv=2)[2]
@@ -180,13 +180,13 @@ def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
                     rho_ov_b[1:4] += numpy.einsum('ri,xra->xria', mo_ob[0].conj(), mo_vb[1:4])
                     rho_vo_a = rho_ov_a.conj()
                     rho_vo_b = rho_ov_b.conj()
-                    w_ov  = numpy.einsum('xsyr,xria->syria', wv_a, rho_ov_a)
-                    w_ov += numpy.einsum('xsyr,xria->syria', wv_b, rho_ov_b)
-                    wa_ov, wb_ov = w_ov
-                    a += lib.einsum('xria,xrjb->iajb', wa_ov, rho_vo_a)
-                    a += lib.einsum('xria,xrjb->iajb', wb_ov, rho_vo_b)
-                    b += lib.einsum('xria,xrjb->iajb', wa_ov, rho_ov_a)
-                    b += lib.einsum('xria,xrjb->iajb', wb_ov, rho_ov_b)
+                    w_vo  = numpy.einsum('xsyr,xria->syria', wv_a, rho_vo_a)
+                    w_vo += numpy.einsum('xsyr,xria->syria', wv_b, rho_vo_b)
+                    wa_vo, wb_vo = w_vo
+                    a += lib.einsum('xria,xrjb->iajb', wa_vo, rho_ov_a)
+                    a += lib.einsum('xria,xrjb->iajb', wb_vo, rho_ov_b)
+                    b += lib.einsum('xria,xrjb->iajb', wa_vo, rho_vo_a)
+                    b += lib.einsum('xria,xrjb->iajb', wb_vo, rho_vo_b)
                 else:
                     raise NotImplementedError(ni.collinear)
 
@@ -225,9 +225,9 @@ def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
                     rho_ov_bb = numpy.vstack([rho_ov_bb, tau_ov_bb[numpy.newaxis]])
                     rho_ov = ud2tm(rho_ov_aa, rho_ov_ab, rho_ov_ba, rho_ov_bb)
                     rho_vo = rho_ov.conj()
-                    w_ov = numpy.einsum('txsyr,txria->syria', wfxc, rho_ov)
-                    a += lib.einsum('syria,syrjb->iajb', w_ov, rho_vo)
-                    b += lib.einsum('syria,syrjb->iajb', w_ov, rho_ov)
+                    w_vo = numpy.einsum('txsyr,txria->syria', wfxc, rho_vo)
+                    a += lib.einsum('syria,syrjb->iajb', w_vo, rho_ov)
+                    b += lib.einsum('syria,syrjb->iajb', w_vo, rho_vo)
                 elif ni.collinear[0] == 'c':
                     rho = ni.eval_rho(mol, ao, dm0, mask, xctype, hermi=1, with_lapl=False)
                     fxc = ni.eval_xc_eff(mf.xc, rho, deriv=2)[2]
@@ -243,13 +243,13 @@ def get_ab(mf, mo_energy=None, mo_coeff=None, mo_occ=None):
                     rho_ov_b = numpy.vstack([rho_ov_b, tau_ov_b[numpy.newaxis]])
                     rho_vo_a = rho_ov_a.conj()
                     rho_vo_b = rho_ov_b.conj()
-                    w_ov  = numpy.einsum('xsyr,xria->syria', wv_a, rho_ov_a)
-                    w_ov += numpy.einsum('xsyr,xria->syria', wv_b, rho_ov_b)
-                    wa_ov, wb_ov = w_ov
-                    a += lib.einsum('xria,xrjb->iajb', wa_ov, rho_vo_a)
-                    a += lib.einsum('xria,xrjb->iajb', wb_ov, rho_vo_b)
-                    b += lib.einsum('xria,xrjb->iajb', wa_ov, rho_ov_a)
-                    b += lib.einsum('xria,xrjb->iajb', wb_ov, rho_ov_b)
+                    w_vo  = numpy.einsum('xsyr,xria->syria', wv_a, rho_vo_a)
+                    w_vo += numpy.einsum('xsyr,xria->syria', wv_b, rho_vo_b)
+                    wa_vo, wb_vo = w_vo
+                    a += lib.einsum('xria,xrjb->iajb', wa_vo, rho_ov_a)
+                    a += lib.einsum('xria,xrjb->iajb', wb_vo, rho_ov_b)
+                    b += lib.einsum('xria,xrjb->iajb', wa_vo, rho_vo_a)
+                    b += lib.einsum('xria,xrjb->iajb', wb_vo, rho_vo_b)
                 else:
                     raise NotImplementedError(ni.collinear)
 
@@ -290,9 +290,9 @@ class TDA(TDBase, ghf.TDA):
             mf = self._scf
         return gen_tda_hop(mf)
 
-    def init_guess(self, mf, nstates=None, wfnsym=None):
+    def init_guess(self, mf, nstates=None, wfnsym=None, return_symmetry=False):
         assert self.wfnsym is None
-        return ghf.TDA.init_guess(self, mf, nstates, None)
+        return ghf.TDA.init_guess(self, mf, nstates, None, return_symmetry)
 
     kernel = ghf.TDA.kernel
 
@@ -313,9 +313,9 @@ class TDHF(TDBase, ghf.TDHF):
             mf = self._scf
         return gen_tdhf_operation(mf)
 
-    def init_guess(self, mf, nstates=None, wfnsym=None):
+    def init_guess(self, mf, nstates=None, wfnsym=None, return_symmetry=False):
         assert self.wfnsym is None
-        return ghf.TDHF.init_guess(self, mf, nstates, None)
+        return ghf.TDHF.init_guess(self, mf, nstates, None, return_symmetry)
 
     kernel = ghf.TDHF.kernel
 

pyscf/x2c/x2c.py

@@ -577,7 +577,7 @@ class SCF(hf.SCF):
         log = logger.new_logger(mol, verbose)
 
         if not (isinstance(dm, numpy.ndarray) and dm.ndim == 2):
-            # UHF denisty matrices
+            # UHF density matrices
             dm = dm[0] + dm[1]
 
         with mol.with_common_orig((0,0,0)):
@@ -774,17 +774,22 @@ class X2C1E_GSCF(_X2C_SCF):
         charges = mol.atom_charges()
         coords  = mol.atom_coords()
         nucl_dip = numpy.einsum('i,ix->x', charges, coords)
-        with mol.with_common_orig(nucl_dip):
-            r = mol.intor_symmetric('int1e_r')
-            ao_dip = numpy.array([_block_diag(x) for x in r])
+        with mol.with_common_orig((0,0,0)):
             if picture_change:
                 xmol = self.with_x2c.get_xmol()[0]
                 nao = xmol.nao
-                prp = xmol.intor_symmetric('int1e_sprsp').reshape(3,4,nao,nao)[:,0]
-                prp = numpy.array([_block_diag(x) for x in prp])
-                ao_dip = self.with_x2c.picture_change((ao_dip, prp))
+                r = xmol.intor_symmetric('int1e_r')
+                r = numpy.array([_block_diag(x) for x in r])
+                c1 = 0.5/lib.param.LIGHT_SPEED
+                prp = xmol.intor_symmetric('int1e_sprsp').reshape(3,4,nao,nao)
+                prp = numpy.array([_sigma_dot(x*c1**2) for x in prp])
+                ao_dip = self.with_x2c.picture_change((r, prp))
+            else:
+                r = mol.intor_symmetric('int1e_r')
+                ao_dip = numpy.array([_block_diag(x) for x in r])
 
-        mol_dip = -numpy.einsum('xij,ji->x', ao_dip, dm).real
+        el_dip = numpy.einsum('xij,ji->x', ao_dip, dm).real
+        mol_dip = nucl_dip - el_dip
 
         if unit.upper() == 'DEBYE':
             mol_dip *= nist.AU2DEBYE
@@ -810,8 +815,7 @@ class X2C1E_GSCF(_X2C_SCF):
 
 def _uncontract_mol(mol, xuncontract=None, exp_drop=0.2):
     '''mol._basis + uncontracted steep functions'''
-    pmol, contr_coeff = mol.decontract_basis(atoms=xuncontract)
-    contr_coeff = scipy.linalg.block_diag(*contr_coeff)
+    pmol, contr_coeff = mol.decontract_basis(atoms=xuncontract, aggregate=True)
     return pmol, contr_coeff
 
 
@@ -953,7 +957,7 @@ def _x2c1e_get_hcore(t, v, w, s, c):
 
     w, u = numpy.linalg.eigh(reduce(numpy.dot, (cl.T.conj(), s, cl)))
     idx = w > 1e-14
-    # Adopt (2) here becuase X is not appeared in Eq (2).
+    # Adopt (2) here because X is not appeared in Eq (2).
     # R[A] = u w^{1/2} u^+,  so R[A]^{-1} A^+ S in Eq (2) is
     r = reduce(numpy.dot, (u[:,idx]/numpy.sqrt(w[idx]), u[:,idx].T.conj(),
                            cl.T.conj(), s))