DiFfRG Namespace Reference

Namespaces
namespace	CG
namespace	dDG
namespace	def
	This namespace contains all default implementations and definitions needed for numerical models.
namespace	DG
namespace	FE
namespace	fRG
namespace	FV
namespace	get_type
namespace	internal
namespace	Interpolation
namespace	LDG
namespace	LoopIntegrals
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	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	DataOutput< 0, Vector< double > >
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, Vector< double > >
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	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...
class	IndexStack
class	Integrator1DCartesianGPU
	Integration of an arbitrary 1D function from qx_min to qx_max using CUDA. More...
class	Integrator1DCartesianTBB
	Integration of an arbitrary 1D function from qx_min to qx_max using TBB. More...
class	Integrator2DCartesianGPU
	Integration of an arbitrary 2D function from (qx_min, qy_min) to (qx_max, qy_max) using TBB. More...
class	Integrator2DCartesianTBB
	Integration of an arbitrary 2D function from (qx_min, qy_min) to (qx_max, qy_max) using TBB. More...
class	Integrator2Dpq0GPU
	Integrator for 2+1D integrals over p, q0 and an angle on the GPU. Calculates. More...
class	Integrator2Dpq0TBB
	Integrator for 2+1D integrals over p, q0 and an angle using TBB. Calculates. More...
class	Integrator2Dpx0GPU
	Integrator for 2+1D integrals over p, x0 and an angle using the GPU. Calculates. More...
class	Integrator2Dpx0TBB
	Integrator for 2+1D integrals over p, x0 and an angle using TBB. Calculates. More...
class	Integrator3DCartesianGPU
class	Integrator3DCartesianTBB
class	Integrator3DGPU
class	Integrator3Dpq0GPU
class	Integrator3Dpq0TBB
class	Integrator3Dpx0GPU
class	Integrator3Dpx0TBB
class	Integrator3DTBB
class	Integrator4D2AngGPU
	GPU integrator for the integration of a 4D function with two angles with CUDA. Calculates. More...
class	Integrator4D2AngTBB
	Integrator for the integration of a 4D function with two angles with CUDA. Calculates. More...
class	Integrator4DFiniteTq0GPU
class	Integrator4DFiniteTq0TBB
class	Integrator4DFiniteTx0GPU
class	Integrator4DFiniteTx0TBB
class	Integrator4DGPU
	GPU integrator for the integration of a 4D function with three angles with CUDA. Calculates. More...
class	Integrator4DGPU_fq
class	Integrator4DOACC
class	Integrator4DQMC
	GPU integrator for the integration of a 4D function with three angles with quasi-Monte-Carlo. Calculates. More...
class	Integrator4DTBB
	Integrator for the integration of a 4D function with three angles with TBB. Calculates. More...
class	IntegratorAngleFiniteTq0GPU
class	IntegratorAngleFiniteTq0TBB
class	IntegratorAngleFiniteTx0GPU
class	IntegratorAngleFiniteTx0TBB
class	IntegratorAngleGPU
	GPU integrator for the integration of a function with one angle with CUDA. Calculates. More...
class	IntegratorAngleQMC
	GPU integrator for the integration of a function with one angle with quasi-Monte-Carlo. Calculates. More...
class	IntegratorAngleTBB
	Integrator for the integration of a function with one angle with TBB. Calculates. More...
class	IntegratorConstant
class	IntegratorFiniteTq0GPU
class	IntegratorFiniteTq0TBB
class	IntegratorFiniteTx0GPU
class	IntegratorFiniteTx0TBB
class	IntegratorGPU
class	IntegratorQMC
class	IntegratorTBB
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...
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	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...
struct	NDBlock
class	Newton
	A newton solver, using local error estimates for each vector component. More...
class	NoAdaptivity
class	Polynomial
	A class representing a polynomial. More...
struct	PolynomialExpRegulator
	Implements a regulator given by. More...
struct	PolynomialExpRegulatorOpts
class	Quadrature
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	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...
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
struct	stepperChoice
struct	SubDescriptor
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	TexLinearInterpolator1D
	A linear interpolator for 1D data, using texture memory on the GPU and floating point arithmetic on the CPU. More...
class	TexLinearInterpolator1DStack
	A linear interpolator for 1D data, using texture memory on the GPU and floating point arithmetic on the CPU. More...
class	TexLinearInterpolator2D
	A linear interpolator for 2D data, using texture memory on the GPU and floating point arithmetic on the CPU. More...
