コード例 #1
0
ファイル: single_det.py プロジェクト: sunchong137/pauxy
 def __init__(self, weight, system, trial, index=0):
     self.weight = weight
     self.alive = 1
     if trial.initial_wavefunction == 'free_electron':
         self.phi = numpy.zeros(shape=(system.nbasis, system.ne),
                                dtype=trial.psi.dtype)
         tmp = FreeElectron(system, system.ktwist.all() != None, {})
         self.phi[:, :system.nup] = tmp.psi[:, :system.nup]
         self.phi[:, system.nup:] = tmp.psi[:, system.nup:]
     else:
         self.phi = copy.deepcopy(trial.psi)
     self.inv_ovlp = [0, 0]
     self.nup = system.nup
     self.inverse_overlap(trial.psi)
     self.G = numpy.zeros(shape=(2, system.nbasis, system.nbasis),
                          dtype=trial.psi.dtype)
     self.Gmod = numpy.zeros(shape=(2, system.nbasis, system.nup),
                             dtype=trial.psi.dtype)
     self.greens_function(trial)
     self.ot = 1.0
     # interface consistency
     self.ots = numpy.zeros(1)
     self.E_L = local_energy(system, self.G)[0].real
     # walkers overlap at time tau before backpropagation occurs
     self.ot_bp = 1.0
     # walkers weight at time tau before backpropagation occurs
     self.weight_bp = weight
     # Historic wavefunction for back propagation.
     self.phi_old = copy.deepcopy(self.phi)
     # Historic wavefunction for ITCF.
     self.phi_init = copy.deepcopy(self.phi)
     # Historic wavefunction for ITCF.
     self.phi_bp = copy.deepcopy(self.phi)
     self.weights = numpy.array([1])
コード例 #2
0
 def calculate_energy(self, system):
     if self.verbose:
         print("# Computing trial energy.")
     (self.energy, self.e1b, self.e2b) = local_energy(system, self.G)
     if self.verbose:
         print("# (E, E1B, E2B): (%13.8e, %13.8e, %13.8e)" %
               (self.energy.real, self.e1b.real, self.e2b.real))
コード例 #3
0
ファイル: hartree_fock.py プロジェクト: sunchong137/pauxy
 def __init__(self, system, cplx, trial, parallel=False, verbose=False):
     if verbose:
         print("# Parsing Hartree--Fock trial wavefunction input options.")
     init_time = time.time()
     self.name = "hartree_fock"
     self.type = "hartree_fock"
     self.initial_wavefunction = trial.get('initial_wavefunction',
                                           'hartree_fock')
     self.trial_type = complex
     self.psi = numpy.zeros(shape=(system.nbasis,
                                   system.nup + system.ndown),
                            dtype=self.trial_type)
     occup = numpy.identity(system.nup)
     occdown = numpy.identity(system.ndown)
     self.psi[:system.nup, :system.nup] = occup
     self.psi[:system.ndown, system.nup:] = occdown
     gup = gab(self.psi[:, :system.nup], self.psi[:, :system.nup])
     gdown = gab(self.psi[:, system.nup:], self.psi[:, system.nup:])
     self.G = numpy.array([gup, gdown])
     (self.energy, self.e1b, self.e2b) = local_energy(system, self.G)
     self.coeffs = 1.0
     self.bp_wfn = trial.get('bp_wfn', None)
     self.error = False
     self.initialisation_time = time.time() - init_time
     if verbose:
         print("# Finished setting up trial wavefunction.")
