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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solid_dmft
-Version: 3.3.2
+Version: 3.3.4
 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
@@ -21,7 +21,8 @@ Dynamic: license-file
 
 ![logo_soliDMFT](https://raw.githubusercontent.com/triqs/solid_dmft/unstable/doc/logos/logo_solid_dmft.png)
 
-![CI](https://github.com/triqs/solid_dmft/actions/workflows/build.yml/badge.svg)
+![CI dev](https://github.com/triqs/solid_dmft/actions/workflows/build_unstable_doc.yml/badge.svg)
+![CI stable](https://github.com/triqs/solid_dmft/actions/workflows/build_release.yml/badge.svg)
 [![PyPI version](https://badge.fury.io/py/solid_dmft.svg)](https://badge.fury.io/py/solid_dmft)
 [![status](https://joss.theoj.org/papers/48eb529b08c6bb464b235ba919d78922/status.svg)](https://joss.theoj.org/papers/48eb529b08c6bb464b235ba919d78922)
 
@@ -65,3 +66,12 @@ and the Center for Computational Quantum Physics, Flatiron Institute.
 If you are using this code for your research, please cite it with this
 [bib file](https://github.com/TRIQS/solid_dmft/blob/unstable/cite_solid_dmft.bib).
 
+## Support
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" width="20%" srcset="doc/_static/CCQ-dark.png">
+  <img alt="Flatiron Center for Computational Quantum Physics logo." width="20%" src="doc/_static/CCQ.png">
+</picture>
+
+TRIQS/solid_dmft is supported by the Flatiron Institute, a division of the Simons Foundation.
+

{solid_dmft-3.3.2 → solid_dmft-3.3.4}/README.md

@@ -1,6 +1,7 @@
 ![logo_soliDMFT](https://raw.githubusercontent.com/triqs/solid_dmft/unstable/doc/logos/logo_solid_dmft.png)
 
-![CI](https://github.com/triqs/solid_dmft/actions/workflows/build.yml/badge.svg)
+![CI dev](https://github.com/triqs/solid_dmft/actions/workflows/build_unstable_doc.yml/badge.svg)
+![CI stable](https://github.com/triqs/solid_dmft/actions/workflows/build_release.yml/badge.svg)
 [![PyPI version](https://badge.fury.io/py/solid_dmft.svg)](https://badge.fury.io/py/solid_dmft)
 [![status](https://joss.theoj.org/papers/48eb529b08c6bb464b235ba919d78922/status.svg)](https://joss.theoj.org/papers/48eb529b08c6bb464b235ba919d78922)
 
@@ -44,3 +45,12 @@ and the Center for Computational Quantum Physics, Flatiron Institute.
 If you are using this code for your research, please cite it with this
 [bib file](https://github.com/TRIQS/solid_dmft/blob/unstable/cite_solid_dmft.bib).
 
+## Support
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" width="20%" srcset="doc/_static/CCQ-dark.png">
+  <img alt="Flatiron Center for Computational Quantum Physics logo." width="20%" src="doc/_static/CCQ.png">
+</picture>
+
+TRIQS/solid_dmft is supported by the Flatiron Institute, a division of the Simons Foundation.
+

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

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

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

@@ -312,6 +312,12 @@ def dmft_cycle(general_params, solver_params, advanced_params, dft_params,
 
     iteration_offset = 0
 
+    # 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.')
+            general_params['magnetic'] = True
+
     # determine chemical potential for bare DFT sum_k object
     if mpi.is_master_node():
         archive = HDFArchive(general_params['jobname']+'/'+general_params['seedname']+'.h5', 'a')
@@ -559,7 +565,7 @@ def dmft_cycle(general_params, solver_params, advanced_params, dft_params,
     for it in range(iteration_offset + 1, iteration_offset + n_iter + 1):
 
         # remove h_field when number of iterations is reached
-        if sum_k.h_field != 0.0 and general_params['h_field_it'] != 0 and it > general_params['h_field_it']:
+        if sum_k.h_field != 0.0 and general_params['h_field_it'] != -1 and it > general_params['h_field_it']:
             mpi.report('\nRemoving magnetic field now.\n')
             sum_k.h_field = 0.0
             # enforce recomputation of eff_atomic_levels

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

@@ -54,9 +54,9 @@ def determine(general_params, archive, n_inequiv_shells):
                     # determine if we need to switch up and down channel
                     switch = np.isclose(general_params['magmom'][icrsh], -general_params['magmom'][source])
 
-                    afm_mapping[icrsh] = [True, source, switch]
+                    afm_mapping[icrsh] = [True, int(source), bool(switch)]
                 else:
-                    afm_mapping[icrsh] = [False, icrsh, False]
+                    afm_mapping[icrsh] = [False, int(icrsh), False]
 
 
             print('AFM calculation selected, mapping self energies as follows:')
@@ -86,6 +86,20 @@ 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
+        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()}
+
+    # 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 invert_spin:
         for spin_channel in gf_struct_solver.keys():
             if 'up' in spin_channel:
@@ -99,11 +113,12 @@ 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['measure_pert_order']:
-                if not hasattr(solvers[icrsh], 'perturbation_order'):
-                    solvers[icrsh].perturbation_order = {}
+            if solvers[icrsh].solver_params.get('measure_pert_order'):
                 solvers[icrsh].perturbation_order[spin_channel] = solvers[imp_source].perturbation_order[target_channel]
-                solvers[icrsh].perturbation_order_total = solvers[imp_source].perturbation_order_total
+
+            # 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'):
+                solvers[icrsh].orbital_occupations[spin_channel] = solvers[imp_source].orbital_occupations[target_channel]
 
     else:
         solvers[icrsh].Sigma_freq << solvers[imp_source].Sigma_freq
@@ -112,15 +127,7 @@ def apply(general_params, icrsh, gf_struct_solver, solvers):
         solvers[icrsh].G0_freq << solvers[imp_source].G0_freq
         solvers[icrsh].G_time << solvers[imp_source].G_time
 
-        if solvers[icrsh].solver_params['measure_pert_order']:
-            solvers[icrsh].perturbation_order = solvers[imp_source].perturbation_order
-            solvers[icrsh].perturbation_order_total = solvers[imp_source].perturbation_order_total
-
-    if solvers[icrsh].solver_params['measure_density_matrix']:
-        solvers[icrsh].density_matrix = solvers[imp_source].density_matrix
-        solvers[icrsh].h_loc_diagonalization = solvers[imp_source].h_loc_diagonalization
-
-    if 'measure_chi' in solvers[icrsh].solver_params and solvers[icrsh].solver_params['measure_chi'] is not None:
+    if solvers[icrsh].solver_params.get('measure_chi'):
         solvers[icrsh].O_time = solvers[imp_source].O_time
 
     return solvers

{solid_dmft-3.3.2 → solid_dmft-3.3.4}/python/solid_dmft/dmft_tools/initial_self_energies.py

@@ -533,9 +533,9 @@ def determine_dc_and_initial_sigma(general_params, gw_params, advanced_params, s
                     # if magmom positive the up channel will be favored
                     for spin_channel in sum_k.gf_struct_solver[icrsh].keys():
                         if 'up' in spin_channel:
-                            start_sigma[icrsh][spin_channel] << -np.eye(dc_pot[spin_channel].shape[0])*fac + dc_pot[spin_channel]
+                            start_sigma[icrsh][spin_channel] <<  dc_pot[spin_channel] - fac*np.eye(dc_pot[spin_channel].shape[0])
                         else:
-                            start_sigma[icrsh][spin_channel] << np.eye(dc_pot[spin_channel].shape[0])*fac + dc_pot[spin_channel]
+                            start_sigma[icrsh][spin_channel] << dc_pot[spin_channel] + fac*np.eye(dc_pot[spin_channel].shape[0])
                 else:
                     for spin_channel in sum_k.gf_struct_solver[icrsh].keys():
                         start_sigma[icrsh][spin_channel] << dc_pot[spin_channel]
@@ -554,9 +554,9 @@ def determine_dc_and_initial_sigma(general_params, gw_params, advanced_params, s
                     # if magmom positive the up channel will be favored
                     for spin_channel in sum_k.gf_struct_solver[icrsh].keys():
                         if 'up' in spin_channel:
-                            start_sigma[icrsh][spin_channel] << -fac
+                            start_sigma[icrsh][spin_channel] << -fac*np.eye(start_sigma[icrsh][spin_channel].target_shape[0])
                         else:
-                            start_sigma[icrsh][spin_channel] << fac
+                            start_sigma[icrsh][spin_channel] << fac*np.eye(start_sigma[icrsh][spin_channel].target_shape[0])
         else:
             start_sigma = [sum_k.block_structure.create_gf(ish=iineq, gf_function=Gf, space='solver', mesh=sum_k.mesh)
                            for iineq in range(sum_k.n_inequiv_shells)]

{solid_dmft-3.3.2 → solid_dmft-3.3.4}/python/solid_dmft/dmft_tools/matheval.py

@@ -4,8 +4,12 @@ import ast
 import math
 
 
+# Determine numeric/constant node for compatibility across Python versions
+_AST_CONSTANT = getattr(ast, "Constant", None)
+
 class MathExpr(object):
-    allowed_nodes = (
+    # Base allowed nodes (version-agnostic)
+    _base_allowed = (
         ast.Module,
         ast.Expr,
         ast.Load,
@@ -13,7 +17,6 @@ class MathExpr(object):
         ast.Add,
         ast.Sub,
         ast.UnaryOp,
-        ast.Num,
         ast.BinOp,
         ast.Mult,
         ast.Div,
@@ -32,6 +35,11 @@ class MathExpr(object):
         ast.Name,
     )
 
+    # Extend allowed nodes with version-specific constant node
+    allowed_nodes = _base_allowed + (
+        _AST_CONSTANT if _AST_CONSTANT is not None else ast.Num,
+    )
+
     functions = {
         "abs": abs,
         "complex": complex,

{solid_dmft-3.3.2 → solid_dmft-3.3.4}/python/solid_dmft/dmft_tools/solver.py

@@ -30,7 +30,6 @@ from triqs.gf.tools import inverse, make_zero_tail
 from triqs.gf.descriptors import Fourier
 from triqs.operators import c_dag, c, Operator, util
 from triqs.operators.util.U_matrix import reduce_4index_to_2index
-from triqs.operators.util.extractors import block_matrix_from_op
 import triqs.utility.mpi as mpi
 import itertools
 from h5 import HDFArchive
@@ -105,12 +104,7 @@ def _gf_fit_tail_fraction(Gf, fraction=0.4, replace=None, known_moments=[]):
 
     return Gf_fit
 
-def _fit_tail_window(
-        Sigma_iw,
-        fit_min_n=None, fit_max_n=None,
-        fit_min_w=None, fit_max_w=None,
-        fit_max_moment=None, fit_known_moments=None
-        ):
+def _fit_tail_window(Sigma_iw, fit_min_n=None, fit_max_n=None, fit_min_w=None, fit_max_w=None, fit_max_moment=None, fit_known_moments=None):
     """
     Fit a high frequency 1/(iw)^n expansion of Sigma_iw
     and replace the high frequency part with the fitted high frequency expansion.
@@ -121,7 +115,7 @@ def _fit_tail_window(
     Parameters
     ----------
     Sigma_iw : Gf
-               Self-energy.
+            Self-energy.
     fit_min_n : int, optional, default=int(0.8*len(Sigma_iw.mesh))
                 Matsubara frequency index from which tail fitting should start.
     fit_max_n : int, optional, default=int(len(Sigma_iw.mesh))
@@ -131,7 +125,7 @@ def _fit_tail_window(
     fit_max_w : float, optional
                 Matsubara frequency at which tail fitting should end.
     fit_max_moment : int, optional
-                     Highest moment to fit in the tail of Sigma_iw.
+                    Highest moment to fit in the tail of Sigma_iw.
     fit_known_moments : ``ndarray.shape[order, Sigma_iw[0].target_shape]``, optional, default = None
                         Known moments of Sigma_iw, given as an numpy ndarray
 
@@ -140,17 +134,17 @@ def _fit_tail_window(
     tail_barr : dict of arr
                 fitted tail of Sigma_iw
     """
-    from triqs.gf import fit_hermitian_tail_on_window
+    from triqs.gf.gf_fnt import fit_hermitian_tail_on_window, replace_by_tail
 
     # Define default tail quantities
     if fit_min_w is not None:
-        fit_min_n = int(0.5*(fit_min_w*Sigma_iw.mesh.beta/np.pi - 1.0))
+        fit_min_n = int(0.5 * (fit_min_w * Sigma_iw.mesh.beta / np.pi - 1.0))
     if fit_max_w is not None:
-        fit_max_n = int(0.5*(fit_max_w*Sigma_iw.mesh.beta/np.pi - 1.0))
+        fit_max_n = int(0.5 * (fit_max_w * Sigma_iw.mesh.beta / np.pi - 1.0))
     if fit_min_n is None:
-        fit_min_n = int(0.8*len(Sigma_iw.mesh)/2)
+        fit_min_n = int(0.8 * len(Sigma_iw.mesh) / 2)
     if fit_max_n is None:
-        fit_max_n = int(len(Sigma_iw.mesh)/2)
+        fit_max_n = int(len(Sigma_iw.mesh) / 2)
     if fit_max_moment is None:
         fit_max_moment = 3
 
@@ -158,24 +152,25 @@ def _fit_tail_window(
         fit_known_moments = {}
         for name, sig in Sigma_iw:
             shape = [0] + list(sig.target_shape)
-            fit_known_moments[name] = np.zeros(shape, dtype=complex) # no known moments
+            fit_known_moments[name] = np.zeros(shape, dtype=complex)  # no known moments
 
     # Now fit the tails of Sigma_iw and replace the high frequency part with the tail expansion
     tail_barr = {}
-    for name, sig in Sigma_iw:
-
+    Sigma_fit = Sigma_iw.copy()
+    for name, sig in Sigma_fit:
         tail, err = fit_hermitian_tail_on_window(
             sig,
-            n_min = fit_min_n,
-            n_max = fit_max_n,
-            known_moments = fit_known_moments[name],
+            n_min=fit_min_n,
+            n_max=fit_max_n,
+            known_moments=fit_known_moments[name],
             # set max number of pts used in fit larger than mesh size, to use all data in fit
-            n_tail_max = 10 * len(sig.mesh),
-            expansion_order = fit_max_moment
-            )
+            n_tail_max=10 * len(sig.mesh),
+            expansion_order=fit_max_moment,
+        )
         tail_barr[name] = tail
+        replace_by_tail(sig, tail, n_min=fit_min_n)
 
-    return tail_barr
+    return Sigma_fit, tail_barr
 
 class SolverStructure:
 
@@ -1168,6 +1163,7 @@ class SolverStructure:
             self.Sigma_moments = self.triqs_solver.Sigma_moments
             self.Sigma_Hartree = self.triqs_solver.Sigma_Hartree
             self.G_moments = self.triqs_solver.G_moments
+            self.orbital_occupations = self.triqs_solver.orbital_occupations
 
         if self.solver_params['measure_pert_order']:
             self.perturbation_order = self.triqs_solver.perturbation_order
@@ -1251,8 +1247,8 @@ class SolverStructure:
         # get everything from solver
         self.G0_freq << self.triqs_solver.G0_iw
         self.G_freq_unsym << self.triqs_solver.G_iw
+        self.G_freq << self.triqs_solver.G_iw
         self.sum_k.symm_deg_gf(self.G_freq, ish=self.icrsh)
-        self.G_freq << self.G_freq
         for bl, gf in self.Sigma_freq:
             self.Sigma_freq[bl] << self.triqs_solver.Sigma_HF[bl]
             self.Sigma_Refreq[bl] << self.triqs_solver.Sigma_HF[bl]
@@ -1346,6 +1342,8 @@ class SolverStructure:
         r'''
         Organize G_freq, G_time, Sigma_freq and G_l from ctseg solver
         '''
+        from solid_dmft.postprocessing.eval_U_cRPA_RESPACK import construct_Uijkl
+        from triqs.operators.util.extractors import extract_U_dict2, dict_to_matrix
 
         def set_Gs_from_G_l():
 
@@ -1442,7 +1440,7 @@ class SolverStructure:
             # get G_time, G_freq, Sigma_freq from G_l
             set_Gs_from_G_l()
         # if improved estimators are turned on calc Sigma from F_tau, otherwise:
-        elif self.solver_params['improved_estimator']:
+        elif self.solver_params['improved_estimator'] and not self.solver_params['perform_tail_fit']:
             self.F_freq = self.G_freq.copy()
             self.F_freq << 0.0
             self.F_time = self.G_time.copy()
@@ -1460,6 +1458,42 @@ class SolverStructure:
             for block, fw in self.F_freq:
                 for iw in fw.mesh:
                     self.Sigma_freq[block][iw] = self.F_freq[block][iw] / self.G_freq[block][iw]
+        elif self.solver_params['perform_tail_fit']:
+            if not self.solver_params['improved_estimator']:
+                mpi.report('Self-energy post-processing algorithm: tail fitting with analytic static impurity self-energy')
+                self.Sigma_freq = inverse(self.G0_freq) - inverse(self.G_freq)
+            else:
+                mpi.report('Self-energy post-processing algorithm: '
+                           'improved estimator + tail fitting with analytic static imppurity self-energy')
+                self.F_freq = self.G_freq.copy()
+                self.F_freq << 0.0
+                self.F_time = self.G_time.copy()
+                self.F_time << self.triqs_solver.results.F_tau
+                F_known_moments = make_zero_tail(self.F_freq, n_moments=1)
+                for i, bl in enumerate(self.F_freq.indices):
+                    self.F_freq[bl] << Fourier(self.triqs_solver.results.F_tau[bl], F_known_moments[i])
+
+                for block, fw in self.F_freq:
+                    for iw in fw.mesh:
+                        self.Sigma_freq[block][iw] = self.F_freq[block][iw] / self.G_freq[block][iw]
+
+            # without any degenerate shells we run the minimization for all blocks
+            if mpi.is_master_node():
+                self.Sigma_freq, tail = _fit_tail_window(
+                    self.Sigma_freq,
+                    fit_min_n=self.solver_params['fit_min_n'],
+                    fit_max_n=self.solver_params['fit_max_n'],
+                    fit_min_w=self.solver_params['fit_min_w'],
+                    fit_max_w=self.solver_params['fit_max_w'],
+                    fit_max_moment=self.solver_params['fit_max_moment'],
+                    fit_known_moments=self.Sigma_moments,
+                )
+
+                # recompute G_freq from Sigma with fitted tail
+                self.G_freq = inverse(inverse(self.G0_freq) - self.Sigma_freq)
+
+            self.Sigma_freq << mpi.bcast(self.Sigma_freq)
+            self.G_freq << mpi.bcast(self.G_freq)
 
         elif self.solver_params['crm_dyson_solver']:
             from triqs.gf.dlr_crm_dyson_solver import minimize_dyson
@@ -1490,7 +1524,7 @@ class SolverStructure:
                 # minimize dyson for the first entry of each deg shell
                 self.Sigma_dlr = self.sum_k.block_structure.create_gf(ish=self.icrsh, gf_function=Gf, mesh=mesh_dlr_iw, space='solver')
                 # without any degenerate shells we run the minimization for all blocks
-                tail = _fit_tail_window(Sigma_iw,
+                _, tail = _fit_tail_window(Sigma_iw,
                                         fit_min_n=self.solver_params['fit_min_n'],
                                         fit_max_n=self.solver_params['fit_max_n'],
                                         fit_min_w=self.solver_params['fit_min_w'],

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

@@ -20,7 +20,7 @@ g0_mix_type = "linear"
 gimp_conv_crit = -1.0
 gw_embedding = false
 h_field = 0.0
-h_field_it = 0
+h_field_it = -1
 h_int_basis = "triqs"
 h_int_type = "<no default>"
 h5_save_freq = 5

{solid_dmft-3.3.2 → solid_dmft-3.3.4}/python/solid_dmft/io_tools/verify_input_params.py

@@ -28,6 +28,11 @@ def _verify_input_params_general(params: FullConfig) -> None:
     if params['general']['calc_energies'] and any(entry['type'] == 'ftps' for entry in params['solver']):
         raise ValueError('"calc_energies" is not valid for solver of type = "ftps"')
 
+    if params['general']['n_iter_dmft'] is None:
+        raise ValueError('"n_iter_dmft" must be specified.')
+    elif params['general']['n_iter_dmft'] < 0:
+        raise ValueError('"n_iter_dmft" must be at least 0.')
+
     # Checks validity of other general params
     h_int_type_options = (
         'density_density',
@@ -110,8 +115,8 @@ def _verify_input_params_solver(params: FullConfig) -> None:
                        entry['legendre_fit'],
                        entry['improved_estimator'],
                        entry['perform_tail_fit']]
-            if sum(tail_op) > 1:
-                raise ValueError('Only one of the options "crm_dyson_solver", "legendre_fit", "improved_estimator", and "perform_tail_fit" can be set to True.')
+            if sum(tail_op) > 1 and not (entry['improved_estimator'] and entry['perform_tail_fit']):
+                raise ValueError('Only one of the options "crm_dyson_solver", "legendre_fit", "improved_estimator", and "perform_tail_fit" can be set to True. You can only combine "improved_estimator" and "perform_tail_fit".')
         if entry['type'] == 'cthyb':
             tail_op = [entry['crm_dyson_solver'],
                        entry['legendre_fit'],

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

@@ -22,12 +22,12 @@
 #
 ################################################################################
 
-version = "3.3.2"
-triqs_hash = "2642a94a63558f20e2ec7f32207c8df6cc13193b"
-solid_dmft_hash = "12b01d076e9c00fe86fab31aea8062d9e307326c"
+version = "3.3.4"
+triqs_hash = "e0692a5bc9a8df98ec544abef51f06a728b37105"
+solid_dmft_hash = "598a67977a6ff7eeca9394ec35138f569dd9a5f7"
 
 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"%("12b01d076e9c00fe86fab31aea8062d9e307326c", triqs_hash))
+  print("\nYou are using solid_dmft git hash %s based on triqs git hash %s\n"%("598a67977a6ff7eeca9394ec35138f569dd9a5f7", triqs_hash))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solid_dmft
-Version: 3.3.2
+Version: 3.3.4
 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
@@ -21,7 +21,8 @@ Dynamic: license-file
 
 ![logo_soliDMFT](https://raw.githubusercontent.com/triqs/solid_dmft/unstable/doc/logos/logo_solid_dmft.png)
 
-![CI](https://github.com/triqs/solid_dmft/actions/workflows/build.yml/badge.svg)
+![CI dev](https://github.com/triqs/solid_dmft/actions/workflows/build_unstable_doc.yml/badge.svg)
+![CI stable](https://github.com/triqs/solid_dmft/actions/workflows/build_release.yml/badge.svg)
 [![PyPI version](https://badge.fury.io/py/solid_dmft.svg)](https://badge.fury.io/py/solid_dmft)
 [![status](https://joss.theoj.org/papers/48eb529b08c6bb464b235ba919d78922/status.svg)](https://joss.theoj.org/papers/48eb529b08c6bb464b235ba919d78922)
 
@@ -65,3 +66,12 @@ and the Center for Computational Quantum Physics, Flatiron Institute.
 If you are using this code for your research, please cite it with this
 [bib file](https://github.com/TRIQS/solid_dmft/blob/unstable/cite_solid_dmft.bib).
 
+## Support
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" width="20%" srcset="doc/_static/CCQ-dark.png">
+  <img alt="Flatiron Center for Computational Quantum Physics logo." width="20%" src="doc/_static/CCQ.png">
+</picture>
+
+TRIQS/solid_dmft is supported by the Flatiron Institute, a division of the Simons Foundation.
+