From 6c908e9c6e7f29179f8f8895afc0cf4f03a76ae7 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Wed, 29 Aug 2018 11:29:46 +0200
Subject: [PATCH 01/35] block_structure: add check_gf method

---
 python/block_structure.py | 40 ++++++++++++++++++++++++
 test/blockstructure.py    | 65 ++++++++++++++++++++-------------------
 2 files changed, 74 insertions(+), 31 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index f1501409..21f8e790 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -281,6 +281,46 @@ class BlockStructure(object):
         G = BlockGf(name_list = names, block_list = blocks)
         return G
 
+    def check_gf(self, G, ish=None):
+        """ check whether the Green's function G has the right structure
+        This throws an error if the structure of G is not the same
+        as ``gf_struct_solver``.
+
+        Parameters
+        ----------
+        G : BlockGf or list of BlockGf
+            Green's function to check
+            if it is a list, there should be as many entries as there
+            are shells, and the check is performed for all shells (unless
+            ish is given).
+        ish : int
+            shell index
+            default: 0 if G is just one Green's function is given,
+            check all if list of Green's functions is given
+        """
+
+        if isinstance(G, list):
+            assert len(G) == len(self.gf_struct_solver),\
+                "list of G does not have the correct length"
+            if ish is None:
+                ishs = range(len(self.gf_struct_solver))
+            else:
+                ishs = [ish]
+            for ish in ishs:
+                self.check_gf(G[ish], ish=ish)
+            return
+
+        if ish is None:
+            ish = 0
+
+        for block in self.gf_struct_solver[ish]:
+            assert block in G.indices,\
+                "block " + block + " not in G (shell {})".format(ish)
+        for block, gf in G:
+            assert block in self.gf_struct_solver[ish],\
+                "block " + block + " not in struct (shell {})".format(ish)
+            assert list(gf.indices) == 2 * [map(str, self.gf_struct_solver[ish][block])],\
+                "block " + block + " has wrong indices (shell {})".format(ish)
 
     def convert_gf(self,G,G_struct,ish=0,show_warnings=True,**kwargs):
         """ Convert BlockGf from its structure to this structure.
diff --git a/test/blockstructure.py b/test/blockstructure.py
index f7a68e5b..0123a141 100644
--- a/test/blockstructure.py
+++ b/test/blockstructure.py
@@ -4,7 +4,7 @@ from pytriqs.gf import *
 from pytriqs.utility.comparison_tests import assert_block_gfs_are_close
 from triqs_dft_tools.block_structure import BlockStructure
 
-SK = SumkDFT('blockstructure.in.h5',use_dft_blocks=True)
+SK = SumkDFT('blockstructure.in.h5', use_dft_blocks=True)
 
 original_bs = SK.block_structure
 
@@ -13,56 +13,59 @@ pick1 = original_bs.copy()
 pick1.pick_gf_struct_solver([{'up_0': [1], 'up_1': [0], 'down_1': [0]}])
 
 # check loading a block_structure from file
-SK.block_structure = SK.load(['block_structure'],'mod')[0]
+SK.block_structure = SK.load(['block_structure'], 'mod')[0]
 assert SK.block_structure == pick1, 'loading SK block structure from file failed'
 
 # check SumkDFT backward compatibility
-sk_pick1 = BlockStructure(gf_struct_sumk = SK.gf_struct_sumk,
-                          gf_struct_solver = SK.gf_struct_solver,
-                          solver_to_sumk = SK.solver_to_sumk,
-                          sumk_to_solver = SK.sumk_to_solver,
-                          solver_to_sumk_block = SK.solver_to_sumk_block,
-                          deg_shells = SK.deg_shells)
+sk_pick1 = BlockStructure(gf_struct_sumk=SK.gf_struct_sumk,
+                          gf_struct_solver=SK.gf_struct_solver,
+                          solver_to_sumk=SK.solver_to_sumk,
+                          sumk_to_solver=SK.sumk_to_solver,
+                          solver_to_sumk_block=SK.solver_to_sumk_block,
+                          deg_shells=SK.deg_shells)
 assert sk_pick1 == pick1, 'constructing block structure from SumkDFT properties failed'
 
 # check pick_gf_struct_sumk
 pick2 = original_bs.copy()
-pick2.pick_gf_struct_sumk([{'up': [1, 2], 'down': [0,1]}])
+pick2.pick_gf_struct_sumk([{'up': [1, 2], 'down': [0, 1]}])
 
 # check map_gf_struct_solver
-mapping = [{ ('down_0', 0):('down', 0),
-             ('down_0', 1):('down', 2),
-             ('down_1', 0):('down', 1),
-             ('up_0', 0)  :('down_1', 0),
-             ('up_0', 1)  :('up_0', 0) }]
+mapping = [{('down_0', 0): ('down', 0),
+            ('down_0', 1): ('down', 2),
+            ('down_1', 0): ('down', 1),
+            ('up_0', 0): ('down_1', 0),
+            ('up_0', 1): ('up_0', 0)}]
 map1 = original_bs.copy()
 map1.map_gf_struct_solver(mapping)
 
 # check create_gf
-G1 = original_bs.create_gf(beta=40,n_points=3)
+G1 = original_bs.create_gf(beta=40, n_points=3)
 i = 1
-for block,gf in G1:
+for block, gf in G1:
     gf << SemiCircular(i)
-    i+=1
+    i += 1
+original_bs.check_gf(G1)
+original_bs.check_gf([G1])
 
 # check approximate_as_diagonal
 offd = original_bs.copy()
 offd.approximate_as_diagonal()
 
 # check map_gf_struct_solver
-G2 = map1.convert_gf(G1,original_bs,beta=40,n_points=3,show_warnings=False)
+G2 = map1.convert_gf(G1, original_bs, beta=40, n_points=3, show_warnings=False)
 
 # check full_structure
-full = BlockStructure.full_structure([{'up_0': [0, 1], 'up_1': [0], 'down_1': [0], 'down_0': [0, 1]}],None)
+full = BlockStructure.full_structure(
+    [{'up_0': [0, 1], 'up_1': [0], 'down_1': [0], 'down_0': [0, 1]}], None)
 
 # check __eq__
-assert full==full, 'equality not correct (equal structures not equal)'
-assert pick1==pick1, 'equality not correct (equal structures not equal)'
-assert pick1!=pick2, 'equality not correct (different structures not different)'
-assert original_bs!=offd, 'equality not correct (different structures not different)'
+assert full == full, 'equality not correct (equal structures not equal)'
+assert pick1 == pick1, 'equality not correct (equal structures not equal)'
+assert pick1 != pick2, 'equality not correct (different structures not different)'
+assert original_bs != offd, 'equality not correct (different structures not different)'
 
 if mpi.is_master_node():
-    with HDFArchive('blockstructure.out.h5','w') as ar:
+    with HDFArchive('blockstructure.out.h5', 'w') as ar:
         ar['original_bs'] = original_bs
         ar['pick1'] = pick1
         ar['pick2'] = pick2
@@ -75,10 +78,10 @@ if mpi.is_master_node():
     # cannot use h5diff because BlockStructure testing is not implemented
     # there (and seems difficult to implement because it would mix triqs
     # and dft_tools)
-    with HDFArchive('blockstructure.out.h5','r') as ar,\
-         HDFArchive('blockstructure.ref.h5','r') as ar2:
-            for k in ar2:
-                if isinstance(ar[k],BlockGf):
-                    assert_block_gfs_are_close(ar[k],ar2[k],1.e-6)
-                else:
-                    assert ar[k]==ar2[k], '{} not equal'.format(k)
+    with HDFArchive('blockstructure.out.h5', 'r') as ar,\
+            HDFArchive('blockstructure.ref.h5', 'r') as ar2:
+        for k in ar2:
+            if isinstance(ar[k], BlockGf):
+                assert_block_gfs_are_close(ar[k], ar2[k], 1.e-6)
+            else:
+                assert ar[k] == ar2[k], '{} not equal'.format(k)

From 2b490d14857c3b00bb0aea6b013fe4a05d8097f4 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Wed, 29 Aug 2018 12:03:14 +0200
Subject: [PATCH 02/35] block_structure: convert_gf: add G_out, let G_struct be
 sumk

---
 python/block_structure.py | 63 ++++++++++++++++++++++++++-------------
 test/blockstructure.py    | 13 ++++++--
 2 files changed, 53 insertions(+), 23 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index 21f8e790..0f792d2a 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -283,6 +283,7 @@ class BlockStructure(object):
 
     def check_gf(self, G, ish=None):
         """ check whether the Green's function G has the right structure
+
         This throws an error if the structure of G is not the same
         as ``gf_struct_solver``.
 
@@ -322,8 +323,9 @@ class BlockStructure(object):
             assert list(gf.indices) == 2 * [map(str, self.gf_struct_solver[ish][block])],\
                 "block " + block + " has wrong indices (shell {})".format(ish)
 
-    def convert_gf(self,G,G_struct,ish=0,show_warnings=True,**kwargs):
-        """ Convert BlockGf from its structure to this structure.
+    def convert_gf(self, G, G_struct, ish=0, show_warnings=True,
+                   G_out=None, **kwargs):
+        """ Convert BlockGf from its structure to this (solver) structure.
 
         .. warning::
 
@@ -335,8 +337,9 @@ class BlockStructure(object):
         ----------
         G : BlockGf
             the Gf that should be converted
