def _ready_file(self, hf, config, git_revision, start_time): # generate HDF5 file and write important metadata hf.attrs["outfile-version"] = _aux.OUTPUT_VERSION hf.attrs["code-version"] = _aux.CODE_VERSION if git_revision is not None: hf.attrs["git-revision"] = git_revision hf.attrs["run-date"] = time.strftime("%c", start_time) # write configureation of current run hfgrp = hf.create_group(".config") for key, val in _flat_items(config): if val is None: continue hfgrp.attrs[key.lower()] = val # write environment of current run hfgrp = hf.create_group(".environment") for k, v in os.environ.iteritems(): if v is None: continue hfgrp.attrs[k] = v # write metadata for possible axes objects ax = hf.create_group(".axes") beta = config["General"]["beta"] qcfg = config["QMC"] ax.create_dataset("iw", data=_tf.matfreq(beta, "fermi", 2 * qcfg["Niw"])) ax.create_dataset("tau", data=np.linspace(0, beta, qcfg["Ntau"])) ax.create_dataset("tauf", data=np.linspace(0, beta, qcfg["Nftau"])) ax.create_dataset("taubin", data=_tf.tau_bins(beta, qcfg["Ntau"], 'centre')) ax.create_dataset("tausus", data=np.linspace(0, beta, qcfg["Ntau"] + 1)) ax.create_dataset("tau-g4", data=_tf.tau_bins(beta, qcfg["N4tau"], 'centre')) ax.create_dataset("iwb-g4", data=_tf.matfreq(beta, 'bose', 2 * qcfg["N4iwb"] + 1)) ax.create_dataset("iwf-g4", data=_tf.matfreq(beta, 'fermi', 2 * qcfg["N4iwf"])) ax.create_dataset("iwf-g2", data=_tf.matfreq(beta, 'fermi', 2 * (qcfg["N4iwf"] + qcfg["N4iwb"]))) ax.create_dataset("iwb-p2", data=_tf.matfreq(beta, 'bose', 2 * qcfg["N2iwb"] + 1)) ax.create_dataset("iwf-p3", data=_tf.matfreq(beta, 'fermi', 2 * qcfg["N3iwf"])) ax.create_dataset("iwb-p3", data=_tf.matfreq(beta, 'bose', 2 * qcfg["N3iwf"] + 1)) # create group for quantity metadata self._qtty_meta = hf.create_group(".quantities") # create start iteration hiter = hf.create_group("start") hiter.attrs["desc"] = "DMFT initial data" hf.flush() return hiter
log("Generating list of atoms ...") latt_type = cfg["General"]["DOS"] norbitals = mylattice.norbitals nspins = mylattice.nspins atom_list = config.atomlist_from_cfg(cfg, norbitals) epseq = cfg["General"]["EPSEQ"] equiv = atoms.check_equivalence( None, atom_list, lambda at1, at2: (at1.nd == at2.nd and at1.typ == at2.typ and at1.se_shift == at2.se_shift and interaction.similar(at1.dd_int, at2.dd_int, epseq))) log("Equivalence before G0 check: %s", equiv) # Compute G0 beta = cfg["General"]["beta"] iwf = tf.matfreq(beta, 'fermi', niw) paramag = cfg["General"]["magnetism"] == "para" eqmaxfreq = cfg["General"]["eqmaxfreq"] eqslice = slice(iwf.searchsorted(0), iwf.searchsorted(eqmaxfreq) + 1) siw_zero = np.zeros((iwf.size, mylattice.norbitals, mylattice.nspins, mylattice.norbitals, mylattice.nspins), complex) log("Checking equivalence of d-d blocks (checking %d frequencies) ...", eqslice.stop - eqslice.start) chk_lattice = mylattice if use_mpi: chk_lattice = mpi.MPILattice(chk_lattice) glociw_eq = chk_lattice.gloc(iwf[eqslice], mylattice.mu, siw_zero[eqslice]) equiv = atoms.check_equivalence( equiv, atom_list, lambda at1, at2: np.allclose(
def __init__(self, beta, lattice, ineq_list, niwf, nftau, dc_dp, dc_dp_orbitals, GW, GW_KAverage, natoms, dc=None, udd_full=None, udp_full=None, upp_full=None, paramag=False, siw_mixer=None, mu_mixer=None, mpi_comm=None): if beta < 0: raise ValueError("beta must be positive") if niwf <= 0 or niwf % 2 != 0: raise ValueError("niwf must be even") if nftau <= 1: raise ValueError("nftau must be greater than 1") if dc is None: dc = doublecounting.Zero() if siw_mixer is None: siw_mixer = mixing.FlatMixingDecorator(mixing.LinearMixer()) if mu_mixer is None: mu_mixer = mixing.LinearMixer() self.mpi_comm = mpi_comm self.beta = beta self.lattice = lattice self.ineq_list = ineq_list self.dc = dc self.udd_full = udd_full self.udp_full = udp_full self.upp_full = upp_full self.paramag = paramag if self.udp_full is None or upp_full is None: self.use_hartree = False else: self.use_hartree = udp_full.any() or upp_full.any() self.siw_mixer = siw_mixer self.mu_mixer = mu_mixer self._eye = lattice.eye self.niwf = niwf self.iwf = tf.matfreq(beta, 'fermi', niwf) if self.mpi_comm is not None: self.mpi_strategy = FrequencyDistribution(mpi_comm, self.niwf) self.my_slice = self.mpi_strategy.myslice else: self.my_slice = slice(None) self.my_iwf = self.iwf[self.my_slice] self.my_niwf = self.iwf.size self.nftau = nftau # build transformation yourself since it potentially only contains part # of the frequency axis self.tauf = np.arange(nftau) * self.beta / (nftau - 1.0) # Fixing d-p distance self.dc_dp = dc_dp self.dc_dp_orbitals = dc_dp_orbitals self.dc_dp_shift = None # GW Inclusion self.use_gw = GW self.use_gw_kaverage = GW_KAverage if self.use_gw == 1: try: dummy_try = self.lattice.nkpoints except: print( '********* GW MODULE IS NOT AVAILABLE FOR BETHE LATTICE *********' ) print('...exiting') exit() self.gw = gw.GWInclusion(self.lattice.norbitals, natoms, self.lattice.nkpoints, self.my_niwf, self.paramag, self.use_gw_kaverage) self.siw_gw = None self.smom_gw = None self.natoms = natoms
log("Generating list of atoms ...") latt_type = cfg["General"]["DOS"] norbitals = mylattice.norbitals nspins = mylattice.nspins atom_list = config.atomlist_from_cfg(cfg, norbitals) epseq = cfg["General"]["EPSEQ"] equiv = atoms.check_equivalence( None, atom_list, lambda at1, at2: (at1.nd == at2.nd and at1.typ == at2.typ and at1.se_shift == at2.se_shift and interaction.similar(at1.dd_int, at2.dd_int, epseq))) log("Equivalence before G0 check: %s", equiv) # Compute G0 beta = cfg["General"]["beta"] iwf = tf.matfreq(beta, 'fermi', niw) paramag = cfg["General"]["magnetism"] == "para" eqmaxfreq = cfg["General"]["eqmaxfreq"] eqslice = slice(iwf.searchsorted(0), iwf.searchsorted(eqmaxfreq) + 1) siw_zero = np.zeros((iwf.size, mylattice.norbitals, mylattice.nspins, mylattice.norbitals, mylattice.nspins), complex) log("Checking equivalence of d-d blocks (checking %d frequencies) ...", eqslice.stop - eqslice.start) chk_lattice = mylattice if use_mpi: chk_lattice = mpi.MPILattice(chk_lattice) glociw_eq = chk_lattice.gloc(iwf[eqslice], mylattice.mu, siw_zero[eqslice]) equiv = atoms.check_equivalence( equiv, atom_list, lambda at1, at2: np.allclose(
def __init__(self, hk, beta, niw, leadsw, w_hyb, nleads, check_herm=False, deltino=1e-1): #GS:def __init__(self, hk, leadsw, w_hyb, nleads, beta, check_herm=False): #GS: set up of Hk exactly as in KspaceHamiltonian. #GS: Moments of H(k) need not to be redifined, right (Angelo)?? Check Eq. B.18 of Angelo's PhD Thesis #GS: In the moments of G0 there is however also a contribution from V (Eq. B.21), which will have to be taken into account at some point KspaceHamiltonian.__init__(self, beta, hk, check_herm=True) print("norbitals, nspins, nflavours = ", self.norbitals, self.nspins, self.nflavours) print("total # of Matsubara (positive + negative) = ", niw) # store the Delta(w) for the computation of the DOS self.leadsw = leadsw.transpose(5, 0, 1, 2, 3, 4) self.w = w_hyb self.deltino = deltino #GS: add also a check that # of k-points is really 1 (ask Angelo) #GS: we now call read_ImHyb as well as the transformation function to get leadsiw. We should then define moments from leadsiw #GSAV if nleads: #GSAV print "check: after read_ImHyb", leadsw.shape, nleads #GS: add a check that the dimension of the lead matrix is compatible with nflavours #GS: initialize self.leadsiw --> this is not optimal, as if readleads=False, then you would have no attribut leadsiw for the nano-class self.leadsiw, leadsmom = self.get_leadsiw(leadsw, w_hyb, nleads, beta, niw) self.iwleads = tr.matfreq(beta, 'fermi', niw) #GS: now transform each of these to matsubara and then fill self.leadsiw in #GS: leadsiw = tr.transform(tr.wre2mat(beta, w_hyb-hk[0,0,0,0,0].real, 'fermi', 800), leadsw) # <-- this is needed if ImDelta(w) is symmetric #GS!!!!!! leadsiw = tr.transform(tr.wre2mat(beta, w_hyb, 'fermi', niw), leadsw) #wre2mat wants the total # of Matsubara, positive + negative #GS: leadsiw = tr.wre2mat_quad(beta, w_hyb, leadsw, 'fermi', 2) # replace 10 with a parameter and don't forget to add hk (or hk.mean?) #GS: In order to use it as argument for the function transform, the frequency must be the last argument: #GS!!!!!! leadsiw = leadsiw.transpose(5, 0, 1, 2, 3, 4) # w, lead, band, spin, band, spin print("leadsiw -> ", self.leadsiw.shape) #GS: add hk[0:...] to the real part of leadsiw # leadsiw.real += hk[0,...].real #adding a (band, spin, band, spin) array to a (w, lead, band, spin, band, spin) one #GS:!!!!! leadsiw.real += hk.mean(0).real #here I am less sure about the right indices, but it seems to work. Ask Markus! #GS: add a check that the imaginary part of hk is zero..... #GS: leadsiw needs to be put in the right form, if spin_orbit=false #GS:!!!!! if not self.spinorbit: #GS: self.leadsiw = np.zeros_like(leadsiw) # in case of spin-independent Hamiltonians, we copy twice to the diagonal #GS:!!!!! self.leadsiw[:, :, :, :1, :, :1] = leadsiw #GS:!!!!! self.leadsiw[:, :, :, 1:2, :, 1:2] = leadsiw #GS:!!!!! else: #GS:!!!!! self.leadsiw=leadsiw #GS:!!!!else: #GS:!!!!! self.leadsiw = 0 # set "non-interacting moments": those from H(k) *and* from leadsiw self.hloc = self.hk.mean(0) self.hmom2 = np.einsum( "kasbt,kbtcu->ascu", self.hk, self.hk) / self.nkpoints - self.hloc**2 + leadsmom.sum(1) print("LMOM") print(leadsmom.sum(1))