#-----------------------------------------------------
def InverseFourier(self, time_min =None) :
"""
Returns a GfReTime containing the Inverse Fourier transform of self
time_min is the minimal time. By default the time window is centered around 0
"""
import gf_retime
(a,b),N = list(self.mesh)[0:2], len(self.mesh)
om0 = b-a
if time_min !=None :
time_max = time_min + 2* pi/om0
else :
time_max = pi/om0
time_min = -time_max
gt = gf_retime.GfReTime( indices = self.indices, beta = self.beta,
statistic = self.statistic,
time_min = time_min, time_max = time_max, n_time_points = N )
gt.set_from_inverse_fourier(self)
return gt
#-----------------------------------------------------
# Register the class for HDFArchive
#-----------------------------------------------------
from pytriqs.base.archive.hdf_archive_schemes import register_class
register_class (GfReFreq)
def __check_attr(self,ATTR) :
if not hasattr(self._first(), ATTR ) :
raise RuntimeError, "The blocks of this Green Function do not possess the %s method"%ATTR
def invert(self) :
"""Inverse all the blocks"""
self.__check_attr("invert")
for i,g in self : g.invert()
def delta(self) :
"""Compute delta from G0"""
self.__check_attr("delta")
return self.__class__( name_block_generator = [ (n, g.delta()) for n,g in self], make_copies=False)
def transpose(self):
"""Transpose of the BlockGf"""
self.__check_attr("transpose")
return self.__class__( name_block_generator = [ (n, g.transpose()) for n,g in self], make_copies=False)
def conjugate(self):
"""Conjugate of the BlockGf"""
self.__check_attr("conjugate")
return self.__class__( name_block_generator = [ (n, g.conjugate()) for n,g in self], make_copies=False)
#---------------------------------------------------------
from pytriqs.base.archive.hdf_archive_schemes import register_class
register_class (BlockGf)
"""
assert callable(function), "function is not callable"
self.function,self.x_min,self.x_max = function,x_min,x_max
try :
e = function(0.001)
len(numpy.array(e).shape) ==1
except :
raise RuntimeError , "Value of the function must be a 1d-array"
self.__f(n_pts) # compute arrays
DOS.__init__(self,self.eps,self.rho,name)
#-------------------------------------------------------------
def __reduce__(self) :
return self.__class__, (self.function,self.x_min, self.x_max, len(self.eps), self.name)
#-------------------------------------------------------------
def __f(self,N) :
r = (self.x_max - self.x_min)/float(N-1)
self.eps = numpy.array( [self.x_min + r* i for i in range(N) ] )
self.rho = numpy.array( [self.function(e) for e in self.eps])
#-----------------------------------------------------
# Register the class for HDFArchive
#-----------------------------------------------------
from pytriqs.base.archive.hdf_archive_schemes import register_class
register_class (DOS)
return [{'type' : "XY",
'xlabel' : xlabel,
'ylabel' : ylabel (self.name),
'xdata' : X[sl],
'label' : Name if Name else prefix + B.name ,
'ydata' : f( B._data.array[0,0,sl] ) } for (i,j,B) in self ]
if use_ris :
ris = opt_dict.pop('RI','RI')
if ris == "R" :
res = mdic( 'Re ', lambda x : x.real)
elif ris == "I" :
res = mdic( 'Im ', lambda x : x.imag)
elif ris == "S" :
res = mdic( '', lambda x : -1/numpy.pi *x.imag)
elif ris == 'RI' :
res = mdic( 'Re ', lambda x : x.real) + mdic( 'Im ', lambda x : x.imag)
else :
raise ValueError, "RIS flags meaningless %s"%ris
else:
res = mdic( '', lambda x : x)
if NamePrefix: self.name = name_save
return res
#-----------------------------------------------------
from pytriqs.base.archive.hdf_archive_schemes import register_class
register_class (TailGf)
register_class (MeshGf)
import gf_refreq
om0 = 2*pi/(self.time_max - self.time_min)
N = self.Npts
gw = gf_refreq.GfReFreq(indices = self.indices,beta = self.beta,
statistic = self.statistic,
MeshArray = numpy.array([ om0*i for i in range (- (N/2),N/2)]))
gw.set_from_fourier(self)
return gw
#-----------------------------------------------------
def _plot_(self, OptionsDict):
""" Plot protocol. OptionsDict can contain :
* :param RI: 'R', 'I', 'RI' [ default]
* :param x_window: (xmin,xmax) or None [default]
* :param name: a string [default ='']. If not '', it remplaces the name of the function just for this plot.
"""
M = [x for x in self.mesh]
return self._plot_base( OptionsDict, r'$t$', lambda name : r'%s$(t)$'%name, True, M)
#-----------------------------------------------------
# Register the class for HDFArchive
#-----------------------------------------------------
from pytriqs.base.archive.hdf_archive_schemes import register_class
register_class (GfReTime)
return tuple([x for (n, x) in sorted(D.items())])
class PythonDictWrap:
def __init__(self, ob):
self.ob = ob
def __reduce_to_dict__(self):
return dict([(str(n), v) for (n, v) in self.ob.items()])
@classmethod
def __factory_from_dict__(cls, D):
return dict([(n, x) for (n, x) in D.items()])
register_class(PythonListWrap)
register_class(PythonTupleWrap)
register_class(PythonDictWrap)
# -------------------------------------------
#
# A view of a subgroup of the archive
#
# --------------------------------------------
class HDFArchiveGroup(HDFArchiveGroupBasicLayer):
"""
"""
_wrappedType = {type([]): PythonListWrap, type(()): PythonTupleWrap, type({}): PythonDictWrap}
# This is the function to be minimized, the diff between the original
# data in values and the fitting function
def fct(p):
y_fct = 1.0*f_known
for order in range(len_param):
y_fct += p[order]*omegas**(1-len(known_coef[n1][n2])-order)
y_fct -= values[n1,n2,:]
return abs(y_fct)
# Now call the minimizing function
sol = leastsq(fct, p0, maxfev=1000*len_param)
# Put the known and the new found moments in the tail
for order in range(len(known_coef[n1][n2])):
self._tail[order-1][indR,indL] = [[ known_coef[n1][n2][order] ]]
for order, moment in enumerate(sol[0]):
self._tail[len(known_coef[n1][n2])+order-1][indR,indL] = [[ moment ]]
# Replace then end of the Green's function by the tail
if replace_tail: self.replace_by_tail(ninit);
#-----------------------------------------------------
# Register the class for HDFArchive
#-----------------------------------------------------
from pytriqs.base.archive.hdf_archive_schemes import register_class
register_class (GfImFreq)
#-----------------------------------------------------
def copy_and_truncate(self, Nleg):
""" Copies the Legendre Green's function and truncates it down
Parameters
----------
Nleg : int
remaining number of Legendre coefficients after truncation
"""
new_g = self.__class__(indicesL = self._indicesL,
indicesR = self._indicesR,
beta = self.beta,
statistic = self.statistic,
n_legendre_coeffs = Nleg,
name = self.name, note = self.note)
new_g._data.array[:,:,:] = self._data.array[:,:,0:Nleg]
new_g.determine_tail()
return new_g
#-----------------------------------------------------
# Register the class for HDFArchive
#-----------------------------------------------------
from pytriqs.base.archive.hdf_archive_schemes import register_class
register_class (GfLegendre)