コード例 #4
0
 def recompute_ci_coeffs(self, system):
     H = numpy.zeros((self.ndets, self.ndets), dtype=numpy.complex128)
     S = numpy.zeros((self.ndets, self.ndets), dtype=numpy.complex128)
     if self.ortho_expansion:
         for i in range(self.ndets):
             for j in range(i, self.ndets):
                 di = self.spin_occs[i]
                 dj = self.spin_occs[j]
                 H[i, j] = get_hmatel(system, di, dj)[0]
         e, ev = scipy.linalg.eigh(H, lower=False)
     else:
         na = system.nup
         for i, di in enumerate(self.psi):
             for j, dj in enumerate(self.psi):
                 if j >= i:
                     ga, gha, ioa = gab_mod_ovlp(di[:, :na], dj[:, :na])
                     gb, ghb, iob = gab_mod_ovlp(di[:, na:], dj[:, na:])
                     G = numpy.array([ga, gb])
                     Ghalf = numpy.array([gha, ghb])
                     ovlp = 1.0 / (scipy.linalg.det(ioa) *
                                   scipy.linalg.det(iob))
                     if abs(ovlp) > 1e-12:
                         H[i, j] = ovlp * local_energy(
                             system, G, Ghalf=Ghalf)[0]
                         S[i, j] = ovlp
                         H[j, i] = numpy.conjugate(H[i, j])
                         S[j, i] = numpy.conjugate(S[i, j])
         e, ev = scipy.linalg.eigh(H, S, lower=False)
     if self.verbose > 1:
         print("Old and New CI coefficients: ")
         for co, cn in zip(self.coeffs, ev[:, 0]):
             print("{} {}".format(co, cn))
     self.coeffs = numpy.array(ev[:, 0], dtype=numpy.complex128)
コード例 #5
0
ファイル: uhf.py プロジェクト: sunchong137/pauxy
 def __init__(self, system, cplx, trial, parallel=False, verbose=False):
     if verbose:
         print("# Constructing UHF trial wavefunction")
     init_time = time.time()
     self.name = "UHF"
     self.type = "UHF"
     self.initial_wavefunction = trial.get('initial_wavefunction', 'trial')
     if cplx:
         self.trial_type = complex
     else:
         self.trial_type = float
     # Unpack input options.
     self.ninitial = trial.get('ninitial', 10)
     self.nconv = trial.get('nconv', 5000)
     self.ueff = trial.get('ueff', 0.4)
     self.deps = trial.get('deps', 1e-8)
     self.alpha = trial.get('alpha', 0.5)
     # For interface compatability
     self.coeffs = 1.0
     self.ndets = 1
     (self.psi, self.eigs, self.emin, self.error,
      self.nav) = (self.find_uhf_wfn(system, cplx, self.ueff, self.ninitial,
                                     self.nconv, self.alpha, self.deps,
                                     verbose))
     if self.error and not parallel:
         warnings.warn('Error in constructing trial wavefunction. Exiting')
         sys.exit()
     Gup = gab(self.psi[:, :system.nup], self.psi[:, :system.nup]).T
     Gdown = gab(self.psi[:, system.nup:], self.psi[:, system.nup:]).T
     self.G = numpy.array([Gup, Gdown])
     self.etrial = local_energy(system, self.G)[0].real
     self.bp_wfn = trial.get('bp_wfn', None)
     self.initialisation_time = time.time() - init_time
コード例 #6
0
ファイル: test_multi_det.py プロジェクト: hungpham2017/pauxy
def test_walker_energy():
    numpy.random.seed(7)
    nelec = (2, 2)
    nmo = 5
    h1e, chol, enuc, eri = generate_hamiltonian(nmo, nelec, cplx=False)
    system = Generic(nelec=nelec,
                     h1e=h1e,
                     chol=chol,
                     ecore=enuc,
                     inputs={'integral_tensor': False})
    (e0, ev), (d, oa, ob) = simple_fci(system, gen_dets=True)
    na = system.nup
    init = get_random_wavefunction(nelec, nmo)
    init[:, :na], R = reortho(init[:, :na])
    init[:, na:], R = reortho(init[:, na:])
    trial = MultiSlater(system, (ev[:, 0], oa, ob), init=init)
    trial.calculate_energy(system)
    walker = MultiDetWalker({}, system, trial)
    nume = 0
    deno = 0
    for i in range(trial.ndets):
        psia = trial.psi[i, :, :na]
        psib = trial.psi[i, :, na:]
        oa = numpy.dot(psia.conj().T, init[:, :na])
        ob = numpy.dot(psib.conj().T, init[:, na:])
        isa = numpy.linalg.inv(oa)
        isb = numpy.linalg.inv(ob)
        ovlp = numpy.linalg.det(oa) * numpy.linalg.det(ob)
        ga = numpy.dot(init[:, :system.nup], numpy.dot(isa, psia.conj().T)).T
        gb = numpy.dot(init[:, system.nup:], numpy.dot(isb, psib.conj().T)).T
        e = local_energy(system, numpy.array([ga, gb]), opt=False)[0]
        nume += trial.coeffs[i].conj() * ovlp * e
        deno += trial.coeffs[i].conj() * ovlp
    print(nume / deno, nume, deno, e0[0])
