Esempio n. 1
0
def pyq1_dft(atomtuples=[(2, (0, 0, 0))],
             basis='6-31G**',
             maxit=10,
             xcname='SVWN'):
    from PyQuante import Ints, settings, Molecule
    from PyQuante.dft import getXC
    from PyQuante.MG2 import MG2 as MolecularGrid
    from PyQuante.LA2 import mkdens, geigh, trace2
    from PyQuante.Ints import getJ

    print("PyQ1 DFT run")
    atoms = Molecule('Pyq1', atomlist=atomtuples)

    bfs = Ints.getbasis(atoms, basis=basis)
    S, h, Ints = Ints.getints(bfs, atoms)

    nclosed, nopen = nel // 2, nel % 2
    assert nopen == 0
    enuke = atoms.get_enuke()

    grid_nrad = settings.DFTGridRadii
    grid_fineness = settings.DFTGridFineness

    gr = MolecularGrid(atoms, grid_nrad, grid_fineness)
    gr.set_bf_amps(bfs)

    orbe, orbs = geigh(h, S)
    eold = 0

    for i in range(maxit):
        D = mkdens(orbs, 0, nclosed)
        gr.setdens(D)

        J = getJ(Ints, D)

        Exc, Vxc = getXC(gr, nel, functional=xcname)

        F = h + 2 * J + Vxc
        orbe, orbs = geigh(F, S)

        Ej = 2 * trace2(D, J)
        Eone = 2 * trace2(D, h)
        energy = Eone + Ej + Exc + enuke

        print(i, energy, Eone, Ej, Exc, enuke)
        if np.isclose(energy, eold):
            break
        eold = energy
    return energy
Esempio n. 2
0
def pyq1_dft(atomtuples=[(2,(0,0,0))],basis = '6-31G**',maxit=10,
             xcname='SVWN'):
    from PyQuante import Ints,settings,Molecule
    from PyQuante.dft import getXC
    from PyQuante.MG2 import MG2 as MolecularGrid
    from PyQuante.LA2 import mkdens,geigh,trace2
    from PyQuante.Ints import getJ
    
    print ("PyQ1 DFT run")
    atoms = Molecule('Pyq1',atomlist=atomtuples)

    bfs = Ints.getbasis(atoms,basis=basis)
    S,h,Ints = Ints.getints(bfs,atoms)

    nclosed,nopen = nel//2,nel%2
    assert nopen==0
    enuke = atoms.get_enuke()

    grid_nrad = settings.DFTGridRadii
    grid_fineness = settings.DFTGridFineness

    gr = MolecularGrid(atoms,grid_nrad,grid_fineness) 
    gr.set_bf_amps(bfs)

    orbe,orbs = geigh(h,S)
    eold = 0

    for i in range(maxit):
        D = mkdens(orbs,0,nclosed)
        gr.setdens(D)

        J = getJ(Ints,D)

        Exc,Vxc = getXC(gr,nel,functional=xcname)

        F = h+2*J+Vxc
        orbe,orbs = geigh(F,S)
        
        Ej = 2*trace2(D,J)
        Eone = 2*trace2(D,h)
        energy = Eone + Ej + Exc + enuke
        
        print (i,energy,Eone,Ej,Exc,enuke)
        if np.isclose(energy,eold):
            break
        eold = energy
    return energy
Esempio n. 3
0
 def setup_grid(self, molecule, bfs, **kwargs):
     #from PyQuante.MolecularGrid import MolecularGrid
     from PyQuante.MG2 import MG2 as MolecularGrid
     grid_nrad = kwargs.get('grid_nrad', settings.DFTGridRadii)
     grid_fineness = kwargs.get('grid_fineness', settings.DFTGridFineness)
     self.gr = MolecularGrid(molecule, grid_nrad, grid_fineness, **kwargs)
     self.gr.set_bf_amps(bfs)
     return
Esempio n. 4
0
 def setup_grid(self, molecule, bfs, **opts):
     #from PyQuante.MolecularGrid import MolecularGrid
     from PyQuante.MG2 import MG2 as MolecularGrid
     grid_nrad = opts.get('grid_nrad', 32)
     grid_fineness = opts.get('grid_fineness', 1)
     self.gr = MolecularGrid(molecule, grid_nrad, grid_fineness, **opts)
     self.gr.set_bf_amps(bfs)
     return