-        G_struct : GfStructure
-            the structure of that G
+        G_struct : BlockStructure or str
+            the structure of that G or 'sumk' (then, the structure of
+            the sumk Green's function of this BlockStructure is used)
         ish : int
             shell index
         show_warnings : bool or float
@@ -354,30 +357,50 @@ class BlockStructure(object):
             warning_threshold = show_warnings
             show_warnings = True
 
-        G_new = self.create_gf(ish=ish,**kwargs)
-        for block in G_struct.gf_struct_solver[ish].keys():
-            for i1 in G_struct.gf_struct_solver[ish][block]:
-                for i2 in G_struct.gf_struct_solver[ish][block]:
-                    i1_sumk = G_struct.solver_to_sumk[ish][(block,i1)]
-                    i2_sumk = G_struct.solver_to_sumk[ish][(block,i2)]
+        # we offer the possibility to convert to convert from sumk_dft
+        from_sumk = False
+        if isinstance(G_struct, str) and G_struct == 'sumk':
+            gf_struct_in = {block: indices
+                            for block, indices in self.gf_struct_sumk[ish]}
+            from_sumk = True
+        else:
+            gf_struct_in = G_struct.gf_struct_solver[ish]
+
+        # create a Green's function to hold the result
+        if G_out is None:
+            G_out = self.create_gf(ish=ish, **kwargs)
+        else:
+            self.check_gf(G_out, ish=ish)
+
+        for block in gf_struct_in.keys():
+            for i1 in gf_struct_in[block]:
+                for i2 in gf_struct_in[block]:
+                    if from_sumk:
+                        i1_sumk = (block, i1)
+                        i2_sumk = (block, i2)
+                    else:
+                        i1_sumk = G_struct.solver_to_sumk[ish][(block, i1)]
+                        i2_sumk = G_struct.solver_to_sumk[ish][(block, i2)]
+
                     i1_sol = self.sumk_to_solver[ish][i1_sumk]
                     i2_sol = self.sumk_to_solver[ish][i2_sumk]
                     if i1_sol[0] is None or i2_sol[0] is None:
                         if show_warnings:
                             if mpi.is_master_node():
-                                warn(('Element {},{} of block {} of G is not present '+
-                                    'in the new structure').format(i1,i2,block))
+                                warn(('Element {},{} of block {} of G is not present ' +
+                                      'in the new structure').format(i1, i2, block))
                         continue
-                    if i1_sol[0]!=i2_sol[0]:
-                        if show_warnings and np.max(np.abs(G[block][i1,i2].data)) > warning_threshold:
+                    if i1_sol[0] != i2_sol[0]:
+                        if (show_warnings and
+                                np.max(np.abs(G[block][i1, i2].data)) > warning_threshold):
                             if mpi.is_master_node():
-                                warn(('Element {},{} of block {} of G is approximated '+
-                                    'to zero to match the new structure. Max abs value: {}').format(
-                                        i1,i2,block,np.max(np.abs(G[block][i1,i2].data))))
+                                warn(('Element {},{} of block {} of G is approximated ' +
+                                      'to zero to match the new structure. Max abs value: {}').format(
+                                    i1, i2, block, np.max(np.abs(G[block][i1, i2].data))))
                         continue
-                    G_new[i1_sol[0]][i1_sol[1],i2_sol[1]] = \
-                            G[block][i1,i2]
-        return G_new
+                    G_out[i1_sol[0]][i1_sol[1], i2_sol[1]] = \
+                        G[block][i1, i2]
+        return G_out
 
     def approximate_as_diagonal(self):
         """ Create a structure for a GF with zero off-diagonal elements.
diff --git a/test/blockstructure.py b/test/blockstructure.py
index 0123a141..b96f38aa 100644
--- a/test/blockstructure.py
+++ b/test/blockstructure.py
@@ -40,10 +40,9 @@ map1.map_gf_struct_solver(mapping)
 
 # check create_gf
 G1 = original_bs.create_gf(beta=40, n_points=3)
-i = 1
+widths = dict(up_0=1, up_1=2, down_0=4, down_1=3)
 for block, gf in G1:
-    gf << SemiCircular(i)
-    i += 1
+    gf << SemiCircular(widths[block])
 original_bs.check_gf(G1)
 original_bs.check_gf([G1])
 
@@ -58,6 +57,14 @@ G2 = map1.convert_gf(G1, original_bs, beta=40, n_points=3, show_warnings=False)
 full = BlockStructure.full_structure(
     [{'up_0': [0, 1], 'up_1': [0], 'down_1': [0], 'down_0': [0, 1]}], None)
 
+G_sumk = BlockGf(mesh=G1.mesh, gf_struct=original_bs.gf_struct_sumk[0])
+for i in range(3):
+    G_sumk['up'][i, i] << SemiCircular(1 if i < 2 else 2)
+    G_sumk['down'][i, i] << SemiCircular(4 if i < 2 else 3)
+G3 = original_bs.convert_gf(G_sumk, 'sumk', beta=40, n_points=3)
+assert_block_gfs_are_close(G1, G3)
+
+
 # check __eq__
 assert full == full, 'equality not correct (equal structures not equal)'
 assert pick1 == pick1, 'equality not correct (equal structures not equal)'

From f0de5c62b59ad37fcff88fbf3f8d979309476561 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Wed, 29 Aug 2018 19:36:20 +0200
Subject: [PATCH 03/35] block_structure: add gf_struct_***_list and _dict

now sumk is given in the list format and
solver is given in the dict format
---
 python/block_structure.py | 84 +++++++++++++++++++++++++++++++++++----
 python/sumk_dft.py        | 16 ++++++++
 test/blockstructure.py    |  8 ++++
 3 files changed, 100 insertions(+), 8 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index 0f792d2a..c5f0bf68 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -5,6 +5,7 @@ from ast import literal_eval
 import pytriqs.utility.mpi as mpi
 from warnings import warn
 
+
 class BlockStructure(object):
     """ Contains information about the Green function structure.
 
@@ -37,12 +38,13 @@ class BlockStructure(object):
         maps from the solver block to the sumk block
         for *inequivalent* correlated shell ish
     """
-    def __init__(self,gf_struct_sumk=None,
-                      gf_struct_solver=None,
-                      solver_to_sumk=None,
-                      sumk_to_solver=None,
-                      solver_to_sumk_block=None,
-                      deg_shells=None):
+
+    def __init__(self, gf_struct_sumk=None,
+                 gf_struct_solver=None,
+                 solver_to_sumk=None,
+                 sumk_to_solver=None,
+                 solver_to_sumk_block=None,
+                 deg_shells=None):
         self.gf_struct_sumk = gf_struct_sumk
         self.gf_struct_solver = gf_struct_solver
         self.solver_to_sumk = solver_to_sumk
@@ -50,6 +52,73 @@ class BlockStructure(object):
         self.solver_to_sumk_block = solver_to_sumk_block
         self.deg_shells = deg_shells
 
+    @property
+    def gf_struct_solver_list(self):
+        """ The structure of the solver Green's function
+
+        This is returned as a
+            list (for each shell)
+        of lists (for each block)
+        of tuples (block_name, block_indices).
+
+        That is,
+        ``gf_struct_solver_list[ish][b][0]``
+        is the name of the block number ``b`` of shell ``ish``, and
+        ``gf_struct_solver_list[ish][b][1]``
+        is a list of its indices.
+
+        The list for each shell is sorted alphabetically by block name.
+        """
+        # we sort by block name in order to get a reproducible result
+        return [sorted([(k, v) for k, v in gfs.iteritems()], key=lambda x: x[0])
+                for gfs in self.gf_struct_solver]
+
+    @property
+    def gf_struct_sumk_list(self):
+        """ The structure of the sumk Green's function
+
+        This is returned as a
+            list (for each shell)
+        of lists (for each block)
+        of tuples (block_name, block_indices)
+
+        That is,
+        ``gf_struct_sumk_list[ish][b][0]``
+        is the name of the block number ``b`` of shell ``ish``, and
+        ``gf_struct_sumk_list[ish][b][1]``
+        is a list of its indices.
+        """
+        return self.gf_struct_sumk
+
+    @property
+    def gf_struct_solver_dict(self):
+        """ The structure of the solver Green's function
+
+        This is returned as a
+            list (for each shell)
+        of dictionaries.
+
+        That is,
+        ``gf_struct_solver_dict[ish][bname]``
+        is a list of the indices of block ``bname`` of shell ``ish``.
+        """
+        return self.gf_struct_solver
+
+    @property
+    def gf_struct_sumk_dict(self):
+        """ The structure of the sumk Green's function
+
+        This is returned as a
+            list (for each shell)
+        of dictionaries.
+
+        That is,
+        ``gf_struct_sumk_dict[ish][bname]``
+        is a list of the indices of block ``bname`` of shell ``ish``.
+        """
+        return [{block: indices for block, indices in gfs}
+                for gfs in self.gf_struct_sumk]
+
     @classmethod
     def full_structure(cls,gf_struct,corr_to_inequiv):
         """ Construct structure that maps to itself.
@@ -360,8 +429,7 @@ class BlockStructure(object):
         # we offer the possibility to convert to convert from sumk_dft
         from_sumk = False
         if isinstance(G_struct, str) and G_struct == 'sumk':
-            gf_struct_in = {block: indices
-                            for block, indices in self.gf_struct_sumk[ish]}
+            gf_struct_in = self.gf_struct_sumk_dict[ish]
             from_sumk = True
         else:
             gf_struct_in = G_struct.gf_struct_solver[ish]
diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 825b6b5d..66d7faac 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -2057,3 +2057,19 @@ class SumkDFT(object):
     def __set_deg_shells(self,value):
         self.block_structure.deg_shells = value
     deg_shells = property(__get_deg_shells,__set_deg_shells)
+
+    @property
+    def gf_struct_solver_list(self):
+        return self.block_structure.gf_struct_solver_list
+
+    @property
+    def gf_struct_sumk_list(self):
+        return self.block_structure.gf_struct_sumk_list
+
+    @property
+    def gf_struct_solver_dict(self):
+        return self.block_structure.gf_struct_solver_dict
+
+    @property
+    def gf_struct_sumk_dict(self):
+        return self.block_structure.gf_struct_sumk_dict
diff --git a/test/blockstructure.py b/test/blockstructure.py
index b96f38aa..eac85863 100644
--- a/test/blockstructure.py
+++ b/test/blockstructure.py
@@ -64,6 +64,14 @@ for i in range(3):
 G3 = original_bs.convert_gf(G_sumk, 'sumk', beta=40, n_points=3)
 assert_block_gfs_are_close(G1, G3)
 
+assert original_bs.gf_struct_sumk_list ==\
+    [[('up', [0, 1, 2]), ('down', [0, 1, 2])]]
+assert original_bs.gf_struct_solver_dict ==\
+    [{'up_0': [0, 1], 'up_1': [0], 'down_1': [0], 'down_0': [0, 1]}]
+assert original_bs.gf_struct_sumk_dict ==\
+    [{'down': [0, 1, 2], 'up': [0, 1, 2]}]
+assert original_bs.gf_struct_solver_list ==\
+    [[('down_0', [0, 1]), ('down_1', [0]), ('up_0', [0, 1]), ('up_1', [0])]]
 
 # check __eq__
 assert full == full, 'equality not correct (equal structures not equal)'

From d0f0c208650e5e8bc68de0014ca745a24e534498 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Thu, 30 Aug 2018 20:24:21 +0200
Subject: [PATCH 04/35] change isinstance for new TRIQS

this fixes test analyse_block_structure_from_gf
---
 python/sumk_dft.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 66d7faac..5f84a3e5 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -868,7 +868,7 @@ class SumkDFT(object):
             the output G(tau) or A(w)
         """
         # make a GfImTime from the supplied GfImFreq
-        if all(isinstance(g_sh._first(), GfImFreq) for g_sh in G):
+        if all(isinstance(g_sh.mesh, MeshImFreq) for g_sh in G):
             gf = [BlockGf(name_block_generator = [(name, GfImTime(beta=block.mesh.beta,
                 indices=block.indices,n_points=len(block.mesh)+1)) for name, block in g_sh],
                 make_copies=False) for g_sh in G]
@@ -876,15 +876,15 @@ class SumkDFT(object):
                 for name, g in gf[ish]:
                     g.set_from_inverse_fourier(G[ish][name])
         # keep a GfImTime from the supplied GfImTime
-        elif all(isinstance(g_sh._first(), GfImTime) for g_sh in G):
+        elif all(isinstance(g_sh.mesh, MeshImTime) for g_sh in G):
             gf = G
         # make a spectral function from the supplied GfReFreq
-        elif all(isinstance(g_sh._first(), GfReFreq) for g_sh in G):
+        elif all(isinstance(g_sh.mesh, MeshReFreq) for g_sh in G):
             gf = [g_sh.copy() for g_sh in G]
             for ish in range(len(gf)):
                 for name, g in gf[ish]:
                     g << 1.0j*(g-g.conjugate().transpose())/2.0/numpy.pi
-        elif all(isinstance(g_sh._first(), GfReTime) for g_sh in G):
+        elif all(isinstance(g_sh.mesh, MeshReTime) for g_sh in G):
             def get_delta_from_mesh(mesh):
                 w0 = None
                 for w in mesh:

From ef979199af73f2987b9c0a2fe07fb64a53b99174 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Thu, 30 Aug 2018 20:49:12 +0200
Subject: [PATCH 05/35] sumk_dft: split transform_to_solver_blocks from
 extract_G_loc

this is done in a backward-compatible manner
---
 python/block_structure.py | 28 +++++++++++++++
 python/sumk_dft.py        | 76 ++++++++++++++++++++++++++++-----------
 2 files changed, 83 insertions(+), 21 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index c5f0bf68..2af7dffe 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -1,3 +1,28 @@
+
+##########################################################################
+#
+# TRIQS: a Toolbox for Research in Interacting Quantum Systems
+#
+# Copyright (C) 2018 by G. J. Kraberger
+# Copyright (C) 2018 by Simons Foundation
+# Authors: G. J. Kraberger, O. Parcollet
+#
+# TRIQS is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# TRIQS is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# TRIQS. If not, see <http://www.gnu.org/licenses/>.
+#
+##########################################################################
+
+
 import copy
 import numpy as np
 from pytriqs.gf import GfImFreq, BlockGf
@@ -417,6 +442,9 @@ class BlockStructure(object):
             if float, set the threshold for the magnitude of an element
             about to be thrown away to trigger a warning
             (default: 1.e-10)
+        G_out : BlockGf
+            the output Green's function (if not given, a new one is
+            created)
         **kwargs :
             options passed to the constructor for the new Gf
         """
diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 5f84a3e5..23b91593 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -3,6 +3,7 @@
 #
 # TRIQS: a Toolbox for Research in Interacting Quantum Systems
 #
+# Copyright (C) 2018 by G. J. Kraberger
 # Copyright (C) 2011 by M. Aichhorn, L. Pourovskii, V. Vildosola
 #
 # TRIQS is free software: you can redistribute it and/or modify it under the
@@ -631,29 +632,34 @@ class SumkDFT(object):
                 for bname, gf in SK_Sigma_imp[icrsh]:
                     gf << self.rotloc(icrsh, gf, direction='toGlobal')
 
-    def extract_G_loc(self, mu=None, iw_or_w='iw', with_Sigma=True, with_dc=True, broadening=None):
+    def extract_G_loc(self, mu=None, iw_or_w='iw', with_Sigma=True, with_dc=True, broadening=None,
+                      transform_to_solver_blocks=True):
         r"""
         Extracts the local downfolded Green function by the Brillouin-zone integration of the lattice Green's function.
 
         Parameters
         ----------
         mu : real, optional
-             Input chemical potential. If not provided the value of self.chemical_potential is used as mu.
+            Input chemical potential. If not provided the value of self.chemical_potential is used as mu.
         with_Sigma : boolean, optional
-                     If True then the local GF is calculated with the self-energy self.Sigma_imp.
+            If True then the local GF is calculated with the self-energy self.Sigma_imp.
         with_dc : boolean, optional
-                  If True then the double-counting correction is subtracted from the self-energy in calculating the GF.
+            If True then the double-counting correction is subtracted from the self-energy in calculating the GF.
         broadening : float, optional
-                     Imaginary shift for the axis along which the real-axis GF is calculated.
-                     If not provided, broadening will be set to double of the distance between mesh points in 'mesh'.
-                     Only relevant for real-frequency GF.
+            Imaginary shift for the axis along which the real-axis GF is calculated.
+            If not provided, broadening will be set to double of the distance between mesh points in 'mesh'.
+            Only relevant for real-frequency GF.
+        transform_to_solver_blocks : bool, optional
+            If True (default), the returned G_loc will be transformed to the block structure ``gf_struct_solver``,
+            else it will be in ``gf_struct_sumk``.
 
         Returns
         -------
-        G_loc_inequiv : list of BlockGf (Green's function) objects
-                        List of the local Green's functions for all inequivalent correlated shells, 
-                        rotated into the corresponding local frames.
-
+        G_loc : list of BlockGf (Green's function) objects
+            List of the local Green's functions for all (inequivalent) correlated shells,
+            rotated into the corresponding local frames.
+            If ``transform_to_solver_blocks`` is True, it will be one per correlated shell, else one per
+            inequivalent correlated shell.
         """
 
         if mu is None:
@@ -712,20 +718,48 @@ class SumkDFT(object):
                     G_loc[icrsh][bname] << self.rotloc(
                         icrsh, gf, direction='toLocal')
 
+        if transform_to_solver_blocks:
+            return self.transform_to_solver_blocks(G_loc)
+
+        return G_loc
+
+    def transform_to_solver_blocks(self, G_loc, G_out=None):
+        """ transform G_loc from sumk to solver space
+
+        Parameters
+        ----------
+        G_loc : list of BlockGf
+            a list of one BlockGf per correlated shell with a structure
+            according to ``gf_struct_sumk``, e.g. as returned by
+            :py:meth:`.extract_G_loc` with ``transform_to_solver_blocks=False``.
+        G_out : list of BlockGf
+            a list of one BlockGf per *inequivalent* correlated shell
+            with a structure according to ``gf_struct_solver``.
+            The output Green's function (if not given, a new one is
+            created)
+
+        Returns
+        -------
+        G_out
+        """
+        if G_out is None:
+            G_out = [BlockGf(mesh=G_loc[0].mesh,
+                             gf_struct=[(k, v) for k, v in self.gf_struct_solver[ish].iteritems()])
+                     for ish in range(self.n_inequiv_shells)]
+        else:
+            for ish in range(self.n_inequiv_shells):
+                self.block_structure.check_gf(G_out, ish=ish)
+
         # transform to CTQMC blocks:
         for ish in range(self.n_inequiv_shells):
-            for block, inner in self.gf_struct_solver[ish].iteritems():
-                for ind1 in inner:
-                    for ind2 in inner:
-                        block_sumk, ind1_sumk = self.solver_to_sumk[
-                            ish][(block, ind1)]
-                        block_sumk, ind2_sumk = self.solver_to_sumk[
-                            ish][(block, ind2)]
-                        G_loc_inequiv[ish][block][ind1, ind2] << G_loc[
-                            self.inequiv_to_corr[ish]][block_sumk][ind1_sumk, ind2_sumk]
+            self.block_structure.convert_gf(
+                G=G_loc[self.inequiv_to_corr[ish]],
+                G_struct='sumk',
+                ish=ish,
+                G_out=G_out[ish])
 
         # return only the inequivalent shells:
-        return G_loc_inequiv
+        return G_out
 
     def analyse_block_structure(self, threshold=0.00001, include_shells=None, dm=None, hloc=None):
         r"""

From d8a26931234ca6f8aa0eac0345ce1b93084c0435 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Thu, 30 Aug 2018 21:55:59 +0200
Subject: [PATCH 06/35] block_structure: introduce space parameter

in methods convert_gf, create_gf, check_gf
---
 python/block_structure.py | 125 +++++++++++++++++++++++++++-----------
 python/sumk_dft.py        |   9 +--
 test/blockstructure.py    |   2 +-
 3 files changed, 96 insertions(+), 40 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index 2af7dffe..e256dfcb 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -349,8 +349,11 @@ class BlockStructure(object):
             self.sumk_to_solver[ish]=su2so
             self.solver_to_sumk_block[ish]=so2su_block
 
-    def create_gf(self,ish=0,gf_function=GfImFreq,**kwargs):
-        """ Create a zero BlockGf having the gf_struct_solver structure.
+    def create_gf(self, ish=0, gf_function=GfImFreq, space='solver', **kwargs):
+        """ Create a zero BlockGf having the correct structure.
+
+        For ``space='solver'``, the structure is according to
+        ``gf_struct_solver``, else according to ``gf_struct_sumk``.
 
         When using GfImFreq as gf_function, typically you have to
         supply beta as keyword argument.
@@ -359,27 +362,40 @@ class BlockStructure(object):
         ----------
         ish : int
             shell index
+            If ``space='solver', the index of the of the inequivalent correlated shell,
+            if ``space='sumk'`, the index of the correlated shell
         gf_function : constructor
             function used to construct the Gf objects constituting the
             individual blocks; default: GfImFreq
+        space : 'solver' or 'sumk'
+            which space the structure should correspond to
         **kwargs :
             options passed on to the Gf constructor for the individual
             blocks
         """
 
-        names = self.gf_struct_solver[ish].keys()
-        blocks=[]
+        if space == 'solver':
+            gf_struct = self.gf_struct_solver
+        elif space == 'sumk':
+            gf_struct = self.gf_struct_sumk_dict
+        else:
+            raise Exception(
+                "Argument space has to be either 'solver' or 'sumk'.")
+
+        names = gf_struct[ish].keys()
+        blocks = []
         for n in names:
-            G = gf_function(indices=self.gf_struct_solver[ish][n],**kwargs)
+            G = gf_function(indices=gf_struct[ish][n], **kwargs)
             blocks.append(G)
-        G = BlockGf(name_list = names, block_list = blocks)
+        G = BlockGf(name_list=names, block_list=blocks)
         return G
 
-    def check_gf(self, G, ish=None):
+    def check_gf(self, G, ish=None, space='solver'):
         """ check whether the Green's function G has the right structure
 
         This throws an error if the structure of G is not the same
-        as ``gf_struct_solver``.
+        as ``gf_struct_solver`` (for ``space=solver``) or
+        ``gf_struct_sumk`` (for ``space=sumk``)..
 
         Parameters
         ----------
@@ -392,34 +408,44 @@ class BlockStructure(object):
             shell index
             default: 0 if G is just one Green's function is given,
             check all if list of Green's functions is given
+        space : 'solver' or 'sumk'
+            which space the structure should correspond to
         """
 
+        if space == 'solver':
+            gf_struct = self.gf_struct_solver
+        elif space == 'sumk':
+            gf_struct = self.gf_struct_sumk_dict
+        else:
+            raise Exception(
+                "Argument space has to be either 'solver' or 'sumk'.")
+
         if isinstance(G, list):
-            assert len(G) == len(self.gf_struct_solver),\
+            assert len(G) == len(gf_struct),\
                 "list of G does not have the correct length"
             if ish is None:
-                ishs = range(len(self.gf_struct_solver))
+                ishs = range(len(gf_struct))
             else:
                 ishs = [ish]
             for ish in ishs:
-                self.check_gf(G[ish], ish=ish)
+                self.check_gf(G[ish], ish=ish, space=space)
             return
 
         if ish is None:
             ish = 0
 
-        for block in self.gf_struct_solver[ish]:
+        for block in gf_struct[ish]:
             assert block in G.indices,\
                 "block " + block + " not in G (shell {})".format(ish)
         for block, gf in G:
-            assert block in self.gf_struct_solver[ish],\
+            assert block in gf_struct[ish],\
                 "block " + block + " not in struct (shell {})".format(ish)
-            assert list(gf.indices) == 2 * [map(str, self.gf_struct_solver[ish][block])],\
+            assert list(gf.indices) == 2 * [map(str, gf_struct[ish][block])],\
                 "block " + block + " has wrong indices (shell {})".format(ish)
 
-    def convert_gf(self, G, G_struct, ish=0, show_warnings=True,
-                   G_out=None, **kwargs):
-        """ Convert BlockGf from its structure to this (solver) structure.
+    def convert_gf(self, G, G_struct, ish_from=0, ish_to=None, show_warnings=True,
+                   G_out=None, space_from='solver', space_to='solver', ish=None, **kwargs):
+        """ Convert BlockGf from its structure to this structure.
 
         .. warning::
 
@@ -432,10 +458,13 @@ class BlockStructure(object):
         G : BlockGf
             the Gf that should be converted
         G_struct : BlockStructure or str
-            the structure of that G or 'sumk' (then, the structure of
-            the sumk Green's function of this BlockStructure is used)
-        ish : int
-            shell index
+            the structure of that G or None (then, this structure
+            is used)
+        ish_from : int
+            shell index of the input structure
+        ish_to : int
+            shell index of the output structure; if None (the default),
+            it is the same as ish_from
         show_warnings : bool or float
             whether to show warnings when elements of the Green's
             function get thrown away
@@ -445,41 +474,67 @@ class BlockStructure(object):
         G_out : BlockGf
             the output Green's function (if not given, a new one is
             created)
+        space_from : 'solver' or 'sumk'
+            whether the Green's function ``G`` corresponds to the
+            solver or sumk structure of ``G_struct``
+        space_to : 'solver' or 'sumk'
+            whether the output Green's function should be according to
+            the solver of sumk structure of this structure
         **kwargs :
             options passed to the constructor for the new Gf
         """
 
+        if ish is not None:
+            warn(
+                'The parameter ish in convert_gf is deprecated. Use ish_from and ish_to instead.')
+            ish_from = ish
+            ish_to = ish
+
+        if ish_to is None:
+            ish_to = ish_from
+
         warning_threshold = 1.e-10
         if isinstance(show_warnings, float):
             warning_threshold = show_warnings
             show_warnings = True
 
-        # we offer the possibility to convert to convert from sumk_dft
-        from_sumk = False
-        if isinstance(G_struct, str) and G_struct == 'sumk':
-            gf_struct_in = self.gf_struct_sumk_dict[ish]
-            from_sumk = True
+        if G_struct is None:
+            G_struct = self
+
+        if space_from == 'solver':
+            gf_struct_in = G_struct.gf_struct_solver[ish_from]
+        elif space_from == 'sumk':
+            gf_struct_in = G_struct.gf_struct_sumk_dict[ish_from]
         else:
-            gf_struct_in = G_struct.gf_struct_solver[ish]
+            raise Exception(
+                "Argument space_from has to be either 'solver' or 'sumk'.")
 
         # create a Green's function to hold the result
         if G_out is None:
-            G_out = self.create_gf(ish=ish, **kwargs)
+            G_out = self.create_gf(ish=ish_to, space=space_to, **kwargs)
         else:
-            self.check_gf(G_out, ish=ish)
+            self.check_gf(G_out, ish=ish_to, space=space_to)
 
         for block in gf_struct_in.keys():
             for i1 in gf_struct_in[block]:
                 for i2 in gf_struct_in[block]:
-                    if from_sumk:
+                    if space_from == 'sumk':
                         i1_sumk = (block, i1)
                         i2_sumk = (block, i2)
-                    else:
-                        i1_sumk = G_struct.solver_to_sumk[ish][(block, i1)]
-                        i2_sumk = G_struct.solver_to_sumk[ish][(block, i2)]
+                    elif space_from == 'solver':
+                        i1_sumk = G_struct.solver_to_sumk[ish_from][(block, i1)]
+                        i2_sumk = G_struct.solver_to_sumk[ish_from][(block, i2)]
+
+                    if space_to == 'sumk':
+                        i1_sol = i1_sumk
+                        i2_sol = i2_sumk
+                    elif space_to == 'solver':
+                        i1_sol = self.sumk_to_solver[ish_to][i1_sumk]
+                        i2_sol = self.sumk_to_solver[ish_to][i2_sumk]
+                    else:
+                        raise Exception(
+                            "Argument space_to has to be either 'solver' or 'sumk'.")
 
-                    i1_sol = self.sumk_to_solver[ish][i1_sumk]
-                    i2_sol = self.sumk_to_solver[ish][i2_sumk]
                     if i1_sol[0] is None or i2_sol[0] is None:
                         if show_warnings:
                             if mpi.is_master_node():
diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 23b91593..1b93373c 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -743,8 +743,7 @@ class SumkDFT(object):
         G_out
         """
         if G_out is None:
-            G_out = [BlockGf(mesh=G_loc[0].mesh,
-                             gf_struct=[(k, v) for k, v in self.gf_struct_solver[ish].iteritems()])
+            G_out = [self.block_structure.create_gf(ish=ish, mesh=G_loc[self.inequiv_to_corr[ish]].mesh)
                      for ish in range(self.n_inequiv_shells)]
         else:
             for ish in range(self.n_inequiv_shells):
@@ -754,8 +753,10 @@ class SumkDFT(object):
         for ish in range(self.n_inequiv_shells):
             self.block_structure.convert_gf(
                 G=G_loc[self.inequiv_to_corr[ish]],
-                G_struct='sumk',
-                ish=ish,
+                G_struct=None,
+                ish_from=self.inequiv_to_corr[ish],
+                ish_to=ish,
+                space_from='sumk',
                 G_out=G_out[ish])
 
         # return only the inequivalent shells:
diff --git a/test/blockstructure.py b/test/blockstructure.py
index eac85863..7333620c 100644
--- a/test/blockstructure.py
+++ b/test/blockstructure.py
@@ -61,7 +61,7 @@ G_sumk = BlockGf(mesh=G1.mesh, gf_struct=original_bs.gf_struct_sumk[0])
 for i in range(3):
     G_sumk['up'][i, i] << SemiCircular(1 if i < 2 else 2)
     G_sumk['down'][i, i] << SemiCircular(4 if i < 2 else 3)
-G3 = original_bs.convert_gf(G_sumk, 'sumk', beta=40, n_points=3)
+G3 = original_bs.convert_gf(G_sumk, None, space_from='sumk', beta=40, n_points=3)
 assert_block_gfs_are_close(G1, G3)
 
 assert original_bs.gf_struct_sumk_list ==\

From 9076baf9d66b01ef931fbf703086af5d16bcc069 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Thu, 30 Aug 2018 22:39:35 +0200
Subject: [PATCH 07/35] sumk_dft: split transform_to_sumk_blocks from put_Sigma

this is done in a backward-compatible manner
---
 python/sumk_dft.py | 102 ++++++++++++++++++++++++++++++---------------
 1 file changed, 68 insertions(+), 34 deletions(-)

diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 1b93373c..08eedafc 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -576,61 +576,95 @@ class SumkDFT(object):
 
         return G_latt
 
-    def set_Sigma(self, Sigma_imp):
-        self.put_Sigma(Sigma_imp)
+    def set_Sigma(self, Sigma_imp, transform_to_sumk_blocks=True):
+        self.put_Sigma(Sigma_imp, transform_to_sumk_blocks)
 
-    def put_Sigma(self, Sigma_imp):
+    def put_Sigma(self, Sigma_imp, transform_to_sumk_blocks=True):
         r"""
-        Inserts the impurity self-energies into the sumk_dft class.
+        Insert the impurity self-energies into the sumk_dft class.
 
         Parameters
         ----------
         Sigma_imp : list of BlockGf (Green's function) objects
-                    List containing impurity self-energy for all inequivalent correlated shells.
-                    Self-energies for equivalent shells are then automatically set by this function.
-                    The self-energies can be of the real or imaginary-frequency type.
+            List containing impurity self-energy for all (inequivalent) correlated shells.
+            Self-energies for equivalent shells are then automatically set by this function.
+            The self-energies can be of the real or imaginary-frequency type.
+        transform_to_sumk_blocks : bool, optional
+            If True (default), the input Sigma_imp will be transformed to the block structure ``gf_struct_sumk``,
+            else it has to be given in ``gf_struct_sumk``.
         """
 
-        assert isinstance(
-            Sigma_imp, list), "put_Sigma: Sigma_imp has to be a list of Sigmas for the correlated shells, even if it is of length 1!"
-        assert len(
-            Sigma_imp) == self.n_inequiv_shells, "put_Sigma: give exactly one Sigma for each inequivalent corr. shell!"
+        if transform_to_sumk_blocks:
+            Sigma_imp = self.transform_to_sumk_blocks(Sigma_imp)
 
-        # init self.Sigma_imp_(i)w:
-        if all( (isinstance(gf, Gf) and isinstance (gf.mesh, MeshImFreq)) for bname, gf in Sigma_imp[0]):
+        assert isinstance(Sigma_imp, list),\
+            "put_Sigma: Sigma_imp has to be a list of Sigmas for the correlated shells, even if it is of length 1!"
+        assert len(Sigma_imp) == self.n_corr_shells,\
+            "put_Sigma: give exactly one Sigma for each corr. shell!"
+
+        if all((isinstance(gf, Gf) and isinstance(gf.mesh, MeshImFreq)) for bname, gf in Sigma_imp[0]):
             # Imaginary frequency Sigma:
-            self.Sigma_imp_iw = [BlockGf(name_block_generator=[(block, GfImFreq(indices=inner, mesh=Sigma_imp[0].mesh))
-                                                               for block, inner in self.gf_struct_sumk[icrsh]], make_copies=False)
+            self.Sigma_imp_iw = [self.block_structure.create_gf(ish=icrsh, mesh=Sigma_imp[icrsh].mesh, space='sumk')
                                  for icrsh in range(self.n_corr_shells)]
             SK_Sigma_imp = self.Sigma_imp_iw
-        elif all( isinstance(gf, Gf) and isinstance (gf.mesh, MeshReFreq) for bname, gf in Sigma_imp[0]):
+        elif all(isinstance(gf, Gf) and isinstance(gf.mesh, MeshReFreq) for bname, gf in Sigma_imp[0]):
             # Real frequency Sigma:
-            self.Sigma_imp_w = [BlockGf(name_block_generator=[(block, GfReFreq(indices=inner, mesh=Sigma_imp[0].mesh))
-                                                              for block, inner in self.gf_struct_sumk[icrsh]], make_copies=False)
+            self.Sigma_imp_w = [self.block_structure.create_gf(ish=icrsh, mesh=Sigma_imp[icrsh].mesh, gf_function=GfReFreq, space='sumk')
                                 for icrsh in range(self.n_corr_shells)]
             SK_Sigma_imp = self.Sigma_imp_w
         else:
-            raise ValueError, "put_Sigma: This type of Sigma is not handled."
+            raise ValueError, "put_Sigma: This type of Sigma is not handled, give either BlockGf of GfReFreq or GfImFreq."
+
+        # rotation from local to global coordinate system:
+        for icrsh in range(self.n_corr_shells):
+            for bname, gf in SK_Sigma_imp[icrsh]:
+                if self.use_rotations:
+                    gf << self.rotloc(icrsh,
+                                      Sigma_imp[icrsh][bname],
+                                      direction='toGlobal')
+                else:
+                    gf << Sigma_imp[icrsh][bname]
+
+    def transform_to_sumk_blocks(self, Sigma_imp, Sigma_out=None):
+        r""" transform Sigma from solver to sumk space
+
+        Parameters
+        ----------
+        Sigma_imp : list of BlockGf (Green's function) objects
+            List containing impurity self-energy for all inequivalent correlated shells.
+            The self-energies can be of the real or imaginary-frequency type.
+        Sigma_out : list of BlockGf
+            list of one BlockGf per correlated shell with the block structure
+            according to ``gf_struct_sumk``; if None, it will be created
+        """
+
+        assert isinstance(Sigma_imp, list),\
+            "transform_to_sumk_blocks: Sigma_imp has to be a list of Sigmas for the inequivalent correlated shells, even if it is of length 1!"
+        assert len(Sigma_imp) == self.n_inequiv_shells,\
+            "transform_to_sumk_blocks: give exactly one Sigma for each inequivalent corr. shell!"
+
+        if Sigma_out is None:
+            Sigma_out = [self.block_structure.create_gf(ish=icrsh, mesh=Sigma_imp[self.corr_to_inequiv[icrsh]].mesh, space='sumk')
+                         for icrsh in range(self.n_corr_shells)]
+        else:
+            for icrsh in range(self.n_corr_shells):
+                self.block_structure.check_gf(Sigma_out,
+                                              ish=icrsh,
+                                              space='sumk')
 
         # transform the CTQMC blocks to the full matrix:
         for icrsh in range(self.n_corr_shells):
             # ish is the index of the inequivalent shell corresponding to icrsh
             ish = self.corr_to_inequiv[icrsh]
-            for block, inner in self.gf_struct_solver[ish].iteritems():
-                for ind1 in inner:
-                    for ind2 in inner:
-                        block_sumk, ind1_sumk = self.solver_to_sumk[
-                            ish][(block, ind1)]
-                        block_sumk, ind2_sumk = self.solver_to_sumk[
-                            ish][(block, ind2)]
-                        SK_Sigma_imp[icrsh][block_sumk][
-                            ind1_sumk, ind2_sumk] << Sigma_imp[ish][block][ind1, ind2]
-
-        # rotation from local to global coordinate system:
-        if self.use_rotations:
-            for icrsh in range(self.n_corr_shells):
-                for bname, gf in SK_Sigma_imp[icrsh]:
-                    gf << self.rotloc(icrsh, gf, direction='toGlobal')
+            self.block_structure.convert_gf(
+                G=Sigma_imp[ish],
+                G_struct=None,
+                space_from='solver',
+                space_to='sumk',
+                ish_from=ish,
+                ish_to=icrsh,
+                G_out=Sigma_out[icrsh])
+        return Sigma_out
 
     def extract_G_loc(self, mu=None, iw_or_w='iw', with_Sigma=True, with_dc=True, broadening=None,
                       transform_to_solver_blocks=True):

From 31cb7a0ea4794413d463c86dd1982cae20769c03 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Fri, 31 Aug 2018 17:52:01 +0200
Subject: [PATCH 08/35] block_structure: prepare for transformation

this includes some TODOs that need to be fixed
---
 python/block_structure.py | 112 ++++++++++++++++++++++++++++++++------
 python/sumk_dft.py        |   3 +
 2 files changed, 97 insertions(+), 18 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index e256dfcb..1d5bb3b2 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -62,6 +62,43 @@ class BlockStructure(object):
 
         maps from the solver block to the sumk block
         for *inequivalent* correlated shell ish
+    deg_shells : list of lists of lists OR list of lists of dicts
+        In the simple format, ``deg_shells[ish][grp]`` is a list of
+        block names; ``ish`` is the index of the inequivalent correlated shell,
+        ``grp`` is the index of the group of symmetry-related blocks.
+        When the name of two blocks is in the same group, that means that
+        these two blocks are the same by symmetry.
+
+        In the more general format, ``deg_shells[ish][grp]`` is a
+        dictionary whose keys are the block names that are part of the
+        group. The values of the dict for each key are tuples ``(v, conj)``,
+        where ``v`` is a transformation matrix with the same matrix dimensions
+        as the block and ``conj`` is a bool (whether or not to conjugate).
+        Two blocks with ``v_1, conj_1`` and ``v_2, conj_2`` being in the same
+        symmetry group means that
+
+        .. math::
+
+            C_1(v_1^\dagger G_1 v_1) = C_2(v_2^\dagger G_2 v_2),
+
+        where the :math:`G_i` are the Green's functions of the block,
+        and the functions :math:`C_i` conjugate their argument if the bool
+        ``conj_i`` is ``True``.
+    transformation : list of numpy.array or list of dict
+        a list with entries for each ``ish`` giving transformation matrices
+        that are used on the Green's function in ``sumk`` space when before
+        converting to the ``solver`` space
+        Up to the change in block structure,
+
+        .. math::
+
+            G_{solver} = T G_{sumk} T^\dagger
+
+        if :math:`T` is the ``transformation`` of that particular shell.
+
+        Note that for each shell this can either be a numpy array which
+        applies to all blocks or a dict with a transformation matrix for
+        each block.
     """
 
     def __init__(self, gf_struct_sumk=None,
@@ -69,13 +106,15 @@ class BlockStructure(object):
                  solver_to_sumk=None,
                  sumk_to_solver=None,
                  solver_to_sumk_block=None,
-                 deg_shells=None):
+                 deg_shells=None,
+                 transformation=None):
         self.gf_struct_sumk = gf_struct_sumk
         self.gf_struct_solver = gf_struct_solver
         self.solver_to_sumk = solver_to_sumk
         self.sumk_to_solver = sumk_to_solver
         self.solver_to_sumk_block = solver_to_sumk_block
         self.deg_shells = deg_shells
+        self.transformation = transformation
 
     @property
     def gf_struct_solver_list(self):
@@ -144,6 +183,13 @@ class BlockStructure(object):
         return [{block: indices for block, indices in gfs}
                 for gfs in self.gf_struct_sumk]
 
+    @property
+    def effective_transformation(self):
+        # TODO: if transformation is None, return np.eye
+        # TODO: zero out all the lines of the transformation that are
+        #       not included in gf_struct_solver
+        return self.transformation
+
     @classmethod
     def full_structure(cls,gf_struct,corr_to_inequiv):
         """ Construct structure that maps to itself.
@@ -294,6 +340,10 @@ class BlockStructure(object):
             but the sumk Gf.
         """
 
+        # TODO: when there is a transformation matrix, this should
+        #       first zero out the corresponding rows of (a copy of) T and then
+        #       pick_gf_struct_solver all lines of (the copy of) T that have at least
+        #       one non-zero entry
 
         gfs = []
         # construct gfs, which is the equivalent of new_gf_struct
@@ -309,9 +359,8 @@ class BlockStructure(object):
                     gfs[ish][ind_sol[0]].append(ind_sol[1])
         self.pick_gf_struct_solver(gfs)
 
-
-    def map_gf_struct_solver(self,mapping):
-        """ Map the Green function structure from one struct to another.
+    def map_gf_struct_solver(self, mapping):
+        r""" Map the Green function structure from one struct to another.
 
         Parameters
         ----------
@@ -319,35 +368,51 @@ class BlockStructure(object):
             the dict consists of elements
             (from_block,from_index) : (to_block,to_index)
             that maps from one structure to the other
+            (one for each shell; use a mapping ``None`` for a shell
+            you want to leave unchanged)
+
+        Examples
+        --------
+
+        Consider a `gf_struct_solver` consisting of two :math:`1 \times 1`
+        blocks, `block_1` and `block_2`. Say you want to have a new block
+        structure where you merge them into one block because you want to
+        introduce an off-diagonal element. You could perform the mapping
+        via::
+
+            map_gf_struct_solver([{('block_1',0) : ('block', 0)
+                                   ('block_2',0) : ('block', 1)}])
         """
 
         for ish in range(len(mapping)):
+            if mapping[ish] is None:
+                continue
             gf_struct = {}
             so2su = {}
             su2so = {}
             so2su_block = {}
-            for frm,to in mapping[ish].iteritems():
+            for frm, to in mapping[ish].iteritems():
                 if not to[0] in gf_struct:
-                    gf_struct[to[0]]=[]
+                    gf_struct[to[0]] = []
                 gf_struct[to[0]].append(to[1])
 
-                so2su[to]=self.solver_to_sumk[ish][frm]
-                su2so[self.solver_to_sumk[ish][frm]]=to
+                so2su[to] = self.solver_to_sumk[ish][frm]
+                su2so[self.solver_to_sumk[ish][frm]] = to
                 if to[0] in so2su_block:
                     if so2su_block[to[0]] != \
-                        self.solver_to_sumk_block[ish][frm[0]]:
+                            self.solver_to_sumk_block[ish][frm[0]]:
                             warn("solver block '{}' maps to more than one sumk block: '{}', '{}'".format(
-                                    to[0],so2su_block[to[0]],self.solver_to_sumk_block[ish][frm[0]]))
+                                to[0], so2su_block[to[0]], self.solver_to_sumk_block[ish][frm[0]]))
                 else:
-                    so2su_block[to[0]]=\
+                    so2su_block[to[0]] =\
                         self.solver_to_sumk_block[ish][frm[0]]
             for k in self.sumk_to_solver[ish].keys():
                 if not k in su2so:
-                    su2so[k] = (None,None)
-            self.gf_struct_solver[ish]=gf_struct
-            self.solver_to_sumk[ish]=so2su
-            self.sumk_to_solver[ish]=su2so
-            self.solver_to_sumk_block[ish]=so2su_block
+                    su2so[k] = (None, None)
+            self.gf_struct_solver[ish] = gf_struct
+            self.solver_to_sumk[ish] = so2su
+            self.sumk_to_solver[ish] = su2so
+            self.solver_to_sumk_block[ish] = so2su_block
 
     def create_gf(self, ish=0, gf_function=GfImFreq, space='solver', **kwargs):
         """ Create a zero BlockGf having the correct structure.
@@ -484,6 +549,8 @@ class BlockStructure(object):
             options passed to the constructor for the new Gf
         """
 
+        # TODO: use effective_transformation here
+
         if ish is not None:
             warn(
                 'The parameter ish in convert_gf is deprecated. Use ish_from and ish_to instead.')
@@ -607,7 +674,7 @@ class BlockStructure(object):
 
         for prop in [ "gf_struct_sumk", "gf_struct_solver",
                 "solver_to_sumk", "sumk_to_solver", "solver_to_sumk_block",
-                "deg_shells"]:
+                "deg_shells","transformation"]:
             if not compare(getattr(self,prop),getattr(other,prop)):
                 return False
         return True
@@ -620,9 +687,13 @@ class BlockStructure(object):
 
         ret = {}
         for element in [ "gf_struct_sumk", "gf_struct_solver",
-                         "solver_to_sumk_block","deg_shells"]:
+                         "solver_to_sumk_block","deg_shells",
+                         "transformation"]:
             ret[element] = getattr(self,element)
 
