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

{solid_dmft-3.3.3/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.3
+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

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

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

{solid_dmft-3.3.3 → 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.3 → 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.3 → 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.3 → solid_dmft-3.3.4}/python/solid_dmft/dmft_tools/solver.py

@@ -1163,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

{solid_dmft-3.3.3 → 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',

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

@@ -22,12 +22,12 @@
 #
 ################################################################################
 
-version = "3.3.3"
-triqs_hash = "0a3ce9651e4b043eb24c0f7eae52e6538b36b752"
-solid_dmft_hash = "282d8435c4ccdc1c9061451f5d777f374de8c238"
+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"%("282d8435c4ccdc1c9061451f5d777f374de8c238", 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.3 → 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.3
+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