import GFBloc_ReFreq om0 = 2*pi/(self.TimeMax - self.TimeMin) N = self.Npts gw = GFBloc_ReFreq.GFBloc_ReFreq(Indices = self.Indices,Beta = self.Beta, Statistic = self.Statistic, MeshArray = numpy.array([ om0*i for i in range (- (N/2),N/2)])) gw.setFromFourierOf(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 HDF_Archive #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class (GFBloc_ReTime)
# 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 GF by the tail if replaceTail: self.replaceByTail(ninit); #----------------------------------------------------- # Register the class for HDF_Archive #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class (GFBloc_ImFreq)
def InverseFourier(self, TimeMin=None): """ Returns a GFBloc_ReTime containing the Inverse Fourier transform of self TimeMin is the minimal time. By default the time window is centered around 0 """ import GFBloc_ReTime (a, b), N = list(self.mesh)[0:2], len(self.mesh) om0 = b - a if TimeMin != None: TimeMax = TimeMin + 2 * pi / om0 else: TimeMax = pi / om0 TimeMin = -TimeMax gt = GFBloc_ReTime.GFBloc_ReTime(Indices=self.Indices, Beta=self.Beta, Statistic=self.Statistic, TimeMin=TimeMin, TimeMax=TimeMax, NTimeSlices=N) gt.setFromInverseFourierOf(self) return gt #----------------------------------------------------- # Register the class for HDF_Archive #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class(GFBloc_ReFreq)
numpy.array([ (n+0.5)*Beta/Nmax for n in range(Nmax)])) for a in [ 'Beta', 'Statistic', 'NTimeSlices'] : if a in d : del d[a] else : assert d['Mesh'].TypeGF==GF_Type.Imaginary_Time, "You provided a wrong type of mesh !!" self._init_base__(d) self._init_before_injection__(*self._param_for_cons) del self._param_for_cons #----------------------------------------------------- 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. """ has_complex_value = False M = [x for x in self.mesh] return self._plot_base( OptionsDict, r'$\tau$', lambda name : r'%s$(\tau)$'%name, has_complex_value , M) #----------------------------------------------------- # Register the class for HDF_Archive #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class (GFBloc_ImTime)
#----------------------------------------------------- def InverseFourier(self, TimeMin =None) : """ Returns a GFBloc_ReTime containing the Inverse Fourier transform of self TimeMin is the minimal time. By default the time window is centered around 0 """ import GFBloc_ReTime (a,b),N = list(self.mesh)[0:2], len(self.mesh) om0 = b-a if TimeMin !=None : TimeMax = TimeMin + 2* pi/om0 else : TimeMax = pi/om0 TimeMin = -TimeMax gt = GFBloc_ReTime.GFBloc_ReTime( Indices = self.Indices,Beta = self.Beta, Statistic = self.Statistic, TimeMin = TimeMin, TimeMax = TimeMax,NTimeSlices = N ) gt.setFromInverseFourierOf(self) return gt #----------------------------------------------------- # Register the class for HDF_Archive #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class (GFBloc_ReFreq)
def __reduce_to_dict__(self) : return dict( [ (_my_str(n),v) for (n,v) in enumerate (self.ob)]) @classmethod def __factory_from_dict__(cls,D) : 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 HDF_Archive_group (HDF_Archive_group_basic_layer) : """ """ _wrappedType = { type([]) : PythonListWrap, type(()) : PythonTupleWrap, type({}) : PythonDictWrap} _MaxLengthKey = 500
""" assert callable(Function), "Function is not callable" self.Function,self.xmin,self.xmax = Function,xmin,xmax 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(Npts) # compute arrays DOS.__init__(self,self.eps,self.rho,Name) #------------------------------------------------------------- def __reduce__(self) : return self.__class__, (self.Function,self.xmin, self.xmax, len(self.eps), self.Name) #------------------------------------------------------------- def __f(self,N) : r = (self.xmax - self.xmin)/float(N-1) self.eps = numpy.array( [self.xmin + r* i for i in range(N) ] ) self.rho = numpy.array( [self.Function(e) for e in self.eps]) #----------------------------------------------------- # Register the class for HDF_Archive #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class (DOS)
def __init__(self,l=None) : if l : self.b = l def __str__(self): return """ b = %s"""%(self.a,self.b) def __write_hdf5__(self,archive, path) : archive.write("%s"%path,self.b) def __read_hdf5__(self,archive, path) : self.b = archive.read ("%s"%path) from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class (test_p2) register_class (test_p2B) h = HDF_Archive('ExampleTestH5-2.output.h5','w') t1 = test_p2(1) t2 = test_p2(2) h['t'] = t1 h['t'] = t2 h['B'] = test_p2B(123) h = HDF_Archive('ExampleTestH5-2.output.h5','r') print h['t'] print h['B']
return self.__class__( Indices = list(self.Indices), Mesh = self.mesh, Data = self._data.array.conjugate(), Tail = self._tail.conjugate(self.mesh.TypeGF==GF_Type.Imaginary_Frequency), Name = self.Name+'*', Note = self.Note) #----------------------------------------------------- # Put it out a a free funciton in a module. Nothing to do here... # why is this here ??? def Delta(self) : """Computes Delta from self ....""" if self.mesh.TypeGF not in [GF_Type.Real_Frequency, GF_Type.Imaginary_Frequency] : raise RuntimeError, "Can not compute Delta for this GF" G0 = self if self._tail.OrderMin <=-1 else inverse(self) tmp = G0.copy() tmp <<= GF_Initializers.A_Omega_Plus_B(G0._tail[-1], G0._tail[0]) tmp -= G0 return tmp #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class (TailGF) register_class (MeshGF)
#----------------------------------------------------- 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, NLegendreCoeffs = 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 HDF_Archive #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class (GFBloc_ImLegendre)
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], Copy=False) def transpose(self): """Transpose of the GF""" self.__check_attr("transpose") return self.__class__( Name_Block_Generator = [ (n, g.transpose()) for n,g in self], Copy=False) def conjugate(self): """Conjugate of the GF""" self.__check_attr("conjugate") return self.__class__( Name_Block_Generator = [ (n, g.conjugate()) for n,g in self], Copy=False) #--------------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class (GF)
self.Function, self.xmin, self.xmax = Function, xmin, xmax 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(Npts) # compute arrays DOS.__init__(self, self.eps, self.rho, Name) #------------------------------------------------------------- def __reduce__(self): return self.__class__, (self.Function, self.xmin, self.xmax, len(self.eps), self.Name) #------------------------------------------------------------- def __f(self, N): r = (self.xmax - self.xmin) / float(N - 1) self.eps = numpy.array([self.xmin + r * i for i in range(N)]) self.rho = numpy.array([self.Function(e) for e in self.eps]) #----------------------------------------------------- # Register the class for HDF_Archive #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class(DOS)
# 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 GF by the tail if replaceTail: self.replaceByTail(ninit) #----------------------------------------------------- # Register the class for HDF_Archive #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class(GFBloc_ImFreq)
Indices=list(self.Indices), Mesh=self.mesh, Data=self._data.array.conjugate(), Tail=self._tail.conjugate( self.mesh.TypeGF == GF_Type.Imaginary_Frequency), Name=self.Name + '*', Note=self.Note) #----------------------------------------------------- # Put it out a a free funciton in a module. Nothing to do here... # why is this here ??? def Delta(self): """Computes Delta from self ....""" if self.mesh.TypeGF not in [ GF_Type.Real_Frequency, GF_Type.Imaginary_Frequency ]: raise RuntimeError, "Can not compute Delta for this GF" G0 = self if self._tail.OrderMin <= -1 else inverse(self) tmp = G0.copy() tmp <<= GF_Initializers.A_Omega_Plus_B(G0._tail[-1], G0._tail[0]) tmp -= G0 return tmp #----------------------------------------------------- from pytriqs.Base.Archive.HDF_Archive_Schemes import register_class register_class(TailGF) register_class(MeshGF)