class	TexLinearInterpolator3D
	A linear interpolator for 3D data, using texture memory on the GPU and floating point arithmetic on the CPU. 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_ARKode
	This timestepping class utilizes the ARKode solver from SUNDIALS. It is specifically meant to be used for a spatial discretization which uses implicit timestepping and coupled to additional variables which are evolved explicitly. Therefore, this solver is an ImEx solver and requires the dynamics of the additional variables to be far slower than the dynamics of the spatial discretization. In the used Assembler, the two additional methods residual_variables and set_additional_data must be implemented, which are used to compute the explicit residual and to make the additional variables available to the implicit residual. More...
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_ARKode
	This timestepping class utilizes the ARKode solver from SUNDIALS for explicitly evolving the variables and SUNDIALS IDA for implicitly evolving the spatial discretization. In this scheme, the IDA stepper is the controller and the ARKode stepper solves the explicit part of the problem on-demand. 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	IsContainer
concept	MeshIsRectangular

Typedefs
template<size_t N, typename T >
using	cxreal = autodiff::Real<N, complex<T>>
using	cxReal = autodiff::Real<1, complex<double>>
using	uint = unsigned int
template<FixedString _str>
using	Scalar = NDBlock<_str, 1>
template<FixedString _str, size_t... _val>
using	FunctionND = NDBlock<_str, _val...>
template<typename... descriptors>
using	FEFunctionDescriptor = SubDescriptor<descriptors...>
template<typename... descriptors>
using	VariableDescriptor = SubDescriptor<descriptors...>
template<typename... descriptors>
using	ExtractorDescriptor = SubDescriptor<descriptors...>
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.

Enumerations
enum class	QuadratureType {   legendre , chebyshev , laguerre , hermite ,   jacobi , count }

