Esempio n. 1
0
    def __init__(self,beta,U_int,J_hund,l,n_msb=1025,T=None, use_spin_orbit=False, verbosity=0):
        #If T is specified, it is used to transform the Basis set

        Nlm=2*l+1
        if (use_spin_orbit):
            # no blocks!
            GFstruct = [ ('ud', range(2*Nlm)) ]
        else:
            # up/down blocks:
            GFstruct = [ ('up', range(Nlm)), ('down', range(Nlm)) ]
        
        # U matrix:
        #l = (Nlm-1)/2
        Umat = Umatrix(U_interact=U_int, J_hund=J_hund, l=l)  
        Umat(T=T)
        Umat.reduce_matrix()
        assert (Umat.N==Umat.Nmat),"Transformation that mixes spins is not implemented in hubbard_I Solver!!"
        # now we have the reduced matrices U and Up

        SolverBaseHub.__init__(self, Beta=beta, GFstruct=GFstruct, Nlm=Nlm, Nmsb = n_msb, UseSpinOrbit = use_spin_orbit, Verbosity=verbosity)
        
        self.ur = Umat.Ufull
        self.umn  = Umat.Up             # reduced matrix, opposite spins
        self.ujmn = Umat.U              # reduced matrix, same spins


        # Define Atomic Levels Dictionary according to the GF Bloc Structure
        self.Eff_Atomic_Levels = {}
        for a,al in GFstruct:
            if (self.UseSpinOrbit):
                self.Eff_Atomic_Levels[a] = numpy.zeros([self.Nlm*2,self.Nlm*2],numpy.complex_)
            else:
                self.Eff_Atomic_Levels[a] = numpy.zeros([self.Nlm,self.Nlm],numpy.complex_)
Esempio n. 2
0
#
# 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/>.
#
################################################################################

from pytriqs.base.archive import *
import numpy
from pytriqs.dft.U_matrix import Umatrix

U = Umatrix(U_interact = 2.0, J_hund = 0.5, l=2)

T = numpy.zeros([5,5],numpy.complex_)
sqtwo = 1.0/numpy.sqrt(2.0)
T[0,0] = 1j*sqtwo
T[0,4] = -1j*sqtwo
T[1,1] = -1j*sqtwo
T[1,3] = -1j*sqtwo
T[2,2] = 1.0
T[3,1] = -sqtwo
T[3,3] = sqtwo
T[4,0] = sqtwo
T[4,4] = sqtwo

U(T=T)