def E_mp2():
    # 3 E_(MP2) =  MP2(fc)/6-31G(d)//B3LYP/6-31G(2df,p)

    global Multiplicity
    global Emp2

    say("MP2(fc).")

    send_nwchem_cmd("unset basis:*")
    send_nwchem_cmd("basis noprint ; * library 6-31G* ; end")

    scfcmd = build_SCF_cmd()
    send_nwchem_cmd(scfcmd)

    send_nwchem_cmd("unset mp2:*")
    send_nwchem_cmd("mp2 ; freeze atomic ; end")

    if Multiplicity > 1:
        send_nwchem_cmd("unset tce:*")
        send_nwchem_cmd("tce ; scf ; mp2 ; freeze atomic ; end")
        en = nwchem.task_energy("tce")

    else:
        en = nwchem.task_energy("mp2")

    debug("MP2 frozen: en=%.6f\n" % en)

    Emp2 = en

    return False
def E_mp2_g3lxp():

    global Emp2g3lxp
    # 5 E_(HF/G3LXP) = MP2fc/G3LargeXP

    send_nwchem_cmd("unset basis:*")
    send_nwchem_cmd(
        """
        basis spherical
          * library g3mp2largexp
        end"""
    )

    send_nwchem_cmd("unset mp2:*")
    send_nwchem_cmd("mp2 ; freeze atomic ; end")

    if Multiplicity > 1 or is_atom():
        send_nwchem_cmd("unset tce:*")
        send_nwchem_cmd("tce ; mp2 ; freeze atomic ; end")
        en = nwchem.task_energy("tce")
    else:
        en = nwchem.task_energy("mp2")

    debug("MP(2,fc)/g3mp2large: en=%.6f\n" % en)

    Emp2g3lxp = en

    return False
def MP2_frozen():
    # MP2(fc)/6-31G* single point energy

    global Emp2frozen

    say('MP2(frozen).')

    scfcmd = build_SCF_cmd()
    send_nwchem_cmd(scfcmd)

    send_nwchem_cmd("unset mp2:*")
    send_nwchem_cmd("mp2 ; freeze atomic ; end")

    if Multiplicity > 1:
        send_nwchem_cmd("unset tce:*")
        send_nwchem_cmd("tce ; scf ; mp2 ; freeze atomic ; end")

        en = nwchem.task_energy("tce")
    else:
        en = nwchem.task_energy("mp2")

    debug('MP2 frozen: en=%.6f\n' % en)
    Emp2frozen = en

    return False
def MP2_g3mp2large():
    '''get MP2(fc)/G3MP2large single point energy
    '''
    global Eg3mp2large

    say('GMP2large.')

    send_nwchem_cmd('''
        basis spherical
          * library g3mp2large
        end''')

    send_nwchem_cmd("unset mp2:*")
    send_nwchem_cmd("mp2; freeze atomic; end")

    if Multiplicity > 1 or is_atom():
        send_nwchem_cmd("unset tce:*")
        send_nwchem_cmd("tce ; mp2 ; freeze atomic ; end")
        en = nwchem.task_energy("tce")
    else:
        en = nwchem.task_energy("mp2")

    debug(' g3mp2large: en=%.6f\n' % en)

    Eg3mp2large = en

    return False
def MP2_optimize():
    '''Optimize geometry at MP2(full)/6-31G(d)
    '''

    global Emp2full
    global Emp2frozen

    say('MP2 optimize.')

    if Multiplicity > 1:
        send_nwchem_cmd("tce ; scf ; mp2 ; end")
        if is_atom():
            en = nwchem.task_energy("tce")
        else:
            en, grad = nwchem.task_optimize("tce")
    else:
        if is_atom():
            en = nwchem.task_energy("mp2")
        else:
            en, grad = nwchem.task_optimize("mp2")

    debug('optimize: MP(2,full)/6-31G*= %.6f\n' % en)

    Emp2full = en

    return False
    def prepare_scf_vectors(self):
        """Set up converged scf vectors before first correlated steps so they
        can be used to initialize later calculations.
        """

        self.basis_prepare(self.correlated_basis[0][0],
                           output=self.correlated_basis[0][0],
                           coordinates=self.correlated_basis[0][1])

        self.send_nwchem_cmd(self.build_SCF_cmd())
        nwchem.task_energy("scf")
