Beispiel #1
0
def solver_input_data(parms, L, hyb_data_all, AvgDispersion, VCoulomb, nf):
    # prepare hybtau file for CTQMC
    N_LAYERS = int(parms["N_LAYERS"])
    FLAVORS = int(parms["FLAVORS"])
    SPINS = int(parms["SPINS"])
    corr_id = system.getCorrIndex(parms)
    dmft_id = system.getDMFTCorrIndex(parms)
    dmft_FLAVORS = 2 * len(dmft_id) / N_LAYERS
    # 2 for SPINS

    hyb_data = []
    for n, d in enumerate(hyb_data_all):
        data = hyb_data_all[n][:, :, dmft_id[L::N_LAYERS]]
        data_out = zeros((size(data, 1), dmft_FLAVORS), dtype=data.dtype)
        data_out[:, ::2] = data[0]
        data_out[:, 1::2] = data[0] if SPINS == 1 else data[1]
        hyb_data.append(data_out)

    Eav = AvgDispersion[:, 0, dmft_id[L::N_LAYERS]]
    inertHFSelfEnergy = get_inert_band_HF(parms, nf[:, L::N_LAYERS])

    MU = array([float(parms["MU"]) - VCoulomb[L] - Eav[s] - inertHFSelfEnergy[s] for s in range(SPINS)])
    MU_out = zeros(dmft_FLAVORS)
    MU_out[::2] = MU[0]
    MU_out[1::2] = MU[0] if SPINS == 1 else MU[1]
    parms_copy = parms.copy()
    parms_copy["FLAVORS"] = dmft_FLAVORS

    print "Inert HF Self Energy: ", inertHFSelfEnergy
    return {"hybtau": hyb_data[0], "hybmat": hyb_data[1], "hybtail": hyb_data[2], "MU": MU_out, "parms": parms_copy}
Beispiel #2
0
def get_asymp_selfenergy(parms, nf_in, nn_in = None):
    dmft_id = system.getDMFTCorrIndex(parms, all = False);
    FLAVORS = int(parms['FLAVORS']);
    SPINS = 2;
    U = generate_Umatrix(float(parms['U']), float(parms['J']), 
            int(parms['FLAVORS']), val_def(parms, 'INTERACTION_TYPE', 'SlaterKanamori'));
    if int(val_def(parms, 'TMP_HELD_DC' , 0)) > 0: 
        for m in range(2*FLAVORS):
            for n in range(2*FLAVORS):
                f1 = m/2
                f2 = n/2
                if (f1 not in dmft_id) or (f2 not in dmft_id):
                    U[m, n] = 0.

    nf = zeros(SPINS*FLAVORS);
    nf[::2] = nf[1::2] = nf_in[0];
    if int(parms['SPINS']) == 2: nf[1::2] = nf_in[1];

    nn = zeros((FLAVORS*SPINS, FLAVORS*SPINS));
    pos = 0;
    for i in range(FLAVORS*SPINS):
        for j in range(i+1):
            f1 = i/SPINS;
            f2 = j/SPINS;
            if f1 in dmft_id and f2 in dmft_id and nn_in is not None:
                nn[i,j] = nn[j,i] = nn_in[pos];
                pos += 1;
        if f1 in dmft_id: nn[i,i] = nf[i];

    S = zeros((2, SPINS*FLAVORS)); # 2: expansion orders: (iwn)^0, (iwn)^{-1}
    for f in range(SPINS*FLAVORS):
        # zeroth order is easy: \Sigma^0_f = U_{f, f'} * <n_f'>
        S[0, f] = sum(U[f, :]*nf);

        # first order is harder: \Sigma^1_f = U_{f,f1}*U_{f,f2}*<n_f1 n_f2> - (\Sigma^0_f)^2
        for f1 in range(SPINS*FLAVORS):
            for f2 in range(SPINS*FLAVORS):
                S[1, f] += U[f, f1]*U[f,f2]*nn[f1,f2];
        S[1,f] -= S[0,f]**2;
    ret = array([S[:,::2], S[:,1::2]]);

    # for mean field, there is only \Sigma^0, other terms vanish
    # so I set \Sigma^1 to be zero
    for f in range(FLAVORS):
        if f not in dmft_id: 
            ret[:, 1, f] = 0;
            if int(val_def(parms, 'TMP_HELD_DC' , 0)) > 0: 
                uu = float(parms['U'])
                jj = float(parms['J'])
                ntot = sum(nf_in[0][dmft_id] + nf_in[1][dmft_id])
                ret[:, 0, f] = ((uu-2*jj) + jj*(2 - (3-1)) / (2*3.-1.))*(ntot-0.5)
    if int(parms['SPINS']) == 1: ret = array([ret[0]]);
    return ret;
