Exemplo n.º 1
0
def dmrg_infinite_size_sawtooth(para=None, A=None):
    from library.MPSClass import MpsInfiniteSawtooth as Minf
    is_print = True

    t_start = time.time()
    info = dict()
    if is_print:
        print('Start ' + str(para['n_site']) +
              '-site iDMRG (sawtooth) calculation')
    if para is None:
        para = pm.generate_parameters_infinite_dmrg_sawtooth()
        para = pm.make_para_consistent_idmrg_sawtooth(para)

    if A is None:
        d = para['d']
        A = Minf(para['form'],
                 d,
                 para['chi'],
                 para['d']**para['n_site'],
                 n_site=para['n_site'],
                 is_symme_env=para['is_symme_env'],
                 dmrg_type=para['dmrg_type'],
                 spin=para['spin'])

    ob = dict()
    e1 = 0
    de = 1
    A.update_ort_tensor_mps_sawtooth()
    A.update_bath_onsite_sawtooth(para['j1'], para['j2'], para['hx'],
                                  para['hz'])
    A.update_effective_ops_sawtooth()

    # iDMRG sweep
    for t in range(0, para['sweep_time']):
        A.update_central_tensor_sawtooth(para['tau'], para['j1'], para['j2'],
                                         para['hx'], para['hz'])

        if t % para['dt_ob'] == 0:
            A.rho_from_central_tensor_sawtooth()
            ob['eb'], ob['mag'], ob['energy_site'], ob[
                'ent'] = A.observation_sawtooth(para['j1'], para['j2'],
                                                para['hx'], para['hz'])
            if is_print:
                print('At the %g-th sweep: Eb = ' % t + str(e1))
            de = sum(abs(ob['eb'] - e1)) / ob['eb'].__len__()
            if de > para['break_tol']:
                e1 = ob['eb']
            elif is_print:
                print('Converged with de = %g' % de)
                break
        if t == para['sweep_time']:
            print('Not sufficiently converged with de = %g' % de)

        A.update_ort_tensor_mps_sawtooth()
        A.update_bath_onsite_sawtooth(para['j1'], para['j2'], para['hx'],
                                      para['hz'])
        A.update_effective_ops_sawtooth()
    info['t_cost'] = time.time() - t_start
    print('Energy per site = %g' % ob['energy_site'])
    print('x-magnetization = ' + str(ob['mag']['x']))
    print('z-magnetization = ' + str(ob['mag']['z']))
    print('Entanglement = ' + str(ob['ent']))
    print('Total time cost: %g' % info['t_cost'])
    return A, ob, info
Exemplo n.º 2
0
def dmrg_infinite_size(para=None, A=None, hamilt=None):
    from library.MPSClass import MpsInfinite as Minf
    is_print = True

    t_start = time.time()
    info = dict()
    if is_print:
        print('Start ' + str(para['n_site']) + '-site iDMRG calculation')
    if para is None:
        para = pm.generate_parameters_infinite_dmrg_sawtooth()
    if hamilt is None:
        hamilt = hamiltonian_heisenberg(para['spin'], para['jxy'], para['jxy'],
                                        para['jz'], para['hx'] / 2,
                                        para['hz'] / 2)
    if A is None:
        if para['dmrg_type'] is 'mpo':
            d = para['d']**para['n_site']
        else:
            d = para['d']
        A = Minf(para['form'],
                 d,
                 para['chi'],
                 para['d']**para['n_site'],
                 n_site=para['n_site'],
                 is_symme_env=para['is_symme_env'],
                 dmrg_type=para['dmrg_type'],
                 hamilt_index=para['hamilt_index'])
    if A.dmrg_type is 'mpo':
        tensor = hamiltonian2cell_tensor(hamilt, para['tau'])
    else:
        tensor = np.zeros(0)
    if A.n_site == 1:
        # singe-site iDMRG
        e0 = 0
        e1 = 1
    else:
        # double-site iDMRG (including White's way)
        e0 = np.zeros((1, 3))
        e1 = np.ones((1, 3))
    de = 1
    if A.is_symme_env:
        A.update_ort_tensor_mps('left')
        if A.dmrg_type is 'white':
            A.update_bath_onsite()
            A.update_effective_ops()
        else:
            A.update_left_env(tensor)
    else:
        A.update_ort_tensor_mps('both')
        A.update_left_env(tensor)
        A.update_right_env(tensor)
    # iDMRG sweep
    for t in range(0, para['sweep_time']):
        if A.dmrg_type is 'mpo':
            A.update_central_tensor(tensor)
        else:
            A.update_central_tensor((para['tau'], 'full'))

        if t % para['dt_ob'] == 0:
            A.rho_from_central_tensor()
            e1 = A.observe_energy(hamilt)
            if is_print:
                print('At the %g-th sweep: Eb = ' % t + str(e1))
            de = np.sum(abs(e0 - e1)) / A.n_site
            if de > para['break_tol']:
                e0 = e1
            elif is_print:
                print('Converged with de = %g' % de)
                break
        if t == para['sweep_time']:
            print('Not sufficiently converged with de = %g' % de)

        if A.is_symme_env:
            A.update_ort_tensor_mps('left')
            if A.dmrg_type is 'mpo':
                A.update_left_env(tensor)
            else:
                A.update_bath_onsite()
                A.update_effective_ops()
        else:
            A.update_ort_tensor_mps('both')
            A.update_left_env(tensor)
            A.update_right_env(tensor)
    ob = {'eb': e1}
    info['t_cost'] = time.time() - t_start
    if is_print:
        print('Total time cost: %g' % info['t_cost'])
    return A, ob, info