+        if ret["transformation"] is None:
+            ret["transformation"] = "None"
+
         def construct_mapping(mapping):
             d = []
             for ish in range(len(mapping)):
@@ -648,6 +719,9 @@ class BlockStructure(object):
                     d[ish][literal_eval(k)] = literal_eval(v)
             return d
 
+        if 'transformation' in D and D['transformation'] == "None":
+            D['transformation'] = None
+
         D['solver_to_sumk']=reconstruct_mapping(D['solver_to_sumk'])
         D['sumk_to_solver']=reconstruct_mapping(D['sumk_to_solver'])
         return cls(**D)
@@ -679,6 +753,8 @@ class BlockStructure(object):
                 else:
                     for key in self.deg_shells[ish][l]:
                         s+='   '+key+'\n'
+        s += "transformation\n"
+        s += str(self.transformation)
         return s
 
 from pytriqs.archive.hdf_archive_schemes import register_class
diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 08eedafc..1b7c3d18 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -36,6 +36,9 @@ from warnings import warn
 from scipy import compress
 from scipy.optimize import minimize
 
+# TODO: check where the transformation in block_structure has to enter
+#       - DC
+
 
 class SumkDFT(object):
     """This class provides a general SumK method for combining ab-initio code and pytriqs."""

From 5fd74f73b71477102d90f2c10eb438eb45c4f487 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Tue, 4 Sep 2018 19:02:10 +0200
Subject: [PATCH 09/35] start with Sr2RuO4 guide

---
 doc/documentation.rst                         |  1 +
 doc/guide/Sr2RuO4.rst                         | 40 ++++++++
 doc/guide/Sr2RuO4/Sr2RuO4.indmftpr            | 17 ++++
 doc/guide/Sr2RuO4/Sr2RuO4.struct              | 96 +++++++++++++++++++
 .../Sr2RuO4/calculate_dos_wannier_basis.py    | 15 +++
 5 files changed, 169 insertions(+)
 create mode 100644 doc/guide/Sr2RuO4.rst
 create mode 100644 doc/guide/Sr2RuO4/Sr2RuO4.indmftpr
 create mode 100644 doc/guide/Sr2RuO4/Sr2RuO4.struct
 create mode 100644 doc/guide/Sr2RuO4/calculate_dos_wannier_basis.py

diff --git a/doc/documentation.rst b/doc/documentation.rst
index b000a6c8..45f071d6 100644
--- a/doc/documentation.rst
+++ b/doc/documentation.rst
@@ -26,6 +26,7 @@ User guide
    guide/dftdmft_singleshot
    guide/SrVO3
    guide/dftdmft_selfcons
+   guide/Sr2RuO4
    guide/analysis
    guide/full_tutorial
    guide/transport
diff --git a/doc/guide/Sr2RuO4.rst b/doc/guide/Sr2RuO4.rst
new file mode 100644
index 00000000..a1e3c8b9
--- /dev/null
+++ b/doc/guide/Sr2RuO4.rst
@@ -0,0 +1,40 @@
+.. _Sr2RuO4:
+
+Spin-orbit coupled calculations (single-shot)
+=============================================
+
+There are two main ways of including the spin-orbit coupling (SO) term into
+DFT+DMFT calculations:
+
+-   by performing a DFT calculation including SO and then doing a DMFT calculation on top, or
+-   by performing a DFT calculation without SO and then adding the SO term on the model level.
+
+Treatment of SO in DFT
+----------------------
+
+For now, TRIQS/DFTTools does only work with Wien2k when performing calculations with SO.
+Of course, the general Hk framework is also possible.
+But the way VASP treats SO is fundamentally different to the way Wien2k treats it and the interface does not handle that at the moment.
+
+Therefore, this guide assumes that Wien2k is being used.
+
+First, a Wien2k calculation including SO has to be performed.
+For details, we refer the reader to the documentation of Wien2k.
+The interface to Wien2k only works when the DFT calculation is done both spin-polarized and with SO (that means that you have to initialize the Wien2k calculation accordingly and then run with ``runsp -sp``).
+
+Performing the projection
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Note that the final ``x lapw2 -almd -so -up`` and ``x lapw2 -almd -so -dn`` have to be run *on a single core*, which implies that, before, ``x lapw1 -up``, ``x lapw2 -dn``, and ``x lapwso -up`` have to be run in single-core mode (once).
+
+In the ``case.indmftpr`` file, the spin-orbit flag has to be set to ``1`` for the correlated atoms.
+For example, for the compound Sr\ :sub:`2`\ RuO\ :sub:`4`, with the struct file :download:`Sr2RuO4.struct <Sr2RuO4/Sr2RuO4.struct>`, we would e.g. use the ``indmftpr`` file :download:`found here <Sr2RuO4/Sr2RuO4.indmftpr>`.
+Then, ``dmftproj -sp -so`` has to be called.
+As usual, it is important to check for warnings (e.g., about eigenvalues of the overlap matrix) in the output of ``dmftproj`` and adapt the window until these warnings disappear.
+
+Note that in presence of SO, it is not possible to project only onto the :math:`t_{2g}` subshell because it is not an irreducible representation.
+A redesign of the orthonormalization procedure might happen in the long term, which might allow that.
+
+We strongly suggest using the :py:meth:`.dos_wannier_basis` functionality of the :py:class:`.SumkDFTTools` class (see :download:`calculate_dos_wannier_basis.py <Sr2RuO4/calculate_dos_wannier_basis.py>`) and compare the Wannier-projected orbitals to the original DFT DOS (they should be more or less equal).
+Note that, with SO, there are usually off-diagonal elements of the spectral function, which can also be imaginary.
+The imaginary part can be found in the third column of the files ``DOS_wann_...``.
diff --git a/doc/guide/Sr2RuO4/Sr2RuO4.indmftpr b/doc/guide/Sr2RuO4/Sr2RuO4.indmftpr
new file mode 100644
index 00000000..fa8e6be5
--- /dev/null
+++ b/doc/guide/Sr2RuO4/Sr2RuO4.indmftpr
@@ -0,0 +1,17 @@
+4 ! Nsort
+2 1 2 2 ! Multiplicities
+3 ! lmax
+complex ! Sr
+0 0 0 0
+0 0 0 0
+cubic ! Ru
+0 0 2 0 ! include d-shell as correlated
+0 0 0 0 ! there are no irreps with SO
+1 ! SO-flag
+complex ! O1
+0 0 0 0
+0 0 0 0
+complex ! O2
+0 0 0 0
+0 0 0 0
+-0.7 1.4 ! energy window (Ry)
diff --git a/doc/guide/Sr2RuO4/Sr2RuO4.struct b/doc/guide/Sr2RuO4/Sr2RuO4.struct
new file mode 100644
index 00000000..5cfd9a0d
--- /dev/null
+++ b/doc/guide/Sr2RuO4/Sr2RuO4.struct
@@ -0,0 +1,96 @@
+Sr2RuO4                                  s-o calc. M||  0.00  0.00  1.00
+B                            4 39_I
+             RELA
+  7.300012  7.300012 24.044875 90.000000 90.000000 90.000000
+ATOM  -1: X=0.00000000 Y=0.00000000 Z=0.35240000
+          MULT= 2          ISPLIT=-2
+      -1: X=0.00000000 Y=0.00000000 Z=0.64760000
+Sr2+       NPT=  781  R0=.000010000 RMT=   2.26000   Z:  38.00000
+LOCAL ROT MATRIX:    1.0000000 0.0000000 0.0000000
+                     0.0000000 1.0000000 0.0000000
+                     0.0000000 0.0000000 1.0000000
+ATOM  -2: X=0.00000000 Y=0.00000000 Z=0.00000000
+          MULT= 1          ISPLIT=-2
+Ru4+       NPT=  781  R0=.000010000 RMT=   1.95000   Z:  44.00000
+LOCAL ROT MATRIX:    1.0000000 0.0000000 0.0000000
+                     0.0000000 1.0000000 0.0000000
+                     0.0000000 0.0000000 1.0000000
+ATOM  -3: X=0.50000000 Y=0.00000000 Z=0.00000000
+          MULT= 2          ISPLIT= 8
+      -3: X=0.00000000 Y=0.50000000 Z=0.00000000
+O 2-       NPT=  781  R0=.000100000 RMT=   1.68000   Z:   8.00000
+LOCAL ROT MATRIX:    1.0000000 0.0000000 0.0000000
+                     0.0000000 1.0000000 0.0000000
+                     0.0000000 0.0000000 1.0000000
+ATOM  -4: X=0.00000000 Y=0.00000000 Z=0.16350000
+          MULT= 2          ISPLIT=-2
+      -4: X=0.00000000 Y=0.00000000 Z=0.83650000
+O 2-       NPT=  781  R0=.000100000 RMT=   1.68000   Z:   8.00000
+LOCAL ROT MATRIX:    1.0000000 0.0000000 0.0000000
+                     0.0000000 1.0000000 0.0000000
+                     0.0000000 0.0000000 1.0000000
+  16      NUMBER OF SYMMETRY OPERATIONS
+ 0-1 0 0.00000000
+ 1 0 0 0.00000000
+ 0 0-1 0.00000000
+       1   A   2 so. oper.  type  orig. index
+-1 0 0 0.00000000
+ 0-1 0 0.00000000
+ 0 0-1 0.00000000
+       2   A   3
+ 1 0 0 0.00000000
+ 0 1 0 0.00000000
+ 0 0-1 0.00000000
+       3   A   6
+ 0-1 0 0.00000000
+ 1 0 0 0.00000000
+ 0 0 1 0.00000000
+       4   A   8
+ 0 1 0 0.00000000
+-1 0 0 0.00000000
+ 0 0-1 0.00000000
+       5   A   9
+-1 0 0 0.00000000
+ 0-1 0 0.00000000
+ 0 0 1 0.00000000
+       6   A  11
+ 1 0 0 0.00000000
+ 0 1 0 0.00000000
+ 0 0 1 0.00000000
+       7   A  14
+ 0 1 0 0.00000000
+-1 0 0 0.00000000
+ 0 0 1 0.00000000
+       8   A  15
+ 1 0 0 0.00000000
+ 0-1 0 0.00000000
+ 0 0-1 0.00000000
+       9   B   1
+ 0 1 0 0.00000000
+ 1 0 0 0.00000000
+ 0 0-1 0.00000000
+      10   B   4
+ 0-1 0 0.00000000
+-1 0 0 0.00000000
+ 0 0-1 0.00000000
+      11   B   5
+ 1 0 0 0.00000000
+ 0-1 0 0.00000000
+ 0 0 1 0.00000000
+      12   B   7
+-1 0 0 0.00000000
+ 0 1 0 0.00000000
+ 0 0-1 0.00000000
+      13   B  10
+ 0 1 0 0.00000000
+ 1 0 0 0.00000000
+ 0 0 1 0.00000000
+      14   B  12
+ 0-1 0 0.00000000
+-1 0 0 0.00000000
+ 0 0 1 0.00000000
+      15   B  13
+-1 0 0 0.00000000
+ 0 1 0 0.00000000
+ 0 0 1 0.00000000
+      16   B  16
diff --git a/doc/guide/Sr2RuO4/calculate_dos_wannier_basis.py b/doc/guide/Sr2RuO4/calculate_dos_wannier_basis.py
new file mode 100644
index 00000000..7cb8462a
--- /dev/null
+++ b/doc/guide/Sr2RuO4/calculate_dos_wannier_basis.py
@@ -0,0 +1,15 @@
+from triqs_dft_tools.converters.wien2k_converter import Wien2kConverter
+from triqs_dft_tools import SumkDFTTools
+
+filename = 'Sr2RuO4'
+
+conv = Wien2kConverter(filename = filename,hdf_filename=filename+'.h5')
+conv.convert_dft_input()
+
+SK = SumkDFTTools(filename+'.h5')
+mesh = (-10.0,10.0,500)
+SK.dos_wannier_basis(broadening=(mesh[1]-mesh[0])/float(mesh[2]),
+                     mesh=mesh,
+                     save_to_file=True,
+                     with_Sigma=False,
+                     with_dc=False)

From 2d481198766cf8ce30b40370080fceb29911dbea Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Fri, 7 Sep 2018 11:27:07 +0200
Subject: [PATCH 10/35] block_structure: effective_transformation_sumk

---
 python/block_structure.py | 52 ++++++++++++++++++++++++++++++++----
 test/blockstructure.py    | 55 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 101 insertions(+), 6 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index 1d5bb3b2..42227c82 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -133,6 +133,8 @@ class BlockStructure(object):
 
         The list for each shell is sorted alphabetically by block name.
         """
+        if self.gf_struct_solver is None:
+            return None
         # we sort by block name in order to get a reproducible result
         return [sorted([(k, v) for k, v in gfs.iteritems()], key=lambda x: x[0])
                 for gfs in self.gf_struct_solver]
@@ -180,15 +182,55 @@ class BlockStructure(object):
         ``gf_struct_sumk_dict[ish][bname]``
         is a list of the indices of block ``bname`` of shell ``ish``.
         """
+        if self.gf_struct_sumk is None:
+            return None
         return [{block: indices for block, indices in gfs}
                 for gfs in self.gf_struct_sumk]
 
     @property
-    def effective_transformation(self):
-        # TODO: if transformation is None, return np.eye
-        # TODO: zero out all the lines of the transformation that are
-        #       not included in gf_struct_solver
-        return self.transformation
+    def effective_transformation_sumk(self):
+        trans = copy.deepcopy(self.transformation)
+        if self.gf_struct_sumk is None:
+            raise Exception('gf_struct_sumk not set.')
+        if self.gf_struct_solver is None:
+            raise Exception('gf_struct_solver not set.')
+
+        if trans is None:
+            trans = [{block: np.eye(len(indices)) for block, indices in gfs}
+                     for gfs in self.gf_struct_sumk]
+
+        assert isinstance(trans, list),\
+            "transformation has to be a list"
+
+        assert len(trans) == len(self.gf_struct_sumk),\
+            "give one transformation per correlated shell"
+
+        for icrsh in range(len(trans)):
+            if trans[icrsh] is None:
+                trans[icrsh] = {block: np.eye(len(indices))
+                                for block, indices in self.gf_struct_sumk[icrsh]}
+
+            if not isinstance(trans[icrsh], dict):
+                trans[icrsh] = {block: copy.deepcopy(trans[icrsh])
+                                for block, indices in self.gf_struct_sumk[icrsh]}
+
+            assert trans[icrsh].keys() == self.gf_struct_sumk_dict[icrsh].keys(),\
+                "wrong block names used in transformation (icrsh = {})".format(icrsh)
+
+            for block in trans[icrsh]:
+                assert trans[icrsh][block].shape[0] == trans[icrsh][block].shape[1],\
+                    "Transformation has to be quadratic; throwing away orbitals can be achieved on the level of the mapping. (icrsh = {}, block = {})".format(icrsh, block)
+
+                assert trans[icrsh][block].shape[0] == len(self.gf_struct_sumk_dict[icrsh][block]),\
+                    "Transformation block shape does not match gf_struct_sumk. (icrsh = {}, block = {})".format(icrsh, block)
+
+                # zero out all the lines of the transformation that are
+                # not included in gf_struct_solver
+                for iorb, norb in enumerate(self.gf_struct_sumk_dict[icrsh][block]):
+                    if self.sumk_to_solver[icrsh][(block, norb)][0] is None:
+                        trans[icrsh][block][iorb, :] = 0.0
+        return trans
+
 
     @classmethod
     def full_structure(cls,gf_struct,corr_to_inequiv):
diff --git a/test/blockstructure.py b/test/blockstructure.py
index 7333620c..b0da8c5c 100644
--- a/test/blockstructure.py
+++ b/test/blockstructure.py
@@ -3,15 +3,38 @@ from pytriqs.utility.h5diff import h5diff
 from pytriqs.gf import *
 from pytriqs.utility.comparison_tests import assert_block_gfs_are_close
 from triqs_dft_tools.block_structure import BlockStructure
+import numpy as np
+from pytriqs.utility.h5diff import compare, failures
+
+
+def cmp(a, b, precision=1.e-15):
+    compare('', a, b, 0, precision)
+    if failures:
+        raise AssertionError('\n'.join(failures))
 
 SK = SumkDFT('blockstructure.in.h5', use_dft_blocks=True)
 
 original_bs = SK.block_structure
+cmp(original_bs.effective_transformation_sumk,
+    [{'down': np.array([[1., 0., 0.],
+                        [0., 1., 0.],
+                        [0., 0., 1.]]),
+      'up': np.array([[1., 0., 0.],
+                      [0., 1., 0.],
+                      [0., 0., 1.]])}])
 
 # check pick_gf_struct_solver
 pick1 = original_bs.copy()
 pick1.pick_gf_struct_solver([{'up_0': [1], 'up_1': [0], 'down_1': [0]}])
 
+cmp(pick1.effective_transformation_sumk,
+    [{'down': np.array([[0., 0., 0.],
+                        [0., 0., 0.],
+                        [0., 0., 1.]]),
+      'up': np.array([[0., 0., 0.],
+                      [0., 1., 0.],
+                      [0., 0., 1.]])}])
+
 # check loading a block_structure from file
 SK.block_structure = SK.load(['block_structure'], 'mod')[0]
 assert SK.block_structure == pick1, 'loading SK block structure from file failed'
@@ -25,10 +48,36 @@ sk_pick1 = BlockStructure(gf_struct_sumk=SK.gf_struct_sumk,
                           deg_shells=SK.deg_shells)
 assert sk_pick1 == pick1, 'constructing block structure from SumkDFT properties failed'
 
+cmp(pick1.effective_transformation_sumk,
+    [{'down': np.array([[0., 0., 0.],
+                        [0., 0., 0.],
+                        [0., 0., 1.]]),
+      'up': np.array([[0., 0., 0.],
+                      [0., 1., 0.],
+                      [0., 0., 1.]])}])
+
 # check pick_gf_struct_sumk
 pick2 = original_bs.copy()
 pick2.pick_gf_struct_sumk([{'up': [1, 2], 'down': [0, 1]}])
 
