def init( mesh=None, shape=None, name='g', **kwargs): """ """ if mesh is None: from gf import MeshImFreq if 'beta' not in kwargs: raise ValueError, "beta not provided" beta = float(kwargs.pop('beta')) n_points = kwargs.pop('n_points',1025) stat = kwargs.pop('statistic','Fermion') positive_only = kwargs.pop('positive_only',True) mesh = MeshImFreq(beta,stat,n_points, positive_only) indices_pack = get_indices_in_dict(kwargs) if not shape: assert indices_pack, "No shape, no indices !" indicesL, indicesR = indices_pack shape = len(indicesL),len(indicesR) if kwargs: raise ValueError, "GfImFreq: Unused parameters %s were passed."%kwargs.keys() # FIXME why is this here and uncommented? #data = kwargs.pop('data') if 'data' in kwargs else numpy.zeros((len(mesh),N1,N2), self.dtype ) #tail = kwargs.pop('tail') if 'tail' in kwargs else TailGf(shape = (N1,N2)) #symmetry = kwargs.pop('symmetry', Nothing()) #return mesh, data, tail, symmetry, indices_pack, name return (mesh, shape, indices_pack, name), {}
def init(mesh=None, shape=None, name='g', **kwargs): """ """ if mesh is None: from gf import MeshImTime if 'beta' not in kwargs: raise ValueError, "beta not provided" beta = float(kwargs.pop('beta')) n_max = kwargs.pop('n_points', 10000) stat = kwargs.pop('statistic', 'Fermion') mesh = MeshImTime(beta, stat, n_max) indices_pack = get_indices_in_dict(kwargs) if not shape: assert indices_pack, "No shape, no indices !" indicesL, indicesR = indices_pack shape = len(indicesL), len(indicesR) if kwargs: raise ValueError, "GfImTime: Unused parameters %s were passed." % kwargs.keys( ) # FIXME #data = kwargs.pop('data') if 'data' in kwargs else numpy.zeros((len(mesh),N1,N2), self.dtype ) #tail = kwargs.pop('tail') if 'tail' in kwargs else TailGf(shape = (N1,N2)) #symmetry = kwargs.pop('symmetry', Nothing()) return (mesh, shape, indices_pack, name), {}
def init(mesh=None, shape=None, name='g', **kwargs): """ """ if mesh is None: from gf import MeshReTime window = kwargs.pop('window') t_min = window[0] t_max = window[1] n_max = kwargs.pop('n_points', 10000) mesh = MeshReTime(t_min, t_max, n_max) indices_pack = get_indices_in_dict(kwargs) if not shape: assert indices_pack, "No shape, no indices !" indicesL, indicesR = indices_pack shape = len(indicesL), len(indicesR) if kwargs: raise ValueError, "GfReFreq: Unused parameters %s were passed." % kwargs.keys( ) #data = kwargs.pop('data') if 'data' in kwargs else numpy.zeros((len(mesh),N1,N2), self.dtype ) #tail = kwargs.pop('tail') if 'tail' in kwargs else TailGf(shape = (N1,N2)) #symmetry = kwargs.pop('symmetry', Nothing()) return (mesh, shape, indices_pack, name), {}
def init( mesh = None, shape = None, name = 'g', **kwargs): """ """ if mesh is None: from gf import MeshImTime if 'beta' not in kwargs: raise ValueError, "beta not provided" beta = float(kwargs.pop('beta')) n_max = kwargs.pop('n_points',10000) stat = kwargs.pop('statistic','Fermion') mesh = MeshImTime(beta,stat,n_max) indices_pack = get_indices_in_dict(kwargs) if not shape: assert indices_pack, "No shape, no indices !" indicesL, indicesR = indices_pack shape = len(indicesL),len(indicesR) if kwargs: raise ValueError, "GfImTime: Unused parameters %s were passed."%kwargs.keys() # FIXME #data = kwargs.pop('data') if 'data' in kwargs else numpy.zeros((len(mesh),N1,N2), self.dtype ) #tail = kwargs.pop('tail') if 'tail' in kwargs else TailGf(shape = (N1,N2)) #symmetry = kwargs.pop('symmetry', Nothing()) return (mesh, shape, indices_pack, name), {}
def __init__(self, **d): """ The constructor have two variants : you can either provide the mesh in Matsubara frequencies yourself, or give the parameters to build it. All parameters must be given with keyword arguments. GfImFreq(indices, beta, statistic, n_points, data, tail, name) * ``indices``: a list of indices names of the block * ``beta``: Inverse Temperature * ``statistic``: 'F' or 'B' * ``positive_only``: True or False * ``n_points``: Number of Matsubara frequencies * ``data``: A numpy array of dimensions (len(indices),len(indices),n_points) representing the value of the Green function on the mesh. * ``tail``: the tail * ``name``: a name of the GF GfImFreq(indices, mesh, data, tail, name) * ``indices``: a list of indices names of the block * ``mesh``: a MeshGf object, such that mesh.TypeGF== GF_Type.Imaginary_Frequency * ``data``: A numpy array of dimensions (len(indices),len(indices),:) representing the value of the Green function on the mesh. * ``tail``: the tail * ``name``: a name of the GF .. warning:: The Green function take a **view** of the array data, and a **reference** to the tail. """ mesh = d.pop('mesh', None) if mesh is None: if 'beta' not in d: raise ValueError, "beta not provided" beta = float(d.pop('beta')) n_points = d.pop('n_points', 1025) stat = d.pop('statistic', 'F') positive_only = d.pop('positive_only', True) mesh = MeshImFreq(beta, stat, n_points, positive_only) self.dtype = numpy.complex_ indices_pack = get_indices_in_dict(d) indicesL, indicesR = indices_pack N1, N2 = len(indicesL), len(indicesR) data = d.pop('data') if 'data' in d else numpy.zeros( (len(mesh), N1, N2), self.dtype) tail = d.pop('tail') if 'tail' in d else TailGf(shape=(N1, N2)) symmetry = d.pop('symmetry', Nothing()) name = d.pop('name', 'g') assert len( d ) == 0, "Unknown parameters in GFBloc constructions %s" % d.keys() GfGeneric.__init__(self, mesh, data, tail, symmetry, indices_pack, name, GfImFreq) GfImFreq_cython.__init__(self, mesh, data, tail)
def __init__(self, **d): """ The constructor have two variants : you can either provide the mesh in Matsubara frequencies yourself, or give the parameters to build it. All parameters must be given with keyword arguments. GfReTime(indices, window, n_points, data, tail, name) * ``indices``: a list of indices names of the block * ``window``: a tuple (t_min, t_max) * ``n_points`` : Number of time points in the mesh * ``data``: A numpy array of dimensions (len(indices),len(indices),n_points) representing the value of the Green function on the mesh. * ``tail``: the tail * ``name``: a name of the GF GfReTime (indices, mesh, data, tail, name) * ``indices``: a list of indices names of the block * ``mesh``: a MeshGf object, such that mesh.TypeGF== GF_Type.Imaginary_Time * ``data``: A numpy array of dimensions (len(indices),len(indices),n_points) representing the value of the Green function on the mesh. * ``tail``: the tail * ``name``: a name of the GF .. warning:: The Green function take a **view** of the array data, and a **reference** to the tail. """ mesh = d.pop('mesh', None) if mesh is None: window = d.pop('window') t_min = window[0] t_max = window[1] n_max = d.pop('n_points', 10000) kind = d.pop('kind', 'F') mesh = MeshReTime(t_min, t_max, n_max, kind) self.dtype = numpy.complex_ indices_pack = get_indices_in_dict(d) indicesL, indicesR = indices_pack N1, N2 = len(indicesL), len(indicesR) data = d.pop('data') if 'data' in d else numpy.zeros( (len(mesh), N1, N2), self.dtype) tail = d.pop('tail') if 'tail' in d else TailGf(shape=(N1, N2)) symmetry = d.pop('symmetry', None) name = d.pop('name', 'g') assert len( d ) == 0, "Unknown parameters in GFBloc constructions %s" % d.keys() GfGeneric.__init__(self, mesh, data, tail, symmetry, indices_pack, name, GfReTime) GfReTime_cython.__init__(self, mesh, data, tail)
def __init__(self, **d): """ The constructor have two variants : you can either provide the mesh in Matsubara frequencies yourself, or give the parameters to build it. All parameters must be given with keyword arguments. GfImFreq(indices, beta, statistic, n_points, data, tail, name) * ``indices``: a list of indices names of the block * ``beta``: Inverse Temperature * ``statistic``: 'F' or 'B' * ``positive_only``: True or False * ``n_points``: Number of Matsubara frequencies * ``data``: A numpy array of dimensions (len(indices),len(indices),n_points) representing the value of the Green function on the mesh. * ``tail``: the tail * ``name``: a name of the GF GfImFreq(indices, mesh, data, tail, name) * ``indices``: a list of indices names of the block * ``mesh``: a MeshGf object, such that mesh.TypeGF== GF_Type.Imaginary_Frequency * ``data``: A numpy array of dimensions (len(indices),len(indices),:) representing the value of the Green function on the mesh. * ``tail``: the tail * ``name``: a name of the GF .. warning:: The Green function take a **view** of the array data, and a **reference** to the tail. """ mesh = d.pop('mesh',None) if mesh is None : if 'beta' not in d : raise ValueError, "beta not provided" beta = float(d.pop('beta')) n_points = d.pop('n_points',1025) stat = d.pop('statistic','F') positive_only = d.pop('positive_only',True) mesh = MeshImFreq(beta,stat,n_points, positive_only) self.dtype = numpy.complex_ indices_pack = get_indices_in_dict(d) indicesL, indicesR = indices_pack N1, N2 = len(indicesL),len(indicesR) data = d.pop('data') if 'data' in d else numpy.zeros((len(mesh),N1,N2), self.dtype ) tail = d.pop('tail') if 'tail' in d else TailGf(shape = (N1,N2)) symmetry = d.pop('symmetry', Nothing()) name = d.pop('name','g') assert len(d) ==0, "Unknown parameters in GFBloc constructions %s"%d.keys() GfGeneric.__init__(self, mesh, data, tail, symmetry, indices_pack, name, GfImFreq) GfImFreq_cython.__init__(self, mesh, data, tail)
def __init__(self, **d): """ The constructor have two variants : you can either provide the mesh in Matsubara frequencies yourself, or give the parameters to build it. All parameters must be given with keyword arguments. GfTwoRealTime(indices, window, n_points, data, tail, name) * ``indices``: a list of indices names of the block * ``window``: a tuple (t_min, t_max) * ``n_points`` : Number of time points in the mesh * ``data``: A numpy array of dimensions (len(indices),len(indices),n_points) representing the value of the Green function on the mesh. * ``tail``: the tail * ``name``: a name of the GF GfReTime (indices, mesh, data, tail, name) * ``indices``: a list of indices names of the block * ``mesh``: a MeshGf object, such that mesh.TypeGF== GF_Type.Imaginary_Time * ``data``: A numpy array of dimensions (len(indices),len(indices),n_points) representing the value of the Green function on the mesh. * ``tail``: the tail * ``name``: a name of the GF .. warning:: The Green function take a **view** of the array data, and a **reference** to the tail. """ mesh = d.pop('mesh',None) if mesh is None : window = d.pop('window') t_min = window[0] t_max = window[1] n_max = d.pop('n_points',10000) kind = d.pop('kind','F') mesh = MeshTwoRealTime(t_max, n_max) #mesh = MeshTwoRealTime(t_min, t_max, n_max) #mesh = MeshReTime(t_min, t_max, n_max, 'F') self.dtype = numpy.complex_ indices_pack = get_indices_in_dict(d) indicesL, indicesR = indices_pack N1, N2 = len(indicesL),len(indicesR) data = d.pop('data') if 'data' in d else numpy.zeros((len(mesh),N1,N2), self.dtype ) symmetry = d.pop('symmetry',None) name = d.pop('name','g') assert len(d) ==0, "Unknown parameters in GfTwoRealTime constructions %s"%d.keys() GfGeneric.__init__(self, mesh, data, None, symmetry, indices_pack, name, GfTwoRealTime) GfTwoRealTime_cython.__init__(self, mesh, data)
def __init__(self, **d): """ The constructor have two variants : you can either provide the mesh in Matsubara frequencies yourself, or give the parameters to build it. All parameters must be given with keyword arguments. GfImTime(indices, beta, statistic, n_time_points, data, tail, name) * ``indices``: a list of indices names of the block * ``beta``: Inverse Temperature * ``statistic``: 'F' or 'B' * ``n_time_points`` : Number of time points in the mesh * ``data``: A numpy array of dimensions (len(indices),len(indices),n_time_points) representing the value of the Green function on the mesh. * ``tail``: the tail * ``name``: a name of the GF If you already have the mesh, you can use a simpler version : GfImTime (indices, mesh, data, tail, name) * ``indices``: a list of indices names of the block * ``mesh``: a MeshGf object, such that mesh.TypeGF== GF_Type.Imaginary_Time * ``data``: A numpy array of dimensions (len(indices),len(indices),n_time_points) representing the value of the Green function on the mesh. * ``tail``: the tail * ``name``: a name of the GF .. warning:: The Green function take a **view** of the array data, and a **reference** to the tail. """ mesh = d.pop('mesh',None) if mesh is None : if 'beta' not in d : raise ValueError, "beta not provided" beta = float(d.pop('beta')) stat = d.pop('statistic','F') n_max = d.pop('n_time_points',10000) kind = d.pop('kind','H') mesh = MeshImTime(beta,stat,n_max,kind) self.dtype = numpy.float64 indicesL, indicesR = get_indices_in_dict(d) N1, N2 = len(indicesL),len(indicesR) data = d.pop('data') if 'data' in d else numpy.zeros((N1,N2,len(mesh)), self.dtype ) tail= d.pop('tail') if 'tail' in d else TailGf(shape = (N1,N2), size=10, order_min=-1) symmetry = d.pop('symmetry',None) name = d.pop('name','g') assert len(d) ==0, "Unknown parameters in GFBloc constructions %s"%d.keys() GfImTime_cython.__init__(self, mesh, data, tail, symmetry, (indicesL,indicesR), name)
def init( mesh = None, shape = None, name = 'g', **kwargs): """ """ if mesh is None: from gf import MeshReTime window = kwargs.pop('window') t_min = window[0] t_max = window[1] n_max = kwargs.pop('n_points',10000) mesh = MeshReTime(t_min, t_max, n_max) indices_pack = get_indices_in_dict(kwargs) if not shape: assert indices_pack, "No shape, no indices !" indicesL, indicesR = indices_pack shape = len(indicesL),len(indicesR) if kwargs: raise ValueError, "GfReFreq: Unused parameters %s were passed."%kwargs.keys() #data = kwargs.pop('data') if 'data' in kwargs else numpy.zeros((len(mesh),N1,N2), self.dtype ) #tail = kwargs.pop('tail') if 'tail' in kwargs else TailGf(shape = (N1,N2)) #symmetry = kwargs.pop('symmetry', Nothing()) return (mesh, shape, indices_pack, name), {}