solid-dmft 3.3.4__tar.gz → 3.3.5__tar.gz

{solid_dmft-3.3.4/python/solid_dmft.egg-info → solid_dmft-3.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solid_dmft
-Version: 3.3.4
+Version: 3.3.5
 Summary: solid_dmft: a versatile python wrapper to perform DFT+DMFT calculations utilizing the TRIQS software library
 Author-email: Alexander Hampel <mail@alexander-hampel.de>
 Project-URL: Homepage, https://triqs.github.io/solid_dmft

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/pyproject.toml

@@ -7,7 +7,7 @@ where = ["python"]
 
 [project]
 name = "solid_dmft"
-version = "3.3.4"
+version = "3.3.5"
 authors = [
   { name="Alexander Hampel", email="mail@alexander-hampel.de" }
 ]

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/python/solid_dmft/csc_flow.py

@@ -98,7 +98,7 @@ def _full_qe_run(seedname, dft_params, mode):
 
     # runs a full iteration of DFT
     qe_wrapper = lambda calc_type: qe.run(dft_params['n_cores'], calc_type, dft_params['dft_exec'],
-                                          dft_params['mpi_env'], seedname)
+                                          dft_params['mpi_env'], dft_params['mpi_exe'], seedname)
 
     # Initially run an scf calculation
     if mode == 'initial':
@@ -179,15 +179,23 @@ def _full_vasp_run(general_params, dft_params, initial_run, n_iter_dft=1, sum_k=
     if initial_run:
         assert n_iter_dft == 1
     else:
+        dft_iter_init = vasp.read_dft_iter()
         assert n_iter_dft == 1 or sum_k is not None, 'Sumk object needed to run multiple DFT iterations'
 
     for i in range(n_iter_dft):
         if initial_run:
             vasp_process_id = vasp.run_initial_scf(dft_params['n_cores'], dft_params['dft_exec'],
-                                                   dft_params['mpi_env'])
+                                                   dft_params['mpi_exe'], dft_params['mpi_env'])
         else:
             vasp_process_id = None
             vasp.run_charge_update()
+            dft_iter = vasp.read_dft_iter()
+            mpi.report(f'\nDFT SCF iteration {dft_iter} finished. Running converter:')
+            if not dft_iter == dft_iter_init+i+1:
+                mpi.report(f'DFT iteration number did not increase. Aborting.\n \
+                        DFT iteration {dft_iter} != {dft_iter_init+i+1}')
+                vasp.kill(vasp_process_id)
+                exit()
 
         if dft_params['projector_type'] == 'plo':
             _run_plo_converter(general_params, dft_params)