Beispiel #3
0
def getDensity(h5, it = None):
    if it is None: it = h5['iter'][0];
    parms    = load_parms(h5, it);
    N_LAYERS = int(parms['N_LAYERS']);
    SPINS    = int(parms['SPINS']);
    NCOR     = int(parms['NCOR']);
    U        = float(parms['U']);
    n_f = h5['log_density'][0 if it == 0 else it-1, 4:].reshape(SPINS, -1)[:, :NCOR];
    if U != 0 and it > 0:
        if int(val_def(parms, 'FIXED_HARTREE', 0)) > 0:
            n_f = h5['log_density'][0, 4:].reshape(SPINS, -1)[:, :NCOR];
        dmft_id = system.getDMFTCorrIndex(parms);
        gtau = h5['SolverData/Gtau/'+str(it)][:]
        n_f[:, dmft_id]  = -gtau[:, -1, dmft_id];
    return n_f;
Beispiel #4
0
def get_inert_band_HF(parms, nf):
    FLAVORS = int(parms["FLAVORS"])
    SPINS = 2
    ret = zeros(SPINS)
    if int(val_def(parms, "TMP_HELD_DC", 0)) > 0:
        return ret
    assert size(nf, 1) == FLAVORS
    dmft_id = system.getDMFTCorrIndex(parms, all=False)
    inert_id = array([s for s in range(FLAVORS) if s not in dmft_id])
    U = float(parms["U"])
    J = float(parms["J"])
    if len(nf) == 1:
        nf = r_[nf, nf]
    for s in range(SPINS):
        for f in inert_id:
            ret[s] += (U - 2 * J) * nf[not s, f] + (U - 3 * J) * nf[s, f]

    if int(val_def(parms, "MEAN_FIELD_UNPOLARIZED", 0)) > 0:
        ret = ones(SPINS) * mean(ret)
    return ret
Beispiel #5
0
def getSpectraFromSelfEnergy(h5, se_filename, rham, rotmat, numk = None, setail_filename = None, it = 0):
    
    # prepare data
    w, se_refreq = ProcessSelfEnergy(se_filename, emin = -5, emax = 5, NFreq = 500);

    it = h5['iter'][0] - it;
    parms = load_parms(h5, it);
    print 'work on iteration ', it;
    if rham is not None: print 'new path for rham file is: ', rham; parms['RHAM'] = rham;
    if rotmat is not None: print 'new path for rot_mat file is ', rotmat; parms['ROT_MAT'] = rotmat;
    BETA = float(parms['BETA']);
    N_LAYERS = int(parms['N_LAYERS']);
    FLAVORS  = int(parms['FLAVORS']);
    SPINS = int(parms['SPINS']);
    NORB  = int(parms['NORB']);
    dmft_id = system.getDMFTCorrIndex(parms, all = False);
    dmft_id_len = len(dmft_id);

    # get the se tails
    tmp = h5['SolverData/selfenergy_asymp_coeffs'][:];
    se_tail = tmp[tmp[:,0] == it, 1:].reshape(SPINS, 2, -1)[:, :, ::N_LAYERS];
    if setail_filename is not None:
        print 'use the tail from external source: ', setail_filename;
        tmp = genfromtxt(setail_filename);
        se_tail[:, :, dmft_id] = array([tmp[:, s::SPINS] for s in range(SPINS)]); 
    print se_tail;

    # restore SelfEnergy
    se = zeros((SPINS, len(se_refreq), N_LAYERS*FLAVORS), dtype = complex);
    for s in range(SPINS):
        for f in range(N_LAYERS*FLAVORS):
            if f/N_LAYERS not in dmft_id: se[s,:,f] = se_tail[s, 0, f/N_LAYERS];
            else: 
                f1 = nonzero(f/N_LAYERS == dmft_id)[0][0];
                se[s, :, f] = se_refreq[:, SPINS*f1+s]*se_tail[s, 1, f/N_LAYERS] + se_tail[s, 0, f/N_LAYERS]; 

    # tight binding Hamiltonian
    if 'RHAM' in parms: 
        HR, R = getHamiltonian(parms['RHAM'], 4);
        if parms['DTYPE'] == '3bands': FLAVORS = 3;
        extra = { 'HR' : HR, 'R': R };

    # rotation matrix
    if int(val_def(parms, 'FORCE_DIAGONAL', 0)) > 0:
        print 'FORCE_DIAGONAL is used';
        ind = nonzero(sum(R**2, 1)==0)[0][0];
        H0 = HR[ind];
    else: H0 = None;
    rot_mat = getRotationMatrix(N_LAYERS, FLAVORS, val_def(parms, 'ROT_MAT', None), H0);


    # prepare for k-integrate
    parms['NUMK'] = 16 if numk is None else numk;
    bp, wf = grule(int(parms['NUMK']));
    broadening = 0.01;
    extra.update({
            'GaussianData' : [bp, wf],
            'rot_mat'      : rot_mat
            });
    delta = float(parms['DELTA']);
    mu    = float(parms['MU']);

    # running
    print 'generating interacting DOS with parameters'
    for k, v in parms.iteritems(): print '%s = %s'%(k, v);

    Gr = averageGreen(delta, mu, w+1j*broadening, se, parms, float(parms['ND']), float(parms['DENSITY']), 0, extra)[1];
    if SPINS == 1: savetxt(parms['ID']+'.idos', c_[w, -1/pi*Gr[0].imag], fmt = '%g');
    elif SPINS == 2:
        savetxt(parms['ID']+'_up.idos', c_[w, -1/pi*Gr[0].imag], fmt = '%g'); 
        savetxt(parms['ID']+'_dn.idos', c_[w, -1/pi*Gr[1].imag], fmt = '%g'); 
    
    # calculate original G(iwn), only consider one "LAYERS"
    Giwn_orig = h5['ImpurityGreen/%d'%it][:,:,::N_LAYERS];
    NMatsubara = size(Giwn_orig, 1);
    wn = (2*arange(NMatsubara) + 1)*pi/BETA;
    Giwn = zeros((NMatsubara, 2*FLAVORS*SPINS), dtype = float); # 2 for real and imag
    for f in range(FLAVORS):
        for s in range(SPINS):
            Giwn[:, 2*(SPINS*f+s)] = Giwn_orig[s, :, f].real;
            Giwn[:, 2*(SPINS*f+s)+1] = Giwn_orig[s, :, f].imag;
    savetxt(parms['ID']+'.gmat', c_[wn, Giwn]);

    # calculate G(iwn) for reference, only consider one "LAYERS"
    NMatsubara = 200;
    wn = (2*arange(NMatsubara) + 1)*pi/BETA;
    Giwn = zeros((NMatsubara, 2*FLAVORS*SPINS), dtype = float); # 2 for real and imag
    for f in range(FLAVORS):
        for s in range(SPINS):
            A = -1/pi * Gr[s, :, f*N_LAYERS].imag;
            for n in range(NMatsubara):
                tck_re = splrep(w, real(A / (1j*wn[n] - w)));
                tck_im = splrep(w, imag(A / (1j*wn[n] - w)));
                Giwn[n, 2*(SPINS*f+s)] = splint(w[0], w[-1], tck_re);
                Giwn[n, 2*(SPINS*f+s)+1] = splint(w[0], w[-1], tck_im);
    savetxt(parms['ID']+'.gmat.ref', c_[wn, Giwn]);
