DiFfRG Namespace Reference#

DiFfRG: DiFfRG Namespace Reference

DiFfRG

Namespaces
namespace	CG

namespace	compute

namespace	dDG

namespace	def
	This namespace contains all default implementations and definitions needed for numerical models.

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	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

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 JSONValue object, such as the timestep sizes, tolerances, verbosity, etc. that are used in the timestepping algorithms. More...

class	BisectionRootFinder

class	BosonicCoordinates1DFiniteT

class	BosonicMatsubaraValues

struct	BosonicRegulator
	Implements one of the standard exponential regulators, i.e. More...

struct	BosonicRegulatorOpts

class	ComponentDescriptor
	A class to describe how many FE functions, additional variables and extractors are used in a model. 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...

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...

class	DataOutput
	Class to manage writing to files. FEM functions are written to vtk files and other data is written to csv files. 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

class	FermionicMatsubaraValues

struct	FixedString
	A fixed size compile-time string. More...

class	FlowEquations

class	FlowEquationsFiniteT

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...

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

class	HDF5Input
	A class to output data to a CSV file. More...

class	HDF5Output
	A class to output data to a CSV file. More...

class	IndexStack

class	Init

class	IntegrationLoadBalancer

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 a single angle on $[0,\pi]$ as $$ \frac{S_d}{2(2\pi)^{d}}\,\int_0^\pi d\cos\,\int_0^\infty dp^2 p^{d-2} K(p,\cos\ldots) $$ where $S_d$ is the solid angle in $d$ dimensions. 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	is_complex

struct	is_complex< complex< T > >

struct	is_complex< cxReal< N, T > >

class	JSONValue
	A wrapper around the boost json value class. More...

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, both on GPU and CPU. More...

class	LinearInterpolator2D
	A linear interpolator for 2D data, both on GPU and CPU. More...

class	LinearInterpolator3D
	A linear interpolator for 3D data, both on GPU and CPU. More...

struct	LinearInterpolatorND_helper

struct	LinearInterpolatorND_helper< 1, NT, Coordinates, DefaultMemorySpace >

struct	LinearInterpolatorND_helper< 2, NT, Coordinates, DefaultMemorySpace >

struct	LinearInterpolatorND_helper< 3, NT, Coordinates, DefaultMemorySpace >

struct	LitimRegulator
	Implements the Litim regulator, i.e. More...

class	LogarithmicCoordinates1D

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

struct	NodeDistribution

class	Polynomial
	A class representing a polynomial. More...

struct	PolynomialExpRegulator
	Implements a regulator given by. More...

struct	PolynomialExpRegulatorOpts

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

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	Scalar

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	SplineInterpolator1D
	A spline interpolator for 1D data, both on GPU and CPU. More...

class	SplineInterpolator1DStack
	A linear interpolator for 1D data, using texture memory on the GPU and floating point arithmetic on the CPU. More...

struct	stepperChoice

struct	StringSet

class	SubCoordinates

struct	SubDescriptor

struct	SumPlus
	An extension of the Kokkos::Sum reducer that adds a constant value to the result. More...

struct	TBB_ExecutionSpace
	This execution space is optimal when used in conjunction with the FE discretizations. 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...

class	TimeStepperBoostABM
	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
	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

class	TimeStepperImplicitEuler

class	TimeStepperRK

class	TimeStepperSUNDIALS_IDA
	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	TimeStepperSUNDIALS_IDA_BoostABM
	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
	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	TimeStepperTRBDF2

class	UMFPack

Concepts
concept	NamedTuple
	Concept for a named tuple.

concept	is_container

concept	is_sized_container

concept	has_n_call_operator

concept	MeshIsRectangular

concept	is_coordinates

concept	has_integrator_AD

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, get_on<CPU_memory>, get_on<GPU_memory>) 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	Threads_memory = ExecutionSpaces::Threads_memory_space

using	TBB_memory = ExecutionSpaces::TBB_memory_space

using	CPU_memory = Kokkos::DefaultHostExecutionSpace::memory_space

using	GPU_exec = ExecutionSpaces::GPU_exec_space

