olb::util Namespace Reference

Namespaces
namespace	tensorIndices2D
namespace	tensorIndices3D

Classes
class	ADf
	Definition of a description of a algoritmic differentiation data type using the forward method. More...
struct	BaseTypeHelper
struct	BaseTypeHelper< double >
struct	BaseTypeHelper< float >
struct	BaseTypeHelper< int >
struct	BaseTypeHelper< long double >
class	BisectStepper
	Propose successive test values of a scalar (e.g. Re) to check stability of a system. More...
class	CircularBuffer
	Simple circular buffer to compute average and other quantities over pre-defined temporal windows. More...
struct	ContainerCreator
	Creates a container of type C. More...
struct	ContainerCreator< std::array< T, SIZE > >
struct	ContainerCreator< std::vector< T > >
struct	ContainerCreator< Vector< T, SIZE > >
struct	divides
	Wrapper of function object std::divides. More...
class	ExponentialMovingAverage
	Exponential moving average. More...
struct	has_identity_functor
	Indicates existence of F::identity_functor_type typedef. More...
struct	has_identity_functor< F, std::void_t< typename F::identity_functor_type > >
	Indicates existence of F::identity_functor_type typedef. More...
struct	is_adf
struct	is_adf< ADf< S, DIM > >
class	KahanSummator
	Accurate summation of floating point numbers with the Kahan algorithm Reduces round-off effects which arise if the total sum is significantly larger than the single summands. More...
struct	maxOp
	Wrapper function object for util::max. More...
struct	maxOp< void >
struct	minOp
	Wrapper function object for util::min. More...
struct	minOp< void >
struct	minus
	Wrapper of function object std::minus with special handling for bool. More...
struct	multiplies
	Wrapper of function object std::multiplies. More...
class	Newton1D
	1D Newton simple scheme More...
struct	plus
	Wrapper of function object std::plus. More...
struct	power
	Power function object. More...
class	Randomizer
struct	TensorVal
	Compute number of elements of a symmetric d-dimensional tensor. More...
class	TimeIntegrator
	Integration with the trapezoid rule. More...
class	TimeIntegratorsArray
	Helper class that manages an array of time integrators. More...
class	Timer
	How to use in Code: More...
class	TrapezRuleInt1D
	Trapezoidal rule. More...
class	ValueTracer
	Check time-convergence of a scalar. More...

Typedefs
template<typename S >
using	StdVector = std::vector<S,std::allocator<S>>

Functions
template<typename T >
cpu::simd::Pack< T >	sqrt (cpu::simd::Pack< T > value)
template<typename T >
cpu::simd::Pack< T >	fabs (cpu::simd::Pack< T > value)
template<typename T >
cpu::simd::Pack< T >	pow (cpu::simd::Pack< T > base, cpu::simd::Pack< T > exp)
template<typename T , typename S >
cpu::simd::Pack< T >	pow (cpu::simd::Pack< T > base, S exp)
template<typename T >
cpu::simd::Pack< T >	min (cpu::simd::Pack< T > rhs, cpu::simd::Pack< T > lhs)
template<typename T >
cpu::simd::Pack< T >	max (cpu::simd::Pack< T > rhs, cpu::simd::Pack< T > lhs)
template<typename T >
T	norm (const std::vector< T > &a)
	l2 norm of a vector of arbitrary length
template<typename T >
int	sign (T val)
template<typename T >
bool	aligned_to_x (const std::vector< T > &vec)
template<typename T >
bool	aligned_to_y (const std::vector< T > &vec)
template<typename T >
bool	aligned_to_z (const std::vector< T > &vec)
template<typename T >
bool	aligned_to_grid (const std::vector< T > &vec)
bool	intersect (int x0, int x1, int y0, int y1, int x0_, int x1_, int y0_, int y1_, int &newX0, int &newX1, int &newY0, int &newY1)
bool	intersect (int x0, int x1, int y0, int y1, int z0, int z1, int x0_, int x1_, int y0_, int y1_, int z0_, int z1_, int &newX0, int &newX1, int &newY0, int &newY1, int &newZ0, int &newZ1)
bool	contained (int x, int y, int x0, int x1, int y0, int y1)
bool	contained (int x, int y, int z, int x0, int x1, int y0, int y1, int z0, int z1)
template<typename T >
T	sqr (T arg)
template<typename ARRAY_LIKE , unsigned D>
auto	normSqr (const ARRAY_LIKE &u) any_platform
	Compute norm square of a d-dimensional vector.
template<unsigned D, typename ARRAY_LIKE >
auto	norm (const ARRAY_LIKE &u)
template<typename T , unsigned D>
T	normSqr (const T *u) any_platform
template<typename T >
T	normSqr (std::initializer_list< T > data)
template<typename T , unsigned D, typename IMPL >
T	normSqr (const ScalarVector< T, D, IMPL > &u) any_platform
	Compute norm square of a d-dimensional vector.
template<typename T , int d>
T	scalarProduct (const T u1[d], const T u2[d])
template<typename T >
T	scalarProduct (const std::vector< T > &u1, const std::vector< T > &u2)
template<typename DESCRIPTOR , unsigned iVel, int value>
constexpr auto	populationsContributingToVelocity () any_platform
	Return array of population indices where c[iVel] == value.
template<typename DESCRIPTOR , int... NORMAL>
constexpr auto	populationsContributingToDirection () any_platform
	Return array of population indices where c[iPop][iD] == NORMAL[iD].
template<typename DESCRIPTORBASE >
int	findVelocity (const int v[DESCRIPTORBASE::d]) any_platform
template<typename DESCRIPTOR , int direction, int orientation>
constexpr auto	subIndexOutgoing () any_platform
	Compute opposites of wall-incoming population indices.
template<typename DESCRIPTOR , int direction, int orientation>
constexpr auto	subIndexOutgoingRemaining () any_platform
template<typename DESCRIPTOR , int plane, int normal1, int normal2>
constexpr auto	subIndexOutgoing3DonEdges () any_platform
template<typename DESCRIPTOR , int normalX, int normalY>
constexpr auto	subIndexOutgoing2DonCorners () any_platform
template<typename DESCRIPTOR , int normalX, int normalY, int normalZ>
constexpr auto	subIndexOutgoing3DonCorners () any_platform
template<typename DESCRIPTORBASE >
std::vector< int >	remainingIndexes (const std::vector< int > &indices)
	finds all the remaining indexes of a lattice given some other indexes
template<typename T , typename DESCRIPTOR >
int	get_nearest_link (const std::vector< T > &vec)
	Util Function for Wall Model of Malaspinas get link with smallest angle to a vector.
template<typename T , typename DESCRIPTOR >
T	densityFromPressure (T latticePressure)
	compute lattice density from lattice pressure
template<typename T , typename DESCRIPTOR >
T	pressureFromDensity (T latticeDensity)
	compute lattice pressure from lattice density
template<typename S , unsigned D, typename F1 , typename F2 >
bool	distance (S &distance, const Vector< S, D > &origin, const Vector< S, D > &direction, S precision, S pitch, F1 isInside, F2 isInsideBoundingBox)
template<typename S , unsigned D, typename F1 , typename F2 >
bool	distance (S &distance, const Vector< S, D > &origin, const Vector< S, D > &direction, S precision, F1 sdf, F2 isInsideBoundingBox, const unsigned maxIt=1e6)
template<typename S , unsigned D, bool normalizeDirection = true>
bool	distance (S &distance, const Vector< S, D > &origin, const Vector< S, D > &direction, S precision, std::function< S(const Vector< S, D > &)> sdf, S maxDistance, const unsigned maxIt=1e6)
template<typename S , unsigned D, typename F1 , typename F2 >
bool	bisectDistance (S &distance, const Vector< S, D > &origin, const Vector< S, D > &direction, S pitch, S precision, F1 isInside, F2 isInsideBoundingBox)
	Using a bisect to find the unsigned distance (false if distance was not found, true if distance was found)
template<typename S , unsigned D, typename F1 >
Vector< S, D >	surfaceNormal (const Vector< S, D > &pos, const S meshSize, F1 sdf)
template<typename SAD >
void	iniDiagonal (SAD *a, int dim)
	The variables of an array are set to be the differential variables.
template<typename C >
void	iniDiagonal (C &a)
template<typename T , typename TAD >
void	copyDerivatives (T *target, const TAD *source, int length)
	Copy the derivatives from an ADf array into an array.
template<typename T , typename S , template< typename > typename C>
C< T >	copyAs (const C< S > &input)
	copy vector with specified typecast
template<typename S >
ADf< S, 1 >	iniAD (const S source)
	copy value and initialize derivative
template<unsigned n, typename S >
ADf< S, n > *	iniAD (const S *source)
	copy array values and initialize derivatives
template<unsigned n, typename S , template< typename > typename C>
C< ADf< S, n > >	iniAD (const C< S > &source)
	copy values and initialize derivatives
template<typename S , typename F >
auto	derivativeFAD (F f, const S input)
	Compute derivatives of a function f: S -> T via forward AD Signature is "V f(U)" so f is expected to accept and return a single value.
template<unsigned sourceDIM, typename S , typename F >
auto	derivativeFAD (F f, const S *input)
	Compute derivatives of a function f: S^sourceDIM -> T via forward AD Signature is "V f(U*)" so f is expected to return a single value.
template<unsigned sourceDIM, typename T , typename S , typename F >
void	derivativeFAD (F f, T *output, const S *input, unsigned targetDIM)
	Compute derivatives of a function f: S^sourceDIM -> T^targetDIM via forward AD Signature of f is "void f(V*, U*)", it is expected to modify the first argument in-place.