コード例 #7
0
 def calculate_energy(self, system):
     if self.verbose:
         print("# Computing trial wavefunction energy.")
     start = time.time()
     (self.energy, self.e1b,
      self.e2b) = local_energy(system,
                               self.G,
                               Ghalf=[self.gup_half, self.gdown_half],
                               opt=True)
     if self.verbose:
         print("# (E, E1B, E2B): (%13.8e, %13.8e, %13.8e)" %
               (self.energy.real, self.e1b.real, self.e2b.real))
         print("# Time to evaluate local energy: %f s" %
               (time.time() - start))
コード例 #8
0
ファイル: single_det.py プロジェクト: sunchong137/pauxy
    def local_energy(self, system):
        """Compute walkers local energy

        Parameters
        ----------
        system : object
            System object.

        Returns
        -------
        (E, T, V) : tuple
            Mixed estimates for walker's energy components.
        """
        return local_energy(system, self.G)
コード例 #9
0
ファイル: back_propagation.py プロジェクト: sunchong137/pauxy
    def update_uhf(self, system, qmc, trial, psi, step, free_projection=False):
        """Calculate back-propagated estimates for RHF/UHF walkers.

        Parameters
        ----------
        system : system object in general.
            Container for model input options.
        qmc : :class:`pauxy.state.QMCOpts` object.
            Container for qmc input options.
        trial : :class:`pauxy.trial_wavefunction.X' object
            Trial wavefunction class.
        psi : :class:`pauxy.walkers.Walkers` object
            CPMC wavefunction.
        step : int
            Current simulation step
        free_projection : bool
            True if doing free projection.
        """
        if step % self.nmax != 0:
            return
        psi_bp = self.back_propagate(system, psi.walkers, trial, self.nstblz,
                                     self.BT2, qmc.dt)
        nup = system.nup
        denominator = 0
        for i, (wnm, wb) in enumerate(zip(psi.walkers, psi_bp)):
            self.G[0] = gab(wb.phi[:, :nup], wnm.phi_old[:, :nup]).T
            self.G[1] = gab(wb.phi[:, nup:], wnm.phi_old[:, nup:]).T
            energies = numpy.array(list(local_energy(system, self.G)))
            if self.restore_weights is not None:
                weight = wnm.weight * self.calculate_weight_factor(wnm)
            else:
                weight = wnm.weight
            denominator += weight
            self.estimates[1:] = (
                self.estimates[1:] +
                weight * numpy.append(energies, self.G.flatten()))
        self.estimates[0] += denominator
        psi.copy_historic_wfn()
        psi.copy_bp_wfn(psi_bp)