using	Threads_exec = ExecutionSpaces::Threads_exec_space

using	TBB_exec = ExecutionSpaces::TBB_exec_space

template<typename MemorySpace >
using	other_memory_space_t = std::conditional_t<std::is_same_v<MemorySpace, GPU_memory>, CPU_memory, GPU_memory>

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

using	uint = unsigned int

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

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 , typename DefaultMemorySpace = CPU_memory>
using	LinearInterpolatorND
	A linear interpolator for ND data, both on GPU and CPU.

template<typename VectorType , typename SparseMatrixType = dealii::SparseMatrix<get_type::NumberType<VectorType>>, uint dim = 0>
using	TimeStepperBoostRK54 = TimeStepperBoostRK<VectorType, SparseMatrixType, dim, 0>
	A class to perform time stepping using the adaptive Boost Cash-Karp54 method.

template<typename VectorType , typename SparseMatrixType = dealii::SparseMatrix<get_type::NumberType<VectorType>>, uint dim = 0>
using	TimeStepperBoostRK78 = TimeStepperBoostRK<VectorType, SparseMatrixType, dim, 1>
	A class to perform time stepping using the adaptive Boost Fehlberg78 method.

template<typename VectorType , typename SparseMatrixType , uint dim, template< typename, typename > typename LinearSolver>
using	TimeStepperSUNDIALS_IDA_BoostRK54
	A class to perform time stepping using the adaptive Boost Runge-Kutta Cash-Karp54 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.

template<typename VectorType , typename SparseMatrixType , uint dim, template< typename, typename > typename LinearSolver>
using	TimeStepperSUNDIALS_IDA_BoostRK78
	A class to perform time stepping using the adaptive Boost Runge-Kutta Fehlberg78 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.

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)

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)

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_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 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 \|\| std::is_same_v<T1, autodiff::real> \|\| is_complex<T1>::value) && (std::is_floating_point<T2>::value \|\| std::is_same_v<T2, autodiff::real> \|\| 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 \|\| std::is_same_v<T1, autodiff::real> \|\| is_complex<T1>::value) && (std::is_floating_point<T2>::value \|\| std::is_same_v<T2, autodiff::real> \|\| is_complex<T1>::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)

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::shared_ptr< spdlog::logger >	build_logger (const std::string &name, const std::string &filename)

std::string	strip_name (const std::string &name)
	Strips all special characters from a string, e.g. for use in filenames.

std::vector< double >	string_to_double_array (const std::string &str)
	Takes a string of comma-separated numbers and outputs it as a vector.

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)

template<typename VectorType , typename EoMFUN , typename EoMPFUN >
dealii::Point< 1 >	get_EoM_point_1D (typename dealii::DoFHandler< 1 >::cell_iterator &EoM_cell, const VectorType &sol, const dealii::DoFHandler< 1 > &dof_handler, const dealii::Mapping< 1 > &mapping, const EoMFUN &get_EoM, const EoMPFUN &EoM_postprocess=[](const auto &p, const auto &values) { return p;}, const double EoM_abs_tol=1e-8, const uint max_iter=100)
	Get the EoM point for a given solution and model in 1D. This is done by first checking the origin, and then checking all cell borders in order to find a zero crossing. Then, the EoM point is found by bisection within the cell.

template<int dim, typename VectorType , typename EoMFUN , typename EoMPFUN >
dealii::Point< dim >	get_EoM_point_ND (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, const auto &values) { return p;}, const double EoM_abs_tol=1e-8, const uint max_iter=100)
	Get the EoM point for a given solution and model in 2D. This is done by first checking the origin, and then checking all cell borders in order to find a zero crossing. Then, the EoM point is found by bisection within the cell.

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, const auto &values) { return p;}, const double EoM_abs_tol=1e-5, const uint max_iter=100)
	Get the EoM point for a given solution and model.

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)

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 > requires DiFfRG::has_integrator_AD<Int>
void	all_set_k (Int &integrator, const double k)