+cmp(pick2.effective_transformation_sumk,
+    [{'down': np.array([[1., 0., 0.],
+                        [0., 1., 0.],
+                        [0., 0., 0.]]),
+      'up': np.array([[0., 0., 0.],
+                      [0., 1., 0.],
+                      [0., 0., 1.]])}])
+
+pick3 = pick2.copy()
+pick3.transformation = [np.reshape(range(9), (3, 3))]
+cmp(pick3.effective_transformation_sumk,
+    [{'down': np.array([[0, 1, 2],
+                        [3, 4, 5],
+                        [0, 0, 0]]),
+      'up': np.array([[0, 0, 0],
+                      [3, 4, 5],
+                      [6, 7, 8]])}])
+
 # check map_gf_struct_solver
 mapping = [{('down_0', 0): ('down', 0),
             ('down_0', 1): ('down', 2),
@@ -61,7 +110,11 @@ G_sumk = BlockGf(mesh=G1.mesh, gf_struct=original_bs.gf_struct_sumk[0])
 for i in range(3):
     G_sumk['up'][i, i] << SemiCircular(1 if i < 2 else 2)
     G_sumk['down'][i, i] << SemiCircular(4 if i < 2 else 3)
-G3 = original_bs.convert_gf(G_sumk, None, space_from='sumk', beta=40, n_points=3)
+G3 = original_bs.convert_gf(G_sumk,
+                            None,
+                            space_from='sumk',
+                            beta=40,
+                            n_points=3)
 assert_block_gfs_are_close(G1, G3)
 
 assert original_bs.gf_struct_sumk_list ==\

From bc78560ee1184f6da5652fe89c70d200545800ac Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Fri, 7 Sep 2018 14:40:43 +0200
Subject: [PATCH 11/35] block_structure: add corr_to_inequiv

---
 python/block_structure.py                   |  37 ++++++++++++++++----
 python/sumk_dft.py                          |  18 ++++++++--
 test/analyse_block_structure_from_gf.ref.h5 | Bin 73312 -> 76008 bytes
 test/blockstructure.in.h5                   | Bin 66104 -> 67352 bytes
 test/blockstructure.py                      |   3 +-
 test/blockstructure.ref.h5                  | Bin 248384 -> 240784 bytes
 6 files changed, 48 insertions(+), 10 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index 42227c82..df0cc2e9 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -107,6 +107,7 @@ class BlockStructure(object):
                  sumk_to_solver=None,
                  solver_to_sumk_block=None,
                  deg_shells=None,
+                 corr_to_inequiv = None,
                  transformation=None):
         self.gf_struct_sumk = gf_struct_sumk
         self.gf_struct_solver = gf_struct_solver
@@ -114,6 +115,7 @@ class BlockStructure(object):
         self.sumk_to_solver = sumk_to_solver
         self.solver_to_sumk_block = solver_to_sumk_block
         self.deg_shells = deg_shells
+        self.corr_to_inequiv = corr_to_inequiv
         self.transformation = transformation
 
     @property
@@ -187,6 +189,24 @@ class BlockStructure(object):
         return [{block: indices for block, indices in gfs}
                 for gfs in self.gf_struct_sumk]
 
+    @property
+    def inequiv_to_corr(self):
+        if self.corr_to_inequiv is None:
+            return None
+        N_solver = len(np.unique(self.corr_to_inequiv))
+        if self.gf_struct_solver is not None:
+            assert N_solver == len(self.gf_struct_solver)
+        assert sorted(np.unique(self.corr_to_inequiv)) == range(N_solver),\
+            "an inequivalent shell is missing in corr_to_inequiv"
+        return [self.corr_to_inequiv.index(icrsh)
+                for icrsh in range(N_solver)]
+
+    @inequiv_to_corr.setter
+    def inequiv_to_corr(self, value):
+        if value is None:
+            return
+        assert self.inequiv_to_corr == value, "Trying to set incompatible inequiv_to_corr"
+
     @property
     def effective_transformation_sumk(self):
         trans = copy.deepcopy(self.transformation)
@@ -285,7 +305,8 @@ class BlockStructure(object):
                 solver_to_sumk = copy.deepcopy(solver_to_sumk),
                 sumk_to_solver = solver_to_sumk,
                 solver_to_sumk_block = s2sblock,
-                deg_shells = [[] for ish in range(len(gf_struct))])
+                deg_shells = [[] for ish in range(len(gf_struct))],
+                corr_to_inequiv = corr_to_inequiv)
 
     def pick_gf_struct_solver(self,new_gf_struct):
         """ Pick selected orbitals within blocks.
@@ -716,7 +737,7 @@ class BlockStructure(object):
 
         for prop in [ "gf_struct_sumk", "gf_struct_solver",
                 "solver_to_sumk", "sumk_to_solver", "solver_to_sumk_block",
-                "deg_shells","transformation"]:
+                "deg_shells","transformation", "corr_to_inequiv"]:
             if not compare(getattr(self,prop),getattr(other,prop)):
                 return False
         return True
@@ -730,8 +751,10 @@ class BlockStructure(object):
         ret = {}
         for element in [ "gf_struct_sumk", "gf_struct_solver",
                          "solver_to_sumk_block","deg_shells",
-                         "transformation"]:
+                         "transformation", "corr_to_inequiv"]:
             ret[element] = getattr(self,element)
+            if ret[element] is None:
+                ret[element] = 'None'
 
         if ret["transformation"] is None:
             ret["transformation"] = "None"
@@ -761,8 +784,9 @@ class BlockStructure(object):
                     d[ish][literal_eval(k)] = literal_eval(v)
             return d
 
-        if 'transformation' in D and D['transformation'] == "None":
-            D['transformation'] = None
+        for elem in D:
+            if D[elem]=="None":
+                D[elem] = None
 
         D['solver_to_sumk']=reconstruct_mapping(D['solver_to_sumk'])
         D['sumk_to_solver']=reconstruct_mapping(D['sumk_to_solver'])
@@ -770,7 +794,8 @@ class BlockStructure(object):
 
     def __str__(self):
         s=''
-        s+= "gf_struct_sumk "+str( self.gf_struct_sumk)+'\n'
+        s+= "corr_to_inequiv "+str(self.corr_to_inequiv)+'\n'
+        s+= "gf_struct_sumk "+str(self.gf_struct_sumk)+'\n'
         s+= "gf_struct_solver "+str(self.gf_struct_solver)+'\n'
         s+= "solver_to_sumk_block "+str(self.solver_to_sumk_block)+'\n'
         for el in ['solver_to_sumk','sumk_to_solver']:
diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 1b7c3d18..854ee564 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -98,6 +98,8 @@ class SumkDFT(object):
             self.misc_data = misc_data
             self.h_field = h_field
 
+            self.block_structure = BlockStructure()
+
             # Read input from HDF:
             things_to_read = ['energy_unit', 'n_k', 'k_dep_projection', 'SP', 'SO', 'charge_below', 'density_required',
                               'symm_op', 'n_shells', 'shells', 'n_corr_shells', 'corr_shells', 'use_rotations', 'rot_mat',
@@ -123,8 +125,6 @@ class SumkDFT(object):
                     self.spin_names_to_ind[iso][
                         self.spin_block_names[iso][isp]] = isp * self.SP
 
-            self.block_structure = BlockStructure()
-
             # GF structure used for the local things in the k sums
             # Most general form allowing for all hybridisation, i.e. largest
             # blocks possible
@@ -187,7 +187,7 @@ class SumkDFT(object):
         # initialise variables on all nodes to ensure mpi broadcast works at
         # the end
         for it in things_to_read:
-            setattr(self, it, 0)
+            setattr(self, it, None)
         subgroup_present = 0
 
         if mpi.is_master_node():
@@ -2145,3 +2145,15 @@ class SumkDFT(object):
     @property
     def gf_struct_sumk_dict(self):
         return self.block_structure.gf_struct_sumk_dict
+
+    def __get_corr_to_inequiv(self):
+        return self.block_structure.corr_to_inequiv
+    def __set_corr_to_inequiv(self, value):
+        self.block_structure.corr_to_inequiv = value
+    corr_to_inequiv = property(__get_corr_to_inequiv, __set_corr_to_inequiv)
+
+    def __get_inequiv_to_corr(self):
+        return self.block_structure.inequiv_to_corr
+    def __set_inequiv_to_corr(self, value):
+        self.block_structure.inequiv_to_corr = value
+    inequiv_to_corr = property(__get_inequiv_to_corr, __set_inequiv_to_corr)
diff --git a/test/analyse_block_structure_from_gf.ref.h5 b/test/analyse_block_structure_from_gf.ref.h5
index 7acea34d680aa13c55ebfa786da8eea4044c2812..e046860512cd1a04b2918461f2c7fecf8a0cf7ba 100644
GIT binary patch
delta 6538
zcmai24RBP|6@K?FKksdR*d&H*Hoz_d62jjy#IhnfTgN(#MF?Oe1%*WfB4S*SpOs=+
zT7M!_=`N?546VBOQ&!Nrk8~s;mc^k?V6d}*LsJkNtksB&EVkkbj`rSj-rY^!IMbbh
zbG~!WyZ5~FoqON8=|0e}=Xk$ZE$^u{>uz(fh-rS$AlzSfwrKRLtp|@|n9+C>!4NE7
z>*ek_aJ2tSPvB`XGRwECjg%<F&CAf;X~3j`FYu;o%w2;y^cZdky)u&xgjvo>n`#I5
zeYC;CVK>=pttnGO`}%cRIOipM(DF-+?&}wuL^w5>WP|0GS&GUMO~o8(rjfQV$q)%G
z^)M;QuVEA6+#@6-mS1>7U%##=Ex)JY<^+fph2rgQSTTGC@3;w`AF@!2?}jYg)M4e*
zA-oOoPvL$x+~0-=*ziCb)@@kM-Fto~;Z6Aki);?X0(0?C1yo`iFSX%8Hte$DG8-;O
z{L{h$6*h-!Y`D^fWuf$bqpG-B4Id7J_@43Y&E6g+Gu${F6WuYqkZ6zXu^Jm5V#Bh|
zdM`7~hGqTr9{1VsaKeQ|Uu$z1A#m?RkF?=Y0!wlf5!czUEco8za>w+>V-PPWOi*WY
z7;D4hY<Rp4Pq5*MadRJ}$Iju|BKX5d-{Ai~ux-KInX_(X;<aQM%3ro3ZVrR&NS&qH
z7Y`o9&_9R%{iHv1S5-4NOm$4)`jGbX8wYb9bHo1fWzNEZ08ZC3-Y~S?S$rGksT!D5
z+U%KLP4lbW8Mbh&#x#d9vF&tc!GsfpeYi?&1g+xs;VOmW1f9A@!iIwr*=X_!jDXXX
z&7O>}?^-zvyGPJkdkiCQf$c9Y<H0d-rD}rPEfX$&KKx(PG80LG*>k;S`UnHxDL3~`
z#N)NAp2qNaHQYBSw4>Bp9gvkEe(GIA7LI~h=WS1atTSicG#YlDN^q@M5K_+*V^s1(
zFng>QVt44Q3$@@Voi~h&n}0z*^kTUCx^>(|!Y#y-^^8DmG0eD6fj}`#TPnejIUn;*
z@%S+C&DD8uywoyvI`2R&ENuP>I67A6Nz~H9=AINcn{mPE#qgUuZ{?XO^25M0li~JP
z7RJ;1pd}BjUcG3|LyPWjUb<@S{p(=S1CKy%pAYFQ9Oy8AUNd)1BaR|dV8x{7TRLsW
zf8ct`S>qIv@>G()^lXwUmre5tx7;niSeXfik$(`E3CzS0J8lGLrWtZhmos8<({`h&
zDy?8@-!diX;tj>H@<cuFxI^YZ)P8kJp5o%CR*lXgoPZs3z43GxWPUXOO5GlJb`A~r
zNNCAMQu>rkZXTA5b`OnF$pjZGH2W>Lq2`~B<q)EBh|EDwk_H@^i^afGcS?&ahT5O0
zVrU}b!-DHtMSQdv#*I-RMh<Nx5>yQd@jO+7`!1=;YKWmGt3jWKqoNw3sL5)`{#;c<
zlByxMh!{=YjXSfz3=-kH7l}wLl0<lVY&3?fTtpX{7AZ#F1e-&X;n;$8JVmr57Rz8H
zElo=(XNs1Xg;QWIM_PQ2YPJmbvbLODeI&Gwm8A3`MqddlJYIbj4G}L5YZcmDROQUC
zuoQ_&6EQ8ztcaj%xhVEKbe?XK7D-Itenm{DV5C8j&?Oj|tw0Y^ktLBMp_Sk^O^N4;
znA#Omlf)!Ylf<|mz)?X=3^hrN)~txpOK_X&YlxVRFcMQ}n835Lx!k{wUNAsHtKHas
z<?#WWXCH-K_jvWq>h(q2$WpL*Z55<SUDdgzWLK#VTS<$7x$0m%9ikIl86SrE;UssJ
zz_hFNa+38_zLE7Z`sga1=TMXH7KzAwg;&q#z7jaL`j^~KB1ocvL`aA=)3|#BIM=Q-
z!dt8$<7O2;8YZtOiC77IyRM$+#LUB>VZB)65uvrF7!#-425C$PW9=`5_AHk+sX<oQ
z!jH;S%3u;Ddp{V$9%Evs`;4Z?Xg$6CIDF5Xh0YQyJ@y2p+w~ZJeY$LYXvWHD_SdE?
z_0)00$XhT?DH(1ZY~AeSt|v_MN4O@BJx#N^x6pU*NeUtN6n*!$$|^7K_$^r#m#Jrv
z%K?#AX@@V0YV_^oLB$<-K_U5_%2;VsoaQX-hIq{SPUTHcW2k9jGyvyf#HbdRsgsOG
zQIm{n+Z3Z2;-i~HmV{P{G`mV++}8U1ttEC6rk?VOuigApqxBC|lx2?5M$^j{Qe^vR
z0zZjhDUux(ixSzIxXV~%`+p~mlI)b!kZk`m(k98yJ*&uWDD6dd_BmQFLSz@NNO1ZY
z@fl0tvDWsS_ypd!X<)u@3fXQ}jlZ{Mv1W4<)N(+I%6Vo7;p|H!Wm71B(fuTqU(&*z
z2gn|jLf&vP8L1UMRXGd0Pm;ZXgckaW6g8p#9pPH*BNwv#f)4Ufe%+;{wHPELmY?Qi
zTBX#LV^0-ndh4MYCQf4)9tnj!$ODvx;P}8wNR2H1!RE8=1>|O=&Kq}_W+^tGtVumW
z{by>RkGJf!cHGP0e0;gFgF?!_gj*w%#J(}Rn|%B`;k<Dl+&tJ>-Dy>lia2Xw7qFyN
z?|IWsoGb7;Y?(Zfr6lK$w%uCmjRt$r<A0SFRP!`iII`PR9Y(=~4Q9f`m=b%ic(jx#
zp5|NHUhg|i+QQv$kX^Mvkw5qKOISGlrfh*^=UjLawlBB~8h5VdVX-@Q)^lx-%xLBl
zgSA@;)gk!my*w}oUVCF259}3jO=KMyR`;7w_u4XNVS3p9+Vjx(x~syaQ7o~26iG;&
zEoZK)?iUV=3qfqBuiSo%XxpoZ%<hxxdUTC8fP>vIh~|h{*@G*8O7SBu8IBQr+nOJK
zyrGt*iNKx%cmNhQ05X$2gc<ETjMV69i<*QrgQBL>!aWC(n$Qfx$Xk#Z*Sm5az2{w8
z8Q56S>i>g5VxOCb55xX_&9~_9(3qOjZ{dc+WLG@7j`sBnSh(?+<jFPJF!B##GjY@<
zn*KVt`GAv$-&OhYcS<dG)nKT|j>30Dn&cVVCbVa<AwS{58^CE76o0Xv5jgLHX$PnA
z%rShU<a<BxMv-IUjTU0toDU9T`LYm;|2-8;_HP)AxP&x8JmZz^4eLft2Gf{P!CY~{
zg^TN18HVH}QC^0@1m8!R0)NK}3!MDF7YA`S%TVC%llXOwoS`!4K85#&gzfxHyieZg
zQzR7`4d)0e(sG|!vtE#7M5_!V{~#`tIExYb&d7GPy3@8wcNaaafq7P*6b3Vt<&4;J
zN$x3wjh|f4&dP*|-RAzV@9M69686LFV_$>M;pWM6*rrB5q5&TXEzm<szD@O?uO9fR
zWy`!#tzRIWKIfUNLg)VI*7Iw`&&`79J98x=pI^^Dk};(|H`u=vn?cy|v3J`ALx_VA
zJdBRwIytorivOx;yq##ALt;LOdr7P)!%o%zZ#kj7P$p4}T{6J@#0#QNWo@W+UozOI
z(n+?d(a%(yy1ES8)Rv3HY~TWJ@B%|fNa_+2;=hQ5L~L|stvtBk&?R+rE7L_}WJ4L=
z>HL@E`r`87$$d%5QWfF*58>cfvLYlW9bX|QvCA~zBcV<ImXtgv^3MQmS7F6gFVkSl
z*3o)Dnll9A%3$Q@h1r*9L3+j<zNHLr_wLJ>iW3I=S}O8#-vEohp?%dUw1c>{w^5R}
zm%#^T6dSw9wui)i67P^WN^Atbk&{X`I#3gx81uubtHehVHJ`XQ_^x6Uf}<E5lA~i^
z<R_32N1KDSf4;GjJEm(4-YQ>O)T>8;nw1Y$r2Es02CU3<6tVWJkN4+}XbFQF$52Bn
zQ<)IA2P0UikmxpRT5Ju7#%R>%V5T{gwRSt1;Vjr-L3k%WEl!cE^^RbF7B`1NVzI#o
zq9)ECM+>RqJsr9(tZ!rAe!dL5%PS<D<%m2a>V#M`&5<-16s=urL_Jn`s<E6(Znu+|
zUoIO<M~j?$sJuon(b*Wxi}wgez)2yk*Bu?G%I1;<T8|eouk0=zT8VIY5Mx?VzV}<s
zUS>wFf>xw^gpqHpS}!@-PvH4^bq?QPX6~-!JW<g))nLsvO}1_<WF<ISfk~5J|Ds+t
zOxlKWS^17cB}OR!l-Ja{qf)kHSqx{3e7}*9y3^-K47C`q^$_FvCQjfY*HTB1xUpQV
z8eh>VN?raG^XX9*^DU#rD)&IbQ|7VKNsgMP*N|2_v=C}98-}{Q9QmE@#ZbkLaJYt}
zDhZBR>RE$dD~!bNE+S_?iK8S=lQ>`AD)KyTudAAI#;=gkSwSUGfo#U)Ovt9gHA1Sy
fW^g2$#ZAGHMpd%u2#!LlWK)-~No>|t&}HF&`*nIb

delta 6278
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
bKwI2G<$xYSl>-`|#k>e;TOFg@JIMb4heS0i

diff --git a/test/blockstructure.in.h5 b/test/blockstructure.in.h5
index 6e1bb46905cf3496c64e184258c9168afef997b8..7e03651c9fa5b68fa3be4e9480d8a2a236ed296c 100644
GIT binary patch
delta 2473
zcmZ8iZD><h7{2GE+IwTwTQ{?qZfyoz8+6zXti*v3!5>*ITijrj3L0kHMTHn;lTO8E
zP)62?CVfEz`;+}}i}fqlOEJ11%VZx>sf*KUs#t=>8e81dqIPa|J6|^+4cvR)=RNOv
z&+|U#JvYhTis*rgumf8wwWYOHk(9i$LXsqBl)T6fk!LP>42+3gI&Uh>!@jC|?2N*9
ze7Iay-(xJQBtc3^5_uM;bEQem1k;U-_48)oDuU@_%+H^N7Z6N*?-T+S&I(Worb&$i
z)wA#-U7LRl>t6NM6&1Sz{TuY)+EzQaG9B_9b&*6%;OfwM$ZoMiV4EGfdsW@J)rlZ!
zvFqV&-4@iXY5yThf`v;`NQ~Bt)PNTkYUJO!%M02Ub&C6{fgZh9r-yoT2uok<Tff|k
zQ6=09z1`#9&jaYW&|g5{@Bxk;e30^|xM9Spf<e=1?sti}w%^L*f&#}baKA^yP2Xk4
zX4VkYw2$){SDuevK1l9|+%Pr{2poRQ{oNui`n)_YC2;QFh_)PDFU!!>*A4@9Elg<>
za#z9LO1nkh-oN3)_ugNN2oW|zvV{6HZ6$(4z>4LAu(Y!g_3Ia_Ef^;b!1Fh|%tei0
zX-k(90KT&qzO8P+;X``MbqhurSRd(xeZ6Lz?_fEzu)v9krqv=!&0KV`jM>Ab8Iy6A
z5jzjT#Qu&}T;Q1z8ynJ03v4~am#ch`f&=9Q;sU3SN3^F9_A5$Zp>Bq_iabzrv>7>J
z{m}+24QSc|1ok8C$P0UptVS+){a7QmpX8+S#|f#8qzFYRWQDEuA3-MHO0TJ8LIIi$
z$4*4FTJYEvbgGar$P&h3&B;cb9^@K(PBV>*{lyef&+rns#!ct60dgFHLFh~PZL(fo
zUX#F{!GgX;7qr)TV0Vi}&m`R#XU{_WvW{h@f}{blk0EJP;N)4phYCjr8;})Nebo>-
zlV)dE4AJ|3SXqhHUs)lL{rNm;HxG)zx--o<`is$1N}AnON#eDnhIrkn3t$`TTDW=p
z&Yhb+-M(pyzjMcDTXsRu*yph3Ej!z(c$dId<Hyn;<Op8DXo#GEADZr|X2&JY(mli~
zPh}OQ;9*M~*Z8T$uh3RnS8OGBZ@Gp(@f8VO5q0xHa^0F0CvXTJjXYx{iz~r)IgaA6
zXQUa&uhPR0tFkRHT%I5*aPkK2MRMhorYw)(^2j6XsIxbq<#w037)^RC1|JXCLvU0@
zVW=Leqv^5dCf&$>O~z?rjYI6+58&po1Nw$NC=IuUS1ZzJY5Lr#5ahOKW7+I8O1jMo
z$j|~v>qkZ#Y>r$xd5^$>I|ljuozm>7F-AUohmkKvGxD|^Bahu<LK`gKHOL2v#mV>Q
zIQfT^JWl4pe6SHs@|N-D*;OfiIoVaQKPaIfOMh}in&?L@wF*IQiE4IopA?*g^W%P-
z^*+Z&)4K%rPHM&ns_25<`8b}gg4U@OIQYOI?EZ^dvHL`KVvR$1q8-UFInhJz%H%`?
zoXc6TJjK4HPdWL-WBx5Ie9kF(9C!v71C3~!>6Upy@AnelR5`t{zzMiAbuW@~vbHNY
zpHPCx0qdrkapoCiMf)Q9x53o<+~DVA{M-gVrEP}q!y3=jEg}6<^<s>r8A9|ErSNw`
zd74rPLCy8$GUl4K(LZHy{G(#uT=>bfvA<S*DJjw!s^(@S*fDQ01Yf9nEG?sX#36nN
z_T;}uZSc)ZGqz)rfVXho#7wHHuY#Gb7c$N>)9e;&eRJ4Mn9fks&$Rck+Pc|0#NJW*
Q#_{>EcjS%3A%qhD1H0{*fdBvi

delta 2443
zcmZ8iZ%kWN6o2=E?7a%Jn57~_cqR(Xrdf6C!akT_;)iZoVnMSsH6fTFc9=B%*vt=O
z2_GuX*>WTh^h0r3RxyyibsG&VT8)1SLDE2+Ww_eFfGRS})QQ7o-hZ#J<tFXDzjM$1
z-Sa!=y!VFAm&bd{gI3&(wf*&#;H)e^>H>)kME)ztPsf<7%ZqT?uKn_mR#!otTma*h
zjhIX~DjUz}$M=vOrRcc43)8(~dK1B%jV#D`l>CZuCBgKk^H=S{dkH4CLj{M&b~%^{
zrldMSbpgl5t1e?mZS0M8nJtIQhc6AdV?D2&Q28p=DL(?aQ!2=EC9^<wpBl4vI}pg-
zYApDU--0}v_7GX3gpm$EpCtbZT|oQub#jiIIzT(ypjhwdXzQtlSfDqHu;YW+<b(x7
zPoN7`z<S_?r{&MN6D<oJHi4aE0>gWgO=ns-km6as(7m$)ODqIQatc33Z>e8!gX8EX
zpFP4a{&%TgR$yscIPfX-#W85vCxfle4X2M=l;C-8?|_l&CL9gLYCp1IoIeLMAupKU
zmmk;Ti}rEH)HzM7N0h^4m|*|$E@ivFm@0jNQ6U#hhu%7YCE87N<i&+LZ_S6?-W=jH
zEjk_Hi+tAok^<*0g|vJ0dZlm@&cds)<{`HkIbdhZj$Ic*T0I2KGFC5Y+FsN@>Ly{l
zG5V6y5#gj%trdO7#mW&Pww)<5E`jdGlOT__ArGTWL@1^2MJ2WsIfam)u_Z-edG2yi
z))3e?2KS%sG8xsU$w4+i(Sz7|RU0Mg4Mw5+s<+lUUMkTkurFFjv0(ytgOgQk=$fIS
z3Hv7at=m_?eW3HTvO=DNmrKdx0;jKVyPoHGywoo%ur$T(HSp$SQ)nW|@?(&Y{De^e
z4qUh6?Q5EL1VPkS6AMf@Fjl8n0t}*9-_(&k*p=iDO!}LznU3%@zkp{iG0Te~C0XaG
z-x-~k_?A0nzb~Z4FtN^)=ZdLvbDYXEOQ<@FT2GqcZhA{u1$NAGyPgv1#x6gB9cj^e
zCgUWy7a}MOQyDw<%!#(EwWUf4Tmt*&DFI28lAq@uTzqnYwZ+gp^euOp3~!d?D15wP
z$Ib;oj?F*PRmY-?17x)Z;bU#EoNk1k)i(I_rWNk5T9ib(m_EEH5|S=7y0svQ2}m*l
z>Y}*g$=uCS0p=x+ZO}UZ4-*i%ReVEFh6+GV7`fE|`JWt$aiBVL2tH}_qBNC(WZ23y
z;p8v6gqEx>VR(g0aIZ26*m@g=M-QTP-rnj8Oip)!ZN?Ar<z|!dvV__?uk84h2LmrZ
z_obFNilAeo1}E3x^oAEwKbTE{+k8K=rs?l4!$cmeli<m;p*$>Y+Ho?c#}@pJtQ0Fh
zDwzTOzTQ9jx=g#L3`tdRJ@X7nx(um5+OV0!#1krZZ1Ip&n=sS*wo-UqvrY}(<#fF6
zzCT&r^Lh3<2;AX&dV59%PUQ<x8zwz!tX9F#n}>1!E)AQ$^WuLA0jL>T?-hk?D-F4Y
z!<MBQ#V@`QJgT7`k@Ic-92Y($OhNX)A_Yp~0Y@(SIUSIZ83z!2Ro32LZ>~)XR$Y(u
zFZWe<3VIBat_L{>-^Iv|TOJ4%Sbj)WCcO*+iU!p(BqMoX1T`oQPAUZ`8uXD3EYlFY
YMy)zZh5JfjPbmzR!Z3q_o(dHGABpst-~a#s

diff --git a/test/blockstructure.py b/test/blockstructure.py
index b0da8c5c..92f5f3b6 100644
--- a/test/blockstructure.py
+++ b/test/blockstructure.py
@@ -45,7 +45,8 @@ sk_pick1 = BlockStructure(gf_struct_sumk=SK.gf_struct_sumk,
                           solver_to_sumk=SK.solver_to_sumk,
                           sumk_to_solver=SK.sumk_to_solver,
                           solver_to_sumk_block=SK.solver_to_sumk_block,
-                          deg_shells=SK.deg_shells)
+                          deg_shells=SK.deg_shells,
+                          corr_to_inequiv=SK.corr_to_inequiv)
 assert sk_pick1 == pick1, 'constructing block structure from SumkDFT properties failed'
 
 cmp(pick1.effective_transformation_sumk,
diff --git a/test/blockstructure.ref.h5 b/test/blockstructure.ref.h5
index c9eb42303698a3aad0d5067b8d916f9d52d8ea7b..d85903cf04181b46dd7763275e790d8b7ab2196d 100644
GIT binary patch
literal 240784
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
H39tVT&h`6x

literal 248384
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


From e9bfb3ed2c126d76174c2a94250c897e51d01713 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Fri, 7 Sep 2018 15:31:41 +0200
Subject: [PATCH 12/35] block_structure: effective_transformation_solver

---
 python/block_structure.py | 22 ++++++++++++++++++++++
 test/blockstructure.py    | 26 ++++++++++++++++++++++++++
 2 files changed, 48 insertions(+)

diff --git a/python/block_structure.py b/python/block_structure.py
index df0cc2e9..c9cb03dd 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -251,6 +251,28 @@ class BlockStructure(object):
                         trans[icrsh][block][iorb, :] = 0.0
         return trans
 
+    @property
+    def effective_transformation_solver(self):
+        eff_trans_sumk = self.effective_transformation_sumk
+
+        ets = []
+        for ish in range(len(self.gf_struct_solver)):
+            icrsh = self.inequiv_to_corr[ish]
+            ets.append(dict())
+            for block in self.gf_struct_solver[ish]:
+                block_sumk = self.solver_to_sumk_block[ish][block]
+                T = eff_trans_sumk[icrsh][block_sumk]
+                ets[ish][block] = np.zeros((len(self.gf_struct_solver[ish][block]),
+                                            len(T)),
+                                           dtype=T.dtype)
+                for i in self.gf_struct_solver[ish][block]:
+                    i_sumk = self.solver_to_sumk[ish][block, i]
+                    assert i_sumk[0] == block_sumk,\
+                        "Wrong block in solver_to_sumk"
+                    i_sumk = i_sumk[1]
+                    ets[ish][block][i, :] = T[i_sumk, :]
+        return ets
+
 
     @classmethod
     def full_structure(cls,gf_struct,corr_to_inequiv):
diff --git a/test/blockstructure.py b/test/blockstructure.py
index 92f5f3b6..482bd570 100644
--- a/test/blockstructure.py
+++ b/test/blockstructure.py
@@ -22,6 +22,14 @@ cmp(original_bs.effective_transformation_sumk,
       'up': np.array([[1., 0., 0.],
                       [0., 1., 0.],
                       [0., 0., 1.]])}])
+cmp(original_bs.effective_transformation_solver,
+    [{'up_0': np.array([[1., 0., 0.],
+                        [0., 1., 0.]]),
+      'up_1': np.array([[0., 0., 1.]]),
+      'down_1': np.array([[0., 0., 1.]]),
+      'down_0': np.array([[1., 0., 0.],
+                          [0., 1., 0.]])}])
+
 
 # check pick_gf_struct_solver
 pick1 = original_bs.copy()
@@ -34,6 +42,10 @@ cmp(pick1.effective_transformation_sumk,
       'up': np.array([[0., 0., 0.],
                       [0., 1., 0.],
                       [0., 0., 1.]])}])
+cmp(pick1.effective_transformation_solver,
+    [{'up_0': np.array([[0., 1., 0.]]),
+      'up_1': np.array([[0., 0., 1.]]),
+      'down_1': np.array([[0., 0., 1.]])}])
 
 # check loading a block_structure from file
 SK.block_structure = SK.load(['block_structure'], 'mod')[0]
@@ -56,6 +68,10 @@ cmp(pick1.effective_transformation_sumk,
       'up': np.array([[0., 0., 0.],
                       [0., 1., 0.],
                       [0., 0., 1.]])}])
+cmp(pick1.effective_transformation_solver,
+    [{'up_0': np.array([[0., 1., 0.]]),
+      'up_1': np.array([[0., 0., 1.]]),
+      'down_1': np.array([[0., 0., 1.]])}])
 
 # check pick_gf_struct_sumk
 pick2 = original_bs.copy()
@@ -68,6 +84,11 @@ cmp(pick2.effective_transformation_sumk,
       'up': np.array([[0., 0., 0.],
                       [0., 1., 0.],
                       [0., 0., 1.]])}])
+cmp(pick2.effective_transformation_solver,
+    [{'up_0': np.array([[0., 1., 0.]]),
+      'up_1': np.array([[0., 0., 1.]]),
+      'down_0': np.array([[1., 0., 0.],
+                          [0., 1., 0.]])}])
 
 pick3 = pick2.copy()
 pick3.transformation = [np.reshape(range(9), (3, 3))]
@@ -78,6 +99,11 @@ cmp(pick3.effective_transformation_sumk,
       'up': np.array([[0, 0, 0],
                       [3, 4, 5],
                       [6, 7, 8]])}])
+cmp(pick3.effective_transformation_solver,
+    [{'up_0': np.array([[3, 4, 5]]),
+      'up_1': np.array([[6, 7, 8]]),
+      'down_0': np.array([[0, 1, 2],
+                          [3, 4, 5]])}])
 
 # check map_gf_struct_solver
 mapping = [{('down_0', 0): ('down', 0),

From ff40e8e0f02055c29887f3391975596cdc3ff830 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Tue, 11 Sep 2018 14:30:17 +0200
Subject: [PATCH 13/35] [doc] block_structure: small fixes

---
 doc/reference/block_structure.rst |  5 ++--
 python/block_structure.py         | 49 +++++++++++++++++++++++++++----
 2 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/doc/reference/block_structure.rst b/doc/reference/block_structure.rst
index ad4004c8..1fe1bebb 100644
--- a/doc/reference/block_structure.rst
+++ b/doc/reference/block_structure.rst
@@ -9,8 +9,8 @@ The block structure can also be written to and read from HDF files.
 .. warning::
 
     Do not write the individual elements of this class to a HDF file,
-    as they belong together and changing one without the other can 
-    result in unexpected results. Always write the BlockStructure 
+    as they belong together and changing one without the other can
+    result in unexpected results. Always write the BlockStructure
     object as a whole.
 
     Writing the sumk_to_solver and solver_to_sumk elements
@@ -19,4 +19,3 @@ The block structure can also be written to and read from HDF files.
 .. autoclass:: triqs_dft_tools.block_structure.BlockStructure
    :members:
    :show-inheritance:
-   
diff --git a/python/block_structure.py b/python/block_structure.py
index c9cb03dd..b0ce1228 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -84,6 +84,9 @@ class BlockStructure(object):
         where the :math:`G_i` are the Green's functions of the block,
         and the functions :math:`C_i` conjugate their argument if the bool
         ``conj_i`` is ``True``.
+    corr_to_inequiv : list
+        a list where, for each correlated shell, the index of the corresponding
+        inequivalent correlated shell is given
     transformation : list of numpy.array or list of dict
         a list with entries for each ``ish`` giving transformation matrices
         that are used on the Green's function in ``sumk`` space when before
@@ -123,7 +126,7 @@ class BlockStructure(object):
         """ The structure of the solver Green's function
 
         This is returned as a