コード例 #10
0
ファイル: mean_field.py プロジェクト: hungpham2017/pauxy
 def scf(self, system, beta, mu, P):
     # 1. Compute HMF
     HMF = fock_matrix(system, P)
     dt = self.dtau
     muN = mu * numpy.eye(system.nbasis, dtype=self.G.dtype)
     rho = numpy.array([
         scipy.linalg.expm(-dt * (HMF[0] - muN)),
         scipy.linalg.expm(-dt * (HMF[1] - muN))
     ])
     Pold = one_rdm_stable(rho, self.num_bins)
     if self.verbose:
         print(" # Running Thermal SCF.")
     for it in range(self.max_scf_it):
         HMF = fock_matrix(system, Pold)
         rho = numpy.array([
             scipy.linalg.expm(-dt * (HMF[0] - muN)),
             scipy.linalg.expm(-dt * (HMF[1] - muN))
         ])
         Pnew = (1 - self.alpha) * one_rdm_stable(
             rho, self.num_bins) + self.alpha * Pold
         change = numpy.linalg.norm(Pnew - Pold)
         if change < self.deps:
             break
         if self.verbose:
             N = particle_number(P).real
             E = local_energy(system, P, opt=False)[0].real
             S = entropy(beta, mu, HMF)
             omega = E - mu * N - 1.0 / beta * S
             print(
                 " # Iteration: {:4d} dP: {:13.8e} Omega: {:13.8e}".format(
                     it, change, omega.real))
         Pold = Pnew.copy()
     if self.verbose:
         N = particle_number(P).real
         print(" # Average particle number: {:13.8e}".format(N))
     return HMF
コード例 #11
0
    def find_uhf_wfn(self,
                     system,
                     cplx,
                     ueff,
                     ninit,
                     nit_max,
                     alpha,
                     deps=1e-8,
                     verbose=0):
        emin = 0
        uold = system.U
        system.U = ueff
        minima = []  # Local minima
        nup = system.nup
        # Search over different random starting points.
        for attempt in range(0, ninit):
            # Set up initial (random) guess for the density.
            (self.trial, eold) = self.initialise(system.nbasis, system.nup,
                                                 system.ndown, cplx)
            niup = self.density(self.trial[:, :nup])
            nidown = self.density(self.trial[:, nup:])
            niup_old = self.density(self.trial[:, :nup])
            nidown_old = self.density(self.trial[:, nup:])
            for it in range(0, nit_max):
                (niup, nidown, e_up, e_down) = (self.diagonalise_mean_field(
                    system, ueff, niup, nidown))
                # Construct Green's function to compute the energy.
                Gup = gab(self.trial[:, :nup], self.trial[:, :nup]).T
                Gdown = gab(self.trial[:, nup:], self.trial[:, nup:]).T
                enew = local_energy(system, numpy.array([Gup, Gdown]))[0].real
                if verbose > 1:
                    print("# %d %f %f" % (it, enew, eold))
                sc = self.self_consistant(enew, eold, niup, niup_old, nidown,
                                          nidown_old, it, deps, verbose)
                if sc:
                    # Global minimum search.
                    if attempt == 0:
                        minima.append(enew)
                        psi_accept = copy.deepcopy(self.trial)
                        e_accept = numpy.append(e_up, e_down)
                    elif all(numpy.array(minima) - enew > deps):
                        minima.append(enew)
                        psi_accept = copy.deepcopy(self.trial)
                        e_accept = numpy.append(e_up, e_down)
                    break
                else:
                    mixup = self.mix_density(niup, niup_old, alpha)
                    mixdown = self.mix_density(nidown, nidown_old, alpha)
                    niup_old = niup
                    nidown_old = nidown
                    niup = mixup
                    nidown = mixdown
                    eold = enew
            if verbose > 1:
                print("# SCF cycle: {:3d}. After {:4d} steps the minimum UHF"
                      " energy found is: {: 8f}".format(attempt, it, eold))

        system.U = uold
        print("# Minimum energy found: {: 8f}".format(min(minima)))
        try:
            return (psi_accept, e_accept, min(minima), False, [niup, nidown])
        except UnboundLocalError:
            warnings.warn("Warning: No UHF wavefunction found."
                          "Delta E: %f" % (enew - emin))
            return (trial, numpy.append(e_up, e_down), None, True, None)
