def solve(self, U_interact=None, J_hund=None, use_spinflip=False,
use_matrix = True, l=2, T=None, dim_reps=None, irep=None, deg_orbs = [], sl_int = None, **params):
self.use_spinflip = use_spinflip
self.U, self.Up, self.U4ind, self.offset = set_U_matrix(U_interact,J_hund,self.n_orb,l,use_matrix,T,sl_int,use_spinflip,dim_reps,irep)
# define mapping of indices:
self.map_ind={}
for nm in self.map:
bl_names = self.map[nm]
block = []
for a,al in self.gf_struct:
if a in bl_names: block.append(al)
self.map_ind[nm] = range(self.n_orb)
i = 0
for al in block:
cnt = 0
for a in range(len(al)):
self.map_ind[nm][i] = cnt
i = i+1
cnt = cnt+1
# set the Hamiltonian
if (use_spinflip==False):
Hamiltonian = self.__set_hamiltonian_density()
else:
if (use_matrix):
#Hamiltonian = self.__set_full_hamiltonian_slater()
Hamiltonian = self.__set_spinflip_hamiltonian_slater()
else:
Hamiltonian = self.__set_full_hamiltonian_kanamori(J_hund = J_hund)
# set the Quantum numbers
Quantum_Numbers = self.__set_quantum_numbers(self.gf_struct)
# Determine if there are only blocs of size 1:
self.blocssizeone = True
for ib in self.gf_struct:
if (len(ib[1])>1): self.blocssizeone = False
nc = params.pop("n_cycles",10000)
if ((self.blocssizeone) and (self.use_spinflip==False)):
use_seg = True
else:
use_seg = False
#gm = self.set_global_moves(deg_orbs)
Solver.solve(self,H_local = Hamiltonian, quantum_numbers = Quantum_Numbers, n_cycles = nc, use_segment_picture = use_seg, **params)
def __init__(self, beta, n_orb, gf_struct = False, map = False):
self.n_orb = n_orb
# either get or construct gf_struct
if (gf_struct):
assert map, "give also the mapping!"
self.map = map
else:
# standard gf_struct and map
gf_struct = [ ('%s'%(ud),[n for n in range(n_orb)]) for ud in ['up','down'] ]
self.map = {'up' : ['up' for v in range(n_orb)], 'down' : ['down' for v in range(n_orb)]}
# now initialize the solver with the stuff given above:
Solver.__init__(self, beta = beta, gf_struct = gf_struct)
from pytriqs.archive import HDFArchive
from pytriqs.gf.local import *
#
# Example of DMFT single site solution with CTQMC
#
# set up a few parameters
Half_Bandwidth= 1.0
U = 2.5
Chemical_Potential = U/2.0
beta = 100
# Construct a CTQMC solver
from pytriqs.applications.impurity_solvers.cthyb_matrix import Solver
S = Solver(beta = beta, gf_struct = [ ('up',[1]), ('down',[1]) ])
# init the Green function
S.G <<= SemiCircular(Half_Bandwidth)
# Impose Paramagnetism
g = 0.5*(S.G['up']+S.G['down'])
for name, bloc in S.G : bloc <<= g
# Compute G0
for sig,g0 in S.G0 :
g0 <<= inverse( iOmega_n + Chemical_Potential - (Half_Bandwidth/2.0)**2 * S.G[sig] )
# Solve
#from pytriqs.applications.impurity_solvers.operators import *
from pytriqs.operators import *
from pytriqs.gf.local import *
from pytriqs.operators import *
from pytriqs.applications.impurity_solvers.cthyb_matrix import Solver
# Parameters
D, V, U = 1.0, 0.2, 4.0
e_f, beta = -U/2.0, 50
# Construct the impurity solver with the inverse temperature
# and the structure of the Green's functions
S = Solver(beta = beta, gf_struct = [ ('up',[1]), ('down',[1]) ])
# Initialize the non-interacting Green's function S.G0
for spin, g0 in S.G0 :
g0 <<= inverse( iOmega_n - e_f - V**2 * Wilson(D) )
# Run the solver. The result will be in S.G
S.solve(H_local = U * N('up',1) * N('down',1), # Local Hamiltonian
quantum_numbers = { # Quantum Numbers
'Nup' : N('up',1), # Operators commuting with H_Local
'Ndown' : N('down',1) },
n_cycles = 500000, # Number of QMC cycles
length_cycle = 200, # Length of one cycle
n_warmup_cycles = 10000, # Warmup cycles
n_legendre = 50, # Number of Legendre coefficients
random_name = 'mt19937', # Name of the random number generator
use_segment_picture = True, # Use the segment picture
measured_operators = { # Operators to be averaged
'Nimp' : N('up',1)+N('down',1) }
)
from pytriqs.gf.local import *
from pytriqs.operators import *
from pytriqs.archive import HDFArchive
from pytriqs.applications.impurity_solvers.cthyb_matrix import Solver
import pytriqs.utility.mpi as mpi
D, V, U = 1.0, 0.2, 4.0
e_f, beta = -U / 2.0, 50
# Construct the impurity solver
S = Solver(beta=beta, gf_struct=[('up', [1]), ('down', [1])])
# Loop for two random generators
for random_name in ['mt11213b', 'lagged_fibonacci607']:
for spin, g0 in S.G0:
g0 <<= inverse(iOmega_n - e_f - V**2 * Wilson(D))
# Solve using random_name as a generator
S.solve(
H_local=U * N('up', 1) * N('down', 1), # Local Hamiltonian
quantum_numbers={ # Quantum Numbers
'Nup': N('up', 1), # (operators commuting with H_Local)
'Ndown': N('down', 1)
},
n_cycles=100000, # Number of QMC cycles
length_cycle=200, # Length of one cycle
n_warmup_cycles=10000, # Warmup cycles
random_name=random_name, # Name of the random generator
use_segment_picture=True) # Use the segment picture
from pytriqs.gf.local import *
from pytriqs.operators import *
from pytriqs.archive import *
import pytriqs.utility.mpi as mpi
# Set up a few parameters
U = 2.5
half_bandwidth = 1.0
chemical_potential = U / 2.0
beta = 100
n_loops = 5
# Construct the CTQMC solver
from pytriqs.applications.impurity_solvers.cthyb_matrix import Solver
S = Solver(beta=beta, gf_struct=[('up', [1]), ('down', [1])])
# Initalize the Green's function to a semi circular
S.G <<= SemiCircular(half_bandwidth)
# Now do the DMFT loop
for IterationNumber in range(n_loops):
# Compute S.G0 with the self-consistency condition while imposing paramagnetism
g = 0.5 * (S.G['up'] + S.G['down'])
for name, g0block in S.G0:
g0block <<= inverse(iOmega_n + chemical_potential -
(half_bandwidth / 2.0)**2 * g)
# Run the solver
S.solve(
H_local=U * N('up', 1) * N('down', 1), # Local Hamiltonian
Ntot = sum( [ N('%s%d'%(s,f),0) for s in spins for f in range(NCOR) ]);
Sz = sum( [ N('%s%d'%(spins[0],f),0) - N('%s%d'%(spins[1],f),0) for f in range(NCOR) ]);
Quantum_Numbers = { 'Ntot' : Ntot, 'Sztot' : Sz };
for f in range(NCOR):
Quantum_Numbers['Sz2_%d'%f] = N('%s%d'%(spins[0],f),0) + N('%s%d'%(spins[1],f),0) - 2*N('%s%d'%(spins[0],f),0)*N('%s%d'%(spins[1],f),0)
else:
Quantum_Numbers = {};
for sp in spins:
for f in range(NCOR): Quantum_Numbers['N%s%d'%(sp,f)] = N('%s%d'%(sp,f),0);
solver_parms['quantum_numbers'] = Quantum_Numbers;
solver_parms['use_segment_picture'] = int(parms['SPINFLIP']) == 0;
solver_parms['H_local'] = H_Local;
# create a solver object
solver = Solver(beta = BETA, gf_struct = GFstruct, n_w = int(val_def(parms, 'N_MATSUBARA', len(hyb_mat))));
# Legendre or Time accumulation
accumulation = val_def(parms, 'ACCUMULATION', 'time');
if accumulation not in ['time', 'legendre']: exit('ACCUMULATION should be either "time" or "legendre"');
if accumulation == 'time':
solver_parms['time_accumulation'] = True;
solver_parms['legendre_accumulation'] = False;
solver_parms['fit_start'] = len(hyb_mat)-10;
solver_parms['fit_stop'] = len(hyb_mat)-1; # I don't want to use the fitTails()
elif accumulation == 'legendre':
solver_parms['legendre_accumulation'] = True;
solver_parms['n_legendre'] = int(val_def(parms, 'N_LEGENDRE', 50));
from pytriqs.gf.local import *
from pytriqs.operators import *
from pytriqs.archive import *
import pytriqs.utility.mpi as mpi
# Set up a few parameters
U = 2.5
half_bandwidth = 1.0
chemical_potential = U / 2.0
beta = 100
n_loops = 5
# Construct the CTQMC solver
from pytriqs.applications.impurity_solvers.cthyb_matrix import Solver
S = Solver(beta=beta, gf_struct=[("up", [1]), ("down", [1])])
# Initalize the Green's function to a semi circular
S.G <<= SemiCircular(half_bandwidth)
# Now do the DMFT loop
for IterationNumber in range(n_loops):
# Compute S.G0 with the self-consistency condition while imposing paramagnetism
g = 0.5 * (S.G["up"] + S.G["down"])
for name, g0block in S.G0:
g0block <<= inverse(iOmega_n + chemical_potential - (half_bandwidth / 2.0) ** 2 * g)
# Run the solver
S.solve(
H_local=U * N("up", 1) * N("down", 1), # Local Hamiltonian
from pytriqs.gf.local import *
from pytriqs.operators import *
from pytriqs.archive import HDFArchive
from pytriqs.applications.impurity_solvers.cthyb_matrix import Solver
import pytriqs.utility.mpi as mpi
D, V, U = 1.0, 0.2, 4.0
e_f, beta = -U/2.0, 50
# Construct the impurity solver
S = Solver(beta = beta, gf_struct = [ ('up',[1]), ('down',[1]) ])
# Loop for two random generators
for random_name in ['mt11213b','lagged_fibonacci607']:
for spin, g0 in S.G0 :
g0 <<= inverse( iOmega_n - e_f - V**2 * Wilson(D) )
# Solve using random_name as a generator
S.solve(H_local = U * N('up',1) * N('down',1), # Local Hamiltonian
quantum_numbers = { # Quantum Numbers
'Nup' : N('up',1), # (operators commuting with H_Local)
'Ndown' : N('down',1) },
n_cycles = 100000, # Number of QMC cycles
length_cycle = 200, # Length of one cycle
n_warmup_cycles = 10000, # Warmup cycles
random_name = random_name, # Name of the random generator
use_segment_picture = True) # Use the segment picture
# Save the results in an hdf5 file (only on the master node)
if mpi.is_master_node():
from pytriqs.archive import HDFArchive
from pytriqs.gf.local import *
#
# Example of DMFT single site solution with CTQMC
#
# set up a few parameters
Half_Bandwidth = 1.0
U = 2.5
Chemical_Potential = U / 2.0
beta = 100
# Construct a CTQMC solver
from pytriqs.applications.impurity_solvers.cthyb_matrix import Solver
S = Solver(beta=beta, gf_struct=[('up', [1]), ('down', [1])])
# init the Green function
S.G <<= SemiCircular(Half_Bandwidth)
# Impose Paramagnetism
g = 0.5 * (S.G['up'] + S.G['down'])
for name, bloc in S.G:
bloc <<= g
# Compute G0
for sig, g0 in S.G0:
g0 <<= inverse(iOmega_n + Chemical_Potential -
(Half_Bandwidth / 2.0)**2 * S.G[sig])
# Solve
from pytriqs.gf.local import *
from pytriqs.operators import *
from pytriqs.applications.impurity_solvers.cthyb_matrix import Solver
# parameters
D, V, U = 1.0, 0.2, 4.0
e_f, beta = -U / 2.0, 50
# construct the impurity solver with the inverse temperature
# and the structure of the Green's functions
S = Solver(beta=beta, gf_struct=[('up', [1]), ('down', [1])])
# Initialize the non-interacting Green's function S.G0
for spin, g0 in S.G0:
g0 <<= inverse(iOmega_n - e_f - V**2 * Wilson(D))
# run the solver. The result will be in S.G
S.solve(
H_local=U * N('up', 1) * N('down', 1), # Local Hamiltonian
quantum_numbers={ # Quantum Numbers
'Nup': N('up', 1), # Operators commuting with H_Local
'Ndown': N('down', 1)
},
n_cycles=20000, # Number of QMC cycles
length_cycle=20, # Length of one cycle
n_warmup_cycles=1000, # Warmup cycles
n_legendre=50, # Number of Legendre coefficients
random_name='mt19937', # Name of the random number generator
use_segment_picture=True, # Use the segment picture
measured_operators={ # Operators to be averaged
'Nimp': N('up', 1) + N('down', 1)