Beispiel #6
0
def run_solver(AvgDispersion, nf, w, it, parms, aWeiss, np=1, VCoulomb=None):
    ID = parms["ID"]
    N_LAYERS = int(parms["N_LAYERS"])
    FLAVORS = int(parms["FLAVORS"])
    SPINS = int(parms["SPINS"])
    DATA_FILE = parms["DATA_FILE"]
    TMPH5FILE = "." + DATA_FILE + ".id" + str(ID) + ".i" + str(it) + ".solver_out.h5"
    if VCoulomb is None:
        VCoulomb = zeros(N_LAYERS)
    solver = solver_types.init_solver(parms, np)
    corr_id = system.getCorrIndex(parms)
    NCOR = int(parms["NCOR"])
    NDMFT = 2 * len(system.getDMFTCorrIndex(parms))
    # 2 for SPINS

    # check save point and initialize for new iteration
    try:
        tmph5 = h5py.File(TMPH5FILE, "r+")
        hyb_tau = tmph5["Hybtau"][:]
        hyb_mat = tmph5["Hybmat"][:]
        hyb_coefs = tmph5["hyb_asym_coeffs"][:].reshape(SPINS, -1, NCOR)
    except:
        try:
            tmph5.close()
        except:
            pass
        tmph5 = h5py.File(TMPH5FILE, "w")
        tmph5.create_dataset("L", (2,), dtype=int, data=array([it, 0]))

        # asymptotic coefficients, upto 3rd order for hyb
        hyb_coefs = zeros((SPINS, 3, NCOR), dtype=float)
        # electric chemical potential
        eMU = float(parms["MU"]) - VCoulomb
        for L in range(N_LAYERS):
            hyb_coefs[:, :, L::N_LAYERS] = get_asymp_hybmat(
                parms, nf[:, L::N_LAYERS], eMU[L], AvgDispersion[:, :, corr_id[L:NCOR:N_LAYERS]]
            )

        # get practical hybmat, and hybtau
        Eav = AvgDispersion[:, 0, corr_id]
        hyb_mat = zeros((SPINS, int(parms["N_MAX_FREQ"]), NCOR), dtype=complex)
        hyb_tau = zeros((SPINS, int(parms["N_TAU"]) + 1, NCOR), dtype=float)
        for s in range(SPINS):
            for f in range(NCOR):
                hyb_mat[s, :, f] = w + eMU[f % N_LAYERS] - Eav[s, f] - aWeiss[s, :, f]
                tmp = cppext.IFT_mat2tau(
                    hyb_mat[s, :, f].copy(),
                    int(parms["N_TAU"]) + 1,
                    float(parms["BETA"]),
                    float(hyb_coefs[s, 0, f]),
                    float(hyb_coefs[s, 1, f]),
                )

                # set value >= 0 to be smaller than 0, the mean of left and right neighbors
                ind = nonzero(tmp >= 0)[0]
                for i in ind:
                    lefti = righti = i
                    while tmp[lefti] >= 0 and lefti > 0:
                        lefti -= 1
                    while tmp[righti] >= 0 and righti < len(tmp) - 1:
                        righti += 1
                    leftval = tmp[lefti] if tmp[lefti] < 0 else 0
                    rightval = tmp[righti] if tmp[righti] < 0 else 0
                    tmp[i] = (leftval + rightval) / 2.0
                hyb_tau[s, :, f] = tmp
        tmph5.create_dataset("Hybmat", hyb_mat.shape, dtype=complex, data=hyb_mat)
        tmph5.create_dataset("Hybtau", hyb_tau.shape, dtype=float, data=hyb_tau)

        # initialize output dataset
        Gtau_shape = (int(parms["N_TAU"]) + 1, NDMFT)
        tmph5.create_dataset("Gtau", Gtau_shape, dtype=float, data=zeros(Gtau_shape, dtype=float))
        tmph5.create_group("Observables")
        tmph5.create_dataset("hyb_asym_coeffs", hyb_coefs.flatten().shape, dtype=float, data=hyb_coefs.flatten())

    # run
    hyb_data = [hyb_tau, hyb_mat, hyb_coefs]
    MEASURE_freq = True if "Gw" in tmph5 else False
    startL = tmph5["L"][1]
    sym_layers = getSymmetricLayers(tmph5, parms)
    for L in range(startL, N_LAYERS):
        print "Processing task ", ID, ": iteration ", it, ", layer ", L
        tmph5["L"][1] = L
        TMPFILE = "." + DATA_FILE + ".id" + str(ID) + ".i" + str(it) + ".L" + str(L)

        if float(parms["U"]) == 0:
            break

        if (sym_layers is None) or (L not in sym_layers[:, 1]):
            solver.prepare(TMPFILE, solver_input_data(parms, L, hyb_data, AvgDispersion, VCoulomb, nf))
            tmph5.close()
            ret_val = solver.run()
            tmph5 = h5py.File(TMPH5FILE, "r+")
            if ret_val > 0:
                print "Not finish running impurity solver or problem occurs while running the solver."
                os.system("rm " + TMPFILE + ".*")
                tmph5.close()
                return None
            solver_out = solver.collect()
            if solver_out is None:
                tmph5.close()
                return None
            Gtau = solver_out[0]
            obs = solver_out[1]
            if len(solver_out) > 2:
                MEASURE_freq = True
                Giwn = solver_out[2]
                Siwn = solver_out[3]
            os.system("rm " + TMPFILE + ".*")

        elif L in sym_layers[:, 1]:  # symmetric layer, no need to calculate
            sym_index = nonzero(sym_layers[:, 1] == L)[0]
            sym_L = sym_layers[sym_index, 0][0]
            print "L=%d is the symmetric layer of layer L=%d" % (L, sym_L)
            Gtau = tmph5["Gtau"][:, sym_L::N_LAYERS]
            obs = None
            if tmph5["Observables"].keys() != []:
                obs = dict()
                for k, v in tmph5["Observables/L" + str(sym_L)].iteritems():
                    obs[k] = v
            if MEASURE_freq:
                Giwn = tmph5["Gw"][:, sym_L::N_LAYERS]
                Siwn = tmph5["Sw"][:, sym_L::N_LAYERS]
            # this is the only place for AFM
            # only works for the 4-cell unitcell (GdFeO3 distortion)
            # G-type AFM: 0-3 are the same, 0-1 and 0-2 are opposite in spin
            # here I just swap values of opposite spins
            if int(val_def(parms, "AFM", 0) > 0) and (L in [1, 2]):
                print "AFM processing on this L"
                Ntmp = NDMFT / N_LAYERS
                # correlated bands per site
                mapid = zeros(Ntmp, dtype=int)
                mapid[0::2] = arange(1, Ntmp, 2)
                mapid[1::2] = arange(0, Ntmp, 2)
                Gtau = Gtau[:, mapid]
                if MEASURE_freq:
                    Giwn = Giwn[:, mapid]
                    Siwn = Siwn[:, mapid]
                if "nn" in obs:
                    tmp = obs["nn"][:]
                    nn = zeros((Ntmp, Ntmp), dtype=float)
                    pos = 0
                    for i in range(Ntmp):
                        for j in range(i + 1):
                            nn[i, j] = nn[j, i] = tmp[pos]
                            pos += 1
                    nn = nn[mapid]
                    nn = nn[:, mapid]
                    tmp = array([])
                    for i in range(Ntmp):
                        for j in range(i + 1):
                            tmp = r_[tmp, nn[i, j]]
                    obs["nn"] = tmp

        tmph5["Gtau"][:, L::N_LAYERS] = Gtau
        if MEASURE_freq:
            if "Gw" not in tmph5:
                matsubara_shape = (len(Giwn), NDMFT)
                tmph5.create_dataset("Gw", matsubara_shape, dtype=complex, data=zeros(matsubara_shape, dtype=complex))
                tmph5.create_dataset("Sw", matsubara_shape, dtype=complex, data=zeros(matsubara_shape, dtype=complex))
            tmph5["Gw"][:, L::N_LAYERS] = Giwn
            tmph5["Sw"][:, L::N_LAYERS] = Siwn

        if obs is not None:
            new_group_str = "Observables/L" + str(L)
            tmph5.create_group(new_group_str)
            for k, v in obs.iteritems():
                tmph5.create_dataset(new_group_str + "/" + k, v.shape, dtype=v.dtype, data=v)

        print "Finish iteration ", it, ", layer ", L, "\n"
    print "DONE: iteration %d\n" % it
    tmph5["L"][1] = N_LAYERS
    tmph5.close()
    return TMPH5FILE
