DiFfRG Namespace Reference

Namespaces
namespace	assembly_cost
	Representative per-cell costs, in nanoseconds, for the loops DiFfRG assembles.
namespace	assembly_schedule_defaults
namespace	CG
namespace	compute
namespace	Config
namespace	dDG
namespace	def
	This namespace contains all default implementations and definitions needed for numerical models.
namespace	detail
namespace	device
namespace	DG
namespace	FE
namespace	fRG
namespace	FV
namespace	get_type
namespace	hdf5
namespace	internal
namespace	Interpolation
namespace	LDG
namespace	LoopIntegrals
namespace	MPI
namespace	ParallelDoFs
	DoF-layout helpers shared by the CG, DG and FV discretizations.
namespace	progress_topics
namespace	Variables

Classes
class	AbstractAdaptor
	Implement a simple interface to do all adaptivity tasks, i.e. solution transfer, reinit of dofHandlers, etc. More...
class	AbstractAssembler
	This is the general assembler interface for any kind of discretization. An assembler is responsible for calculating residuals and their jacobians for any given discretization, including both the spatial part and any further variables. Any assembler for a specific spatial discretization must fully implement this interface. More...
class	AbstractFlowingVariables
	A class to set up initial data for whatever discretization we have chosen. Also used to switch/manage memory, vectors, matrices over interfaces between spatial discretization and separate variables. More...
class	AbstractIntegrator
	Common base of every integrator, carrying the identity MapScheduler needs. More...
class	AbstractLinearSolver
class	AbstractMinimizer
	Abstract class for minimization in arbitrary dimensions. More...
class	AbstractMinimizer< 1 >
class	AbstractRootFinder
class	AbstractRootFinder< 1 >
class	AbstractTimestepper
	The abstract base class for all timestepping algorithms. It provides a standard constructor which populates typical timestepping parameters from a given ConfigTree object, such as the timestep sizes, tolerances, verbosity, etc. that are used in the timestepping algorithms. More...
struct	AffineConstraintComponentView
class	AffineConstraintContext
struct	AssemblySchedule
	The two trailing arguments of dealii::MeshWorker::mesh_loop. More...
struct	AssemblyScheduleOverrides
	Overrides, if really wanted by the user: /discretization/{mesh_workers,batch_size}. More...
class	BisectionRootFinder
class	BisectionRootFinderTarget
	Bisection search which converges a target value rather than the search variable. More...
class	BosonicCoordinates1DFiniteT
	Matsubara frequencies combined with a radial momentum axis. More...
class	BosonicMatsubaraValues
struct	BosonicRegulator
	Implements one of the standard exponential regulators, i.e. More...
struct	BosonicRegulatorOpts
struct	CalcDtTimer
	Stopwatch feeding structured progress durations. More...
class	ComponentDescriptor
	A class to describe how many FE functions, additional variables and extractors are used in a model. More...
class	ConfigTree
	A hierarchical configuration tree, readable from JSON and TOML files. More...
class	ConfigurationHelper
	Class to read parameters given from the command line and from a parameter file. More...
class	CoordinatePackND
	Utility class for combining multiple coordinate systems into one. More...
struct	CsvDialect
	The CSV dialect DiFfRG reads and writes. More...
class	CsvOutput
	A class to output data to a CSV file. More...
class	CSVReader
	This class reads a .csv file and allows to access the data. More...
struct	CsvTable
	A numeric table, stored one vector per column. More...
class	DataOutput
class	DeferredMaps
	Scope in which map() results are landed lazily instead of one blocking copy per call. More...
class	DiagnosticPort
struct	EoMResult
	Result of finding an EoM point, optionally including its reconstructed potential. More...
class	ExecutionSpaces
struct	ExponentialRegulator
	Implements one of the standard exponential regulators, i.e. More...
struct	ExponentialRegulatorOpts
class	ExternalDataInterpolator
	This class takes in a .csv file with x-dependent data and interpolates it to a given x on request. More...
class	FEMAssembler
	The basic assembler that can be used for any standard CG scheme with flux and source. More...
class	FEOutput
	A class to output finite element data to disk as .vtu files and .pvd time series. More...
class	FEOutput< 0, VectorType >
class	FermionicCoordinates1DFiniteT
	Fermionic counterpart of BosonicCoordinates1DFiniteT, see there. More...
class	FermionicMatsubaraValues
struct	FixedString
	A fixed size compile-time string. More...
class	FlowingVariables
	A class to set up initial data for whatever discretization we have chosen. Also used to switch/manage memory, vectors, matrices over interfaces between spatial discretization and separate variables. More...
class	FocusedLogCoordinates1D
	Logarithmic coordinates which cluster grid points around an interior scale. More...
struct	FrameTimings
	Wall-clock cost of producing one output frame, split by where the time went. More...
struct	FunctionND
	A class to describe a function with a compile-time name and a fixed number of dimensions. More...
struct	GetKokkosNDStarType
struct	GetKokkosNDStarType< 1, T >
struct	GLQuadrature
struct	GLQuadrature< 1, ctype >
struct	GLQuadrature< 10, ctype >
struct	GLQuadrature< 11, ctype >
struct	GLQuadrature< 12, ctype >
struct	GLQuadrature< 128, ctype >
struct	GLQuadrature< 13, ctype >
struct	GLQuadrature< 14, ctype >
struct	GLQuadrature< 15, ctype >
struct	GLQuadrature< 16, ctype >
struct	GLQuadrature< 2, ctype >
struct	GLQuadrature< 20, ctype >
struct	GLQuadrature< 24, ctype >
struct	GLQuadrature< 3, ctype >
struct	GLQuadrature< 32, ctype >
struct	GLQuadrature< 4, ctype >
struct	GLQuadrature< 48, ctype >
struct	GLQuadrature< 5, ctype >
struct	GLQuadrature< 6, ctype >
struct	GLQuadrature< 64, ctype >
struct	GLQuadrature< 7, ctype >
struct	GLQuadrature< 8, ctype >
struct	GLQuadrature< 9, ctype >
struct	GLQuadrature< 96, ctype >
class	GMRES
class	GSLMinimizer1D
	Minimizer in 1D using either the golden section, Brent or quadratic method from GSL. More...
class	GSLSimplexMinimizer
	Minimizer using the Nelder-Mead simplex algorithm from GSL. More...
class	HAdaptivity
	Implement a simple interface to do all adaptivity tasks, i.e. solution transfer, reinit of dofHandlers, etc. More...
struct	has_n_call_operator_helper
struct	HDF5Frame
	Everything one output frame will write to one file, and nothing else. More...
class	HDF5FrameContext
	The one place HDF5 identifiers live while a frame is being written. More...
class	HDF5FrameWriter
	Writes staged HDF5 frames on a single background thread. More...
class	HDF5Input
	A class to output data to a CSV file. More...
class	HDF5Output
	A class to output data to a CSV file. More...
struct	IDAErrorDofDiagnostics
struct	IDAErrorDofRecord
struct	IDAProgressDiagnostics
class	IndexStack
class	Init
class	Integrator_fT
class	Integrator_fT_p2
class	Integrator_fT_p2_1ang
class	Integrator_fT_p2_4D_2ang
class	Integrator_p2
	Integrator_p2 integrates a kernel \(K(p,\ldots)\) depending on the radial momentum \(p\) as $$ \frac{S_d}{(2\pi)^{d}}\,\int_0^\infty dp^2 p^{d-2} K(p, \ldots) $$ where \(S_d\) is the solid angle in $d$ dimensions. More...
class	Integrator_p2_1ang
	Integrator_p2_1ang integrates a kernel \(K(p,\cos,\ldots)\) depending on the radial momentum \(p\) and the cosine of the single polar angle between the loop and external momentum as $$ \frac{S_{d-1}}{(2\pi)^{d}}\,\int_{-1}^1 dc\,(1-c^2)^{\frac{d-3}{2}}\,\int_0^\infty dp\, p^{d-1} K(p,c,\ldots) $$ in \(d\) dimensions, where \(S_{d-1}\) is the solid angle of the \((d-2)\)-sphere remaining after the polar angle is singled out. The zonal measure \((1-c^2)^{(d-3)/2}\) is supplied exactly by a Gauss-Jacobi angular quadrature, so it does not appear in the kernel. More...
class	Integrator_p2_4D_2ang
	Integrator_p2_4D_2ang integrates a kernel \(K(p,\cos_1,\cos_2,\ldots)\) depending on the radial momentum \(p\) and two angles on \([0,\pi]\) as $$ \frac{2\pi}{(2\pi)^{d}} \,\int_0^\pi d\cos_1\,\int_0^\pi d\cos_2\,\int_0^\infty dp^2 p^{d-2} K(p,\cos_1,\cos_2,\ldots) $$ in \(d=4\) dimensions. More...
class	Integrator_p2_4D_3ang
	Integrator_p2_4D_3ang integrates a kernel \(K(p,\cos_1,\cos_2,\ldots)\) depending on the radial momentum \(p\) and two angles on \([0,\pi]\) and one angle on \([0,2\pi]\) as $$ \frac{1}{(2\pi)^{d}} \,\int_0^\pi d\cos_1\,\int_0^\pi d\cos_2\,\int_0^{2\pi}d\phi\,\int_0^\infty dp^2 p^{d-2} K(p,\cos_1,\cos_2,\pi,\ldots) $$ in \(d=4\) dimensions. More...
class	IntegratorLat1D
class	IntegratorLat2D
class	IntegratorLat3D
class	IntegratorLat4D
struct	InterpolationStencil
	The two grid indices and the interpolation weight for one axis of a linear interpolation. More...
struct	is_autodiff_real
	Type trait: true iff T is any autodiff::Real<N, U> specialization. Allows generic handling of higher-order forward-mode AD types beyond autodiff::real (= autodiff::Real<1, double>). More...
struct	is_autodiff_real< autodiff::Real< N, U > >
struct	is_complex
struct	is_complex< complex< T > >
struct	is_complex< cxReal< N, T > >
struct	JacobianFactorizationDiagnostics
struct	JacobianMatrixDiagnostics
class	KINSOL
	A newton solver, using local error estimates for each vector component. More...
struct	KokkosNDLambdaWrapper
	This is a functor which wraps a lambda. Basically, this is necessary when one wants to call a variadic lambda on an NVIDIA GPU. CUDA seems to be unable to expand the variadic arguments - in contrast, a direct approach does indeed work for openMP or serial compilation. To get around this limitation, the KokkosNDLambdaWrapper packs the indices into an array. If you wonder, whether there's a difference when using tie and tuples: https://godbolt.org/z/M3bG39rsM No. Therefore, we spare the ourselves the hassle and simply use an array. More...
struct	KokkosNDLambdaWrapperReduction
	This is a functor which wraps a lambda for reduction. Basically, this is necessary when one wants to call a variadic lambda on an NVIDIA GPU. CUDA seems to be unable to expand the variadic arguments - in contrast, a direct approach does indeed work for openMP or serial compilation. To get around this limitation, the KokkosNDLambdaWrapperReduction packs the indices into an array. Uses compile-time index sequences to extract the first dim args as indices and the last arg as the reduction value, avoiding recursive tuple_first/tuple_cat overhead per GPU thread. More...
struct	KokkosNDRangeHelper
struct	KokkosNDRangeHelper< 1, ExecutionSpace >
class	LinearCoordinates1D
class	LinearInterpolator1D
	A linear interpolator for 1D data, callable from host AND device code. More...
class	LinearInterpolator2D
	A linear interpolator for 2D data, callable from host AND device code. More...
class	LinearInterpolator3D
	A linear interpolator for 3D data, callable from host AND device code. More...
struct	LinearInterpolatorND_helper
struct	LinearInterpolatorND_helper< 1, NT, Coordinates >
struct	LinearInterpolatorND_helper< 2, NT, Coordinates >
struct	LinearInterpolatorND_helper< 3, NT, Coordinates >
class	LinearPeriodicCoordinates1D
	Linear coordinates on a periodic axis of period (stop - start). More...
class	LinePrefixFilter
	A std::streambuf that forwards everything except whole lines starting with a prefix. More...
struct	LitimRegulator
	Implements the Litim regulator, i.e. More...
class	LogarithmicCoordinates1D
class	MapCompletion
	Deferred landing of QuadratureIntegrator::map() results in host memory. More...
class	MapScheduler
struct	MapSlice
	This rank's window into the external grid of one QuadratureIntegrator::map() call. More...
struct	MapTarget
	Which resource a map() runs on and how many evaluations saturate one rank's share of it. More...
class	MatsubaraQuadrature
	A quadrature rule for (bosonic) Matsubara frequencies, based on the method of Monien [1]. This class provides nodes and weights for the summation. More...
struct	named_tuple
	A class to store a tuple with elements that can be accessed by name. The names are stored as FixedString objects and their lookup is done at compile time. More...
class	Newton
	A newton solver, using local error estimates for each vector component. More...
class	NoAdaptivity
class	NoMapsHere
	Decides, without any user input, which rank computes which part of each map(). More...
class	OutputFrame
class	OutputPath
class	OutputSession_impl
class	OutputTimings
	Running statistics over all frames of one run. More...
class	Polynomial
	A class representing a polynomial. More...
struct	PolynomialExpRegulator
	Implements a regulator given by. More...
struct	PolynomialExpRegulatorOpts
struct	ProgressEvent
struct	ProgressField
struct	ProgressTopic
class	Quadrature
class	QuadratureIntegrator
	This class performs numerical integration over a d-dimensional hypercube using quadrature rules. More...
class	QuadratureIntegrator< dim, NT, KERNEL, TBB_exec >
class	QuadratureIntegrator_fT
class	QuadratureIntegrator_fT< dim, NT, KERNEL, TBB_exec >
class	QuadratureProvider
	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...
struct	QuadratureType
struct	RationalExpRegulator
	Implements a regulator given by. More...
struct	RationalExpRegulatorOpts
struct	RawPotentialEvaluation
	Reconstructed potential data and the explicitly separate Hessian used for mass extraction. More...
struct	ReconstructedEoMPotential
	An owning scalar potential reconstructed from a model EoM vector field. More...
struct	ReconstructedEoMPotential< 0, NumberType >
struct	ReconstructedRawPotential
struct	ReconstructedRawPotential< 0, NumberType >
struct	RecoveredMassHessian
	A scalar potential reconstructed from a model-provided raw gradient. More...
class	RectangularMesh
	Class to manage the discretization mesh, also called grid and triangluation, on which we simulate. This class only builds cartesian, regular grids, however cell density in all directions can be chosen independently. More...
struct	RectangularMeshOptions
class	ReportPort
class	RunReporter
struct	RunReporterOptions
struct	Scalar
class	ScaledLinearSolver
class	ScalingRootFinder
	Bracketed root find accelerated by the critical scaling of the observable. More...
class	ScopedLineFilter
	Installs a LinePrefixFilter on a stream for the duration of a scope. More...
class	ScopedTimer
	Adds the wall time of its scope to a double, in seconds. More...
class	SimpleMatrix
	A simple NxM-matrix class, which is used for cell-wise Jacobians. More...
