def test_mpi(self): a = Toto(0) if mpi.is_master_node(): a = Toto(1) mpi.bcast(a) self.assertEqual(a, Toto(1))
def is_vasp_running(vasp_pid): """ Tests if VASP initial process is still alive. """ pid_exists = False if mpi.is_master_node(): try: os.kill(vasp_pid, 0) except OSError as e: pid_exists = e.errno == errno.EPERM else: pid_exists = True pid_exists = mpi.bcast(pid_exists) return pid_exists
gf_struct = [('dn',3), ('up',3)] beta = 10 # create GF for comparison G_tau = atomic_g_tau(ad, beta, gf_struct, 400) G_iw = atomic_g_iw(ad, beta, gf_struct, 100) G_l = atomic_g_l(ad, beta, gf_struct, 20) G_w = atomic_g_w(ad, beta, gf_struct, (-2, 2), 400, 0.01) ad_bcast = None if mpi.is_master_node(): ad_bcast = ad else: ad = None ad_bcast = mpi.bcast(ad_bcast) assert isinstance(ad_bcast, AtomDiagReal) # GF (real) G_tau_bcast = atomic_g_tau(ad_bcast, beta, gf_struct, 400) G_iw_bcast = atomic_g_iw(ad_bcast, beta, gf_struct, 100) G_l_bcast = atomic_g_l(ad_bcast, beta, gf_struct, 20) G_w_bcast = atomic_g_w(ad_bcast, beta, gf_struct, (-2, 2), 400, 0.01) assert_block_gfs_are_close(G_tau_bcast, G_tau) assert_block_gfs_are_close(G_iw_bcast, G_iw) assert_block_gfs_are_close(G_l_bcast, G_l) assert_block_gfs_are_close(G_w_bcast, G_w)
G=BlockGf(name_list = ["ch","sp"],block_list = [g,g]) assert G['ch'].data.shape==(200,199,1,1,1) A=HDFArchive("g_multivar_3.h5",'w') A["G"] = G del A #mpi bcast import triqs.utility.mpi as mpi g2=Gf(mesh = mprod, target_shape = [1,1,1]) if mpi.is_master_node(): g2.data[:,:,:,:,:] = 5 assert g2.data[0,0,0,0,0] == 5, "not ok : %s"%(g2.data[0,0,0,0,0]) if not mpi.is_master_node(): assert g2.data[0,0,0,0,0] == 0, "not ok : %s"%(g2.data[0,0,0,0,0]) g2 = mpi.bcast(g2) if not mpi.is_master_node(): assert g2.data[0,0,0,0,0] == 5, "not ok : %s"%(g2.data[0,0,0,0,0]) #ImTime ##construct product mesh m1=MeshImTime(beta=1., S="Fermion", n_max=100) m2=MeshImTime(beta=1., S="Boson", n_max=100) mprod=MeshProduct(m1,m2) g=Gf(mesh = mprod, target_shape = [1,1,1]) f=Gf(mesh = mprod, target_shape =[1,1,1]) g.data[:]=2.5 f.data[:]=2.5 #operations #inplace f+=g
"dft_tools_version"] = dft_tools_version.dft_tools_hash if 'iteration_count' in ar['DMFT_results']: iteration_offset = ar['DMFT_results']['iteration_count'] + 1 S.Sigma_iw = ar['DMFT_results']['Iterations']['Sigma_it' + str(iteration_offset - 1)] SK.dc_imp = ar['DMFT_results']['Iterations']['dc_imp' + str(iteration_offset - 1)] SK.dc_energ = ar['DMFT_results']['Iterations']['dc_energ' + str(iteration_offset - 1)] SK.chemical_potential = ar['DMFT_results']['Iterations'][ 'chemical_potential' + str(iteration_offset - 1)].real ar['DMFT_input']["dmft_script_it" + str(iteration_offset)] = open( sys.argv[0]).read() iteration_offset = mpi.bcast(iteration_offset) S.Sigma_iw = mpi.bcast(S.Sigma_iw) SK.dc_imp = mpi.bcast(SK.dc_imp) SK.dc_energ = mpi.bcast(SK.dc_energ) SK.chemical_potential = mpi.bcast(SK.chemical_potential) # Calc the first G0 SK.symm_deg_gf(S.Sigma_iw, orb=0) SK.put_Sigma(Sigma_imp=[S.Sigma_iw]) SK.calc_mu(precision=0.01) S.G_iw << SK.extract_G_loc()[0] SK.symm_deg_gf(S.G_iw, orb=0) #Init the DC term and the self-energy if no previous iteration was found if iteration_offset == 0: dm = S.G_iw.density()
def is_vasp_lock_present(): res_bool = False if mpi.is_master_node(): res_bool = os.path.isfile('./vasp.lock') res_bool = mpi.bcast(res_bool) return res_bool
#Converter = Wien2kConverter(filename=dft_filename, repacking=True) #Converter.convert_dft_input() #mpi.barrier() previous_runs = 0 previous_present = False if mpi.is_master_node(): with HDFArchive(dft_filename + '.h5', 'a') as f: if 'dmft_output' in f: ar = f['dmft_output'] if 'iterations' in ar: previous_present = True previous_runs = ar['iterations'] else: f.create_group('dmft_output') previous_runs = mpi.bcast(previous_runs) previous_present = mpi.bcast(previous_present) SK = SumkDFT(hdf_file=dft_filename + '.h5', use_dft_blocks=use_blocks, h_field=h_field) n_orb = SK.corr_shells[0]['dim'] l = SK.corr_shells[0]['l'] spin_names = ["up", "down"] orb_names = [i for i in range(n_orb)] # Use GF structure determined by DFT blocks gf_struct = [(block, indices) for block, indices in SK.gf_struct_solver[0].items()]
4, 5, 1, 9, 8, 0, 4, 5, 3, 2, 4, 8, 8, 6, 4, 3, 5, 3, 9, 8, 1, 0, 4, 2, 2, 0, 5, 8, 6, 6, 2, 3, 5, 3, 8, 5, 2, 3, 4, 3, 4, 1, 0, 4, 0, 0, 8, 4, 3, 5, 8, 4, 5, 3, 5, 4, 7, 7, 0, 2, 5, 9, 0, 9, 2, 8, 0, 4, 2, 2, 0, 2, 3, 0, 9, 6, 9, 7, 2, 4, 9, 7, 0, 3, 8, 0, 0, 7, 8, 7, 6, 4, 0, 3, 7, 1, 9, 2, 8, 1, 2, 6, 4, 8, 9, 6, 2, 9, 9, 2, 8, 4, 1, 0, 7, 5, 9, 0, 4, 8, 0, 0, 4, 3, 7, 5, 7, 7, 5, 0, 5, 8, 8, 7, 2, 7]) h_ref = py_histogram(x) h = Histogram(0, 10) h << x else: h, h_ref = None, None h = mpi.bcast(h) h_ref = mpi.bcast(h_ref) for rank in range(mpi.size): if rank == mpi.rank: print('-'*72) print('rank =', mpi.rank) print('h =\n', h) print('h_ref =\n', h_ref) # -- Compare h and h_ref pts = np.array([ int(h.mesh_point(idx)) for idx in range(len(h))]) for pt, val in zip(pts, h.data): val = int(val)
# # You may obtain a copy of the License at # https:#www.gnu.org/licenses/gpl-3.0.txt # # Authors: Olivier Parcollet, Nils Wentzell # Import the Green's functions from triqs.gf import GfImFreq, iOmega_n, inverse # Create the Matsubara-frequency Green's function and initialize it g = GfImFreq(indices=[1], beta=50, n_points=1000, name="imp") g << inverse(iOmega_n + 0.5) import triqs.utility.mpi as mpi mpi.bcast(g) #Block from triqs.gf import * g1 = GfImFreq(indices=['eg1', 'eg2'], beta=50, n_points=1000, name="egBlock") g2 = GfImFreq(indices=['t2g1', 't2g2', 't2g3'], beta=50, n_points=1000, name="t2gBlock") G = BlockGf(name_list=('eg', 't2g'), block_list=(g1, g2), make_copies=False) mpi.bcast(G) #imtime from triqs.gf import *
A2 = 2 * A print("A ", A) assert (A2["up"] == 2 * m0).all() and ( A2["dn"] == 2 * m1).all(), "Multiplication by constant failed" A2 = A * 2 assert (A2["up"] == 2 * m0).all() and ( A2["dn"] == 2 * m1).all(), "Multiplication by constant failed" A2 = A / 2 assert (A2["up"] == 0.5 * m0).all() and ( A2["dn"] == 0.5 * m1).all(), "Division by constant failed" A2 = -A assert (A2["up"] == -m0).all() and (A2["dn"] == -m1).all(), "Unary minus failed" # MPI Abcast = mpi.bcast(A) assert (A['up'] == Abcast['up']).all() and (A['dn'] == Abcast['dn']).all(), "mpi.bcast failed" # HDF5 with HDFArchive("block_matrix.output.h5", 'w') as R: R["A"] = A with HDFArchive("block_matrix.output.h5", 'r') as R: A2 = R["A"] assert (A['up'] == A2['up']).all() and (A['dn'] == A2['dn']).all(), "HDF5 write/read failed" ######################## # Complex block matrix #
del A2 assert G3.data.shape == G.data.shape, "not ok:%s vs %s" % (G3.data.shape, G.data.shape) #mpi bcast import triqs.utility.mpi as mpi G4 = GfImFreq(beta=1., statistic="Fermion", n_points=100, indices=[['a'], ['b1', 'b2'], ['c1', 'c2']]) if mpi.is_master_node(): G4.data[:, :, :, :] = 5 assert G4.data[0, 0, 0, 0] == 5, "not ok :%s" % (G4.data[0, 0, 0, 0]) if not mpi.is_master_node(): assert G4.data[0, 0, 0, 0] == 0, "not ok" G4 = mpi.bcast(G4) if not mpi.is_master_node(): assert G4.data[0, 0, 0, 0] == 5, "not ok :%s" % (G4.data[0, 0, 0, 0]) ##Tv4 print("#############################") G5 = GfImFreq(mesh=m, indices=[['a'], ['b1', 'b2'], ['c1', 'c2'], ['c']]) print(G5.data.shape) assert G5.data.shape == (20, 1, 2, 2, 1), "not ok" assert G5['a', 'b1', 'c2', 'c'].data.shape == (20, ), "not ok" #ImTime, print("#############################") G6 = GfImTime(beta=1., statistic="Fermion",
# Authors: Hugo U. R. Strand, Nils Wentzell """ Dimension of bz mesh is reduced from 3 to 2 by broadcasting it over mpi... Author: H. U.R. Strand (2019) """ import numpy as np from triqs.gf import MeshBrZone from triqs.lattice.lattice_tools import BrillouinZone from triqs.lattice.lattice_tools import BravaisLattice bl = BravaisLattice(np.eye(3), [(0, 0, 0)]) bz = BrillouinZone(bl) mesh = MeshBrZone(bz, 8 * np.eye(3, dtype=int)) import triqs.utility.mpi as mpi if mpi.is_master_node(): m = MeshBrZone(bz, 8 * np.eye(3, dtype=int)) else: m = None m = mpi.bcast(m) print(mesh) print(m) assert (mesh.domain.lattice.ndim == m.domain.lattice.ndim)
def _main_mpi(model_hdf5_file, input_file, output_file): """ Launch SumkDFT and compute chemical potential, local Green's function and density matrix This function depends on MPI through DFTTools. Do not call this from non-MPI module directly. """ import triqs.utility.mpi as mpi # read HDF5 file on the master node if mpi.is_master_node(): with HDFArchive(input_file, 'r') as h: params = h['params'] keys = list(params.keys()) else: params = {} keys = [] assert isinstance(params, dict) # broadcast parameters keys = mpi.bcast(keys) for key in keys: if not mpi.is_master_node(): params[key] = None params[key] = mpi.bcast(params[key]) beta = params['beta'] with_dc = params['with_dc'] results = {} def add_potential(_sigma, _pot): sigma_plus_pot = _sigma.copy() for sp, sigma in sigma_plus_pot: sigma += _pot[sp] return sigma_plus_pot def setup_sk(sk, iwn_or_w_or_none): if iwn_or_w_or_none == 'iwn': assert len(params['Sigma_iw_sh']) == len(params['potential']) Sigma_iw_sh_plus_pot = [ add_potential(sigma, pot) for sigma, pot in zip( params['Sigma_iw_sh'], params['potential']) ] sk.set_Sigma(Sigma_iw_sh_plus_pot) elif iwn_or_w_or_none == 'w': # sk.set_Sigma([params['Sigma_w_sh'][ish] for ish in range(sk.n_inequiv_shells)]) Sigma_w_sh = [ params['Sigma_w_sh'][ish] for ish in range(sk.n_inequiv_shells) ] Sigma_w_sh_plus_pot = [ add_potential(sigma, pot) for sigma, pot in zip(Sigma_w_sh, params['potential']) ] sk.set_Sigma(Sigma_w_sh_plus_pot) elif iwn_or_w_or_none == "none": pass else: raise RuntimeError("Invalid iwn_or_w") if params['with_dc']: sk.set_dc(params['dc_imp'], params['dc_energ']) sk.set_mu(params['mu']) if params['calc_mode'] == 'Gloc': from triqs_dft_tools import SumkDFT sk = SumkDFT(hdf_file=model_hdf5_file, use_dft_blocks=False, h_field=0.0) setup_sk(sk, 'iwn') if params['adjust_mu']: # find the chemical potential for given density sk.calc_mu(params['prec_mu']) results['mu'] = float(sk.chemical_potential) # Local Green's function and Density matrix results['Gloc_iw_sh'] = sk.extract_G_loc(with_dc=with_dc) dm = sk.density_matrix(beta=beta) for ish in range(len(dm)): for b in list(dm[ish].keys()): dm[ish][b] = numpy.conj(dm[ish][b]) results['dm_sh'] = dm elif params['calc_mode'] == 'dos': # Compute dos from .sumkdft_post import SumkDFTDCorePost sk = SumkDFTDCorePost(hdf_file=model_hdf5_file, use_dft_blocks=False, h_field=0.0) setup_sk(sk, 'w') results['dos'], results['dosproj'], results['dosproj_orb'] = \ sk.dos_wannier_basis(broadening=params['broadening'], mesh=params['mesh'], with_Sigma=True, with_dc=with_dc, save_to_file=False) elif params['calc_mode'] == 'spaghettis': # A(k, omega) from .sumkdft_post import SumkDFTDCorePost sk = SumkDFTDCorePost(hdf_file=model_hdf5_file, use_dft_blocks=False, h_field=0.0, bands_data=params['bands_data']) setup_sk(sk, 'w') results['akw'] = sk.spaghettis(broadening=params['broadening'], plot_range=None, ishell=None, save_to_file=None) elif params['calc_mode'] == 'momentum_distribution': # n(k) from .sumkdft_post import SumkDFTDCorePost sk = SumkDFTDCorePost(hdf_file=model_hdf5_file, use_dft_blocks=False, h_field=0.0) setup_sk(sk, 'iwn') results['den'] = \ sk.calc_momentum_distribution(mu=params["mu"], beta=beta, with_Sigma=True, with_dc=True) elif params['calc_mode'] == 'bse': # chi0 from dft_tools.sumk_dft_chi import SumkDFTChi # save div data (overwrite if data exist) if mpi.is_master_node(): with HDFArchive(model_hdf5_file, 'a') as ar: if 'dft_input_chi' in ar: del ar['dft_input_chi'] ar.create_group('dft_input_chi') ar['dft_input_chi']['div'] = numpy.array(params['div']) # check if IBZ and FBZ data are saved separately dft_data_fbz = 'dft_input' if mpi.is_master_node(): with HDFArchive(model_hdf5_file, 'r') as ar: if 'dft_input_fbz' in ar: dft_data_fbz = 'dft_input_fbz' dft_data_fbz = mpi.bcast(dft_data_fbz) sk = SumkDFTChi(hdf_file=model_hdf5_file, use_dft_blocks=False, h_field=0.0, dft_data_fbz=dft_data_fbz) setup_sk(sk, 'iwn') temp_file = None if params['use_temp_file']: temp_file = 'G_k_iw_temp.h5' sk.save_X0q_for_bse(list_wb=params['list_wb'], n_wf_cutoff=params['n_wf_G2'], qpoints_saved=params['X0q_qpoints_saved'], h5_file=params['bse_h5_out_file'], temp_file=temp_file, nonlocal_order_parameter=False) else: raise RuntimeError("Unknown calc_mode: " + str(params['calc_mode'])) if mpi.is_master_node(): with HDFArchive(output_file, 'w') as h: for k, v in list(results.items()): h[k] = v
chemical_potential0 = 0.0 if mpi.is_master_node(): ar = HDFArchive(filename+'.h5','a') if 'iteration_count' in ar['DMFT_results']: previous_present = True iteration_offset = ar['DMFT_results']['iteration_count']+1 print('reading iteration'+str(iteration_offset)) SK_tools.dc_imp = ar['DMFT_results']['Iterations']['dc_imp'+str(iteration_offset-1)] S.Sigma_w = ar['DMFT_results']['Iterations']['Sigma_w_it'+str(iteration_offset-1)] dc_energ = ar['DMFT_results']['Iterations']['dc_energ'+str(iteration_offset-1)] SK_tools.chemical_potential = ar['DMFT_results']['Iterations']['chemical_potential'+str(iteration_offset-1)].real chemical_potential0 = ar['DMFT_results']['Iterations']['chemical_potential0'].real mpi.barrier() S.Sigma_w << mpi.bcast(S.Sigma_w) SK_tools.chemical_potential = mpi.bcast(SK_tools.chemical_potential) chemical_potential0 = mpi.bcast(chemical_potential0) SK_tools.dc_imp = mpi.bcast(SK_tools.dc_imp) SK_tools.put_Sigma(Sigma_imp = [S.Sigma_w]) idelta = 0.1 DOS, DOSproj, DOSproj_orb = SK_tools.dos_wannier_basis(broadening=idelta, with_dc=True, with_Sigma=True) SK_tools.chemical_potential = chemical_potential0 SK_tools.put_Sigma(Sigma_imp = [0.0*S.Sigma_w]) idelta = 0.1 DOS0, DOSproj0, DOSproj0_orb = SK_tools.dos_wannier_basis(broadening=idelta, with_dc=False, with_Sigma=True) if mpi.is_master_node(): ar['DMFT_results']['Iterations']['DOS_it'+str(iteration_offset-1)] = DOS ar['DMFT_results']['Iterations']['DOSproj_orb_it'+str(iteration_offset-1)] = DOSproj_orb
def dmft_cycle(): filename = 'nio' Converter = VaspConverter(filename=filename) Converter.convert_dft_input() SK = SumkDFT(hdf_file = filename+'.h5', use_dft_blocks = False) beta = 5.0 Sigma = SK.block_structure.create_gf(beta=beta) SK.put_Sigma([Sigma]) G = SK.extract_G_loc() SK.analyse_block_structure_from_gf(G, threshold = 1e-2) for i_sh in range(len(SK.deg_shells)): num_block_deg_orbs = len(SK.deg_shells[i_sh]) mpi.report('found {0:d} blocks of degenerate orbitals in shell {1:d}'.format(num_block_deg_orbs, i_sh)) for iblock in range(num_block_deg_orbs): mpi.report('block {0:d} consists of orbitals:'.format(iblock)) for keys in list(SK.deg_shells[i_sh][iblock].keys()): mpi.report(' '+keys) # Setup CTQMC Solver n_orb = SK.corr_shells[0]['dim'] spin_names = ['up','down'] orb_names = [i for i in range(0,n_orb)] #gf_struct = set_operator_structure(spin_names, orb_names, orb_hyb) gf_struct = SK.gf_struct_solver[0] mpi.report('Sumk to Solver: %s'%SK.sumk_to_solver) mpi.report('GF struct sumk: %s'%SK.gf_struct_sumk) mpi.report('GF struct solver: %s'%SK.gf_struct_solver) S = Solver(beta=beta, gf_struct=gf_struct) # Construct the Hamiltonian and save it in Hamiltonian_store.txt H = Operator() U = 8.0 J = 1.0 U_sph = U_matrix(l=2, U_int=U, J_hund=J) U_cubic = transform_U_matrix(U_sph, spherical_to_cubic(l=2, convention='')) Umat, Upmat = reduce_4index_to_2index(U_cubic) H = h_int_density(spin_names, orb_names, map_operator_structure=SK.sumk_to_solver[0], U=Umat, Uprime=Upmat) # Print some information on the master node mpi.report('Greens function structure is: %s '%gf_struct) mpi.report('U Matrix set to:\n%s'%Umat) mpi.report('Up Matrix set to:\n%s'%Upmat) # Parameters for the CTQMC Solver p = {} p["max_time"] = -1 p["random_name"] = "" p["random_seed"] = 123 * mpi.rank + 567 p["length_cycle"] = 100 p["n_warmup_cycles"] = 2000 p["n_cycles"] = 20000 p["fit_max_moment"] = 4 p["fit_min_n"] = 30 p["fit_max_n"] = 50 p["perform_tail_fit"] = True # Double Counting: 0 FLL, 1 Held, 2 AMF DC_type = 0 DC_value = 59.0 # Prepare hdf file and and check for previous iterations n_iterations = 1 iteration_offset = 0 if mpi.is_master_node(): ar = HDFArchive(filename+'.h5','a') if not 'DMFT_results' in ar: ar.create_group('DMFT_results') if not 'Iterations' in ar['DMFT_results']: ar['DMFT_results'].create_group('Iterations') if not 'DMFT_input' in ar: ar.create_group('DMFT_input') if not 'Iterations' in ar['DMFT_input']: ar['DMFT_input'].create_group('Iterations') if not 'code_versions' in ar['DMFT_input']: ar['DMFT_input'].create_group('code_versio\ ns') ar['DMFT_input']['code_versions']["triqs_version"] = triqs_version.version ar['DMFT_input']['code_versions']["triqs_git"] = triqs_version.git_hash ar['DMFT_input']['code_versions']["cthyb_version"] = cthyb_version.version ar['DMFT_input']['code_versions']["cthyb_git"] = cthyb_version.triqs_cthyb_hash ar['DMFT_input']['code_versions']["dft_tools_version"] = dft_tools_version.version ar['DMFT_input']['code_versions']["dft_tools_git"] = dft_tools_version.triqs_dft_tools_hash if 'iteration_count' in ar['DMFT_results']: iteration_offset = ar['DMFT_results']['iteration_count']+1 S.Sigma_iw = ar['DMFT_results']['Iterations']['Sigma_it'+str(iteration_offset-1)] SK.dc_imp = ar['DMFT_results']['Iterations']['dc_imp'+str(iteration_offset-1)] SK.dc_energ = ar['DMFT_results']['Iterations']['dc_energ'+str(iteration_offset-1)] SK.chemical_potential = ar['DMFT_results']['Iterations']['chemical_potential'+str(iteration_offset-1)].real ar['DMFT_input']["dmft_script_it"+str(iteration_offset)] = open(sys.argv[0]).read() iteration_offset = mpi.bcast(iteration_offset) S.Sigma_iw = mpi.bcast(S.Sigma_iw) SK.dc_imp = mpi.bcast(SK.dc_imp) SK.dc_energ = mpi.bcast(SK.dc_energ) SK.chemical_potential = mpi.bcast(SK.chemical_potential) # Calc the first G0 SK.symm_deg_gf(S.Sigma_iw, ish=0) SK.put_Sigma(Sigma_imp = [S.Sigma_iw]) SK.calc_mu(precision=0.01) S.G_iw << SK.extract_G_loc()[0] SK.symm_deg_gf(S.G_iw, ish=0) #Init the DC term and the self-energy if no previous iteration was found if iteration_offset == 0: dm = S.G_iw.density() SK.calc_dc(dm, U_interact=U, J_hund=J, orb=0, use_dc_formula=DC_type,use_dc_value=DC_value) S.Sigma_iw << SK.dc_imp[0]['up'][0,0] mpi.report('%s DMFT cycles requested. Starting with iteration %s.'%(n_iterations,iteration_offset)) # The infamous DMFT self consistency cycle for it in range(iteration_offset, iteration_offset + n_iterations): mpi.report('Doing iteration: %s'%it) # Get G0 S.G0_iw << inverse(S.Sigma_iw + inverse(S.G_iw)) # Solve the impurity problem S.solve(h_int = H, **p) if mpi.is_master_node(): ar['DMFT_input']['Iterations']['solver_dict_it'+str(it)] = p ar['DMFT_results']['Iterations']['Gimp_it'+str(it)] = S.G_iw ar['DMFT_results']['Iterations']['Gtau_it'+str(it)] = S.G_tau ar['DMFT_results']['Iterations']['Sigma_uns_it'+str(it)] = S.Sigma_iw # Calculate double counting dm = S.G_iw.density() SK.calc_dc(dm, U_interact=U, J_hund=J, orb=0, use_dc_formula=DC_type,use_dc_value=DC_value) # Get new G SK.symm_deg_gf(S.Sigma_iw, ish=0) SK.put_Sigma(Sigma_imp=[S.Sigma_iw]) SK.calc_mu(precision=0.01) S.G_iw << SK.extract_G_loc()[0] # print densities for sig,gf in S.G_iw: mpi.report("Orbital %s density: %.6f"%(sig,dm[sig][0,0])) mpi.report('Total charge of Gloc : %.6f'%S.G_iw.total_density()) if mpi.is_master_node(): ar['DMFT_results']['iteration_count'] = it ar['DMFT_results']['Iterations']['Sigma_it'+str(it)] = S.Sigma_iw ar['DMFT_results']['Iterations']['Gloc_it'+str(it)] = S.G_iw ar['DMFT_results']['Iterations']['G0loc_it'+str(it)] = S.G0_iw ar['DMFT_results']['Iterations']['dc_imp'+str(it)] = SK.dc_imp ar['DMFT_results']['Iterations']['dc_energ'+str(it)] = SK.dc_energ ar['DMFT_results']['Iterations']['chemical_potential'+str(it)] = SK.chemical_potential if mpi.is_master_node(): print('calculating mu...') SK.chemical_potential = SK.calc_mu( precision = 0.000001 ) if mpi.is_master_node(): print('calculating GAMMA') SK.calc_density_correction(dm_type='vasp') if mpi.is_master_node(): print('calculating energy corrections') correnerg = 0.5 * (S.G_iw * S.Sigma_iw).total_density() dm = S.G_iw.density() # compute the density matrix of the impurity problem SK.calc_dc(dm, U_interact=U, J_hund=J, orb=0, use_dc_formula=DC_type,use_dc_value=DC_value) dc_energ = SK.dc_energ[0] if mpi.is_master_node(): ar['DMFT_results']['Iterations']['corr_energy_it'+str(it)] = correnerg ar['DMFT_results']['Iterations']['dc_energy_it'+str(it)] = dc_energ if mpi.is_master_node(): del ar return correnerg, dc_energ