Beispiel #7
0
def solver_post_process(parms, aWeiss, h5, tmph5filename):
    N_LAYERS = int(parms["N_LAYERS"])
    FLAVORS = int(parms["FLAVORS"])
    NCOR = int(parms["NCOR"])
    SPINS = 2
    # NOTE: for collecting all spins, symmetrize them later if neccessary
    if len(aWeiss) == 1:
        aWeiss = r_[aWeiss, aWeiss]
        # SPINS = 1 case
    dmft_id = system.getDMFTCorrIndex(parms)

    if not os.path.isfile(tmph5filename):
        print >> sys.stderr, "File %s not found" % tmph5filename
        return None
    tmph5 = h5py.File(tmph5filename, "r")
    if tmph5["L"][1] < N_LAYERS:
        print >> sys.stderr, "Unfinish solving the impurity model"
        return None

    # save data from temporary file
    h5solver = h5["SolverData"]
    it = tmph5["L"][0]
    MEASURE_freq = True if "Gw" in tmph5 else False

    for s in tmph5["Observables"]:
        new_group_str = "Observables/%d/%s" % (it, s)
        for k in tmph5["Observables/%s" % s]:
            v = tmph5["Observables/%s/%s" % (s, k)]
            try:
                h5solver.create_dataset(new_group_str + "/" + k, v.shape, dtype=v.dtype, data=v)
            except:
                h5solver[new_group_str + "/" + k][:] = v

    Gmat = zeros((SPINS, int(parms["N_MAX_FREQ"]), NCOR), dtype=complex)
    Smat = zeros((SPINS, int(parms["N_MAX_FREQ"]), NCOR), dtype=complex)
    Ntau = max(int(parms["N_TAU"]) / 20, 400) + 1
    Htau = tmph5["Hybtau"][:, ::20, :]

    # the updated density: for DMFT bands, get from Gtau, for inert bands, get from Gavg of previous iteration
    nf = h5["log_density"][0 if int(val_def(parms, "FIXED_HARTREE", 0)) > 0 else it - 1, 4:].reshape(-1, NCOR + 1)
    if len(nf) == 1:
        nf = r_[nf, nf]
    nf = nf[:, :NCOR]
    nf[:, dmft_id] = -assign(tmph5["Gtau"][-1, :], N_LAYERS)

    # get raw Gmat and Smat
    for f in range(size(tmph5["Gtau"], 1)):
        g = cppext.FT_tau2mat(tmph5["Gtau"][:, f].copy(), float(parms["BETA"]), int(parms["N_MAX_FREQ"]))
        try:
            tmp = c_[tmp, g]
        except:
            tmp = g.copy()
    Gmat[:, :, dmft_id] = assign(tmp, N_LAYERS)
    Smat[:, :, dmft_id] = aWeiss[:, :, dmft_id] - 1 / Gmat[:, :, dmft_id]
    if MEASURE_freq:
        nfreq = size(tmph5["Gw"][:], 0)
        Gmat[:, :nfreq, dmft_id] = assign(tmph5["Gw"], N_LAYERS)
        Stmp = assign(tmph5["Sw"], N_LAYERS)
        # adjust self energy measured using improved estimator
        # with contribution from inertial d-bands
        for L in range(N_LAYERS):
            SE_inert = get_inert_band_HF(parms, nf[:, L::N_LAYERS])
            Stmp[0, :, L::N_LAYERS] += SE_inert[0]
            Stmp[1, :, L::N_LAYERS] += SE_inert[1]
        Smat[:, :nfreq, dmft_id] = Stmp

    # symmetrize orbital and spin if necessary
    paraorb = [int(s) for s in val_def(parms, "PARAORBITAL", "").split()]
    if len(paraorb) == 1:
        if paraorb[0] > 0:
            if parms["DTYPE"] == "3bands":
                paraorb = [[0, 1, 2]]
                # t2g only HARD CODE
            else:
                paraorb = [[0, 3], [1, 2, 4]]
                # t2g and eg HARD CODE
        else:
            paraorb = []
    if len(paraorb) > 0:
        if type(paraorb[0]) != list:
            paraorb = [paraorb]
        print "Symmetrize over orbital ", paraorb
        for L in range(N_LAYERS):
            for s in range(SPINS):
                for sym_bands in paraorb:
                    gm = zeros(size(Gmat, 1), dtype=complex)
                    sm = zeros(size(Smat, 1), dtype=complex)
                    nf_tmp = 0.0
                    for f in sym_bands:
                        gm += Gmat[s, :, L + f * N_LAYERS]
                        sm += Smat[s, :, L + f * N_LAYERS]
                        nf_tmp += nf[s, L + f * N_LAYERS]
                    for f in sym_bands:
                        Gmat[s, :, L + f * N_LAYERS] = gm / float(len(sym_bands))
                        Smat[s, :, L + f * N_LAYERS] = sm / float(len(sym_bands))
                        nf[s, L + f * N_LAYERS] = nf_tmp / float(len(sym_bands))
    if int(parms["SPINS"]) == 1:
        print "Symmetrize over spins"
        Gmat = array([mean(Gmat, 0)])
        Smat = array([mean(Smat, 0)])
        nf = array([mean(nf, 0)])

    # smooth Gmat and Smat
    SPINS = int(parms["SPINS"])
    Smat = smooth_selfenergy(it, h5, Smat, nf)
    NCutoff = int(parms["N_CUTOFF"])
    Gmat[:, NCutoff:, :] = 1.0 / (aWeiss[:SPINS, NCutoff:, :] - Smat[:, NCutoff:, :])

    # calculate Gtau from Gmat (after symmtrization)
    Gtau = zeros((SPINS, Ntau, NCOR), dtype=float)
    S0 = zeros((SPINS, NCOR))
    for L in range(N_LAYERS):
        S0[:, L::N_LAYERS] = get_asymp_selfenergy(parms, nf[:, L::N_LAYERS])[:, 0, :]
    for s in range(SPINS):
        for f in range(NCOR):
            if f not in dmft_id:
                Smat[s, :, f] = S0[s, f]
                Gmat[s, :, f] = 1.0 / (aWeiss[s, :, f] - Smat[s, :, f])
            Gtau[s, :, f] = cppext.IFT_mat2tau(Gmat[s, :, f].copy(), Ntau, float(parms["BETA"]), 1.0, 0.0)

    Gtau[:, 0, :] = -(1.0 - nf)
    Gtau[:, -1, :] = -nf

    # saving data
    dT = 5
    Nb2 = size(tmph5["Gtau"], 0) / 2
    Gb2 = array([mean(tmph5["Gtau"][Nb2 - dT : Nb2 + dT, f], 0) for f in range(size(tmph5["Gtau"], 1))])
    log_data(h5solver, "log_Gbeta2", it, Gb2.flatten(), data_type=float)
    log_data(h5solver, "log_nsolve", it, -tmph5["Gtau"][-1, :].flatten(), data_type=float)
    log_data(h5solver, "hyb_asym_coeffs", it, tmph5["hyb_asym_coeffs"][:].flatten(), data_type=float)
    save_data(h5solver, it, ("Gtau", "Hybtau", "Hybmat"), (Gtau, Htau, tmph5["Hybmat"][:]))
    tmph5.close()
    del tmph5
    os.system("rm %s" % tmph5filename)
    return Gmat, Smat