struct	SmoothedLitimRegulator
	Implements one of the standard exponential regulators, i.e. More...
struct	SmoothedLitimRegulatorOpts
class	SolutionSample
	A read-only snapshot of the discrete solution, one sample per active cell. More...
struct	SolutionSampleEntry
	One cell's worth of a SolutionSample. More...
class	SolutionView
	A read-only, fully-replicated view of the solution. More...
struct	SolverCallbackDiagnostics
class	SplineInterpolator1D
	A spline interpolator for 1D data, callable from host AND device code. More...
class	SplineInterpolator1DStack
	A stack of 1D splines, callable from host AND device code. More...
struct	stepperChoice
struct	StringSet
class	SubCoordinates
	A contiguous window into the linear index range of another coordinate system. More...
struct	SubDescriptor
struct	SummaryEvent
struct	SummaryMetric
struct	SumPlus
	An extension of the Kokkos::Sum reducer that adds a constant value to the result. More...
struct	TBB_ExecutionSpace
	The CPU execution space: TBB, the one host thread pool DiFfRG runs on. More...
class	TC_Default
	This is a default time controller implementation which should be used as a base class for any other time controller. It only implements the basic tasks that should be done when advancing time, i.e. saving, logging if the stepper got stuck, checking if the simulation is finished and restricting the minimal timestep. More...
class	TC_PI
	A simple PI controller which adjusts time steps in a smooth fashion depending on how well the solver performs, taking into account the most recent time step, too. More...
struct	ThreadResolution
	What the precedence rules picked, and which setting it came from. More...
class	TimeStepperBoostABM_impl
	A class to perform time stepping using the Boost Adams-Bashforth-Moulton method. This stepper uses fixed time steps and is fully explicit. More...
class	TimeStepperBoostRK_impl
	A class to perform time stepping using adaptive Boost Runge-Kutta methods. This stepper uses adaptive time steps and is fully explicit. More...
class	TimeStepperExplicitEuler_impl
class	TimeStepperImplicitEuler_impl
struct	TimestepperJacobianBuildDiagnostics
class	TimestepperJacobianDiagnosticsState
class	TimeStepperRK_impl
class	TimeStepperSUNDIALS_IDA_BoostABM_impl
	A class to perform time stepping using the Boost Adams-Bashforth-Moulton method for the explicit part and SUNDIALS IDA for the implicit part. This stepper uses fixed time steps in the explicit part and adaptive time steps in the implicit part. IDA acts as the controller and the ABM stepper solves the explicit part of the problem on-demand. More...
class	TimeStepperSUNDIALS_IDA_BoostRK_impl
	A class to perform time stepping using the adaptive Boost Runge-Kutta method for the explicit part and SUNDIALS IDA for the implicit part. In this scheme, the IDA stepper is the controller and the Boost RK stepper solves the explicit part of the problem on-demand. More...
class	TimeStepperSUNDIALS_IDA_impl
	A class to perform time stepping using the SUNDIALS IDA solver. This stepper uses adaptive time steps and is fully implicit. Furthermore, IDA allows for the solution of DAEs. More...
class	TimeStepperTRBDF2_impl
struct	TimesteppingDiagnostics
class	UMFPack
struct	UnusedPotential
	Stand-in for a raw potential that a model has declared it does not read. More...
struct	UnusedPotentialEvaluation
	Evaluating an unread potential: the same three slots, all inert. More...

Concepts
concept	SupportedVectorType
	A vector type DiFfRG's timesteppers and assemblers can work with.
concept	NamedTuple
	Concept for a named tuple.
concept	is_container
concept	is_sized_container
concept	has_n_call_operator
concept	HasExtractorPoint
	Whether Model chooses its own point at which the extractors are evaluated.
concept	MeshIsRectangular
concept	is_coordinates
concept	has_integrator_AD
concept	has_integrator_AD2
concept	has_set_k
concept	has_set_T
concept	has_set_typical_E
concept	has_set_x_extent
concept	provides_regulator
concept	provides_kernel
concept	provides_constant
concept	is_valid_kernel
concept	has_interpolator_types
	Checks that an interpolator class provides the required type aliases (value_type, ctype).
concept	has_interpolator_methods
	Checks that an interpolator class provides the required methods (get_coordinates) and a call operator with the correct arity.
concept	is_interpolator
	A concept for what is an interpolator class.

Typedefs
template<size_t N, typename T >
using	cxReal = autodiff::Real<N, complex<T>>
using	cxreal = autodiff::Real<1, complex<double>>
using	GPU_memory = ExecutionSpaces::GPU_memory_space
using	KokkosHost_memory = ExecutionSpaces::KokkosHost_memory_space
using	TBB_memory = ExecutionSpaces::TBB_memory_space
using	CPU_memory = Kokkos::DefaultHostExecutionSpace::memory_space
using	PinnedHost_memory = CPU_memory
	Host memory the device can DMA to/from without staging, i.e. page-locked.
using	GPU_exec = ExecutionSpaces::GPU_exec_space
using	KokkosHost_exec = ExecutionSpaces::KokkosHost_exec_space
using	TBB_exec = ExecutionSpaces::TBB_exec_space
template<int dim, typename T , typename ExecutionSpace >
using	KokkosNDView
template<int dim, typename T , typename ExecutionSpace >
using	KokkosNDViewRestrict
template<int dim, typename T , typename ExecutionSpace >
using	KokkosNDViewUnmanaged
template<int dim, typename ExecutionSpace >
using	KokkosNDRange = KokkosNDRangeHelper<dim, ExecutionSpace>::type
template<int dim>
using	DefaultTriangulation = dealii::Triangulation<dim>
template<typename Mesh , typename NumberType >
using	LAVectorFor = dealii::Vector<NumberType>
template<typename Mesh , typename NumberType >
using	LASparseMatrixFor = dealii::SparseMatrix<NumberType>
using	uint = unsigned int
using	FocusedBosonicCoordinates1DFiniteT = BosonicCoordinates1DFiniteT<int, double, FocusedLogCoordinates1D<double>>
using	FocusedFermionicCoordinates1DFiniteT
using	LogCoordinates = LogarithmicCoordinates1D<double>
using	LinCoordinates = LinearCoordinates1D<double>
using	LogLogCoordinates = CoordinatePackND<LogarithmicCoordinates1D<double>, LogarithmicCoordinates1D<double>>
using	LogLinCoordinates = CoordinatePackND<LogarithmicCoordinates1D<double>, LinearCoordinates1D<double>>
using	LinLogCoordinates = CoordinatePackND<LinearCoordinates1D<double>, LogarithmicCoordinates1D<double>>
using	LinLinCoordinates = CoordinatePackND<LinearCoordinates1D<double>, LinearCoordinates1D<double>>
using	LogLogLinCoordinates
using	LogLinLinCoordinates
using	LinLinLinCoordinates
using	FocusedLogCoordinates = FocusedLogCoordinates1D<double>
using	FocusedLogLinCoordinates = CoordinatePackND<FocusedLogCoordinates1D<double>, LinearCoordinates1D<double>>
using	FocusedLogLinLinCoordinates
using	LinPeriodicCoordinates = LinearPeriodicCoordinates1D<double>
using	LogLinPeriodicCoordinates
using	LogLinLinPeriodicCoordinates
using	FocusedLogLinPeriodicCoordinates
using	FocusedLogLinLinPeriodicCoordinates
using	HDF5Action = std::function<void(HDF5FrameContext &)>
template<typename AssemblerOrDiscretization >
using	OutputSession
using	OutputSettings = Config::OutputSettings
template<uint dim>
using	RectangularMeshSerial = RectangularMesh<dim, dealii::Triangulation<dim>>
	A rectangular mesh pinned to a serial triangulation, whatever the build configuration.
template<typename... descriptors>
using	FEFunctionDescriptor = SubDescriptor<descriptors...>
template<typename... descriptors>
using	VariableDescriptor = SubDescriptor<descriptors...>
template<typename... descriptors>
using	ExtractorDescriptor = SubDescriptor<descriptors...>
template<typename NT , typename Coordinates >
using	LinearInterpolatorND = typename LinearInterpolatorND_helper<Coordinates::dim, NT, Coordinates>::type
	A linear interpolator for ND data, callable from host and device code alike.
template<typename Assembler >
using	TimeStepperBoostABM
template<typename Assembler , int prec>
using	TimeStepperBoostRK
template<typename Assembler >
using	TimeStepperBoostRK54 = TimeStepperBoostRK<Assembler, 0>
	Time stepping with the adaptive Boost Cash-Karp54 method.
template<typename Assembler >
using	TimeStepperBoostRK78 = TimeStepperBoostRK<Assembler, 1>
	Time stepping with the adaptive Boost Fehlberg78 method.
template<typename SparseMatrixType , typename VectorType >
using	DefaultLinearSolver = typename internal::_default_solver<SparseMatrixType, VectorType>::type
	The build-configuration-dependent default linear solver.
template<typename Assembler >
using	TimeStepperExplicitEuler
template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>
using	TimeStepperImplicitEuler
template<typename SparseMatrixType , typename VectorType , typename PreconditionerType = dealii::PreconditionIdentity>
using	ScaledGMRES
template<typename SparseMatrixType , typename VectorType >
using	ScaledUMFPack = ScaledLinearSolver<SparseMatrixType, VectorType, UMFPack<SparseMatrixType, VectorType>>
template<typename Assembler >
using	TimeStepperRK
using	IDACallbackDiagnostics = SolverCallbackDiagnostics
template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>
using	TimeStepperSUNDIALS_IDA
template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>
using	TimeStepperSUNDIALS_IDA_BoostABM
template<typename Assembler , template< typename... > typename LinearSolver, int prec>
using	TimeStepperSUNDIALS_IDA_BoostRK
template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>
using	TimeStepperSUNDIALS_IDA_BoostRK54 = TimeStepperSUNDIALS_IDA_BoostRK<Assembler, LinearSolver, 0>
	Boost Cash-Karp54 for the explicit part, SUNDIALS IDA for the implicit part.
template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>
using	TimeStepperSUNDIALS_IDA_BoostRK78 = TimeStepperSUNDIALS_IDA_BoostRK<Assembler, LinearSolver, 1>
	Boost Fehlberg78 for the explicit part, SUNDIALS IDA for the implicit part.
template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>
using	TimeStepperTRBDF2

Enumerations
enum class	ThreadSource {   diffrg_env , launcher , config , other_env ,   automatic }
	Where the CPU thread budget came from, in order of precedence (highest first). More...
enum class	TemporaryRetention { remove_on_destruction , keep }
enum class	MapResource : int { device = 0 , host = 1 }
	The physical resource a map() competes for. More...
enum class	ImplicitTimestepperKind : unsigned int {   ida = 0 , ida_boost_rk = 1 , ida_boost_abm = 2 , implicit_euler = 3 ,   trbdf2 = 4 }
enum class	ImplicitTimestepperStage : unsigned int { main = 0 , trapezoidal = 1 , bdf2 = 2 }