def E_hf_augccpvnz(basisset=""):

    basis_cmd = "basis spherical ; * library %s ; end" % basisset
    send_nwchem_cmd("unset basis:*")
    send_nwchem_cmd(basis_cmd)

    en = nwchem.task_energy("scf")

    return en
    def E_ccsdt(self):
        """# 4 E_(ccsd(t)) =  CCSD(fc,T)/6-31G(d)

        Get CCSDT(fc)/6-31G(d) energy
        """

        self.say("CCSD(T).")

        if self.multiplicity != "singlet" or self.is_atom():
            self.send_nwchem_cmd("unset tce:*")
            self.send_nwchem_cmd("tce ; ccsd(t) ; freeze atomic ; end")
            en = nwchem.task_energy("tce")
        else:
            self.send_nwchem_cmd("ccsd ; freeze atomic ; end")
            en = nwchem.task_energy("ccsd(t)")

            self.debug('CCSD(T): en=%.6f\n' % en)

        self.Eccsdt = en
    def E_mp2_g3lxp(self):
        """# 5 E_(HF/G3LXP) = MP2fc/G3LargeXP
        """

        self.basis_prepare(self.correlated_basis[1][0],
                           input=self.correlated_basis[1][0],
                           coordinates=self.correlated_basis[1][1])

        self.send_nwchem_cmd("unset mp2:*")
        self.send_nwchem_cmd("mp2 ; freeze atomic ; end")

        if self.multiplicity != "singlet" or self.is_atom():
            self.send_nwchem_cmd("unset tce:*")
            self.send_nwchem_cmd("tce ; mp2 ; freeze atomic ; end")
            en = nwchem.task_energy("tce")
        else:
            en = nwchem.task_energy("mp2")

        self.debug('MP(2,fc)/g3mp2large: en=%.6f\n' % en)

        self.Emp2g3lxp = en
    def E_hf_g3lxp(self):
        """# 5 E_(HF/G3LXP) = HF/G3LargeXP
        """

        self.basis_prepare(self.correlated_basis[1][0],
                           input=self.correlated_basis[0][0],
                           output=self.correlated_basis[1][0],
                           coordinates=self.correlated_basis[1][1])

        en = nwchem.task_energy("scf")
        self.Ehfg3lxp = en
        self.debug("HF/G3LargeXP SCF:energy = %f Ha" % (en))
def CCSDT_frozen():
    '''get CCSDT(fc)/6-31G(d) energy
    '''
    global Ecc

    say("CCSD(T).")

    # NWChem6.5 direct CCSD(T) at 6-31G* fails on H2
    if Multiplicity > 1 or is_atom() or is_H2():
        send_nwchem_cmd("unset tce:*")
        send_nwchem_cmd("tce ; ccsd(t) ; freeze atomic ; end")
        en = nwchem.task_energy("tce")
    else:
        send_nwchem_cmd("ccsd ; freeze atomic ; end")
        en = nwchem.task_energy("ccsd(t)")

    debug(' CCSD(T): en=%.6f\n' % en)

    Ecc = en

    return False
def E_ccsdt():
    """get CCSDT(fc)/6-31G(d) energy
    """
    global Multiplicity
    global Eccsdt

    say("CCSD(T).")

    if Multiplicity > 1 or is_atom() or is_H2():
        send_nwchem_cmd("unset tce:*")
        send_nwchem_cmd("tce ; ccsd(t) ; freeze atomic ; end")
        en = nwchem.task_energy("tce")
    else:
        send_nwchem_cmd("ccsd ; freeze atomic ; end")
        en = nwchem.task_energy("ccsd(t)")

    debug("CCSD(T): en=%.6f\n" % en)

    Eccsdt = en

    return False
    def E_mp2(self):
        """Calculate the MP2 energy at the B3LYP-optimized geometry.

        # 3 E_(MP2) =  MP2(fc)/6-31G(d)//B3LYP/6-31G(2df,p)

        :return: failure code (True for failure, False for success)
        :rtype : bool
        """

        self.say('MP2(fc).')

        self.basis_prepare(self.correlated_basis[0][0],
                           input=self.correlated_basis[0][0],
                           coordinates=self.correlated_basis[0][1])

        scfcmd = self.build_SCF_cmd()
        self.send_nwchem_cmd(scfcmd)

        self.send_nwchem_cmd("unset mp2:*")
        self.send_nwchem_cmd("mp2 ; freeze atomic ; end")

        try:
            if self.multiplicity != "singlet":
                self.send_nwchem_cmd("unset tce:*")
                self.send_nwchem_cmd("tce ; scf ; mp2 ; freeze atomic ; end")

                en = nwchem.task_energy("tce")
            else:
                en = nwchem.task_energy("mp2")

            self.debug('MP2 frozen: en=%.6f\n' % en)
        except:
            self.report("FAILED: MP2(fc)/6-31G(2df,p) energy")
            return True
        else:
            self.Emp2 = en

        return False
def QCISDT_frozen():