Beispiel #8
0
def HartreeRun(parms, extra):
    print "Initialization using Hartree approximation\n"
    N_LAYERS = int(parms['N_LAYERS']);
    FLAVORS  = int(parms['FLAVORS']);
    SPINS    = 1;

    p = dict({
        'MU' : float(val_def(parms, 'MU', 0)), 
        'N_LAYERS': N_LAYERS,
        'NORB' : int(parms['NORB']),
        'U'  : float(parms['U']),
        'J'  : float(parms['J']),
        'DELTA': float(val_def(parms, 'DELTA', 0)),
        'ND'   : N_LAYERS*float(val_def(parms, 'ND', -1)),
    
        'DENSITY' : N_LAYERS*float(parms['DENSITY']),
        'FLAVORS' : FLAVORS,
        'SPINS'   : 1,
    
        'OUTPUT' : '.' + parms['DATA_FILE'] + '_HartreeInit',
        'NN'     : None,
        'N_MAX_FREQ'  : 30,
        'BETA'        : float(parms['BETA']),
        'NUMK' : int(val_def(parms, 'INIT_NUMK', 8)),
        'TUNEUP' : int(val_def(parms, 'NO_TUNEUP', 0)) == 0,
        'MAX_ITER' : 15,
        'ALPHA'  : 0.5, # pay attention at this parm sometimes
        'DTYPE'  : parms['DTYPE'],
        'INTEGRATE_MOD' : val_def(parms, 'INTEGRATE_MOD', 'integrate'),
        'np' : parms['np']
        });
    
    for k, v in p.iteritems(): print k + ': ', v;
    
    bp, wf = grule(p['NUMK']);
    X, W = generateGaussPoints(p['N_MAX_FREQ']);
    wn = 1/sqrt(X)/p['BETA'];
    p.update({
        'X'  : X,
        'W'  : W,
        'w'  : wn
        });
    if p['NN'] is None and os.path.isfile(p['OUTPUT']+'.nn'): p['NN'] = p['OUTPUT'];
       
    # running
    TOL = 1e-2;
    if p['NN'] is None: 
        nn = ones(N_LAYERS*FLAVORS, dtype = 'f8') * p['DENSITY']/p['NORB']/2;  # 2 for spin
        mu = p['MU'];
        delta = p['DELTA'];
    else:
        print 'Continue from '+p['NN'];
        nn = genfromtxt(p['NN']+'.nn')[2:];
        mu = genfromtxt(p['NN']+'.nn')[1];
        delta = genfromtxt(p['NN']+'.nn')[0];
    Gavg = zeros((p['N_MAX_FREQ'], p['NORB']), dtype = 'c16');
    se = zeros((SPINS, p['N_MAX_FREQ'], N_LAYERS*FLAVORS), dtype = 'c16');
    stop = False;
    count = 0;
    ALPHA = p['ALPHA'];
    corr1 = system.getDMFTCorrIndex(parms, all = False);
    corr2 = array([i for i in range(FLAVORS) if i not in corr1]);   # index for eg bands
    old_GaussianData = extra['GaussianData'];
    extra['GaussianData'] = [bp, wf];
    while not stop:
        count += 1;
        nn_old = nn.copy();
        p['MU'] = mu;
        p['DELTA'] = delta;
        Gavg_old = Gavg.copy();
    
        for L in range(N_LAYERS):
            se_coef = functions.get_asymp_selfenergy(p, array([nn[L:N_LAYERS*FLAVORS:N_LAYERS]]))[0, 0, :];
            for s in range(SPINS): 
                for f in range(len(se_coef)): se[s, :, f*N_LAYERS+L] = se_coef[f];
        
        Gavg, delta, mu, Vc = averageGreen(delta, mu, 1j*wn, se, p, p['ND'], p['DENSITY'], p['TUNEUP'], extra);
        Gavg  = mean(Gavg, 0);
        nn = getDensity(Gavg, p);

        # no spin/orbital polarization, no charge order
        for L in range(N_LAYERS):
            nf1 = nn[0:N_LAYERS*FLAVORS:N_LAYERS];
            for id in range(FLAVORS):
                if id in corr1: nf1[id] = mean(nf1[corr1]);
                else: nf1[id] = mean(nf1[corr2]);
            nn[L:N_LAYERS*FLAVORS:N_LAYERS] = nf1;
   
        err = linalg.norm(r_[delta, mu, nn] - r_[p['DELTA'], p['MU'], nn_old]);
        savetxt(p['OUTPUT']+'.nn', r_[delta, mu, nn]);
        print 'Step %d: %.5f'%(count, err);
        if (err < TOL): stop = True; print 'converged';
        if count > p['MAX_ITER']: break;

        mu = ALPHA*mu + (1-ALPHA)*p['MU'];
        delta = ALPHA*delta + (1-ALPHA)*p['DELTA'];
        nn = ALPHA*nn + (1-ALPHA)*nn_old;

 
    # DOS
    NFREQ = 500;
    BROADENING = 0.03;
    extra['GaussianData'] = old_GaussianData;
    parms_tmp = parms.copy(); parms_tmp['DELTA'] = delta;
    Eav = system.getAvgDispersion(parms_tmp, 3, extra)[0,0,:];
    Ed  = mean(Eav[:N_LAYERS*FLAVORS][corr1]);
    Ep  = mean(Eav[N_LAYERS*FLAVORS:]) if N_LAYERS*FLAVORS < p['NORB'] else Ed;
    emax = min(4, p['U']);
    emin = -(Ed - Ep + max(se_coef) + min(4, p['U']));
    print "Energy range for HF DOS: ", emin, emax
    w = linspace(emin, emax, NFREQ) + 1j*BROADENING;
    se = zeros((SPINS, NFREQ, N_LAYERS*FLAVORS), dtype = 'c16');
    for L in range(N_LAYERS):
        se_coef = functions.get_asymp_selfenergy(p, array([nn[L:N_LAYERS*FLAVORS:N_LAYERS]]))[0, 0, :];
        for s in range(SPINS): 
            for f in range(len(se_coef)): se[s, :, f*N_LAYERS+L] = se_coef[f];
    Gr = average_green.averageGreen(delta, mu, w, se, p,p['ND'], p['DENSITY'], 0, extra)[1][0];
    savetxt(parms['ID']+'.dos', c_[w.real, -1/pi*Gr.imag], fmt = '%.6f');

    print ('End Hartree approx.:%d   Ntot=%.2f  Nd=%.2f  Delta=%.4f   '
           'Delta_eff=%.4f')%(count, 2*sum(nn)/N_LAYERS,
                              2*sum(nn[:N_LAYERS*FLAVORS]/N_LAYERS),
                              delta, delta-mean(se_coef[corr1])), ': \n', \
                              nn[:N_LAYERS*FLAVORS].reshape(-1, N_LAYERS),\
                              '\n\n'
