示例#1
0
    def init_b_mps(self):
        # get the right hand site vector b, Ax=b
        # b = -eta * dipole * \psi_0

        # only support Holstine model 0/1 exciton manifold
        if self.spectratype == "abs":
            nexciton = 0
            dipoletype = r"a^\dagger"
        elif self.spectratype == "emi":
            nexciton = 1
            dipoletype = "a"

        # procedure for ground state calculation
        if self.procedure_gs is None:
            self.procedure_gs = \
                [[10, 0.4], [20, 0.2], [30, 0.1], [40, 0], [40, 0]]

        # ground state calculation
        mps = Mps.random(
            self.model, nexciton, self.procedure_gs[0][0], percent=1.0)
        mps.optimize_config = OptimizeConfig(procedure=self.procedure_gs)
        mps.optimize_config.method = "2site"

        energies, mps = gs.optimize_mps(mps, self.h_mpo)
        e0 = min(energies)

        dipole_mpo = \
            Mpo.onsite(
                self.model, dipoletype, dipole=True
            )
        b_mps = dipole_mpo.apply(mps.scale(-self.eta))

        return b_mps, e0
示例#2
0
    def init_mps(self):
        mmax = self.optimize_config.procedure[0][0]
        i_mps = Mps.random(self.h_mpo.model, self.nexciton, mmax, 1)
        i_mps.optimize_config = self.optimize_config
        energy, i_mps = gs.optimize_mps(i_mps, self.h_mpo)
        if self.spectratype == "emi":
            operator = "a"
        else:
            operator = r"a^\dagger"
        dipole_mpo = Mpo.onsite(self.model, operator, dipole=True)
        if self.temperature != 0:
            beta = self.temperature.to_beta()
            # print "beta=", beta
            # thermal_mpo = Mpo.exact_propagator(self.model, -beta / 2.0, space=self.space1, shift=self.shift1)
            # ket_mps = thermal_mpo.apply(i_mps)
            # ket_mps.normalize()
            # no test, don't know work or not
            i_mpdm = MpDm.from_mps(i_mps)
            tp = ThermalProp(i_mpdm, self.h_mpo, exact=True, space=self.space1)
            tp.evolve(None, 1, beta / 2j)
            ket_mps = tp.latest_mps
        else:
            ket_mps = i_mps
        a_ket_mps = dipole_mpo.apply(ket_mps, canonicalise=True)
        a_ket_mps.canonical_normalize()

        if self.temperature != 0:
            a_bra_mps = ket_mps.copy()
        else:
            a_bra_mps = a_ket_mps.copy()
        return BraKetPair(a_bra_mps, a_ket_mps)
示例#3
0
def test_optimization(scheme, method):
    mps, mpo = construct_mps_mpo_2(holstein_model.switch_scheme(scheme),
                                   procedure[0][0], nexciton)
    mps.optimize_config.procedure = procedure
    mps.optimize_config.method = method
    energies, mps_opt = optimize_mps(mps.copy(), mpo)
    assert energies[-1] == pytest.approx(0.08401412 + holstein_model.gs_zpe,
                                         rel=1e-5)
    assert mps_opt.expectation(mpo) == pytest.approx(0.08401412 +
                                                     holstein_model.gs_zpe,
                                                     rel=1e-5)
示例#4
0
def test_multistate(method, algo):
    mps, mpo = construct_mps_mpo_2(holstein_model, procedure[0][0], nexciton)
    mps.optimize_config.procedure = procedure
    mps.optimize_config.nroots = 4
    mps.optimize_config.method = method
    mps.optimize_config.algo = algo
    mps.optimize_config.e_atol = 1e-6
    mps.optimize_config.e_rtol = 1e-6
    energy, mps = optimize_mps(mps, mpo)
    expectation = [mp.expectation(mpo) for mp in mps]
    energy_std = np.array([0.08401412, 0.08449771, 0.08449801, 0.08449945
                           ]) + holstein_model.gs_zpe
    assert np.allclose(energy[-1], energy_std)
    assert np.allclose(expectation, energy_std)
示例#5
0
def test_ex(method, nroots):
    mps, mpo = construct_mps_mpo_2(holstein_model, procedure[0][0], nexciton)
    mps.optimize_config.procedure = procedure
    mps.optimize_config.nroots = nroots
    mps.optimize_config.method = method
    mps.optimize_config.e_atol = 1e-6
    mps.optimize_config.e_rtol = 1e-6
    omega = 0.084
    energy, mps = optimize_mps(mps, mpo, omega=omega)
    energy_std = np.array([0.08401412, 0.08449771, 0.08449801, 0.08449945
                           ]) + holstein_model.gs_zpe
    if nroots == 1:
        #print("eigenenergy", mps.expectation(mpo))
        assert np.allclose(mps.expectation(mpo), energy_std[0])
    else:
        #print("eigenenergy", [ms.expectation(mpo) for ms in mps])
        assert np.allclose([ms.expectation(mpo) for ms in mps], energy_std)