template<class T , unsigned DIM>
std::ostream &	operator<< (std::ostream &os, const ADf< T, DIM > &o)
template<class T , unsigned DIM>
std::istream &	operator>> (std::istream &is, ADf< T, DIM > &in)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator+ (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator+ (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator+ (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator- (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator- (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator- (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator* (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator* (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator* (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator/ (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator/ (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator/ (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator+ (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator- (const ADf< T, DIM > &a)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
ADf< T, DIM >	pow (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
ADf< T, DIM >	pow (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
ADf< T, DIM >	pow (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
ADf< T, DIM >	pow (const ADf< T, DIM > &a, int b)
template<class T , unsigned DIM>
ADf< T, DIM >	sqr (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	exp (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	expf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	expl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	log (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	logf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	logl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	log10 (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	log10f (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	log10l (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	log2 (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	log2f (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	log2l (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	log1p (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	log1pf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	log1pl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	sqrt (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	sin (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	cos (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	tan (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	asin (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	acos (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	atan (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	atan2 (const T &y, const ADf< T, DIM > &x)
template<class T , unsigned DIM>
ADf< T, DIM >	atan2 (const ADf< T, DIM > &y, const T &x)
template<class T , unsigned DIM>
ADf< T, DIM >	atan2 (const ADf< T, DIM > &y, const ADf< T, DIM > &x)
template<class T , unsigned DIM>
ADf< T, DIM >	sinh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	cosh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	tanh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	asinh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	acosh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	atanh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	fmod (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
ADf< T, DIM >	fmod (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
ADf< T, DIM >	fmod (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator== (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator== (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator== (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator!= (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator!= (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator!= (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator> (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator> (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator> (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator>= (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator>= (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator>= (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator< (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator< (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator< (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator<= (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator<= (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator<= (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
ADf< T, DIM >	floor (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	floorf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	floorl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	ceil (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	ceilf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	ceill (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	round (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	roundf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	roundl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	lround (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	lroundf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	lroundl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	llround (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	llroundf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	llroundl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	fabs (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	fabsf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	fabsl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	abs (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	labs (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	llabs (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	max (const olb::BaseType< ADf< T, DIM > > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	max (const ADf< T, DIM > &a, const olb::BaseType< ADf< T, DIM > > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	max (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	min (const olb::BaseType< ADf< T, DIM > > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	min (const ADf< T, DIM > &a, const olb::BaseType< ADf< T, DIM > > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	min (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
bool	nearZero (const ADf< T, DIM > &a)
template<typename T >
constexpr void	throwADfException (T arg)
template<typename T , typename S >
auto	fmod_pos (T a, S b)
	Variant of fmod (floating point modulo) that always returns positive values.
Expr	sqrt (Expr x)
Expr	fabs (Expr x)
Expr	pow (Expr base, Expr exp)
Expr	exp (Expr x)
template<typename T , unsigned D>
decltype(Vector< decltype(util::sqrt(T())), D >())	degreeToRadian (const Vector< T, D > &angle)
template<typename T >
decltype(util::sqrt(T()))	degreeToRadian (T angle)
template<typename T , unsigned D>
decltype(Vector< decltype(util::sqrt(T())), D >())	radianToDegree (const Vector< T, D > &angle)
template<typename T >
decltype(util::sqrt(T()))	radianToDegree (T angle)
template<typename T , unsigned D>
Vector< T, utilities::dimensions::convert< D >::matrix >	calculateRotationMatrix (const Vector< T, utilities::dimensions::convert< D >::rotation > &angle)
template<typename T , unsigned D>
Vector< T, utilities::dimensions::convert< D >::matrix >	invertRotationMatrix (const Vector< T, utilities::dimensions::convert< D >::matrix > &rotationMatrix)
template<typename T , unsigned D>
Vector< T, utilities::dimensions::convert< D >::matrix >	calculateInverseRotationMatrix (const Vector< T, utilities::dimensions::convert< D >::rotation > &angle)
template<typename T , unsigned D, bool OUTPUT_USES_ROTATION_CENTER_AS_ORIGIN = false>
Vector< T, D >	executeRotation (const Vector< T, D > &input, const Vector< T, utilities::dimensions::convert< D >::matrix > &rotationMatrix, const Vector< T, D > &rotationCenter=Vector< T, D >(0.))
	Rotates the input around the rotationCenter with a given rotationMatrix.
template<typename T , unsigned D, bool OUTPUT_USES_ROTATION_CENTER_AS_ORIGIN = false>
Vector< T, D >	invertRotation (const Vector< T, D > &input, const Vector< T, utilities::dimensions::convert< D >::matrix > &rotationMatrix, const Vector< T, D > &rotationCenter=Vector< T, D >(0.))
	Rotates the input around the rotationCenter with a given rotationMatrix in the opposite direction.
template<typename T , unsigned D>
constexpr Vector< T, D >	calculateLocalVelocity (const Vector< T, D > &rotationCenter, const Vector< T, D > &velocity, const Vector< T, utilities::dimensions::convert< D >::rotation > &angularVelocity, const Vector< T, D > &position)
	Calculate local velocity.
template<typename T >
constexpr Matrix< T, 3, 3 >	rotateMofi (const Vector< T, 3 > &mofi, const Vector< T, 9 > &rotationMatrix)
	Rotate moment of inertia (mofi)
template<typename T >
int	evaluateIntegration (std::vector< T > &testValues, bool print=false)
template<typename T >
T	euklidN2 (const T x[], int dim)
	Squared Euclidean norm of an array.
template<typename T >
T	euklidDistance2 (const T x[], const T y[], int dim)
	Squared Euclidean distance between two arrays.
template<typename T >
T	euklidN (const T x[], int dim)
	Euclidean norm of an array.
template<typename T >
T	euklidDistance (const T x[], const T y[], int dim)
	Euclidean distance between two arrays.
template<typename C >
auto	euklidN2 (const C &x)
	Squared Euclidean norm for Container-type array.
template<typename C >
auto	euklidDistance2 (const C &x, const C &y)
	Squared Euclidean distance for Container-type array.
template<typename C >
auto	euklidN (const C &x)
	Euclidean norm for Container-type array.
template<typename C >
auto	euklidDistance (const C &x, const C &y)
	Euclidean distance for Container-type array.
template<typename T >
constexpr T	max (T a, meta::id_t< T > b)
template<typename T , class Compare >
constexpr T	max (T a, meta::id_t< T > b, Compare comp)
template<typename T >
constexpr T	max (std::initializer_list< T > ilist)
template<typename T , class Compare >
constexpr T	max (std::initializer_list< T > ilist, Compare comp)
template<>
float	max< float > (float x, float y) any_platform
template<>
double	max< double > (double x, double y) any_platform
template<typename T >
constexpr T	min (T a, meta::id_t< T > b)
template<typename T , class Compare >
constexpr T	min (T a, meta::id_t< T > b, Compare comp)
template<typename T >
constexpr T	min (std::initializer_list< T > ilist)
template<typename T , class Compare >
constexpr T	min (std::initializer_list< T > ilist, Compare comp)
template<>
float	min< float > (float x, float y) any_platform
template<>
double	min< double > (double x, double y) any_platform
template<typename T , typename S >
any_platform auto	pow (T base, S exp) -> std::enable_if_t< std::is_arithmetic_v< T >, decltype(std::pow(base, exp))>
any_platform float	powf (float base, float exp)
long double	powl (long double base, long double exp)
float	fmod (float x, float y)
float	fmodf (float x, float y)
double	fmod (double x, double y)
long double	fmod (long double x, long double y)
long double	fmodl (long double x, long double y)
float	fmod (float x, int y)
double	fmod (double x, int y)
long double	fmod (long double x, int y)
template<typename T , typename S >
auto	fmod (T x, S y)
template<typename T >
std::enable_if_t< std::is_floating_point_v< T >, T >	exp (T arg) any_platform
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	exp (T arg) any_platform
float	expf (float arg)
long double	expl (long double arg)
float	log (float arg)
float	logf (float arg)
double	log (double arg)
long double	log (long double arg)
long double	logl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	log (T arg)
float	log10 (float arg)
float	log10f (float arg)
double	log10 (double arg)
long double	log10 (long double arg)
long double	log10l (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	log10 (T arg)
float	log2 (float arg)
float	log2f (float arg)
double	log2 (double arg)
long double	log2 (long double arg)
long double	log2l (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	log2 (T arg)
float	log1p (float arg)
float	log1pf (float arg)
double	log1p (double arg)
long double	log1p (long double arg)
long double	log1pl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	log1p (T arg)
any_platform float	sqrtf (float arg)
long double	sqrtl (long double arg)
template<typename T >
std::enable_if_t< std::is_floating_point_v< T >, T >	sqrt (T arg) any_platform
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	sqrt (T arg) any_platform
float	sin (float arg)
float	sinf (float arg)
double	sin (double arg)
long double	sin (long double arg)
long double	sinl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	sin (T arg)
float	sinh (float arg)
float	sinhf (float arg)
double	sinh (double arg)
long double	sinh (long double arg)
long double	sinhl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	sinh (T arg)
float	cos (float arg)
float	cosf (float arg)
double	cos (double arg)
long double	cos (long double arg)
long double	cosl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	cos (T arg)
float	cosh (float arg)
float	coshf (float arg)
double	cosh (double arg)
long double	cosh (long double arg)
long double	coshl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	cosh (T arg)
float	tan (float arg)
float	tanf (float arg)
double	tan (double arg)
long double	tan (long double arg)
long double	tanl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	tan (T arg)
float	tanh (float arg)
float	tanhf (float arg)
double	tanh (double arg)
long double	tanh (long double arg)
long double	tanhl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	tanh (T arg)
float	asin (float arg)
float	asinf (float arg)
double	asin (double arg)
long double	asin (long double arg)
long double	asinl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	asin (T arg)
float	asinh (float arg)
float	asinhf (float arg)
double	asinh (double arg)
long double	asinh (long double arg)
long double	asinhl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	asinh (T arg)
float	acos (float arg)
float	acosf (float arg)
double	acos (double arg)
long double	acos (long double arg)
long double	acosl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	acos (T arg)
float	acosh (float arg)
float	acoshf (float arg)
double	acosh (double arg)
long double	acosh (long double arg)
long double	acoshl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	acosh (T arg)
float	atan (float arg)
float	atanf (float arg)
double	atan (double arg)
long double	atan (long double arg)
long double	atanl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	atan (T arg)
float	atan2 (float y, float x)
float	atan2f (float y, float x)
double	atan2 (double y, double x)
long double	atan2 (long double y, long double x)
long double	atan2l (long double y, long double x)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	atan2 (T y, T x)
float	atanh (float arg)
float	atanhf (float arg)
double	atanh (double arg)
long double	atanh (long double arg)
long double	atanhl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	atanh (T arg)
float	floor (float arg)
double	floor (double arg)
long double	floor (long double arg)
float	floorf (float arg)
long double	floorl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	floor (T arg)
float	ceil (float arg)
double	ceil (double arg)
long double	ceil (long double arg)
float	ceilf (float arg)
long double	ceill (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	ceil (T arg)
float	trunc (float arg)
float	truncf (float arg)
double	trunc (double arg)
long double	trunc (long double arg)
long double	truncl (long double arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	trunc (T arg)
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	round (T arg)
float	round (float arg)
double	round (double arg)
long double	round (long double arg)
float	roundf (float arg)
double	roundf (double arg)
long double	roundl (long double arg)
template<typename T >
std::enable_if_t< std::is_arithmetic_v< T >, long >	lround (T arg)
long	lroundf (float arg)
long	lroundl (long double arg)
template<typename T >
std::enable_if_t< std::is_arithmetic_v< T >, long long >	llround (T arg)
long long	llroundf (float arg)
long long	llroundl (long double arg)
template<typename T >
std::enable_if_t< std::is_arithmetic_v< T >, T >	abs (T arg) any_platform
template<typename T >
std::enable_if_t< std::is_floating_point_v< T >, T >	fabs (T arg) any_platform
template<typename T >
std::enable_if_t< std::is_integral_v< T >, double >	fabs (T arg) any_platform
long	labs (long arg)
long long	llabs (long long arg)
float	fabsf (float arg)
long double	fabs (long double arg)
long double	fabsl (long double arg)
template<typename T , typename DESCRIPTOR >
Timer< T > *	createTimer (XMLreader &param, const UnitConverter< T, DESCRIPTOR > &converter, size_t numLatticePoints)
template<typename T >
bool	nearZero (T a)
	return true if a is close to zero
template<typename T >
bool	nearZero (T a, T epsilon)
template<typename T , typename U = T, typename W = T>
bool	approxEqual (T a, U b, W epsilon)
template<typename T , typename U = T>
bool	approxEqual (T a, U b)
template<class T >
void	copyN (T c[], const T a[], const unsigned dim) any_platform
template<class S , class T >
void	copyN (S c[], const T a[], const unsigned dim) any_platform
template<class T >
void	copy3 (T c[], const T a[])
template<typename T >
std::vector< T >	fromVector3 (const Vector< T, 3 > &vec)
template<typename T >
std::vector< T >	fromVector2 (const Vector< T, 2 > &vec)
template<typename T >
T	norm2 (const std::vector< T > &a)
	l2 norm to the power of 2 of a vector of arbitrary length
template<typename T >
T	dotProduct3D (const Vector< T, 3 > &a, const Vector< T, 3 > &b)
	dot product, only valid in 3d
template<typename T >
T	dotProduct2D (const Vector< T, 2 > &a, const Vector< T, 2 > &b)
	dot product, only valid in 2d
template<typename T , unsigned D>
T	dotProduct (const Vector< T, D > &a, const Vector< T, D > &b)
	dot product
template<typename T , unsigned D>
Vector< T, D >	normalize (const Vector< T, D > &a)
template<typename T >
std::vector< T >	normalize (const std::vector< T > &a)
	returns a normalized vector, works for arbitrary lengths
template<typename T , unsigned Size>
Vector< T, Size >	floor (const Vector< T, Size > &a)
	applies floor to each component of a vector
template<typename T , unsigned Size>
Vector< T, Size >	ceil (const Vector< T, Size > &a)
	applies ceil to each component of a vector
template<typename T , typename S , unsigned Size>
Vector< T, Size >	fmod (const Vector< T, Size > &a, S b)
	applies fmod to each component of a vector
template<typename T , unsigned Size>
T	average (const Vector< T, Size > &a)
	computes the average of all elements
template<typename T , unsigned Size>
T	max_element (const Vector< T, Size > &a)
	finds maximum element of all elements
template<typename T , unsigned Size>
T	min_element (const Vector< T, Size > &a)
	finds minimum element of all elements
template<typename T , unsigned Size>
unsigned	maxElementPos (const Vector< T, Size > &a)
	finds position of maximum element of all elements
template<typename T , unsigned Size>
unsigned	minElementPos (const Vector< T, Size > &a)
	finds position of minimum element of all elements
template<typename T , unsigned Size>
T	maxElementAbs (const Vector< T, Size > &a)
	finds maximum element of all absolute elements
template<typename T , unsigned Size>
unsigned	maxElementAbsPos (const Vector< T, Size > &a)
	finds position of maximum element of all absolute elements
template<typename T , bool ensureAngularBounds = true>
T	angleBetweenVectors (const Vector< T, 2 > &a, const Vector< T, 2 > &b)
	Calculates angles between two 2D vectors.
template<typename T , bool ensureAngularBounds = true>
Vector< T, 3 >	angleBetweenVectors (const Vector< T, 3 > &a, const Vector< T, 3 > &b)
	Calculates angles between two 3D vectors.
template<typename T >
std::vector< T >	assign (T a, T b)
template<typename T >
std::vector< T >	assign (T a, T b, T c)
template<typename U >
void	print (U data, const std::string &name="", OstreamManager clout=OstreamManager(std::cout,"print"), const char delimiter=',')
template<typename C , typename U >
bool	isContained (const C &c, U object)
	Check, if object is contained in iteratable container c.

Variables
template<class T >
constexpr bool	is_adf_v = is_adf<T>::value

Typedef Documentation

StdVector

template<typename S >

using olb::util::StdVector = std::vector<S,std::allocator<S>>

Definition at line 49 of file vectorHelpers.h.

Function Documentation

abs() [1/2]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::abs ( const ADf< T, DIM > & a )

inline

Definition at line 1019 of file aDiff.h.

{
  return fabs(a);
}

References fabs().

Here is the call graph for this function:

Here is the caller graph for this function:

abs() [2/2]

template<typename T >

std::enable_if_t< std::is_arithmetic_v< T >, T > olb::util::abs ( T arg )

inline

Definition at line 881 of file omath.h.

{
#ifdef  __CUDA_ARCH__
  return ::fabs(arg);
#else
  return std::abs(arg);
#endif
}

acos() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::acos ( const ADf< T, DIM > & a )

inline

Definition at line 605 of file aDiff.h.

{
  ADf<T,DIM> c(std::acos(a._v), a._d);
  T tmp(-T(1)/std::sqrt(T(1)-(a._v)*(a._v)));
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

acos() [2/5]

double olb::util::acos ( double arg )

inline

Definition at line 562 of file omath.h.

{
  return std::acos(arg);
}

acos() [3/5]

float olb::util::acos ( float arg )

inline

Definition at line 552 of file omath.h.

{
  return std::acos(arg);
}

acos() [4/5]

long double olb::util::acos ( long double arg )

inline

Definition at line 567 of file omath.h.

{
  return std::acos(arg);
}

acos() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::acos ( T arg )

inline

Definition at line 578 of file omath.h.

{
  return std::acos(arg);
}

acosf()

float olb::util::acosf ( float arg )

inline

Definition at line 557 of file omath.h.

{
  return acos(arg);
}

References acos().

Here is the call graph for this function:

acosh() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::acosh ( const ADf< T, DIM > & a )

inline

Definition at line 675 of file aDiff.h.

{
  if (a._v >= 1) {
    return log( a + sqrt(a*a-1) );
  }
  else {
    ADf<T,DIM> c;
    c._v = std::acosh(a._v);
    c._d = ( std::numeric_limits<T>::quiet_NaN() );
    return c;
  }
}

References olb::util::ADf< T, DIM >::_v, log(), and sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

acosh() [2/5]

double olb::util::acosh ( double arg )

inline

Definition at line 594 of file omath.h.

{
  return std::acosh(arg);
}

acosh() [3/5]

float olb::util::acosh ( float arg )

inline

Definition at line 584 of file omath.h.

{
  return std::acosh(arg);
}

acosh() [4/5]

long double olb::util::acosh ( long double arg )

inline

Definition at line 599 of file omath.h.

{
  return std::acosh(arg);
}

acosh() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::acosh ( T arg )

inline

Definition at line 610 of file omath.h.

{
  return std::acosh(arg);
}

acoshf()

float olb::util::acoshf ( float arg )

inline

Definition at line 589 of file omath.h.

{
  return acosh(arg);
}

References acosh().

Here is the call graph for this function:

acoshl()

long double olb::util::acoshl ( long double arg )

inline

Definition at line 604 of file omath.h.

{
  return acosh(arg);
}

References acosh().

Here is the call graph for this function:

acosl()

long double olb::util::acosl ( long double arg )

inline

Definition at line 572 of file omath.h.

{
  return acos(arg);
}

References acos().

Here is the call graph for this function:

aligned_to_grid()

template<typename T >

bool olb::util::aligned_to_grid ( const std::vector< T > & vec )

inline

Definition at line 78 of file util.h.

{
  return (aligned_to_x<T>(vec) or
          aligned_to_y<T>(vec) or
          aligned_to_z<T>(vec));
}

aligned_to_x()

template<typename T >

bool olb::util::aligned_to_x ( const std::vector< T > & vec )

inline

Definition at line 60 of file util.h.

{
  return (vec[0]!=0 and vec[1]==0 and vec[2]==0);
}

aligned_to_y()

template<typename T >

bool olb::util::aligned_to_y ( const std::vector< T > & vec )

inline

Definition at line 66 of file util.h.

{
  return (vec[0]==0 and vec[1]!=0 and vec[2]==0);
}

aligned_to_z()

template<typename T >

bool olb::util::aligned_to_z ( const std::vector< T > & vec )

inline

Definition at line 72 of file util.h.

{
  return (vec[0]==0 and vec[1]==0 and vec[2]!=0);
}

angleBetweenVectors() [1/2]

template<typename T , bool ensureAngularBounds = true>

T olb::util::angleBetweenVectors	(	const Vector< T, 2 > &	a,
		const Vector< T, 2 > &	b )

Calculates angles between two 2D vectors.

Definition at line 331 of file vectorHelpers.h.

{
  if constexpr(ensureAngularBounds){
    return std::fmod(util::atan2(b[1]*a[0]-b[0]*a[1], a[0]*b[0]+a[1]*b[1]), M_PI);
  } else {
    return util::atan2(b[1]*a[0]-b[0]*a[1], a[0]*b[0]+a[1]*b[1]);
  }
}

References atan2(), and M_PI.

Here is the call graph for this function:

Here is the caller graph for this function:

angleBetweenVectors() [2/2]

template<typename T , bool ensureAngularBounds = true>

Vector< T, 3 > olb::util::angleBetweenVectors	(	const Vector< T, 3 > &	a,
		const Vector< T, 3 > &	b )

Calculates angles between two 3D vectors.

Definition at line 342 of file vectorHelpers.h.

{
  Vector<T,3> angles;
  angles[0] = angleBetweenVectors<T,ensureAngularBounds>(Vector<T,2>(a[1], a[2]), Vector<T,2>(b[1], b[2]));
  angles[1] = angleBetweenVectors<T,ensureAngularBounds>(Vector<T,2>(a[0], a[2]), Vector<T,2>(b[0], b[2]));
  angles[2] = angleBetweenVectors<T,ensureAngularBounds>(Vector<T,2>(a[0], a[1]), Vector<T,2>(b[0], b[1]));
  return angles;
}

approxEqual() [1/2]

template<typename T , typename U = T>

bool olb::util::approxEqual ( T a, U b )

inline

Definition at line 88 of file vectorHelpers.h.

{
  if (a==b) {
    return true;
  }
  if (nearZero(a) && nearZero(b)) {
    return true;
  }
  T EPSILON = std::numeric_limits<T>::epsilon()*4.*util::fabs(a);
  return approxEqual(a,b,EPSILON);
}

References approxEqual(), fabs(), and nearZero().

Here is the call graph for this function:

approxEqual() [2/2]

template<typename T , typename U = T, typename W = T>

bool olb::util::approxEqual ( T a, U b, W epsilon )

inline

Definition at line 79 of file vectorHelpers.h.

{
  if (a==b) {
    return true;
  }
  return nearZero<T>(a - b, epsilon);
}

Here is the caller graph for this function:

asin() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::asin ( const ADf< T, DIM > & a )

inline

Definition at line 596 of file aDiff.h.

{
  ADf<T,DIM> c(std::asin(a._v), a._d);
  T tmp(T(1)/std::sqrt(T(1)-(a._v)*(a._v)));
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

asin() [2/5]

double olb::util::asin ( double arg )

inline

Definition at line 498 of file omath.h.

{
  return std::asin(arg);
}

asin() [3/5]

float olb::util::asin ( float arg )

inline

Definition at line 488 of file omath.h.

{
  return std::asin(arg);
}

asin() [4/5]

long double olb::util::asin ( long double arg )

inline

Definition at line 503 of file omath.h.

{
  return std::asin(arg);
}

asin() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::asin ( T arg )

inline

Definition at line 514 of file omath.h.

{
  return std::asin(arg);
}

asinf()

float olb::util::asinf ( float arg )

inline

Definition at line 493 of file omath.h.

{
  return asin(arg);
}

References asin().

Here is the call graph for this function:

asinh() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::asinh ( const ADf< T, DIM > & a )

inline

Definition at line 669 of file aDiff.h.

{
  return log( a + sqrt(a*a+1) );
}

References log(), and sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

asinh() [2/5]

double olb::util::asinh ( double arg )

inline

Definition at line 530 of file omath.h.

{
  return std::asinh(arg);
}

asinh() [3/5]

float olb::util::asinh ( float arg )

inline

Definition at line 520 of file omath.h.

{
  return std::asinh(arg);
}

asinh() [4/5]

long double olb::util::asinh ( long double arg )

inline

Definition at line 535 of file omath.h.

{
  return std::asinh(arg);
}

asinh() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::asinh ( T arg )

inline

Definition at line 546 of file omath.h.

{
  return std::asinh(arg);
}

asinhf()

float olb::util::asinhf ( float arg )

inline

Definition at line 525 of file omath.h.

{
  return asinh(arg);
}

References asinh().

Here is the call graph for this function:

asinhl()

long double olb::util::asinhl ( long double arg )

inline

Definition at line 540 of file omath.h.

{
  return asinh(arg);
}

References asinh().

Here is the call graph for this function:

asinl()

long double olb::util::asinl ( long double arg )

inline

Definition at line 508 of file omath.h.

{
  return asin(arg);
}

References asin().

Here is the call graph for this function:

assign() [1/2]

template<typename T >

std::vector< T > olb::util::assign	(	T	a,
		T	b )

Definition at line 399 of file vectorHelpers.h.

{
  std::vector<T> v1;
  v1.push_back(a);
  v1.push_back(b);
  return v1;
}

assign() [2/2]

template<typename T >

std::vector< T > olb::util::assign	(	T	a,
		T	b,
		T	c )

Definition at line 408 of file vectorHelpers.h.

{
  std::vector<T> v1;
  v1.push_back(a);
  v1.push_back(b);
  v1.push_back(c);
  return v1;
}

atan() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::atan ( const ADf< T, DIM > & a )

inline

Definition at line 614 of file aDiff.h.

{
  ADf<T,DIM> c(std::atan(a._v), a._d);
  T tmp(T(1)/(T(1)+(a._v)*(a._v)));
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

atan() [2/5]

double olb::util::atan ( double arg )

inline

Definition at line 626 of file omath.h.

{
  return std::atan(arg);
}

atan() [3/5]

float olb::util::atan ( float arg )

inline

Definition at line 616 of file omath.h.

{
  return std::atan(arg);
}

atan() [4/5]

long double olb::util::atan ( long double arg )

inline

Definition at line 631 of file omath.h.

{
  return std::atan(arg);
}

atan() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::atan ( T arg )

inline

Definition at line 642 of file omath.h.

{
  return std::atan(arg);
}

atan2() [1/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::atan2 ( const ADf< T, DIM > & y, const ADf< T, DIM > & x )

inline

Definition at line 641 of file aDiff.h.

{
  ADf<T,DIM> c(std::atan2(y._v, x._v));
  T tmpA(x._v / (x._v*x._v + y._v*y._v));
  T tmpB(-y._v / (x._v*x._v + y._v*y._v));
  c._d = tmpA*y._d + tmpB*x._d;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

atan2() [2/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::atan2 ( const ADf< T, DIM > & y, const T & x )

inline

Definition at line 632 of file aDiff.h.

{
  ADf<T,DIM> c(std::atan2(y._v, x));
  T tmpA(x / (x*x + y._v*y._v));
  c._d = tmpA*y._d;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

atan2() [3/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::atan2 ( const T & y, const ADf< T, DIM > & x )

inline

Definition at line 623 of file aDiff.h.

{
  ADf<T,DIM> c(std::atan2(y, x._v));
  T tmpB(-y / (x._v*x._v + y*y));
  c._d = tmpB*x._d;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

atan2() [4/7]

double olb::util::atan2 ( double y, double x )

inline

Definition at line 658 of file omath.h.

{
  return std::atan2(y, x);
}

atan2() [5/7]

float olb::util::atan2 ( float y, float x )

inline

Definition at line 648 of file omath.h.

{
  return std::atan2(y, x);
}

atan2() [6/7]

long double olb::util::atan2 ( long double y, long double x )

inline

Definition at line 663 of file omath.h.

{
  return std::atan2(y, x);
}

atan2() [7/7]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::atan2 ( T y, T x )

inline

Definition at line 674 of file omath.h.

{
  return std::atan2(y, x);
}

atan2f()

float olb::util::atan2f ( float y, float x )

inline

Definition at line 653 of file omath.h.

{
  return atan2(y, x);
}

References atan2().

Here is the call graph for this function:

atan2l()

long double olb::util::atan2l ( long double y, long double x )

inline

Definition at line 668 of file omath.h.

{
  return atan2(y, x);
}

References atan2().

Here is the call graph for this function:

atanf()

float olb::util::atanf ( float arg )

inline

Definition at line 621 of file omath.h.

{
  return atan(arg);
}

References atan().

Here is the call graph for this function:

atanh() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::atanh ( const ADf< T, DIM > & a )

inline

Definition at line 689 of file aDiff.h.

{
  if (std::abs(a._v) < 1) {
    return 0.5 * log( (1+a) / (1-a) );
  }
  else {
    ADf<T,DIM> c;
    c._v = std::atanh(a._v);
    c._d = ( std::numeric_limits<T>::quiet_NaN() );
    return c;
  }
}

References olb::util::ADf< T, DIM >::_v, and log().

Here is the call graph for this function:

Here is the caller graph for this function:

atanh() [2/5]

double olb::util::atanh ( double arg )

inline

Definition at line 690 of file omath.h.

{
  return std::atanh(arg);
}

atanh() [3/5]

float olb::util::atanh ( float arg )

inline

Definition at line 680 of file omath.h.

{
  return std::atanh(arg);
}

atanh() [4/5]

long double olb::util::atanh ( long double arg )

inline

Definition at line 695 of file omath.h.

{
  return std::atanh(arg);
}

atanh() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::atanh ( T arg )

inline

Definition at line 706 of file omath.h.

{
  return std::atanh(arg);
}

atanhf()

float olb::util::atanhf ( float arg )

inline

Definition at line 685 of file omath.h.

{
  return atanh(arg);
}

References atanh().

Here is the call graph for this function:

atanhl()

long double olb::util::atanhl ( long double arg )

inline

Definition at line 700 of file omath.h.

{
  return atanh(arg);
}

References atanh().

Here is the call graph for this function:

atanl()

long double olb::util::atanl ( long double arg )

inline

Definition at line 636 of file omath.h.

{
  return atan(arg);
}

References atan().

Here is the call graph for this function:

average()

template<typename T , unsigned Size>

T olb::util::average

(

const Vector< T, Size > &

a

)

computes the average of all elements

Definition at line 246 of file vectorHelpers.h.

{
  T sum = a[0];
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    sum += a[iDim];
  }
  return sum/Size;
}

Here is the caller graph for this function:

bisectDistance()

template<typename S , unsigned D, typename F1 , typename F2 >

bool olb::util::bisectDistance	(	S &	distance,
		const Vector< S, D > &	origin,
		const Vector< S, D > &	direction,
		S	pitch,
		S	precision,
		F1	isInside,
		F2	isInsideBoundingBox )

Using a bisect to find the unsigned distance (false if distance was not found, true if distance was found)

Parameters

distance	computed distance from origin to surface in direction
direction	is saved here
origin	the point we want to calculate the distance from
direction	the considered direction
pitch	a first guess for the distance, must be > 0 (if origin is inside origin + normalize(direction) * pitch should be outside and if origin is outside origin + normalize(direction) * pitch should be inside)
precision	when the change of the found distance reaches the defined precision, the iteration stops
isInside	function that defines if a point is inside or outside a geometry (usually the ()-operator of an Indicator)
isInsideBoundingBox	function that defines if a point is inside the enclosing bounding box (maybe needs at least one extra layer between geometry surface and bounding box surface)

Definition at line 168 of file indicatorBase.h.

{
  distance = S(0);
  Vector<S,D> dir = normalize(direction);
 
  // Check if origin is on surface
  bool isInsideDistance = isInside(origin + 5*precision*dir);
  bool isInsideOppDistance = isInside(origin - 5*precision*dir);
  if (isInsideDistance == !isInsideOppDistance) {
    return true;
  }
 
  Vector<S,D> startPoint = origin;
  S fixedDistance = S(0);
  S oldDistance = distance;
  std::function<Vector<S,D>()> calcCurrPoint = [&startPoint, &pitch, &dir]() {
    return startPoint + pitch * dir;
  };
  Vector<S,D> currPoint = calcCurrPoint();
 
  bool originValue = isInside(startPoint);
  bool currentValue = isInside(currPoint);
 
  // if aforementioned requirement for pitch is not given, try to find a proper pitch
  while (originValue == currentValue) {
    pitch *= 1.5;
    currPoint = calcCurrPoint();
    currentValue = isInside(currPoint);
 
    // if both points are outside the bounding box return false indicating that no distance was found
    if (!currentValue && !isInsideBoundingBox(startPoint) && !isInsideBoundingBox(currPoint)) {
      return false;
    }
  }
 
  for (unsigned iD=0; iD<D; ++iD) {
    if (!std::isfinite(currPoint[iD])) {
      return false;
    }
  }
 
  // if we have one point inside and another outside, we can keep halving the line from origin to currPoint until we find the wanted precision
  distance = norm(startPoint - currPoint);
  while ( util::abs(distance - oldDistance) > precision ) {
    pitch *= 0.5;
    currPoint = calcCurrPoint();
 
    // set distances
    oldDistance = distance;
    distance = norm(startPoint - currPoint);
 
    // if both points are outside or inside run take result of same function with different start point (= current point)
    currentValue = isInside(currPoint);
    if (currentValue == originValue) {
      startPoint = currPoint;
      fixedDistance += distance;
      // convert distances to distance to new start point
      oldDistance -= distance;
      distance = S(0);
    }
  }
  distance += fixedDistance;
 
  return true;
}

References abs(), distance(), norm(), and normalize().

Here is the call graph for this function:

calculateInverseRotationMatrix()

template<typename T , unsigned D>

Vector< T, utilities::dimensions::convert< D >::matrix > olb::util::calculateInverseRotationMatrix

(

const Vector< T, utilities::dimensions::convert< D >::rotation > &

angle

)

Definition at line 137 of file geometricOperations.h.

{
  return invertRotationMatrix<T, D>(calculateRotationMatrix<T, D>(angle));
}

calculateLocalVelocity()

template<typename T , unsigned D>

constexpr Vector< T, D > olb::util::calculateLocalVelocity ( const Vector< T, D > & rotationCenter, const Vector< T, D > & velocity, const Vector< T, utilities::dimensions::convert< D >::rotation > & angularVelocity, const Vector< T, D > & position )

constexpr

Calculate local velocity.

Definition at line 194 of file geometricOperations.h.

{
  if constexpr (D == 2) {
    // two dimensions: u = U + w x r = (Ux, Uy, 0) + (0,0,w) x (X,Y,0) = (Ux, Uy, 0) + (-w*Y, w*X, 0)
    return Vector<T, 2>(
        velocity[0] - angularVelocity[0] * (position[1] - rotationCenter[1]),
        velocity[1] + angularVelocity[0] * (position[0] - rotationCenter[0]));
  }
  else {
    // three dimensions: u = U + w x r = (Ux, Uy, Uz) + (wx,wy,wz) x (X,Y,Z) = (Ux, Uy, Uz) + (wy*Z-wz*Y, wz*X-wx*Z, wx*Y-wy*X)
    return velocity +
           crossProduct3D(angularVelocity, position - rotationCenter);
  }
  __builtin_unreachable();
}

References olb::crossProduct3D().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateRotationMatrix()

template<typename T , unsigned D>

Vector< T, utilities::dimensions::convert< D >::matrix > olb::util::calculateRotationMatrix

(

const Vector< T, utilities::dimensions::convert< D >::rotation > &

angle

)

Definition at line 69 of file geometricOperations.h.

{
  Vector<T, utilities::dimensions::convert<D>::matrix> rotationMatrix;
 
  if constexpr (D == 2) {
    T const cos = util::cos(angle[0]);
    T const sin = util::sin(angle[0]);
 
    // row 1
    rotationMatrix[0] = cos;
    rotationMatrix[1] = -sin;
    // row 2
    rotationMatrix[2] = sin;
    rotationMatrix[3] = cos;
  }
  else {
    T const cos[3] = {util::cos(angle[0]), util::cos(angle[1]),
                      util::cos(angle[2])};
    T const sin[3] = {util::sin(angle[0]), util::sin(angle[1]),
                      util::sin(angle[2])};
 
    // |x0| / 0 1 2 \   |x1|
    // |y0| | 3 4 5 | = |x1|
    // |z0| \ 6 7 8 /   |x1|
 
    // row 1
    rotationMatrix[0] = cos[1] * cos[2];
    rotationMatrix[1] = sin[0] * sin[1] * cos[2] - cos[0] * sin[2];
    rotationMatrix[2] = cos[0] * sin[1] * cos[2] + sin[0] * sin[2];
    // row 2
    rotationMatrix[3] = cos[1] * sin[2];
    rotationMatrix[4] = sin[0] * sin[1] * sin[2] + cos[0] * cos[2];
    rotationMatrix[5] = cos[0] * sin[1] * sin[2] - sin[0] * cos[2];
    // row 3
    rotationMatrix[6] = -sin[1];
    rotationMatrix[7] = sin[0] * cos[1];
    rotationMatrix[8] = cos[0] * cos[1];
  }
 
  return rotationMatrix;
}

References cos(), and sin().

Here is the call graph for this function:

ceil() [1/6]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::ceil ( const ADf< T, DIM > & a )

inline

Definition at line 900 of file aDiff.h.

{
  // Similar to floor
  ADf<T,DIM> c (std::ceil(a._v));
  if (a._v == c._v) {
#ifdef AdWarnings
    std::cout << "ADf WARNING: ceil(Adf) - ceil evaluated at non-differentiable point" << std::endl;
#endif
    for (unsigned i = 0; i < DIM; ++i) {
      c._d[i] = (a.d(i) == 0) ? T(0) : std::numeric_limits<T>::quiet_NaN();
    }
  }
  return c;
}

References olb::util::ADf< T, DIM >::_v, and olb::util::ADf< T, DIM >::d().

Here is the call graph for this function:

Here is the caller graph for this function:

ceil() [2/6]

template<typename T , unsigned Size>

Vector< T, Size > olb::util::ceil

(

const Vector< T, Size > &

a

)

applies ceil to each component of a vector

Definition at line 224 of file vectorHelpers.h.

{
  Vector<T,Size> out;
  for (unsigned int iDim=0; iDim < Size; ++iDim) {
    out[iDim] = util::ceil(a[iDim]);
  }
  return out;
}

References ceil().

Here is the call graph for this function:

ceil() [3/6]

double olb::util::ceil ( double arg )

inline

Definition at line 751 of file omath.h.

{
  return std::ceil(arg);
}

ceil() [4/6]

float olb::util::ceil ( float arg )

inline

Definition at line 746 of file omath.h.

{
  return std::ceil(arg);
}

ceil() [5/6]

long double olb::util::ceil ( long double arg )

inline

Definition at line 756 of file omath.h.

{
  return std::ceil(arg);
}

ceil() [6/6]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::ceil ( T arg )

inline

Definition at line 772 of file omath.h.

{
  return std::ceil(arg);
}

ceilf() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::ceilf ( const ADf< float, DIM > & a )

inline

Definition at line 916 of file aDiff.h.

{
  return ceil(a);
}

References ceil().

Here is the call graph for this function:

ceilf() [2/2]

float olb::util::ceilf ( float arg )

inline

Definition at line 761 of file omath.h.

{
  return ceil(arg);
}

References ceil().

Here is the call graph for this function:

ceill() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::ceill ( const ADf< long double, DIM > & a )

inline

Definition at line 922 of file aDiff.h.

{
  return ceil(a);
}

References ceil().

Here is the call graph for this function:

ceill() [2/2]

long double olb::util::ceill ( long double arg )

inline

Definition at line 766 of file omath.h.

{
  return ceil(arg);
}

References ceil().

Here is the call graph for this function:

contained() [1/2]

bool olb::util::contained ( int x, int y, int x0, int x1, int y0, int y1 )

inline

Definition at line 119 of file util.h.

{
  return x>=x0 && x<=x1 &&
         y>=y0 && y<=y1;
}

Here is the caller graph for this function:

contained() [2/2]

bool olb::util::contained ( int x, int y, int z, int x0, int x1, int y0, int y1, int z0, int z1 )

inline

Definition at line 126 of file util.h.

{
  return x>=x0 && x<=x1 &&
         y>=y0 && y<=y1 &&
         z>=z0 && z<=z1;
}

copy3()

template<class T >

void olb::util::copy3 ( T c[], const T a[] )

inline

Definition at line 117 of file vectorHelpers.h.

{
  for (unsigned i=0; i<3; i++) {
    c[i] = a[i];
  }
}

copyAs()

template<typename T , typename S , template< typename > typename C>

C< T > olb::util::copyAs

(

const C< S > &

input

)

copy vector with specified typecast

Definition at line 72 of file adHelpers.h.

                               {
  C<T> result = ContainerCreator<C<T>>::create(input.size());
 
  for(std::size_t it = 0; it < input.size(); ++it) {
    result[it] = T(input[it]);
  }
  return result;
}

copyDerivatives()

template<typename T , typename TAD >

void olb::util::copyDerivatives	(	T *	target,
		const TAD *	source,
		int	length )

Copy the derivatives from an ADf array into an array.

Returns

target[j*dim+i] = source[j].d(i) = d/dx_i (s_j)

Parameters

length

= length of the array

Definition at line 61 of file adHelpers.h.

                                                               {
  for (int j = 0; j < length; ++j) {
    for (unsigned i = 0; i < TAD::dim; ++i) {
      target[j*(TAD::dim)+i] = source[j].d(i);
    }
  }
}

Here is the caller graph for this function:

copyN() [1/2]

template<class S , class T >

void olb::util::copyN ( S c[], const T a[], const unsigned dim )

inline

Definition at line 109 of file vectorHelpers.h.

{
  for (unsigned i=0; i<dim; i++) {
    c[i] = a[i];
  }
}

copyN() [2/2]

template<class T >

void olb::util::copyN ( T c[], const T a[], const unsigned dim )

inline

Definition at line 101 of file vectorHelpers.h.

{
  for (unsigned i=0; i<dim; i++) {
    c[i] = a[i];
  }
}

Here is the caller graph for this function:

cos() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::cos ( const ADf< T, DIM > & a )

inline

Definition at line 578 of file aDiff.h.

{
  ADf<T,DIM> c(std::cos(a._v), a._d);
  T tmp(-std::sin(a._v));
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

cos() [2/5]

double olb::util::cos ( double arg )

inline

Definition at line 370 of file omath.h.

{
  return std::cos(arg);
}

cos() [3/5]

float olb::util::cos ( float arg )

inline

Definition at line 360 of file omath.h.

{
  return std::cos(arg);
}

cos() [4/5]

long double olb::util::cos ( long double arg )

inline

Definition at line 375 of file omath.h.

{
  return std::cos(arg);
}

cos() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::cos ( T arg )

inline

Definition at line 386 of file omath.h.

{
  return std::cos(arg);
}

cosf()

float olb::util::cosf ( float arg )

inline

Definition at line 365 of file omath.h.

{
  return cos(arg);
}

References cos().

Here is the call graph for this function:

cosh() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::cosh ( const ADf< T, DIM > & a )

inline

Definition at line 657 of file aDiff.h.

{
  return 0.5*(exp(a)+exp(-a));
}

References exp().

Here is the call graph for this function:

Here is the caller graph for this function:

cosh() [2/5]

double olb::util::cosh ( double arg )

inline

Definition at line 402 of file omath.h.

{
  return std::cosh(arg);
}

cosh() [3/5]

float olb::util::cosh ( float arg )

inline

Definition at line 392 of file omath.h.

{
  return std::cosh(arg);
}

cosh() [4/5]

long double olb::util::cosh ( long double arg )

inline

Definition at line 407 of file omath.h.

{
  return std::cosh(arg);
}

cosh() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::cosh ( T arg )

inline

Definition at line 418 of file omath.h.

{
  return std::cosh(arg);
}

coshf()

float olb::util::coshf ( float arg )

inline

Definition at line 397 of file omath.h.

{
  return cosh(arg);
}

References cosh().

Here is the call graph for this function:

coshl()

long double olb::util::coshl ( long double arg )

inline

Definition at line 412 of file omath.h.

{
  return cosh(arg);
}

References cosh().

Here is the call graph for this function:

cosl()

long double olb::util::cosl ( long double arg )

inline

Definition at line 380 of file omath.h.

{
  return cos(arg);
}

References cos().

Here is the call graph for this function:

createTimer()

template<typename T , typename DESCRIPTOR >

Timer< T > * olb::util::createTimer	(	XMLreader &	param,
		const UnitConverter< T, DESCRIPTOR > &	converter,
		size_t	numLatticePoints )

Definition at line 260 of file timer.hh.

{
  OstreamManager clout(std::cout,"createTimer");
 
  // initialize parameters with some default values
  T physMaxT = T();
  T physStartT = T();
  int printModeSummary = 0;
 
  // fetch xml Data and error handling
  if ( ! param["Application"]["PhysParameters"]["PhysMaxTime"].read(physMaxT) ) {
    if ( ! param["Application"]["PhysParam"]["MaxTime"].read(physStartT) ) {
      clout << "PhysMaxTime not found" << std::endl;
    }
    else {
      clout << "Application::PhysParam::MaxTime needs to be renamed to Application::PhysParameters::PhysMaxTime" << std::endl;
    }
  }
  // read the variable for the mode of printSummary
  param.readOrWarn<int>("Output","Timer","PrintModeSummary", printModeSummary,true,false,false);
 
//  if ( ! param["Application"]["PhysParam"]["MaxStartTime"].read(physStartT) ) {
//    clout << "PhysStartTime not found" << std::endl;
//  }
 
  // variable processing according to the constructor
  int maxT = converter.getLatticeTime(physMaxT) + converter.getLatticeTime(physStartT);
 
  //return some default values that produce reasonable output (e.g.
  // zero); in best case there should be no output at all (TODO)
  return new Timer<T>(maxT, numLatticePoints, printModeSummary);
}

References olb::UnitConverter< T, DESCRIPTOR >::getLatticeTime(), and olb::XMLreader::readOrWarn().

Here is the call graph for this function:

degreeToRadian() [1/2]

template<typename T , unsigned D>

decltype(Vector< decltype(util::sqrt(T())), D >()) olb::util::degreeToRadian

(

const Vector< T, D > &

angle

)

Definition at line 42 of file geometricOperations.h.

{
  constexpr BaseType<decltype(util::sqrt(T()))> conversionFactor = M_PI / 180.;
  return conversionFactor * angle;
}

References M_PI, and sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

degreeToRadian() [2/2]

template<typename T >

decltype(util::sqrt(T())) olb::util::degreeToRadian

(

T

angle

)

Definition at line 49 of file geometricOperations.h.

{
  return degreeToRadian(Vector<T, 1>(angle))[0];
}

References degreeToRadian().

Here is the call graph for this function:

densityFromPressure()

template<typename T , typename DESCRIPTOR >

T olb::util::densityFromPressure

(

T

latticePressure

)

compute lattice density from lattice pressure

Definition at line 379 of file util.h.

{
  // rho = p / c_s^2 + 1
  return latticePressure * descriptors::invCs2<T,DESCRIPTOR>() + 1.0;
}

derivativeFAD() [1/3]

template<unsigned sourceDIM, typename S , typename F >

auto olb::util::derivativeFAD	(	F	f,
		const S *	input )

Compute derivatives of a function f: S^sourceDIM -> T via forward AD Signature is "V f(U*)" so f is expected to return a single value.

It must be (captured by) a lambda function that handles arbitrary types, so "auto f(auto x)" is to be written.

Definition at line 128 of file adHelpers.h.

                                         {
  using SAD = ADf<S,sourceDIM>;
  using T = decltype(f(input));
  using TAD = ADf<T,sourceDIM>;
 
  SAD inputAD[sourceDIM];
  util::copyN(inputAD, input, sourceDIM);
  util::iniDiagonal(inputAD, sourceDIM);
 
  TAD resultAD = f(inputAD);
  T* result = new T[sourceDIM];
  copyDerivatives(result, &resultAD, 1);
  return result;
}

References copyDerivatives(), copyN(), and iniDiagonal().

Here is the call graph for this function:

derivativeFAD() [2/3]

template<typename S , typename F >

auto olb::util::derivativeFAD	(	F	f,
		const S	input )

Compute derivatives of a function f: S -> T via forward AD Signature is "V f(U)" so f is expected to accept and return a single value.

It must be (captured by) a lambda function that handles arbitrary types, so "auto f(auto x)" is to be written.

Definition at line 115 of file adHelpers.h.

                                        {
  ADf<S,1> inputAD = input;
  inputAD.setDiffVariable(0);
 
  return f(inputAD).d(0);
}

References olb::util::ADf< T, DIM >::setDiffVariable().

Here is the call graph for this function:

derivativeFAD() [3/3]

template<unsigned sourceDIM, typename T , typename S , typename F >

void olb::util::derivativeFAD	(	F	f,
		T *	output,
		const S *	input,
		unsigned	targetDIM )

Compute derivatives of a function f: S^sourceDIM -> T^targetDIM via forward AD Signature of f is "void f(V*, U*)", it is expected to modify the first argument in-place.

f must be (captured by) a lambda function that handles arbitrary types, so "void f(auto y, auto x)" is to be written.

Definition at line 150 of file adHelpers.h.

                                                                        {
  using SAD = ADf<S,sourceDIM>;
  using TAD = ADf<T,sourceDIM>;
 
  SAD inputAD[sourceDIM];
  util::copyN(inputAD, input, sourceDIM);
  util::iniDiagonal(inputAD, sourceDIM);
  TAD outputAD[targetDIM];
 
  f(outputAD, inputAD);
  copyDerivatives(output, outputAD, targetDIM);
  return;
}

References copyDerivatives(), copyN(), and iniDiagonal().

Here is the call graph for this function:

distance() [1/3]

template<typename S , unsigned D, typename F1 , typename F2 >

bool olb::util::distance	(	S &	distance,
		const Vector< S, D > &	origin,
		const Vector< S, D > &	direction,
		S	precision,
		F1	sdf,
		F2	isInsideBoundingBox,
		const unsigned	maxIt = 1e6 )

Definition at line 95 of file indicatorBase.h.

{
  S signedDistance{sdf(origin)};
  Vector<S,D> currPos{origin};
  const Vector<S,D> dir{util::sign(signedDistance) * normalize(direction)};
 
  if (util::fabs(signedDistance) <= precision) {
    distance = util::fabs(signedDistance);
    return true;
  }
 
  distance = S{0};
  for(unsigned i=0; util::fabs(signedDistance) > precision && i<maxIt; ++i) {
    distance += signedDistance;
    currPos += signedDistance * dir;
    signedDistance = sdf(currPos);
    if (!isInsideBoundingBox(currPos)) {
      distance = S{0};
      return false;
    }
  }
 
  distance = util::fabs(distance);
  return true;
}

References distance(), fabs(), normalize(), and sign().

Here is the call graph for this function:

distance() [2/3]

template<typename S , unsigned D, typename F1 , typename F2 >

bool olb::util::distance	(	S &	distance,
		const Vector< S, D > &	origin,
		const Vector< S, D > &	direction,
		S	precision,
		S	pitch,
		F1	isInside,
		F2	isInsideBoundingBox )

Definition at line 36 of file indicatorBase.h.

{
  // Check if point is on surface
  bool isInsideDistance;
  bool isInsideOppDistance;
  Vector<S,D> currentPoint = origin + 10*precision*direction;
  isInside(&isInsideDistance, currentPoint.data());
  currentPoint = origin - 10*precision*direction;
  isInside(&isInsideOppDistance, currentPoint.data());
  if (isInsideDistance == !isInsideOppDistance) {
    distance = 0;
    return true;
  }
 
  bool originValue;
  bool currentValue;
 
  isInside(&originValue, origin.data());
 
  // start at origin and move into given direction
  currentPoint = origin;
  currentValue = originValue;
 
  while (currentValue == originValue && isInsideBoundingBox(currentPoint)) {
    currentPoint += direction;
    // update currentValue until the first point on the other side (inside/outside) is found
    isInside(&currentValue, currentPoint.data());
  }
 
  // return false if no point was found in given direction
  if (!isInsideBoundingBox(currentPoint) && !originValue) {
    return false;
  }
 
 
  while (pitch >= precision) {
    if (!isInsideBoundingBox(currentPoint) && originValue) {
      currentPoint -= pitch * direction;
      pitch *= 0.5;
    }
    else {
      isInside(&currentValue, currentPoint.data());
      if (currentValue == originValue) {
        currentPoint += pitch * direction;
        pitch *= 0.5;
      }
      else {
        currentPoint -= pitch * direction;
        pitch *= 0.5;
      }
    }
  }
 
  distance = norm(currentPoint - origin);
  return true;
}

References olb::Vector< T, D >::data(), distance(), and norm().

Here is the call graph for this function:

Here is the caller graph for this function:

distance() [3/3]

template<typename S , unsigned D, bool normalizeDirection = true>

bool olb::util::distance	(	S &	distance,
		const Vector< S, D > &	origin,
		const Vector< S, D > &	direction,
		S	precision,
		std::function< S(const Vector< S, D > &)>	sdf,
		S	maxDistance,
		const unsigned	maxIt = 1e6 )

Definition at line 123 of file indicatorBase.h.

{
  S signedDistance{sdf(origin)};
  Vector<S,D> currPos{origin};
  Vector<S,D> dir;
  if constexpr(normalizeDirection) {
    dir = util::sign(signedDistance) * normalize(direction);
  }
  else {
    dir = util::sign(signedDistance) * direction;
  }
 
  if (util::fabs(signedDistance) <= precision) {
    distance = util::fabs(signedDistance);
    return true;
  }
 
  distance = S{0};
  for(unsigned i=0; util::fabs(signedDistance) > precision && i<maxIt; ++i) {
    distance += signedDistance;
    currPos += signedDistance * dir;
    signedDistance = sdf(currPos);
    if (signedDistance > maxDistance) {
      distance = S{0};
      return false;
    }
  }
 
  distance = util::fabs(distance);
  return true;
}

References distance(), fabs(), normalize(), and sign().

Here is the call graph for this function:

dotProduct()

template<typename T , unsigned D>

T olb::util::dotProduct	(	const Vector< T, D > &	a,
		const Vector< T, D > &	b )

dot product

Definition at line 183 of file vectorHelpers.h.

{
  if constexpr (D==2){
    return dotProduct2D(a, b);
  } else {
    return dotProduct3D(a, b);
  }
}

References dotProduct2D(), and dotProduct3D().

Here is the call graph for this function:

dotProduct2D()

template<typename T >

T olb::util::dotProduct2D	(	const Vector< T, 2 > &	a,
		const Vector< T, 2 > &	b )

dot product, only valid in 2d

Definition at line 176 of file vectorHelpers.h.

{
  return a[0]*b[0] + a[1]*b[1];
}

Here is the caller graph for this function:

dotProduct3D()

template<typename T >

T olb::util::dotProduct3D	(	const Vector< T, 3 > &	a,
		const Vector< T, 3 > &	b )

dot product, only valid in 3d

Definition at line 169 of file vectorHelpers.h.

{
  return a[0]*b[0] + a[1]*b[1] + a[2]*b[2];
}

Here is the caller graph for this function:

euklidDistance() [1/2]

template<typename C >

auto olb::util::euklidDistance	(	const C &	x,
		const C &	y )

Euclidean distance for Container-type array.

Definition at line 97 of file norm.h.

{
  OLB_ASSERT((x.size() == y.size()), "Arrays must have same dimension");
  return euklidDistance(x.data(), y.data(), x.size());
}

References euklidDistance(), and OLB_ASSERT.

Here is the call graph for this function:

euklidDistance() [2/2]

template<typename T >

T olb::util::euklidDistance	(	const T	x[],
		const T	y[],
		int	dim )

Euclidean distance between two arrays.

Definition at line 67 of file norm.h.

{
  return olb::util::sqrt(euklidDistance2(x,y,dim));
}

References euklidDistance2(), and sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

euklidDistance2() [1/2]

template<typename C >

auto olb::util::euklidDistance2	(	const C &	x,
		const C &	y )

Squared Euclidean distance for Container-type array.

Definition at line 82 of file norm.h.

{
  OLB_ASSERT((x.size() == y.size()), "Arrays must have same dimension");
  return euklidDistance2(x.data(), y.data(), x.size());
}

References euklidDistance2(), and OLB_ASSERT.

Here is the call graph for this function:

euklidDistance2() [2/2]

template<typename T >

T olb::util::euklidDistance2	(	const T	x[],
		const T	y[],
		int	dim )

Squared Euclidean distance between two arrays.

Definition at line 48 of file norm.h.

{
  T euklid = 0;
  for (int iDim=0; iDim<dim; iDim++) {
    euklid += (x[iDim]-y[iDim])*(x[iDim]-y[iDim]);
  }
  return euklid;
}

Here is the caller graph for this function:

euklidN() [1/2]

template<typename C >

auto olb::util::euklidN

(

const C &

x

)

Euclidean norm for Container-type array.

Definition at line 90 of file norm.h.

{
  return euklidN(x.data(), x.size());
}

References euklidN().

Here is the call graph for this function:

euklidN() [2/2]

template<typename T >

T olb::util::euklidN	(	const T	x[],
		int	dim )

Euclidean norm of an array.

Definition at line 60 of file norm.h.

{
  return olb::util::sqrt(euklidN2(x,dim));
}

References euklidN2(), and sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

euklidN2() [1/2]

template<typename C >

auto olb::util::euklidN2

(

const C &

x

)

Squared Euclidean norm for Container-type array.

Definition at line 75 of file norm.h.

{
  return euklidN2(x.data(), x.size());
}

References euklidN2().

Here is the call graph for this function:

euklidN2() [2/2]

template<typename T >

T olb::util::euklidN2	(	const T	x[],
		int	dim )

Squared Euclidean norm of an array.

Definition at line 37 of file norm.h.

{
  T euklid = 0;
  for (int iDim=0; iDim<dim; iDim++) {
    euklid += x[iDim]*x[iDim];
  }
  return euklid;
}

Here is the caller graph for this function:

evaluateIntegration()

template<typename T >

int olb::util::evaluateIntegration	(	std::vector< T > &	testValues,
		bool	print = false )

Definition at line 34 of file integrationTestUtils.h.

                                                                     {
  OstreamManager clout( std::cout,"Integrationtest" );
  bool allPassed = true;
  for (int i=0; i<testValues.size(); i+=3){
    T val = testValues[i];
    T ref = testValues[i+1];
    T maxErr = testValues[i+2];
    T err = std::abs(ref-val)/ref;
    bool passed = err <= maxErr;
    if (print || !passed ){
      clout << std::setprecision(16);
      clout << "i:|"     << "Value:                 |"
                         << "Reference:             |"
                         << "Error:                 |"
                         << "MaxError:              |"
                         << "Passed:" <<  std::endl;
      clout << i << " |" << std::setw(22) << val
                 << " |" << std::setw(22) << ref
                 << " |" << std::setw(22) << err
                 << " |" << std::setw(22) << maxErr
                 << " |" << passed << std::endl;
      clout << std::setprecision(6);
    }
    if (!passed){ allPassed=false; };
  }
  if (allPassed){
    return 0;
  } else {
    return 1;
  }
}

References print().

Here is the call graph for this function:

executeRotation()

template<typename T , unsigned D, bool OUTPUT_USES_ROTATION_CENTER_AS_ORIGIN = false>

Vector< T, D > olb::util::executeRotation	(	const Vector< T, D > &	input,
		const Vector< T, utilities::dimensions::convert< D >::matrix > &	rotationMatrix,
		const Vector< T, D > &	rotationCenter = Vector<T, D>(0.) )

Rotates the input around the rotationCenter with a given rotationMatrix.

Definition at line 146 of file geometricOperations.h.

{
  const Vector<T, D> dist = input - rotationCenter;
  Vector<T, D>       rotated;
 
  if constexpr (D == 2) {
    rotated =
        Vector<T, 2>(dist[0] * rotationMatrix[0] + dist[1] * rotationMatrix[1],
                     dist[0] * rotationMatrix[2] + dist[1] * rotationMatrix[3]);
  }
  else {
    rotated =
        Vector<T, 3>(rotationMatrix[0] * dist[0] + rotationMatrix[1] * dist[1] +
                         rotationMatrix[2] * dist[2],
                     rotationMatrix[3] * dist[0] + rotationMatrix[4] * dist[1] +
                         rotationMatrix[5] * dist[2],
                     rotationMatrix[6] * dist[0] + rotationMatrix[7] * dist[1] +
                         rotationMatrix[8] * dist[2]);
  }
 
  if constexpr (!OUTPUT_USES_ROTATION_CENTER_AS_ORIGIN) {
    return rotationCenter + rotated;
  }
  else {
    return rotated;
  }
 
  __builtin_unreachable();
}

Here is the caller graph for this function:

exp() [1/4]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::exp ( const ADf< T, DIM > & a )

inline

Definition at line 455 of file aDiff.h.

{
  ADf<T,DIM> c(std::exp(a._v), a._d);
  c._d*=c._v;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

exp() [2/4]

Expr olb::util::exp

(

Expr

x

)

Definition at line 192 of file expr.h.

                 {
  return Expr(Expr::Op::Exp, x);
}

References olb::Expr::Exp.

exp() [3/4]

template<typename T >

std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::exp ( T arg )

inline

Definition at line 111 of file omath.h.

{
  return std::exp(arg);
}

exp() [4/4]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::exp ( T arg )

inline

Definition at line 117 of file omath.h.

{
  return std::exp(arg);
}

expf() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::expf ( const ADf< float, DIM > & a )

inline

Definition at line 463 of file aDiff.h.

{
  return exp(a);
}

References exp().

Here is the call graph for this function:

expf() [2/2]

float olb::util::expf ( float arg )

inline

Definition at line 122 of file omath.h.

{
  return exp(arg);
}

References exp().

Here is the call graph for this function:

expl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::expl ( const ADf< long double, DIM > & a )

inline

Definition at line 469 of file aDiff.h.

{
  return exp(a);
}

References exp().

Here is the call graph for this function:

expl() [2/2]

long double olb::util::expl ( long double arg )

inline

Definition at line 127 of file omath.h.

{
  return exp(arg);
}

References exp().

Here is the call graph for this function:

fabs() [1/6]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::fabs ( const ADf< T, DIM > & a )

inline

Definition at line 996 of file aDiff.h.

{
#ifdef AdWarnings
  if (a._v == T(0)) {
    std::cout << "ADf WARNING: fabs(Adf) - fabs evaluated at non-differentiable point" << std::endl;
  }
#endif
  return ADf<T,DIM>( util::sign(a._v) * a );
}

References olb::util::ADf< T, DIM >::_v, and sign().

Here is the call graph for this function:

fabs() [2/6]

template<typename T >

cpu::simd::Pack< T > olb::util::fabs

(

cpu::simd::Pack< T >

value

)

Definition at line 106 of file pack.h.

{
  return cpu::simd::fabs(value);
}

References olb::cpu::simd::fabs().

Here is the call graph for this function:

Here is the caller graph for this function:

fabs() [3/6]

Expr olb::util::fabs

(

Expr

x

)

Definition at line 184 of file expr.h.

                  {
  return Expr(Expr::Op::Abs, x);
}

References olb::Expr::Abs.

fabs() [4/6]

long double olb::util::fabs ( long double arg )

inline

Definition at line 925 of file omath.h.

{
  return std::fabs(arg);
}

fabs() [5/6]

template<typename T >

std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::fabs ( T arg )

inline

Definition at line 891 of file omath.h.

{
#ifdef  __CUDA_ARCH__
  return ::fabs(arg);
#else
  return std::fabs(arg);
#endif
}

fabs() [6/6]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::fabs ( T arg )

inline

Definition at line 901 of file omath.h.

{
#ifdef  __CUDA_ARCH__
  return ::fabs(arg);
#else
  return std::fabs(arg);
#endif
}

fabsf() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::fabsf ( const ADf< float, DIM > & a )

inline

Definition at line 1007 of file aDiff.h.

{
  return fabs(a);
}

References fabs().

Here is the call graph for this function:

Here is the caller graph for this function:

fabsf() [2/2]

float olb::util::fabsf ( float arg )

inline

Definition at line 920 of file omath.h.

{
  return fabs(arg);
}

References fabs().

Here is the call graph for this function:

fabsl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::fabsl ( const ADf< long double, DIM > & a )

inline

Definition at line 1013 of file aDiff.h.

{
  return fabs(a);
}

References fabs().

Here is the call graph for this function:

Here is the caller graph for this function:

fabsl() [2/2]

long double olb::util::fabsl ( long double arg )

inline

Definition at line 930 of file omath.h.

{
  return fabs(arg);
}

References fabs().

Here is the call graph for this function:

findVelocity()

template<typename DESCRIPTORBASE >

int olb::util::findVelocity

(

const int

v[DESCRIPTORBASE::d]

)

Definition at line 237 of file util.h.

{
  for (int iPop=0; iPop<DESCRIPTORBASE::q; ++iPop) {
    bool fit = true;
    for (int iD=0; iD<DESCRIPTORBASE::d; ++iD) {
      if (descriptors::c<DESCRIPTORBASE>(iPop,iD) != v[iD]) {
        fit = false;
        break;
      }
    }
    if (fit) {
      return iPop;
    }
  }
  return DESCRIPTORBASE::q;
}

floor() [1/6]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::floor ( const ADf< T, DIM > & a )

inline

Definition at line 869 of file aDiff.h.

{
  ADf<T,DIM> c;
  if (a._v == std::floor(a._v)) {
    c._v = a._v;
#ifdef AdWarnings
    std::cout << "ADf WARNING: floor(Adf) - floor evaluated at non-differentiable point" << std::endl;
#endif
    for (unsigned i = 0; i < DIM; ++i) {
      c._d[i] = (a.d(i) == 0) ? T(0) : std::numeric_limits<T>::quiet_NaN();
    }
    return c;
  }
  c._v = std::floor(a._v);
  c._d = ( T(0) );
  return c;
}

References olb::util::ADf< T, DIM >::_v, and olb::util::ADf< T, DIM >::d().

Here is the call graph for this function:

Here is the caller graph for this function:

floor() [2/6]

template<typename T , unsigned Size>

Vector< T, Size > olb::util::floor

(

const Vector< T, Size > &

a

)

applies floor to each component of a vector

Definition at line 213 of file vectorHelpers.h.

{
  Vector<T,Size> out;
  for (unsigned int iDim=0; iDim < Size; ++iDim) {
    out[iDim] = util::floor(a[iDim]);
  }
  return out;
}

References floor().

Here is the call graph for this function:

floor() [3/6]

double olb::util::floor ( double arg )

inline

Definition at line 719 of file omath.h.

{
  return std::floor(arg);
}

floor() [4/6]

float olb::util::floor ( float arg )

inline

Definition at line 714 of file omath.h.

{
  return std::floor(arg);
}

floor() [5/6]

long double olb::util::floor ( long double arg )

inline

Definition at line 724 of file omath.h.

{
  return std::floor(arg);
}

floor() [6/6]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::floor ( T arg )

inline

Definition at line 740 of file omath.h.

{
  return std::floor(arg);
}

floorf() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::floorf ( const ADf< float, DIM > & a )

inline

Definition at line 888 of file aDiff.h.

{
  return floor(a);
}

References floor().

Here is the call graph for this function:

floorf() [2/2]

float olb::util::floorf ( float arg )

inline

Definition at line 729 of file omath.h.

{
  return floor(arg);
}

References floor().

Here is the call graph for this function:

floorl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::floorl ( const ADf< long double, DIM > & a )

inline

Definition at line 894 of file aDiff.h.

{
  return floor(a);
}

References floor().

Here is the call graph for this function:

floorl() [2/2]

long double olb::util::floorl ( long double arg )

inline

Definition at line 734 of file omath.h.

{
  return floor(arg);
}

References floor().

Here is the call graph for this function:

fmod() [1/11]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::fmod ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inline

Definition at line 703 of file aDiff.h.

{
  const T k = std::floor(T(a) / T(b));
  return ADf<T,DIM>(a - k * b);
}

Here is the caller graph for this function:

fmod() [2/11]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::fmod ( const ADf< T, DIM > & a, const U & b )

inline

Definition at line 710 of file aDiff.h.

{
  return fmod(a, ADf<T,DIM>(b));
}

References fmod().

Here is the call graph for this function:

fmod() [3/11]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::fmod ( const U & a, const ADf< T, DIM > & b )

inline

Definition at line 716 of file aDiff.h.

{
  return fmod( ADf<T,DIM>(a),b);
}

References fmod().

Here is the call graph for this function:

fmod() [4/11]

template<typename T , typename S , unsigned Size>

Vector< T, Size > olb::util::fmod	(	const Vector< T, Size > &	a,
		S	b )

applies fmod to each component of a vector

Definition at line 235 of file vectorHelpers.h.

{
  Vector<T,Size> out;
  for (unsigned int iDim=0; iDim < Size; ++iDim) {
    out[iDim] = util::fmod(a[iDim], b);
  }
  return out;
}

References fmod().

Here is the call graph for this function:

fmod() [5/11]

double olb::util::fmod ( double x, double y )

inline

Definition at line 72 of file omath.h.

{
  return std::fmod(x, y);
}

fmod() [6/11]

double olb::util::fmod ( double x, int y )

inline

Definition at line 92 of file omath.h.

{
  return std::fmod(x, y);
}

fmod() [7/11]

float olb::util::fmod ( float x, float y )

inline

Definition at line 62 of file omath.h.

{
  return std::fmod(x, y);
}

fmod() [8/11]

float olb::util::fmod ( float x, int y )

inline

Definition at line 87 of file omath.h.

{
  return std::fmod(x, y);
}

fmod() [9/11]

long double olb::util::fmod ( long double x, int y )

inline

Definition at line 97 of file omath.h.

{
  return std::fmod(x, y);
}

fmod() [10/11]

long double olb::util::fmod ( long double x, long double y )

inline

Definition at line 77 of file omath.h.

{
  return std::fmod(x, y);
}

fmod() [11/11]

template<typename T , typename S >

auto olb::util::fmod ( T x, S y )

inline

Definition at line 103 of file omath.h.

{
  return std::fmod(x, y);
}

fmod_pos()

template<typename T , typename S >

auto olb::util::fmod_pos ( T a, S b )

inline

Variant of fmod (floating point modulo) that always returns positive values.

Definition at line 39 of file calc.h.

                               {
  const auto res = util::fmod(a, b);
  if (res < 0) {
    return (res + b);
  } else {
    return res;
  }
}

References fmod().

Here is the call graph for this function:

Here is the caller graph for this function:

fmodf()

float olb::util::fmodf ( float x, float y )

inline

Definition at line 67 of file omath.h.

{
  return fmod(x, y);
}

References fmod().

Here is the call graph for this function:

fmodl()

long double olb::util::fmodl ( long double x, long double y )

inline

Definition at line 82 of file omath.h.

{
  return fmod(x, y);
}

References fmod().

Here is the call graph for this function:

fromVector2()

template<typename T >

std::vector< T > olb::util::fromVector2

(

const Vector< T, 2 > &

vec

)

Definition at line 135 of file vectorHelpers.h.

{
  std::vector<T> v;
  v.push_back(vec[0]);
  v.push_back(vec[1]);
  return v;
}

fromVector3()

template<typename T >

std::vector< T > olb::util::fromVector3

(

const Vector< T, 3 > &

vec

)

Definition at line 126 of file vectorHelpers.h.

{
  std::vector<T> v;
  v.push_back(vec[0]);
  v.push_back(vec[1]);
  v.push_back(vec[2]);
  return v;
}

Here is the caller graph for this function:

get_nearest_link()

template<typename T , typename DESCRIPTOR >

int olb::util::get_nearest_link

(

const std::vector< T > &

vec

)

Util Function for Wall Model of Malaspinas get link with smallest angle to a vector.

Definition at line 354 of file util.h.

{
  T max=-1;
  int max_index = 0;
  for (int iQ=1; iQ<DESCRIPTOR::q; ++iQ) {
    std::vector<T> c_i(DESCRIPTOR::c[iQ], DESCRIPTOR::c[iQ]+3);
    T tmp = util::scalarProduct<T>(c_i, vec)/util::norm(c_i);
    if (tmp > max) {
      max = tmp;
      max_index = iQ;
    }
  }
  return max_index;
}

References max(), and norm().

Here is the call graph for this function:

iniAD() [1/3]

template<unsigned n, typename S , template< typename > typename C>

C< ADf< S, n > > olb::util::iniAD

(

const C< S > &

source

)

copy values and initialize derivatives

Definition at line 101 of file adHelpers.h.

                                      {
  auto result = copyAs<ADf<S,n>,S,C> (source);
  util::iniDiagonal (result);
  return result;
}

References iniDiagonal().

Here is the call graph for this function:

iniAD() [2/3]

template<unsigned n, typename S >

ADf< S, n > * olb::util::iniAD

(

const S *

source

)

copy array values and initialize derivatives

Definition at line 92 of file adHelpers.h.

                                 {
  ADf<S,n>* result = new ADf<S,n>[n];
  util::copyN (result, source, n);
  util::iniDiagonal (result, n);
  return result;
}

References copyN(), and iniDiagonal().

Here is the call graph for this function:

iniAD() [3/3]

template<typename S >

ADf< S, 1 > olb::util::iniAD

(

const S

source

)

copy value and initialize derivative

Definition at line 84 of file adHelpers.h.

                               {
  ADf<S,1> result(source);
  result.setDiffVariable(0);
  return result;
}

References olb::util::ADf< T, DIM >::setDiffVariable().

Here is the call graph for this function:

iniDiagonal() [1/2]

template<typename C >

void olb::util::iniDiagonal

(

C &

a

)

Definition at line 49 of file adHelpers.h.

                       {
  for (unsigned i = 0; i < a.size(); ++i) {
    a[i].setDiffVariable(i);
  }
}

iniDiagonal() [2/2]

template<typename SAD >

void olb::util::iniDiagonal	(	SAD *	a,
		int	dim )

The variables of an array are set to be the differential variables.

--> d/di a_j = 1 if (i==j) else 0.

Definition at line 42 of file adHelpers.h.

                                  {
  for (int i = 0; i < dim; ++i) {
    a[i].setDiffVariable(i);
  }
}

Here is the caller graph for this function:

intersect() [1/2]

bool olb::util::intersect ( int x0, int x1, int y0, int y1, int x0_, int x1_, int y0_, int y1_, int & newX0, int & newX1, int & newY0, int & newY1 )

inline

Definition at line 89 of file util.h.

{
  newX0 = util::max(x0,x0_);
  newY0 = util::max(y0,y0_);
 
  newX1 = util::min(x1,x1_);
  newY1 = util::min(y1,y1_);
 
  return newX1>=newX0 && newY1>=newY0;
}

References max(), and min().

Here is the call graph for this function:

Here is the caller graph for this function:

intersect() [2/2]

bool olb::util::intersect ( int x0, int x1, int y0, int y1, int z0, int z1, int x0_, int x1_, int y0_, int y1_, int z0_, int z1_, int & newX0, int & newX1, int & newY0, int & newY1, int & newZ0, int & newZ1 )

inline

Definition at line 103 of file util.h.

{
  newX0 = util::max(x0,x0_);
  newY0 = util::max(y0,y0_);
  newZ0 = util::max(z0,z0_);
 
  newX1 = util::min(x1,x1_);
  newY1 = util::min(y1,y1_);
  newZ1 = util::min(z1,z1_);
 
  return newX1>=newX0 && newY1>=newY0 && newZ1>=newZ0;
}

References max(), and min().

Here is the call graph for this function:

invertRotation()

template<typename T , unsigned D, bool OUTPUT_USES_ROTATION_CENTER_AS_ORIGIN = false>

Vector< T, D > olb::util::invertRotation	(	const Vector< T, D > &	input,
		const Vector< T, utilities::dimensions::convert< D >::matrix > &	rotationMatrix,
		const Vector< T, D > &	rotationCenter = Vector<T, D>(0.) )

Rotates the input around the rotationCenter with a given rotationMatrix in the opposite direction.

Definition at line 182 of file geometricOperations.h.

{
  const Vector<T, utilities::dimensions::convert<D>::matrix> invRotationMatrix =
      invertRotationMatrix<T, D>(rotationMatrix);
  return executeRotation(input, invRotationMatrix, rotationCenter);
}

References executeRotation().

Here is the call graph for this function:

invertRotationMatrix()

template<typename T , unsigned D>

Vector< T, utilities::dimensions::convert< D >::matrix > olb::util::invertRotationMatrix

(

const Vector< T, utilities::dimensions::convert< D >::matrix > &

rotationMatrix

)

Definition at line 113 of file geometricOperations.h.

{
  if constexpr (D == 2) {
    return Vector<T, 4>(rotationMatrix[0], rotationMatrix[2], rotationMatrix[1],
                        rotationMatrix[3]);
  }
  else {
 
    //Individual Entries ( source: https://doi.org/10.1016/j.compfluid.2018.02.027 )
    // |x0| / 0 3 6 \   |x1|
    // |y0| | 1 4 7 | = |x1|
    // |z0| \ 2 5 8 /   |x1|
 
    return Vector<T, 9>(rotationMatrix[0], rotationMatrix[3], rotationMatrix[6],
                        rotationMatrix[1], rotationMatrix[4], rotationMatrix[7],
                        rotationMatrix[2], rotationMatrix[5],
                        rotationMatrix[8]);
  }
  __builtin_unreachable();
}

isContained()

template<typename C , typename U >

bool olb::util::isContained	(	const C &	c,
		U	object )

Check, if object is contained in iteratable container c.

Definition at line 435 of file vectorHelpers.h.

                                       {
  return (std::find(c.begin(), c.end(), object) != c.end());
}

Here is the caller graph for this function:

labs() [1/2]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::labs ( const ADf< T, DIM > & a )

inline

Definition at line 1025 of file aDiff.h.

{
#ifdef AdWarnings
  std::cout << "ADf WARNING: ADf is not supporting integer types. Using abs() instead." << std::endl;
#endif
  return abs(a);
}

References abs().

Here is the call graph for this function:

Here is the caller graph for this function:

labs() [2/2]

long olb::util::labs ( long arg )

inline

Definition at line 910 of file omath.h.

{
  return abs(arg);
}

References abs().

Here is the call graph for this function:

llabs() [1/2]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::llabs ( const ADf< T, DIM > & a )

inline

Definition at line 1034 of file aDiff.h.

{
  return labs(a);
}

References labs().

Here is the call graph for this function:

llabs() [2/2]

long long olb::util::llabs ( long long arg )

inline

Definition at line 915 of file omath.h.

{
  return abs(arg);
}

References abs().

Here is the call graph for this function:

llround() [1/2]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::llround ( const ADf< T, DIM > & a )

inline

Definition at line 978 of file aDiff.h.

{
  return lround(a);
}

References lround().

Here is the call graph for this function:

Here is the caller graph for this function:

llround() [2/2]

template<typename T >

std::enable_if_t< std::is_arithmetic_v< T >, long long > olb::util::llround ( T arg )

inline

Definition at line 863 of file omath.h.

{
  return std::llround(arg);
}

llroundf() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::llroundf ( const ADf< float, DIM > & a )

inline

Definition at line 984 of file aDiff.h.

{
  return llround(a);
}

References llround().

Here is the call graph for this function:

llroundf() [2/2]

long long olb::util::llroundf ( float arg )

inline

Definition at line 868 of file omath.h.

{
  return llround(arg);
}

References llround().

Here is the call graph for this function:

llroundl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::llroundl ( const ADf< long double, DIM > & a )

inline

Definition at line 990 of file aDiff.h.

{
  return llround(a);
}

References llround().

Here is the call graph for this function:

llroundl() [2/2]

long long olb::util::llroundl ( long double arg )

inline

Definition at line 873 of file omath.h.

{
  return llround(arg);
}

References llround().

Here is the call graph for this function:

log() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::log ( const ADf< T, DIM > & a )

inline

Definition at line 475 of file aDiff.h.

{
  ADf<T,DIM> c(std::log(a._v), a._d);
  T tmp (T(1)/a._v);
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

log() [2/5]

double olb::util::log ( double arg )

inline

Definition at line 143 of file omath.h.

{
  return std::log(arg);
}

log() [3/5]

float olb::util::log ( float arg )

inline

Definition at line 133 of file omath.h.

{
  return std::log(arg);
}

log() [4/5]

long double olb::util::log ( long double arg )

inline

Definition at line 148 of file omath.h.

{
  return std::log(arg);
}

log() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::log ( T arg )

inline

Definition at line 159 of file omath.h.

{
  return std::log(arg);
}

log10() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::log10 ( const ADf< T, DIM > & a )

inline

Definition at line 496 of file aDiff.h.

{
  ADf<T,DIM> c(std::log10(a._v), a._d);
  T tmp (T(1)/(a._v*std::log(T(10))));
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

log10() [2/5]

double olb::util::log10 ( double arg )

inline

Definition at line 175 of file omath.h.

{
  return std::log10(arg);
}

log10() [3/5]

float olb::util::log10 ( float arg )

inline

Definition at line 165 of file omath.h.

{
  return std::log10(arg);
}

log10() [4/5]

long double olb::util::log10 ( long double arg )

inline

Definition at line 180 of file omath.h.

{
  return std::log10(arg);
}

log10() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::log10 ( T arg )

inline

Definition at line 191 of file omath.h.

{
  return std::log10(arg);
}

log10f() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::log10f ( const ADf< float, DIM > & a )

inline

Definition at line 505 of file aDiff.h.

{
  return log10(a);
}

References log10().

Here is the call graph for this function:

log10f() [2/2]

float olb::util::log10f ( float arg )

inline

Definition at line 170 of file omath.h.

{
  return log10(arg);
}

References log10().

Here is the call graph for this function:

log10l() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::log10l ( const ADf< long double, DIM > & a )

inline

Definition at line 511 of file aDiff.h.

{
  return log10(a);
}

References log10().

Here is the call graph for this function:

log10l() [2/2]

long double olb::util::log10l ( long double arg )

inline

Definition at line 185 of file omath.h.

{
  return log10(arg);
}

References log10().

Here is the call graph for this function:

log1p() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::log1p ( const ADf< T, DIM > & a )

inline

Definition at line 538 of file aDiff.h.

{
  return log(a+T(1));
}

References log().

Here is the call graph for this function:

Here is the caller graph for this function:

log1p() [2/5]

double olb::util::log1p ( double arg )

inline

Definition at line 239 of file omath.h.

{
  return std::log1p(arg);
}

log1p() [3/5]

float olb::util::log1p ( float arg )

inline

Definition at line 229 of file omath.h.

{
  return std::log1p(arg);
}

log1p() [4/5]

long double olb::util::log1p ( long double arg )

inline

Definition at line 244 of file omath.h.

{
  return std::log1p(arg);
}

log1p() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::log1p ( T arg )

inline

Definition at line 255 of file omath.h.

{
  return std::log1p(arg);
}

log1pf() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::log1pf ( const ADf< float, DIM > & a )

inline

Definition at line 544 of file aDiff.h.

{
  return log1p(a);
}

References log1p().

Here is the call graph for this function:

log1pf() [2/2]

float olb::util::log1pf ( float arg )

inline

Definition at line 234 of file omath.h.

{
  return log1p(arg);
}

References log1p().

Here is the call graph for this function:

log1pl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::log1pl ( const ADf< long double, DIM > & a )

inline

Definition at line 550 of file aDiff.h.

{
  return log1p(a);
}

References log1p().

Here is the call graph for this function:

log1pl() [2/2]

long double olb::util::log1pl ( long double arg )

inline

Definition at line 249 of file omath.h.

{
  return log1p(arg);
}

References log1p().

Here is the call graph for this function:

log2() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::log2 ( const ADf< T, DIM > & a )

inline

Definition at line 517 of file aDiff.h.

{
  ADf<T,DIM> c(std::log2(a._v), a._d);
  T tmp (T(1)/(a._v*std::log(T(2))));
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

log2() [2/5]

double olb::util::log2 ( double arg )

inline

Definition at line 207 of file omath.h.

{
  return std::log2(arg);
}

log2() [3/5]

float olb::util::log2 ( float arg )

inline

Definition at line 197 of file omath.h.

{
  return std::log2(arg);
}

log2() [4/5]

long double olb::util::log2 ( long double arg )

inline

Definition at line 212 of file omath.h.

{
  return std::log2(arg);
}

log2() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::log2 ( T arg )

inline

Definition at line 223 of file omath.h.

{
  return std::log2(arg);
}

log2f() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::log2f ( const ADf< float, DIM > & a )

inline

Definition at line 526 of file aDiff.h.

{
  return log2(a);
}

References log2().

Here is the call graph for this function:

log2f() [2/2]

float olb::util::log2f ( float arg )

inline

Definition at line 202 of file omath.h.

{
  return log2(arg);
}

References log2().

Here is the call graph for this function:

log2l() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::log2l ( const ADf< long double, DIM > & a )

inline

Definition at line 532 of file aDiff.h.

{
  return log2(a);
}

References log2().

Here is the call graph for this function:

log2l() [2/2]

long double olb::util::log2l ( long double arg )

inline

Definition at line 217 of file omath.h.

{
  return log2(arg);
}

References log2().

Here is the call graph for this function:

logf() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::logf ( const ADf< float, DIM > & a )

inline

Definition at line 484 of file aDiff.h.

{
  return log(a);
}

References log().

Here is the call graph for this function:

logf() [2/2]

float olb::util::logf ( float arg )

inline

Definition at line 138 of file omath.h.

{
  return log(arg);
}

References log().

Here is the call graph for this function:

logl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::logl ( const ADf< long double, DIM > & a )

inline

Definition at line 490 of file aDiff.h.

{
  return log(a);
}

References log().

Here is the call graph for this function:

logl() [2/2]

long double olb::util::logl ( long double arg )

inline

Definition at line 153 of file omath.h.

{
  return log(arg);
}

References log().

Here is the call graph for this function:

lround() [1/2]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::lround ( const ADf< T, DIM > & a )

inline

Definition at line 957 of file aDiff.h.

{
#ifdef AdWarnings
  std::cout << "ADf WARNING: ADf does not support integer types. Using round() instead." << std::endl;
#endif
  return round(a);
}

References round().

Here is the call graph for this function:

Here is the caller graph for this function:

lround() [2/2]

template<typename T >

std::enable_if_t< std::is_arithmetic_v< T >, long > olb::util::lround ( T arg )

inline

Definition at line 847 of file omath.h.

{
  return std::lround(arg);
}

lroundf() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::lroundf ( const ADf< float, DIM > & a )

inline

Definition at line 966 of file aDiff.h.

{
  return lround(a);
}

References lround().

Here is the call graph for this function:

lroundf() [2/2]

long olb::util::lroundf ( float arg )

inline

Definition at line 852 of file omath.h.

{
  return lround(arg);
}

References lround().

Here is the call graph for this function:

lroundl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::lroundl ( const ADf< long double, DIM > & a )

inline

Definition at line 972 of file aDiff.h.

{
  return lround(a);
}

References lround().

Here is the call graph for this function:

lroundl() [2/2]

long olb::util::lroundl ( long double arg )

inline

Definition at line 857 of file omath.h.

{
  return lround(arg);
}

References lround().

Here is the call graph for this function:

max() [1/8]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::max ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 1056 of file aDiff.h.

{
  ADf<T,DIM> c((a + b + fabs(a - b) ) * T(0.5));
  return c;
}

References fabs().

Here is the call graph for this function:

max() [2/8]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::max ( const ADf< T, DIM > & a, const olb::BaseType< ADf< T, DIM > > & b )

inlineconstexpr

Definition at line 1048 of file aDiff.h.

{
  ADf<T,DIM> c(b);
  c = max(a, c);
  return c;
}

References max().

Here is the call graph for this function:

max() [3/8]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::max ( const olb::BaseType< ADf< T, DIM > > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 1040 of file aDiff.h.

{
  ADf<T,DIM> c(a);
  c = max(c, b);
  return c;
}

References max().

Here is the call graph for this function:

max() [4/8]

template<typename T >

cpu::simd::Pack< T > olb::util::max	(	cpu::simd::Pack< T >	rhs,
		cpu::simd::Pack< T >	lhs )

Definition at line 130 of file pack.h.

{
  return cpu::simd::max(rhs, lhs);
}

References olb::cpu::simd::max().

Here is the call graph for this function:

Here is the caller graph for this function:

max() [5/8]

template<typename T >

constexpr T olb::util::max ( std::initializer_list< T > ilist )

inlineconstexpr

Definition at line 47 of file oalgorithm.h.

{
  return std::max(ilist);
}

max() [6/8]

template<typename T , class Compare >

constexpr T olb::util::max ( std::initializer_list< T > ilist, Compare comp )

inlineconstexpr

Definition at line 52 of file oalgorithm.h.

{
  return std::max(ilist, comp);
}

max() [7/8]

template<typename T >

constexpr T olb::util::max ( T a, meta::id_t< T > b )

inlineconstexpr

Definition at line 37 of file oalgorithm.h.

{
  return std::max(a, b);
}

max() [8/8]

template<typename T , class Compare >

constexpr T olb::util::max ( T a, meta::id_t< T > b, Compare comp )

inlineconstexpr

Definition at line 42 of file oalgorithm.h.

{
  return std::max(a, b, comp);
}

max< double >()

template<>

double olb::util::max< double > ( double x, double y )

inline

Definition at line 64 of file oalgorithm.h.

{
  return std::fmax(x, y);
}

max< float >()

template<>

float olb::util::max< float > ( float x, float y )

inline

Definition at line 58 of file oalgorithm.h.

{
  return std::fmax(x, y);
}

max_element()

template<typename T , unsigned Size>

T olb::util::max_element

(

const Vector< T, Size > &

a

)

finds maximum element of all elements

Definition at line 257 of file vectorHelpers.h.

{
  T max = a[0];
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    max = std::max(max,a[iDim]);
  }
  return max;
}

References max().

Here is the call graph for this function:

Here is the caller graph for this function:

maxElementAbs()

template<typename T , unsigned Size>

T olb::util::maxElementAbs

(

const Vector< T, Size > &

a

)

finds maximum element of all absolute elements

Definition at line 305 of file vectorHelpers.h.

{
  T maxAbs = a[0];
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    if (abs(a[iDim])>abs(maxAbs)){
      maxAbs = a[iDim];
    }
  }
  return maxAbs;
}

References abs().

Here is the call graph for this function:

Here is the caller graph for this function:

maxElementAbsPos()

template<typename T , unsigned Size>

unsigned olb::util::maxElementAbsPos

(

const Vector< T, Size > &

a

)

finds position of maximum element of all absolute elements

Definition at line 318 of file vectorHelpers.h.

{
  unsigned maxAbsPos = 0;
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    if (abs(a[iDim])>abs(a[maxAbsPos])){
      maxAbsPos = iDim;
    }
  }
  return maxAbsPos;
}

References abs().

Here is the call graph for this function:

Here is the caller graph for this function:

maxElementPos()

template<typename T , unsigned Size>

unsigned olb::util::maxElementPos

(

const Vector< T, Size > &

a

)

finds position of maximum element of all elements

Definition at line 279 of file vectorHelpers.h.

{
  unsigned maxPos = 0;
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    if (a[iDim]>a[maxPos]){
      maxPos = iDim;
    }
  }
  return maxPos;
}

min() [1/8]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::min ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 1079 of file aDiff.h.

{
  ADf<T,DIM> c((a + b - fabs(a - b) ) * T(0.5));
  return c;
}

References fabs().

Here is the call graph for this function:

min() [2/8]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::min ( const ADf< T, DIM > & a, const olb::BaseType< ADf< T, DIM > > & b )

inlineconstexpr

Definition at line 1071 of file aDiff.h.

{
  ADf<T,DIM> c(b);
  c = min(a, c);
  return c;
}

References min().

Here is the call graph for this function:

min() [3/8]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::min ( const olb::BaseType< ADf< T, DIM > > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 1063 of file aDiff.h.

{
  ADf<T,DIM> c(a);
  c = min(c, b);
  return c;
}

References min().

Here is the call graph for this function:

min() [4/8]

template<typename T >

cpu::simd::Pack< T > olb::util::min	(	cpu::simd::Pack< T >	rhs,
		cpu::simd::Pack< T >	lhs )

Definition at line 124 of file pack.h.

{
  return cpu::simd::min(rhs, lhs);
}

References olb::cpu::simd::min().

Here is the call graph for this function:

Here is the caller graph for this function:

min() [5/8]

template<typename T >

constexpr T olb::util::min ( std::initializer_list< T > ilist )

inlineconstexpr

Definition at line 81 of file oalgorithm.h.

{
  return std::min(ilist);
}

min() [6/8]

template<typename T , class Compare >

constexpr T olb::util::min ( std::initializer_list< T > ilist, Compare comp )

inlineconstexpr

Definition at line 86 of file oalgorithm.h.

{
  return std::min(ilist, comp);
}

min() [7/8]

template<typename T >

constexpr T olb::util::min ( T a, meta::id_t< T > b )

inlineconstexpr

Definition at line 71 of file oalgorithm.h.

{
  return std::min(a, b);
}

min() [8/8]

template<typename T , class Compare >

constexpr T olb::util::min ( T a, meta::id_t< T > b, Compare comp )

inlineconstexpr

Definition at line 76 of file oalgorithm.h.

{
  return std::min(a, b, comp);
}

min< double >()

template<>

double olb::util::min< double > ( double x, double y )

inline

Definition at line 98 of file oalgorithm.h.

{
  return std::fmin(x, y);
}

min< float >()

template<>

float olb::util::min< float > ( float x, float y )

inline

Definition at line 92 of file oalgorithm.h.

{
  return std::fmin(x, y);
}

min_element()

template<typename T , unsigned Size>

T olb::util::min_element

(

const Vector< T, Size > &

a

)

finds minimum element of all elements

Definition at line 268 of file vectorHelpers.h.

{
  T min = a[0];
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    min = std::min(min,a[iDim]);
  }
  return min;
}

References min().

Here is the call graph for this function:

Here is the caller graph for this function:

minElementPos()

template<typename T , unsigned Size>

unsigned olb::util::minElementPos

(

const Vector< T, Size > &

a

)

finds position of minimum element of all elements

Definition at line 292 of file vectorHelpers.h.

{
  unsigned minPos = 0;
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    if (a[iDim]<a[minPos]){
      minPos = iDim;
    }
  }
  return minPos;
}

nearZero() [1/3]

template<class T , unsigned DIM>

bool olb::util::nearZero ( const ADf< T, DIM > & a )

inline

Definition at line 1087 of file aDiff.h.

{
  const T EPSILON = std::numeric_limits<T>::epsilon();
  if (a._v > -EPSILON && a._v < EPSILON) {
    return true;
  }
  else {
    return false;
  }
}

References olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

nearZero() [2/3]

template<typename T >

bool olb::util::nearZero ( T a )

inline

return true if a is close to zero

Definition at line 53 of file vectorHelpers.h.

{
  if (a==T()) {
    return true;
  }
  T EPSILON = std::numeric_limits<T>::epsilon();
  if (a > -EPSILON && a < EPSILON) {
    return true;
  }
  else {
    return false;
  }
}

nearZero() [3/3]

template<typename T >

bool olb::util::nearZero ( T a, T epsilon )

inline

Definition at line 68 of file vectorHelpers.h.

{
  if (a > -epsilon && a < epsilon) {
    return true;
  }
  else {
    return false;
  }
}

norm() [1/2]

template<unsigned D, typename ARRAY_LIKE >

auto olb::util::norm

(

const ARRAY_LIKE &

u

)

Definition at line 153 of file util.h.

{
  return sqrt(normSqr<ARRAY_LIKE,D>(u));
}

References sqrt().

Here is the call graph for this function:

norm() [2/2]

template<typename T >

T olb::util::norm

(

const std::vector< T > &

a

)

l2 norm of a vector of arbitrary length

Definition at line 146 of file vectorHelpers.h.

{
  T v(0);
  for (unsigned iD=0; iD<a.size(); iD++) {
    v += a[iD]*a[iD];
  }
  v = util::sqrt(v);
  return v;
}

References sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

norm2()

template<typename T >

T olb::util::norm2

(

const std::vector< T > &

a

)

l2 norm to the power of 2 of a vector of arbitrary length

Definition at line 158 of file vectorHelpers.h.

{
  T v = T();
  for (unsigned iD=0; iD<a.size(); iD++) {
    v += a[iD]*a[iD];
  }
  return v;
}

Here is the caller graph for this function:

normalize() [1/2]

template<typename T >

std::vector< T > olb::util::normalize

(

const std::vector< T > &

a

)

returns a normalized vector, works for arbitrary lengths

Definition at line 200 of file vectorHelpers.h.

{
  std::vector<T> out(a);
  T scale = norm(a);
  assert(scale>0);
  for (unsigned int iDim=0; iDim<a.size(); iDim++) {
    out[iDim] /= scale;
  }
  return out;
}

References norm().

Here is the call graph for this function:

normalize() [2/2]

template<typename T , unsigned D>

Vector< T, D > olb::util::normalize

(

const Vector< T, D > &

a

)

Definition at line 193 of file vectorHelpers.h.

{
  return a / norm(a);
}

References norm().

Here is the call graph for this function:

Here is the caller graph for this function:

normSqr() [1/4]

template<typename ARRAY_LIKE , unsigned D>

auto olb::util::normSqr

(

const ARRAY_LIKE &

u

)

Compute norm square of a d-dimensional vector.

Definition at line 143 of file util.h.

{
  auto uSqr = decltype(u[0]){};
  for (unsigned iD=0; iD < D; ++iD) {
    uSqr += u[iD]*u[iD];
  }
  return uSqr;
}

normSqr() [2/4]

template<typename T , unsigned D, typename IMPL >

T olb::util::normSqr

(

const ScalarVector< T, D, IMPL > &

u

)

Compute norm square of a d-dimensional vector.

Definition at line 177 of file util.h.

{
  T uSqr = T();
  for (unsigned iD=0; iD < D; ++iD) {
    uSqr += u[iD]*u[iD];
  }
  return uSqr;
}

normSqr() [3/4]

template<typename T , unsigned D>

T olb::util::normSqr

(

const T *

u

)

Definition at line 159 of file util.h.

{
  auto uSqr = T{};
  for (unsigned iD=0; iD < D; ++iD) {
    uSqr += u[iD]*u[iD];
  }
  return uSqr;
}

normSqr() [4/4]

template<typename T >

T olb::util::normSqr

(

std::initializer_list< T >

data

)

Definition at line 169 of file util.h.

{
  return std::inner_product(data.begin(), data.end(), data.begin(), T(0));
}

operator!=() [1/3]

template<class T , unsigned DIM>

constexpr bool olb::util::operator!= ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 762 of file aDiff.h.

{
  return a._v!=b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator!=() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator!= ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 768 of file aDiff.h.

{
  return a._v!=olb::BaseType<ADf<T,DIM>>(b);
}

References olb::util::ADf< T, DIM >::_v.

operator!=() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator!= ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 774 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)!=b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator*() [1/3]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::operator* ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 349 of file aDiff.h.

{
  return ADf<T,DIM>(a) *= b;
}

operator*() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr ADf< T, DIM > olb::util::operator* ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 343 of file aDiff.h.

{
  return ADf<T,DIM>(a) *= olb::BaseType<ADf<T,DIM>>(b);
}

operator*() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr ADf< T, DIM > olb::util::operator* ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 337 of file aDiff.h.

{
  return ADf<T,DIM>(b) *= olb::BaseType<ADf<T,DIM>>(a);
}

operator+() [1/4]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::operator+ ( const ADf< T, DIM > & a )

inlineconstexpr

Definition at line 375 of file aDiff.h.

{
  return ADf<T,DIM>(a);
}

operator+() [2/4]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::operator+ ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 313 of file aDiff.h.

{
  return ADf<T,DIM>(a) += b;
}

operator+() [3/4]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr ADf< T, DIM > olb::util::operator+ ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 307 of file aDiff.h.

{
  return ADf<T,DIM>(a) += olb::BaseType<ADf<T,DIM>>(b);
}

operator+() [4/4]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr ADf< T, DIM > olb::util::operator+ ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 301 of file aDiff.h.

{
  return ADf<T,DIM>(b) += olb::BaseType<ADf<T,DIM>>(a);
}

operator-() [1/4]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::operator- ( const ADf< T, DIM > & a )

inlineconstexpr

Definition at line 381 of file aDiff.h.

{
  return ADf<T,DIM>(a) *= -1;
}

operator-() [2/4]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::operator- ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 331 of file aDiff.h.

{
  return ADf<T,DIM>(a)-=b;
}

operator-() [3/4]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr ADf< T, DIM > olb::util::operator- ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 325 of file aDiff.h.

{
  return ADf<T,DIM>(a) -= olb::BaseType<ADf<T,DIM>>(b);
}

operator-() [4/4]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr ADf< T, DIM > olb::util::operator- ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 319 of file aDiff.h.

{
  return ADf<T,DIM>(-ADf<T,DIM>(b) + olb::BaseType<ADf<T,DIM>>(a));
}

operator/() [1/3]

template<class T , unsigned DIM>

constexpr ADf< T, DIM > olb::util::operator/ ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 368 of file aDiff.h.

{
  return ADf<T,DIM>(a) /= b;
}

operator/() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr ADf< T, DIM > olb::util::operator/ ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 361 of file aDiff.h.

{
  return ADf<T,DIM>(a) /= olb::BaseType<ADf<T,DIM>>(b);
}

operator/() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr ADf< T, DIM > olb::util::operator/ ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 355 of file aDiff.h.

{
  return ADf<T,DIM>(a) /= b;
}

operator<() [1/3]

template<class T , unsigned DIM>

constexpr bool olb::util::operator< ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 818 of file aDiff.h.

{
  return a._v<b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator<() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator< ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 824 of file aDiff.h.

{
  return a._v<olb::BaseType<ADf<T,DIM>>(b);
}

References olb::util::ADf< T, DIM >::_v.

operator<() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator< ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 830 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)<b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator<<()

template<class T , unsigned DIM>

std::ostream & olb::util::operator<< ( std::ostream & os, const ADf< T, DIM > & o )

inline

Definition at line 277 of file aDiff.h.

{
  os << o._v;
  if constexpr (DIM>0) {
    os << o._d;
  }
  return os;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

operator<=() [1/3]

template<class T , unsigned DIM>

constexpr bool olb::util::operator<= ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 836 of file aDiff.h.

{
  return a._v<=b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator<=() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator<= ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 842 of file aDiff.h.

{
  return a._v<=olb::BaseType<ADf<T,DIM>>(b);
}

References olb::util::ADf< T, DIM >::_v.

operator<=() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator<= ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 848 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)<=b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator==() [1/3]

template<class T , unsigned DIM>

constexpr bool olb::util::operator== ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 744 of file aDiff.h.

{
  return a._v==b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator==() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator== ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 750 of file aDiff.h.

{
  return a._v==olb::BaseType<ADf<T,DIM>>(b);
}

References olb::util::ADf< T, DIM >::_v.

operator==() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator== ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 756 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)==b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator>() [1/3]

template<class T , unsigned DIM>

constexpr bool olb::util::operator> ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 781 of file aDiff.h.

{
  return a._v>b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator>() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator> ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 787 of file aDiff.h.

{
  return a._v>olb::BaseType<ADf<T,DIM>>(b);
}

References olb::util::ADf< T, DIM >::_v.

operator>() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator> ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 793 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)>b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator>=() [1/3]

template<class T , unsigned DIM>

constexpr bool olb::util::operator>= ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 799 of file aDiff.h.

{
  return a._v>=b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator>=() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator>= ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 805 of file aDiff.h.

{
  return a._v>=olb::BaseType<ADf<T,DIM>>(b);
}

References olb::util::ADf< T, DIM >::_v.

operator>=() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

constexpr bool olb::util::operator>= ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 811 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)>=b._v;
}

References olb::util::ADf< T, DIM >::_v.

operator>>()

template<class T , unsigned DIM>

std::istream & olb::util::operator>> ( std::istream & is, ADf< T, DIM > & in )

inline

Definition at line 288 of file aDiff.h.

{
  is >> in._v;
  in._d = T{0};
  return is;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

populationsContributingToDirection()

template<typename DESCRIPTOR , int... NORMAL>

constexpr auto olb::util::populationsContributingToDirection ( )

constexpr

Return array of population indices where c[iPop][iD] == NORMAL[iD].

Definition at line 226 of file util.h.

                                                                 {
  constexpr auto velocity_matches_direction = [](unsigned iPop) -> bool {
    return meta::indexed_pack_contains<NORMAL...>([iPop](unsigned iD, int x) -> bool {
      return x != 0 && x == descriptors::c<DESCRIPTOR>(iPop,iD);
    });
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches_direction));
};

References olb::meta::array_from_index_sequence(), and olb::meta::indexed_pack_contains().

Here is the call graph for this function:

Here is the caller graph for this function:

populationsContributingToVelocity()

template<typename DESCRIPTOR , unsigned iVel, int value>

constexpr auto olb::util::populationsContributingToVelocity ( )

constexpr

Return array of population indices where c[iVel] == value.

Definition at line 216 of file util.h.

                                                                {
  constexpr auto velocity_matches_value = [](unsigned iPop) -> bool {
    return descriptors::c<DESCRIPTOR>(iPop,iVel) == value;
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches_value));
};

References olb::meta::array_from_index_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

pow() [1/8]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::pow ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inline

Definition at line 415 of file aDiff.h.

{
  if (!util::nearZero(a._v)) {
    return exp(b*log(a));
  }
  else {
    ADf<T,DIM> c(std::pow(a._v, b._v), Vector<T,DIM> {std::numeric_limits<T>::quiet_NaN()});
#ifdef AdWarnings
    std::cout << "ADf WARNING: pow(Adf) - pow evaluated at non-differentiable point" << std::endl;
#endif
    if (std::isfinite(c._v)) {
      for (unsigned i = 0; i < DIM; ++i) {
        if (util::nearZero(a.d(i))) {
          c._d[i] = T(0);
        }
      }
    }
    return c;
  }
}

References olb::util::ADf< T, DIM >::_v, olb::util::ADf< T, DIM >::d(), exp(), log(), and nearZero().

Here is the call graph for this function:

pow() [2/8]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::pow ( const ADf< T, DIM > & a, const U & b )

inline

Definition at line 405 of file aDiff.h.

{
  ADf<T,DIM> c(std::pow(a._v,T(b)), a._d);
  T tmp(T(b)*std::pow(a._v,b-T(1)));
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

pow() [3/8]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::pow ( const ADf< T, DIM > & a, int b )

inline

Definition at line 437 of file aDiff.h.

{
  ADf<T,DIM> c(std::pow(a._v,b), a._d);
  T tmp(b*std::pow(a._v, b-1));
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

pow() [4/8]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::pow ( const U & a, const ADf< T, DIM > & b )

inline

Definition at line 396 of file aDiff.h.

{
  ADf<T,DIM> c(std::pow(T(a),b._v), b._d);
  T tmp(c._v*std::log(T(a)));
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

pow() [5/8]

template<typename T >

cpu::simd::Pack< T > olb::util::pow	(	cpu::simd::Pack< T >	base,
		cpu::simd::Pack< T >	exp )

Definition at line 112 of file pack.h.

{
  return cpu::simd::pow(base, exp);
}

References exp(), and olb::cpu::simd::pow().

Here is the call graph for this function:

pow() [6/8]

template<typename T , typename S >

cpu::simd::Pack< T > olb::util::pow	(	cpu::simd::Pack< T >	base,
		S	exp )

Definition at line 118 of file pack.h.

{
  return cpu::simd::pow(base, cpu::simd::Pack<T>(exp));
}

References exp(), and olb::cpu::simd::pow().

Here is the call graph for this function:

pow() [7/8]

Expr olb::util::pow	(	Expr	base,
		Expr	exp )

Definition at line 188 of file expr.h.

                              {
  return Expr(base, Expr::Op::Pow, exp);
}

References exp(), and olb::Expr::Pow.

Here is the call graph for this function:

pow() [8/8]

template<typename T , typename S >

any_platform auto olb::util::pow ( T base, S exp ) -> std::enable_if_t<std::is_arithmetic_v<T>,decltype(std::pow(base,exp))>

inline

Definition at line 38 of file omath.h.

{
#ifdef  __CUDA_ARCH__
  return ::pow(base, exp);
#else
  return std::pow(base, exp);
#endif
}

References exp().

Here is the call graph for this function:

powf()

any_platform float olb::util::powf ( float base, float exp )

inline

Definition at line 47 of file omath.h.

{
#ifdef  __CUDA_ARCH__
  return ::powf(base, exp);
#else
  return pow(base, exp);
#endif
}

References exp(), and pow().

Here is the call graph for this function:

powl()

long double olb::util::powl ( long double base, long double exp )

inline

Definition at line 56 of file omath.h.

{
  return pow(base, exp);
}

References exp(), and pow().

Here is the call graph for this function:

pressureFromDensity()

template<typename T , typename DESCRIPTOR >

T olb::util::pressureFromDensity

(

T

latticeDensity

)

compute lattice pressure from lattice density

Definition at line 387 of file util.h.

{
  // p = (rho - 1) * c_s^2
  return (latticeDensity - 1.0) / descriptors::invCs2<T,DESCRIPTOR>();
}

print()

template<typename U >

void olb::util::print	(	U	data,
		const std::string &	name = "",
		OstreamManager	clout = OstreamManager(std::cout,"print"),
		const char	delimiter = ',' )

Definition at line 419 of file vectorHelpers.h.

{
  static_assert(!std::is_integral<U>::value && !std::is_floating_point<U>::value, "passed integral or floating_point value to function print()");
  if (name != "") {
    clout << name << " = ";
  }
  for ( auto& element : data ) {
    clout << std::fixed << element << delimiter << ' ';
  }
  clout << std::endl;
}

Here is the caller graph for this function:

radianToDegree() [1/2]

template<typename T , unsigned D>

decltype(Vector< decltype(util::sqrt(T())), D >()) olb::util::radianToDegree

(

const Vector< T, D > &

angle

)

Definition at line 56 of file geometricOperations.h.

{
  constexpr BaseType<decltype(util::sqrt(T()))> conversionFactor = 180. / M_PI;
  return conversionFactor * angle;
}

References M_PI, and sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

radianToDegree() [2/2]

template<typename T >

decltype(util::sqrt(T())) olb::util::radianToDegree

(

T

angle

)

Definition at line 63 of file geometricOperations.h.

{
  return radianToDegree(Vector<T, 1>(angle))[0];
}

References radianToDegree().

Here is the call graph for this function:

remainingIndexes()

template<typename DESCRIPTORBASE >

std::vector< int > olb::util::remainingIndexes

(

const std::vector< int > &

indices

)

finds all the remaining indexes of a lattice given some other indexes

Definition at line 333 of file util.h.

{
  std::vector<int> remaining;
  for (int iPop = 0; iPop < DESCRIPTORBASE::q; ++iPop) {
    bool found = false;
    for (unsigned jPop = 0; jPop < indices.size(); ++jPop) {
      if (indices[jPop] == iPop) {
        found = true;
      }
    }
    if (!found) {
      remaining.push_back(iPop);
    }
  }
  return remaining;
}

rotateMofi()

template<typename T >

constexpr Matrix< T, 3, 3 > olb::util::rotateMofi ( const Vector< T, 3 > & mofi, const Vector< T, 9 > & rotationMatrix )

constexpr

Rotate moment of inertia (mofi)

Definition at line 216 of file geometricOperations.h.

{
  // I' = R(angle) * I * R(angle)^T
  // TODO: The inertia tensor is symmetric - make use of it
  T data[3][3] = {
      {mofi[0],    T {},    T {}},
      {   T {}, mofi[1],    T {}},
      {   T {},    T {}, mofi[2]}
  };
  Matrix<T, 3, 3>       inertiaTensor(data);
  const Matrix<T, 3, 3> _rotationMatrix(rotationMatrix);
  inertiaTensor =
      _rotationMatrix * inertiaTensor * (_rotationMatrix.transpose());
 
  return inertiaTensor;
}

References olb::Matrix< T, ROWS, COLS >::transpose().

Here is the call graph for this function:

round() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::round ( const ADf< T, DIM > & a )

inline

Definition at line 928 of file aDiff.h.

{
  ADf<T,DIM> c (std::round(a._v));
  constexpr T EPSILON (std::numeric_limits<T>::epsilon());
  if (std::round(a._v - EPSILON) != std::round(a._v + EPSILON)) {
#ifdef AdWarnings
    std::cout << "ADf WARNING: round(Adf) - round evaluated at non-differentiable point" << std::endl;
#endif
    for (unsigned i = 0; i < DIM; ++i) {
      c._d[i] = (a.d(i) == 0) ? T(0) : std::numeric_limits<T>::quiet_NaN();
    }
  }
  return c;
}

References olb::util::ADf< T, DIM >::_v, and olb::util::ADf< T, DIM >::d().

Here is the call graph for this function:

Here is the caller graph for this function:

round() [2/5]

double olb::util::round ( double arg )

inline

Definition at line 821 of file omath.h.

{
  return std::round(arg);
}

round() [3/5]

float olb::util::round ( float arg )

inline

Definition at line 816 of file omath.h.

{
  return std::round(arg);
}

round() [4/5]

long double olb::util::round ( long double arg )

inline

Definition at line 826 of file omath.h.

{
  return std::round(arg);
}

round() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::round ( T arg )

inline

Definition at line 811 of file omath.h.

{
  return std::round(arg);
}

roundf() [1/3]

template<unsigned DIM>

ADf< float, DIM > olb::util::roundf ( const ADf< float, DIM > & a )

inline

Definition at line 944 of file aDiff.h.

{
  return round(a);
}

References round().

Here is the call graph for this function:

roundf() [2/3]

double olb::util::roundf ( double arg )

inline

Definition at line 836 of file omath.h.

{
  return round(arg);
}

References round().

Here is the call graph for this function:

roundf() [3/3]

float olb::util::roundf ( float arg )

inline

Definition at line 831 of file omath.h.

{
  return round(arg);
}

References round().

Here is the call graph for this function:

roundl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::roundl ( const ADf< long double, DIM > & a )

inline

Definition at line 950 of file aDiff.h.

{
  return round(a);
}

References round().

Here is the call graph for this function:

roundl() [2/2]

long double olb::util::roundl ( long double arg )

inline

Definition at line 841 of file omath.h.

{
  return round(arg);
}

References round().

Here is the call graph for this function:

scalarProduct() [1/2]

template<typename T >

T olb::util::scalarProduct	(	const std::vector< T > &	u1,
		const std::vector< T > &	u2 )

Definition at line 197 of file util.h.

{
  T prod = T();
  if (u1.size() == u2.size()) {
    for (int iD=0; iD<u1.size(); ++iD) {
      prod += u1[iD]*u2[iD];
    }
  }
  return prod;
}

scalarProduct() [2/2]

template<typename T , int d>

T olb::util::scalarProduct	(	const T	u1[d],
		const T	u2[d] )

Definition at line 187 of file util.h.

{
  T prod = T();
  for (int iD=0; iD<d; ++iD) {
    prod += u1[iD]*u2[iD];
  }
  return prod;
}

sign()

template<typename T >

int olb::util::sign ( T val )

inline

Definition at line 54 of file util.h.

{
  return (0 < val) - (val < 0);
}

Here is the caller graph for this function:

sin() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::sin ( const ADf< T, DIM > & a )

inline

Definition at line 569 of file aDiff.h.

{
  ADf<T,DIM> c(std::sin(a._v), a._d);
  T tmp(std::cos(a._v));
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

sin() [2/5]

double olb::util::sin ( double arg )

inline

Definition at line 306 of file omath.h.

{
  return std::sin(arg);
}

sin() [3/5]

float olb::util::sin ( float arg )

inline

Definition at line 296 of file omath.h.

{
  return std::sin(arg);
}

sin() [4/5]

long double olb::util::sin ( long double arg )

inline

Definition at line 311 of file omath.h.

{
  return std::sin(arg);
}

sin() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::sin ( T arg )

inline

Definition at line 322 of file omath.h.

{
  return std::sin(arg);
}

sinf()

float olb::util::sinf ( float arg )

inline

Definition at line 301 of file omath.h.

{
  return sin(arg);
}

References sin().

Here is the call graph for this function:

sinh() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::sinh ( const ADf< T, DIM > & a )

inline

Definition at line 651 of file aDiff.h.

{
  return 0.5*(exp(a)-exp(-a));
}

References exp().

Here is the call graph for this function:

Here is the caller graph for this function:

sinh() [2/5]

double olb::util::sinh ( double arg )

inline

Definition at line 338 of file omath.h.

{
  return std::sinh(arg);
}

sinh() [3/5]

float olb::util::sinh ( float arg )

inline

Definition at line 328 of file omath.h.

{
  return std::sinh(arg);
}

sinh() [4/5]

long double olb::util::sinh ( long double arg )

inline

Definition at line 343 of file omath.h.

{
  return std::sinh(arg);
}

sinh() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::sinh ( T arg )

inline

Definition at line 354 of file omath.h.

{
  return std::sinh(arg);
}

sinhf()

float olb::util::sinhf ( float arg )

inline

Definition at line 333 of file omath.h.

{
  return sinh(arg);
}

References sinh().

Here is the call graph for this function:

sinhl()

long double olb::util::sinhl ( long double arg )

inline

Definition at line 348 of file omath.h.

{
  return sinh(arg);
}

References sinh().

Here is the call graph for this function:

sinl()

long double olb::util::sinl ( long double arg )

inline

Definition at line 316 of file omath.h.

{
  return sin(arg);
}

References sin().

Here is the call graph for this function:

sqr() [1/2]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::sqr ( const ADf< T, DIM > & a )

inline

Definition at line 446 of file aDiff.h.

{
  ADf<T,DIM> c((a._v)*(a._v), a._d);
  T tmp(T(2)*a._v);
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

sqr() [2/2]

template<typename T >

T olb::util::sqr

(

T

arg

)

Definition at line 136 of file util.h.

{
  return arg*arg;
}

sqrt() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::sqrt ( const ADf< T, DIM > & a )

inline

Definition at line 556 of file aDiff.h.

{
  ADf<T,DIM> c(std::sqrt(a._v), a._d);
  T tmp(T(1.)/(c._v*T(2)));
  for (unsigned i = 0; i < DIM; ++i) {
    if (!util::nearZero(a.d(i))) {
      c._d[i] *= tmp;
    }
  }
  return c;
}

References olb::util::ADf< T, DIM >::_d, olb::util::ADf< T, DIM >::_v, olb::util::ADf< T, DIM >::d(), and nearZero().

Here is the call graph for this function:

sqrt() [2/5]

template<typename T >

cpu::simd::Pack< T > olb::util::sqrt

(

cpu::simd::Pack< T >

value

)

Definition at line 100 of file pack.h.

{
  return value.sqrt();
}

sqrt() [3/5]

Expr olb::util::sqrt

(

Expr

x

)

Definition at line 180 of file expr.h.

                  {
  return Expr(Expr::Op::Sqrt, x);
}

References olb::Expr::Sqrt.

sqrt() [4/5]

template<typename T >

std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::sqrt ( T arg )

inline

Definition at line 276 of file omath.h.

{
#ifdef  __CUDA_ARCH__
  return ::sqrt(arg);
#else
  return std::sqrt(arg);
#endif
}

sqrt() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::sqrt ( T arg )

inline

Definition at line 286 of file omath.h.

{
#ifdef  __CUDA_ARCH__
  return ::sqrt(arg);
#else
  return std::sqrt(arg);
#endif
}

sqrtf()

any_platform float olb::util::sqrtf ( float arg )

inline

Definition at line 261 of file omath.h.

{
#ifdef  __CUDA_ARCH__
  return ::sqrtf(arg);
#else
  return sqrt(arg);
#endif
}

References sqrt().

Here is the call graph for this function:

sqrtl()

long double olb::util::sqrtl ( long double arg )

inline

Definition at line 270 of file omath.h.

{
  return sqrt(arg);
}

References sqrt().

Here is the call graph for this function:

subIndexOutgoing()

template<typename DESCRIPTOR , int direction, int orientation>

constexpr auto olb::util::subIndexOutgoing ( )

constexpr

Compute opposites of wall-incoming population indices.

Definition at line 256 of file util.h.

                                               {
  // Should be expressed in terms of populationsContributingToVelocity
  // but std::array / std::index_sequence distinction makes this ugly
  // To be revisitited
  constexpr auto velocity_matches_value = [](unsigned iPop) {
    return descriptors::c<DESCRIPTOR>(iPop,direction) == orientation;
  };
  constexpr auto opposite_population = [](unsigned iPop) {
    return descriptors::opposite<DESCRIPTOR>(iPop);
  };
  return meta::array_from_index_sequence(
    meta::map_index_sequence(opposite_population,
                             descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches_value)));
}

References olb::meta::array_from_index_sequence(), and olb::meta::map_index_sequence().

Here is the call graph for this function:

subIndexOutgoing2DonCorners()

template<typename DESCRIPTOR , int normalX, int normalY>

constexpr auto olb::util::subIndexOutgoing2DonCorners ( )

constexpr

Definition at line 310 of file util.h.

                                                          {
  constexpr auto velocity_matches = [](unsigned iPop) {
    return ( descriptors::c<DESCRIPTOR>(iPop,0) * normalX
           + descriptors::c<DESCRIPTOR>(iPop,1) * normalY) < 0;
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches));
}

References olb::meta::array_from_index_sequence().

Here is the call graph for this function:

subIndexOutgoing3DonCorners()

template<typename DESCRIPTOR , int normalX, int normalY, int normalZ>

constexpr auto olb::util::subIndexOutgoing3DonCorners ( )

constexpr

Definition at line 321 of file util.h.

                                                          {
  constexpr auto velocity_matches = [](unsigned iPop) {
    return ( descriptors::c<DESCRIPTOR>(iPop,0) * normalX
           + descriptors::c<DESCRIPTOR>(iPop,1) * normalY
           + descriptors::c<DESCRIPTOR>(iPop,2) * normalZ) < 0;
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches));
}

References olb::meta::array_from_index_sequence().

Here is the call graph for this function:

subIndexOutgoing3DonEdges()

template<typename DESCRIPTOR , int plane, int normal1, int normal2>

constexpr auto olb::util::subIndexOutgoing3DonEdges ( )

constexpr

Definition at line 286 of file util.h.

                                                        {
  constexpr auto velocity_matches = [](unsigned iPop) {
           if constexpr (plane == 0) {
      return ( descriptors::c<DESCRIPTOR>(iPop,0) * 0
             + descriptors::c<DESCRIPTOR>(iPop,1) * (normal1 == 1 ? 1 : -1)
             + descriptors::c<DESCRIPTOR>(iPop,2) * (normal2 == 1 ? 1 : -1)) < 0;
    } else if constexpr (plane == 1) {
      return ( descriptors::c<DESCRIPTOR>(iPop,0) * (normal1 == 1 ? 1 : -1)
             + descriptors::c<DESCRIPTOR>(iPop,1) * 0
             + descriptors::c<DESCRIPTOR>(iPop,2) * (normal2 == 1 ? 1 : -1)) < 0;
    } else if constexpr (plane == 2) {
      return ( descriptors::c<DESCRIPTOR>(iPop,0) * (normal1 == 1 ? 1 : -1)
             + descriptors::c<DESCRIPTOR>(iPop,1) * (normal2 == 1 ? 1 : -1)
             + descriptors::c<DESCRIPTOR>(iPop,2) * 0) < 0;
    } else {
      return false;
    }
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches));
}

References olb::meta::array_from_index_sequence().

Here is the call graph for this function:

subIndexOutgoingRemaining()

template<typename DESCRIPTOR , int direction, int orientation>

constexpr auto olb::util::subIndexOutgoingRemaining ( )

constexpr

Definition at line 272 of file util.h.

                                                        {
  constexpr auto velocity_matches = [](unsigned iPop) {
    for (unsigned jPop : subIndexOutgoing<DESCRIPTOR,direction,orientation>()) {
      if (iPop == jPop) {
        return false;
      }
    }
    return true;
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches));
}

References olb::meta::array_from_index_sequence().

Here is the call graph for this function:

surfaceNormal()

template<typename S , unsigned D, typename F1 >

Vector< S, D > olb::util::surfaceNormal	(	const Vector< S, D > &	pos,
		const S	meshSize,
		F1	sdf )

Definition at line 236 of file indicatorBase.h.

{
  Vector<S,D> normal( S(0) );
 
  for (unsigned iD=0; iD<D; ++iD) {
    Vector<S,D> delta(S(0));
    delta[iD] = meshSize;
    normal[iD] = (sdf(pos+delta) - sdf(pos-delta)) / (2*meshSize);
  }
 
  return normal;
}

Here is the caller graph for this function:

tan() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::tan ( const ADf< T, DIM > & a )

inline

Definition at line 587 of file aDiff.h.

{
  ADf<T,DIM> c(std::tan(a._v), a._d);
  T tmp(T(1)+c._v*c._v);
  c._d*=tmp;
  return c;
}

References olb::util::ADf< T, DIM >::_d, and olb::util::ADf< T, DIM >::_v.

Here is the caller graph for this function:

tan() [2/5]

double olb::util::tan ( double arg )

inline

Definition at line 434 of file omath.h.

{
  return std::tan(arg);
}

tan() [3/5]

float olb::util::tan ( float arg )

inline

Definition at line 424 of file omath.h.

{
  return std::tan(arg);
}

tan() [4/5]

long double olb::util::tan ( long double arg )

inline

Definition at line 439 of file omath.h.

{
  return std::tan(arg);
}

tan() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::tan ( T arg )

inline

Definition at line 450 of file omath.h.

{
  return std::tan(arg);
}

tanf()

float olb::util::tanf ( float arg )

inline

Definition at line 429 of file omath.h.

{
  return tan(arg);
}

References tan().

Here is the call graph for this function:

tanh() [1/5]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::tanh ( const ADf< T, DIM > & a )

inline

Definition at line 663 of file aDiff.h.

{
  return 1 - 2.0 / (exp(2*a) + 1);
}

References exp().

Here is the call graph for this function:

Here is the caller graph for this function:

tanh() [2/5]

double olb::util::tanh ( double arg )

inline

Definition at line 466 of file omath.h.

{
  return std::tanh(arg);
}

tanh() [3/5]

float olb::util::tanh ( float arg )

inline

Definition at line 456 of file omath.h.

{
  return std::tanh(arg);
}

tanh() [4/5]

long double olb::util::tanh ( long double arg )

inline

Definition at line 471 of file omath.h.

{
  return std::tanh(arg);
}

tanh() [5/5]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::tanh ( T arg )

inline

Definition at line 482 of file omath.h.

{
  return std::tanh(arg);
}

tanhf()

float olb::util::tanhf ( float arg )

inline

Definition at line 461 of file omath.h.

{
  return tanh(arg);
}

References tanh().

Here is the call graph for this function:

tanhl()

long double olb::util::tanhl ( long double arg )

inline

Definition at line 476 of file omath.h.

{
  return tanh(arg);
}

References tanh().

Here is the call graph for this function:

tanl()

long double olb::util::tanl ( long double arg )

inline

Definition at line 444 of file omath.h.

{
  return tan(arg);
}

References tan().

Here is the call graph for this function:

throwADfException()

template<typename T >

constexpr void olb::util::throwADfException ( T arg )

inlineconstexpr

Definition at line 1099 of file aDiff.h.

{
  static_assert(std::is_floating_point<T>::value,
                "The data type ADf has slipped in here. If you really want to use it here and lose all derivation information, then perform an explicit typecast.");
}

trunc() [1/4]

double olb::util::trunc ( double arg )

inline

Definition at line 788 of file omath.h.

{
  return std::trunc(arg);
}

trunc() [2/4]

float olb::util::trunc ( float arg )

inline

Definition at line 778 of file omath.h.

{
  return std::trunc(arg);
}

Here is the caller graph for this function:

trunc() [3/4]

long double olb::util::trunc ( long double arg )

inline

Definition at line 793 of file omath.h.

{
  return std::trunc(arg);
}

trunc() [4/4]

template<typename T >

std::enable_if_t< std::is_integral_v< T >, double > olb::util::trunc ( T arg )

inline

Definition at line 804 of file omath.h.

{
  return std::trunc(arg);
}

truncf()

float olb::util::truncf ( float arg )

inline

Definition at line 783 of file omath.h.

{
  return trunc(arg);
}

References trunc().

Here is the call graph for this function:

truncl()

long double olb::util::truncl ( long double arg )

inline

Definition at line 798 of file omath.h.

{
  return trunc(arg);
}

References trunc().

Here is the call graph for this function:

Variable Documentation

is_adf_v

template<class T >

constexpr bool olb::util::is_adf_v = is_adf<T>::value

inlineconstexpr

Definition at line 124 of file aDiff.h.