template<typename Int > requires (!DiFfRG::has_integrator_AD<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 > requires DiFfRG::has_integrator_AD<Int>
void	all_set_T (Int &integrator, const double T)

template<typename Int > requires (!DiFfRG::has_integrator_AD<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 > requires DiFfRG::has_integrator_AD<Int>
void	all_set_typical_E (Int &integrator, const double typical_E)

template<typename Int > requires (!DiFfRG::has_integrator_AD<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 > requires DiFfRG::has_integrator_AD<Int>
void	all_set_x_extent (Int &integrator, const double x_extent)

template<typename Int > requires (!DiFfRG::has_integrator_AD<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 ()

template<typename Regulator , int dim = 4>
double	optimize_x_extent (const JSONValue &json)

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)

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>>

◆ ExtractorDescriptor

template<typename... descriptors>

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

◆ FEFunctionDescriptor

template<typename... descriptors>

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

◆ GPU_exec

using DiFfRG::GPU_exec = ExecutionSpaces::GPU_exec_space

◆ GPU_memory

using DiFfRG::GPU_memory = ExecutionSpaces::GPU_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>     
                   >

◆ LinCoordinates

using DiFfRG::LinCoordinates = LinearCoordinates1D<double>

◆ LinearInterpolatorND

template<typename NT , typename Coordinates , typename DefaultMemorySpace = CPU_memory>

using DiFfRG::LinearInterpolatorND

Initial value:

typename LinearInterpolatorND_helper<Coordinates::dim, NT, Coordinates, DefaultMemorySpace>::type

A linear interpolator for ND data, both on GPU and CPU.

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>>

◆ 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>>

◆ LogLogCoordinates

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

◆ LogLogLinCoordinates

using DiFfRG::LogLogLinCoordinates

Initial value:

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

◆ other_memory_space_t

template<typename MemorySpace >

using DiFfRG::other_memory_space_t = std::conditional_t<std::is_same_v<MemorySpace, GPU_memory>, CPU_memory, GPU_memory>

◆ TBB_exec

using DiFfRG::TBB_exec = ExecutionSpaces::TBB_exec_space

◆ TBB_memory

using DiFfRG::TBB_memory = ExecutionSpaces::TBB_memory_space

◆ Threads_exec

using DiFfRG::Threads_exec = ExecutionSpaces::Threads_exec_space

◆ Threads_memory

using DiFfRG::Threads_memory = ExecutionSpaces::Threads_memory_space

◆ TimeStepperBoostRK54

template<typename VectorType , typename SparseMatrixType = dealii::SparseMatrix<get_type::NumberType<VectorType>>, uint dim = 0>

using DiFfRG::TimeStepperBoostRK54 = TimeStepperBoostRK<VectorType, SparseMatrixType, dim, 0>

A class to perform time stepping using the adaptive Boost Cash-Karp54 method.

Template Parameters

VectorType	Type of the vector
dim	Dimension of the problem

◆ TimeStepperBoostRK78

template<typename VectorType , typename SparseMatrixType = dealii::SparseMatrix<get_type::NumberType<VectorType>>, uint dim = 0>

using DiFfRG::TimeStepperBoostRK78 = TimeStepperBoostRK<VectorType, SparseMatrixType, dim, 1>

A class to perform time stepping using the adaptive Boost Fehlberg78 method.

Template Parameters

VectorType	Type of the vector
dim	Dimension of the problem

◆ TimeStepperSUNDIALS_IDA_BoostRK54

template<typename VectorType , typename SparseMatrixType , uint dim, template< typename, typename > typename LinearSolver>

using DiFfRG::TimeStepperSUNDIALS_IDA_BoostRK54

Initial value:

TimeStepperSUNDIALS_IDA_BoostRK<VectorType, SparseMatrixType, dim, LinearSolver, 0>

A class to perform time stepping using the adaptive Boost Runge-Kutta Cash-Karp54 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.

Template Parameters

VectorType	Type of the vector
dim	Dimension of the problem

◆ TimeStepperSUNDIALS_IDA_BoostRK78

template<typename VectorType , typename SparseMatrixType , uint dim, template< typename, typename > typename LinearSolver>

using DiFfRG::TimeStepperSUNDIALS_IDA_BoostRK78

Initial value:

TimeStepperSUNDIALS_IDA_BoostRK<VectorType, SparseMatrixType, dim, LinearSolver, 1>

A class to perform time stepping using the adaptive Boost Runge-Kutta Fehlberg78 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.

Template Parameters

VectorType	Type of the vector
dim	Dimension of the problem

◆ uint

using DiFfRG::uint = unsigned int

◆ VariableDescriptor

template<typename... descriptors>

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

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() [1/2]

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

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

◆ all_set_k() [2/2]

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

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

◆ all_set_T() [1/2]

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

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

◆ all_set_T() [2/2]

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

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

◆ all_set_typical_E() [1/2]

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

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

◆ all_set_typical_E() [2/2]

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

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

◆ all_set_x_extent() [1/2]

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

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

◆ all_set_x_extent() [2/2]

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

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

◆ build_logger()

std::shared_ptr< spdlog::logger > DiFfRG::build_logger	(	const std::string &	name,
		const std::string &	filename )

◆ check_kernel_requirements()

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

void DiFfRG::check_kernel_requirements ( )

consteval

◆ 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.

◆ 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

◆ 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

◆ factorial()

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

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

constexpr

◆ file_exists()

bool DiFfRG::file_exists ( const std::string & name )

Checks if a file exists.

Parameters

name	The name of the file.

◆ FixedString()

template<unsigned N>

DiFfRG::FixedString ( char const(&)[N] ) -> FixedString< N - 1 >

◆ 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()

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, const auto &values) { return p; },
		const double	EoM_abs_tol = 1e-5,
		const uint	max_iter = 100 )

Get the EoM point for a given solution and model.

Template Parameters

dim	dimension of the problem.
VectorType	type of the solution vector.
Model	type of the model.

Parameters

EoM_cell	the cell where the EoM point is located, will be set by the function. Is also used as a starting point for the search.
sol	the solution vector.
dof_handler	a DoFHandler object associated with the solution vector.
mapping	a Mapping object associated with the solution vector.
model	numerical model providing a method EoM(const VectorType &)->double which we use to find a zero crossing.
EoM_abs_tol	the relative tolerance for the bisection method.

Returns: Point<dim> the point where the EoM is zero.

◆ get_EoM_point_1D()

template<typename VectorType , typename EoMFUN , typename EoMPFUN >

dealii::Point< 1 > DiFfRG::get_EoM_point_1D	(	typename dealii::DoFHandler< 1 >::cell_iterator &	EoM_cell,
		const VectorType &	sol,
		const dealii::DoFHandler< 1 > &	dof_handler,
		const dealii::Mapping< 1 > &	mapping,
		const EoMFUN &	get_EoM,
		const EoMPFUN &	EoM_postprocess = [](const auto &p, const auto &values) { return p; },
		const double	EoM_abs_tol = 1e-8,
		const uint	max_iter = 100 )

Get the EoM point for a given solution and model in 1D. This is done by first checking the origin, and then checking all cell borders in order to find a zero crossing. Then, the EoM point is found by bisection within the cell.

Template Parameters

VectorType	type of the solution vector.
Model	type of the model.

Parameters

EoM_cell	the cell where the EoM point is located, will be set by the function. Is also used as a starting point for the search.
sol	the solution vector.
dof_handler	a DoFHandler object associated with the solution vector.
mapping	a Mapping object associated with the solution vector.
model	numerical model providing a method EoM(const VectorType &)->double which we use to find a zero crossing.
EoM_abs_tol	the relative tolerance for the bisection method.

Returns: Point<dim> the point where the EoM is zero.

◆ get_EoM_point_ND()

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

dealii::Point< dim > DiFfRG::get_EoM_point_ND	(	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, const auto &values) { return p; },
		const double	EoM_abs_tol = 1e-8,
		const uint	max_iter = 100 )