-            list (for each shell)
+        list (for each shell)
         of lists (for each block)
         of tuples (block_name, block_indices).
 
@@ -146,7 +149,7 @@ class BlockStructure(object):
         """ The structure of the sumk Green's function
 
         This is returned as a
-            list (for each shell)
+        list (for each shell)
         of lists (for each block)
         of tuples (block_name, block_indices)
 
@@ -163,7 +166,7 @@ class BlockStructure(object):
         """ The structure of the solver Green's function
 
         This is returned as a
-            list (for each shell)
+        list (for each shell)
         of dictionaries.
 
         That is,
@@ -177,7 +180,7 @@ class BlockStructure(object):
         """ The structure of the sumk Green's function
 
         This is returned as a
-            list (for each shell)
+        list (for each shell)
         of dictionaries.
 
         That is,
@@ -191,6 +194,9 @@ class BlockStructure(object):
 
     @property
     def inequiv_to_corr(self):
+        """ A list mapping an inequivalent correlated shell to a correlated shell
+        """
+
         if self.corr_to_inequiv is None:
             return None
         N_solver = len(np.unique(self.corr_to_inequiv))
@@ -209,6 +215,12 @@ class BlockStructure(object):
 
     @property
     def effective_transformation_sumk(self):
+        """ Return the effective transformation matrix
+
+        A list of dicts, one for every correlated shell. In the dict,
+        there is a transformation matrix (as numpy array) for each
+        block in sumk space, that is used to transform the block.
+        """
         trans = copy.deepcopy(self.transformation)
         if self.gf_struct_sumk is None:
             raise Exception('gf_struct_sumk not set.')
@@ -253,6 +265,31 @@ class BlockStructure(object):
 
     @property
     def effective_transformation_solver(self):
+        """ Return the effective transformation matrix
+
+        A list of dicts, one for every inequivalent correlated shell.
+        In the dict, there is a transformation matrix (as numpy array)
+        for each block in solver space, that is used to transform from
+        the sumk block (see :py:meth:`.solver_to_sumk_block`) to the
+        solver block.
+
+
+        For a solver block ``b`` for inequivalent correlated shell ``ish``,
+        the corresponding block of the solver Green's function is::
+
+            # the effective transformation matrix for the block
+            T = block_structure.effective_transformation_solver[ish][b]
+            # the index of the correlated shell
+            icrsh = block_structure.inequiv_to_corr[ish]
+            # the name of the corresponding sumk block
+            block_sumk = block_structure.solver_to_sumk_block[icrsh][b]
+            # transform the Green's function
+            G_solver[ish][b].from_L_G_R(T, G_sumk[icrsh][block_sumk], T.conjugate().transpose())
+
+        The functionality of that code block is implemented in
+        :py:meth:`.convert_gf` (i.e., you don't need to use this directly).
+        """
+
         eff_trans_sumk = self.effective_transformation_sumk
 
         ets = []
@@ -512,8 +549,8 @@ class BlockStructure(object):
         ----------
         ish : int
             shell index
-            If ``space='solver', the index of the of the inequivalent correlated shell,
-            if ``space='sumk'`, the index of the correlated shell
+            If ``space='solver'``, the index of the of the inequivalent correlated shell,
+            if ``space='sumk'``, the index of the correlated shell
         gf_function : constructor
             function used to construct the Gf objects constituting the
             individual blocks; default: GfImFreq

From 6a889fab8c237abb11a3e11475c67639ce4b5d32 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Thu, 13 Sep 2018 13:57:54 +0200
Subject: [PATCH 14/35] block_structure: convert_gf with transformation

---
 python/block_structure.py | 96 +++++++++++++++++++++++----------------
 test/blockstructure.py    | 24 +++++++++-
 2 files changed, 80 insertions(+), 40 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index b0ce1228..6d700d83 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -29,6 +29,7 @@ from pytriqs.gf import GfImFreq, BlockGf
 from ast import literal_eval
 import pytriqs.utility.mpi as mpi
 from warnings import warn
+from collections import defaultdict
 
 
 class BlockStructure(object):
@@ -209,10 +210,23 @@ class BlockStructure(object):
 
     @inequiv_to_corr.setter
     def inequiv_to_corr(self, value):
+        # a check for backward compatibility
         if value is None:
             return
         assert self.inequiv_to_corr == value, "Trying to set incompatible inequiv_to_corr"
 
+    @property
+    def sumk_to_solver_block(self):
+        if self.corr_to_inequiv is None:
+            return None
+        ret = []
+        for icrsh, ish in enumerate(self.corr_to_inequiv):
+            d = defaultdict(list)
+            for block_solver, block_sumk in self.solver_to_sumk_block[ish].iteritems():
+                d[block_sumk].append(block_solver)
+            ret.append(d)
+        return ret
+
     @property
     def effective_transformation_sumk(self):
         """ Return the effective transformation matrix
@@ -671,8 +685,6 @@ class BlockStructure(object):
             options passed to the constructor for the new Gf
         """
 
-        # TODO: use effective_transformation here
-
         if ish is not None:
             warn(
                 'The parameter ish in convert_gf is deprecated. Use ish_from and ish_to instead.')
@@ -691,55 +703,61 @@ class BlockStructure(object):
             G_struct = self
 
         if space_from == 'solver':
-            gf_struct_in = G_struct.gf_struct_solver[ish_from]
+            gf_struct_from = G_struct.gf_struct_solver[ish_from]
+            eff_trans_from = G_struct.effective_transformation_solver[ish_from]
+            block_mapping_from = G_struct.sumk_to_solver_block[ish_from]
         elif space_from == 'sumk':
-            gf_struct_in = G_struct.gf_struct_sumk_dict[ish_from]
+            gf_struct_from = G_struct.gf_struct_sumk_dict[ish_from]
+            eff_trans_from = {block: np.eye(len(indices))
+                              for block, indices in G_struct.gf_struct_sumk[ish_from]}
+            block_mapping_from = {b: [b] for b in gf_struct_from}
         else:
             raise Exception(
                 "Argument space_from has to be either 'solver' or 'sumk'.")
 
+        if space_to == 'solver':
+            gf_struct_to = self.gf_struct_solver[ish_to]
+            eff_trans_to = self.effective_transformation_solver[ish_to]
+            block_mapping_to = self.solver_to_sumk_block[ish_to]
+        elif space_to == 'sumk':
+            gf_struct_to = self.gf_struct_sumk_dict[ish_to]
+            eff_trans_to = {block: np.eye(len(indices))
+                            for block, indices in self.gf_struct_sumk_list[ish_to]}
+            block_mapping_to = {b: b for b in gf_struct_to}
+        else:
+            raise Exception(
+                "Argument space_to has to be either 'solver' or 'sumk'.")
+
         # create a Green's function to hold the result
         if G_out is None:
             G_out = self.create_gf(ish=ish_to, space=space_to, **kwargs)
         else:
             self.check_gf(G_out, ish=ish_to, space=space_to)
 
-        for block in gf_struct_in.keys():
-            for i1 in gf_struct_in[block]:
-                for i2 in gf_struct_in[block]:
-                    if space_from == 'sumk':
-                        i1_sumk = (block, i1)
-                        i2_sumk = (block, i2)
-                    elif space_from == 'solver':
-                        i1_sumk = G_struct.solver_to_sumk[ish_from][(block, i1)]
-                        i2_sumk = G_struct.solver_to_sumk[ish_from][(block, i2)]
+        for block_to in gf_struct_to.keys():
+            block_intermediate = block_mapping_to[block_to]
+            block_from = block_mapping_from[block_intermediate]
+            T_to = eff_trans_to[block_to]
+            g_help = G_out[block_to].copy()
+            for block in block_from:
+                T_from = eff_trans_from[block]
+                g_help.from_L_G_R(np.dot(T_to, np.conjugate(np.transpose(T_from))),
+                                  G[block],
+                                  np.dot(T_from, np.conjugate(np.transpose(T_to))))
+                G_out[block_to] << G_out[block_to] + g_help
 
-                    if space_to == 'sumk':
-                        i1_sol = i1_sumk
-                        i2_sol = i2_sumk
-                    elif space_to == 'solver':
-                        i1_sol = self.sumk_to_solver[ish_to][i1_sumk]
-                        i2_sol = self.sumk_to_solver[ish_to][i2_sumk]
-                    else:
-                        raise Exception(
-                            "Argument space_to has to be either 'solver' or 'sumk'.")
-
-                    if i1_sol[0] is None or i2_sol[0] is None:
-                        if show_warnings:
-                            if mpi.is_master_node():
-                                warn(('Element {},{} of block {} of G is not present ' +
-                                      'in the new structure').format(i1, i2, block))
-                        continue
-                    if i1_sol[0] != i2_sol[0]:
-                        if (show_warnings and
-                                np.max(np.abs(G[block][i1, i2].data)) > warning_threshold):
-                            if mpi.is_master_node():
-                                warn(('Element {},{} of block {} of G is approximated ' +
-                                      'to zero to match the new structure. Max abs value: {}').format(
-                                    i1, i2, block, np.max(np.abs(G[block][i1, i2].data))))
-                        continue
-                    G_out[i1_sol[0]][i1_sol[1], i2_sol[1]] = \
-                        G[block][i1, i2]
+        if show_warnings:
+            # we back-transform it
+            G_back = G_struct.convert_gf(G_out, self, ish_from=ish_to,
+                                         ish_to=ish_from,
+                                         show_warnings=False,  # else we get an endless loop
+                                         space_from=space_to, space_to=space_from, **kwargs)
+            for name, gf in G_back:
+                maxdiff = np.max(np.abs(G_back[name].data - G[name].data),
+                                 axis=0)
+                if np.any(maxdiff > warning_threshold):
+                    warn('Block {} maximum difference:\n'.format(name)
+                         + str(maxdiff))
         return G_out
 
     def approximate_as_diagonal(self):
diff --git a/test/blockstructure.py b/test/blockstructure.py
index 482bd570..27ff65ab 100644
--- a/test/blockstructure.py
+++ b/test/blockstructure.py
@@ -2,6 +2,7 @@ from triqs_dft_tools.sumk_dft import *
 from pytriqs.utility.h5diff import h5diff
 from pytriqs.gf import *
 from pytriqs.utility.comparison_tests import assert_block_gfs_are_close
+from scipy.linalg import expm
 from triqs_dft_tools.block_structure import BlockStructure
 import numpy as np
 from pytriqs.utility.h5diff import compare, failures
@@ -127,7 +128,14 @@ offd = original_bs.copy()
 offd.approximate_as_diagonal()
 
 # check map_gf_struct_solver
-G2 = map1.convert_gf(G1, original_bs, beta=40, n_points=3, show_warnings=False)
+import warnings
+with warnings.catch_warnings(record=True) as w:
+    G2 = map1.convert_gf(G1, original_bs, beta=40, n_points=3,
+                         show_warnings=True)
+    assert len(w) == 1
+    assert issubclass(w[-1].category, UserWarning)
+    assert "Block up_1 maximum difference" in str(w[-1].message)
+
 
 # check full_structure
 full = BlockStructure.full_structure(
@@ -144,6 +152,20 @@ G3 = original_bs.convert_gf(G_sumk,
                             n_points=3)
 assert_block_gfs_are_close(G1, G3)
 
+# check convert_gf with transformation
+# np.random.seed(894892309)
+H = np.random.rand(3, 3) + 1.0j * np.random.rand(3, 3)
+H = H + H.conjugate().transpose()
+T = expm(1.0j * H)
+G_T = G_sumk.copy()
+for block, gf in G_T:
+    gf.from_L_G_R(T.conjugate().transpose(), gf, T)
+transformed_bs = original_bs.copy()
+transformed_bs.transformation = [T]
+G_bT = transformed_bs.convert_gf(G_T, None, space_from='sumk',
+                                 beta=40, n_points=3)
+assert_block_gfs_are_close(G1, G_bT)
+
 assert original_bs.gf_struct_sumk_list ==\
     [[('up', [0, 1, 2]), ('down', [0, 1, 2])]]
 assert original_bs.gf_struct_solver_dict ==\

From 8130d6b9fc907f9d94108ef89158ca69cc5502b6 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Thu, 13 Sep 2018 16:27:12 +0200
Subject: [PATCH 15/35] block_structure: pick_gf_struct_sumk with
 transformation

plus little bug fixes
---
 python/block_structure.py | 77 ++++++++++++++++++++++++++-------------
 python/sumk_dft.py        |  2 +-
 test/blockstructure.py    | 16 ++++++++
 3 files changed, 68 insertions(+), 27 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index 6d700d83..79812cb0 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -217,10 +217,10 @@ class BlockStructure(object):
 
     @property
     def sumk_to_solver_block(self):
-        if self.corr_to_inequiv is None:
+        if self.inequiv_to_corr is None:
             return None
         ret = []
-        for icrsh, ish in enumerate(self.corr_to_inequiv):
+        for ish, icrsh in enumerate(self.inequiv_to_corr):
             d = defaultdict(list)
             for block_solver, block_sumk in self.solver_to_sumk_block[ish].iteritems():
                 d[block_sumk].append(block_solver)
@@ -252,6 +252,7 @@ class BlockStructure(object):
             "give one transformation per correlated shell"
 
         for icrsh in range(len(trans)):
+            ish = self.corr_to_inequiv[icrsh]
             if trans[icrsh] is None:
                 trans[icrsh] = {block: np.eye(len(indices))
                                 for block, indices in self.gf_struct_sumk[icrsh]}
@@ -273,7 +274,7 @@ class BlockStructure(object):
                 # zero out all the lines of the transformation that are
                 # not included in gf_struct_solver
                 for iorb, norb in enumerate(self.gf_struct_sumk_dict[icrsh][block]):
-                    if self.sumk_to_solver[icrsh][(block, norb)][0] is None:
+                    if self.sumk_to_solver[ish][(block, norb)][0] is None:
                         trans[icrsh][block][iorb, :] = 0.0
         return trans
 
@@ -381,7 +382,7 @@ class BlockStructure(object):
                 deg_shells = [[] for ish in range(len(gf_struct))],
                 corr_to_inequiv = corr_to_inequiv)
 
-    def pick_gf_struct_solver(self,new_gf_struct):
+    def pick_gf_struct_solver(self, new_gf_struct):
         """ Pick selected orbitals within blocks.
 
         This throws away parts of the Green's function that (for some
@@ -419,28 +420,28 @@ class BlockStructure(object):
             gf_struct = new_gf_struct[ish]
 
             # create new solver_to_sumk
-            so2su={}
+            so2su = {}
             so2su_block = {}
-            for blk,idxs in gf_struct.items():
+            for blk, idxs in gf_struct.items():
                 for i in range(len(idxs)):
-                    so2su[(blk,i)]=self.solver_to_sumk[ish][(blk,idxs[i])]
-                    so2su_block[blk]=so2su[(blk,i)][0]
+                    so2su[(blk, i)] = self.solver_to_sumk[ish][(blk, idxs[i])]
+                    so2su_block[blk] = so2su[(blk, i)][0]
             self.solver_to_sumk[ish] = so2su
             self.solver_to_sumk_block[ish] = so2su_block
             # create new sumk_to_solver
-            for k,v in self.sumk_to_solver[ish].items():
-                blk,ind=v
+            for k, v in self.sumk_to_solver[ish].items():
+                blk, ind = v
                 if blk in gf_struct and ind in gf_struct[blk]:
                     new_ind = gf_struct[blk].index(ind)
-                    self.sumk_to_solver[ish][k]=(blk,new_ind)
+                    self.sumk_to_solver[ish][k] = (blk, new_ind)
                 else:
-                    self.sumk_to_solver[ish][k]=(None,None)
+                    self.sumk_to_solver[ish][k] = (None, None)
             # reindexing gf_struct so that it starts with 0
             for k in gf_struct:
-                gf_struct[k]=range(len(gf_struct[k]))
-            self.gf_struct_solver[ish]=gf_struct
+                gf_struct[k] = range(len(gf_struct[k]))
+            self.gf_struct_solver[ish] = gf_struct
 
-    def pick_gf_struct_sumk(self,new_gf_struct):
+    def pick_gf_struct_sumk(self, new_gf_struct):
         """ Pick selected orbitals within blocks.
 
         This throws away parts of the Green's function that (for some
@@ -475,24 +476,46 @@ class BlockStructure(object):
             However, the indices are not according to the solver Gf
             but the sumk Gf.
         """
+        eff_trans_sumk = self.effective_transformation_sumk
 
-        # TODO: when there is a transformation matrix, this should
-        #       first zero out the corresponding rows of (a copy of) T and then
-        #       pick_gf_struct_solver all lines of (the copy of) T that have at least
-        #       one non-zero entry
+        assert len(eff_trans_sumk) == len(new_gf_struct),\
+            "new_gf_struct has the wrong length"
+
+        new_gf_struct_transformed = copy.deepcopy(new_gf_struct)
+
+        # when there is a transformation matrix, this first zeroes out
+        # the corresponding rows of (a copy of) T and then applies
+        # pick_gf_struct_solver for all lines of  T that have at least
+        # one non-zero entry
+
+        for icrsh in range(len(new_gf_struct)):
+            for block, indices in self.gf_struct_sumk[icrsh]:
+                if not block in new_gf_struct[icrsh]:
+                    del new_gf_struct_transformed[block]
+                    continue
+                T = eff_trans_sumk[icrsh][block]
+                for index in indices:
+                    if not index in new_gf_struct[icrsh][block]:
+                        T[:, index] = 0.0
+                new_indices = []
+                for index in indices:
+                    if np.any(np.abs(T[index, :]) > 1.e-15):
+                        new_indices.append(index)
+                new_gf_struct_transformed[icrsh][block] = new_indices
 
         gfs = []
         # construct gfs, which is the equivalent of new_gf_struct
         # but according to the solver Gf, by using the sumk_to_solver
         # mapping
-        for ish in range(len(new_gf_struct)):
+        for icrsh in range(len(new_gf_struct_transformed)):
+            ish = self.corr_to_inequiv[icrsh]
             gfs.append({})
-            for block in new_gf_struct[ish].keys():
-                for ind in new_gf_struct[ish][block]:
-                    ind_sol = self.sumk_to_solver[ish][(block,ind)]
-                    if not ind_sol[0] in gfs[ish]:
-                        gfs[ish][ind_sol[0]]=[]
-                    gfs[ish][ind_sol[0]].append(ind_sol[1])
+            for block in new_gf_struct_transformed[icrsh].keys():
+                for ind in new_gf_struct_transformed[icrsh][block]:
+                    ind_sol = self.sumk_to_solver[ish][(block, ind)]
+                    if not ind_sol[0] in gfs[icrsh]:
+                        gfs[icrsh][ind_sol[0]] = []
+                    gfs[icrsh][ind_sol[0]].append(ind_sol[1])
         self.pick_gf_struct_solver(gfs)
 
     def map_gf_struct_solver(self, mapping):
@@ -730,6 +753,8 @@ class BlockStructure(object):
 
         # create a Green's function to hold the result
         if G_out is None:
+            if not 'mesh' in kwargs and not 'beta' in kwargs:
+                kwargs['mesh'] = G.mesh
             G_out = self.create_gf(ish=ish_to, space=space_to, **kwargs)
         else:
             self.check_gf(G_out, ish=ish_to, space=space_to)
diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 854ee564..1ae7febb 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -1080,7 +1080,7 @@ class SumkDFT(object):
         full_structure = BlockStructure.full_structure(
             [{sp:range(self.corr_shells[self.inequiv_to_corr[ish]]['dim'])
                 for sp in self.spin_block_names[self.corr_shells[self.inequiv_to_corr[ish]]['SO']]}
-                for ish in range(self.n_inequiv_shells)],None)
+                for ish in range(self.n_inequiv_shells)],self.corr_to_inequiv)
         G_transformed = [
             self.block_structure.convert_gf(G[ish],
                 full_structure, ish, mesh=G[ish].mesh.copy(), show_warnings=threshold,
diff --git a/test/blockstructure.py b/test/blockstructure.py
index 27ff65ab..f7a581be 100644
--- a/test/blockstructure.py
+++ b/test/blockstructure.py
@@ -106,6 +106,22 @@ cmp(pick3.effective_transformation_solver,
       'down_0': np.array([[0, 1, 2],
                           [3, 4, 5]])}])
 