Esempio n. 5
0
 def setup_grid(self,molecule,bfs,**kwargs):
     #from PyQuante.MolecularGrid import MolecularGrid
     from PyQuante.MG2 import MG2 as MolecularGrid
     grid_nrad = kwargs.get('grid_nrad',settings.DFTGridRadii)
     grid_fineness = kwargs.get('grid_fineness',settings.DFTGridFineness)
     self.gr = MolecularGrid(molecule,grid_nrad,grid_fineness,**kwargs) 
     self.gr.set_bf_amps(bfs)
     return
Esempio n. 6
0
 def setup_grid(self,molecule,bfs,**opts):
     #from PyQuante.MolecularGrid import MolecularGrid
     from PyQuante.MG2 import MG2 as MolecularGrid
     grid_nrad = opts.get('grid_nrad',32)
     grid_fineness = opts.get('grid_fineness',1)
     self.gr = MolecularGrid(molecule,grid_nrad,grid_fineness,**opts) 
     self.gr.set_bf_amps(bfs)
     return
Esempio n. 7
0
class DFTHamiltonian(AbstractHamiltonian):
    method = 'DFT'

    def __init__(self, molecule, **kwargs):
        from PyQuante.Convergence import DIIS
        from PyQuante.DFunctionals import need_gradients
        self.molecule = molecule
        logging.info("DFT calculation on system %s" % self.molecule.name)
        self.basis_set = BasisSet(molecule, **kwargs)
        self.integrals = Integrals(molecule, self.basis_set, **kwargs)
        self.iterator = SCFIterator()
        self.h = self.integrals.get_h()
        self.S = self.integrals.get_S()
        self.ERI = self.integrals.get_ERI()
        self.Enuke = molecule.get_enuke()
        self.nel = molecule.get_nel()
        self.F = self.h
        self.functional = kwargs.get('functional', settings.DFTFunctional)
        kwargs['do_grad_dens'] = need_gradients[self.functional]
        self.setup_grid(molecule, self.basis_set.get(), **kwargs)
        self.dmat = None
        self.entropy = None
        self.DoAveraging = kwargs.get('DoAveraging', settings.DFTAveraging)
        if self.DoAveraging:
            self.Averager = DIIS(self.S)
        nel = molecule.get_nel()
        nclosed, nopen = molecule.get_closedopen()
        logging.info("Nclosed/open = %d, %d" % (nclosed, nopen))
        self.solver = SolverFactory(nel, nclosed, nopen, self.S, **kwargs)
        return

    def __repr__(self):
        lstr = [
            'Hamiltonian constructed for method %s' % self.method,
            repr(self.molecule),
            repr(self.basis_set),
            repr(self.iterator)
        ]
        return '\n'.join(lstr)

    def get_energy(self):
        return self.energy

    def iterate(self, **kwargs):
        return self.iterator.iterate(self, **kwargs)

    def setup_grid(self, molecule, bfs, **kwargs):
        #from PyQuante.MolecularGrid import MolecularGrid
        from PyQuante.MG2 import MG2 as MolecularGrid
        grid_nrad = kwargs.get('grid_nrad', settings.DFTGridRadii)
        grid_fineness = kwargs.get('grid_fineness', settings.DFTGridFineness)
        self.gr = MolecularGrid(molecule, grid_nrad, grid_fineness, **kwargs)
        self.gr.set_bf_amps(bfs)
        return

    def update(self, **kwargs):
        from PyQuante.LA2 import trace2
        from PyQuante.Ints import getJ
        from PyQuante.dft import getXC

        #self.DoAveraging = kwargs.get('DoAveraging',True)
        #if self.DoAveraging:
        #    self.Averager = DIIS(self.S)

        if self.DoAveraging and self.dmat is not None:
            self.F = self.Averager.getF(self.F, self.dmat)
        self.dmat, self.entropy = self.solver.solve(self.F, **kwargs)
        D = self.dmat

        self.gr.setdens(D)
        self.J = getJ(self.ERI, D)
        self.Ej = 2 * trace2(D, self.J)

        self.Exc, self.XC = getXC(self.gr,
                                  self.nel,
                                  functional=self.functional)

        self.Eone = 2 * trace2(D, self.h)

        self.F = self.h + 2 * self.J + self.XC
        self.energy = self.Eone + self.Ej + self.Exc + self.Enuke + self.entropy
        return