Functions
template<typename NT >
constexpr auto	cot (const NT x)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	real (const autodiff::Real< N, T > &a)
template<size_t N, typename T >
constexpr AUTODIFF_DEVICE_FUNC auto	imag (const autodiff::Real< N, T > &)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	real (const cxreal< N, T > &x)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	imag (const cxreal< N, T > &x)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator* (const autodiff::Real< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator* (const complex< double > x, const autodiff::Real< N, T > y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator+ (const autodiff::Real< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator+ (const complex< double > x, const autodiff::Real< N, T > y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator- (const autodiff::Real< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator- (const complex< double > x, const autodiff::Real< N, T > y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator/ (const autodiff::Real< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator/ (const complex< double > x, const autodiff::Real< N, T > y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator* (const autodiff::Real< N, T > &x, const cxreal< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator* (const cxreal< N, T > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator+ (const autodiff::Real< N, T > &x, const cxreal< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator+ (const cxreal< N, T > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator- (const autodiff::Real< N, T > &x, const cxreal< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator- (const cxreal< N, T > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator/ (const autodiff::Real< N, T > &x, const cxreal< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator/ (const cxreal< N, T > &x, const autodiff::Real< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator* (const complex< double > &x, const cxreal< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator* (const cxreal< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator+ (const complex< double > &x, const cxreal< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator+ (const cxreal< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator- (const complex< double > &x, const cxreal< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator- (const cxreal< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator/ (const cxreal< N, T > &x, const complex< double > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator/ (const complex< double > &x, const cxreal< N, T > &y)
template<size_t N, typename T >
AUTODIFF_DEVICE_FUNC auto	operator/ (const double x, const cxreal< N, T > &y)
template<typename T1 , typename T2 > requires (!std::is_same_v<T1, T2>) && std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2>
AUTODIFF_DEVICE_FUNC auto	operator* (const T1 x, const complex< T2 > y)
template<typename T1 , typename T2 > requires (!std::is_same_v<T1, T2>) && std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2>
AUTODIFF_DEVICE_FUNC auto	operator* (const complex< T1 > &x, const T2 &y)
template<typename T1 , typename T2 > requires (!std::is_same_v<T1, T2>) && std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2>
AUTODIFF_DEVICE_FUNC auto	operator+ (const T1 &x, const complex< T2 > &y)
template<typename T1 , typename T2 > requires (!std::is_same_v<T1, T2>) && std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2>
AUTODIFF_DEVICE_FUNC auto	operator+ (const complex< T1 > &x, const T2 &y)
template<typename T1 , typename T2 > requires (!std::is_same_v<T1, T2>) && std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2>
AUTODIFF_DEVICE_FUNC auto	operator- (const T1 &x, const complex< T2 > &y)
template<typename T1 , typename T2 > requires (!std::is_same_v<T1, T2>) && std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2>
AUTODIFF_DEVICE_FUNC auto	operator- (const complex< T1 > &x, const T2 &y)
template<typename T1 , typename T2 > requires (!std::is_same_v<T1, T2>) && std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2>
AUTODIFF_DEVICE_FUNC auto	operator/ (const T1 &x, const complex< T2 > &y)
template<typename T1 , typename T2 > requires (!std::is_same_v<T1, T2>) && std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2>
AUTODIFF_DEVICE_FUNC auto	operator/ (const complex< T1 > x, const T2 &y)
void	check_cuda (std::string prefix="")
	Check if a CUDA error occurred and print an error message if it did.
template<unsigned N>
	FixedString (char const (&)[N]) -> FixedString< N - 1 >
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 __forceinline__ __host__ __device__ NumberType	powr (const NumberType x)
	A compile-time evaluatable power function for whole number exponents.
template<typename NT >
constexpr __forceinline__ __host__ __device__ double	V_d (NT d)
	Volume of a d-dimensional sphere.
template<typename NT1 , typename NT2 >
constexpr __forceinline__ __host__ __device__ double	V_d (NT1 d, NT2 extent)
	Volume of a d-dimensional sphere with extent.
template<typename NT >
constexpr __forceinline__ __host__ __device__ 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 __forceinline__ __host__ __device__ auto	heaviside_theta (const NumberType x)
	A compile-time evaluatable theta function.
template<typename NumberType > requires requires(NumberType x) { x >= 0; }
constexpr __forceinline__ __host__ __device__ 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 __forceinline__ __host__ __device__	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 __forceinline__ __host__ __device__	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.
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<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.
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 , FixedString... strs>
constexpr auto &	get (named_tuple< tuple_type, strs... > &ob)
	get a reference to the element with the given name
template<FixedString name, typename tuple_type , FixedString... strs>
constexpr auto &	get (named_tuple< tuple_type, strs... > &&ob)
template<FixedString name, typename tuple_type , FixedString... strs>
constexpr auto &	get (const named_tuple< tuple_type, strs... > &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	vectorToTupleHelper (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 , FixedString... strs>
constexpr auto	tuple_tail (const named_tuple< tuple_type, strs... > &t)
template<int i, typename Head , typename... Tail>
constexpr auto	tuple_last (const std::tuple< Head, Tail... > &t)
template<int i, typename tuple_type , FixedString... strs>
constexpr auto	tuple_last (const named_tuple< tuple_type, strs... > &t)
template<int i, typename Head , typename... Tail>
constexpr auto	tuple_first (const std::tuple< Head, Tail... > &t)
template<int i, typename tuple_type , FixedString... strs>
constexpr auto	tuple_first (const named_tuple< tuple_type, strs... > &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.
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 ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_2d_cartesian (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *y_quadrature_p, const ctype *y_quadrature_w, const ctype qx_min, const ctype qy_min, const ctype qx_extent, const ctype qy_extent, const ctype k, T... t)
	GPU kernel for the integration of an arbitrary 2D function from qx_min to qx_max and qy_min to qy_max.
template<typename ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_2dpq0 (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype *q0_quadrature_p, const ctype *q0_quadrature_w, const ctype x_extent, const ctype q0_extent, const ctype k, T... t)
template<typename ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_2dpx0 (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype *x0_quadrature_p, const ctype *x0_quadrature_w, const ctype x_extent, const ctype x0_extent, const ctype k, T... t)
	GPU kernel for the integration of a function dependent on p, an angle cos1 and q0.
template<typename ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_3d_cartesian (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *y_quadrature_p, const ctype *y_quadrature_w, const ctype *z_quadrature_p, const ctype *z_quadrature_w, const ctype qx_min, const ctype qy_min, const ctype qz_min, const ctype qx_extent, const ctype qy_extent, const ctype qz_extent, const ctype k, T... t)
template<typename ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_3d (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype x_extent, const ctype k, T... t)
template<typename ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_3dpq0 (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype *q0_quadrature_p, const ctype *q0_quadrature_w, const ctype x_extent, const ctype q0_extent, const ctype k, T... t)
template<typename ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_3dpx0 (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype *x0_quadrature_p, const ctype *x0_quadrature_w, const ctype x_extent, const ctype x0_extent, const ctype k, T... t)
template<typename ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_4d_2ang (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype x_extent, const ctype k, T... t)
template<typename ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_4d (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype x_extent, const ctype k, T... t)
template<typename ctype , int d, typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_angle (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype x_extent, const ctype k, T... t)
template<typename ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_4d_finiteTq0 (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype *matsubara_quadrature_p, const ctype *matsubara_quadrature_w, const ctype x_extent, const uint matsubara_size, const ctype m_T, const ctype k, T... t)
template<typename ctype , typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_4d_finiteTx0 (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype *x0_quadrature_p, const ctype *x0_quadrature_w, const ctype x_extent, const ctype x0_extent, const uint x0_quadrature_size, const uint x0_summands, const ctype m_T, const ctype k, T... t)
template<typename ctype , int d, typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_angle_finiteTq0 (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype *matsubara_quadrature_p, const ctype *matsubara_quadrature_w, const ctype x_extent, const ctype m_T, const ctype k, T... t)
template<typename ctype , int d, typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_angle_finiteTx0 (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *ang_quadrature_p, const ctype *ang_quadrature_w, const ctype *x0_quadrature_p, const ctype *x0_quadrature_w, const ctype x_extent, const ctype x0_extent, const uint x0_summands, const ctype m_T, const ctype k, T... t)
template<typename ctype , int d, typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_1d_finiteTq0 (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *matsubara_quadrature_p, const ctype *matsubara_quadrature_w, const ctype x_extent, const ctype m_T, const ctype k, T... t)
template<typename ctype , int d, typename NT , typename KERNEL , typename... T>
__global__ void	gridreduce_1d_finiteTx0 (NT *dest, const ctype *x_quadrature_p, const ctype *x_quadrature_w, const ctype *x0_quadrature_p, const ctype *x0_quadrature_w, const ctype x_extent, const ctype x0_extent, const uint x0_summands, const ctype m_T, const ctype k, T... t)
template<typename T >
auto __forceinline__ __device__ __host__	Cosh (const T x)
template<typename T >
auto __forceinline__ __device__ __host__	Sinh (const T x)
template<typename T >
auto __forceinline__ __device__ __host__	Tanh (const T x)
template<typename T >
auto __forceinline__ __device__ __host__	Coth (const T x)
template<typename T >
auto __forceinline__ __device__ __host__	Sech (const T x)
template<typename T >
auto __forceinline__ __device__ __host__	Csch (const T x)
template<typename T1 , typename T2 > requires (std::is_arithmetic_v<T2>)
auto __forceinline__ __device__ __host__	CothFiniteT (const T1 x, const T2 T)
template<typename T1 , typename T2 > requires (std::is_arithmetic_v<T2>)
auto __forceinline__ __device__ __host__	TanhFiniteT (const T1 x, const T2 T)
template<typename T1 , typename T2 > requires (std::is_arithmetic_v<T2>)
auto __forceinline__ __device__ __host__	SechFiniteT (const T1 x, const T2 T)
template<typename T1 , typename T2 > requires (std::is_arithmetic_v<T2>)
auto __forceinline__ __device__ __host__	CschFiniteT (const T1 x, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	cothS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	dcothS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	ddcothS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	dddcothS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	tanhS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	dtanhS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	ddtanhS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	sechS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	cschS (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	nB (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	dnB (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	ddnB (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	nF (const T1 e, const T2 T)
template<typename T1 , typename T2 >
auto __forceinline__ __device__ __host__	dnF (const T1 e, const T2 T)
template<typename NT , typename FUN , typename Coordinates , typename... T> requires IsCoordinate<Coordinates>
std::shared_ptr< std::vector< std::future< NT > > >	request_data (FUN &fun, Coordinates &coordinates, const double k, std::tuple< T... > args)
	For a given set of coordinates and arguments, this function will call fun.request(k, coordinates..., args...) for each coordinate in coordinates.
template<typename NT , typename FUN , typename Coordinates , typename... T> requires IsCoordinate<Coordinates>
std::shared_ptr< std::vector< std::future< NT > > >	request_data (FUN &fun, Coordinates &coordinates, const double k, T... args)
	For a given set of coordinates and arguments, this function will call fun.request(k, coordinates..., args...) for each coordinate in coordinates.
template<typename NT , typename FUN , typename GRID , typename... T> requires IsContainer<GRID>
std::shared_ptr< std::vector< std::future< NT > > >	request_data (FUN &fun, const GRID &grid, const double k, std::tuple< T... > args)
	For a given grid and arguments, this function will call fun.request(k, grid[...]..., args...) for each gridpoint in grid.
template<typename NT , typename FUN , typename GRID , typename... T> requires IsContainer<GRID>
std::shared_ptr< std::vector< std::future< NT > > >	request_data (FUN &fun, const GRID &grid, const double k, T... args)
	For a given grid and arguments, this function will call fun.request(k, grid[...]..., args...) for each gridpoint in grid.
template<typename NT1 , typename NT2 , typename... T>
void	update_data (std::shared_ptr< std::vector< std::future< NT1 > > > futures, NT2 *destination)
	Obtain data from a vector of futures and store it in a destination array.
template<typename NT , typename INT , typename... T>
void	update_interpolator (std::shared_ptr< std::vector< std::future< NT > > > futures, INT &destination)
	Obtain data from a vector of futures and store it in an interpolator.
template<typename NT , typename FUN , typename GRID , typename... T>
void	get_data (NT *dest, FUN &fun, const GRID &grid, const double k, std::tuple< T... > args)
	For a given grid and arguments, this function will call fun.request(k, grid[...]..., args...) for each gridpoint in grid.
template<typename NT , typename FUN , typename GRID , typename... T>
void	get_data (NT *dest, FUN &fun, const GRID &grid, const double k, T... args)
	For a given grid and arguments, this function will call fun.request(k, grid[...]..., args...) for each gridpoint in grid.

Detailed Description

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

Typedef Documentation

cxReal

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

cxreal

template<size_t N, typename T >

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

ExtractorDescriptor

template<typename... descriptors>

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

FEFunctionDescriptor

template<typename... descriptors>

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

FunctionND

template<FixedString _str, size_t... _val>

using DiFfRG::FunctionND = NDBlock<_str, _val...>

Scalar

template<FixedString _str>

using DiFfRG::Scalar = NDBlock<_str, 1>

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

Enumeration Type Documentation

QuadratureType

enum class DiFfRG::QuadratureType

strong

Enumerator
legendre
chebyshev
laguerre
hermite
jacobi
count

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 )

build_logger()

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

check_cuda()

void DiFfRG::check_cuda

(

std::string

prefix = ""

)

Check if a CUDA error occurred and print an error message if it did.

Parameters

prefix

A prefix to be printed before the error message.

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.

Cosh()

template<typename T >

auto __forceinline__ __device__ __host__ DiFfRG::Cosh

(

const T

x

)

cot()

template<typename NT >

auto DiFfRG::cot ( const NT x )

constexpr

Coth()

template<typename T >

auto __forceinline__ __device__ __host__ DiFfRG::Coth

(

const T

x

)

CothFiniteT()

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

auto __forceinline__ __device__ __host__ DiFfRG::CothFiniteT	(	const T1	x,
		const T2	T )

cothS()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ 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.

Csch()

template<typename T >

auto __forceinline__ __device__ __host__ DiFfRG::Csch

(

const T

x

)

CschFiniteT()

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

auto __forceinline__ __device__ __host__ DiFfRG::CschFiniteT	(	const T1	x,
		const T2	T )

cschS()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ DiFfRG::cschS	(	const T1	e,
		const T2	T )

dcothS()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ DiFfRG::dcothS	(	const T1	e,
		const T2	T )

ddcothS()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ DiFfRG::ddcothS	(	const T1	e,
		const T2	T )

dddcothS()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ DiFfRG::dddcothS	(	const T1	e,
		const T2	T )

ddnB()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ DiFfRG::ddnB	(	const T1	e,
		const T2	T )

ddtanhS()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ 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 __forceinline__ __device__ __host__ DiFfRG::dnB	(	const T1	e,
		const T2	T )

dnF()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ 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 __forceinline__ __device__ __host__ DiFfRG::dtanhS	(	const T1	e,
		const T2	T )

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

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 , FixedString... strs>

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

constexpr

get() [2/3]

template<FixedString name, typename tuple_type , FixedString... strs>

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

constexpr

get() [3/3]

template<FixedString name, typename tuple_type , FixedString... strs>

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

constexpr

get a reference to the element with the given name

get_data() [1/2]

template<typename NT , typename FUN , typename GRID , typename... T>

void DiFfRG::get_data	(	NT *	dest,
		FUN &	fun,
		const GRID &	grid,
		const double	k,
		std::tuple< T... >	args )

For a given grid and arguments, this function will call fun.request(k, grid[...]..., args...) for each gridpoint in grid.

Template Parameters

NT	Type of the data requested
FUN	Type of the function object
GRID	Type of the grid
T	Types of the arguments

Parameters

FUN&	fun The function object, usually an integrator class.
GRID&	grid The grid object
const	double k current RG scale
std::tuple<T...>	args The arguments to pass to the request function

Returns

std::shared_ptr<std::vector<std::future<NT>>> A vector of futures which will yield the requested data

get_data() [2/2]

template<typename NT , typename FUN , typename GRID , typename... T>

void DiFfRG::get_data	(	NT *	dest,
		FUN &	fun,
		const GRID &	grid,
		const double	k,
		T...	args )

For a given grid and arguments, this function will call fun.request(k, grid[...]..., args...) for each gridpoint in grid.

Template Parameters

NT	Type of the data requested
FUN	Type of the function object
GRID	Type of the grid
T	Types of the arguments

Parameters

FUN&	fun The function object, usually an integrator class.
GRID&	grid The grid object
const	double k current RG scale
T...	args The arguments to pass to the request function

Returns

std::shared_ptr<std::vector<std::future<NT>>> A vector of futures which will yield the requested data

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.

gridreduce_1d_finiteTq0()

template<typename ctype , int d, typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_1d_finiteTq0	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	matsubara_quadrature_p,
		const ctype *	matsubara_quadrature_w,
		const ctype	x_extent,
		const ctype	m_T,
		const ctype	k,
		T...	t )

gridreduce_1d_finiteTx0()

template<typename ctype , int d, typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_1d_finiteTx0	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	x0_quadrature_p,
		const ctype *	x0_quadrature_w,
		const ctype	x_extent,
		const ctype	x0_extent,
		const uint	x0_summands,
		const ctype	m_T,
		const ctype	k,
		T...	t )

gridreduce_2d_cartesian()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_2d_cartesian	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	y_quadrature_p,
		const ctype *	y_quadrature_w,
		const ctype	qx_min,
		const ctype	qy_min,
		const ctype	qx_extent,
		const ctype	qy_extent,
		const ctype	k,
		T...	t )

GPU kernel for the integration of an arbitrary 2D function from qx_min to qx_max and qy_min to qy_max.

Template Parameters

ctype	The numerical type of the integration points and weights.
NT	The numerical type of the result.
KERNEL	The kernel to integrate.

gridreduce_2dpq0()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_2dpq0	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype *	q0_quadrature_p,
		const ctype *	q0_quadrature_w,
		const ctype	x_extent,
		const ctype	q0_extent,
		const ctype	k,
		T...	t )

gridreduce_2dpx0()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_2dpx0	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype *	x0_quadrature_p,
		const ctype *	x0_quadrature_w,
		const ctype	x_extent,
		const ctype	x0_extent,
		const ctype	k,
		T...	t )

GPU kernel for the integration of a function dependent on p, an angle cos1 and q0.

Template Parameters

ctype	The numerical type of the integration points and weights.
NT	The numerical type of the result.
KERNEL	The kernel to integrate.

gridreduce_3d()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_3d	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype	x_extent,
		const ctype	k,
		T...	t )

gridreduce_3d_cartesian()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_3d_cartesian	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	y_quadrature_p,
		const ctype *	y_quadrature_w,
		const ctype *	z_quadrature_p,
		const ctype *	z_quadrature_w,
		const ctype	qx_min,
		const ctype	qy_min,
		const ctype	qz_min,
		const ctype	qx_extent,
		const ctype	qy_extent,
		const ctype	qz_extent,
		const ctype	k,
		T...	t )

gridreduce_3dpq0()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_3dpq0	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype *	q0_quadrature_p,
		const ctype *	q0_quadrature_w,
		const ctype	x_extent,
		const ctype	q0_extent,
		const ctype	k,
		T...	t )

gridreduce_3dpx0()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_3dpx0	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype *	x0_quadrature_p,
		const ctype *	x0_quadrature_w,
		const ctype	x_extent,
		const ctype	x0_extent,
		const ctype	k,
		T...	t )

gridreduce_4d()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_4d	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype	x_extent,
		const ctype	k,
		T...	t )

gridreduce_4d_2ang()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_4d_2ang	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype	x_extent,
		const ctype	k,
		T...	t )

gridreduce_4d_finiteTq0()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_4d_finiteTq0	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype *	matsubara_quadrature_p,
		const ctype *	matsubara_quadrature_w,
		const ctype	x_extent,
		const uint	matsubara_size,
		const ctype	m_T,
		const ctype	k,
		T...	t )

gridreduce_4d_finiteTx0()

template<typename ctype , typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_4d_finiteTx0	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype *	x0_quadrature_p,
		const ctype *	x0_quadrature_w,
		const ctype	x_extent,
		const ctype	x0_extent,
		const uint	x0_quadrature_size,
		const uint	x0_summands,
		const ctype	m_T,
		const ctype	k,
		T...	t )

gridreduce_angle()

template<typename ctype , int d, typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_angle	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype	x_extent,
		const ctype	k,
		T...	t )

gridreduce_angle_finiteTq0()

template<typename ctype , int d, typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_angle_finiteTq0	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype *	matsubara_quadrature_p,
		const ctype *	matsubara_quadrature_w,
		const ctype	x_extent,
		const ctype	m_T,
		const ctype	k,
		T...	t )

gridreduce_angle_finiteTx0()

template<typename ctype , int d, typename NT , typename KERNEL , typename... T>

__global__ void DiFfRG::gridreduce_angle_finiteTx0	(	NT *	dest,
		const ctype *	x_quadrature_p,
		const ctype *	x_quadrature_w,
		const ctype *	ang_quadrature_p,
		const ctype *	ang_quadrature_w,
		const ctype *	x0_quadrature_p,
		const ctype *	x0_quadrature_w,
		const ctype	x_extent,
		const ctype	x0_extent,
		const uint	x0_summands,
		const ctype	m_T,
		const ctype	k,
		T...	t )

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

__forceinline__ __host__ __device__ auto DiFfRG::heaviside_theta ( const NumberType x )

constexpr

A compile-time evaluatable theta function.

imag() [1/2]

template<size_t N, typename T >

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

constexpr

imag() [2/2]

template<size_t N, typename T >

AUTODIFF_DEVICE_FUNC auto DiFfRG::imag

(

const cxreal< N, T > &

x

)

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 __forceinline__ __host__ __device__ 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 __forceinline__ __host__ __device__ 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_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)

nB()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ DiFfRG::nB	(	const T1	e,
		const T2	T )

nF()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ DiFfRG::nF	(	const T1	e,
		const T2	T )

operator*() [1/8]

template<size_t N, typename T >

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

operator*() [2/8]

template<size_t N, typename T >

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

operator*() [3/8]

template<size_t N, typename T >

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

operator*() [4/8]

template<size_t N, typename T >

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

operator*() [5/8]

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

AUTODIFF_DEVICE_FUNC auto DiFfRG::operator*	(	const complex< T1 > &	x,
		const T2 &	y )

operator*() [6/8]

template<size_t N, typename T >

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

operator*() [7/8]

template<size_t N, typename T >

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

operator*() [8/8]

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

AUTODIFF_DEVICE_FUNC auto DiFfRG::operator*	(	const T1	x,
		const complex< T2 >	y )

operator+() [1/8]

template<size_t N, typename T >

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

operator+() [2/8]

template<size_t N, typename T >

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

operator+() [3/8]

template<size_t N, typename T >

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

operator+() [4/8]

template<size_t N, typename T >

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

operator+() [5/8]

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

AUTODIFF_DEVICE_FUNC auto DiFfRG::operator+	(	const complex< T1 > &	x,
		const T2 &	y )

operator+() [6/8]

template<size_t N, typename T >

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

operator+() [7/8]

template<size_t N, typename T >

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

operator+() [8/8]

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

AUTODIFF_DEVICE_FUNC auto DiFfRG::operator+	(	const T1 &	x,
		const complex< T2 > &	y )

operator-() [1/8]

template<size_t N, typename T >

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

operator-() [2/8]

template<size_t N, typename T >

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

operator-() [3/8]

template<size_t N, typename T >

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

operator-() [4/8]

template<size_t N, typename T >

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

operator-() [5/8]

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

AUTODIFF_DEVICE_FUNC auto DiFfRG::operator-	(	const complex< T1 > &	x,
		const T2 &	y )

operator-() [6/8]

template<size_t N, typename T >

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

operator-() [7/8]

template<size_t N, typename T >

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

operator-() [8/8]

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

AUTODIFF_DEVICE_FUNC auto DiFfRG::operator-	(	const T1 &	x,
		const complex< T2 > &	y )

operator/() [1/9]

template<size_t N, typename T >

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

operator/() [2/9]

template<size_t N, typename T >

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

operator/() [3/9]

template<size_t N, typename T >

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

operator/() [4/9]

template<size_t N, typename T >

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

operator/() [5/9]

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

AUTODIFF_DEVICE_FUNC auto DiFfRG::operator/	(	const complex< T1 >	x,
		const T2 &	y )

operator/() [6/9]

template<size_t N, typename T >

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

operator/() [7/9]

template<size_t N, typename T >

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

operator/() [8/9]

template<size_t N, typename T >

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

operator/() [9/9]

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

AUTODIFF_DEVICE_FUNC auto DiFfRG::operator/	(	const T1 &	x,
		const complex< T2 > &	y )

powr()

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

__forceinline__ __host__ __device__ 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 >

AUTODIFF_DEVICE_FUNC auto DiFfRG::real

(

const autodiff::Real< N, T > &

a

)

real() [2/2]

template<size_t N, typename T >

AUTODIFF_DEVICE_FUNC auto DiFfRG::real

(

const cxreal< N, T > &

x

)

request_data() [1/4]

template<typename NT , typename FUN , typename GRID , typename... T>
requires IsContainer<GRID>

std::shared_ptr< std::vector< std::future< NT > > > DiFfRG::request_data	(	FUN &	fun,
		const GRID &	grid,
		const double	k,
		std::tuple< T... >	args )

For a given grid and arguments, this function will call fun.request(k, grid[...]..., args...) for each gridpoint in grid.

Template Parameters

NT	Type of the data requested
FUN	Type of the function object
GRID	Type of the grid
T	Types of the arguments

Parameters

FUN&	fun The function object, usually an integrator class.
GRID&	grid The grid object
const	double k current RG scale
std::tuple<T...>	args The arguments to pass to the request function

Returns

std::shared_ptr<std::vector<std::future<NT>>> A vector of futures which will yield the requested data

request_data() [2/4]

template<typename NT , typename FUN , typename GRID , typename... T>
requires IsContainer<GRID>

std::shared_ptr< std::vector< std::future< NT > > > DiFfRG::request_data	(	FUN &	fun,
		const GRID &	grid,
		const double	k,
		T...	args )

For a given grid and arguments, this function will call fun.request(k, grid[...]..., args...) for each gridpoint in grid.

Template Parameters

NT	Type of the data requested
FUN	Type of the function object
GRID	Type of the grid
T	Types of the arguments

Parameters

FUN&	fun The function object, usually an integrator class.
GRID&	grid The grid object
const	double k current RG scale
T...	args The arguments to pass to the request function

Returns

std::shared_ptr<std::vector<std::future<NT>>> A vector of futures which will yield the requested data

request_data() [3/4]

template<typename NT , typename FUN , typename Coordinates , typename... T>
requires IsCoordinate<Coordinates>

std::shared_ptr< std::vector< std::future< NT > > > DiFfRG::request_data	(	FUN &	fun,
		Coordinates &	coordinates,
		const double	k,
		std::tuple< T... >	args )

For a given set of coordinates and arguments, this function will call fun.request(k, coordinates..., args...) for each coordinate in coordinates.

Template Parameters

NT	Type of the data requested
FUN	Type of the function object
Coordinates	Type of the coordinates
T	Types of the arguments

Parameters

FUN&	fun The function object, usually an integrator class.
Coordinates&	coordinates The coordinates object
const	double k current RG scale
std::tuple<T...>	args The arguments to pass to the request function

Returns

std::shared_ptr<std::vector<std::future<NT>>> A vector of futures which will yield the requested data

request_data() [4/4]

template<typename NT , typename FUN , typename Coordinates , typename... T>
requires IsCoordinate<Coordinates>

std::shared_ptr< std::vector< std::future< NT > > > DiFfRG::request_data	(	FUN &	fun,
		Coordinates &	coordinates,
		const double	k,
		T...	args )

For a given set of coordinates and arguments, this function will call fun.request(k, coordinates..., args...) for each coordinate in coordinates.

Template Parameters

NT	Type of the data requested
FUN	Type of the function object
Coordinates	Type of the coordinates
T	Types of the arguments

Parameters

FUN&	fun The function object, usually an integrator class.
Coordinates&	coordinates The coordinates object
const	double k current RG scale
T...	args The arguments to pass to the request function

Returns

std::shared_ptr<std::vector<std::future<NT>>> A vector of futures which will yield the requested data

S_d()

template<typename NT >

__forceinline__ __host__ __device__ 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

Sech()

template<typename T >

auto __forceinline__ __device__ __host__ DiFfRG::Sech

(

const T

x

)

SechFiniteT()

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

auto __forceinline__ __device__ __host__ DiFfRG::SechFiniteT	(	const T1	x,
		const T2	T )

sechS()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ DiFfRG::sechS	(	const T1	e,
		const T2	T )

sign()

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

__forceinline__ __host__ __device__ auto DiFfRG::sign ( const NumberType x )

constexpr

A compile-time evaluatable sign function.

Sinh()

template<typename T >

auto __forceinline__ __device__ __host__ DiFfRG::Sinh

(

const T

x

)

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

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

constexpr

Check if two strings are equal at compile time.

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

Tanh()

template<typename T >

auto __forceinline__ __device__ __host__ DiFfRG::Tanh

(

const T

x

)

TanhFiniteT()

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

auto __forceinline__ __device__ __host__ DiFfRG::TanhFiniteT	(	const T1	x,
		const T2	T )

tanhS()

template<typename T1 , typename T2 >

auto __forceinline__ __device__ __host__ DiFfRG::tanhS	(	const T1	e,
		const T2	T )

time_format()

std::string DiFfRG::time_format

(

size_t

time_in_seconds

)

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

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 , FixedString... strs>

auto DiFfRG::tuple_first ( const named_tuple< tuple_type, strs... > & 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 , FixedString... strs>

auto DiFfRG::tuple_last ( const named_tuple< tuple_type, strs... > & 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 , FixedString... strs>

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

constexpr

tuple_tail() [2/2]

template<typename Head , typename... Tail>

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

constexpr

update_data()

template<typename NT1 , typename NT2 , typename... T>

void DiFfRG::update_data	(	std::shared_ptr< std::vector< std::future< NT1 > > >	futures,
		NT2 *	destination )

Obtain data from a vector of futures and store it in a destination array.

Template Parameters

NT1	Type of the data in the futures
NT2	Type of the data in the destination array
T	Types of the arguments

Parameters

futures	The vector of futures
destination	The destination array

update_interpolator()

template<typename NT , typename INT , typename... T>

void DiFfRG::update_interpolator	(	std::shared_ptr< std::vector< std::future< NT > > >	futures,
		INT &	destination )

Obtain data from a vector of futures and store it in an interpolator.

Template Parameters

NT	Type of the data in the futures
INT	Type of the interpolator. Must have a method update().
T	Types of the arguments

Parameters

futures	The vector of futures
destination	The interpolator

V_d() [1/2]

template<typename NT >

__forceinline__ __host__ __device__ 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 >

__forceinline__ __host__ __device__ 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

)

vectorToTupleHelper()

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

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