+pick4 = original_bs.copy()
+pick4.transformation = [np.array([[0, 1, 0], [1, 0, 0], [0, 0, 1]])]
+pick4.pick_gf_struct_sumk([{'up': [1, 2], 'down': [0, 1]}])
+cmp(pick2.gf_struct_sumk, pick4.gf_struct_sumk)
+cmp(pick2.gf_struct_solver, pick4.gf_struct_solver)
+assert pick4.sumk_to_solver == [{('up', 0): ('up_0', 0),
+                                 ('up', 1): (None, None),
+                                 ('up', 2): ('up_1', 0),
+                                 ('down', 2): (None, None),
+                                 ('down', 1): ('down_0', 1),
+                                 ('down', 0): ('down_0', 0)}]
+assert pick4.solver_to_sumk == [{('up_1', 0): ('up', 2),
+                                 ('up_0', 0): ('up', 0),
+                                 ('down_0', 0): ('down', 0),
+                                 ('down_0', 1): ('down', 1)}]
+
 # check map_gf_struct_solver
 mapping = [{('down_0', 0): ('down', 0),
             ('down_0', 1): ('down', 2),

From f0b1599379847d5778aeaa18ffafb2ebc86d7c00 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Thu, 13 Sep 2018 17:11:30 +0200
Subject: [PATCH 16/35] SumkDFT: transform in calc_dc

---
 python/sumk_dft.py | 35 ++++++++++++++++++++---------------
 1 file changed, 20 insertions(+), 15 deletions(-)

diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 1ae7febb..03e4cbbb 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -36,9 +36,6 @@ from warnings import warn
 from scipy import compress
 from scipy.optimize import minimize
 
-# TODO: check where the transformation in block_structure has to enter
-#       - DC
-
 
 class SumkDFT(object):
     """This class provides a general SumK method for combining ab-initio code and pytriqs."""
@@ -1526,21 +1523,22 @@ class SumkDFT(object):
         dc_imp : gf_struct_sumk like
                  Double-counting self-energy term.
         dc_energ : list of floats
-                   Double-counting energy corrections for each correlated shell. 
+                   Double-counting energy corrections for each correlated shell.
 
         """
 
         self.dc_imp = dc_imp
         self.dc_energ = dc_energ
 
-    def calc_dc(self, dens_mat, orb=0, U_interact=None, J_hund=None, use_dc_formula=0, use_dc_value=None):
+    def calc_dc(self, dens_mat, orb=0, U_interact=None, J_hund=None,
+                use_dc_formula=0, use_dc_value=None, transform=True):
         r"""
-        Calculates and sets the double counting corrections.
+        Calculate and set the double counting corrections.
 
         If 'use_dc_value' is provided the double-counting term is uniformly initialized
         with this constant and 'U_interact' and 'J_hund' are ignored.
 
-        If 'use_dc_value' is None the correction is evaluated according to 
+        If 'use_dc_value' is None the correction is evaluated according to
         one of the following formulae:
 
         * use_dc_formula = 0: fully-localised limit (FLL)
@@ -1558,19 +1556,21 @@ class SumkDFT(object):
         Parameters
         ----------
         dens_mat : gf_struct_solver like
-                   Density matrix for the specified correlated shell.
+            Density matrix for the specified correlated shell.
         orb : int, optional
-              Index of an inequivalent shell.
+            Index of an inequivalent shell.
         U_interact : float, optional
-                     Value of interaction parameter `U`.
+            Value of interaction parameter `U`.
         J_hund : float, optional
-                 Value of interaction parameter `J`.
+            Value of interaction parameter `J`.
         use_dc_formula : int, optional
-                         Type of double-counting correction (see description).
+            Type of double-counting correction (see description).
         use_dc_value : float, optional
-                       Value of the double-counting correction. If specified
-                       `U_interact`, `J_hund` and `use_dc_formula` are ignored.
-
+            Value of the double-counting correction. If specified
+            `U_interact`, `J_hund` and `use_dc_formula` are ignored.
+        transform : bool
+            whether or not to use the transformation in block_structure
+            to transform the dc
         """
 
         for icrsh in range(self.n_corr_shells):
@@ -1651,6 +1651,11 @@ class SumkDFT(object):
                 mpi.report(
                     "DC for shell %(icrsh)i = %(use_dc_value)f" % locals())
                 mpi.report("DC energy = %s" % self.dc_energ[icrsh])
+            if transform:
+                for sp in spn:
+                    T = self.block_structure.effective_transformation_sumk[icrsh][sp]
+                    self.dc_imp[icrsh][sp] = numpy.dot(T.conjugate().transpose(),
+                            numpy.dot(self.dc_imp[icrsh][sp], T))
 
     def add_dc(self, iw_or_w="iw"):
         r"""

From 8e4c923d21a50f6598ffd2bf3a7dfbb0dafd3002 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Mon, 17 Sep 2018 13:32:50 +0200
Subject: [PATCH 17/35] [block_structure] create_matrix etc.

---
 python/block_structure.py | 195 ++++++++++++++++++++++++++++++++------
 python/sumk_dft.py        |   5 +
 test/blockstructure.py    |  16 ++++
 3 files changed, 189 insertions(+), 27 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index 79812cb0..f7f3317c 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -598,6 +598,36 @@ class BlockStructure(object):
             blocks
         """
 
+        return self._create_gf_or_matrix(ish, gf_function, BlockGf, space, **kwargs)
+
+    def create_matrix(self, ish=0, space='solver', dtype=np.complex_):
+        """ Create a zero matrix having the correct structure.
+
+        For ``space='solver'``, the structure is according to
+        ``gf_struct_solver``, else according to ``gf_struct_sumk``.
+
+        Parameters
+        ----------
+        ish : int
+            shell index
+            If ``space='solver'``, the index of the of the inequivalent correlated shell,
+            if ``space='sumk'``, the index of the correlated shell
+        space : 'solver' or 'sumk'
+            which space the structure should correspond to
+        """
+
+        def gf_function(indices):
+            return np.zeros((len(indices), len(indices)), dtype=dtype)
+
+        def block_function(name_list, block_list):
+            d = dict()
+            for i in range(len(name_list)):
+                d[name_list[i]] = block_list[i]
+            return d
+
+        return self._create_gf_or_matrix(ish, gf_function, block_function, space)
+
+    def _create_gf_or_matrix(self, ish=0, gf_function=GfImFreq, block_function=BlockGf, space='solver', **kwargs):
         if space == 'solver':
             gf_struct = self.gf_struct_solver
         elif space == 'sumk':
@@ -611,7 +641,7 @@ class BlockStructure(object):
         for n in names:
             G = gf_function(indices=gf_struct[ish][n], **kwargs)
             blocks.append(G)
-        G = BlockGf(name_list=names, block_list=blocks)
+        G = block_function(name_list=names, block_list=blocks)
         return G
 
     def check_gf(self, G, ish=None, space='solver'):
@@ -636,6 +666,34 @@ class BlockStructure(object):
             which space the structure should correspond to
         """
 
+        return self._check_gf_or_matrix(G, ish, space)
+
+    def check_matrix(self, G, ish=None, space='solver'):
+        """ check whether the matrix G has the right structure
+
+        This throws an error if the structure of G is not the same
+        as ``gf_struct_solver`` (for ``space=solver``) or
+        ``gf_struct_sumk`` (for ``space=sumk``)..
+
+        Parameters
+        ----------
+        G : dict of matrices or list of dict of matrices
+            matrix to check
+            if it is a list, there should be as many entries as there
+            are shells, and the check is performed for all shells (unless
+            ish is given).
+        ish : int
+            shell index
+            default: 0 if G is just one matrix is given,
+            check all if list of dicts is given
+        space : 'solver' or 'sumk'
+            which space the structure should correspond to
+        """
+
+        return self._check_gf_or_matrix(G, ish, space)
+
+    def _check_gf_or_matrix(self, G, ish=None, space='solver'):
+
         if space == 'solver':
             gf_struct = self.gf_struct_solver
         elif space == 'sumk':
@@ -658,16 +716,28 @@ class BlockStructure(object):
         if ish is None:
             ish = 0
 
-        for block in gf_struct[ish]:
-            assert block in G.indices,\
-                "block " + block + " not in G (shell {})".format(ish)
-        for block, gf in G:
-            assert block in gf_struct[ish],\
-                "block " + block + " not in struct (shell {})".format(ish)
-            assert list(gf.indices) == 2 * [map(str, gf_struct[ish][block])],\
-                "block " + block + " has wrong indices (shell {})".format(ish)
+        if isinstance(G, BlockGf):
+            for block in gf_struct[ish]:
+                assert block in G.indices,\
+                    "block " + block + " not in G (shell {})".format(ish)
+            for block, gf in G:
+                assert block in gf_struct[ish],\
+                    "block " + block + " not in struct (shell {})".format(ish)
+                assert list(gf.indices) == 2 * [map(str, gf_struct[ish][block])],\
+                    "block " + block + \
+                    " has wrong indices (shell {})".format(ish)
+        else:
+            for block in gf_struct[ish]:
+                assert block in G,\
+                    "block " + block + " not in G (shell {})".format(ish)
+            for block, gf in G.iteritems():
+                assert block in gf_struct[ish],\
+                    "block " + block + " not in struct (shell {})".format(ish)
+                assert range(len(gf)) == 2 * [map(str, gf_struct[ish][block])],\
+                    "block " + block + \
+                    " has wrong indices (shell {})".format(ish)
 
-    def convert_gf(self, G, G_struct, ish_from=0, ish_to=None, show_warnings=True,
+    def convert_gf(self, G, G_struct=None, ish_from=0, ish_to=None, show_warnings=True,
                    G_out=None, space_from='solver', space_to='solver', ish=None, **kwargs):
         """ Convert BlockGf from its structure to this structure.
 
@@ -714,6 +784,56 @@ class BlockStructure(object):
             ish_from = ish
             ish_to = ish
 
+        return self._convert_gf_or_matrix(G, G_struct, ish_from, ish_to,
+                                          show_warnings, G_out, space_from, space_to, **kwargs)
+
+    def convert_matrix(self, G, G_struct=None, ish_from=0, ish_to=None, show_warnings=True,
+                       G_out=None, space_from='solver', space_to='solver'):
+        """ Convert matrix from its structure to this structure.
+
+        .. warning::
+
+            Elements that are zero in the new structure due to
+            the new block structure will be just ignored, thus
+            approximated to zero.
+
+        Parameters
+        ----------
+        G : dict of numpy array
+            the matrix that should be converted
+        G_struct : BlockStructure or str
+            the structure of that G or None (then, this structure
+            is used)
+        ish_from : int
+            shell index of the input structure
+        ish_to : int
+            shell index of the output structure; if None (the default),
+            it is the same as ish_from
+        show_warnings : bool or float
+            whether to show warnings when elements of the Green's
+            function get thrown away
+            if float, set the threshold for the magnitude of an element
+            about to be thrown away to trigger a warning
+            (default: 1.e-10)
+        G_out : dict of numpy array
+            the output numpy array (if not given, a new one is
+            created)
+        space_from : 'solver' or 'sumk'
+            whether the matrix ``G`` corresponds to the
+            solver or sumk structure of ``G_struct``
+        space_to : 'solver' or 'sumk'
+            whether the output matrix should be according to
+            the solver of sumk structure of this structure
+        **kwargs :
+            options passed to the constructor for the new Gf
+        """
+
+        return self._convert_gf_or_matrix(G, G_struct, ish_from, ish_to,
+                                          show_warnings, G_out, space_from, space_to)
+
+    def _convert_gf_or_matrix(self, G, G_struct=None, ish_from=0, ish_to=None, show_warnings=True,
+                              G_out=None, space_from='solver', space_to='solver', **kwargs):
+
         if ish_to is None:
             ish_to = ish_from
 
@@ -751,35 +871,56 @@ class BlockStructure(object):
             raise Exception(
                 "Argument space_to has to be either 'solver' or 'sumk'.")
 
-        # create a Green's function to hold the result
-        if G_out is None:
-            if not 'mesh' in kwargs and not 'beta' in kwargs:
-                kwargs['mesh'] = G.mesh
-            G_out = self.create_gf(ish=ish_to, space=space_to, **kwargs)
+        if isinstance(G, BlockGf):
+            # create a Green's function to hold the result
+            if G_out is None:
+                if not 'mesh' in kwargs and not 'beta' in kwargs:
+                    kwargs['mesh'] = G.mesh
+                G_out = self.create_gf(ish=ish_to, space=space_to, **kwargs)
+            else:
+                self.check_gf(G_out, ish=ish_to, space=space_to)
+        elif isinstance(G, dict):
+            if G_out is None:
+                G_out = self.create_matrix(ish=ish_to, space=space_to)
+            else:
+                self.check_matrix(G_out, ish=ish_to, space=space_to)
         else:
-            self.check_gf(G_out, ish=ish_to, space=space_to)
+            raise Exception('G is neither BlockGf nor dict.')
 
         for block_to in gf_struct_to.keys():
+            if isinstance(G, BlockGf):
+                G_out[block_to].zero()
+            else:
+                G_out[block_to][:] = 0.0
             block_intermediate = block_mapping_to[block_to]
             block_from = block_mapping_from[block_intermediate]
             T_to = eff_trans_to[block_to]
             g_help = G_out[block_to].copy()
             for block in block_from:
                 T_from = eff_trans_from[block]
-                g_help.from_L_G_R(np.dot(T_to, np.conjugate(np.transpose(T_from))),
-                                  G[block],
-                                  np.dot(T_from, np.conjugate(np.transpose(T_to))))
-                G_out[block_to] << G_out[block_to] + g_help
+                if isinstance(G, BlockGf):
+                    g_help.from_L_G_R(np.dot(T_to, np.conjugate(np.transpose(T_from))),
+                                      G[block],
+                                      np.dot(T_from, np.conjugate(np.transpose(T_to))))
+                    G_out[block_to] << G_out[block_to] + g_help
+                else:
+                    g_help = np.dot(np.dot(T_to, np.conjugate(np.transpose(T_from))),
+                                    np.dot(G[block],
+                                           np.dot(T_from, np.conjugate(np.transpose(T_to)))))
+                    G_out[block_to] += g_help
 
         if show_warnings:
             # we back-transform it
-            G_back = G_struct.convert_gf(G_out, self, ish_from=ish_to,
-                                         ish_to=ish_from,
-                                         show_warnings=False,  # else we get an endless loop
-                                         space_from=space_to, space_to=space_from, **kwargs)
-            for name, gf in G_back:
-                maxdiff = np.max(np.abs(G_back[name].data - G[name].data),
-                                 axis=0)
+            G_back = G_struct._convert_gf_or_matrix(G_out, self, ish_from=ish_to,
+                                                    ish_to=ish_from,
+                                                    show_warnings=False,  # else we get an endless loop
+                                                    space_from=space_to, space_to=space_from, **kwargs)
+            for name, gf in (G_back if isinstance(G, BlockGf) else G_back.iteritems()):
+                if isinstance(G, BlockGf):
+                    maxdiff = np.max(np.abs(G_back[name].data - G[name].data),
+                                     axis=0)
+                else:
+                    maxdiff = G_back[name] - G[name]
                 if np.any(maxdiff > warning_threshold):
                     warn('Block {} maximum difference:\n'.format(name)
                          + str(maxdiff))
diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 03e4cbbb..4fb912a8 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -776,6 +776,9 @@ class SumkDFT(object):
         -------
         G_out
         """
+
+        assert isinstance(G_loc, list), "G_loc must be a list (with elements for each correlated shell)"
+
         if G_out is None:
             G_out = [self.block_structure.create_gf(ish=ish, mesh=G_loc[self.inequiv_to_corr[ish]].mesh)
                      for ish in range(self.n_inequiv_shells)]
@@ -1009,6 +1012,8 @@ class SumkDFT(object):
             the Green's function transformed into the new block structure
         """
 
+        assert isinstance(G, list), "G must be a list (with elements for each correlated shell)"
+
         gf = self._get_hermitian_quantity_from_gf(G)
 
         # initialize the variables
diff --git a/test/blockstructure.py b/test/blockstructure.py
index f7a581be..30aec6f6 100644
--- a/test/blockstructure.py
+++ b/test/blockstructure.py
@@ -31,6 +31,15 @@ cmp(original_bs.effective_transformation_solver,
       'down_0': np.array([[1., 0., 0.],
                           [0., 1., 0.]])}])
 
+created_matrix = original_bs.create_matrix()
+cmp(created_matrix,
+    {'up_0': np.array([[0. + 0.j, 0. + 0.j],
+                       [0. + 0.j, 0. + 0.j]]),
+     'up_1': np.array([[0. + 0.j]]),
+     'down_1': np.array([[0. + 0.j]]),
+     'down_0': np.array([[0. + 0.j, 0. + 0.j],
+                         [0. + 0.j, 0. + 0.j]])})
+
 
 # check pick_gf_struct_solver
 pick1 = original_bs.copy()
@@ -152,6 +161,13 @@ with warnings.catch_warnings(record=True) as w:
     assert issubclass(w[-1].category, UserWarning)
     assert "Block up_1 maximum difference" in str(w[-1].message)
 
+m2 = map1.convert_matrix(created_matrix, original_bs, show_warnings=True)
+cmp(m2,
+    {'down': np.array([[0. + 0.j, 0. + 0.j, 0. + 0.j],
+                       [0. + 0.j, 0. + 0.j, 0. + 0.j],
+                       [0. + 0.j, 0. + 0.j, 0. + 0.j]]),
+     'up_0': np.array([[0. + 0.j]]),
+     'down_1': np.array([[0. + 0.j]])})
 
 # check full_structure
 full = BlockStructure.full_structure(

From 1705e5268f2915592cdf15a32ed09ec4abec6d38 Mon Sep 17 00:00:00 2001
From: "Gernot J. Kraberger" <16017581+gkraberger@users.noreply.github.com>
Date: Thu, 7 Feb 2019 14:09:18 +0100
Subject: [PATCH 18/35] blockstructure: adapt deg_shells in pick

---
 python/block_structure.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/python/block_structure.py b/python/block_structure.py
index f7f3317c..fd34c48a 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -436,6 +436,24 @@ class BlockStructure(object):
                     self.sumk_to_solver[ish][k] = (blk, new_ind)
                 else:
                     self.sumk_to_solver[ish][k] = (None, None)
+            # adapt deg_shells
+            if self.deg_shells is not None:
+                for degsh in self.deg_shells[ish]:
+                    for key in degsh.keys():
+                        if isinstance(degsh, dict):
+                            if not key in gf_struct:
+                                del degsh[key]
+                                continue
+                            if gf_struct[key] != self.gf_struct_solver[ish][key]:
+                                v, C = degsh[key]
+                                degsh[key][0] = \
+                                    v[gf_struct[key], :][:, gf_struct[key]]
+                                warn(
+                                    'Removing shells from degenerate shell {}. Cannot guarantee that they continue to be equivalent.')
+                        else:
+                            if not key in gf_struct:
+                                degsh.remove(key)
+                                continue
             # reindexing gf_struct so that it starts with 0
             for k in gf_struct:
                 gf_struct[k] = range(len(gf_struct[k]))

From 51275c772d5411324e47ae963802d569a5fbfafa Mon Sep 17 00:00:00 2001
From: Hermann Ulrich Schnait <schnai_h@itp.tugraz.at>
Date: Tue, 4 Jun 2019 16:48:23 +0200
Subject: [PATCH 19/35] Bugfix in Blockstructure Test

---
 python/block_structure.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index fd34c48a..7563c224 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -439,8 +439,8 @@ class BlockStructure(object):
             # adapt deg_shells
             if self.deg_shells is not None:
                 for degsh in self.deg_shells[ish]:
-                    for key in degsh.keys():
-                        if isinstance(degsh, dict):
+                    if isinstance(degsh, dict):
+                        for key in degsh.keys():
                             if not key in gf_struct:
                                 del degsh[key]
                                 continue
@@ -450,7 +450,8 @@ class BlockStructure(object):
                                     v[gf_struct[key], :][:, gf_struct[key]]
                                 warn(
                                     'Removing shells from degenerate shell {}. Cannot guarantee that they continue to be equivalent.')
-                        else:
+                    else: # degshell is list
+                        for key in degsh:
                             if not key in gf_struct:
                                 degsh.remove(key)
                                 continue

From 743ff09cac3cc19b2dd59f22447fb21c81c8ad71 Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Wed, 5 Jun 2019 09:24:53 +0200
Subject: [PATCH 20/35] Changed 'orb' parameter to 'ish' for consistency

---
 python/sumk_dft.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 4fb912a8..d3f5ebea 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -1692,7 +1692,7 @@ class SumkDFT(object):
 
         return sigma_minus_dc
 
-    def symm_deg_gf(self, gf_to_symm, orb):
+    def symm_deg_gf(self, gf_to_symm, ish=0):
         r"""
         Averages a GF over degenerate shells.
 
@@ -1704,8 +1704,8 @@ class SumkDFT(object):
         ----------
         gf_to_symm : gf_struct_solver like
                      Input and output GF (i.e., it gets overwritten)
-        orb : int
-              Index of an inequivalent shell.
+        ish : int
+              Index of an inequivalent shell. (default value 0)
 
         """
 
@@ -1713,7 +1713,7 @@ class SumkDFT(object):
         # an h5 file, self.deg_shells might be None
         if self.deg_shells is None: return
 
-        for degsh in self.deg_shells[orb]:
+        for degsh in self.deg_shells[ish]:
             # ss will hold the averaged orbitals in the basis where the
             # blocks are all equal
             # i.e. maybe_conjugate(v^dagger gf v)

From 3d0adafad27bb09203907deb7c65943d40de0eb3 Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Wed, 5 Jun 2019 11:43:00 +0200
Subject: [PATCH 21/35] Modified test-reference files to changed degshells when
 picking gf-struct

---
 test/blockstructure.in.h5  | Bin 67352 -> 67352 bytes
 test/blockstructure.ref.h5 | Bin 240784 -> 240784 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/test/blockstructure.in.h5 b/test/blockstructure.in.h5
index 7e03651c9fa5b68fa3be4e9480d8a2a236ed296c..f4d2cada3e2ec1a058b2848f6dc39fe9cfd6e882 100644
GIT binary patch
delta 47
zcmV+~0MP%Kjs%#F1h62Kv%t3y0+TS77?Thh5VKg8W)cAblfS4bvtTDc0h3^;GP7E$
FzFfCz5{du-

delta 53
zcmV-50LuTEjs%#F1h62K0T8jV2Lh8&fe4c@mKc-ZkxsLgmM9Vd0+YX}DU*;82m%1A
Lv9S&TvZ@$e9gY*s

diff --git a/test/blockstructure.ref.h5 b/test/blockstructure.ref.h5
index d85903cf04181b46dd7763275e790d8b7ab2196d..74857307853722ac906bdc6a2acc24abf214744f 100644
GIT binary patch
delta 107
zcmbPmlW)RJzJ?aYEld@cw>Lau6kwX(ag|A8vcf5W={rIgJ+}Y2$|T1$S?@L1bcGvC
z3L6hdFiw7OG-~^%n@n=0Pz?_Pn86yha|ANWF@n_^1TllvPJgh1IePoyVCJ(C0BeUU
AV*mgE

delta 117
zcmbPmlW)RJzJ?aYEld@cw;Mz<3NTIYxXL6k{lO{5i0wbFGRZMbu9M=Lu5g1%VY-7j
zBPY{Mri~kU87DtD8nu1XO(wZgsHO)2%o39~JPDZY5y*TGti>RRSz&U3B_~rbGf2nu
P2P>GPw;v8>J{ti5g~Tkk


From ba79a7f7086c07a63de5ed1afba5e3445ef42c7a Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Wed, 5 Jun 2019 12:10:12 +0200
Subject: [PATCH 22/35] Modified map_gf_struct to remove degshells + update
 test case

---
 python/block_structure.py  |   1 +
 test/blockstructure.ref.h5 | Bin 240784 -> 240784 bytes
 2 files changed, 1 insertion(+)

diff --git a/python/block_structure.py b/python/block_structure.py
index 7563c224..b7ea824f 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -591,6 +591,7 @@ class BlockStructure(object):
             self.solver_to_sumk[ish] = so2su
             self.sumk_to_solver[ish] = su2so
             self.solver_to_sumk_block[ish] = so2su_block
+            self.deg_shells[ish] = []
 
     def create_gf(self, ish=0, gf_function=GfImFreq, space='solver', **kwargs):
         """ Create a zero BlockGf having the correct structure.
diff --git a/test/blockstructure.ref.h5 b/test/blockstructure.ref.h5
index 74857307853722ac906bdc6a2acc24abf214744f..4b2ab4040bfde95433a1fbdb888e0b7d8734ae82 100644
GIT binary patch
delta 49
zcmbPmlW)RJzJ@J~-+U*3J0-RK$0BA9rpXN#1*U5RFiK2caFxlgy)S?fh?%zc1u!$k
F001_66m0+i

delta 47
zcmbPmlW)RJzJ@J~-+U+gF-tLh2-&U`$tcD&T_b=|V(JE_i1rx)j6lq^eMSKDk7xk1
CHxZiv


From 187499b00f72157b6501e90cf738b2209ebac70a Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Wed, 5 Jun 2019 16:24:38 +0200
Subject: [PATCH 23/35] Bugfixes in block_structure

---
 python/block_structure.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index b7ea824f..e5659b49 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -451,10 +451,11 @@ class BlockStructure(object):
                                 warn(
                                     'Removing shells from degenerate shell {}. Cannot guarantee that they continue to be equivalent.')
                     else: # degshell is list
-                        for key in degsh:
+                        degsh1 = copy.deepcopy(degsh) # in order to not remove a key while iterating
+                        for key in degsh1:
                             if not key in gf_struct:
+                                warn('Removing shells from degenerate shell {}.')
                                 degsh.remove(key)
-                                continue
             # reindexing gf_struct so that it starts with 0
             for k in gf_struct:
                 gf_struct[k] = range(len(gf_struct[k]))
@@ -510,7 +511,7 @@ class BlockStructure(object):
         for icrsh in range(len(new_gf_struct)):
             for block, indices in self.gf_struct_sumk[icrsh]:
                 if not block in new_gf_struct[icrsh]:
-                    del new_gf_struct_transformed[block]
+                    #del new_gf_struct_transformed[block] # this MUST be wrong, as new_gf_struct_transformed needs to have a integer index for icrsh... # error when index is not kept at all
                     continue
                 T = eff_trans_sumk[icrsh][block]
                 for index in indices:

From 159ee1166eaeba8be14a87ff86d8b98cd595a9a7 Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Tue, 18 Jun 2019 09:59:45 +0200
Subject: [PATCH 24/35] Thread show_warnings through to extract_gloc in SK

---
 python/sumk_dft.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index d3f5ebea..db914cd9 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -667,7 +667,7 @@ class SumkDFT(object):
         return Sigma_out
 
     def extract_G_loc(self, mu=None, iw_or_w='iw', with_Sigma=True, with_dc=True, broadening=None,
-                      transform_to_solver_blocks=True):
+                      transform_to_solver_blocks=True, show_warnings=True):
         r"""
         Extracts the local downfolded Green function by the Brillouin-zone integration of the lattice Green's function.
 
@@ -686,6 +686,9 @@ class SumkDFT(object):
         transform_to_solver_blocks : bool, optional
             If True (default), the returned G_loc will be transformed to the block structure ``gf_struct_solver``,
             else it will be in ``gf_struct_sumk``.
+        show_warnings : bool, optional
+            Displays warning messages during transformation
+            (Only effective if transform_to_solver_blocks = True
 
         Returns
         -------
@@ -753,11 +756,11 @@ class SumkDFT(object):
                         icrsh, gf, direction='toLocal')
 
         if transform_to_solver_blocks:
-            return self.transform_to_solver_blocks(G_loc)
+            return self.transform_to_solver_blocks(G_loc, show_warnings=show_warnings)
 
         return G_loc
 
-    def transform_to_solver_blocks(self, G_loc, G_out=None):
+    def transform_to_solver_blocks(self, G_loc, G_out=None, show_warnings = True):
         """ transform G_loc from sumk to solver space
 
         Parameters
@@ -794,7 +797,8 @@ class SumkDFT(object):
                 ish_from=self.inequiv_to_corr[ish],
                 ish_to=ish,
                 space_from='sumk',
-                G_out=G_out[ish])
+                G_out=G_out[ish],
+                show_warnings = show_warnings)
 
         # return only the inequivalent shells:
         return G_out

From 32356a06baf4c01d7ca9465cdb68e709b39c0b13 Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Tue, 18 Jun 2019 14:57:19 +0200
Subject: [PATCH 25/35] Calculate diagonalization in solver blocks

---
 python/block_structure.py | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index e5659b49..3062956f 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -942,9 +942,23 @@ class BlockStructure(object):
                                      axis=0)
                 else:
                     maxdiff = G_back[name] - G[name]
-                if np.any(maxdiff > warning_threshold):
+
+                if space_to == 'solver': # do comparison in solver (ignore diff. in ignored orbitals)
+                    maxdiff = G_struct._convert_gf_or_matrix({'ud':maxdiff}, self, ish_from=ish_from,
+                                                    ish_to=ish_to,
+                                                    show_warnings=False,
+                                                    space_from=space_from, space_to=space_to, **kwargs)
+
+                    for block in maxdiff:
+                        maxdiff_b = maxdiff[block]
+                        if np.any(maxdiff_b > warning_threshold):
+                            warn('Block {} maximum difference:\n'.format(name) + str(maxdiff))
+
+
+                elif np.any(maxdiff > warning_threshold):
                     warn('Block {} maximum difference:\n'.format(name)
                          + str(maxdiff))
+
         return G_out
 
     def approximate_as_diagonal(self):

From 6623a397392f87175c51a32e1529567151afade3 Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Tue, 18 Jun 2019 14:57:46 +0200
Subject: [PATCH 26/35] Display transformation warnings only for relevant
 (solver) blocks

---
 python/trans_basis.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/python/trans_basis.py b/python/trans_basis.py
index 91a014a5..ef573efc 100644
--- a/python/trans_basis.py
+++ b/python/trans_basis.py
@@ -48,7 +48,7 @@ class TransBasis:
         self.T = copy.deepcopy(self.SK.T[0])
         self.w = numpy.identity(SK.corr_shells[0]['dim'])
 
-    def calculate_diagonalisation_matrix(self, prop_to_be_diagonal='eal'):
+    def calculate_diagonalisation_matrix(self, prop_to_be_diagonal='eal', calc_in_solver_blocks = False):
         """
         Calculates the diagonalisation matrix w, and stores it as member of the class.
 
@@ -76,6 +76,13 @@ class TransBasis:
                 "trans_basis: not a valid quantitiy to be diagonal. Choices are 'eal' or 'dm'.")
             return 0
 
+        if calc_in_solver_blocks:
+            trafo = self.SK.block_structure.transformation
+            self.SK.block_structre.transform = None
+            prop_solver = self.SK.block_structre.convert_matrix(prop, space_from='sumk', space_to='solver')
+            prop = self.SK.block_structre.convert_matrix(prop_solver, space_from='solver', space_to='sumk')
+            self.SK.block_structre.transform = trafo
+
         if self.SK.SO == 0:
             self.eig, self.w = numpy.linalg.eigh(prop['up'])
             # calculate new Transformation matrix

From a44f3d36f4f089254cb6a154e5287afd12ef6cc4 Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Tue, 18 Jun 2019 16:35:25 +0200
Subject: [PATCH 27/35] Reworked Diagonalization function to ignore 'picked
 out' obitals (e.g. egs)

---
 python/trans_basis.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/python/trans_basis.py b/python/trans_basis.py
index ef573efc..f00140d6 100644
--- a/python/trans_basis.py
+++ b/python/trans_basis.py
@@ -78,10 +78,15 @@ class TransBasis:
 
         if calc_in_solver_blocks:
             trafo = self.SK.block_structure.transformation
-            self.SK.block_structre.transform = None
-            prop_solver = self.SK.block_structre.convert_matrix(prop, space_from='sumk', space_to='solver')
-            prop = self.SK.block_structre.convert_matrix(prop_solver, space_from='solver', space_to='sumk')
-            self.SK.block_structre.transform = trafo
+            self.SK.block_structure.transform = None
+            prop_solver = self.SK.block_structure.convert_matrix(prop, space_from='sumk', space_to='solver')
+            v= []
+            for name in prop_solver:
+                v[name] = numpy.linalg.eigh(prop_solver[name])[1]
+            self.w = self.SK.block_structure.convert_matrix(v, space_from='solver', space_to='sumk')['ud' if self.SK.SO else 'up']
+            self.T = numpy.dot(self.T.transpose().conjugate(),
+                               self.w).conjugate().transpose()
+            self.SK.block_structure.transform = trafo
 
         if self.SK.SO == 0:
             self.eig, self.w = numpy.linalg.eigh(prop['up'])

From d66950a043fad7507fe8f1a81edf8c4c9d6829b7 Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Tue, 18 Jun 2019 16:53:23 +0200
Subject: [PATCH 28/35] Remove show_warning again as it is not necessary
 anymore

---
 python/sumk_dft.py | 52 +++++++++++++++++++++-------------------------
 1 file changed, 24 insertions(+), 28 deletions(-)

diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index db914cd9..8da2751e 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -52,11 +52,11 @@ class SumkDFT(object):
         hdf_file : string
                    Name of hdf5 containing the data.
         h_field : scalar, optional
-                  The value of magnetic field to add to the DFT Hamiltonian. 
+                  The value of magnetic field to add to the DFT Hamiltonian.
                   The contribution -h_field*sigma is added to diagonal elements of the Hamiltonian.
                   It cannot be used with the spin-orbit coupling on; namely h_field is set to 0 if self.SO=True.
         use_dft_blocks : boolean, optional
-                         If True, the local Green's function matrix for each spin is divided into smaller blocks 
+                         If True, the local Green's function matrix for each spin is divided into smaller blocks
                           with the block structure determined from the DFT density matrix of the corresponding correlated shell.
 
                          Alternatively and additionally, the block structure can be analysed using :meth:`analyse_block_structure <dft.sumk_dft.SumkDFT.analyse_block_structure>`
@@ -64,7 +64,7 @@ class SumkDFT(object):
         dft_data : string, optional
                    Name of hdf5 subgroup in which DFT data for projector and lattice Green's function construction are stored.
         symmcorr_data : string, optional
-                        Name of hdf5 subgroup in which DFT data on symmetries of correlated shells 
+                        Name of hdf5 subgroup in which DFT data on symmetries of correlated shells
                         (symmetry operations, permutaion matrices etc.) are stored.
         parproj_data : string, optional
                        Name of hdf5 subgroup in which DFT data on non-normalized projectors for non-correlated
@@ -291,10 +291,10 @@ class SumkDFT(object):
 
         bname : string
                 Block name of the target block of the lattice Green's function.
-        gf_to_downfold : Gf 
+        gf_to_downfold : Gf
                        Block of the Green's function that is to be downfolded.
-        gf_inp : Gf 
-                 FIXME 
+        gf_inp : Gf
+                 FIXME
         shells : string, optional
 
                  - if shells='corr': orthonormalized projectors for correlated shells are used for the downfolding.
@@ -343,10 +343,10 @@ class SumkDFT(object):
 
         bname : string
                 Block name of the target block of the lattice Green's function.
-        gf_to_upfold : Gf 
+        gf_to_upfold : Gf
                        Block of the Green's function that is to be upfolded.
-        gf_inp : Gf 
-                 FIXME 
+        gf_inp : Gf
+                 FIXME
         shells : string, optional
 
                  - if shells='corr': orthonormalized projectors for correlated shells are used for the upfolding.
@@ -391,10 +391,10 @@ class SumkDFT(object):
               - if shells='corr': ish labels all correlated shells (equivalent or not)
               - if shells='all': ish labels only representative (inequivalent) non-correlated shells
 
-        gf_to_rotate : Gf 
+        gf_to_rotate : Gf
                        Block of the Green's function that is to be rotated.
         direction : string
-                    The direction of rotation can be either 
+                    The direction of rotation can be either
 
                     - 'toLocal' : global -> local transformation,
                     - 'toGlobal' : local -> global transformation.
@@ -444,7 +444,7 @@ class SumkDFT(object):
 
     def lattice_gf(self, ik, mu=None, iw_or_w="iw", beta=40, broadening=None, mesh=None, with_Sigma=True, with_dc=True):
         r"""
-        Calculates the lattice Green function for a given k-point from the DFT Hamiltonian and the self energy. 
+        Calculates the lattice Green function for a given k-point from the DFT Hamiltonian and the self energy.
 
         Parameters
         ----------
@@ -467,7 +467,7 @@ class SumkDFT(object):
                Data defining mesh on which the real-axis GF will be calculated, given in the form
                (om_min,om_max,n_points), where om_min is the minimum omega, om_max is the maximum omega and n_points is the number of points.
         with_Sigma : boolean, optional
-                     If True the GF will be calculated with the self-energy stored in self.Sigmaimp_(w/iw), for real/Matsubara GF, respectively. 
+                     If True the GF will be calculated with the self-energy stored in self.Sigmaimp_(w/iw), for real/Matsubara GF, respectively.
                      In this case the mesh is taken from the self.Sigma_imp object.
                      If with_Sigma=True but self.Sigmaimp_(w/iw) is not present, with_Sigma is reset to False.
         with_dc : boolean, optional
@@ -667,7 +667,7 @@ class SumkDFT(object):
         return Sigma_out
 
     def extract_G_loc(self, mu=None, iw_or_w='iw', with_Sigma=True, with_dc=True, broadening=None,
-                      transform_to_solver_blocks=True, show_warnings=True):
+                      transform_to_solver_blocks=True):
         r"""
         Extracts the local downfolded Green function by the Brillouin-zone integration of the lattice Green's function.
 
@@ -686,9 +686,6 @@ class SumkDFT(object):
         transform_to_solver_blocks : bool, optional
             If True (default), the returned G_loc will be transformed to the block structure ``gf_struct_solver``,
             else it will be in ``gf_struct_sumk``.
-        show_warnings : bool, optional
-            Displays warning messages during transformation
-            (Only effective if transform_to_solver_blocks = True
 
         Returns
         -------
@@ -756,11 +753,11 @@ class SumkDFT(object):
                         icrsh, gf, direction='toLocal')
 
         if transform_to_solver_blocks:
-            return self.transform_to_solver_blocks(G_loc, show_warnings=show_warnings)
+            return self.transform_to_solver_blocks(G_loc)
 
         return G_loc
 
-    def transform_to_solver_blocks(self, G_loc, G_out=None, show_warnings = True):
+    def transform_to_solver_blocks(self, G_loc, G_out=None):
         """ transform G_loc from sumk to solver space
 
         Parameters
@@ -797,16 +794,15 @@ class SumkDFT(object):
                 ish_from=self.inequiv_to_corr[ish],
                 ish_to=ish,
                 space_from='sumk',
-                G_out=G_out[ish],
-                show_warnings = show_warnings)
+                G_out=G_out[ish])
 
         # return only the inequivalent shells:
         return G_out
 
     def analyse_block_structure(self, threshold=0.00001, include_shells=None, dm=None, hloc=None):
         r"""
-        Determines the block structure of local Green's functions by analysing the structure of 
-        the corresponding density matrices and the local Hamiltonian. The resulting block structures 
+        Determines the block structure of local Green's functions by analysing the structure of
+        the corresponding density matrices and the local Hamiltonian. The resulting block structures
         for correlated shells are stored in the :class:`SumkDFT.block_structure <dft.block_structure.BlockStructure>` attribute.
 
         Parameters
@@ -969,7 +965,7 @@ class SumkDFT(object):
                     else:
                         return w-w0
             gf = [BlockGf(name_block_generator = [(name, GfReFreq(
-                window=(-numpy.pi*(len(block.mesh)-1) / (len(block.mesh)*get_delta_from_mesh(block.mesh)), 
+                window=(-numpy.pi*(len(block.mesh)-1) / (len(block.mesh)*get_delta_from_mesh(block.mesh)),
                 numpy.pi*(len(block.mesh)-1) / (len(block.mesh)*get_delta_from_mesh(block.mesh))),
                 n_points=len(block.mesh), indices=block.indices)) for name, block in g_sh], make_copies=False)
                 for g_sh in G]
@@ -1348,7 +1344,7 @@ class SumkDFT(object):
                  - if 'using_point_integration': Only works for diagonal hopping matrix (true in wien2k).
 
         beta : float, optional
-               Inverse temperature.      
+               Inverse temperature.
 
         Returns
         -------
@@ -1756,7 +1752,7 @@ class SumkDFT(object):
 
     def total_density(self, mu=None, iw_or_w="iw", with_Sigma=True, with_dc=True, broadening=None):
         r"""
-        Calculates the total charge within the energy window for a given chemical potential. 
+        Calculates the total charge within the energy window for a given chemical potential.
         The chemical potential is either given by parameter `mu` or, if it is not specified,
         taken from `self.chemical_potential`.
 
@@ -1773,7 +1769,7 @@ class SumkDFT(object):
 
         with
 
-        .. math:: n(k) = Tr G_{\nu\nu'}(k, i\omega_{n}). 
+        .. math:: n(k) = Tr G_{\nu\nu'}(k, i\omega_{n}).
 
         The calculation is done in the global coordinate system, if distinction is made between local/global.
 
@@ -2064,7 +2060,7 @@ class SumkDFT(object):
         return dc
 
     def check_projectors(self):
-        """Calculated the density matrix from projectors (DM = P Pdagger) to check that it is correct and 
+        """Calculated the density matrix from projectors (DM = P Pdagger) to check that it is correct and
            specifically that it matches DFT."""
         dens_mat = [numpy.zeros([self.corr_shells[icrsh]['dim'], self.corr_shells[icrsh]['dim']], numpy.complex_)
                     for icrsh in range(self.n_corr_shells)]

From 810b315c92e44a735b893ef0a3a7b4148a023a4a Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Tue, 18 Jun 2019 16:53:44 +0200
Subject: [PATCH 29/35] Fixing TransBasis

---
 python/trans_basis.py | 31 ++++++++++++++++++-------------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/python/trans_basis.py b/python/trans_basis.py
index f00140d6..7bd2ee4e 100644
--- a/python/trans_basis.py
+++ b/python/trans_basis.py
@@ -60,6 +60,10 @@ class TransBasis:
                               - 'eal' : local hamiltonian (i.e. crystal field)
                               - 'dm' : local density matrix
 
+        calc_in_solver_blocks : bool, optional
+                                Whether the property shall be diagonalized in the
+                                full sumk structure, or just in the solver structure.
+
         Returns
         -------
         wsqr : double
@@ -78,26 +82,27 @@ class TransBasis:
 
         if calc_in_solver_blocks:
             trafo = self.SK.block_structure.transformation
-            self.SK.block_structure.transform = None
+            self.SK.block_structure.transformation = None
+
             prop_solver = self.SK.block_structure.convert_matrix(prop, space_from='sumk', space_to='solver')
-            v= []
+            v= {}
             for name in prop_solver:
                 v[name] = numpy.linalg.eigh(prop_solver[name])[1]
             self.w = self.SK.block_structure.convert_matrix(v, space_from='solver', space_to='sumk')['ud' if self.SK.SO else 'up']
             self.T = numpy.dot(self.T.transpose().conjugate(),
                                self.w).conjugate().transpose()
-            self.SK.block_structure.transform = trafo
-
-        if self.SK.SO == 0:
-            self.eig, self.w = numpy.linalg.eigh(prop['up'])
-            # calculate new Transformation matrix
-            self.T = numpy.dot(self.T.transpose().conjugate(),
-                               self.w).conjugate().transpose()
+            self.SK.block_structure.transformation = trafo
         else:
-            self.eig, self.w = numpy.linalg.eigh(prop['ud'])
-            # calculate new Transformation matrix
-            self.T = numpy.dot(self.T.transpose().conjugate(),
-                               self.w).conjugate().transpose()
+            if self.SK.SO == 0:
+                self.eig, self.w = numpy.linalg.eigh(prop['up'])
+                # calculate new Transformation matrix
+                self.T = numpy.dot(self.T.transpose().conjugate(),
+                                   self.w).conjugate().transpose()
+            else:
+                self.eig, self.w = numpy.linalg.eigh(prop['ud'])
+                # calculate new Transformation matrix
+                self.T = numpy.dot(self.T.transpose().conjugate(),
+                                   self.w).conjugate().transpose()
 
         # measure for the 'unity' of the transformation:
         wsqr = sum(abs(self.w.diagonal())**2) / self.w.diagonal().size

From f695ccac7a384ababd1c2f16dc30d515f1431175 Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Mon, 24 Jun 2019 10:03:43 +0200
Subject: [PATCH 30/35] Ignore imaginary part of the density when calculating
 mu

---
 python/sumk_dft.py | 58 +++++++++++++++++++++++++---------------------
 1 file changed, 32 insertions(+), 26 deletions(-)

diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 8da2751e..38b8195c 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -52,11 +52,11 @@ class SumkDFT(object):
         hdf_file : string
                    Name of hdf5 containing the data.
         h_field : scalar, optional
-                  The value of magnetic field to add to the DFT Hamiltonian.
+                  The value of magnetic field to add to the DFT Hamiltonian. 
                   The contribution -h_field*sigma is added to diagonal elements of the Hamiltonian.
                   It cannot be used with the spin-orbit coupling on; namely h_field is set to 0 if self.SO=True.
         use_dft_blocks : boolean, optional
-                         If True, the local Green's function matrix for each spin is divided into smaller blocks
+                         If True, the local Green's function matrix for each spin is divided into smaller blocks 
                           with the block structure determined from the DFT density matrix of the corresponding correlated shell.
 
                          Alternatively and additionally, the block structure can be analysed using :meth:`analyse_block_structure <dft.sumk_dft.SumkDFT.analyse_block_structure>`
@@ -64,7 +64,7 @@ class SumkDFT(object):
         dft_data : string, optional
                    Name of hdf5 subgroup in which DFT data for projector and lattice Green's function construction are stored.
         symmcorr_data : string, optional
-                        Name of hdf5 subgroup in which DFT data on symmetries of correlated shells
+                        Name of hdf5 subgroup in which DFT data on symmetries of correlated shells 
                         (symmetry operations, permutaion matrices etc.) are stored.
         parproj_data : string, optional
                        Name of hdf5 subgroup in which DFT data on non-normalized projectors for non-correlated
@@ -291,10 +291,10 @@ class SumkDFT(object):
 
         bname : string
                 Block name of the target block of the lattice Green's function.
-        gf_to_downfold : Gf
+        gf_to_downfold : Gf 
                        Block of the Green's function that is to be downfolded.
-        gf_inp : Gf
-                 FIXME
+        gf_inp : Gf 
+                 FIXME 
         shells : string, optional
 
                  - if shells='corr': orthonormalized projectors for correlated shells are used for the downfolding.
@@ -343,10 +343,10 @@ class SumkDFT(object):
 
         bname : string
                 Block name of the target block of the lattice Green's function.
-        gf_to_upfold : Gf
+        gf_to_upfold : Gf 
                        Block of the Green's function that is to be upfolded.
-        gf_inp : Gf
-                 FIXME
+        gf_inp : Gf 
+                 FIXME 
         shells : string, optional
 
                  - if shells='corr': orthonormalized projectors for correlated shells are used for the upfolding.
@@ -391,10 +391,10 @@ class SumkDFT(object):
               - if shells='corr': ish labels all correlated shells (equivalent or not)
               - if shells='all': ish labels only representative (inequivalent) non-correlated shells
 
-        gf_to_rotate : Gf
+        gf_to_rotate : Gf 
                        Block of the Green's function that is to be rotated.
         direction : string
-                    The direction of rotation can be either
+                    The direction of rotation can be either 
 
                     - 'toLocal' : global -> local transformation,
                     - 'toGlobal' : local -> global transformation.
@@ -444,7 +444,7 @@ class SumkDFT(object):
 
     def lattice_gf(self, ik, mu=None, iw_or_w="iw", beta=40, broadening=None, mesh=None, with_Sigma=True, with_dc=True):
         r"""
-        Calculates the lattice Green function for a given k-point from the DFT Hamiltonian and the self energy.
+        Calculates the lattice Green function for a given k-point from the DFT Hamiltonian and the self energy. 
 
         Parameters
         ----------
@@ -467,7 +467,7 @@ class SumkDFT(object):
                Data defining mesh on which the real-axis GF will be calculated, given in the form
                (om_min,om_max,n_points), where om_min is the minimum omega, om_max is the maximum omega and n_points is the number of points.
         with_Sigma : boolean, optional
-                     If True the GF will be calculated with the self-energy stored in self.Sigmaimp_(w/iw), for real/Matsubara GF, respectively.
+                     If True the GF will be calculated with the self-energy stored in self.Sigmaimp_(w/iw), for real/Matsubara GF, respectively. 
                      In this case the mesh is taken from the self.Sigma_imp object.
                      If with_Sigma=True but self.Sigmaimp_(w/iw) is not present, with_Sigma is reset to False.
         with_dc : boolean, optional
@@ -667,7 +667,7 @@ class SumkDFT(object):
         return Sigma_out
 
     def extract_G_loc(self, mu=None, iw_or_w='iw', with_Sigma=True, with_dc=True, broadening=None,
-                      transform_to_solver_blocks=True):
+                      transform_to_solver_blocks=True, show_warnings=True):
         r"""
         Extracts the local downfolded Green function by the Brillouin-zone integration of the lattice Green's function.
 
@@ -686,6 +686,9 @@ class SumkDFT(object):
         transform_to_solver_blocks : bool, optional
             If True (default), the returned G_loc will be transformed to the block structure ``gf_struct_solver``,
             else it will be in ``gf_struct_sumk``.
+        show_warnings : bool, optional
+            Displays warning messages during transformation
+            (Only effective if transform_to_solver_blocks = True 
 
         Returns
         -------
@@ -753,11 +756,11 @@ class SumkDFT(object):
                         icrsh, gf, direction='toLocal')
 
         if transform_to_solver_blocks:
-            return self.transform_to_solver_blocks(G_loc)
+            return self.transform_to_solver_blocks(G_loc, show_warnings=show_warnings)
 
         return G_loc
 
-    def transform_to_solver_blocks(self, G_loc, G_out=None):
+    def transform_to_solver_blocks(self, G_loc, G_out=None, show_warnings = True):
         """ transform G_loc from sumk to solver space
 
         Parameters
@@ -794,15 +797,16 @@ class SumkDFT(object):
                 ish_from=self.inequiv_to_corr[ish],
                 ish_to=ish,
                 space_from='sumk',
-                G_out=G_out[ish])
+                G_out=G_out[ish],
+                show_warnings = show_warnings)
 
         # return only the inequivalent shells:
         return G_out
 
     def analyse_block_structure(self, threshold=0.00001, include_shells=None, dm=None, hloc=None):
         r"""
-        Determines the block structure of local Green's functions by analysing the structure of
-        the corresponding density matrices and the local Hamiltonian. The resulting block structures
+        Determines the block structure of local Green's functions by analysing the structure of 
+        the corresponding density matrices and the local Hamiltonian. The resulting block structures 
         for correlated shells are stored in the :class:`SumkDFT.block_structure <dft.block_structure.BlockStructure>` attribute.
 
         Parameters
@@ -965,7 +969,7 @@ class SumkDFT(object):
                     else:
                         return w-w0
             gf = [BlockGf(name_block_generator = [(name, GfReFreq(
-                window=(-numpy.pi*(len(block.mesh)-1) / (len(block.mesh)*get_delta_from_mesh(block.mesh)),
+                window=(-numpy.pi*(len(block.mesh)-1) / (len(block.mesh)*get_delta_from_mesh(block.mesh)), 
                 numpy.pi*(len(block.mesh)-1) / (len(block.mesh)*get_delta_from_mesh(block.mesh))),
                 n_points=len(block.mesh), indices=block.indices)) for name, block in g_sh], make_copies=False)
                 for g_sh in G]
@@ -1344,7 +1348,7 @@ class SumkDFT(object):
                  - if 'using_point_integration': Only works for diagonal hopping matrix (true in wien2k).
 
         beta : float, optional
-               Inverse temperature.
+               Inverse temperature.      
 
         Returns
         -------
@@ -1752,7 +1756,7 @@ class SumkDFT(object):
 
     def total_density(self, mu=None, iw_or_w="iw", with_Sigma=True, with_dc=True, broadening=None):
         r"""
-        Calculates the total charge within the energy window for a given chemical potential.
+        Calculates the total charge within the energy window for a given chemical potential. 
         The chemical potential is either given by parameter `mu` or, if it is not specified,
         taken from `self.chemical_potential`.
 
@@ -1769,7 +1773,7 @@ class SumkDFT(object):
 
         with
 
-        .. math:: n(k) = Tr G_{\nu\nu'}(k, i\omega_{n}).
+        .. math:: n(k) = Tr G_{\nu\nu'}(k, i\omega_{n}). 
 
         The calculation is done in the global coordinate system, if distinction is made between local/global.
 
@@ -1808,8 +1812,10 @@ class SumkDFT(object):
         # collect data from mpi:
         dens = mpi.all_reduce(mpi.world, dens, lambda x, y: x + y)
         mpi.barrier()
-
-        return dens
+        import numpy as np
+        if np.abs(np.imag(dens)) > 1e-20:
+            mpi.report("Warning: Imaginary part in density will be ignored ({})".format(str(np.abs(np.imag(dens)))))
+        return np.real(dens)
 
     def set_mu(self, mu):
         r"""
@@ -2060,7 +2066,7 @@ class SumkDFT(object):
         return dc
 
     def check_projectors(self):
-        """Calculated the density matrix from projectors (DM = P Pdagger) to check that it is correct and
+        """Calculated the density matrix from projectors (DM = P Pdagger) to check that it is correct and 
            specifically that it matches DFT."""
         dens_mat = [numpy.zeros([self.corr_shells[icrsh]['dim'], self.corr_shells[icrsh]['dim']], numpy.complex_)
                     for icrsh in range(self.n_corr_shells)]

From bd228de7689ff1f3f321f57d3576946d001c13af Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Mon, 24 Jun 2019 10:15:09 +0200
Subject: [PATCH 31/35] Add adapt_deg_shells method and call it in
 map_gf_struct

---
 python/block_structure.py | 50 ++++++++++++++++++++++++---------------
 1 file changed, 31 insertions(+), 19 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index 3062956f..79394657 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -437,30 +437,39 @@ class BlockStructure(object):
                 else:
                     self.sumk_to_solver[ish][k] = (None, None)
             # adapt deg_shells
-            if self.deg_shells is not None:
-                for degsh in self.deg_shells[ish]:
-                    if isinstance(degsh, dict):
-                        for key in degsh.keys():
-                            if not key in gf_struct:
-                                del degsh[key]
-                                continue
-                            if gf_struct[key] != self.gf_struct_solver[ish][key]:
-                                v, C = degsh[key]
-                                degsh[key][0] = \
-                                    v[gf_struct[key], :][:, gf_struct[key]]
-                                warn(
-                                    'Removing shells from degenerate shell {}. Cannot guarantee that they continue to be equivalent.')
-                    else: # degshell is list
-                        degsh1 = copy.deepcopy(degsh) # in order to not remove a key while iterating
-                        for key in degsh1:
-                            if not key in gf_struct:
-                                warn('Removing shells from degenerate shell {}.')
-                                degsh.remove(key)
+
+            self.adapt_deg_shells(gf_struct, ish)
+
+
             # reindexing gf_struct so that it starts with 0
             for k in gf_struct:
                 gf_struct[k] = range(len(gf_struct[k]))
             self.gf_struct_solver[ish] = gf_struct
 
+    def adapt_deg_shells(gf_struct, ish=0):
+        """ Adapts the deg_shells to a new gf_struct
+            Internally called when using pick_gf_struct and map_gf_struct
+        """
+        if self.deg_shells is not None:
+            for degsh in self.deg_shells[ish]:
+                if isinstance(degsh, dict):
+                    for key in degsh.keys():
+                        if not key in gf_struct:
+                            del degsh[key]
+                            continue
+                        if gf_struct[key] != self.gf_struct_solver[ish][key]:
+                            v, C = degsh[key]
+                            degsh[key][0] = \
+                                v[gf_struct[key], :][:, gf_struct[key]]
+                            warn(
+                                'Removing shells from degenerate shell {}. Cannot guarantee that they continue to be equivalent.')
+                else: # degshell is list
+                    degsh1 = copy.deepcopy(degsh) # in order to not remove a key while iterating
+                    for key in degsh1:
+                        if not key in gf_struct:
+                            warn('Removing shells from degenerate shell {}.')
+                            degsh.remove(key)
+
     def pick_gf_struct_sumk(self, new_gf_struct):
         """ Pick selected orbitals within blocks.
 
@@ -588,6 +597,9 @@ class BlockStructure(object):
             for k in self.sumk_to_solver[ish].keys():
                 if not k in su2so:
                     su2so[k] = (None, None)
+
+            adapt_deg_shells(gf_struct, ish)
+
             self.gf_struct_solver[ish] = gf_struct
             self.solver_to_sumk[ish] = so2su
             self.sumk_to_solver[ish] = su2so

From 9bc4643fdf9fc5e2fe99dc7784eeef3119ac5e7f Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Mon, 24 Jun 2019 12:33:22 +0200
Subject: [PATCH 32/35] Update unit tests and bugfixes in BlockStructure

---
 python/block_structure.py               | 12 ++++++------
 python/sumk_dft.py                      |  4 ++--
 test/analyse_block_structure_from_gf.py |  7 +++----
 3 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index 79394657..fca33d5d 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -446,7 +446,7 @@ class BlockStructure(object):
                 gf_struct[k] = range(len(gf_struct[k]))
             self.gf_struct_solver[ish] = gf_struct
 
-    def adapt_deg_shells(gf_struct, ish=0):
+    def adapt_deg_shells(self, gf_struct, ish=0):
         """ Adapts the deg_shells to a new gf_struct
             Internally called when using pick_gf_struct and map_gf_struct
         """
@@ -598,7 +598,7 @@ class BlockStructure(object):
                 if not k in su2so:
                     su2so[k] = (None, None)
 
-            adapt_deg_shells(gf_struct, ish)
+            self.adapt_deg_shells(gf_struct, ish)
 
             self.gf_struct_solver[ish] = gf_struct
             self.solver_to_sumk[ish] = so2su
@@ -816,7 +816,6 @@ class BlockStructure(object):
                 'The parameter ish in convert_gf is deprecated. Use ish_from and ish_to instead.')
             ish_from = ish
             ish_to = ish
-
         return self._convert_gf_or_matrix(G, G_struct, ish_from, ish_to,
                                           show_warnings, G_out, space_from, space_to, **kwargs)
 
@@ -866,7 +865,6 @@ class BlockStructure(object):
 
     def _convert_gf_or_matrix(self, G, G_struct=None, ish_from=0, ish_to=None, show_warnings=True,
                               G_out=None, space_from='solver', space_to='solver', **kwargs):
-
         if ish_to is None:
             ish_to = ish_from
 
@@ -955,8 +953,10 @@ class BlockStructure(object):
                 else:
                     maxdiff = G_back[name] - G[name]
 
-                if space_to == 'solver': # do comparison in solver (ignore diff. in ignored orbitals)
-                    maxdiff = G_struct._convert_gf_or_matrix({'ud':maxdiff}, self, ish_from=ish_from,
+                if space_to == 'solver' and self == G_struct: # do comparison in solver (ignore diff. in ignored orbitals)
+                    tmp = self.create_matrix(space='sumk')
+                    tmp[name] = maxdiff
+                    maxdiff = G_struct._convert_gf_or_matrix(tmp, self, ish_from=ish_from,
                                                     ish_to=ish_to,
                                                     show_warnings=False,
                                                     space_from=space_from, space_to=space_to, **kwargs)
diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 38b8195c..40c3e1b5 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -1090,9 +1090,9 @@ class SumkDFT(object):
         G_transformed = [
             self.block_structure.convert_gf(G[ish],
                 full_structure, ish, mesh=G[ish].mesh.copy(), show_warnings=threshold,
-                gf_function=type(G[ish]._first()))
+                gf_function=type(G[ish]._first()), space_from='sumk', space_to='solver')
             for ish in range(self.n_inequiv_shells)]
-
+        #print 'c'
         if analyse_deg_shells:
             self.analyse_deg_shells(G_transformed, threshold, include_shells)
         return G_transformed
diff --git a/test/analyse_block_structure_from_gf.py b/test/analyse_block_structure_from_gf.py
index 5a831444..442a7fff 100644
--- a/test/analyse_block_structure_from_gf.py
+++ b/test/analyse_block_structure_from_gf.py
@@ -26,7 +26,6 @@ G = SK.extract_G_loc()
 
 # the original block structure
 block_structure1 = SK.block_structure.copy()
-
 G_new = SK.analyse_block_structure_from_gf(G)
 
 # the new block structure
@@ -163,9 +162,9 @@ for conjugate in conjugate_values:
     G_new = SK.analyse_block_structure_from_gf(G, 1.e-7)
 
     # transform G_noisy etc. to the new block structure
-    G_noisy = SK.block_structure.convert_gf(G_noisy, block_structure1, beta = G_noisy.mesh.beta)
-    G_pre_transform = SK.block_structure.convert_gf(G_pre_transform, block_structure1, beta = G_noisy.mesh.beta)
-    G_noisy_pre_transform = SK.block_structure.convert_gf(G_noisy_pre_transform, block_structure1, beta = G_noisy.mesh.beta)
+    G_noisy = SK.block_structure.convert_gf(G_noisy, block_structure1, beta = G_noisy.mesh.beta, space_from='sumk')
+    G_pre_transform = SK.block_structure.convert_gf(G_pre_transform, block_structure1, beta = G_noisy.mesh.beta, space_from='sumk')
+    G_noisy_pre_transform = SK.block_structure.convert_gf(G_noisy_pre_transform, block_structure1, beta = G_noisy.mesh.beta, space_from='sumk')
 
     assert len(SK.deg_shells[0]) == 2, "wrong number of equivalent groups found"
     assert sorted([len(d) for d in SK.deg_shells[0]]) == [2,3], "wrong number of members in the equivalent groups found"

From 8016152c5eca658d789904ac79a363a35cdfeb13 Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Thu, 27 Jun 2019 12:12:33 +0200
Subject: [PATCH 33/35] Documentation for basis rotations

---
 doc/documentation.rst       |  8 ++++
 doc/guide/BasisRotation.rst | 76 +++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+)
 create mode 100644 doc/guide/BasisRotation.rst

diff --git a/doc/documentation.rst b/doc/documentation.rst
index 45f071d6..d40b1dd6 100644
--- a/doc/documentation.rst
+++ b/doc/documentation.rst
@@ -27,6 +27,14 @@ User guide
    guide/SrVO3
    guide/dftdmft_selfcons
    guide/Sr2RuO4
+   guide/BasisRotation
+
+Postprocessing
+--------------
+
+.. toctree::
+   :maxdepth: 2
+
    guide/analysis
    guide/full_tutorial
    guide/transport
diff --git a/doc/guide/BasisRotation.rst b/doc/guide/BasisRotation.rst
new file mode 100644
index 00000000..dda0a573
--- /dev/null
+++ b/doc/guide/BasisRotation.rst
@@ -0,0 +1,76 @@
+.. _plovasp:
+
+Numerical Treatment of the Sign-Problem: Basis Rotations
+=======
+
+When performing calculations with off-diagonal complex hybridisation or local Hamiltonian, one is
+often limited by the fermionic sign-problem. However, as the sign is no
+physical observable, one can try to improve the calculation by rotating
+to another basis.
+
+While the choice of basis to perform the calculation in can be chosen
+arbitrarily, two choices which have shown good results are the basis
+which diagonalizes the local Hamiltonian or the density matrix of then
+system.
+
+The transformation matrix can be stored in the :class:`BlockStructure` and the
+transformation is automatically performed when using :class:`SumkDFT`'s :meth:`extract_G_loc`
+and :meth:`put_Sigma` (see below).
+
+
+Finding the Transformation Matrix
+-----------------
+
+The :class:`TransBasis` class offers a simple mehod to calculate the transformation
+matrices to a basis where either the local Hamiltonian or the density matrix
+is diagonal::
+
+    from triqs_dft_tools.trans_basis import TransBasis
+    TB = TransBasis(SK)
+    TB.calculate_diagonalisation_matrix(prop_to_be_diagonal='eal', calc_in_solver_blocks = True)
+
+    SK.block_structure.transformation = [{'ud':TB.w}]
+
+
+
+Transforming Green's functions manually
+-----------------
+
+One can transform Green's functions manually using the :meth:`convert_gf` method::
+
+    # Rotate a Green's function from solver-space to sumk-space
+    new_gf = block_structure.convert_gf(old_gf, space_from='solver', space_to='sumk')
+
+
+
+Automatic transformation during the DMFT loop
+-----------------
+
+During a DMFT loop one is switching back and forth between Sumk-Space and Solver-Space
+in each iteration. Once the block_structure.transformation property is set, this can be
+done automatically::
+
+    for it in range(iteration_offset, iteration_offset + n_iterations):
+        # every GF is in solver space here
+        S.G0_iw << inverse(S.Sigma_iw + inverse(S.G_iw))
+
+        # solve the impurity in solver space -> hopefully better sign
+        S.solve(h_int = H, **p)
+
+        # calc_dc(..., transform = True) by default
+        SK.calc_dc(S.G_iw.density(), U_interact=U, J_hund=J, orb=0, use_dc_formula=DC_type)
+        
+        # put_Sigma(..., transform_to_sumk_blocks = True) by default
+        SK.put_Sigma([S.Sigma_iw])
+        
+        SK.calc_mu()
+
+        # extract_G_loc(..., transform_to_solver_blocks = True) by default
+        S.G_iw << SK.extract_G_loc()[0]
+
+.. warning::
+  One must not forget to also transform the interaction Hamiltonian to the diagonal basis!
+  This can be done with the :meth:`transform_U_matrix` method. However, due to different 
+  conventions in this method, one must pass the conjugated version of the transformation matrix::
+  
+  U_trans = transform_U_matrix(U, SK.block_structure.transformation[0]['ud'].conjugate())

From e40f3159896e2b5fedfb4e18e4e16ed751dd297b Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Wed, 10 Jul 2019 17:15:48 +0200
Subject: [PATCH 34/35] Implement calculate_diagonalization_matrix method into
 SK

---
 python/sumk_dft.py | 74 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 40c3e1b5..69d95640 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -1333,7 +1333,81 @@ class SumkDFT(object):
 
                         # a block was found, break out of the loop
                         break
+    
+    def calculate_diagonalization_matrix(self, prop_to_be_diagonal='eal', calc_in_solver_blocks=False, write_to_blockstructure = True, ish=0):
+        """
+        Calculates the diagonalisation matrix, and (optionally) stores it in the BlockStructure.
 
+        Parameters
+        ----------
+        prop_to_be_diagonal : string, optional
+                              Defines the property to be diagonalized.
+
+                              - 'eal' : local hamiltonian (i.e. crystal field)
+                              - 'dm' : local density matrix
+
+        calc_in_solver_blocks : bool, optional
+                                Whether the property shall be diagonalized in the
+                                full sumk structure, or just in the solver structure.
+                                
+        write_to_blockstructure : bool, optional
+                                Whether the diagonalization matrix shall be written to
+                                the BlockStructure directly.
+        ish : int, optional
+              Number of the correlated shell to be diagonalized.
+
+        Returns
+        -------
+        trafo : dict
+               The transformation matrix for each spin-block in the correlated shell
+
+        """
+        trafo = {}
+        
+        
+        if prop_to_be_diagonal == 'eal':
+            prop = self.eff_atomic_levels()[ish]
+        elif prop_to_be_diagonal == 'dm':
+            prop = self.density_matrix(method='using_point_integration')[ish]
+        else:
+            mpi.report(
+                "calculate_diagonalization_matrix: not a valid quantitiy to be diagonal. Choices are 'eal' or 'dm'.")
+            return 0
+
+        if calc_in_solver_blocks:
+            trafo_tmp = self.block_structure.transformation
+            self.block_structure.transformation = None
+
+            prop_solver = self.block_structure.convert_matrix(prop, space_from='sumk', space_to='solver')
+            t= {}
+            for name in prop_solver:
+                t[name] = numpy.linalg.eigh(prop_solver[name])[1].conjugate().transpose()
+            trafo = self.block_structure.convert_matrix(t, space_from='solver', space_to='sumk')
+            #self.T = numpy.dot(self.T.transpose().conjugate(),
+             #                  self.w).conjugate().transpose()
+            self.block_structure.transformation = trafo_tmp
+        else:
+            for name in prop:
+                t = numpy.linalg.eigh(prop[name])[1].conjugate().transpose()
+                trafo[name] = t
+                # calculate new Transformation matrix
+                #self.T = numpy.dot(self.T.transpose().conjugate(),
+                #                   self.w).conjugate().transpose()
+
+        # measure for the 'unity' of the transformation:
+        #wsqr = sum(abs(self.w.diagonal())**2) / self.w.diagonal().size
+        #return wsqr
+        
+        if write_to_blockstructure:
+            if self.block_structure.transformation == None:
+                self.block_structure.transformation = [{} for icrsh in range(self.n_corr_shells)]
+                for sp in self.spin_block_names[self.corr_shells[icrsh]['SO']]:
+                    self.block_structure.transformation[icrsh][sp] = numpy.eye(self.corr_shells[icrsh]['dim'], self.corr_shells[icrsh]['dim'], numpy.complex_)
+        
+            self.block_structure.transformation[ish] = trafo
+            
+        return trafo
+        
 
     def density_matrix(self, method='using_gf', beta=40.0):
         """Calculate density matrices in one of two ways.

From e7cddf3e7e320ab855c2c1d946ab7393ed289391 Mon Sep 17 00:00:00 2001
From: Hermann Schnait <hermann.schnait@tugraz.at>
Date: Thu, 18 Jul 2019 11:59:50 +0200
Subject: [PATCH 35/35] Bugfix in calculate_diagonalization_matrix for more
 than one deg shell

---
 python/block_structure.py | 1 -
 python/sumk_dft.py        | 6 ++++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/python/block_structure.py b/python/block_structure.py
index fca33d5d..5739482c 100644
--- a/python/block_structure.py
+++ b/python/block_structure.py
@@ -726,7 +726,6 @@ class BlockStructure(object):
         return self._check_gf_or_matrix(G, ish, space)
 
     def _check_gf_or_matrix(self, G, ish=None, space='solver'):
-
         if space == 'solver':
             gf_struct = self.gf_struct_solver
         elif space == 'sumk':
diff --git a/python/sumk_dft.py b/python/sumk_dft.py
index 69d95640..7408cce2 100644
--- a/python/sumk_dft.py
+++ b/python/sumk_dft.py
@@ -1401,8 +1401,10 @@ class SumkDFT(object):
         if write_to_blockstructure:
             if self.block_structure.transformation == None:
                 self.block_structure.transformation = [{} for icrsh in range(self.n_corr_shells)]
-                for sp in self.spin_block_names[self.corr_shells[icrsh]['SO']]:
-                    self.block_structure.transformation[icrsh][sp] = numpy.eye(self.corr_shells[icrsh]['dim'], self.corr_shells[icrsh]['dim'], numpy.complex_)
+                for icrsh in range(self. n_corr_shells):
+                    for sp in self.spin_block_names[self.corr_shells[icrsh]['SO']]:
+                        self.block_structure.transformation[icrsh][sp] = numpy.eye(self.corr_shells[icrsh]['dim'], dtype=numpy.complex_)
+
         
             self.block_structure.transformation[ish] = trafo