# QCISDT(frozen core)/6-31G(d) single point energy

    global Ecc

    say("QCISD(T).")

    nwchem.input_parse("tce ; qcisd(t) ; freeze atomic ; end")

    en = nwchem.task_energy("tce")
    Ecc = en

    return False
    def E_hf1(self):
        """Use g4mp2-aug-cc-pvtz basis set to get first HF energy.
        """

        self.say("HF1.")

        self.basis_prepare(self.cbs_basis[0][0],
                           input=self.correlated_basis[0][0],
                           output=self.cbs_basis[0][0],
                           coordinates=self.cbs_basis[0][1])

        en = nwchem.task_energy("scf")

        self.Ehf1 = en
        self.debug("HF/%s: energy = %f Ha" % (self.cbs_basis[0][0], en))
    def optimize(self):
        """# 1 optimize  B3LYP/6-31G(2df,p)

        """

        self.say('optimize.')

        self.send_nwchem_cmd("basis noprint ; * library 6-31G(2df,p) ; end")
        #self.send_nwchem_cmd("basis spherical noprint ; * library 6-31G(2df,p) ; end")
        scfcmd = self.build_SCF_cmd()
        self.send_nwchem_cmd(scfcmd)

        # canonical B3LYP spec
        # GAMESS-US b3lyp uses VWN_5
        # Gaussian uses VWN_3
        # NWChem uses something entirely different

        b3lyp_GAMESS = 'xc HFexch 0.2 slater 0.8 becke88 nonlocal 0.72 vwn_5 0.19 lyp 0.81'
        b3lyp_Gaussian = 'xc HFexch 0.2 slater 0.8 becke88 nonlocal 0.72 vwn_3 0.19 lyp 0.81'
        b3lyp_NWChem = 'xc b3lyp'

        blips = b3lyp_Gaussian
        memory_cache_words = self.integral_memory_cache / 8
        disk_cache_words = self.integral_disk_cache / 8
        mem = "semidirect memsize {0} filesize {1}".format(memory_cache_words,
                                                           disk_cache_words)

        if self.multiplicity != "singlet":
            self.send_nwchem_cmd('dft ; odft ; mult %d ; %s ; %s ; end' % (self.multiplicity_numeric, blips, mem))
        else:
            self.send_nwchem_cmd('dft ; %s ; %s ; end' % (blips, mem))

        # fetch and copy atom names list (tags) which enumerates atoms.
        # only available _after_ SCF statement

        self.initialize_atoms_list()
        self.send_nwchem_cmd("driver; maxiter 999; xyz {0}; end".format(self.geohash))
        self.send_nwchem_cmd("scf; maxiter 999; end")

        # optimize the geometry, ignore energy and gradient results
        if self.is_atom():
            en = nwchem.task_energy("dft")

        else:
            self.debug("task_optimize(dft)")
            en, grad = nwchem.task_optimize("dft")

        self.Eb3lyp = en
def E_hf_g3lxp ():
    global Ehfg3lxp

# energy @ HF/G3LargeXP

    send_nwchem_cmd("unset basis:*")
    send_nwchem_cmd('''
        basis spherical
          * library g3mp2largexp
        end''')

    en = nwchem.task_energy("scf")

    Ehfg3lxp = en

    debug("HF/G3LargeXP energy= %f Ha" % (en))

    return False
def optimize():
    # 1 optimize  B3LYP/6-31G(2df,p)

    global Eb3lyp
    global Multiplicity

    say("optimize.")
    limits_high()

    send_nwchem_cmd("basis noprint ; * library 6-31G(2df,p) ; end")

    # canonical B3LYP spec
    # GAMESS-US b3lyp uses VWN_5
    # Gaussian uses VWN_3
    # NWChem uses something entirely different

    b3lyp_GAMESS = "xc HFexch 0.2 slater 0.8 becke88 nonlocal 0.72 vwn_5 0.19 lyp 0.81"
    b3lyp_Gaussian = "xc HFexch 0.2 slater 0.8 becke88 nonlocal 0.72 vwn_3 0.19 lyp 0.81"
    b3lyp_NWChem = "xc b3lyp"

    # blips = b3lyp_GAMESS
    # blips = b3lyp_NWChem
    blips = b3lyp_Gaussian

    if Multiplicity > 1:
        send_nwchem_cmd("dft ; odft ; mult %d ; %s ; end" % (Multiplicity, blips))
    else:
        send_nwchem_cmd("dft ; %s ; end" % blips)

    # fetch and copy atom names list (tags) which enumerates atoms.
    # only available _after_ SCF statement

    set_atoms_list()

    if is_atom():
        en = nwchem.task_energy("dft")
    else:
        en, grad = nwchem.task_optimize("dft")

    Eb3lyp = en

    debug("B3LYP/6-31G(2df,p) energy = %f Ha" % (en))
    return False
    def E_hf2(self):
        """Use g4mp2-aug-cc-pvqz to get second
        HF energy.

        :return: failure code (True for failure, False for success)
        :rtype : bool
        """

        self.say("HF2.")

        self.basis_prepare(self.cbs_basis[1][0],
                           input=self.cbs_basis[0][0],
                           output=self.cbs_basis[1][0],
                           coordinates=self.cbs_basis[1][1])

        en = nwchem.task_energy("scf")

        self.Ehf2 = en
        self.debug("HF/%s: energy = %f Ha" % (self.cbs_basis[0][0], en))
def HF_optimize():
    '''
       HF/6-31G(d) optimization
    '''
    say('optimize.')

    limits_high()
    send_nwchem_cmd("basis noprint ; * library 6-31G* ; end")
    scfcmd = build_SCF_cmd()
    send_nwchem_cmd(scfcmd)

    # fetch and copy atom names list (tags) which enumerates atoms.
    # only available _after_ SCF statement

    set_atoms_list()

    # optimize the geometry, ignore energy and gradient results
    if is_atom():
        en = nwchem.task_energy("scf")
    else:
        en, grad = nwchem.task_optimize("scf")

    debug("HF/6-31G(d) SCF:energy = %.7f Ha" % (en))
    return False