コード例 #12
0
ファイル: free_electron.py プロジェクト: sunchong137/pauxy
 def __init__(self, system, cplx, trial, parallel=False, verbose=False):
     if verbose:
         print ("# Parsing free electron input options.")
     init_time = time.time()
     self.name = "free_electron"
     self.type = "free_electron"
     self.initial_wavefunction = trial.get('initial_wavefunction',
                                           'free_electron')
     if verbose:
         print ("# Diagonalising one-body Hamiltonian.")
     (self.eigs_up, self.eigv_up) = diagonalise_sorted(system.T[0])
     (self.eigs_dn, self.eigv_dn) = diagonalise_sorted(system.T[1])
     self.reference = trial.get('reference', None)
     if cplx:
         self.trial_type = complex
     else:
         self.trial_type = float
     self.read_in = trial.get('read_in', None)
     self.psi = numpy.zeros(shape=(system.nbasis, system.nup+system.ndown),
                            dtype=self.trial_type)
     if self.read_in is not None:
         if verbose:
             print ("# Reading trial wavefunction from %s"%(self.read_in))
         try:
             self.psi = numpy.load(self.read_in)
             self.psi = self.psi.astype(self.trial_type)
         except OSError:
             if verbose:
                 print("# Trial wavefunction is not in native numpy form.")
                 print("# Assuming Fortran GHF format.")
             orbitals = read_fortran_complex_numbers(self.read_in)
             tmp = orbitals.reshape((2*system.nbasis, system.ne),
                                    order='F')
             ups = []
             downs = []
             # deal with potential inconsistency in ghf format...
             for (i, c) in enumerate(tmp.T):
                 if all(abs(c[:system.nbasis]) > 1e-10):
                     ups.append(i)
                 else:
                     downs.append(i)
             self.psi[:, :system.nup] = tmp[:system.nbasis, ups]
             self.psi[:, system.nup:] = tmp[system.nbasis:, downs]
     else:
         # I think this is slightly cleaner than using two separate
         # matrices.
         if self.reference is not None:
             self.psi[:, :system.nup] = self.eigv_up[:, self.reference]
             self.psi[:, system.nup:] = self.eigv_dn[:, self.reference]
         else:
             self.psi[:, :system.nup] = self.eigv_up[:, :system.nup]
             self.psi[:, system.nup:] = self.eigv_dn[:, :system.ndown]
     gup = gab(self.psi[:, :system.nup],
                                      self.psi[:, :system.nup]).T
     gdown = gab(self.psi[:, system.nup:],
                                        self.psi[:, system.nup:]).T
     self.G = numpy.array([gup, gdown])
     self.etrial = local_energy(system, self.G)[0].real
     # For interface compatability
     self.coeffs = 1.0
     self.ndets = 1
     self.bp_wfn = trial.get('bp_wfn', None)
     self.error = False
     self.eigs = numpy.append(self.eigs_up, self.eigs_dn)
     self.eigs.sort()
     self.initialisation_time = time.time() - init_time
     if verbose:
         print ("# Finished initialising free electron trial wavefunction.")
コード例 #13
0
ファイル: thermal.py プロジェクト: hungpham2017/pauxy
 def local_energy(self, system, two_rdm=None):
     rdm = one_rdm_from_G(self.G)
     return local_energy(system, rdm, two_rdm=two_rdm, opt=False)
