Save a duplicate of the current ``stdout`` fd and initialise the thread.

Store ``the_stack`` (reversed) as the work list.

r""" Initialise the discrete sum-k container. The grid arrays (:attr:`hopping`, :attr:`bz_points`, :attr:`bz_weights`) are no

r""" Build the lattice-based discrete sum-k object and its k-grid. Parameters ---------- lattice : triqs.lattice.tigh

Cast to :class:`int`. Returns ------- int ``int(self.value)``.

In-place subtraction ``self -= arg``. Parameters ---------- arg : Gf, descriptor, lazy expression, scalar or numpy.ndarray

In-place lazy subtraction ``self -= y``. Parameters ---------- y : LazyExpr, descriptor or scalar Returns --

In-place block-wise subtraction ``self -= arg``. Parameters ---------- arg : Block2Gf, sequence, or anything accepted by :met

In-place block-wise subtraction ``self -= arg``. Parameters ---------- arg : BlockGf, sequence, or anything accepted by :meth

Iterate as ``((bn1, bn2), block_gf)`` pairs in row-major order. Yields ------ tuple of ((hashable, hashable), Gf)

Yield the per-block sub-descriptors. Yields ------ BaseBlock One sub-descriptor per block, in block order.

Iterate as ``(block_name, block_gf)`` pairs in construction order. Yields ------ tuple of (str, Gf) ``(name, bloc

Iterate over :attr:`m`, yielding ``mp.value`` for each mesh point. Returns ------- generator Generator of :attr:`

Iterate over composite mesh points. Returns ------- iterator Iterator over tuples of mesh points, one per factor

In-place scalar division ``self /= arg``. Parameters ---------- arg : scalar Divisor applied element-wise to ``se

In-place lazy division ``self /= y``. Parameters ---------- y : LazyExpr, descriptor or scalar Returns -----

In-place block-wise division ``self /= arg``. Parameters ---------- arg : sequence or scalar A sequence divides e

In-place block-wise division ``self /= arg``. Parameters ---------- arg : sequence or scalar A sequence divides e

Total number of blocks. Returns ------- int ``len(name_list1) * len(name_list2)``.

Number of blocks. Returns ------- int ``len(self.__GFlist)``.

r"""Total number of points in the product mesh. Returns ------- int Product of the sizes of the factor meshes,

r"""Lazy initialization / copy operator (``g << RHS``). Parameters ---------- A : Gf, descriptor or :class:`~triqs.gfs.lazy_e

r"""Lazy initialization / copy operator (``G << RHS``). Parameters ---------- A : Block2Gf, or per-block initializer

r"""Lazy initialization / copy operator (``G << RHS``). Parameters ---------- A : BlockGf, descriptor or Gf-compatible

Multiplication ``self * y`` (alias for :meth:`~triqs.gfs.gf.Gf.__matmul__`). For matrix-valued Green's functions this is the target-space

Build the lazy node ``self * y``. Parameters ---------- y : LazyExpr, descriptor or scalar Returns -------

Multiplication forwarded to :attr:`value`. Parameters ---------- x : object Right-hand side operand. Ret

r"""Multiplication by a scalar, computed after casting to :class:`complex`. Parameters ---------- other : complex-like

Unary minus ``-self``; returns a new :class:`~triqs.gfs.gf.Gf` with sign-flipped data. Returns ------- Gf

Unary minus ``-self``; returns a new :class:`~triqs.gfs.block2_gf.Block2Gf`. Returns ------- Block2Gf

Unary minus ``-self``; returns a new :class:`~triqs.gfs.block_gf.BlockGf`. Returns ------- BlockGf

Negation. Returns ------- object ``-self.value``.

Pop and return the next input from the stack.

r"""Exponentiation, computed after casting to :class:`complex`. Parameters ---------- other : complex-like Expone

Reflected addition ``y + self``; commutes with :meth:`~triqs.gfs.gf.Gf.__add__`. Parameters ---------- y : same as :meth:`~tr

Reflected lazy ``y + self``. Parameters ---------- y : LazyExpr, descriptor or scalar Returns -------

Reflected addition ``y + self``. Parameters ---------- y : same as :meth:`~triqs.gfs.block2_gf.Block2Gf.__add__` Ret

Reflected addition ``y + self``. Parameters ---------- y : same as :meth:`~triqs.gfs.block_gf.BlockGf.__add__` Retur

Right-hand addition. Parameters ---------- x : object Left-hand side operand. Returns -------

Right-hand addition; defers to :meth:`__add__`. Parameters ---------- other : MatsubaraFreq or complex-like Left-

Pickle hook. Returns ------- tuple ``(call_factory_from_dict, (cls, "", reduced_dict))`` where ``redu

Pickle support: returns the arguments needed to reconstruct this instance.

:func:`repr`-based rendering of the expression tree. Returns ------- str

Multi-line summary listing every block. Returns ------- str Header line followed by ``repr(g)`` for each block.

REPL representation; identical to :meth:`__str__`. Returns ------- str Same string as :meth:`__str__`.

REPL representation listing each factor mesh. Returns ------- str String of the form ``"MeshProduct of :<repr m1>

Reflected multiplication ``y * self``. Parameters ---------- y : scalar or numpy.ndarray Returns -------

Reflected lazy ``y * self``. Parameters ---------- y : LazyExpr, descriptor or scalar Returns -------

Reflected multiplication ``x * self``. Parameters ---------- x : same as :meth:`~triqs.gfs.block2_gf.Block2Gf.__mul__`

Reflected multiplication ``x * self``. Parameters ---------- x : same as :meth:`~triqs.gfs.block_gf.BlockGf.__mul__`

Right-hand multiplication. Parameters ---------- x : object Left-hand side operand. Returns ----

r"""Right-hand multiplication by a scalar. Parameters ---------- other : complex-like Left-hand side of the origi

Reflected subtraction ``y - self``. Parameters ---------- y : same as :meth:`~triqs.gfs.gf.Gf.__sub__` Returns

Reflected lazy ``y - self``. Parameters ---------- y : LazyExpr, descriptor or scalar Returns -------

Reflected subtraction ``y - self``. Parameters ---------- y : same as :meth:`~triqs.gfs.block2_gf.Block2Gf.__sub__`

Reflected subtraction ``y - self``. Parameters ---------- y : same as :meth:`~triqs.gfs.block_gf.BlockGf.__sub__` Re

Right-hand subtraction. Parameters ---------- x : object Left-hand side operand. Returns -------

Right-hand subtraction, implemented as ``(-self) + other``. Parameters ---------- other : MatsubaraFreq or complex-like

Reflected lazy ``y / self``. Parameters ---------- y : LazyExpr, descriptor or scalar Returns -------

Right-hand division. Parameters ---------- x : object Dividend. Returns ------- object

r"""Right-hand division. Parameters ---------- other : complex-like Dividend. Returns -------

Assign at a mesh point or delegate to ``<<`` for everything else. ``g[mp] = val`` writes ``val`` into ``self.data`` at the data index

Assign into a block via ``<<``. ``G[bn1, bn2] = val`` is equivalent to ``G[bn1, bn2] << val``. Parameters ----------

Assign into a block via ``<<``. ``G[key] = val`` is equivalent to ``G[key] << val``. ``G[:] = val`` is equivalent to ``G << val`` (br

Alias for :meth:`~triqs.gfs.gf.Gf.__repr__`. Returns ------- str

Human-readable rendering of the expression tree. Returns ------- str Infix string with parentheses inserted accor

Return ``self.name`` when set, otherwise ``repr(self)``. Returns ------- str ``self.name`` if non-empty, else ``r

Return the string ``"Omega"``. Returns ------- str