Esempio n. 8
0
class DFTHamiltonian(AbstractHamiltonian):
    method='DFT'
    def __init__(self,molecule,**kwargs):
        from PyQuante.Convergence import DIIS
        from PyQuante.DFunctionals import need_gradients
        self.molecule = molecule
        logging.info("DFT calculation on system %s" % self.molecule.name)
        self.basis_set = BasisSet(molecule,**kwargs)
        self.integrals = Integrals(molecule,self.basis_set,**kwargs)
        self.iterator = SCFIterator()
        self.h = self.integrals.get_h()
        self.S = self.integrals.get_S()
        self.ERI = self.integrals.get_ERI()
        self.Enuke = molecule.get_enuke()
        self.nel = molecule.get_nel()
        self.F = self.h
        self.functional = kwargs.get('functional',settings.DFTFunctional)
        kwargs['do_grad_dens'] = need_gradients[self.functional]
        self.setup_grid(molecule,self.basis_set.get(),**kwargs)
        self.dmat = None
        self.entropy = None
        self.DoAveraging = kwargs.get('DoAveraging',settings.DFTAveraging)
        if self.DoAveraging:
            self.Averager = DIIS(self.S)
        nel = molecule.get_nel()
        nclosed,nopen = molecule.get_closedopen()
        logging.info("Nclosed/open = %d, %d" % (nclosed,nopen))
        self.solver = SolverFactory(nel,nclosed,nopen,self.S,**kwargs)
        return
        
    def __repr__(self):
        lstr = ['Hamiltonian constructed for method %s' % self.method,
                repr(self.molecule),
                repr(self.basis_set),
                repr(self.iterator)]
        return '\n'.join(lstr)

    def get_energy(self): return self.energy
    def iterate(self,**kwargs): return self.iterator.iterate(self,**kwargs)

    def setup_grid(self,molecule,bfs,**kwargs):
        #from PyQuante.MolecularGrid import MolecularGrid
        from PyQuante.MG2 import MG2 as MolecularGrid
        grid_nrad = kwargs.get('grid_nrad',settings.DFTGridRadii)
        grid_fineness = kwargs.get('grid_fineness',settings.DFTGridFineness)
        self.gr = MolecularGrid(molecule,grid_nrad,grid_fineness,**kwargs) 
        self.gr.set_bf_amps(bfs)
        return

    def update(self,**kwargs):
        from PyQuante.LA2 import trace2
        from PyQuante.Ints import getJ
        from PyQuante.dft import getXC

        #self.DoAveraging = kwargs.get('DoAveraging',True)
        #if self.DoAveraging:
        #    self.Averager = DIIS(self.S)

        if self.DoAveraging and self.dmat is not None:
            self.F = self.Averager.getF(self.F,self.dmat)
        self.dmat,self.entropy = self.solver.solve(self.F,**kwargs)
        D = self.dmat
        
        self.gr.setdens(D)
        self.J = getJ(self.ERI,D)
        self.Ej = 2*trace2(D,self.J)

        self.Exc,self.XC = getXC(self.gr,self.nel,
                                 functional=self.functional)

        self.Eone = 2*trace2(D,self.h)

        self.F = self.h+2*self.J+self.XC
        self.energy = self.Eone + self.Ej + self.Exc + self.Enuke + self.entropy
        return
Esempio n. 9
0
def gto_lda_inputs(bfs,atoms):
	grid_nrad = 32 # number of radial shells per atom
	grid_fineness = 1 #option
	gr = MolecularGrid(atoms,grid_nrad,grid_fineness) 
	gr.set_bf_amps(bfs)
	return gr