コード例 #14
0
 def __init__(self,
              walker_opts,
              system,
              trial,
              index=0,
              nprop_tot=None,
              nbp=None):
     self.weight = walker_opts.get('weight', 1.0)
     self.unscaled_weight = self.weight
     self.phase = 1 + 0j
     self.alive = 1
     self.phi = trial.init.copy()
     # JOONHO randomizing the guess
     # self.phi = numpy.random.rand([system.nbasis,system.ne])
     self.inv_ovlp = [0.0, 0.0]
     self.nup = system.nup
     self.ndown = system.ndown
     self.inverse_overlap(trial)
     self.G = numpy.zeros(shape=(2, system.nbasis, system.nbasis),
                          dtype=trial.psi.dtype)
     self.Gmod = [
         numpy.zeros(shape=(system.nup, system.nbasis),
                     dtype=trial.psi.dtype),
         numpy.zeros(shape=(system.ndown, system.nbasis),
                     dtype=trial.psi.dtype)
     ]
     self.greens_function(trial)
     self.total_weight = 0.0
     self.ot = 1.0
     # interface consistency
     self.ots = numpy.zeros(1, dtype=numpy.complex128)
     self.E_L = local_energy(system, self.G, self.Gmod)[0].real
     # walkers overlap at time tau before backpropagation occurs
     self.ot_bp = 1.0
     # walkers weight at time tau before backpropagation occurs
     self.weight_bp = self.weight
     # Historic wavefunction for back propagation.
     self.phi_old = copy.deepcopy(self.phi)
     self.hybrid_energy = 0.0
     # Historic wavefunction for ITCF.
     self.phi_right = copy.deepcopy(self.phi)
     self.weights = numpy.array([1.0])
     # Number of propagators to store for back propagation / ITCF.
     num_propg = walker_opts.get('num_propg', 1)
     # if system.name == "Generic":
     # self.stack = PropagatorStack(self.stack_size, num_propg,
     # system.nbasis, trial.psi.dtype,
     # BT=None, BTinv=None,
     # diagonal=False)
     try:
         excite = trial.excite_ia
     except AttributeError:
         excite = None
     if excite is not None:
         self.ia = trial.excite_ia
         self.reortho = self.reortho_excite
         self.trial_buff = numpy.copy(trial.full_orbs[:, :self.ia[1] + 1])
     if nbp is not None:
         self.field_configs = FieldConfig(system.nfields, nprop_tot, nbp,
                                          numpy.complex128)
     else:
         self.field_configs = None
     self.buff_names, self.buff_size = get_numeric_names(self.__dict__)
コード例 #15
0
    "mu": 0.2,
    "sparse": False,
    "integrals": "hamil.h5"
}

system = Generic(inputs=sys_opts)

# trial = OneBody(comm, system, 1.0, 0.05, verbose=True)
mus = numpy.arange(-1, 1)
data = []
dt = 0.05
fci = pd.read_csv('be_fixed_n.out', sep=r'\s+')
for b, n in zip(fci.beta, fci.N):
    trial = OneBody(comm, system, b, dt, options={"nav": n}, verbose=True)
    data.append([
        local_energy(system, trial.P, opt=False)[0].real,
        particle_number(trial.P).real
    ])
pl.plot(fci.beta, zip(*data)[0], label='Match N')
match = zip(*data)[0]
data = []
for b, n in zip(fci.beta, fci.N):
    trial = MeanField(comm, system, b, dt, options={"nav": n}, verbose=True)
    data.append([
        local_energy(system, trial.P, opt=False)[0].real,
        particle_number(trial.P).real
    ])
