Get an iterator to the beginning of the mesh.

Get an iterator to the beginning of the mesh.

* @brief Get the block names of the expression. * @return The block names taken from the block Green's function operand. */

* @brief Get the matrix size of each block. * * @details Only valid for matrix-valued blocks (rank-2 target); requires each block to have a square t

Get a const iterator to the beginning of the set.

Map a base-lattice point ``x`` (in lattice coordinates) to its superlattice coordinates ``(R, alpha)``. Parameters ----------

* @brief Compute barycentric weights for Chebyshev points of the first kind. * * @details Weights are computed as: * \f[ * w_i = (-1)^i

* @brief Compute Chebyshev points of the first kind on the interval \f$ [-1, 1] \f$. * * @details Points are computed as: * \f[ * x_i =

Clone the given repository and its dependencies recursively and create soft links for the dependencies. Parameters ---------- name :

Return the indices of the points in ``L`` closest to ``x`` (ties returned in order). Parameters ---------- x : sequence of float of length 2

Return the indices of the points in ``L`` that lie closest to the oriented segment ``A -> B``. Parameters ---------- A, B : sequence of float of

r""" Recursively compare two objects identified by ``key``. Dispatches on the runtime type of ``a`` (and asserts that ``b`` has the same

Lazily recompute the inverse matrix from scratch (cached in mat_inverse, guarded by mat_inverse_is_valid).

Complex-conjugate every block. Returns ------- BlockGf New container holding the complex conjugate of every block

Return a new :class:`~triqs.gfs.block_gf.BlockGf` containing **deep copies** of the named blocks. Parameters ---------- selec

r"""Compute per-block single-particle density matrices. Equivalent to :math:`\langle c^\dagger_i c_j \rangle` evaluated per block fro

* @brief Deserialize the mesh from a generic archive. * @param ar Archive to deserialize from. */

r""" Bracket a sign change of a monotonic real-valued function. Starting from ``x_0`` and stepping outward by ``dx`` (the sign of the ste

r""" Find :math:`x` such that :math:`f(x) = y_{\mathrm{value}}`. Starting from ``x_init`` (treated as either the lower or the upper bound

* @brief Solve \f$ f(x) = y \f$ on a bracketing interval using the false-position (dichotomy) method. * * @details Given an interval \f$ [x_\mat

* @brief Get the dimension of the superlattice. * * @return Dimension of the superlattice, either 2 or 3. */

* @brief Disable the guard so the stored callable is *not* invoked on destruction. */

Compute the density of states of a tight-binding Hamiltonian on a regular k-grid. Wraps the C++ :func:`triqs.lattice.lattice_tools.dos` and split

* @brief Get a lazy range over the (R-vector, hopping-matrix) pairs. * @return Lazy range of tuples \f$ (\mathbf{R}, t(\mathbf{R})) \f$ pairing e

Get an iterator past the last block.

Get an iterator to the end of the mesh.

Get an iterator to the end of the mesh.

Get an iterator to the end of the mesh.

Get an iterator to the end of the mesh.

Get an iterator to the end of the mesh.

Get an iterator to the end of the mesh.

Get an iterator to the end of the mesh.

Get an iterator to the end of the mesh.

Get an iterator to the end of the mesh.

Impose a discontinuity G(\tau=0)-G(\tau=\beta)

* @brief Linear extrapolation of the remaining time of a loop, formatted as `HH:MM:SS`. * * @details It uses the provided (running) @ref timer t

Recursively reduce ``expr`` using ``eval_term`` on every leaf. Parameters ---------- eval_term : callable Called as ``eval_term(v

Overload evaluate for a single dummy domain.

Extend a Wannier90 hopping dictionary with a trivial spin index. Each ``(num_wann, num_wann)`` hopping matrix is replaced by its Kronecker pr

* @brief Extract the density-density interaction \f$ \frac{1}{2} \sum_{ij} U_{ij} \hat{n}_i \hat{n}_j \f$ from a * many-body operator. * * @p

* @brief Extract the two-body interaction part from a many-body operator. * * @details The two body interaction is assumed to have the form

* @brief Extract the quadratic part \f$ \sum_{ij} h_{ij} \hat{c}^\dagger_i \hat{c}_j \f$ from a many-body operator. * * @param H The many-body o

Return (new_src, num_fixes). Rewrites invalid escapes in str literals.

Return a fixed literal with identical value but no invalid escapes, or None if nothing to fix / cannot fix safely. With prefer_raw, also norma

Fold a real-space function defined on the base lattice onto the superlattice. Parameters ---------- D1 : dict Dic

r"""Matrix transform of the target space of a matrix valued Green's function. Sets the current Green's function :math:`g_{ab}` to the matrix

* @brief Scale a value from the standard interval \f$ [-1, 1] \f$ to interval \f$ [a, b] \f$. * * @param x Value in \f$ [-1, 1] \f$. * @param

r"""Semi-circular Green's function on the imaginary-time axis via adaptive quadrature. Uses :func:`scipy.integrate.quad` to evaluate the original

r"""Retarded semi-circular Green's function on the real-frequency axis. .. math:: G^R(\omega) = \frac{2}{D^2} \begin{cases}

Sample ``n_points`` evenly-spaced points on the segment ``[A, B]``. Parameters ---------- A, B : sequence of float Endpoints ``(x

Distribute ``n_points`` samples along a piecewise-linear path. Points are distributed segment-by-segment proportionally to each segment's len

Generate random tau points in [0, beta] for evaluation

* @brief Get the acceptance rates of all moves in case it is a move set. * @return `std::map` containing the names of the moves and their accepta

Canonical block structure. Returns ------- list of (str, int) ``(block_name, linear_size)`` for every block.

r""" Compare two HDF5 archives and raise on mismatch. Opens both archives in read-only mode and walks them recursively via :func:`compare

* @brief Check if a given \f$ \alpha \f$ is in the set. * * @param alpha Index \f$ \alpha \f$ to look up. * @return True if \f$ \alpha

* @brief Get the HDF5 format tag of a block Green's function. * @return The string `"BlockGf"` (`"Block2Gf"` for a block2_gf). */

Get the HDF5 format tag.

* @brief Get a lazy range over the hopping matrices, one per R-vector. * @return Range over the hopping matrices \f$ t(\mathbf{R}) \f$, one per l

Get the index tuple \f$ \mathbf{n} \f$ of the mesh point.

* @brief Insert a new index \f$ \alpha \f$ into the set. * * @details The index is inserted at end of the set such that \f$ \alpha_i < \alp