示例#6
0
def test_VibBasis(basistype):
    nv = 2
    pdim = 6
    hessian = np.array([[2, 1], [1, 3]])
    e, c = scipy.linalg.eigh(hessian)
    ham_terms = []
    basis = []
    for iv in range(nv):
        op = Op("p^2", f"v_{iv}", factor=0.5, qn=0)
        ham_terms.append(op)
        if basistype == "SineDVR":
            # sqrt(<x^2>) of the highest vibrational basis
            x_mean = np.sqrt((pdim + 0.5) / np.sqrt(hessian[iv, iv]))
            bas = Ba.BasisSineDVR(f"v_{iv}",
                                  2 * pdim,
                                  -x_mean * 1.5,
                                  x_mean * 1.5,
                                  endpoint=True)
            print("x_mean", x_mean, bas.dvr_x)
        else:
            if basistype == "SHO":
                dvr = False
            else:
                dvr = True
            bas = Ba.BasisSHO(f"v_{iv}",
                              np.sqrt(hessian[iv, iv]),
                              pdim,
                              dvr=dvr)

        basis.append(bas)
    for iv in range(nv):
        for jv in range(nv):
            op = Op("x x", [f"v_{iv}", f"v_{jv}"],
                    factor=0.5 * hessian[iv, jv],
                    qn=[0, 0])
            ham_terms.append(op)
    model = Model(basis, ham_terms)
    mpo = Mpo(model)
    mps = Mps.random(model, 0, 10)
    mps.optimize_config.nroots = 2
    energy, mps = gs.optimize_mps(mps, mpo)
    w1, w2 = np.sqrt(e)
    std = [(w1 + w2) * 0.5, w1 * 1.5 + w2 * 0.5]
    print(basistype, "calc:", energy[-1], "exact:", std)
    assert np.allclose(energy[-1], std)
示例#7
0
def test_H_chain_LDOS():
    # local density of states of four H_Chain
    # Ronca,J. Chem. Theory Comput. 2017, 13, 5560-5571
    # example to use Mollist2 to do CV calculation

    spatial_norbs = 4
    spin_norbs = spatial_norbs * 2
    h1e, h2e, nuc = h_qc.read_fcidump(
        os.path.join(cur_dir, "fcidump_lowdin_h4.txt"), spatial_norbs)

    basis, ham_terms = h_qc.qc_model(h1e, h2e)

    model = Model(basis, ham_terms)
    mpo = Mpo(model)

    nelec = spatial_norbs
    M = 50
    procedure = [[M, 0.4], [M, 0.2]] + [
        [M, 0],
    ] * 6
    mps = Mps.random(model, nelec, M, percent=1.0)

    mps.optimize_config.procedure = procedure
    mps.optimize_config.method = "2site"
    energies, mps = gs.optimize_mps(mps, mpo)
    gs_e = min(energies) + nuc

    assert np.allclose(gs_e, -2.190384218792706)
    mps_e = mps.expectation(mpo)

    def photoelectron_operator(idx):
        # norbs is the spin orbitals
        # green function
        op_list = [Op("sigma_z", iorb, qn=0) for iorb in range(idx)]
        return Op.product(op_list + [Op("sigma_+", idx, qn=-1)])

    dipole_model = photoelectron_operator(nelec - 1)
    dipole_op = Mpo(model, dipole_model)
    b_mps = dipole_op.apply(mps)

    #std
    #test_freq = np.linspace(0.25, 1.25, 100, endpoint=False).tolist()
    test_freq = np.linspace(0.25, 1.25, 20, endpoint=False).tolist()
    eta = 0.05
    M = 10
    procedure_cv = [0.4, 0.2] + [0] * 6
    spectra = SpectraZtCV(model,
                          None,
                          M,
                          eta,
                          h_mpo=mpo,
                          method="2site",
                          procedure_cv=procedure_cv,
                          b_mps=b_mps.scale(-eta),
                          e0=mps_e)

    result = batch_run(test_freq, 1, spectra)
    std = np.load(os.path.join(cur_dir, "H_chain_std.npy"))
    #np.save("res", result)
    #np.save("freq", test_freq)
    assert np.allclose(result, std[::5])
示例#8
0
 def get_imps(self):
     mmax = self.optimize_config.procedure[0][0]
     i_mps = Mps.random(self.h_mpo.model, self.nexciton, mmax, 1)
     i_mps.optimize_config = self.optimize_config
     energy, i_mps = gs.optimize_mps(i_mps, self.h_mpo)
     return i_mps