pl.plot(fci.beta, fci.E, label='FCI')
pl.plot(fci.beta, zip(*data)[0], label='THF', linestyle=':')
data = pd.DataFrame({
    'beta': fci.beta,
コード例 #16
0
    def update_uhf(self, system, qmc, trial, psi, step, free_projection=False):
        """Calculate back-propagated estimates for RHF/UHF walkers.

        Parameters
        ----------
        system : system object in general.
            Container for model input options.
        qmc : :class:`pauxy.state.QMCOpts` object.
            Container for qmc input options.
        trial : :class:`pauxy.trial_wavefunction.X' object
            Trial wavefunction class.
        psi : :class:`pauxy.walkers.Walkers` object
            CPMC wavefunction.
        step : int
            Current simulation step
        free_projection : bool
            True if doing free projection.
        """
        buff_ix = psi.walkers[0].field_configs.step
        if buff_ix not in self.splits:
            return
        nup = system.nup
        for i, wnm in enumerate(psi.walkers):
            if self.init_walker:
                phi_bp = trial.init.copy()
            else:
                phi_bp = trial.psi.copy()
            # TODO: Fix for ITCF.
            self.back_propagate(phi_bp, wnm.field_configs, system, self.nstblz,
                                self.BT2, self.dt)
            self.G[0] = gab(phi_bp[:, :nup], wnm.phi_old[:, :nup]).T
            self.G[1] = gab(phi_bp[:, nup:], wnm.phi_old[:, nup:]).T

            if self.eval_energy:
                eloc = local_energy(system,
                                    self.G,
                                    opt=False,
                                    two_rdm=self.two_rdm)
                energies = numpy.array(list(eloc))
            else:
                energies = numpy.zeros(3)

            if self.calc_two_rdm is not None and self.calc_two_rdm is not "structure_factor":
                # <p^+ q^+ s r> = G(p, r, q, s) also spin-summed
                self.two_rdm =  numpy.einsum("pr,qs->prqs",self.G[0], self.G[0], optimize=True)\
                              - numpy.einsum("ps,qr->prqs",self.G[0], self.G[0], optimize=True)
                self.two_rdm += numpy.einsum("pr,qs->prqs",self.G[1], self.G[1], optimize=True)\
                              - numpy.einsum("ps,qr->prqs",self.G[1], self.G[1], optimize=True)
                self.two_rdm += numpy.einsum("pr,qs->prqs",self.G[0], self.G[1], optimize=True)\
                              + numpy.einsum("pr,qs->prqs",self.G[1], self.G[0], optimize=True)

            if self.eval_ekt:
                if (system.name == 'UEG'):
                    # there needs to be a factor of 2.0 here to account for the convention of cholesky vectors in the system class
                    chol_vecs = 2.0 * system.chol_vecs.toarray().T.reshape(
                        (system.nchol, system.nbasis, system.nbasis))
                    self.ekt_fock_1p = ekt_1p_fock_opt(system.H1[0], chol_vecs,
                                                       self.G[0], self.G[1])
                    self.ekt_fock_1h = ekt_1h_fock_opt(system.H1[0], chol_vecs,
                                                       self.G[0], self.G[1])
                else:
                    self.ekt_fock_1p = ekt_1p_fock_opt(system.H1[0],
                                                       system.chol_vecs,
                                                       self.G[0], self.G[1])
                    self.ekt_fock_1h = ekt_1h_fock_opt(system.H1[0],
                                                       system.chol_vecs,
                                                       self.G[0], self.G[1])

            if self.restore_weights is not None:
                cosine_fac, ph_fac = wnm.field_configs.get_wfac()
                if self.restore_weights == "full":
                    # BP-Pres
                    wfac = ph_fac / cosine_fac
                else:
                    # BP-PRes (partial)
                    wfac = ph_fac
                weight = wnm.weight * wfac
            else:
                # BP-PhL
                weight = wnm.weight

            self.estimates[:self.nreg] += weight * energies
            self.estimates[self.nreg] += weight

            start = self.nreg + 1
            end = start + self.G.size
            self.estimates[start:end] += weight * self.G.flatten()

            if self.calc_two_rdm is not None:
                start = end
                end = end + self.two_rdm.size
                self.estimates[start:end] += weight * self.two_rdm.flatten()

            if self.eval_ekt:
                start = end
                end = end + self.ekt_fock_1p.size
                self.estimates[start:end] += weight * self.ekt_fock_1p.flatten(
                )
                start = end
                end = end + self.ekt_fock_1h.size
                self.estimates[start:end] += weight * self.ekt_fock_1h.flatten(
                )

            if buff_ix == self.splits[-1]:
                wnm.field_configs.reset()
        if buff_ix == self.splits[-1]:
            psi.copy_historic_wfn()
        self.accumulated = True
        self.buff_ix = buff_ix