@@ -221,7 +229,7 @@ def _full_vasp_run(general_params, dft_params, initial_run, n_iter_dft=1, sum_k=
         sum_k.calc_mu(precision=general_params['prec_mu'])
 
         # Writes out GAMMA file
-        sum_k.calc_density_correction(dm_type='vasp',  kpts_to_write=irred_indices)
+        sum_k.calc_density_correction(dm_type='vasp', kpts_to_write=irred_indices, spinave=True)
 
     return vasp_process_id, irred_indices
 

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/python/solid_dmft/dft_managers/mpi_helpers.py

@@ -93,6 +93,11 @@ def find_path_to_mpi_command(env_vars, mpi_exe):
     string: absolute path to mpi command
     """
 
+    # first check if mpi_exe is already full path to executable
+    if os.path.isfile(mpi_exe):
+        return mpi_exe
+
+    # otherwise, check if mpi_exe is in PATH
     for path_directory in env_vars.get('PATH').split(os.pathsep):
         if path_directory:
             potential_path = os.path.join(path_directory, mpi_exe)

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/python/solid_dmft/dft_managers/qe_manager.py

@@ -82,7 +82,7 @@ def _start_with_piping(mpi_exe, mpi_arguments, qe_file_ext, env_vars, seedname):
         subprocess.check_call(mpi_arguments + [seedname], env=env_vars, shell=False)
 
 
-def run(number_cores, qe_file_ext, qe_exec, mpi_profile, seedname):
+def run(number_cores, qe_file_ext, qe_exec, mpi_profile, mpi_exe_param, seedname):
     """
     Starts the VASP child process. Takes care of initializing a clean
     environment for the child process. This is needed so that VASP does not
@@ -111,7 +111,8 @@ def run(number_cores, qe_file_ext, qe_exec, mpi_profile, seedname):
                 env_vars[var_name] = var
 
         # assuming that mpirun points to the correct mpi env
-        mpi_exe = mpi_helpers.find_path_to_mpi_command(env_vars, 'mpirun')
+        mpi_exe = mpi_helpers.find_path_to_mpi_command(env_vars, mpi_exe_param)
+        print('\nMPI executable for QE:', mpi_exe)
 
         if qe_file_ext in ['scf', 'nscf', 'mod_scf', 'bnd']:
             qe_exec += f'pw.x -nk {number_cores}'

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/python/solid_dmft/dft_managers/vasp_manager.py

@@ -36,6 +36,7 @@ import signal
 import time
 import numpy as np
 
+from h5 import HDFArchive
 import triqs.utility.mpi as mpi
 
 from solid_dmft.dft_managers import mpi_helpers
@@ -99,7 +100,7 @@ def remove_legacy_projections_suppressed():
     mpi.barrier()
 
 
-def run_initial_scf(number_cores, vasp_command, cluster_name):
+def run_initial_scf(number_cores, vasp_command, mpi_exe_param, cluster_name):
     """
     Starts the VASP child process. Takes care of initializing a clean
     environment for the child process. This is needed so that VASP does not
@@ -133,7 +134,8 @@ def run_initial_scf(number_cores, vasp_command, cluster_name):
                 env_vars[var_name] = var
 
         # assuming that mpirun points to the correct mpi env
-        mpi_exe = mpi_helpers.find_path_to_mpi_command(env_vars, 'mpirun')
+        mpi_exe = mpi_helpers.find_path_to_mpi_command(env_vars, mpi_exe_param)
+        print('\nMPI executable for Vasp:', mpi_exe)
 
         arguments = mpi_helpers.get_mpi_arguments(cluster_name, mpi_exe, number_cores, vasp_command, hostfile)
         vasp_process_id = _fork_and_start_vasp(mpi_exe, arguments, env_vars)
@@ -171,17 +173,56 @@ def run_charge_update():
 
 def read_dft_energy():
     """
-    Reads DFT energy from the last line of Vasp's OSZICAR.
+    Reads DFT energy from the last line of Vasp's OSZICAR or from vasptriqs.h5
     """
+    if os.path.isfile('vaspout.h5'):
+        with HDFArchive('vaspout.h5', 'r') as h5:
+            if 'oszicar' in h5['intermediate/ion_dynamics']:
+                # h5 access returns a numpy scalar/array; cast defensively
+                return float(np.asarray(h5['intermediate/ion_dynamics/oszicar'][-1, 1]).item())
+
+    # Backup: use OSZICAR file
+    last_nonempty_line = None
     with open('OSZICAR', 'r') as file:
-        nextline = file.readline()
-        while nextline.strip():
-            line = nextline
-            nextline = file.readline()
-    dft_energy = float(line.split()[2])
+        for line in file:
+            if line.strip():
+                last_nonempty_line = line
+
+    if last_nonempty_line is None:
+        raise RuntimeError('OSZICAR is empty (cannot read DFT energy).')
+
+    parts = last_nonempty_line.split()
+    try:
+        # Typical OSZICAR line: "  1 F= -10.123 E0= ..." -> energy at index 2
+        return float(parts[2])
+    except (IndexError, ValueError) as err:
+        raise RuntimeError(f'Failed to parse DFT energy from OSZICAR line: {last_nonempty_line!r}') from err
+
+def read_dft_iter():
+    """
+    Reads DFT iteration number from the last line of the OSZICAR or from Vasp's vasptriqs.h5
+    """
+    if os.path.isfile('vaspout.h5'):
+        with HDFArchive('vaspout.h5', 'r') as h5:
+            if 'oszicar' in h5['intermediate/ion_dynamics']:
+                return int(np.asarray(h5['intermediate/ion_dynamics/oszicar'][-1, 0]).item())
+
+    # Backup: use OSZICAR file
+    last_nonempty_line = None
+    with open('OSZICAR', 'r') as file:
+        for line in file:
+            if line.strip():
+                last_nonempty_line = line
 
-    return dft_energy
+    if last_nonempty_line is None:
+        raise RuntimeError('OSZICAR is empty (cannot read DFT iteration).')
 
+    parts = last_nonempty_line.split()
+    try:
+        # Typical OSZICAR line: "  1 F= -10.123 ..." -> iteration at index 1
+        return int(parts[1])
+    except (IndexError, ValueError) as err:
+        raise RuntimeError(f'Failed to parse DFT iteration from OSZICAR line: {last_nonempty_line!r}') from err
 
 def read_irred_kpoints(kpts):
     """ Reads the indices of the irreducible k-points from the OUTCAR. """
@@ -214,6 +255,7 @@ def read_irred_kpoints(kpts):
         symmetry_mapping = np.full(outcar_kpoints.shape[0], -1, dtype=int)
 
         for i, (kpt_outcar, outcar_index) in enumerate(zip(outcar_kpoints, outcar_indices)):
+            found_match = False
             for j, kpt in enumerate(kpts):
                 if np.allclose(kpt_outcar, kpt):
                     # Symmetry-irreducible k points
@@ -222,10 +264,11 @@ def read_irred_kpoints(kpts):
                     # Symmetry-reducible
                     else:
                         symmetry_mapping[j] = outcar_index
+                    found_match = True
                     break
 
-            # Asserts that loop left through break, i.e. a pair was found
-            assert np.allclose(kpt_outcar, kpt)
+            # Assert that a matching k-point was found
+            assert found_match, f'OUTCAR k-point {kpt_outcar} not found in provided kpts.'
 
         irreds, irred_indices = np.unique(symmetry_mapping, return_index=True)
         assert np.all(np.diff(irreds) == 1)

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/python/solid_dmft/dmft_cycle.py

@@ -293,15 +293,19 @@ def dmft_cycle(general_params, solver_params, advanced_params, dft_params,
         updated observable array for calculation
     """
 
+    # print version info and git hashes
+    mpi.report('\nsolid_dmft version: {} (git hash: {})'.format(solid_dmft_version, solid_dmft_hash))
+    mpi.report('TRIQS version: {} (git hash: {})\n'.format(triqs_version, triqs_hash))
+
     # Creates real- or imaginary-frequency mesh to store Green functions on
     if general_params['beta'] is not None:
-        mpi.report('Running solid_dmft on imag-freq grid because "general.beta" specified')
+        mpi.report('Running solid_dmft on imag-freq grid because "general.beta" specified\n')
         sumk_mesh = MeshImFreq(beta=general_params['beta'],
                                S='Fermion',
                                n_iw=general_params['n_iw'])
         broadening = None
     else:
-        mpi.report('Running solid_dmft on real-freq grid because "general.beta" not specified')
+        mpi.report('Running solid_dmft on real-freq grid because "general.beta" not specified\n')
         sumk_mesh = MeshReFreq(window=general_params['w_range'],
                                n_w=general_params['n_w'])
         broadening = general_params['eta']
@@ -315,7 +319,7 @@ def dmft_cycle(general_params, solver_params, advanced_params, dft_params,
     # if magnetic field is set we make sure that this is a magnetic calculation
     if general_params['h_field'] != 0.0:
         if not general_params['magnetic']:
-            mpi.report('WARNING: Magnetic field set but general.magnetic is False. Setting it to True now.')
+            mpi.report('WARNING: Magnetic field set but general.magnetic is False. Setting it to True now.\n')
             general_params['magnetic'] = True
 
     # determine chemical potential for bare DFT sum_k object
@@ -796,7 +800,7 @@ def _dmft_step(sum_k, solvers, it, general_params, solver_params, gw_params,
     if general_params['csc']:
         # handling the density correction for fcsc calculations
         assert dft_irred_kpt_indices is None or dft_params['dft_code'] == 'vasp'
-        deltaN, dens, E_bandcorr = sum_k.calc_density_correction(dm_type=dft_params['dft_code'],
+        deltaN, dens, E_bandcorr = sum_k.calc_density_correction(dm_type=dft_params['dft_code'], spinave=True,
                                                                  kpts_to_write=dft_irred_kpt_indices)
     elif general_params['calc_energies']:
         # for a one shot calculation we are using our own method

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/python/solid_dmft/dmft_tools/afm_mapping.py

@@ -86,19 +86,30 @@ def apply(general_params, icrsh, gf_struct_solver, solvers):
     mpi.report('\ncopying the self-energy for shell {} from shell {}'.format(icrsh, imp_source))
     mpi.report('inverting spin channels: '+str(invert_spin))
 
-    if solvers[icrsh].solver_params.get('measure_density_matrix'):
-        solvers[icrsh].density_matrix = solvers[imp_source].density_matrix
-        solvers[icrsh].h_loc_diagonalization = solvers[imp_source].h_loc_diagonalization
+    if solvers[icrsh].solver_params.get('measure_density_matrix') or solvers[icrsh].solver_params.get('type') == 'ctseg':
         solvers[icrsh].Sigma_moments = solvers[imp_source].Sigma_moments
         solvers[icrsh].Sigma_Hartree = solvers[imp_source].Sigma_Hartree
-        solvers[icrsh].G_moments = solvers[imp_source].G_moments
         # copy orbital occupations dict with deep copy of arrays
         solvers[icrsh].orbital_occupations = {key: occ.copy() for key, occ in solvers[imp_source].orbital_occupations.items()}
+        if solvers[icrsh].solver_params.get('type') == 'cthyb':
+            solvers[icrsh].G_moments = solvers[imp_source].G_moments
+            solvers[icrsh].density_matrix = solvers[imp_source].density_matrix
+            solvers[icrsh].h_loc_diagonalization = solvers[imp_source].h_loc_diagonalization
+
+    if solvers[icrsh].solver_params.get('type') == 'ctseg' and solvers[icrsh].solver_params.get('measure_state_hist'):
+        solvers[icrsh].state_histogram = solvers[imp_source].state_histogram
 
     # and the same for the perturbation order if measured
     if solvers[icrsh].solver_params.get('measure_pert_order'):
-        solvers[icrsh].perturbation_order = {key: hist for key, hist in solvers[imp_source].perturbation_order.items()}
-        solvers[icrsh].perturbation_order_total = solvers[imp_source].perturbation_order_total
+        if solvers[icrsh].solver_params.get('type') == 'cthyb':
+            solvers[icrsh].perturbation_order = {key: hist for key, hist in solvers[imp_source].perturbation_order.items()}
+            solvers[icrsh].perturbation_order_total = solvers[imp_source].perturbation_order_total
+        elif solvers[icrsh].solver_params.get('type') == 'ctseg':
+            solvers[icrsh].perturbation_order_histo = solvers[imp_source].perturbation_order_histo
+            solvers[icrsh].avg_pert_order = solvers[imp_source].avg_pert_order
+
+    if solvers[icrsh].solver_params.get('type') == 'hartree':
+        solvers[icrsh].DC_energy = solvers[imp_source].DC_energy
 
     if invert_spin:
         for spin_channel in gf_struct_solver.keys():
@@ -113,13 +124,17 @@ def apply(general_params, icrsh, gf_struct_solver, solvers):
             solvers[icrsh].G0_freq[spin_channel] << solvers[imp_source].G0_freq[target_channel]
             solvers[icrsh].G_time[spin_channel] << solvers[imp_source].G_time[target_channel]
 
-            if solvers[icrsh].solver_params.get('measure_pert_order'):
+            if solvers[icrsh].solver_params.get('measure_pert_order') and solvers[icrsh].solver_params.get('type') == 'cthyb':
                 solvers[icrsh].perturbation_order[spin_channel] = solvers[imp_source].perturbation_order[target_channel]
 
             # we also need to swap the orbital occupations, but we skip moments since the whole self-energy is copied anyway
-            if solvers[icrsh].solver_params.get('measure_density_matrix'):
+            if solvers[icrsh].solver_params.get('measure_density_matrix') or solvers[icrsh].solver_params.get('type') == 'ctseg':
                 solvers[icrsh].orbital_occupations[spin_channel] = solvers[imp_source].orbital_occupations[target_channel]
 
+            # and for the hartree solver we also need to copy the real frequency self-energy for the correct spin channel
+            if solvers[icrsh].solver_params.get('type') == 'hartree':
+                solvers[icrsh].Sigma_Refreq[spin_channel] = solvers[imp_source].Sigma_Refreq[target_channel]
+
     else:
         solvers[icrsh].Sigma_freq << solvers[imp_source].Sigma_freq
         solvers[icrsh].G_freq << solvers[imp_source].G_freq

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/python/solid_dmft/dmft_tools/observables.py

@@ -511,7 +511,8 @@ def calc_dft_kin_en(general_params, sum_k, dft_mu):
     E_kin = 0.0
     ikarray = np.array(list(range(sum_k.n_k)))
     for ik in mpi.slice_array(ikarray):
-        nb = int(sum_k.n_orbitals[ik])
+        # sum_k.n_orbitals[ik] is a 1-element array, so extract the scalar explicitly.
+        nb = int(np.asarray(sum_k.n_orbitals[ik]).item())
         # calculate lattice greens function need here to set sigma other n_iw is assumend to be 1025!
         # TODO: implement here version for FTPS!
         G_freq_lat = sum_k.lattice_gf(ik, with_Sigma=True, mu=dft_mu).copy()
@@ -560,7 +561,7 @@ def calc_bandcorr_man(general_params, sum_k, E_kin_dft):
     # kinetic energy from dmft lattice Greens functions
     ikarray = np.array(list(range(sum_k.n_k)))
     for ik in mpi.slice_array(ikarray):
-        nb = int(sum_k.n_orbitals[ik])
+        nb = int(np.asarray(sum_k.n_orbitals[ik]).item())
         # calculate lattice greens function
         G_freq_lat = sum_k.lattice_gf(ik, with_Sigma=True, with_dc=True).copy()
         # calculate G(beta) via the function density, which is the same as fourier trafo G(w) and taking G(b)

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/python/solid_dmft/io_tools/default.toml

@@ -178,6 +178,7 @@ with_fock = false
 dft_code = "<none>"
 dft_exec = "vasp_std"
 mpi_env = "default"
+mpi_exe = "mpirun"
 n_cores = "<none>"
 n_iter = 4
 n_iter_first = "<dft.n_iter>"

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/python/solid_dmft/postprocessing/eval_U_cRPA_Vasp.py

@@ -124,24 +124,27 @@ def red_to_2ind(uijkl, n_sites, n_orb, out=False):
     dim = n_sites*n_orb
 
     # create 2 index matrix
-    Uij_anti = np.zeros((dim, dim))
-    Uij_par = np.zeros((dim, dim))
-    Uiijj = np.zeros((dim, dim))
-    Uijji = np.zeros((dim, dim))
+    # Coulomb matrices are expected to be real. If uijkl happens to be complex
+    # (e.g. numerical noise), take the real part explicitly to avoid
+    # ComplexWarning about discarding the imaginary part.
+    Uij_anti = np.zeros((dim, dim), dtype=float)
+    Uij_par = np.zeros((dim, dim), dtype=float)
+    Uiijj = np.zeros((dim, dim), dtype=float)
+    Uijji = np.zeros((dim, dim), dtype=float)
 
     for i in range(0, dim):
         for j in range(0, dim):
             # the indices in VASP are switched: U_ijkl ---VASP--> U_ikjl
-            Uij_anti[i, j] = uijkl[i, i, j, j]
-            Uij_par[i, j] = uijkl[i, i, j, j]-uijkl[i, j, j, i]
-            Uiijj[i, j] = uijkl[i, j, i, j]
-            Uijji[i, j] = uijkl[i, j, j, i]
+            Uij_anti[i, j] = np.real(uijkl[i, i, j, j])
+            Uij_par[i, j] = np.real(uijkl[i, i, j, j] - uijkl[i, j, j, i])
+            Uiijj[i, j] = np.real(uijkl[i, j, i, j])
+            Uijji[i, j] = np.real(uijkl[i, j, j, i])
 
     np.set_printoptions(precision=3, suppress=True)
 
     if out:
-        print('reduced U anti-parallel = U_mm\'\^oo\' = U_mm\'mm\' matrix : \n', Uij_anti)
-        print('reduced U parallel = U_mm\'\^oo = U_mm\'mm\' - U_mm\'m\'m matrix : \n', Uij_par)
+        print(r"reduced U anti-parallel = U_mm'\^oo' = U_mm'mm' matrix : \n", Uij_anti)
+        print(r"reduced U parallel = U_mm'\^oo = U_mm'mm' - U_mm'm'm matrix : \n", Uij_par)
         print('reduced Uijji : \n', Uijji)
         print('reduced Uiijj : \n', Uiijj)
 

{solid_dmft-3.3.4 → solid_dmft-3.3.5}/python/solid_dmft/version.py

@@ -22,12 +22,12 @@
 #
 ################################################################################
 
-version = "3.3.4"
-triqs_hash = "e0692a5bc9a8df98ec544abef51f06a728b37105"
-solid_dmft_hash = "598a67977a6ff7eeca9394ec35138f569dd9a5f7"
+version = "3.3.5"
+triqs_hash = "b85f3d131d6a20fe59ce224ffe4c1319b6dc4676"
+solid_dmft_hash = "a1e3dc1441887348fb336a76bf822bb7bc331dcf"
 
 def show_version():
   print("\nYou are using solid_dmft version %s\n"%version)
 
 def show_git_hash():
-  print("\nYou are using solid_dmft git hash %s based on triqs git hash %s\n"%("598a67977a6ff7eeca9394ec35138f569dd9a5f7", triqs_hash))
+  print("\nYou are using solid_dmft git hash %s based on triqs git hash %s\n"%("a1e3dc1441887348fb336a76bf822bb7bc331dcf", triqs_hash))

{solid_dmft-3.3.4 → solid_dmft-3.3.5/python/solid_dmft.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solid_dmft
-Version: 3.3.4
+Version: 3.3.5
 Summary: solid_dmft: a versatile python wrapper to perform DFT+DMFT calculations utilizing the TRIQS software library
 Author-email: Alexander Hampel <mail@alexander-hampel.de>
 Project-URL: Homepage, https://triqs.github.io/solid_dmft