Functions
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	real (const autodiff::Real< N, T > &a)
template<size_t N, typename T >
constexpr KOKKOS_FORCEINLINE_FUNCTION auto	imag (const autodiff::Real< N, T > &)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	real (const cxReal< N, T > &x)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	imag (const cxReal< N, T > &x)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator* (const autodiff::Real< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator* (const complex< double > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator+ (const autodiff::Real< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator+ (const complex< double > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator- (const autodiff::Real< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator- (const complex< double > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator/ (const autodiff::Real< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator/ (const complex< double > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator* (const autodiff::Real< N, T > &x, const cxReal< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator* (const cxReal< N, T > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator+ (const autodiff::Real< N, T > &x, const cxReal< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator+ (const cxReal< N, T > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator- (const autodiff::Real< N, T > &x, const cxReal< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator- (const cxReal< N, T > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator/ (const autodiff::Real< N, T > &x, const cxReal< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator/ (const cxReal< N, T > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator* (const complex< double > &x, const cxReal< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator* (const cxReal< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator+ (const complex< double > &x, const cxReal< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator+ (const cxReal< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator- (const complex< double > &x, const cxReal< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator- (const cxReal< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator/ (const cxReal< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator/ (const complex< double > &x, const cxReal< N, T > &y)
template<size_t N, typename T >
KOKKOS_FORCEINLINE_FUNCTION auto	operator/ (const double x, const cxReal< N, T > &y)
CsvTable	read_csv (const std::string &path, const CsvDialect &dialect={})
	Read a CSV file into a numeric table.
CsvTable	parse_csv (std::string_view content, const CsvDialect &dialect={}, std::string_view origin={})
	Parse CSV held in memory into a numeric table.
std::vector< std::string >	split_csv_line (std::string_view line, char separator)
	Split one CSV line into its fields, honouring quoting.
double	parse_csv_cell (std::string_view field)
	Parse a single numeric cell, yielding NaN for anything that is not a number.
void	write_csv_header (std::ostream &stream, const std::vector< std::string > &names, const CsvDialect &dialect={})
	Write a header row, quoting any name that would otherwise forge a field boundary.
void	write_csv_row (std::ostream &stream, const std::vector< double > &values, const CsvDialect &dialect={})
	Write one row of values.
void	dealii_to_eigen (const dealii::Vector< double > &dealii, Eigen::VectorXd &eigen)
	Converts a dealii vector to an Eigen vector.
void	dealii_to_eigen (const dealii::BlockVector< double > &dealii, Eigen::VectorXd &eigen)
	Converts a dealii block vector to an Eigen vector.
void	eigen_to_dealii (const Eigen::VectorXd &eigen, dealii::Vector< double > &dealii)
	Converts an Eigen vector to a dealii vector.
void	eigen_to_dealii (const Eigen::VectorXd &eigen, dealii::BlockVector< double > &dealii)
	Converts an Eigen vector to a dealii block vector.
template<unsigned N>
	FixedString (char const (&)[N]) -> FixedString< N - 1 >
template<unsigned N1, unsigned N2>
consteval bool	strings_equal (FixedString< N1 > s1, FixedString< N2 > s2)
void	set_thread_limit (const ConfigTree &config)
	Limit the number of CPU threads from a configuration tree.
template<int dim, typename T , typename ExecutionSpace >
auto	make_kokkos_nd_view (const std::string &label, const device::array< size_t, dim > &extents)
template<int dim, typename T , typename ExecutionSpace >
auto	make_kokkos_nd_view_restrict (const std::string &label, const device::array< size_t, dim > &extents)
template<int dim>
device::array< size_t, dim >	compute_divisible_tile (const device::array< size_t, dim > &extents, const device::array< size_t, dim > &kokkos_tile, size_t budget)
	A tile whose every dimension divides its extent, so no lane is launched masked.
template<int dim>
device::array< size_t, dim >	compute_tile_hints (const device::array< size_t, dim > &extents, size_t max_threads=256)
	Compute clamped tile sizes for MDRangePolicy so that the product of tile dimensions does not exceed max_threads. Fills from the innermost (last) dimension outward.
template<int dim, typename ExecutionSpace >
auto	make_kokkos_nd_range (ExecutionSpace &space, const device::array< size_t, dim > start, const device::array< size_t, dim > end)
template<int dim, typename ExecutionSpace >
auto	make_kokkos_nd_range (ExecutionSpace &space, const device::array< size_t, dim > start, const device::array< size_t, dim > end, const device::array< size_t, dim > tile)
template<int dim, typename ExecutionSpace >
auto	make_kokkos_nd_range_divisible (ExecutionSpace &space, const device::array< size_t, dim > start, const device::array< size_t, dim > end)
	Like make_kokkos_nd_range, but re-tiled so no lane is launched masked.
template<int dim, typename TeamType >
KOKKOS_FORCEINLINE_FUNCTION auto	make_kokkos_nd_thread_range (const TeamType &team, const device::array< size_t, dim > end)
template<size_t N, typename T >
bool	isfinite (const autodiff::Real< N, T > &x)
	Finite-ness check for autodiff::real.
template<int n, typename NumberType > requires requires(NumberType x) { x * x; NumberType(1.) / x; }
constexpr KOKKOS_INLINE_FUNCTION NumberType	powr (const NumberType x)
	A compile-time evaluatable power function for whole number exponents.
template<typename NumberType > requires std::is_integral_v<NumberType>
constexpr KOKKOS_INLINE_FUNCTION NumberType	factorial (const NumberType &x)
template<typename NT >
constexpr KOKKOS_INLINE_FUNCTION double	V_d (NT d)
	Volume of a d-dimensional sphere.
template<typename NT1 , typename NT2 >
constexpr KOKKOS_INLINE_FUNCTION double	V_d (NT1 d, NT2 extent)
	Volume of a d-dimensional sphere with extent.
template<typename NT >
constexpr KOKKOS_INLINE_FUNCTION double	S_d (NT d)
	Surface of a d-dimensional sphere.
template<typename NT >
consteval NT	S_d_prec (uint d)
	Surface of a d-dimensional sphere (precompiled)
template<typename NumberType > requires requires(NumberType x) { x >= 0; }
constexpr KOKKOS_INLINE_FUNCTION auto	heaviside_theta (const NumberType x)
	A compile-time evaluatable theta function.
template<typename NumberType > requires requires(NumberType x) { x >= 0; }
constexpr KOKKOS_INLINE_FUNCTION auto	sign (const NumberType x)
	A compile-time evaluatable sign function.
template<typename T1 , typename T2 , typename T3 > requires (std::is_floating_point<T1>::value || is_autodiff_real_v<T1> || is_complex<T1>::value) && (std::is_floating_point<T2>::value || is_autodiff_real_v<T2> || is_complex<T2>::value) && std::is_floating_point<T3>::value
bool KOKKOS_INLINE_FUNCTION	is_close (T1 a, T2 b, T3 eps_)
	Function to evaluate whether two floats are equal to numerical precision. Tests for both relative and absolute equality.
template<typename T1 , typename T2 > requires (std::is_floating_point<T1>::value || is_autodiff_real_v<T1> || is_complex<T1>::value) && (std::is_floating_point<T2>::value || is_autodiff_real_v<T2> || is_complex<T2>::value)
bool KOKKOS_INLINE_FUNCTION	is_close (T1 a, T2 b)
	Function to evaluate whether two floats are equal to numerical precision. Tests for both relative and absolute equality.
template<uint n, typename NT , typename A1 , typename A2 > requires requires(A1 a1, A2 a2) { a1[0] * a2[0]; }
NT	dot (const A1 &a1, const A2 &a2)
	A dot product which takes the dot product between a1 and a2, assuming each has n entries which can be accessed via the [] operator.
template<typename T >
void	diagonalize_tridiagonal_symmetric_matrix (std::vector< T > &d, std::vector< T > &e, std::vector< T > &z)
	Diagonalizes a symmetric tridiagonal matrix.
template<typename T >
void	make_quadrature (std::vector< T > &a, std::vector< T > &b, const T mu0, std::vector< T > &x, std::vector< T > &w)
	Obtain the quadrature rule from a given three-term recurrence relation.
bool	operator< (const QuadratureType &x, const QuadratureType &y)
template<int dim, typename NT , typename FUN >
NT	TBBReduction (const device::array< size_t, dim > &grid_size, const FUN &functor)
	Bitwise reproducible reduction of functor over a dim-dimensional index grid.
const char *	to_string (const ThreadSource source)
	The name of a thread-count source, as it appears in the precedence warning.
unsigned int	n_threads ()
	The CPU thread budget this process resolved.
ThreadSource	n_threads_source ()
	Which rule produced n_threads(). ThreadSource::automatic before anything has been resolved.
ThreadResolution	resolve_thread_count (const unsigned int configured_threads)
	Apply the precedence order to the environment and one configured thread count.
void	set_thread_limit (const unsigned int threads)
	Limit the number of CPU threads this process may use.
constexpr bool	strings_equal (char const *a, char const *b)
	Check if two strings are equal at compile time.
template<FixedString name, typename tuple_type , typename strSet >
constexpr auto &	get (named_tuple< tuple_type, strSet > &ob)
	get a reference to the element with the given name
template<FixedString name, typename tuple_type , typename strSet >
constexpr auto &	get (named_tuple< tuple_type, strSet > &&ob)
template<FixedString name, typename tuple_type , typename strSet >
constexpr auto &	get (const named_tuple< tuple_type, strSet > &ob)
template<uint n, typename NT , typename Vector >
std::array< NT, n >	vector_to_array (const Vector &v)
template<typename T , std::size_t... Indices>
auto	vector_to_tuple_helper (const std::vector< T > &v, std::index_sequence< Indices... >)
template<std::size_t N, typename T >
auto	vector_to_tuple (const std::vector< T > &v)
template<typename Head , typename... Tail>
constexpr auto	tuple_tail (const std::tuple< Head, Tail... > &t)
template<typename tuple_type , typename strSet >
constexpr auto	tuple_tail (const named_tuple< tuple_type, strSet > &t)
template<int i, typename Head , typename... Tail>
constexpr auto	tuple_last (const std::tuple< Head, Tail... > &t)
template<int i, typename tuple_type , typename strSet >
constexpr auto	tuple_last (const named_tuple< tuple_type, strSet > &t)
template<int i, typename Head , typename... Tail>
constexpr auto	tuple_first (const std::tuple< Head, Tail... > &t)
template<int i, typename tuple_type , typename strSet >
constexpr auto	tuple_first (const named_tuple< tuple_type, strSet > &t)
template<typename T , size_t N, size_t... IDXs>
auto	_local_sol_tuple (const std::array< T, N > &a, std::index_sequence< IDXs... >, uint q_index)
template<typename T , size_t N>
auto	local_sol_q (const std::array< T, N > &a, uint q_index)
template<typename T_inner , typename Model , size_t... IDXs>
auto	_jacobian_tuple (std::index_sequence< IDXs... >)
template<typename T_inner , typename Model >
auto	jacobian_tuple ()
template<typename T_inner , typename Model , size_t... IDXs>
auto	_jacobian_2_tuple (std::index_sequence< IDXs... >)
template<typename T_inner , typename Model >
auto	jacobian_2_tuple ()
template<auto Start, auto End, auto Inc, class F >
constexpr void	constexpr_for (F &&f)
	A compile-time for loop, which calls the lambda f of signature void(integer) for each index.
std::string	strip_name (const std::string &name)
	Strips all special characters from a string, e.g. for use in filenames.
template<typename T >
std::string	getWithPrecision (uint precision, T number)
	Return number with fixed precision after the decimal point.
bool	file_exists (const std::string &name)
	Checks if a file exists.
template<typename T >
std::string	to_string_with_digits (const T number, const int digits)
	Return number with fixed significant digits.
std::string	make_folder (const std::string &path)
	Add a trailing '/' to a string, in order for it to be in standard form of a folder path.
bool	create_folder (const std::string &path_)
	Creates the directory path, even if its parent directories should not exist.
std::string	time_format (size_t time_in_seconds)
	Nice output from seconds to h/min/s style string.
template<typename T > requires (!std::is_same_v<T, size_t>)
std::string	time_format (T time_in_seconds)
std::string	time_format_ms (size_t time_in_miliseconds)
	Nice output from seconds to h/min/s style string.
bool	has_suffix (const std::string &str, const std::string &suffix)
AssemblySchedule	make_assembly_schedule (const uint n_local_cells, const uint thread_budget, const double cost_ns, const AssemblyScheduleOverrides &overrides={})
	Derive one mesh_loop schedule from the cost of a cell.
template<int dim>
auto	locally_owned_cells (const dealii::DoFHandler< dim > &dof_handler)
	The cells this rank assembles.
template<typename Discretization >
uint	n_locally_owned_cells (const Discretization &discretization)
	How many cells locally_owned_cells() yields.
template<int dim>
UnusedPotentialEvaluation	evaluate_raw_potential (const UnusedPotential &, const dealii::Mapping< dim > &, const dealii::Point< dim > &)
template<int dim, typename VectorType , typename GradientFUN >
ReconstructedRawPotential< dim, typename VectorType::value_type >	reconstruct_raw_potential (const VectorType &sol, const dealii::DoFHandler< dim > &dof_handler, const dealii::Mapping< dim > &mapping, const GradientFUN &get_gradient, const Config::EoMConfig &config, internal::PotentialSystemCache< dim, typename VectorType::value_type > *cache=nullptr)
	Reconstruct a scalar raw potential without locating its minimum.
template<int dim, typename NumberType >
RawPotentialEvaluation< dim, NumberType >	evaluate_raw_potential (const ReconstructedRawPotential< dim, NumberType > &potential, const dealii::Mapping< dim > &mapping, const dealii::Point< dim > &point)
	Evaluate a reconstructed raw potential and its mass-extraction Hessian at a real-space point.
template<int dim, typename VectorType , typename EoMFUN , typename EoMPFUN >
EoMResult< dim, typename VectorType::value_type >	get_EoM_point_with_potential (typename dealii::DoFHandler< dim >::cell_iterator &EoM_cell, const VectorType &sol, const dealii::DoFHandler< dim > &dof_handler, const dealii::Mapping< dim > &mapping, const EoMFUN &get_EoM, const EoMPFUN &EoM_postprocess, const Config::EoMConfig &config, const std::optional< dealii::Point< dim > > &initial_guess=std::nullopt, internal::PotentialSystemCache< dim, typename VectorType::value_type > *cache=nullptr)
	Reconstruct a potential whose gradient approximates the model EoM vector field and return a sampled and locally refined minimum of that potential.
template<int dim, typename VectorType , typename EoMFUN , typename EoMPFUN >
EoMResult< dim, typename VectorType::value_type >	get_EoM_point_with_potential (typename dealii::DoFHandler< dim >::cell_iterator &EoM_cell, const VectorType &sol, const dealii::DoFHandler< dim > &dof_handler, const dealii::Mapping< dim > &mapping, const EoMFUN &get_EoM, const EoMPFUN &EoM_postprocess=[](const auto &p, [[maybe_unused]] const auto &values) { return p;}, const double EoM_abs_tol=Config::EoMConfig::default_abs_tol, const uint max_iter=Config::EoMConfig::default_max_iter, const double EoM_smoothing_length=Config::EoMConfig::default_smoothing_length, const std::optional< dealii::Point< dim > > &initial_guess=std::nullopt, internal::PotentialSystemCache< dim, typename VectorType::value_type > *cache=nullptr)
template<int dim, typename VectorType , typename EoMFUN , typename EoMPFUN >
dealii::Point< dim >	get_EoM_point (typename dealii::DoFHandler< dim >::cell_iterator &EoM_cell, const VectorType &sol, const dealii::DoFHandler< dim > &dof_handler, const dealii::Mapping< dim > &mapping, const EoMFUN &get_EoM, const EoMPFUN &EoM_postprocess, const Config::EoMConfig &config, const std::optional< dealii::Point< dim > > &initial_guess=std::nullopt, internal::PotentialSystemCache< dim, typename VectorType::value_type > *cache=nullptr)
	Reconstruct a potential whose gradient approximates the model EoM vector field and return a sampled and locally refined minimum of that potential.
template<int dim, typename VectorType , typename EoMFUN , typename EoMPFUN >
dealii::Point< dim >	get_EoM_point (typename dealii::DoFHandler< dim >::cell_iterator &EoM_cell, const VectorType &sol, const dealii::DoFHandler< dim > &dof_handler, const dealii::Mapping< dim > &mapping, const EoMFUN &get_EoM, const EoMPFUN &EoM_postprocess=[](const auto &p, [[maybe_unused]] const auto &values) { return p;}, const double EoM_abs_tol=Config::EoMConfig::default_abs_tol, const uint max_iter=Config::EoMConfig::default_max_iter, const double EoM_smoothing_length=Config::EoMConfig::default_smoothing_length, const std::optional< dealii::Point< dim > > &initial_guess=std::nullopt)
template<typename VectorType >
void	reinit_la_vector (VectorType &vec, const dealii::IndexSet &locally_owned, MPI_Comm comm)
	Size a vector to the rank's share of the rows.
template<typename SparseMatrixType >
void	finalize_la_sparsity (dealii::DynamicSparsityPattern &dsp, get_type::SparsityPattern< SparseMatrixType > &pattern, const dealii::IndexSet &locally_owned, const dealii::IndexSet &locally_relevant, MPI_Comm comm)
	Turn a freshly built DynamicSparsityPattern into the pattern type the matrix wants.
template<typename SparseMatrixType >
void	reinit_la_matrix (SparseMatrixType &matrix, const get_type::SparsityPattern< SparseMatrixType > &pattern, const dealii::IndexSet &locally_owned, MPI_Comm comm)
	Size a matrix from a finalized sparsity pattern.
template<typename VectorType >
dealii::IndexSet	restrict_to_owned (const dealii::IndexSet &global_set, const dealii::IndexSet &locally_owned)
	Restrict a global index set to what this rank may write.
dealii::IndexSet	variables_owner_set (const dealii::types::global_dof_index n_vars, MPI_Comm comm)
	The ownership set for the extra-variables block: everything on rank 0, nothing elsewhere.
template<typename VectorType >
void	reinit_variables_view (SolutionView< VectorType > &view, const dealii::types::global_dof_index n_vars, MPI_Comm comm)
	Establish the layout of a fully-replicated view of the extra-variables block.
template<typename VectorType >
void	reinit_la_variables_vector (VectorType &vec, const dealii::types::global_dof_index n_vars, MPI_Comm comm)
	Size a standalone vector holding only the extra variables.
template<typename BlockVectorType >
void	reinit_la_block_vector (BlockVectorType &vec, const std::vector< uint > &block_structure, const dealii::IndexSet &locally_owned, MPI_Comm comm)
	Size a block vector: block 0 is the FE dofs, block 1 (if present) the extra variables.
template<typename VectorType , typename Fn >
void	compute_variables_into (VectorType &dst, VectorType &scratch, Fn &&compute)
	Run a model's variables computation and land the result in the distributed block.
template<typename VectorType >
void	reinit_local_variables_vector (VectorType &vec, const dealii::types::global_dof_index n_vars)
	Size a process-local vector holding every extra variable on every rank.
template<typename VectorType , typename NumberType >
void	dense_vmult_variables (const dealii::FullMatrix< NumberType > &matrix, VectorType &dst, const VectorType &src, MPI_Comm comm)
	Apply a dense matrix to the extra-variables block.
template<int dim>
const dealii::Triangulation< dim > &	serial_mirror (const dealii::Triangulation< dim > &source)
	A process-local, serial mirror of a (possibly partitioned) triangulation.
template<int dim>
dealii::Point< dim >	unit_cell_centre ()
	The centre of the reference cell.
template<int dim, typename NumberType , typename FillFUN >
SolutionSample< dim, NumberType >	make_solution_sample (const dealii::DoFHandler< dim > &dof_handler, const dealii::Mapping< dim > &mapping, const uint n_components, const FillFUN &fill)
	Build a SolutionSample, taking values and gradients from a callback.
template<int dim, typename VectorType >
SolutionSample< dim, typename VectorType::value_type >	make_solution_sample (const VectorType &solution, const dealii::DoFHandler< dim > &dof_handler, const dealii::Mapping< dim > &mapping)
	Build a SolutionSample by evaluating the finite-element solution at each cell centre.
template<typename Coordinates >
auto	make_grid (const Coordinates &coordinates)
template<typename Coordinates >
auto	make_idx_grid (const Coordinates &coordinates) -> std::vector< double >
template<typename Coordinates >
std::vector< typename Coordinates::ctype >	dump_grid (const Coordinates &coordinates)
void	write_config_tree (DiFfRG::hdf5::Group &group, const json::value &value)
	Mirror a JSON configuration value into group as a browsable tree: one subgroup per object, one attribute per leaf.
template<typename AssemblerOrDiscretization >
	NoAdaptivity (const AssemblerOrDiscretization &) -> NoAdaptivity< typename AssemblerOrDiscretization::VectorType >
template<typename Int > requires DiFfRG::has_set_k<Int>
void	invoke_set_k (Int &integrator, const double k)
template<typename Int > requires (!DiFfRG::has_set_k<Int>)
void	invoke_set_k (Int &, const double)
template<typename Int >
void	all_set_k (Int &integrator, const double k)
template<typename Int > requires DiFfRG::has_set_T<Int>
void	invoke_set_T (Int &integrator, const double T)
template<typename Int > requires (!DiFfRG::has_set_T<Int>)
void	invoke_set_T (Int &, const double)
template<typename Int >
void	all_set_T (Int &integrator, const double T)
template<typename Int > requires DiFfRG::has_set_typical_E<Int>
void	invoke_set_typical_E (Int &integrator, const double typical_E)
template<typename Int > requires (!DiFfRG::has_set_typical_E<Int>)
void	invoke_set_typical_E (Int &, const double)
template<typename Int >
void	all_set_typical_E (Int &integrator, const double typical_E)
template<typename Int > requires DiFfRG::has_set_x_extent<Int>
void	invoke_set_x_extent (Int &integrator, const double x_extent)
template<typename Int > requires (!DiFfRG::has_set_x_extent<Int>)
void	invoke_set_x_extent (Int &, const double)
template<typename Int >
void	all_set_x_extent (Int &integrator, const double x_extent)
template<typename NT , typename KERNEL , typename ctype , int dim, typename... ARGS>
NT	multidim_kernel_call (const ARGS &...args)
template<typename NT , typename KERNEL , typename ctype , int dim, typename... ARGS>
consteval void	check_kernel_requirements ()
void	flush_maps ()
	Land all outstanding map() results. See MapCompletion.
const char *	to_string (const MapResource r)
template<typename ExecutionSpace >
MapTarget	map_target ()
	The scheduling target of an execution space, selected at compile time.
template<typename ExecutionSpace >
double	map_fill_threshold ()
	The fill threshold alone, for callers that do not need the resource class.
template<typename Regulator , int dim = 4>
double	optimize_x_extent (const ConfigTree &config)
template<bool periodic, typename CT >
KOKKOS_FORCEINLINE_FUNCTION InterpolationStencil< CT >	make_interpolation_stencil (CT idx, const size_t n)
	Resolve a fractional grid index into the linear-interpolation stencil along one axis.
template<typename T1 , typename T2 > requires (std::is_arithmetic_v<T2>)
auto KOKKOS_FORCEINLINE_FUNCTION	CothFiniteT (const T1 x, const T2 T)
template<typename T1 , typename T2 > requires (std::is_arithmetic_v<T2>)
auto KOKKOS_FORCEINLINE_FUNCTION	TanhFiniteT (const T1 x, const T2 T)
template<typename T1 , typename T2 > requires (std::is_arithmetic_v<T2>)
auto KOKKOS_FORCEINLINE_FUNCTION	SechFiniteT (const T1 x, const T2 T)
template<typename T1 , typename T2 > requires (std::is_arithmetic_v<T2>)
auto KOKKOS_FORCEINLINE_FUNCTION	CschFiniteT (const T1 x, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	cothS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	dcothS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	ddcothS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	dddcothS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	tanhS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	dtanhS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	ddtanhS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	sechS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	cschS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	nB (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	dnB (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	ddnB (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	nF (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto KOKKOS_FORCEINLINE_FUNCTION	dnF (const T1 e, const T2 T)
template<typename MatrixType >
JacobianMatrixDiagnostics	analyze_jacobian_matrix (const MatrixType &matrix)
void	record_jacobian_diagnostics (const DiagnosticPort &diagnostics, const std::string &table, const double t, const TimestepperJacobianBuildDiagnostics &build, const JacobianMatrixDiagnostics &matrix, const JacobianFactorizationDiagnostics &factorization)
template<typename LinearSolver , typename MatrixType >
void	factorize_with_diagnostics (LinearSolver &solver, const MatrixType &matrix, JacobianFactorizationDiagnostics &diagnostics, const bool estimate_condition)
template<typename VectorType >
TimesteppingDiagnostics	make_timestepping_diagnostics (const SUNDIALS::IDA< VectorType > &time_stepper, const IDACallbackDiagnostics &callbacks)
template<typename VectorType >
TimestepperJacobianBuildDiagnostics	make_ida_jacobian_build_diagnostics (const SUNDIALS::IDA< VectorType > &time_stepper, const std::size_t build_id, const double alpha, const ImplicitTimestepperKind stepper_kind=ImplicitTimestepperKind::ida)

Variables
template<typename T >
constexpr bool	is_distributed_la = false
	Whether a linear algebra type distributes its rows across MPI ranks.
template<typename T >
constexpr bool	is_autodiff_real_v = is_autodiff_real<T>::value
template<typename T >
constexpr bool	is_periodic_coordinate_v = internal::coord_periodic<T>::value
	Whether a 1D coordinate class describes a periodic axis, i.e. one where the last grid point is followed again by the first one. Detected through a static constexpr bool periodic member, defaulting to false.
template<typename C , size_t i>
constexpr bool	is_periodic_axis_v = internal::axis_periodic<C, i>::value
	Whether axis i of a (possibly multi-dimensional) coordinate system is periodic. Falls back to false for coordinate systems which do not expose their axes as separate types, e.g. BosonicCoordinates1DFiniteT.
template<class K >
constexpr bool	kernel_is_matsubara_even = requires { requires K::matsubara_even; }
template<class K >
constexpr bool	kernel_has_finite_matsubara_extent = requires { requires K::matsubara_finite_extent; }
template<class K >
constexpr bool	kernel_has_matsubara_split = requires { requires K::matsubara_split; }
constexpr int	n_map_resources = 2
template<typename Coordinates >
constexpr bool	has_cacheable_positions_v
	Whether a coordinates type carries enough identity for QuadratureIntegrator::map() to cache its forward()-transformed positions in a device view (one forward() per grid point instead of per thread). Namespace-scope on purpose: it is referenced inside extended device lambdas, where nvcc mishandles function-local constexpr variables.

Detailed Description

This is the top-level namespace of the DiFfRG library. It contains all the classes and functions of the library.

Typedef Documentation

CPU_memory

using DiFfRG::CPU_memory = Kokkos::DefaultHostExecutionSpace::memory_space

cxReal

template<size_t N, typename T >

using DiFfRG::cxReal = autodiff::Real<N, complex<T>>

cxreal

using DiFfRG::cxreal = autodiff::Real<1, complex<double>>

DefaultLinearSolver

template<typename SparseMatrixType , typename VectorType >

using DiFfRG::DefaultLinearSolver = typename internal::_default_solver<SparseMatrixType, VectorType>::type

The build-configuration-dependent default linear solver.

The indirection through _default_solver is load-bearing and must not be "simplified" to using DefaultLinearSolver = UMFPack<...>. As a template template argument, a simple alias is collapsed to the template it names by GCC but not by Clang; an indirect one is kept distinct by both. Since the timesteppers are compiled out of line, a spelling that collapses on one compiler and not the other would match the explicit instantiations in src/ only where it collapses, and produce undefined references everywhere else.

The consequence of staying distinct is worth knowing: TimeStepperSUNDIALS_IDA_impl<Assembler> and TimeStepperSUNDIALS_IDA_impl<Assembler, UMFPack> are different types even in a serial build, and both need their own explicit instantiation.

DefaultTriangulation

template<int dim>

using DiFfRG::DefaultTriangulation = dealii::Triangulation<dim>

ExtractorDescriptor

template<typename... descriptors>

using DiFfRG::ExtractorDescriptor = SubDescriptor<descriptors...>

FEFunctionDescriptor

template<typename... descriptors>

using DiFfRG::FEFunctionDescriptor = SubDescriptor<descriptors...>

FocusedBosonicCoordinates1DFiniteT

using DiFfRG::FocusedBosonicCoordinates1DFiniteT = BosonicCoordinates1DFiniteT<int, double, FocusedLogCoordinates1D<double>>

FocusedFermionicCoordinates1DFiniteT

using DiFfRG::FocusedFermionicCoordinates1DFiniteT

Initial value:

 
      FermionicCoordinates1DFiniteT<int, double, FocusedLogCoordinates1D<double>>

FocusedLogCoordinates

using DiFfRG::FocusedLogCoordinates = FocusedLogCoordinates1D<double>

FocusedLogLinCoordinates

using DiFfRG::FocusedLogLinCoordinates = CoordinatePackND<FocusedLogCoordinates1D<double>, LinearCoordinates1D<double>>

FocusedLogLinLinCoordinates

using DiFfRG::FocusedLogLinLinCoordinates

Initial value:

 CoordinatePackND<FocusedLogCoordinates1D<double>, LinearCoordinates1D<double>,
                                                       LinearCoordinates1D<double>>

FocusedLogLinLinPeriodicCoordinates

using DiFfRG::FocusedLogLinLinPeriodicCoordinates

Initial value:

 
      CoordinatePackND<FocusedLogCoordinates1D<double>, LinearCoordinates1D<double>,
                       LinearPeriodicCoordinates1D<double>>

FocusedLogLinPeriodicCoordinates

using DiFfRG::FocusedLogLinPeriodicCoordinates

Initial value:

 
      CoordinatePackND<FocusedLogCoordinates1D<double>, LinearPeriodicCoordinates1D<double>>

GPU_exec

using DiFfRG::GPU_exec = ExecutionSpaces::GPU_exec_space

GPU_memory

using DiFfRG::GPU_memory = ExecutionSpaces::GPU_memory_space

HDF5Action

using DiFfRG::HDF5Action = std::function<void(HDF5FrameContext &)>

One write, deferred. Closures capture their payload by value: callers hand us pointers into live simulation state (Examples/YangMills/Full/model.hh passes &variables.data()[idxv("ZA")]) which the next timestep overwrites.

IDACallbackDiagnostics

using DiFfRG::IDACallbackDiagnostics = SolverCallbackDiagnostics

KokkosHost_exec

using DiFfRG::KokkosHost_exec = ExecutionSpaces::KokkosHost_exec_space

KokkosHost_memory

using DiFfRG::KokkosHost_memory = ExecutionSpaces::KokkosHost_memory_space

KokkosNDRange

template<int dim, typename ExecutionSpace >

using DiFfRG::KokkosNDRange = KokkosNDRangeHelper<dim, ExecutionSpace>::type

KokkosNDView

template<int dim, typename T , typename ExecutionSpace >

using DiFfRG::KokkosNDView

Initial value:

 Kokkos::View<typename GetKokkosNDStarType<dim, T>::type, 
                                                                                
                                    ExecutionSpace                              
                                    >

KokkosNDViewRestrict

template<int dim, typename T , typename ExecutionSpace >

using DiFfRG::KokkosNDViewRestrict

Initial value:

 
      Kokkos::View<typename GetKokkosNDStarType<dim, T>::type, 
                                                               
                   ExecutionSpace,                             
                   Kokkos::MemoryTraits<Kokkos::Restrict>      
                   >

KokkosNDViewUnmanaged

template<int dim, typename T , typename ExecutionSpace >

using DiFfRG::KokkosNDViewUnmanaged

Initial value:

 
      Kokkos::View<typename GetKokkosNDStarType<dim, T>::type, 
                                                               
                   ExecutionSpace,                             
                   Kokkos::MemoryTraits<Kokkos::Unmanaged>     
                   >

LASparseMatrixFor

template<typename Mesh , typename NumberType >

using DiFfRG::LASparseMatrixFor = dealii::SparseMatrix<NumberType>

LAVectorFor

template<typename Mesh , typename NumberType >

using DiFfRG::LAVectorFor = dealii::Vector<NumberType>

LinCoordinates

using DiFfRG::LinCoordinates = LinearCoordinates1D<double>

LinearInterpolatorND

template<typename NT , typename Coordinates >

using DiFfRG::LinearInterpolatorND = typename LinearInterpolatorND_helper<Coordinates::dim, NT, Coordinates>::type

A linear interpolator for ND data, callable from host and device code alike.

Template Parameters

NT	input data type
Coordinates	coordinate system of the input data

LinLinCoordinates

using DiFfRG::LinLinCoordinates = CoordinatePackND<LinearCoordinates1D<double>, LinearCoordinates1D<double>>

LinLinLinCoordinates

using DiFfRG::LinLinLinCoordinates

Initial value:

 
      CoordinatePackND<LinearCoordinates1D<double>, LinearCoordinates1D<double>, LinearCoordinates1D<double>>

LinLogCoordinates

using DiFfRG::LinLogCoordinates = CoordinatePackND<LinearCoordinates1D<double>, LogarithmicCoordinates1D<double>>

LinPeriodicCoordinates

using DiFfRG::LinPeriodicCoordinates = LinearPeriodicCoordinates1D<double>

LogCoordinates

using DiFfRG::LogCoordinates = LogarithmicCoordinates1D<double>

LogLinCoordinates

using DiFfRG::LogLinCoordinates = CoordinatePackND<LogarithmicCoordinates1D<double>, LinearCoordinates1D<double>>

LogLinLinCoordinates

using DiFfRG::LogLinLinCoordinates

Initial value:

 
      CoordinatePackND<LogarithmicCoordinates1D<double>, LinearCoordinates1D<double>, LinearCoordinates1D<double>>

LogLinLinPeriodicCoordinates

using DiFfRG::LogLinLinPeriodicCoordinates

Initial value:

 CoordinatePackND<LogarithmicCoordinates1D<double>, LinearCoordinates1D<double>,
                                                        LinearPeriodicCoordinates1D<double>>

LogLinPeriodicCoordinates

using DiFfRG::LogLinPeriodicCoordinates

Initial value:

 
      CoordinatePackND<LogarithmicCoordinates1D<double>, LinearPeriodicCoordinates1D<double>>

LogLogCoordinates

using DiFfRG::LogLogCoordinates = CoordinatePackND<LogarithmicCoordinates1D<double>, LogarithmicCoordinates1D<double>>

LogLogLinCoordinates

using DiFfRG::LogLogLinCoordinates

Initial value:

 
      CoordinatePackND<LogarithmicCoordinates1D<double>, LogarithmicCoordinates1D<double>, LinearCoordinates1D<double>>

OutputSession

template<typename AssemblerOrDiscretization >

using DiFfRG::OutputSession

Initial value:

 
      OutputSession_impl<AssemblerOrDiscretization::dim, typename AssemblerOrDiscretization::VectorType>

OutputSettings

using DiFfRG::OutputSettings = Config::OutputSettings

PinnedHost_memory

using DiFfRG::PinnedHost_memory = CPU_memory

Host memory the device can DMA to/from without staging, i.e. page-locked.

A device-to-*pageable*-host cudaMemcpyAsync is synchronous in practice, because the driver must bounce it through its own pinned buffer; copying into this space instead is what makes an asynchronous result copy actually asynchronous. Falls back to ordinary host memory when there is no CUDA backend, where the distinction does not exist.

RectangularMeshSerial

template<uint dim>

using DiFfRG::RectangularMeshSerial = RectangularMesh<dim, dealii::Triangulation<dim>>

A rectangular mesh pinned to a serial triangulation, whatever the build configuration.

Name this when a run must stay serial in an MPI build: LDG, which cannot be distributed at all, and any test compared against a stored reference, which must produce the same numbers in a serial and an MPI build tree.

Naming it is sufficient on its own: a Discretization defaults its vector and matrix from the mesh (see LAVectorFor in common/linear_algebra.hh), so this pins the linear algebra serial too rather than leaving it on the build-configuration default.

ScaledGMRES

template<typename SparseMatrixType , typename VectorType , typename PreconditionerType = dealii::PreconditionIdentity>

using DiFfRG::ScaledGMRES

Initial value:

 
      ScaledLinearSolver<SparseMatrixType, VectorType, GMRES<SparseMatrixType, VectorType, PreconditionerType>>

ScaledUMFPack

template<typename SparseMatrixType , typename VectorType >

using DiFfRG::ScaledUMFPack = ScaledLinearSolver<SparseMatrixType, VectorType, UMFPack<SparseMatrixType, VectorType>>

TBB_exec

using DiFfRG::TBB_exec = ExecutionSpaces::TBB_exec_space

TBB_memory

using DiFfRG::TBB_memory = ExecutionSpaces::TBB_memory_space

TimeStepperBoostABM

template<typename Assembler >

using DiFfRG::TimeStepperBoostABM

Initial value:

 
      TimeStepperBoostABM_impl<typename Assembler::VectorType, typename Assembler::SparseMatrixType, Assembler::dim>

TimeStepperBoostRK

template<typename Assembler , int prec>

using DiFfRG::TimeStepperBoostRK

Initial value:

 TimeStepperBoostRK_impl<typename Assembler::VectorType,
                                                     typename Assembler::SparseMatrixType, Assembler::dim, prec>

TimeStepperBoostRK54

template<typename Assembler >

using DiFfRG::TimeStepperBoostRK54 = TimeStepperBoostRK<Assembler, 0>

Time stepping with the adaptive Boost Cash-Karp54 method.

TimeStepperBoostRK78

template<typename Assembler >

using DiFfRG::TimeStepperBoostRK78 = TimeStepperBoostRK<Assembler, 1>

Time stepping with the adaptive Boost Fehlberg78 method.

TimeStepperExplicitEuler

template<typename Assembler >

using DiFfRG::TimeStepperExplicitEuler

Initial value:

 TimeStepperExplicitEuler_impl<typename Assembler::VectorType,
                                                                 typename Assembler::SparseMatrixType, Assembler::dim>

TimeStepperImplicitEuler

template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>

using DiFfRG::TimeStepperImplicitEuler

Initial value:

 
      TimeStepperImplicitEuler_impl<typename Assembler::VectorType, typename Assembler::SparseMatrixType,
                                    Assembler::dim, LinearSolver>

TimeStepperRK

template<typename Assembler >

using DiFfRG::TimeStepperRK

Initial value:

 
      TimeStepperRK_impl<typename Assembler::VectorType, typename Assembler::SparseMatrixType, Assembler::dim>

TimeStepperSUNDIALS_IDA

template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>

using DiFfRG::TimeStepperSUNDIALS_IDA

Initial value:

 
      TimeStepperSUNDIALS_IDA_impl<typename Assembler::VectorType, typename Assembler::SparseMatrixType, Assembler::dim,
                                   LinearSolver>

TimeStepperSUNDIALS_IDA_BoostABM

template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>

using DiFfRG::TimeStepperSUNDIALS_IDA_BoostABM

Initial value:

 
      TimeStepperSUNDIALS_IDA_BoostABM_impl<typename Assembler::VectorType, typename Assembler::SparseMatrixType,
                                            Assembler::dim, LinearSolver>

TimeStepperSUNDIALS_IDA_BoostRK

template<typename Assembler , template< typename... > typename LinearSolver, int prec>

using DiFfRG::TimeStepperSUNDIALS_IDA_BoostRK

Initial value:

 
      TimeStepperSUNDIALS_IDA_BoostRK_impl<typename Assembler::VectorType, typename Assembler::SparseMatrixType,
                                           Assembler::dim, LinearSolver, prec>

TimeStepperSUNDIALS_IDA_BoostRK54

template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>

using DiFfRG::TimeStepperSUNDIALS_IDA_BoostRK54 = TimeStepperSUNDIALS_IDA_BoostRK<Assembler, LinearSolver, 0>

Boost Cash-Karp54 for the explicit part, SUNDIALS IDA for the implicit part.

IDA is the controller; the Boost RK stepper solves the explicit part on demand.

TimeStepperSUNDIALS_IDA_BoostRK78

template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>

using DiFfRG::TimeStepperSUNDIALS_IDA_BoostRK78 = TimeStepperSUNDIALS_IDA_BoostRK<Assembler, LinearSolver, 1>

Boost Fehlberg78 for the explicit part, SUNDIALS IDA for the implicit part.

TimeStepperTRBDF2

template<typename Assembler , template< typename... > typename LinearSolver = DefaultLinearSolver>

using DiFfRG::TimeStepperTRBDF2

Initial value:

 TimeStepperTRBDF2_impl<typename Assembler::VectorType, typename Assembler::SparseMatrixType,
                                                   Assembler::dim, LinearSolver>

uint

using DiFfRG::uint = unsigned int

VariableDescriptor

template<typename... descriptors>

using DiFfRG::VariableDescriptor = SubDescriptor<descriptors...>

Enumeration Type Documentation

ImplicitTimestepperKind

enum class DiFfRG::ImplicitTimestepperKind : unsigned int

strong

Enumerator
ida
ida_boost_rk
ida_boost_abm
implicit_euler
trbdf2

ImplicitTimestepperStage

enum class DiFfRG::ImplicitTimestepperStage : unsigned int

strong

Enumerator
main
trapezoidal
bdf2

MapResource

enum class DiFfRG::MapResource : int

strong

The physical resource a map() competes for.

A rank owns both: one GPU and a slice of the node's cores. Work placed on one does not make the other busy, and in a DeferredMaps scope the two genuinely run at the same time – the device path launches asynchronously and returns, so a host map issued after it executes while the device is still working. Ownership is therefore balanced against a separate budget per resource; see MapScheduler::least_loaded.

Enumerator
device
host

TemporaryRetention

enum class DiFfRG::TemporaryRetention

strong

Enumerator
remove_on_destruction
keep

ThreadSource

enum class DiFfRG::ThreadSource

strong

Where the CPU thread budget came from, in order of precedence (highest first).

DiFfRG runs its CPU work on a single TBB pool, so there is exactly one number to resolve, and several places that may want to set it. They are ranked rather than combined: a launcher knows more about the machine than a parameter file does, and an explicit environment variable is the user overruling both.

Enumerator
diffrg_env	DiFfRG_NUM_THREADS (or DIFFRG_NUM_THREADS).
launcher	The CPU allocation this process was given: its affinity mask, or SLURM_* if it has none.
config	/discretization/threads.
other_env	OMP_NUM_THREADS, DEAL_II_NUM_THREADS, KOKKOS_NUM_THREADS.
automatic	Nothing was set: the machine, divided among the node-local ranks that share its CPUs.

Function Documentation

_jacobian_2_tuple()

template<typename T_inner , typename Model , size_t... IDXs>

auto DiFfRG::_jacobian_2_tuple

(

std::index_sequence< IDXs... >

)

_jacobian_tuple()

template<typename T_inner , typename Model , size_t... IDXs>

auto DiFfRG::_jacobian_tuple

(

std::index_sequence< IDXs... >

)

_local_sol_tuple()

template<typename T , size_t N, size_t... IDXs>

auto DiFfRG::_local_sol_tuple	(	const std::array< T, N > &	a,
		std::index_sequence< IDXs... >	,
		uint	q_index )

all_set_k()

template<typename Int >

void DiFfRG::all_set_k	(	Int &	integrator,
		const double	k )

all_set_T()

template<typename Int >

void DiFfRG::all_set_T	(	Int &	integrator,
		const double	T )

all_set_typical_E()

template<typename Int >

void DiFfRG::all_set_typical_E	(	Int &	integrator,
		const double	typical_E )

all_set_x_extent()

template<typename Int >

void DiFfRG::all_set_x_extent	(	Int &	integrator,
		const double	x_extent )

analyze_jacobian_matrix()

template<typename MatrixType >

JacobianMatrixDiagnostics DiFfRG::analyze_jacobian_matrix

(

const MatrixType &

matrix

)

check_kernel_requirements()

template<typename NT , typename KERNEL , typename ctype , int dim, typename... ARGS>

void DiFfRG::check_kernel_requirements ( )

consteval

compute_divisible_tile()

template<int dim>

device::array< size_t, dim > DiFfRG::compute_divisible_tile	(	const device::array< size_t, dim > &	extents,
		const device::array< size_t, dim > &	kokkos_tile,
		size_t	budget )

A tile whose every dimension divides its extent, so no lane is launched masked.

Parameters

extents	iteration-space extents
kokkos_tile	the tile Kokkos would have chosen; used as the seed and as the tie-breaker, so this function inherits Kokkos' architecture-specific recommendation rather than duplicating it (which would silently drift on a Kokkos bump)
budget	maximum tile product, i.e. the block size ceiling

Among all tiles that divide their extents and fit the budget, take the largest product – a bigger block means fewer blocks and less of the register file lost to per-warp allocation granularity – breaking ties toward Kokkos' shape, which encodes the coalescing preference on dim 0. Returns kokkos_tile unchanged when it already divides everything, so architectures and models that were already clean (e.g. YangMills, whose orders are 8) are untouched.

compute_tile_hints()

template<int dim>

device::array< size_t, dim > DiFfRG::compute_tile_hints	(	const device::array< size_t, dim > &	extents,
		size_t	max_threads = 256 )

Compute clamped tile sizes for MDRangePolicy so that the product of tile dimensions does not exceed max_threads. Fills from the innermost (last) dimension outward.

compute_variables_into()

template<typename VectorType , typename Fn >

void DiFfRG::compute_variables_into	(	VectorType &	dst,
		VectorType &	scratch,
		Fn &&	compute )

Run a model's variables computation and land the result in the distributed block.

The models write their variables residual entry by entry (residual[i] = ...). Under distribution that block is owned outright by rank 0, so on every other rank the destination has no local entries at all and the writes would go into PETSc's off-process stash – n_ranks ranks each inserting the same index, with no compress() anywhere to resolve it.

The computation is redundant and identical on every rank anyway (its inputs are the replicated variables view and the replicated solution), so compute into a process-local scratch vector and copy back only what this rank owns.

The serial branch calls compute directly on the destination, so the serial path keeps exactly today's instruction sequence and stays bit-exact.

Parameters

scratch

a process-local vector of full variables size, from reinit_local_variables_vector.

constexpr_for()

template<auto Start, auto End, auto Inc, class F >

void DiFfRG::constexpr_for ( F && f )

constexpr

A compile-time for loop, which calls the lambda f of signature void(integer) for each index.

CothFiniteT()

template<typename T1 , typename T2 >
requires (std::is_arithmetic_v<T2>)

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::CothFiniteT	(	const T1	x,
		const T2	T )

cothS()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::cothS	(	const T1	e,
		const T2	T )

create_folder()

bool DiFfRG::create_folder

(

const std::string &

path_

)

Creates the directory path, even if its parent directories should not exist.

CschFiniteT()

template<typename T1 , typename T2 >
requires (std::is_arithmetic_v<T2>)

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::CschFiniteT	(	const T1	x,
		const T2	T )

cschS()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::cschS	(	const T1	e,
		const T2	T )

dcothS()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::dcothS	(	const T1	e,
		const T2	T )

ddcothS()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::ddcothS	(	const T1	e,
		const T2	T )

dddcothS()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::dddcothS	(	const T1	e,
		const T2	T )

ddnB()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::ddnB	(	const T1	e,
		const T2	T )

ddtanhS()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::ddtanhS	(	const T1	e,
		const T2	T )

dealii_to_eigen() [1/2]

void DiFfRG::dealii_to_eigen	(	const dealii::BlockVector< double > &	dealii,
		Eigen::VectorXd &	eigen )

Converts a dealii block vector to an Eigen vector.

Parameters

dealii	a dealii block vector
eigen	an Eigen vector

dealii_to_eigen() [2/2]

void DiFfRG::dealii_to_eigen	(	const dealii::Vector< double > &	dealii,
		Eigen::VectorXd &	eigen )

Converts a dealii vector to an Eigen vector.

Parameters

dealii	a dealii vector
eigen	an Eigen vector

dense_vmult_variables()

template<typename VectorType , typename NumberType >

void DiFfRG::dense_vmult_variables	(	const dealii::FullMatrix< NumberType > &	matrix,
		VectorType &	dst,
		const VectorType &	src,
		MPI_Comm	comm )

Apply a dense matrix to the extra-variables block.

The variables block is small, dense, and owned outright by rank 0 (variables_owner_set), so on every other rank src is locally empty and dealii::FullMatrix::vmult – which indexes elements directly – cannot be applied to it at all.

Broadcast from the owner, apply the dense operator redundantly on every rank, then write back only what each rank owns. Broadcasting rather than sum-reducing partial contributions is deliberate: it is exact. A sum over zero-filled buffers would turn a -0.0 into +0.0 and is not bit-safe, which is the same reason MPI::allgatherv_bytes exists instead of an Allreduce.

Redundant application is the right trade here: the matrix is n_variables squared with n_variables tiny, so replicating the work costs far less than a distributed solve, and it makes every rank agree bit-for-bit without a second collective.

diagonalize_tridiagonal_symmetric_matrix()

template<typename T >

void DiFfRG::diagonalize_tridiagonal_symmetric_matrix	(	std::vector< T > &	d,
		std::vector< T > &	e,
		std::vector< T > &	z )

Diagonalizes a symmetric tridiagonal matrix.

Adapted from https://people.math.sc.edu/burkardt/cpp_src/cpp_src.html

This routine is a slightly modified version of the EISPACK routine to perform the implicit QL algorithm on a symmetric tridiagonal matrix. It produces the product Q' * Z, where Z is an input vector and Q is the orthogonal matrix diagonalizing the input matrix.

Parameters

d	The diagonal elements of the input matrix. On output, d is overwritten by the eigenvalues of the symmetric tridiagonal matrix.
e	The subdiagonal elements of the input matrix. On output, the information in e has been overwritten. Has to be of size d.size(), though the last element is irrelevant.
z	On input, a vector. On output, the value of Q' * Z, where Q is the matrix that diagonalizes the input symmetric tridiagonal matrix. Note that the columns of Q are the eigenvectors of the input matrix, and Q' is the transpose of Q.

dnB()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::dnB	(	const T1	e,
		const T2	T )

dnF()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::dnF	(	const T1	e,
		const T2	T )

dot()

template<uint n, typename NT , typename A1 , typename A2 >
requires requires(A1 a1, A2 a2) { a1[0] * a2[0]; }

NT DiFfRG::dot	(	const A1 &	a1,
		const A2 &	a2 )

A dot product which takes the dot product between a1 and a2, assuming each has n entries which can be accessed via the [] operator.

dtanhS()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::dtanhS	(	const T1	e,
		const T2	T )

dump_grid()

template<typename Coordinates >

std::vector< typename Coordinates::ctype > DiFfRG::dump_grid

(

const Coordinates &

coordinates

)

eigen_to_dealii() [1/2]

void DiFfRG::eigen_to_dealii	(	const Eigen::VectorXd &	eigen,
		dealii::BlockVector< double > &	dealii )

Converts an Eigen vector to a dealii block vector.

Parameters

eigen	an Eigen vector
dealii	a dealii block vector

eigen_to_dealii() [2/2]

void DiFfRG::eigen_to_dealii	(	const Eigen::VectorXd &	eigen,
		dealii::Vector< double > &	dealii )

Converts an Eigen vector to a dealii vector.

Parameters

eigen	an Eigen vector
dealii	a dealii vector

evaluate_raw_potential() [1/2]

template<int dim, typename NumberType >

RawPotentialEvaluation< dim, NumberType > DiFfRG::evaluate_raw_potential	(	const ReconstructedRawPotential< dim, NumberType > &	potential,
		const dealii::Mapping< dim > &	mapping,
		const dealii::Point< dim > &	point )

Evaluate a reconstructed raw potential and its mass-extraction Hessian at a real-space point.

potential_hessian is exactly the second derivative of value. mass_hessian equals it unless FV mass-Hessian recovery was requested, in which case it contains the independently recovered tensor intended for observables.

evaluate_raw_potential() [2/2]

template<int dim>

UnusedPotentialEvaluation DiFfRG::evaluate_raw_potential	(	const UnusedPotential &	,
		const dealii::Mapping< dim > &	,
		const dealii::Point< dim > &	)

factorial()

template<typename NumberType >
requires std::is_integral_v<NumberType>

KOKKOS_INLINE_FUNCTION NumberType DiFfRG::factorial ( const NumberType & x )

constexpr

factorize_with_diagnostics()

template<typename LinearSolver , typename MatrixType >

void DiFfRG::factorize_with_diagnostics	(	LinearSolver &	solver,
		const MatrixType &	matrix,
		JacobianFactorizationDiagnostics &	diagnostics,
		const bool	estimate_condition )

Factorizes and records how it went. The condition estimate costs several extra triangular solves per call, so estimate_condition switches it off when the diagnostics are not written; the success flag and the timing are always filled, as callers branch on them.

file_exists()

bool DiFfRG::file_exists

(

const std::string &

name

)

Checks if a file exists.

Parameters

name	The name of the file.

finalize_la_sparsity()

template<typename SparseMatrixType >

void DiFfRG::finalize_la_sparsity	(	dealii::DynamicSparsityPattern &	dsp,
		get_type::SparsityPattern< SparseMatrixType > &	pattern,
		const dealii::IndexSet &	locally_owned,
		const dealii::IndexSet &	locally_relevant,
		MPI_Comm	comm )

Turn a freshly built DynamicSparsityPattern into the pattern type the matrix wants.

Distributed: the rows a rank builds are not the rows it owns – a cell worker touching a partition-boundary cell adds entries to rows owned by a neighbour. distribute_sparsity_pattern ships those to their owner. Skipping it does not fail loudly; it produces a matrix that is missing exactly the couplings across partition boundaries, and PETSc then drops the corresponding matrix entries at assembly time.

The distributed branch copies rather than moves because DynamicSparsityPattern declares a copy constructor and so has no implicit move. This runs once per reinit(), not per timestep.

FixedString()

template<unsigned N>

DiFfRG::FixedString

(

char

const(&)[N]

)

-> FixedString< N - 1 >

flush_maps()

void DiFfRG::flush_maps ( )

inline

Land all outstanding map() results. See MapCompletion.

get() [1/3]

template<FixedString name, typename tuple_type , typename strSet >

auto & DiFfRG::get ( const named_tuple< tuple_type, strSet > & ob )

constexpr

get() [2/3]

template<FixedString name, typename tuple_type , typename strSet >

auto & DiFfRG::get ( named_tuple< tuple_type, strSet > && ob )

constexpr

get() [3/3]

template<FixedString name, typename tuple_type , typename strSet >

auto & DiFfRG::get ( named_tuple< tuple_type, strSet > & ob )

constexpr

get a reference to the element with the given name

get_EoM_point() [1/2]

template<int dim, typename VectorType , typename EoMFUN , typename EoMPFUN >

dealii::Point< dim > DiFfRG::get_EoM_point	(	typename dealii::DoFHandler< dim >::cell_iterator &	EoM_cell,
		const VectorType &	sol,
		const dealii::DoFHandler< dim > &	dof_handler,
		const dealii::Mapping< dim > &	mapping,
		const EoMFUN &	get_EoM,
		const EoMPFUN &	EoM_postprocess,
		const Config::EoMConfig &	config,
		const std::optional< dealii::Point< dim > > &	initial_guess = std::nullopt,
		internal::PotentialSystemCache< dim, typename VectorType::value_type > *	cache = nullptr )

Reconstruct a potential whose gradient approximates the model EoM vector field and return a sampled and locally refined minimum of that potential.

get_EoM_point() [2/2]

template<int dim, typename VectorType , typename EoMFUN , typename EoMPFUN >

dealii::Point< dim > DiFfRG::get_EoM_point	(	typename dealii::DoFHandler< dim >::cell_iterator &	EoM_cell,
		const VectorType &	sol,
		const dealii::DoFHandler< dim > &	dof_handler,
		const dealii::Mapping< dim > &	mapping,
		const EoMFUN &	get_EoM,
		const EoMPFUN &	EoM_postprocess = [](const auto &p, [[maybe_unused]] const auto &values) { return p; },
		const double	EoM_abs_tol = Config::EoMConfig::default_abs_tol,
		const uint	max_iter = Config::EoMConfig::default_max_iter,
		const double	EoM_smoothing_length = Config::EoMConfig::default_smoothing_length,
		const std::optional< dealii::Point< dim > > &	initial_guess = std::nullopt )

Compatibility overload accepting the historical scalar EoM settings.

get_EoM_point_with_potential() [1/2]

template<int dim, typename VectorType , typename EoMFUN , typename EoMPFUN >

EoMResult< dim, typename VectorType::value_type > DiFfRG::get_EoM_point_with_potential	(	typename dealii::DoFHandler< dim >::cell_iterator &	EoM_cell,
		const VectorType &	sol,
		const dealii::DoFHandler< dim > &	dof_handler,
		const dealii::Mapping< dim > &	mapping,
		const EoMFUN &	get_EoM,
		const EoMPFUN &	EoM_postprocess,
		const Config::EoMConfig &	config,
		const std::optional< dealii::Point< dim > > &	initial_guess = std::nullopt,
		internal::PotentialSystemCache< dim, typename VectorType::value_type > *	cache = nullptr )

Reconstruct a potential whose gradient approximates the model EoM vector field and return a sampled and locally refined minimum of that potential.

get_EoM_point_with_potential() [2/2]

template<int dim, typename VectorType , typename EoMFUN , typename EoMPFUN >

EoMResult< dim, typename VectorType::value_type > DiFfRG::get_EoM_point_with_potential	(	typename dealii::DoFHandler< dim >::cell_iterator &	EoM_cell,
		const VectorType &	sol,
		const dealii::DoFHandler< dim > &	dof_handler,
		const dealii::Mapping< dim > &	mapping,
		const EoMFUN &	get_EoM,
		const EoMPFUN &	EoM_postprocess = [](const auto &p, [[maybe_unused]] const auto &values) { return p; },
		const double	EoM_abs_tol = Config::EoMConfig::default_abs_tol,
		const uint	max_iter = Config::EoMConfig::default_max_iter,
		const double	EoM_smoothing_length = Config::EoMConfig::default_smoothing_length,
		const std::optional< dealii::Point< dim > > &	initial_guess = std::nullopt,
		internal::PotentialSystemCache< dim, typename VectorType::value_type > *	cache = nullptr )

Compatibility overload accepting the historical scalar EoM settings.

getWithPrecision()

template<typename T >

std::string DiFfRG::getWithPrecision	(	uint	precision,
		T	number )

Return number with fixed precision after the decimal point.

has_suffix()

bool DiFfRG::has_suffix	(	const std::string &	str,
		const std::string &	suffix )

heaviside_theta()

template<typename NumberType >
requires requires(NumberType x) { x >= 0; }

KOKKOS_INLINE_FUNCTION auto DiFfRG::heaviside_theta ( const NumberType x )

constexpr

A compile-time evaluatable theta function.

imag() [1/2]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::imag ( const autodiff::Real< N, T > & )

constexpr

imag() [2/2]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::imag

(

const cxReal< N, T > &

x

)

invoke_set_k() [1/2]

template<typename Int >
requires (!DiFfRG::has_set_k<Int>)

void DiFfRG::invoke_set_k	(	Int &	,
		const double	)

invoke_set_k() [2/2]

template<typename Int >
requires DiFfRG::has_set_k<Int>

void DiFfRG::invoke_set_k	(	Int &	integrator,
		const double	k )

invoke_set_T() [1/2]

template<typename Int >
requires (!DiFfRG::has_set_T<Int>)

void DiFfRG::invoke_set_T	(	Int &	,
		const double	)

invoke_set_T() [2/2]

template<typename Int >
requires DiFfRG::has_set_T<Int>

void DiFfRG::invoke_set_T	(	Int &	integrator,
		const double	T )

invoke_set_typical_E() [1/2]

template<typename Int >
requires (!DiFfRG::has_set_typical_E<Int>)

void DiFfRG::invoke_set_typical_E	(	Int &	,
		const double	)

invoke_set_typical_E() [2/2]

template<typename Int >
requires DiFfRG::has_set_typical_E<Int>

void DiFfRG::invoke_set_typical_E	(	Int &	integrator,
		const double	typical_E )

invoke_set_x_extent() [1/2]

template<typename Int >
requires (!DiFfRG::has_set_x_extent<Int>)

void DiFfRG::invoke_set_x_extent	(	Int &	,
		const double	)

invoke_set_x_extent() [2/2]

template<typename Int >
requires DiFfRG::has_set_x_extent<Int>

void DiFfRG::invoke_set_x_extent	(	Int &	integrator,
		const double	x_extent )

is_close() [1/2]

template<typename T1 , typename T2 >
requires (std::is_floating_point<T1>::value || is_autodiff_real_v<T1> || is_complex<T1>::value) && (std::is_floating_point<T2>::value || is_autodiff_real_v<T2> || is_complex<T2>::value)

bool KOKKOS_INLINE_FUNCTION DiFfRG::is_close	(	T1	a,
		T2	b )

Function to evaluate whether two floats are equal to numerical precision. Tests for both relative and absolute equality.

Returns

bool

is_close() [2/2]

template<typename T1 , typename T2 , typename T3 >
requires (std::is_floating_point<T1>::value || is_autodiff_real_v<T1> || is_complex<T1>::value) && (std::is_floating_point<T2>::value || is_autodiff_real_v<T2> || is_complex<T2>::value) && std::is_floating_point<T3>::value

bool KOKKOS_INLINE_FUNCTION DiFfRG::is_close	(	T1	a,
		T2	b,
		T3	eps_ )

Function to evaluate whether two floats are equal to numerical precision. Tests for both relative and absolute equality.

Parameters

eps_	Precision with which to compare a and b

Returns

bool

isfinite()

template<size_t N, typename T >

bool DiFfRG::isfinite

(

const autodiff::Real< N, T > &

x

)

Finite-ness check for autodiff::real.

Parameters

x	Number to check

Returns

Whether x and its derivative are finite

jacobian_2_tuple()

template<typename T_inner , typename Model >

auto DiFfRG::jacobian_2_tuple

(

)

jacobian_tuple()

template<typename T_inner , typename Model >

auto DiFfRG::jacobian_tuple

(

)

local_sol_q()

template<typename T , size_t N>

auto DiFfRG::local_sol_q	(	const std::array< T, N > &	a,
		uint	q_index )

locally_owned_cells()

template<int dim>

auto DiFfRG::locally_owned_cells

(

const dealii::DoFHandler< dim > &

dof_handler

)

The cells this rank assembles.

mesh_loop visits exactly this range, so a work item carries only cells that do work and a worker never has to re-check ownership. On a serial triangulation the filter accepts every cell, so this is the full mesh and costs one trivial predicate per cell.

make_assembly_schedule()

AssemblySchedule DiFfRG::make_assembly_schedule ( const uint n_local_cells, const uint thread_budget, const double cost_ns, const AssemblyScheduleOverrides & overrides = {} )

inline

Derive one mesh_loop schedule from the cost of a cell.

Both quantities follow from "how much work is this", in this order of priority:

1. a work item must carry enough work that the pipeline hand-off around it is negligible, which fixes the chunk size, and
2. subject to that, spread the remaining work over as many workers as it can pay for.

Because (1) is a per-chunk property it holds at any mesh size, so a mesh too small to fill the pipeline loses workers rather than chunk size. That is the right trade: the cores freed are taken by the momentum integrators' own nested TBB work for the expensive loops, and for the cheap ones a small mesh is measurably faster assembled serially than split up.

Parameters

n_local_cells	cells this rank assembles, i.e. the length of locally_owned_cells().
thread_budget	CPU threads this rank may use, i.e. DiFfRG::n_threads().
cost_ns	estimated cost of one cell, in nanoseconds; see namespace assembly_cost.

make_folder()

std::string DiFfRG::make_folder

(

const std::string &

path

)

Add a trailing '/' to a string, in order for it to be in standard form of a folder path.

make_grid()

template<typename Coordinates >

auto DiFfRG::make_grid

(

const Coordinates &

coordinates

)

make_ida_jacobian_build_diagnostics()

template<typename VectorType >

TimestepperJacobianBuildDiagnostics DiFfRG::make_ida_jacobian_build_diagnostics	(	const SUNDIALS::IDA< VectorType > &	time_stepper,
		const std::size_t	build_id,
		const double	alpha,
		const ImplicitTimestepperKind	stepper_kind = ImplicitTimestepperKind::ida )

make_idx_grid()

template<typename Coordinates >

auto DiFfRG::make_idx_grid

(

const Coordinates &

coordinates

)

-> std::vector<double>

make_interpolation_stencil()

template<bool periodic, typename CT >

KOKKOS_FORCEINLINE_FUNCTION InterpolationStencil< CT > DiFfRG::make_interpolation_stencil	(	CT	idx,
		const size_t	n )

Resolve a fractional grid index into the linear-interpolation stencil along one axis.

For a non-periodic axis the index is clamped to [0, n-1] and the stencil is [lower, lower+1] with lower <= n-2, i.e. evaluations outside the grid are constant-extrapolated from the boundary cell.

For a periodic axis no clamping happens - the coordinate's backward() has already folded the index into [0, n) - and the upper index wraps around to 0 in the last cell, which closes the grid across the seam.

Template Parameters

periodic

whether the axis is periodic, see is_periodic_coordinate_v / is_periodic_axis_v

Parameters

idx	fractional grid index, as returned by Coordinates::backward
n	number of grid points along the axis

make_kokkos_nd_range() [1/2]

template<int dim, typename ExecutionSpace >

auto DiFfRG::make_kokkos_nd_range	(	ExecutionSpace &	space,
		const device::array< size_t, dim >	start,
		const device::array< size_t, dim >	end )

make_kokkos_nd_range() [2/2]

template<int dim, typename ExecutionSpace >

auto DiFfRG::make_kokkos_nd_range	(	ExecutionSpace &	space,
		const device::array< size_t, dim >	start,
		const device::array< size_t, dim >	end,
		const device::array< size_t, dim >	tile )

make_kokkos_nd_range_divisible()

template<int dim, typename ExecutionSpace >

auto DiFfRG::make_kokkos_nd_range_divisible	(	ExecutionSpace &	space,
		const device::array< size_t, dim >	start,
		const device::array< size_t, dim >	end )

Like make_kokkos_nd_range, but re-tiled so no lane is launched masked.

Builds the policy once with Kokkos' own tiling to read back what it chose (m_tile), then rebuilds with a divisibility-corrected tile of at most the same product. Because the product never grows, this cannot trip Kokkos' "tile dimensions exceed LaunchBounds" abort (KokkosExp_MDRangePolicy.hpp:449-462).

Only for parallel_for over a write-per-thread range. Do NOT use it on the parallel_reduce paths: there the tile shape sets the reduction tree, so re-tiling would not be bit-identical.

make_kokkos_nd_thread_range()

template<int dim, typename TeamType >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::make_kokkos_nd_thread_range	(	const TeamType &	team,
		const device::array< size_t, dim >	end )

make_kokkos_nd_view()

template<int dim, typename T , typename ExecutionSpace >

auto DiFfRG::make_kokkos_nd_view	(	const std::string &	label,
		const device::array< size_t, dim > &	extents )

make_kokkos_nd_view_restrict()

template<int dim, typename T , typename ExecutionSpace >

auto DiFfRG::make_kokkos_nd_view_restrict	(	const std::string &	label,
		const device::array< size_t, dim > &	extents )

make_quadrature()

template<typename T >

void DiFfRG::make_quadrature	(	std::vector< T > &	a,
		std::vector< T > &	b,
		const T	mu0,
		std::vector< T > &	x,
		std::vector< T > &	w )

Obtain the quadrature rule from a given three-term recurrence relation.

For a reference, see "Numerical Recipes in C++" by Press et al., third edition, chapter 4.6.2.

Template Parameters

T	numeric type

Parameters

a	Diagonal elements of the tridiagonal Jacobi matrix
b	Squares of the off-diagonal elements of the tridiagonal Jacobi matrix
mu0	The weight function at the left endpoint of the interval
x	Quadrature points (output)
w	Quadrature weights (output)

make_solution_sample() [1/2]

template<int dim, typename NumberType , typename FillFUN >

SolutionSample< dim, NumberType > DiFfRG::make_solution_sample	(	const dealii::DoFHandler< dim > &	dof_handler,
		const dealii::Mapping< dim > &	mapping,
		const uint	n_components,
		const FillFUN &	fill )

Build a SolutionSample, taking values and gradients from a callback.

The geometry – which cells, where their centres are, how wide they are, and the ordering – is fixed here; fill only has to say what the solution is at a given cell centre. This is what lets a finite-volume assembler contribute reconstructed gradients (its DG0 shape functions have none) without duplicating any of the traversal.

Parameters

fill	void(cell, point, std::vector<NumberType> &values, std::vector<Tensor<1,dim,NumberType>> &gradients), with both output vectors pre-sized to n_components.

make_solution_sample() [2/2]

template<int dim, typename VectorType >

SolutionSample< dim, typename VectorType::value_type > DiFfRG::make_solution_sample	(	const VectorType &	solution,
		const dealii::DoFHandler< dim > &	dof_handler,
		const dealii::Mapping< dim > &	mapping )

Build a SolutionSample by evaluating the finite-element solution at each cell centre.

The general path, correct for any continuous or discontinuous element. Note that for a DG0 (finite-volume) solution the gradients come out identically zero, because the shape functions are constant – such an assembler should reconstruct them and use the callback overload above.

make_timestepping_diagnostics()

template<typename VectorType >

TimesteppingDiagnostics DiFfRG::make_timestepping_diagnostics	(	const SUNDIALS::IDA< VectorType > &	time_stepper,
		const IDACallbackDiagnostics &	callbacks )

map_fill_threshold()

template<typename ExecutionSpace >

double DiFfRG::map_fill_threshold ( )

inline

The fill threshold alone, for callers that do not need the resource class.

map_target()

template<typename ExecutionSpace >

MapTarget DiFfRG::map_target ( )

inline

The scheduling target of an execution space, selected at compile time.

memory_space == CPU_memory is the same test map_dist() uses to pick its staging path, so a CUDA-less build – where GPU_exec is the host space – automatically resolves to the host resource and threshold with no configuration at all, collapsing back to a single budget.

multidim_kernel_call()

template<typename NT , typename KERNEL , typename ctype , int dim, typename... ARGS>

NT DiFfRG::multidim_kernel_call

(

const ARGS &...

args

)

n_locally_owned_cells()

template<typename Discretization >

uint DiFfRG::n_locally_owned_cells

(

const Discretization &

discretization

)

How many cells locally_owned_cells() yields.

Kept beside it on purpose: the schedule is sized for the range the loop walks, and the two disagreeing would size the pipeline for work that is not there. Plain Triangulation has no n_locally_owned_active_cells(), hence the dispatch.

n_threads()

unsigned int DiFfRG::n_threads

(

)

The CPU thread budget this process resolved.

This is the number every DiFfRG component sizes itself against: the assembly schedule, the host/device split of the map scheduler, and the TBB arena itself. Resolved once by DiFfRG::Init, or by set_thread_limit() for embedders that never construct an Init.

Deliberately not a synonym for dealii::MultithreadInfo::n_threads(). That is a mutable static which every set_thread_limit() call rewrites – silently taking the minimum with DEAL_II_NUM_THREADS as it goes – so the value read back out of deal.II is not necessarily the value DiFfRG resolved. The two are kept in agreement here by construction: this returns what deal.II actually installed, after the precedence rules have been applied.

Before resolution it reports TBB's live concurrency, so an embedder that skips Init still gets a usable number rather than a zero.

n_threads_source()

ThreadSource DiFfRG::n_threads_source

(

)

Which rule produced n_threads(). ThreadSource::automatic before anything has been resolved.

nB()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::nB	(	const T1	e,
		const T2	T )

nF()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::nF	(	const T1	e,
		const T2	T )

NoAdaptivity()

template<typename AssemblerOrDiscretization >

DiFfRG::NoAdaptivity

(

const AssemblerOrDiscretization &

)

-> NoAdaptivity< typename AssemblerOrDiscretization::VectorType >

operator*() [1/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator*	(	const autodiff::Real< N, T > &	x,
		const complex< double > &	y )

operator*() [2/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator*	(	const autodiff::Real< N, T > &	x,
		const cxReal< N, T > &	y )

operator*() [3/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator*	(	const complex< double > &	x,
		const autodiff::Real< N, T > &	y )

operator*() [4/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator*	(	const complex< double > &	x,
		const cxReal< N, T > &	y )

operator*() [5/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator*	(	const cxReal< N, T > &	x,
		const autodiff::Real< N, T > &	y )

operator*() [6/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator*	(	const cxReal< N, T > &	x,
		const complex< double > &	y )

operator+() [1/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator+	(	const autodiff::Real< N, T > &	x,
		const complex< double > &	y )

operator+() [2/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator+	(	const autodiff::Real< N, T > &	x,
		const cxReal< N, T > &	y )

operator+() [3/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator+	(	const complex< double > &	x,
		const autodiff::Real< N, T > &	y )

operator+() [4/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator+	(	const complex< double > &	x,
		const cxReal< N, T > &	y )

operator+() [5/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator+	(	const cxReal< N, T > &	x,
		const autodiff::Real< N, T > &	y )

operator+() [6/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator+	(	const cxReal< N, T > &	x,
		const complex< double > &	y )

operator-() [1/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator-	(	const autodiff::Real< N, T > &	x,
		const complex< double > &	y )

operator-() [2/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator-	(	const autodiff::Real< N, T > &	x,
		const cxReal< N, T > &	y )

operator-() [3/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator-	(	const complex< double > &	x,
		const autodiff::Real< N, T > &	y )

operator-() [4/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator-	(	const complex< double > &	x,
		const cxReal< N, T > &	y )

operator-() [5/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator-	(	const cxReal< N, T > &	x,
		const autodiff::Real< N, T > &	y )

operator-() [6/6]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator-	(	const cxReal< N, T > &	x,
		const complex< double > &	y )

operator/() [1/7]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator/	(	const autodiff::Real< N, T > &	x,
		const complex< double > &	y )

operator/() [2/7]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator/	(	const autodiff::Real< N, T > &	x,
		const cxReal< N, T > &	y )

operator/() [3/7]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator/	(	const complex< double > &	x,
		const autodiff::Real< N, T > &	y )

operator/() [4/7]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator/	(	const complex< double > &	x,
		const cxReal< N, T > &	y )

operator/() [5/7]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator/	(	const cxReal< N, T > &	x,
		const autodiff::Real< N, T > &	y )

operator/() [6/7]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator/	(	const cxReal< N, T > &	x,
		const complex< double > &	y )

operator/() [7/7]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::operator/	(	const double	x,
		const cxReal< N, T > &	y )

operator<()

bool DiFfRG::operator<	(	const QuadratureType &	x,
		const QuadratureType &	y )

optimize_x_extent()

template<typename Regulator , int dim = 4>

double DiFfRG::optimize_x_extent

(

const ConfigTree &

config

)

parse_csv()

CsvTable DiFfRG::parse_csv	(	std::string_view	content,
		const CsvDialect &	dialect = {},
		std::string_view	origin = {} )

Parse CSV held in memory into a numeric table.

Parameters

content	The CSV text.
dialect	The separator, header and comment conventions to apply.
origin	A name for the source, used only to decorate diagnostics.

parse_csv_cell()

double DiFfRG::parse_csv_cell

(

std::string_view

field

)

Parse a single numeric cell, yielding NaN for anything that is not a number.

powr()

template<int n, typename NumberType >
requires requires(NumberType x) { x * x; NumberType(1.) / x; }

KOKKOS_INLINE_FUNCTION NumberType DiFfRG::powr ( const NumberType x )

constexpr

A compile-time evaluatable power function for whole number exponents.

Template Parameters

n	Exponent of type int
RF	Type of argument

Parameters

x

Argument

Returns

x^n

read_csv()

CsvTable DiFfRG::read_csv	(	const std::string &	path,
		const CsvDialect &	dialect = {} )

Read a CSV file into a numeric table.

Parameters

path	The file to read.
dialect	The separator, header and comment conventions to apply.

Exceptions

std::runtime_error

if the file cannot be opened.

real() [1/2]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::real

(

const autodiff::Real< N, T > &

a

)

real() [2/2]

template<size_t N, typename T >

KOKKOS_FORCEINLINE_FUNCTION auto DiFfRG::real

(

const cxReal< N, T > &

x

)

reconstruct_raw_potential()

template<int dim, typename VectorType , typename GradientFUN >

ReconstructedRawPotential< dim, typename VectorType::value_type > DiFfRG::reconstruct_raw_potential	(	const VectorType &	sol,
		const dealii::DoFHandler< dim > &	dof_handler,
		const dealii::Mapping< dim > &	mapping,
		const GradientFUN &	get_gradient,
		const Config::EoMConfig &	config,
		internal::PotentialSystemCache< dim, typename VectorType::value_type > *	cache = nullptr )

Reconstruct a scalar raw potential without locating its minimum.

The supplied callback must return the unmodified gradient of the desired scalar potential. Unlike an EoM callback, it must not include explicit-breaking or other terms which should be absent from readouts and extractors.

record_jacobian_diagnostics()

void DiFfRG::record_jacobian_diagnostics ( const DiagnosticPort & diagnostics, const std::string & table, const double t, const TimestepperJacobianBuildDiagnostics & build, const JacobianMatrixDiagnostics & matrix, const JacobianFactorizationDiagnostics & factorization )

inline

reinit_la_block_vector()

template<typename BlockVectorType >

void DiFfRG::reinit_la_block_vector	(	BlockVectorType &	vec,
		const std::vector< uint > &	block_structure,
		const dealii::IndexSet &	locally_owned,
		MPI_Comm	comm )

Size a block vector: block 0 is the FE dofs, block 1 (if present) the extra variables.

The two blocks get different ownership policies, and the reason is not symmetric:

• Block 0 is partitioned by the dof distribution, like any FE vector.
• Block 1 holds the model's extra variables. Its right hand side comes from map(), which is already computed identically on every rank, and essentially every consumer needs all of it. PETSc block vectors have no replicated block, so it is owned outright by rank 0 and read elsewhere through a SolutionView. Giving every rank the whole block instead would make each entry owned n_ranks times, and IDA would then see a state vector n_ranks times too long.

Parameters

variable_owner

the rank that owns block 1. Fixed at 0 rather than exposed, so the layout cannot silently differ between two places that both build one of these.

reinit_la_matrix()

template<typename SparseMatrixType >

void DiFfRG::reinit_la_matrix	(	SparseMatrixType &	matrix,
		const get_type::SparsityPattern< SparseMatrixType > &	pattern,
		const dealii::IndexSet &	locally_owned,
		MPI_Comm	comm )

Size a matrix from a finalized sparsity pattern.

reinit_la_variables_vector()

template<typename VectorType >

void DiFfRG::reinit_la_variables_vector	(	VectorType &	vec,
		const dealii::types::global_dof_index	n_vars,
		MPI_Comm	comm )

Size a standalone vector holding only the extra variables.

reinit_la_vector()

template<typename VectorType >

void DiFfRG::reinit_la_vector	(	VectorType &	vec,
		const dealii::IndexSet &	locally_owned,
		MPI_Comm	comm )

Size a vector to the rank's share of the rows.

Serial: the plain size-only reinit, exactly as before. Distributed: PETSc needs the owned IndexSet and a communicator – there is no size-only reinit that would give a correct partitioning, which is why this indirection exists rather than a plain vec.reinit(n).

reinit_local_variables_vector()

template<typename VectorType >

void DiFfRG::reinit_local_variables_vector	(	VectorType &	vec,
		const dealii::types::global_dof_index	n_vars )

Size a process-local vector holding every extra variable on every rank.

reinit_variables_view()

template<typename VectorType >

void DiFfRG::reinit_variables_view	(	SolutionView< VectorType > &	view,
		const dealii::types::global_dof_index	n_vars,
		MPI_Comm	comm )

Establish the layout of a fully-replicated view of the extra-variables block.

Separate from the dof-shaped view because the variables block has its own ownership: rank 0 holds all of it (variables_owner_set), so a view built from the dof partition would not fit.

resolve_thread_count()

ThreadResolution DiFfRG::resolve_thread_count

(

const unsigned int

configured_threads

)

Apply the precedence order to the environment and one configured thread count.

Pure: it reads the environment and reports what would win, without installing anything and without touching the environment. DiFfRG::Init calls this and then acts on the result; it is public so the precedence order can be tested directly, rather than through a process-global Init that can only be constructed once.

Parameters

configured_threads

/discretization/threads, or 0 if unset.

restrict_to_owned()

template<typename VectorType >

dealii::IndexSet DiFfRG::restrict_to_owned	(	const dealii::IndexSet &	global_set,
		const dealii::IndexSet &	locally_owned )

Restrict a global index set to what this rank may write.

deal.II builds IDA's differential/algebraic mask by writing every index of the returned set into a distributed vector and then compress(VectorOperation::insert)-ing it (source/sundials/ida.cc). An unrestricted set means every rank writes every index, which is an insert race on the same entries – benign only as long as the values agree, and not something to rely on. Intersecting here makes each entry written by exactly its owner.

S_d()

template<typename NT >

KOKKOS_INLINE_FUNCTION double DiFfRG::S_d ( NT d )

constexpr

Surface of a d-dimensional sphere.

Template Parameters

NT	Type of the number

Parameters

d	Dimension of the sphere

S_d_prec()

template<typename NT >

NT DiFfRG::S_d_prec ( uint d )

consteval

Surface of a d-dimensional sphere (precompiled)

Template Parameters

NT	Type of the number

Parameters

d	Dimension of the sphere

SechFiniteT()

template<typename T1 , typename T2 >
requires (std::is_arithmetic_v<T2>)

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::SechFiniteT	(	const T1	x,
		const T2	T )

sechS()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::sechS	(	const T1	e,
		const T2	T )

serial_mirror()

template<int dim>

const dealii::Triangulation< dim > & DiFfRG::serial_mirror

(

const dealii::Triangulation< dim > &

source

)

A process-local, serial mirror of a (possibly partitioned) triangulation.

Returns source itself when it is already serial, so a serial build allocates nothing and behaves exactly as before.

Why this exists: at the replicated-mesh rung every rank holds the whole mesh and (through SolutionView) the whole solution, so anything that only needs to read the mesh can and should do so without communicating. But deal.II decides collectiveness from the triangulation's type, not from what the caller intends:

• DoFHandler::distribute_dofs() on a parallel triangulation is collective.
• MeshWorker::mesh_loop() visits only the calling rank's cells, and drops faces between two non-owned cells no matter which AssembleFlags are set.
• DataOut::add_data_vector() routes every vector type through a ghosted LinearAlgebra::distributed::BlockVector built on dof_handler.get_mpi_communicator().

Each of those is a hang or a silently truncated result when it runs inside a rank-0-only region such as OutputSession's contributor. Handing that code a serial mirror makes all three local, complete and identical on every rank.

The mirror is cached and refreshed IN PLACE, and the stable address is load-bearing: dealii::DataOut latches onto the triangulation of the first DoFHandler it is handed and never lets go – DataOut_DoFData::clear() resets dofs but leaves triangulation alone, and add_data_vector only re-reads it while it is still null. A fresh mirror per call therefore leaves the output pointing at a destroyed mesh, which surfaces much later as ReferenceCell::get_default_linear_mapping() throwing ExcNotImplemented out of build_patches.

Refreshed when the source mesh changes: the any_change signal covers refinement, coarsening and clearing, and the size comparison covers a source we never managed to connect to.

set_thread_limit() [1/2]

void DiFfRG::set_thread_limit

(

const ConfigTree &

config

)

Limit the number of CPU threads from a configuration tree.

Applies the same precedence order as DiFfRG::Init – environment, launcher allocation, then /discretization/threads – so an embedder that skips Init still honours a cluster allocation.

set_thread_limit() [2/2]

void DiFfRG::set_thread_limit

(

const unsigned int

threads

)

Limit the number of CPU threads this process may use.

Sets deal.II's thread limit, which installs the process-wide tbb::global_control capping every TBB pipeline in deal.II and DiFfRG, and publishes the result through n_threads(). A value of 0 means "all available cores".

Note

This is the unconditional form: it does not consult the environment. Applications go through DiFfRG::Init, which applies the precedence order described at ThreadSource. This exists for tests and for embedders that drive the library without Init.

sign()

template<typename NumberType >
requires requires(NumberType x) { x >= 0; }

KOKKOS_INLINE_FUNCTION auto DiFfRG::sign ( const NumberType x )

constexpr

A compile-time evaluatable sign function.

split_csv_line()

std::vector< std::string > DiFfRG::split_csv_line	(	std::string_view	line,
		char	separator )

Split one CSV line into its fields, honouring quoting.

Exposed because it is the one place that defines what a field boundary is; both the reader and the header path use it.

strings_equal() [1/2]

bool DiFfRG::strings_equal ( char const * a, char const * b )

constexpr

Check if two strings are equal at compile time.

strings_equal() [2/2]

template<unsigned N1, unsigned N2>

bool DiFfRG::strings_equal ( FixedString< N1 > s1, FixedString< N2 > s2 )

consteval

strip_name()

std::string DiFfRG::strip_name

(

const std::string &

name

)

Strips all special characters from a string, e.g. for use in filenames.

Parameters

name	The string to be stripped

Returns

std::string The stripped string

TanhFiniteT()

template<typename T1 , typename T2 >
requires (std::is_arithmetic_v<T2>)

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::TanhFiniteT	(	const T1	x,
		const T2	T )

tanhS()

template<typename T1 , typename T2 >

auto KOKKOS_FORCEINLINE_FUNCTION DiFfRG::tanhS	(	const T1	e,
		const T2	T )

TBBReduction()

template<int dim, typename NT , typename FUN >

NT DiFfRG::TBBReduction	(	const device::array< size_t, dim > &	grid_size,
		const FUN &	functor )

Bitwise reproducible reduction of functor over a dim-dimensional index grid.

The result depends only on grid_size and functor - never on the number of TBB worker threads, on work stealing, or on whether the call is nested inside another parallel region. This is a hard requirement: the flow kernels feed a stiff DAE solver, so a last-bit difference in the residual changes the accepted step sequence and thus the whole trajectory.

tbb::parallel_reduce must never be used here: its range splitting depends on which worker happens to steal which subrange, which makes the summation order - and therefore the result - vary from call to call.

time_format() [1/2]

std::string DiFfRG::time_format

(

size_t

time_in_seconds

)

Nice output from seconds to h/min/s style string.

time_format() [2/2]

template<typename T >
requires (!std::is_same_v<T, size_t>)

std::string DiFfRG::time_format

(

T

time_in_seconds

)

time_format_ms()

std::string DiFfRG::time_format_ms

(

size_t

time_in_miliseconds

)

Nice output from seconds to h/min/s style string.

to_string() [1/2]

const char * DiFfRG::to_string ( const MapResource r )

inline

to_string() [2/2]

const char * DiFfRG::to_string

(

const ThreadSource

source

)

The name of a thread-count source, as it appears in the precedence warning.

to_string_with_digits()

template<typename T >

std::string DiFfRG::to_string_with_digits	(	const T	number,
		const int	digits )

Return number with fixed significant digits.

tuple_first() [1/2]

template<int i, typename tuple_type , typename strSet >

auto DiFfRG::tuple_first ( const named_tuple< tuple_type, strSet > & t )

constexpr

tuple_first() [2/2]

template<int i, typename Head , typename... Tail>

auto DiFfRG::tuple_first ( const std::tuple< Head, Tail... > & t )

constexpr

tuple_last() [1/2]

template<int i, typename tuple_type , typename strSet >

auto DiFfRG::tuple_last ( const named_tuple< tuple_type, strSet > & t )

constexpr

tuple_last() [2/2]

template<int i, typename Head , typename... Tail>

auto DiFfRG::tuple_last ( const std::tuple< Head, Tail... > & t )

constexpr

tuple_tail() [1/2]

template<typename tuple_type , typename strSet >

auto DiFfRG::tuple_tail ( const named_tuple< tuple_type, strSet > & t )

constexpr

tuple_tail() [2/2]

template<typename Head , typename... Tail>

auto DiFfRG::tuple_tail ( const std::tuple< Head, Tail... > & t )

constexpr

unit_cell_centre()

template<int dim>

dealii::Point< dim > DiFfRG::unit_cell_centre

(

)

The centre of the reference cell.

V_d() [1/2]

template<typename NT >

KOKKOS_INLINE_FUNCTION double DiFfRG::V_d ( NT d )

constexpr

Volume of a d-dimensional sphere.

Template Parameters

NT	Type of the number

Parameters

d	Dimension of the sphere

V_d() [2/2]

template<typename NT1 , typename NT2 >

KOKKOS_INLINE_FUNCTION double DiFfRG::V_d ( NT1 d, NT2 extent )

constexpr

Volume of a d-dimensional sphere with extent.

Template Parameters

NT1	Type of the number
NT2	Type of the extent

Parameters

d	Dimension of the sphere
extent	Extent of the sphere

variables_owner_set()

dealii::IndexSet DiFfRG::variables_owner_set ( const dealii::types::global_dof_index n_vars, MPI_Comm comm )

inline

The ownership set for the extra-variables block: everything on rank 0, nothing elsewhere.

Factored out so reinit_la_block_vector and reinit_la_variables_vector cannot drift apart. Two places building disagreeing layouts for the same block is a hang, not a wrong number: the blocks would have different global sizes and the first collective on them would not match up.

vector_to_array()

template<uint n, typename NT , typename Vector >

std::array< NT, n > DiFfRG::vector_to_array

(

const Vector &

v

)

vector_to_tuple()

template<std::size_t N, typename T >

auto DiFfRG::vector_to_tuple

(

const std::vector< T > &

v

)

vector_to_tuple_helper()

template<typename T , std::size_t... Indices>

auto DiFfRG::vector_to_tuple_helper	(	const std::vector< T > &	v,
		std::index_sequence< Indices... >	)

write_config_tree()

void DiFfRG::write_config_tree	(	DiFfRG::hdf5::Group &	group,
		const json::value &	value )

Mirror a JSON configuration value into group as a browsable tree: one subgroup per object, one attribute per leaf.

This is how a run's configuration is recorded in its HDF5 file, so that it reads with the same tools as its data. HDF5 has no boolean type, so booleans become 0/1 ints, arrays are stored as their serialized JSON, and nulls are skipped; set /output/json to also get the verbatim <name>.log.json copy alongside.

Exceptions

std::runtime_error

if an object key contains '/', which is not a legal HDF5 link name.

write_csv_header()

void DiFfRG::write_csv_header	(	std::ostream &	stream,
		const std::vector< std::string > &	names,
		const CsvDialect &	dialect = {} )

Write a header row, quoting any name that would otherwise forge a field boundary.

write_csv_row()

void DiFfRG::write_csv_row	(	std::ostream &	stream,
		const std::vector< double > &	values,
		const CsvDialect &	dialect = {} )

Write one row of values.

Variable Documentation

has_cacheable_positions_v

template<typename Coordinates >

bool DiFfRG::has_cacheable_positions_v

inlineconstexpr

Initial value:

= requires(const Coordinates &c) {
    c.to_string();
    c.forward(c.from_linear_index(size_t(0)));
  }

Whether a coordinates type carries enough identity for QuadratureIntegrator::map() to cache its forward()-transformed positions in a device view (one forward() per grid point instead of per thread). Namespace-scope on purpose: it is referenced inside extended device lambdas, where nvcc mishandles function-local constexpr variables.

is_autodiff_real_v

template<typename T >

bool DiFfRG::is_autodiff_real_v = is_autodiff_real<T>::value

inlineconstexpr

is_distributed_la

template<typename T >

bool DiFfRG::is_distributed_la = false

inlineconstexpr

Whether a linear algebra type distributes its rows across MPI ranks.

Everything the assemblers do differently under distribution keys off this one predicate, so that the assembler bodies read identically for both policies and the branching lives in la_policy.hh.

is_periodic_axis_v

template<typename C , size_t i>

bool DiFfRG::is_periodic_axis_v = internal::axis_periodic<C, i>::value

inlineconstexpr

Whether axis i of a (possibly multi-dimensional) coordinate system is periodic. Falls back to false for coordinate systems which do not expose their axes as separate types, e.g. BosonicCoordinates1DFiniteT.

is_periodic_coordinate_v

template<typename T >

bool DiFfRG::is_periodic_coordinate_v = internal::coord_periodic<T>::value

inlineconstexpr

Whether a 1D coordinate class describes a periodic axis, i.e. one where the last grid point is followed again by the first one. Detected through a static constexpr bool periodic member, defaulting to false.

kernel_has_finite_matsubara_extent

template<class K >

bool DiFfRG::kernel_has_finite_matsubara_extent = requires { requires K::matsubara_finite_extent; }

inlineconstexpr

kernel_has_matsubara_split

template<class K >

bool DiFfRG::kernel_has_matsubara_split = requires { requires K::matsubara_split; }

inlineconstexpr

kernel_is_matsubara_even

template<class K >

bool DiFfRG::kernel_is_matsubara_even = requires { requires K::matsubara_even; }

inlineconstexpr

n_map_resources

int DiFfRG::n_map_resources = 2

inlineconstexpr