A class that provides quadrature points and weights, in host and device memory. The quadrature points and weights are computed either the GSL quadratures or the MatsubaraQuadrature class. This avoids recomputing the quadrature points and weights for each integrator.
More...
|
| | QuadratureProvider () |
| |
| | QuadratureProvider (const ConfigTree &config) |
| | Construct a provider that reports the quadratures it builds.
|
| |
| | QuadratureProvider (const ConfigTree &config, ReportPort log) |
| |
| template<typename NT = double, typename MemorySpace = CPU_memory> |
| auto | nodes (const size_t order, const QuadratureType type=QuadratureType::legendre) |
| | Get the quadrature points for a quadrature of size quadrature_size.
|
| |
| template<typename NT = double, typename MemorySpace = CPU_memory> |
| auto | weights (const size_t order, const QuadratureType type=QuadratureType::legendre) |
| | Get the quadrature weights for a quadrature of size quadrature_size.
|
| |
| template<typename NT = double, typename MemorySpace = CPU_memory> |
| auto | matsubara_nodes (const NT T, const NT typical_E) |
| | Get the quadrature points for a quadrature of size quadrature_size.
|
| |
| template<typename NT = double, typename MemorySpace = CPU_memory> |
| auto | matsubara_weights (const NT T, const NT typical_E) |
| | Get the quadrature weights for a quadrature of size quadrature_size.
|
| |
| template<typename NT = double> |
| const MatsubaraQuadrature< NT > & | matsubara_rule (const NT T, const NT typical_E) |
| | The Matsubara rule itself, for callers that need more than nodes and weights – its size, or the zero-mode-inclusive node list of sum_nodes(). The reference is into a node-based map and stays valid for the lifetime of the provider.
|
| |
| int | max_matsubara_size () const |
| | The node ceiling /integration/max_matsubara_size, i.e. the budget the rule choice is made against.
|
| |
| template<typename NT = double> |
| int | matsubara_predicted_size (const NT T, const NT typical_E) const |
| | Nodes the Monien rule would want at (T, typical_E). See MatsubaraStorage::predicted_size.
|
| |
| template<typename NT = double> |
| const MatsubaraQuadrature< NT > & | matsubara_exact_sum (const NT T, const NT freq_cutoff) |
| | The exact Matsubara sum for a summand that vanishes above freq_cutoff. See MatsubaraQuadrature::reinit_exact_sum.
|
| |
| template<typename NT = double> |
| const MatsubaraQuadrature< NT > & | matsubara_finite_interval (const NT cutoff, const size_t order) |
| | Gauss-Legendre over the finite frequency interval a compactly supported summand lives on, at the given order. See MatsubaraQuadrature::reinit_finite_interval.
|
| |
| template<typename ExecutionSpace > |
| ExecutionSpace | next_execution_space () |
| | Hand out one of a small pool of execution space instances, round robin.
|
| |
A class that provides quadrature points and weights, in host and device memory. The quadrature points and weights are computed either the GSL quadratures or the MatsubaraQuadrature class. This avoids recomputing the quadrature points and weights for each integrator.
| DiFfRG::QuadratureProvider::QuadratureProvider |
( |
const ConfigTree & | config | ) |
|
|
explicit |
Construct a provider that reports the quadratures it builds.
The standalone overload reports into the run log, <output folder>/<output name>.log, under the "quadrature" tag when /output/folder is present. It owns that reporter rather than borrow one from an OutputSession, because integrators request their quadratures inside their constructors – typically before any session exists; the file sink is shared process-wide per path, so the session opening the same file later appends to the quadrature inventory instead of truncating it. The inventory never echoes to the console, where it would drown the timestepper progress report. Passing a port joins an existing run reporter.
template<typename ExecutionSpace >
| ExecutionSpace DiFfRG::QuadratureProvider::next_execution_space |
( |
| ) |
|
|
inline |
Hand out one of a small pool of execution space instances, round robin.
Every integrator used to default-construct its ExecutionSpace, i.e. they all shared the default stream and no two flows could ever execute concurrently – even the ones that are mutually independent (the vertex flows of a typical RHS read the same dressings and write disjoint outputs). Handing neighbouring integrators different instances lets those overlap, which matters most for the many small launches that individually leave the device underutilised.
Safe to mix with the interpolators' uploads, which fence on the host before returning, so any kernel issued afterwards on any stream already sees the new data.
The pool is created lazily and shared by every integrator holding this provider. Host execution spaces have no streams to speak of, so they get a default-constructed instance.
1.12.0