#    os.system('rm ' + p['OUTPUT']+'.nn');
    return delta, mu, array([nn for s in range(int(parms['SPINS']))]), Vc;
Beispiel #9
0
def gget(data, st, iter = None, L = None, f = None):
    if iter == None: iter = str(data['iter'][0]);
    iter = str(iter);
    parms = load_parms(data, int(iter));
    N_LAYERS = int(parms['N_LAYERS']); FLAVORS = int(parms['FLAVORS']); SPINS = int(parms['SPINS']);
    NORB = int(parms['NORB']); NCOR = int(parms['NCOR']);
    corr_id = system.getCorrIndex(parms);
    dmft_id = system.getDMFTCorrIndex(parms);
    dmft_site_id = system.getDMFTCorrIndex(parms, all = False);
    
    if st == 'wn':
        NMaxFreq = int(parms['N_MAX_FREQ']);
        BETA = float(parms['BETA']);
        return (2*arange(0, NMaxFreq)+1)*pi/BETA;
    if st == 'parms': return parms;
    if st == 'log':
        log = data['log_density'][:];
        num_iter = len(log);
        nraw = log[:,4:];
        orbital = zeros((num_iter, FLAVORS, N_LAYERS));
        orbital_abs = zeros((num_iter, FLAVORS, N_LAYERS));
        spinup = zeros((num_iter, N_LAYERS));
        spindn = zeros((num_iter, N_LAYERS));
        density = zeros((num_iter, N_LAYERS));
        magnetization = zeros((num_iter, N_LAYERS));

        for n in range(num_iter):
            nf = nraw[n].reshape(SPINS, -1)[:, :NCOR];
            noxy = nraw[n].reshape(SPINS, -1)[:, -1]/N_LAYERS;