Get the EoM point for a given solution and model in 2D. This is done by first checking the origin, and then checking all cell borders in order to find a zero crossing. Then, the EoM point is found by bisection within the cell.

Template Parameters

VectorType	type of the solution vector.
Model	type of the model.

Parameters

EoM_cell	the cell where the EoM point is located, will be set by the function. Is also used as a starting point for the search.
sol	the solution vector.
dof_handler	a DoFHandler object associated with the solution vector.
mapping	a Mapping object associated with the solution vector.
model	numerical model providing a method EoM(const VectorType &)->double which we use to find a zero crossing.
EoM_abs_tol	the relative tolerance for the bisection method.

Returns: Point<dim> the point where the EoM is zero.

◆ 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 || std::is_same_v<T1, autodiff::real> || is_complex<T1>::value) && (std::is_floating_point<T2>::value || std::is_same_v<T2, autodiff::real> || is_complex<T1>::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 || std::is_same_v<T1, autodiff::real> || is_complex<T1>::value) && (std::is_floating_point<T2>::value || std::is_same_v<T2, autodiff::real> || 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 )

◆ 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_idx_grid()

template<typename Coordinates >

auto DiFfRG::make_idx_grid ( const Coordinates & coordinates ) -> std::vector<double>

◆ 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_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)