示例#9
0
def test_tda():
    from renormalizer.tests.c2h4_para import ff, omega_std, B, zeta
    # See  J. Chem. Phys. 153, 084118 (2020) for the details of the Hamiltonian
    # the order is according to the harmonic frequency from small to large.
    ham_terms = []

    nmode = 12
    omega = {}

    nterms = 0
    # potential terms
    for term in ff:
        mode, factor = term[:-1], term[-1]
        # ignore the factor smaller than 1e-15
        if abs(factor) < 1e-15:
            continue
        # ignore the expansion larger than 4-th order
        #if len(mode) > 4:
        #    continue

        mode = Counter(mode)

        # the permutation symmetry prefactor
        prefactor = 1.
        for p in mode.values():
            prefactor *= scipy.special.factorial(p, exact=True)

        # check harmonic term
        if len(mode) == 1 and list(mode.values())[0] == 2:
            omega[list(mode.keys())[0]] = np.sqrt(factor)

        dof = [f"v_{i}" for i in mode.keys()]
        symbol = " ".join([f"x^{i}" for i in mode.values()])
        qn = [0 for i in mode.keys()]
        factor /= prefactor
        ham_terms.append(Op(symbol, dof, factor=factor, qn=qn))
        nterms += 1

    # Coriolis terms
    B = np.array(B)
    zeta = np.array(zeta)

    terms = [("x", "partialx", "x", "partialx", 1.),
             ("x", "partialx", "partialx", "x", -1.),
             ("partialx", "x", "x", "partialx", -1.),
             ("partialx", "x", "partialx", "x", 1.)]
    for j, l in itertools.product(range(nmode), repeat=2):
        for i, k in itertools.product(range(j), range(l)):
            dof = [f"v_{i}", f"v_{j}", f"v_{k}", f"v_{l}"]
            tmp = -np.einsum("i,i,i ->", B, zeta[:, i, j], zeta[:, k, l])
            qn = [0, 0, 0, 0]
            if abs(tmp) < 1e-15:
                continue
            for term in terms:
                symbol, factor = " ".join(term[:-1]), term[-1] * tmp
                ham_terms.append(Op(symbol, dof, factor=factor, qn=qn))
            nterms += 4

    # Kinetic terms
    for imode in range(nmode):
        ham_terms.append(Op("p^2", f"v_{imode}", 0.5, 0))
        nterms += 1

    logger.info(f"nterms: {nterms}")
    logger.info(
        f"omega: {np.sort(np.array(list(omega.values())),axis=None)*au2cm}")
    logger.info(f"omega_std: {np.array(omega_std)}")

    basis = []
    for imode in range(nmode):
        basis.append(ba.BasisSHO(f"v_{imode}", omega[imode], 4, dvr=False))

    model = Model(basis, ham_terms)
    mpo = Mpo(model)
    logger.info(f"mpo_bond_dims:{mpo.bond_dims}")
    #assert mpo.is_hermitian()

    alias = [
        "v10", "v8", "v7", "v4", "v6", "v3", "v12", "v2", "v11", "v1", "v5",
        "v9"
    ]
    energy_list = {}
    M = 10
    procedure = [[M, 0.4], [M, 0.2], [M, 0.2], [M, 0.1]] + [[M, 0]] * 100
    mps = Mps.random(model, 0, M, percent=1.0)
    mps.optimize_config.procedure = procedure
    mps.optimize_config.method = "2site"
    mps.optimize_config.e_rtol = 1e-6
    mps.optimize_config.e_atol = 1e-8
    mps.optimize_config.nroots = 1
    energies, mps = gs.optimize_mps(mps, mpo)
    logger.info(f"M: {M}, energy : {np.array(energies[-1])*au2cm}")
    tda = TDA(model, mpo, mps, nroots=3, algo="primme")
    e = tda.kernel(include_psi0=False)
    logger.info(f"tda energy : {(e-energies[-1])*au2cm}")
    assert np.allclose((e - energies[-1]) * au2cm,
                       [824.74925026, 936.42650242, 951.96826289],
                       atol=1)
    config, compressed_mps = tda.analysis_dominant_config(alias=alias)
    # std is calculated with M=200, include_psi0=True; the initial gs is
    # calculated with 9 state SA-DMRG; physical_bond=6
    std = np.load(os.path.join(cur_dir, "c2h4_std.npz"))["200"]
    assert np.allclose(energies[-1] * au2cm, std[0], atol=2)
    assert np.allclose(e * au2cm, std[1:4], atol=3)
示例#10
0
    h1e = np.random.uniform(-1, 1, size=(spin_norbs, spin_norbs))
    h2e = np.random.uniform(-1,
                            1,
                            size=(spin_norbs, spin_norbs, spin_norbs,
                                  spin_norbs))
    h1e = 0.5 * (h1e + h1e.T)
    h2e = 0.5 * (h2e + h2e.transpose((2, 3, 0, 1)))

basis, ham_terms = h_qc.qc_model(h1e, h2e)

model = Model(basis, ham_terms)
mpo = Mpo(model)
logger.info(f"mpo_bond_dims:{mpo.bond_dims}")

nelec = 10
energy_list = {}
M = 50
procedure = [[M, 0.4], [M, 0.2], [M, 0.1], [M, 0], [M, 0], [M, 0], [M, 0]]
mps = Mps.random(model, nelec, M, percent=1.0)

mps.optimize_config.procedure = procedure
mps.optimize_config.method = "2site"
energies, mps = gs.optimize_mps(mps.copy(), mpo)
gs_e = min(energies) + nuc
logger.info(f"lowest energy: {gs_e}")
# fci result
assert np.allclose(gs_e, -75.008697516450)

end = time.time()
logger.info(f"time cost {end - start}")