#            if n > 0: 
#                nf_gtau = -data['SolverData/Gtau/'+str(n)][:, -1, :];
#                nf[:, dmft_id] = nf_gtau[:, dmft_id];
            nf = nf.reshape(SPINS, FLAVORS, N_LAYERS);
            if SPINS == 1: nf = r_[nf, nf]; noxy = r_[noxy, noxy];

            density[n] = array([sum(nf[:,:,i]) for i in range(N_LAYERS)]);
            orbital[n] = (nf[0] + nf[1])/density[n];
            orbital_abs[n] = (nf[0] + nf[1]);
            spinup[n] = sum(nf[0], 0)/density[n] - 1./2;
            spindn[n] = sum(nf[1], 0)/density[n] - 1./2;
#            magnetization[n] = sum(nf[0, dmft_site_id, :] - nf[1, dmft_site_id], 0);
            magnetization[n] = sum(nf[0] - nf[1], 0) + noxy[0] - noxy[1];
#            magnetization[n] = sum(nf[0] - nf[1], 0);

        out = (log[:,:4], density, spinup, spindn, orbital, magnetization, orbital_abs);
        return out;
    
    if L == None: L = arange(N_LAYERS);
    if f == None: f = arange(FLAVORS);
    L = array([L]).flatten(); f = asarray([f]).flatten();
    idx = array([], dtype = 'i4');
    for i in range(0,len(f)): idx = r_[idx, L + f[i]*N_LAYERS];
    idx = sort(idx);

    if st == 'idx': return idx;
    if st == 'Gimp': return data['ImpurityGreen/' + iter][:,:,idx];
    if st == 'se': return data['SelfEnergy/' + iter][:,:,idx];
    if st == 'as': return data['WeissField/' + iter][:,:,idx];
    if st == 'Gavg': return data['avgGreen/' + iter][:,:, corr_id][:,:,idx];
    if st == 'hybmat': return data['SolverData/Hybmat/' + iter][:,:,idx];
    if st == 'hybtau': return data['SolverData/Hybtau/' + iter][:,:,idx];
    if st == 'Gtau': return data['SolverData/Gtau/' + iter][:,:,idx];
    if st == 'G0': return 1. / data['WeissField/' + iter][:,:,idx];
    if st == 'bG': return getFermiDOS(data, iter);
    if st == 'Gtot': return getTotalGtau(data, iter);
    if st == 'Z'   : return getRenormFactor(data, npoint = 2, it = iter);