◆ multidim_kernel_call()

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

NT DiFfRG::multidim_kernel_call ( const ARGS &... args )

◆ 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 )

◆ 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 JSONValue & json )

◆ 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

◆ 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 )

◆ 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 )

◆ 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.

◆ string_to_double_array()

std::vector< double > DiFfRG::string_to_double_array ( const std::string & str )

Takes a string of comma-separated numbers and outputs it as a vector.

Parameters

str	The string of comma-separated numbers

Returns: std::vector<double>

◆ 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 )

◆ 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_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

◆ 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

◆ 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... >	)

DiFfRG Namespace Reference#

Namespaces

Classes

Concepts

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ CPU_memory

◆ cxReal

◆ cxreal

◆ ExtractorDescriptor

◆ FEFunctionDescriptor

◆ GPU_exec

◆ GPU_memory

◆ KokkosNDRange

◆ KokkosNDView

◆ KokkosNDViewRestrict

◆ KokkosNDViewUnmanaged

◆ LinCoordinates

◆ LinearInterpolatorND

◆ LinLinCoordinates

◆ LinLinLinCoordinates

◆ LinLogCoordinates

◆ LogCoordinates

◆ LogLinCoordinates

◆ LogLinLinCoordinates

◆ LogLogCoordinates

◆ LogLogLinCoordinates

◆ other_memory_space_t

◆ TBB_exec

◆ TBB_memory

◆ Threads_exec

◆ Threads_memory

◆ TimeStepperBoostRK54

◆ TimeStepperBoostRK78

◆ TimeStepperSUNDIALS_IDA_BoostRK54

◆ TimeStepperSUNDIALS_IDA_BoostRK78

◆ uint

◆ VariableDescriptor

Function Documentation

◆ _jacobian_2_tuple()

◆ _jacobian_tuple()

◆ _local_sol_tuple()

◆ all_set_k() [1/2]

◆ all_set_k() [2/2]

◆ all_set_T() [1/2]

◆ all_set_T() [2/2]

◆ all_set_typical_E() [1/2]

◆ all_set_typical_E() [2/2]

◆ all_set_x_extent() [1/2]

◆ all_set_x_extent() [2/2]

◆ build_logger()

◆ check_kernel_requirements()

◆ compute_tile_hints()

◆ constexpr_for()

◆ CothFiniteT()

◆ cothS()

◆ create_folder()

◆ CschFiniteT()

◆ cschS()

◆ dcothS()

◆ ddcothS()

◆ dddcothS()

◆ ddnB()

◆ ddtanhS()

◆ dealii_to_eigen() [1/2]

◆ dealii_to_eigen() [2/2]

◆ diagonalize_tridiagonal_symmetric_matrix()

◆ dnB()

◆ dnF()

◆ dot()

◆ dtanhS()

◆ dump_grid()

◆ eigen_to_dealii() [1/2]

◆ eigen_to_dealii() [2/2]

◆ factorial()

◆ file_exists()

◆ FixedString()

◆ get() [1/3]