Skip to content

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

  • namespace TempLat
    • class AbstractField A base class for a one-component field, providing common functionality and holding relevant pointers to memory tools.
    • class AbstractMeasurer
    • class AbstractModel A class which contains everything a model should have; models derive from here. Mother of all the models. The arguments are passed as template parameters.
    • class AsComplexField Adapts a getter whose eval() returns a complex<C> value into a complex-field expression (i.e. one exposing ComplexFieldGet(Tag<0>)/ComplexFieldGet(Tag<1>)). This is the inverse ofasFourier() .
    • class AssignableCollectionBase A class which implements collections of object which are assignable.
    • class AssignableCollectionBase< Q >
    • class AssignableTuple A class which makes tuple out of things that have an operator equal. Dispatch the equal.
    • class Averager A class which computes the average value of a getter.
    • class AveragerHelper A class which Average Routimes common to single field and list averager.
    • class Averages A class used to compute common averages.
    • class AxionCouplings A class which computes the matter currents and charge densities of the gauge fields.
    • class BDPhaseHelper
    • class BackDiff A class which implements backward finite differences.
    • class Benchmark A class to benchmark your code.
    • class BinaryOperator A parent class which implements the common methods that all binary operators (*, +, -,... ) share.
    • class CStyleTime A class which returns date and time, pre C++17.
    • class CenteredFields A class which computes centered versions of electric and magnetic fields.
    • struct CheckAxionU1
    • struct CheckAxionU1< M, decltype((void) M::IsAxionU1Coupled, void())>
    • struct CheckerboardForEachWrapper Wraps a foreach functor to apply checkerboard reconstruction.
    • struct CheckerboardLayout Wraps a LayoutStruct to iterate over only even or odd parity lattice sites.
    • struct CheckerboardReduceWrapper Wraps a reduce functor to apply checkerboard reconstruction.
    • class ChiralProjector
    • class CollectionBase
    • class CollectionBase< Q, T, NDim, ISMOMENTUM >
    • struct CollectionHelper
    • struct CollectionHelper< Q, T, NDim, ISMOMENTUM, I, I >
    • struct CollectionSelector
    • struct CollectionSelector< Q, T, NDim, ISMOMENTUM, N, SHIFT, false >
    • class ComplexEvalComponent The real (N==0) or imaginary (N==1) component of a getter whose eval() returns a complex value.
    • class ComplexField A class which implements complex-valued fields.
    • class ComplexFieldAddition A class which implements complex field addition.
    • class ComplexFieldAsFourier A class which treats a complex field as an object in fourier space.
    • class ComplexFieldAverager A class which averages complex fields.
    • class ComplexFieldBinaryOperator A class which gtoups common features of binary field operators.
    • class ComplexFieldConjugate A class which computes the complex conjugate of a complex field.
    • class ComplexFieldFourierView A class which holds complex field in fourier space.
    • class ComplexFieldGetter A class which get real and imaginary part.
    • class ComplexFieldMultiplication A class which multiplies two complex fields.
    • class ComplexFieldOperator A class which implements common features of complex fields operators.
    • class ComplexFieldSU2DoubletMultiplication A class which implements the fundamental action of SU2.
    • class ComplexFieldShifter A class which implements spatial shifts for complex algebra.
    • class ComplexFieldShifterByOne
    • class ComplexFieldSubtraction A class which implements complex subtraction.
    • class ComplexFieldUnaryOperator A class which groups common features of unary complex field operators.
    • class ComplexFieldWrapper A class which wraps two objects as a complex field.
    • struct ComplexGetGetReturnType A class which unpack the return type of a complex type.
    • class ComplexScalarBase
    • class ComplexScalarKernels A class that computes the kernels for the complex scalars.
    • class ComplexScalarMeasurer A class which contains standard measurements for the complex scalars.
    • struct Concat A class which concatenates lists.
    • struct Concat< CollectionBase< Q, T, NDim, ISMOMENTUM, I1s... >, CollectionBase< Q, T, NDim, ISMOMENTUM, I2s... > >
    • struct Concat< TagListBase< I1s... >, TagListBase< I2s... > >
    • class ConditionalFileStream A class which adds an owned file stream to the ConditionalStream .
    • class ConditionalSayShort A class which only spits out to TTY if enabled == true.
    • class ConditionalStream Because of MPI, we often only want to stream if we are root, etc. To simplify the notation, and simply always be able to write output << ..., we create a wrapper that accepts input with operator<<, and does the 'if'-ing inside that operator.
    • class ConfigView A view on the field which, when interacted with, assures every time again that things are in configuration space, and possibly the ghost cells are updated when needed. The final Field class defaults to config space, which means it inherits from this class.
    • class ConfirmGhosts A class which wraps the calls to confirm(Configuration/Fourier)Space, for classes that have it and objects that don't.
    • class ConfirmSpace A class which wraps the calls to confirm(Configuration/Fourier)Space, for classes that have it and objects that don't.
    • namespace Constants A class which implements the i*sigma matrices.
    • class ContainsSpace A class which checks if a string contains a space.
    • class CouplingsManager
    • class CouplingsManager< NMatter, NGauge > This class is a specialization of the CouplingsManager for the case where there are no gauge field couplings.
    • class CouplingsManagerContainer A class which stores statically an array of booleans; useful to manage what couples to what.
    • struct DefaultModelPars
    • class DefectsMeasurer A class which contains measurements of energies and scale factor.
    • class DefectsObservables
    • class Demangle A class which demangles from internal c++ to source code naming, taken from http://stackoverflow.com/a/4541470/2295722 .
    • class Derivatives A class which aaplies vectorially the automatic derivative. Not used anywhere.
    • class Diffusion
    • class DimensionCountRecorder A super class which records the number of dimensions on any call to confirmSpace.
    • class DoEval A class which helps implementing the intermediate evaluation mechanism, extremely useful for matrix algebra.
    • class Endianness A class which detects, at runtime, the endianness of the system.
    • class Energies A class which computes the energy when working with our verlet-type algorithms. Assumes that the averages have already been computed.
    • class EnergiesMeasurer A class which contains measurements of energies and scale factor.
    • class EnergySnapshotsMeasurer A class that prints snapshots of energy densities in configuration space.
    • class Evolver
    • class Exception An exception which takes variadic arguments, all recorded into an error message.
    • class ExpressionShifter A class which implements shifts in coordinates.
    • class ExpressionShifterByOne
    • class ExternalPowerSpectrumInitializer A class that contains functions related with initial random fluctuations for scalar fields given by an external power spectrum.
    • class ExtraFields
    • struct FFTDecomposition The MPI Cartesian decomposition an FFT backend will use for a given runtime setup.
    • class FFTLayoutStruct A struct which holds two memory layouts, which are inseparable:
    • class FFTLibraryInterface A pure abstract class (interface!) which defines the methods that you must implement for your new fft library to play well with us.
    • class FFTLibrarySelector
    • class FFTMPIDomainSplit A class which combines the MPIDomainSplit with theFFTLibrarySelector limits on domain splitting.
    • class FFTNormalization A class which applies the normalization to a block of memory after C2R and R2C fft's. You can choose between: fourier: C2R: 1/N, R2C: 1, mixed: C2R: 1/sqrt(N), R2C: 1/sqrt(N), config: C2R: 1, R2C: 1/N,.
    • class FFTPlanInterface Yes, for once a nested class. The interface for your to-be-implemented FFT plan, but forward and backward. Complex-to-real and real-to-complex.
    • class FFTSessionGuard Yes, another nested class interface: for the session guard. Your constructor should take care of your_library_init(), your destructor should take care of your_library_cleanup(). These are the session-wide initialization / finalization calls.
    • struct FFTTopology The complete MPI topology an FFT backend will use: not just the grid shape, but the communicator whose rank order defines it and this rank's position within it.
    • class FFTWGuard A class which guards intialization and finalization of FFTW. Only used by MPIGuard , which manually calls its destructor.
    • class FFTWHermitianPartners A class which holds all information about the redundancy in the complex values from a r2c fft. The redundancy comes from hermitian symmetry, so certain elements must be each other's complex conjugate. This class tells you which elements are each other's.
    • class FFTWInterface A class which implements all of FFTLibraryInterface . The larger methods are implemented in classes from which we inherit, in a linear chain:FFTWMemoryLayout andFFTWPlanner .
    • class FFTWMemoryLayout Implements part of FFTLibraryInterface , computes the local memory associated to the global problem, for FFTW.
    • class FFTWPlanHolder A class which holds FFT plans, and implements FFTLibraryInterface::PlanInterface<T>. The plans are implemented in std::shared_ptr's, so they are only desctructed when the last instance is destructed.
    • class FFTWPlanner A class which partially implements FFTLibraryInterface , namely the getPlans parts. That is, here the calls to the FFTW planner are made.
    • class FFTWTranspositionFlags A class which creates the transposition flags for FFTW, based on a layout.
    • class Factorize A class which factorizes an integer into its primes.
    • class Field A class which is a classical field on your n-dimensional equisized grid. You use it as a scalar field, a vector component, whatever. Template parameter is your type of floating point precision: float or double. Default: double.
    • class FieldCollection A class which Field collections. Allows to have collection of composite vector fields as well.
    • class FieldFunctionals A class which stores expressions of field functionals. By "field functional" we refer to any function of the field variables such as quadratic forms, e.g. <phi^2>, and others.
    • struct FieldNDimCheck
    • class FieldsAsInModel A class which holds extra fields, so that they can be used across the program.
    • class FieldsNumbering A class which defines an ordering for the fields, to be used across the interface.
    • class FileIO A class which wraps HDF5 file saving and loading.
    • class FileReader A class which reads input files.
    • class FileToJSON A class which reads a file which contains valid JSON, and parses it into a json::JSON object.
    • class FileToString A class which reads a file into a std::string. Constructor does not work, reading is actually done when the class is cast to a string.
    • class FilesManager Interface to switch between hdf5 and std output for measurements. This class hides the polymorphism under the hood.
    • class FixedBackgroundExpansion A class which implements fixed background expansion.
    • class Flattener A class which flattents a composite collection.
    • class FloatToString A class which holds one static method (format) which returns a nicer string representation of a floating point value, for display purposes (not too many significant digits).
    • class FluctuationsGenerator A class that contains functions related with initial random fluctuations for scalar fields.
    • struct ForRangeHelper
    • struct ForRangeHelper< i, 0 >
    • class ForwDiff A class which implements forward finite differences.
    • class ForwDij A class which implements forward finite sums.
    • class FourierView A view on the field which, when interacted with, assures every time again that things are in fourier space, and possibly the ghost cells are updated when needed.
    • class GWBase
    • class GWProjector A class which computed the energy of the GWs, using the type 1 (neutral) TT projector.
    • class GWProjectorType1
    • class GWProjectorType2
    • class GWProjectorType3
    • class GWsInitializer A class which is used to initialize the gravitational waves fields.
    • class GWsKernels A class which stores the kernel for the GWs fields.
    • class GWsMeasurer A class which contains standard measurements for the GWs sector.
    • class GaugeDerivatives A class which computes spatial scalar and (covariant) gauge derivatives.
    • class GaussLaws A class that checks the preservation of the Gauss constraints, for both U1 and SU2 gauge sectors.
    • class GetCPPTypeName A class which calls typeid and demangles it if possible.
    • class GetComponent A class which calls getComp.
    • class GetDeriv A class which gets derivates from all classes, also those that do not have derivative.
    • class GetDx A getter for dx.
    • struct GetFloatType A template which extracts the float type from complexes.
    • struct GetFloatType< F >
    • struct GetFloatType< complex< F > >
    • struct GetFloatType< device::array< T, N > >
    • struct GetGetReturnType get(IterationCoordinates&) might be a function which returns a real value or a complex value. Sometimes we need to explicitly access what type it is.
    • class GetKIR A getter for kIR.
    • class GetNDim A class which returns the number of dimensions.
    • class GetNGrid A class which returns the number of grid points in a specific dimensions.
    • struct GetNScalars
    • struct GetNScalars< CouplingsManager< NScalars, NU1, Coupled > >
    • class GetString A template-programming class which helps to get the 'toString'-value from any type, whether it has the toString-method or it is a scalar value.
    • class GetToolBox A Helper class which returns the toolbox of an object, if it has one, and throws an exception if it doesn't. This is useful for measurement objects, which may or may not have a toolbox, but we want to be able to call getToolBox() on them without having to check if they have one first.
    • class GetVectorComponentHelper A class which returns one component of a vector as an object, keeping all fourier and co mechanics consistent. Mostly useful for wave numbers.
    • class GetVectorSize A class which gets the size of a vector like composite object.
    • class GhostBuster A class which adds and removes (busts!) ghost cells to your layout. Pass the original layout and the target layout to the constructor. Then pass any pointer which satisfies for origin layout to the function call operator. And the rest will be history.
    • class GhostStateKeeper A class which only holds the state of ghost cells: stale or up to date.
    • class GhostSubarray A class which holds an MPI_Datatype which is a subarray of the lattice, created by MPI_Type_create_subarray. The subarray is the ghost padding of the lattice, in one single dimension.
    • class GhostSubarrayMap A class which keeps track of all subarray types for a given layout, which in turn is described by the LayoutStruct . The map is for datatypes and dimensions. getSubArray<T>(dimension) is the only necessary public method.
    • class GhostUpdater A class which updates the ghost cells in our total memory block. By having the LayoutStruct , this class knows what is the ghostDepth.
    • class GhostsHunter A class which helps implementing the automatic management of updating the ghost cells.
    • struct HalfType A class which implement 1/2 as a type. Useful for squareroots.
    • struct HasAsTupleCat A class which detects whether or not an object has the hasTuplCat method.
    • struct HasAsTupleCat< T, std::void_t< decltype(std::declval< T >().asTupleCat())> >
    • struct HasExplicitCoordinateDependence Enables adapting the coordinates inside a possible shifted view on this object. This is very expensive, time-wasting, which is why we want to be able to detect such an explicit coordinate dependence, and skip the coordinate-shift computation when it is not used, saving loads of cpu time.
    • struct HasExplicitCoordinateDependence< T, std::void_t< decltype(T::EXPLICITCOORDINATEDEPENDENCE)> > Specialization: single object that mentions its explicit coordinate dependence.
    • struct HasExplicitCoordinateDependence< T< S >, std::void_t<> > Specialization: template object (Getter) whose enclosed class might mention its explicit coordinate dependence.
    • struct HasExplicitCoordinateDependence< T< S1, S2 >, std::void_t<> > Specialization: template object (Getter) whose enclosed class might mention its explicit coordinate dependence.
    • class HeavisideStepFunction Heaviside step function We use the convention that H(0) = 1 for simplicity.
    • struct HermGetGetReturnType
    • class HermGetter A class which get real and imaginary part.
    • class HermOperator
    • class HermSymTracelessMultiplication A class which multiplies two symmetric-traceless fields.
    • class HermSymTracelessMultiplicationTrace A class which multiplies two symmetric-traceless fields.
    • class HermWrapper A class which wraps six expressions, the upper triangle, as a hermitian 3x3 matrix.
    • class HermitianPartners An almost abstract class which your FFT library must implement, which maps the redundant entries in the complex representation of the FFT of your real values data, to their hermitian-conjugate partners.
    • class HermitianValueAccounting A number of unique / independent real and imaginary floating point values in a memory layout.
    • class HubbleConstraint A class that computes the hubble law in order to monitor "energy conservation".
    • namespace InitialConditionsType
    • struct IntrinsicScales The result holder for getIntrinsicRescaleToGetUnnormalizedFFT: two labeled double values.
    • struct IsCompositeHelper A class which allows to check whether a class is composite or not. Allows to write general function that works on composite classes.
    • struct IsCompositeHelper< T, 1 >
    • class IsInContainer A class which checks wheter container contains some objects. Need to be std compatible. https://stackoverflow.com/a/19299611 .
    • struct IsSU2DaggerT
    • struct IsSU2DaggerT< SU2Dagger< R > >
    • struct IsTupleLike A class which tests whether or not a class behaves like a tuple.
    • struct IsTupleLike< T, std::void_t< typename std::tuple_size< T >::type > >
    • class IsVariadicIndexTester
    • class KBins
    • namespace KECCAK
    • class KeccakHash A class which computes (statically) the keccak hash of one string.
    • class KeccakHashBareClass A class which computes the keccak hash of one string, which is passed to the method compute. Can compute only once, then keeps the state. Throws an exception if compute is called twice.
    • namespace Kernels
    • namespace KernelsTypes
      • class Diffusion
      • class EoM A mechanism to define different kernels for the same solver.
    • class KokkosFFTMemoryLayout Implements part of FFTLibraryInterface , computes the local memory associated to the global problem, for KokkosFFT. Build on this to replace KokkosFFT.
    • class KokkosFFTPlanHolder A class which implements part of FFTLibraryInterface::PlanInterface, holding the KokkosFFT plans in shared_ptr's.
      • struct Plans What's the intention here? Well, KokkosFFT does not support multi-dimensional FFTs directly, but only 1D, 2D and 3D FFTs. So for higher dimensions, we need to chain multiple FFTs together. This struct holds the plans for these FFTs, and provides methods to execute them in sequence.
    • class KokkosFFTPlanner A class which implements part of FFTLibraryInterface , the planner part. Here all calls to KokkosFFT_plan ... are made.
    • class KokkosFFTTranspositionFlags A class which determines the transpose-flags for the KokkosFFT planners, corresponding to a given layout.
    • class LatinIndicesList A class which an enumerated list which starts from 1 rather than 0.
    • class LatticeForwardGradient A class which implements the forward gradient.
    • class LatticeLaplacian A class which implements the laplacian.
    • struct LatticeParameters
    • struct LayoutStruct Holds the result of FFTLibraryInterface::computeLocalSizes . In itself, has practically no logic, only forwards all the getters and setters to their respective owners. SeeLayoutStructGlobal ,LayoutStructLocal andLayoutStructLocalTransposed .
    • class LayoutStructGlobal A class which holds some memory informations.
    • class LayoutStructLocal A class which localSizes: the local size in each dimension. localStart: the coordinate of the first entry in local memory, in the global coordinate space.
    • class LayoutStructLocalTransposed transitionMap: a map of the dimensions, for transposition in memory. E.g. {0, 1, 2, 3} is untransposed 4d, {1, 0, 2, 3} is FFTW transposed. In other words, the entries in transitionMap are in line with the entries in localStarts/-Sizes, and their value indicates the physical-space dimension of that entry.
      • struct CoordinateMapping A dictionary for return values for memory to coordinate mapping.
    • class LeapFrog A class which implements a leapfrog scheme to evolve scalar singlets, complex scalars, SU2 doublets, and U(1) and SU(2) gauge fields.
    • class ListAbsoluteValue A class which adds two getters. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
    • class ListAddition A class which adds two getters. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
    • class ListBinaryOperator Wrapper for algebra with FieldCollection . Here we define the base methods for checking and everything. Can use this algebra to implement matrix and vector algebra! IDEA: statically type MATRIXTYPE type and template methods of the type AddMatrixTypes<R,T>::type.
    • class ListComplexConjugate A class which implements the complex conjugation for the list algebra.
    • class ListDivision
    • class ListExponential A class which implements the exponentiation for the list algebra.
    • class ListLaplacian A class which applies a minus sign. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
    • class ListLog A class which implements the logarithm for the list algebra.
    • class ListMultiplication
    • class ListPower
    • class ListPowerN
    • class ListShifter A class which implements shifts for the list algebra.
    • class ListShifterByOne
    • class ListSubtraction A class which adds two getters. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
    • class ListUnaryMinus A class which adds two getters. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
    • class ListUnaryOperator A class which.
    • class LoadBalance A class which given and a number of threads nth, return nth integer which reprensents the most even splitting of the number.
    • class LogMutex A class which holds a mutex, specific for output (log).
    • class MPIAllReduce A class which calls MPI_Allreduce, meaning that all processes submit their value and receive the combined value of all processes, given an operation to combine the values.
    • class MPICartesianExchange A class which handles the exchange between neighbours in the cartesian group. Has two methods: exchangeUp and exchangeDown, which take as input a datatype, a dimension (because you need to specify what is up and down), a pointer for the sending memory and a pointer for the receiving memory.
    • class MPICartesianGroup A class keeps the books regarding the process layout relative to the physics lattice.
    • class MPICartesianNeighbours A class which fetches and stores the neighbours in all dimensions. Internally just contructs a std::vector<MPICartesianNeighboursSingleDimension> with each entry corresponding to its associated dimension.
    • class MPICartesianNeighboursSingleDimension A class which fetches and stores the two neighbours in a single dimension.
    • class MPICommReference A class which holds an MPIComm. The Comm WILL DESTRUCT when the last owner of a reference to this class destructs its instance. Unless it is MPI_COMM_WORLD, of course.
    • class MPIDebuggerHanger A class which can be used to hang a serial debugger like gdb to individual threads.
    • class MPIDomainSplit A class which factorizes an integer into N roughly equal-size integers. That is, our best guess for the domain decomposition.
    • class MPIGuard A class which guards intialization and finalization of pure MPI. Only used by SessionGuard , which manually calls its destructor, but which also holds the FFTW and other guards.
    • class MPISendReceive A class which holds all methods that do plain Send and Receive in MPI. Just call the send and receive methods with any scalar or vector-like input, associated rank numbers and tags. Unused for now.
    • namespace MPITags
    • class MPITagsJustCompile A class which just compiles. Unit test: ctest -R test-mpitags.
    • class MPITypeConstants
    • class MatrixBinaryOperator A class which gtoups common features of binary field operators.
    • struct MatrixGetGetReturnType
    • class MatrixGetter A class which get real and imaginary part.
    • class MatrixMatrixMultiplication A class which multiplies two general (full, 9-component) 3x3 matrix fields. Distinct from the symmetric-traceless products (sym/herm/scalar SymTracelessMultiplication), which store fewer independent components and use the traceless relation.
    • class MatrixMatrixMultiplicationTrace A class which computes the trace of the product of two matrix fields. Used for the projector of GWs.
    • class MatrixOperator A class which implements common features of matrix fields operators.
    • class MatrixWrapper A class which wraps nine expressions as a general 3x3 matrix, given row by row.
    • class MatterCurrents A class which computes the matter currents and charge densities of the gauge fields.
    • class Maximum
    • class MeansMeasurer A class which implements common measurement to all fields, like mean and variance, in a standardized format.
    • class MeasurementsSaver A class which implements an interface to the measurement IO. Allow to switch between different format.
    • class MeasurementsSaverStd A class which is used to save measurements using the standard library.
    • class Measurer A class which contains the measurements.
    • class MemoryBlock A class which holds a block of memory. Feel free to pass it around and copy: the pointer is itself kept inside a shared pointer. Only when the last owner is destructed, the memory is freed.
    • class MemoryLayoutState A class which tracks the three layout states the memory can have. If state is undefined, all the is___Space() variants return true. So you don't wast time FFT'ing trash etc.
    • class MemoryManager A class which holds a single lattice in memory, and tracks and moves between various ghost states. Templated for the memory type, typically float or double. All the confirm___Space() functions return a device::Idx, which counts the amount of work done. Ignore that, but it is important for testing purposes. NOTE that the memory access operators (T* and operator[]) do NOT verify if memory was allocated.
    • class MemoryToolBox A class which collects all the tool classes which deal with memory(-state) manipulation. Make one toolbox using the makeShared method, and instantiate as many memory managers as you want, with identical layouts!
    • class ModelInitializer A class initializes a model's fields and the scale factor.
    • class ModelParametersBase
    • class MomentumInterpolator
    • class MomentumMultiplicity Computes, for each Fourier-space site, the multiplicity of modes sharing the same rounded momentum magnitude bin. Returns 1/multiplicity on eval. Generalized to arbitrary NDim.
    • class MultipleParameterGetter A class which returns multiple parameters.
    • class NamedTmpFile A class which creates a named temporary file, accepts input, and can close and delete.
    • class NeutDiff A class which implements neutral finite differences.
    • class NeutDij A class which implements neutral finite sums.
    • class NonMinimalCoupling
    • class NonMinimalCouplingBase
    • class NormGradientSquare A class which computes the gradient square norm.
    • struct Number A runtime-mutable scalar value that participates in the expression template algebra.
    • struct NumberCollection A lightweight fixed-size collection of Number<T> values.
    • class NumericalIntegrator A class which encapsulate some newto-cotes integration formula. Assume that the point are equispaced.
    • class OccupationNumberMeasurer A class which computes the occupation number.
    • struct OneType A class which represents one. Attempt to simplify derivative expressions.
    • namespace Operators Extra namespace, as names such as Add and Subtract are too generic.
      • class ACos A class which applies arccosine.
      • class ASinh A class which computes the asinh.
      • class AbsoluteValue A class which takes the absolute value of a given expression.
      • class Addition A class which adds two getters. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
      • class Arg A class to compute the argument of a complex field.
      • class Arg2 A class to compute the argument of a complex field.
      • class ComplexConjugate A class which applies complex conjugation to a complex number.
      • class Cosh A class which implements the Cosh for a given expression.
      • class Cosine A class which applies cosine.
      • class DiracDeltaFunction A class which implements the Dirac delta function.
      • class Division A class which divides two expressions. Holds the expression, only evaluates for a single element when you call Divide::get(pIterCoords).
      • class Exponential A class which exponentiates an expression.
      • class Log Get the logarithm of a given expression.
      • class Multiplication A class which multiplies two expressions.
      • class MultiplicationN
      • class Power A class which takes one expression to the power of another expression.
      • class PowerN
      • struct SafeDivision Check if numerator if roughly zero, don't do the division. Useful for spectrum fluctuation, when normalising with a cutoff.
      • struct SafeSqrt A function which applies a square root, by forwarding to power(x, 0.5), with 0.5 templated explicitly. Holds the expression, only evaluates for a single element when you call SquareRoot::get(pIterCoords).
      • class Sine A class which applies the sine to an expression.
      • class Sinh A class which implements the Sinh .
      • class Subtraction A class which subtracts two getters. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
      • class Tanh A class which implements the Tanh .
      • class UnaryMinus A class which applies a minus sign. Holds the expression, only evaluates for a single element when you call Multiply::get(pIterCoords).
    • class OutputStream A class which handles output, with convenient savetxt function.
    • class PITensor A class which computes the componentes of the Anisotropic Tensor source of Gravitational Waves.
    • class PairMaker Small class which splits strings into two and make a pair out of it.
    • class ParafaftMemoryLayout Memory layout computation for parafaft.
    • class ParafaftPlanHolder Plan holder for parafaft FFT transforms.
    • class ParafaftPlanner Plan creation for parafaft FFT transforms.
    • class ParameterGetter Class for parameter .handler. Special getter which can directly cast to T.
    • class ParameterParser
    • class ParenthesisStripper A class which strips a string of its parenthesis if they are first and last characters.
    • class PauliVectorsAlgebra A class which implements the SU2 algebra at the single element level.
    • class PoorMansProfile A class for the poor man's profiling: prints out the map upon destruction.
    • class PositionVerlet A class which implements a position Verlet algorithm that evolves scalar singlets, complex scalars, SU2 doublets, and U(1) and SU(2) gauge fields.
    • struct PositionVerletParameters A class which stores the composition parameters for position Verlet schemes.
    • class PostGet A class which wraps the calls to confirm(Configuration/Fourier)Space, for classes that have it and objects that don't.
    • class Potential A class which manipulates the potential and the its derivatives.
    • class PowerSpectrumMeasurer A class which computes the power spectrum, with the appropriate rescaling to make it volume independent.
    • class PreGet A class which wraps the calls to confirm(Configuration/Fourier)Space, for classes that have it and objects that don't.
    • class PrettyToString A class which attempts to write a float removing the unnnecessary 0 at the end. Not completely robust as this is a complicated problem but good enough for our purposes.
    • class RK2NStorage A class which implements low storage ("2N-storage") explicit RK methods.
    • class RK2NStorageFields A class which implements low storage ("2N-storage") explicit RK methods.
    • class RK2NStorageParameters A class which stores coefficients for 2N-storage RK.
    • class RadialBinComputer A class which returns an integer bin for a given fp value.
    • class RadialProjectionRebinner A class which takes a std::vector<RadialProjectionSingleBinAndValue<T>> and rebins it into a smaller number of bins.
    • class RadialProjectionResult A class which holds the result of a radial projection, with per bin the average position of each entry (the horizontal axis in your plot..), the variance in the position, the average value, the sample variance (= <f^2> - <f>^2 ) of the values, and the number of entries in a bin (multiplicity).
    • struct RadialProjectionSingleBinAndValue A class which combines a pair of RadialProjectionSingleDatums, one for the bin position, one for the function value for that bin.
    • struct RadialProjectionSingleDatum A class which holds a single bin which results from the radial projection of something. Used for describing both the bin position and values, namely combined in RadialProjectionSingleBinAndValue .
    • class RadialProjectionSingleQuantity A class which holds properties of a quantity (average, variance, min, max), each in a separate vector. Useful during the integration, will be transposed after the integration is done.
    • class RadialProjector A class which projects any N-D lattice on its positive-definite radial coordinate. In other words, integrating out all the angular dimensions. When in Fourier-space, this routine takes into account what the redundancies are. Only the unique values are counted. Real-valued entries get weight 0.5 (they only contribute one float value out of the two for each complex value), and of the hermitian pairs, only the positivePartner is taken into account.
    • class RandomGaussian A gaussian random variable. Is aware of its own state and counts the number of values that have been returned.
    • class RandomGaussianFieldHelper A class which initializes a complex random gaussian field. ONLY WORKS FOR FFTW R2C complex layouts. It has a state, which counts the number of times it has been used. As in the backend a deterministic, stateless RNG is used, we need to keep track of this in order to generate a new set of random numbers each time.
    • class RandomUniform A class which gives pseudo random counter-based rng, based on a string random seed, stable across platforms.
    • class ResolutionPreserving A class that implements the resoluton-preserving techniques (including fattening and extra-fattening).
    • class RunParameters A class which contains the parameters useful to run a simulation but not model specific (dt for example).
    • class SU2Addition A class which implements the sum of su2 matrices.
    • class SU2Averager An averager for su2. Allows to take into account cached operations consistently.
    • class SU2Base
    • class SU2BinaryOperator A class which implements basic features of su2 binary operators.
    • class SU2Commutator A class which computes the commutator of two SU(2) matrices.
    • class SU2Dagger A class which implements the hermitian conjugation.
    • class SU2Dotter Lie-algebra inner product <A,B> = sum_{a=1,2,3} A_a B_a of two SU(2)-valued expressions, returned as a scalar.
    • class SU2Doublet A class which implements su2doublets.
    • class SU2DoubletAddition A class which implements the sum of 2 su2 doublets.
    • class SU2DoubletAverager An averager specialised for SU2Doublet . Allows to take into account cached operations consistently.
    • class SU2DoubletBinaryOperator A class which implements common features to SU2Doublet binary operators.
    • class SU2DoubletDagger A class which compute the hermitean conjugate of Doublets.
    • class SU2DoubletDotter A class which computes the scalar product of two doublets.
    • struct SU2DoubletGetGetReturnType A class which gives the return type of the get function of one of the doublet element.
    • class SU2DoubletGetter A class which return the SU2DouletGet method.
    • class SU2DoubletKernels A class which holds the kernels for the SU2Doublet .
    • class SU2DoubletMeasurer A class which contains standard measurements for the SU2 doublets.
    • class SU2DoubletOperator A class which groups some features of the SU2Doublet ops.
    • class SU2DoubletSectorBase
    • class SU2DoubletShifter A class which shifts a doublet in space.
    • class SU2DoubletShifterByOne
    • class SU2DoubletSubtract A class which implement the Subtraction between two su2 doublets.
    • class SU2DoubletUnaryOperator A class which groups common features to su2doublets unary operators.
    • class SU2DoubletWrapper A class which creates a doublet out of some preexisting objects.
    • class SU2ExpMap A class which computes the exponential map for su(2).
    • class SU2ExpMapInv A class which computes the inverse exponential map for SU2 (log).
    • class SU2Field A class which implements a SU2 field (group). We choose a representation with 4 real numbers per lattice site, c0, c1, c2, c3. These are subject to the unitarity constraint c0^2 + c1^2 + c2^2 + c3^2 = 1, which can be enforced by the unitarize() method. A single link variable is then represented as U = c0 * I + i * (c1 * sigma1 + c2 * sigma2 + c3 * sigma3), where sigma1, sigma2, sigma3 are the Pauli matrices.
    • struct SU2GetGetReturnType A class which determines what is the return type of the composite su2 objects.
    • class SU2Getter A class which return the SU2Get method.
    • class SU2GroupWrapper A class which computes an element of the group SU(2). By that, we mean that det=1 is imposed as a constrained on the 0th element, like in the SU2Fields.
    • class SU2Initializer A class that initializes the SU(2) gauge sector (both non-Abelian gauge fields and SU2 doublets)
    • class SU2Kernels A class that computes the kernel for the SU2 gauge fields.
    • class SU2LieAlgebraField A class which implements a SU2 field (algebra). Same than the group, except set 0 component to 0 and has a function which returns its components wrt to sigma/2 instead of sigma, which is more conventional for the algebra (but internally, also expanded as a function of sigma).
    • class SU2Measurer A class which contains standard measurements for the SU2 gauge fields.
    • class SU2Multiplication A class which implement SU(2) matrix multiplication.
    • class SU2Operator A class which contains basic info about su2 algebra.
    • class SU2SU2DoubletMultiplication A class which implemetns SU2 SU2Doublet multiplication.
    • class SU2Shifter A class which applies the shift method to su2 objects.
    • class SU2ShifterByOne
    • class SU2Subtraction A class which implements the SU2 Subtraction.
    • class SU2UnaryOperator A class which implements basic features of su2 unary operators.
    • class SU2Wrapper A class which construct a SU2-like object.
    • class ScalarBase
    • class ScalarComplexFieldMultiply A class which implements scalar multiplication over complex numbers.
    • class ScalarSU2Multiplication A class which multiplies SU2 field by complex fields.
    • class ScalarSingletInitializer A class which is used to initialize the scalar singlets.
    • class ScalarSingletKernels A class that computes the kernel for the scalar singlets.
    • class ScalarSingletMeasurer A class which contains standard measurements for scalar singlets.
    • class ScalarSymTracelessMultiply A class which implements scalar multiplication over symmetric traceless numbers.
    • class ScalarU1AxionBase
    • class ScaleFactorBase
    • class ScaleFactorInitializer A class which is used to initialize the scale factor.
    • class ScaleFactorKernels A class that computes the kernel for the scale factor equation.
    • class ScaleFactorMeasurer A class which measure the scale factor, its derivative and the Hubble rate.
    • class SessionGuard A class which holds all the guards: fftw, other fft libraries and mpi. Only one instance per process is allowed. Throws an exception if that condition is violated.
    • class SimulationManager A class which handles start and stop of a simulation. Also used to create the info file.
    • class SpaceStateInterface An interface class which all getter-like objects inherit from, so we can access their confirm(Config/Fourier)Space methods by their virtualness.
    • class SpatialCoordinate A class which implements spatial coordinates.
    • class SpectrumSaver A class which saves spectra to files.
    • class SpectrumSaverStd A class which implements the std spectra output.
    • class Spline
    • struct SplineData
    • class Stacktrace A class which holds the stacktrace to the point where it was instantiated.
    • class StaticWarning
    • class StreamCacher A container that sits at the receiving end of a stream, and spits out everything to the mutexed std::cerr only when it is destructed -> that the end of the line;.
    • class StringConverter A class which wraps a single function, splitting it in lines and passing each line to ParameterGetter , returning the result in your provided MultipleParameterGetter<T>.
    • class StringTrimmer A class which trims strings on all ends. In place: [lr]trim(std::string). Copy: std::string [lr]trimmed(std::string)
    • struct SymGetGetReturnType
    • class SymGetter A class which get real and imaginary part.
    • class SymOperator
    • class SymSymTracelessMultiplication A class which multiplies two symmetric-traceless fields.
    • class SymSymTracelessMultiplicationTrace A class which multiplies two symmetric-traceless fields.
    • class SymTracelessAddition A class which implements symmetric-traceless field addition.
    • class SymTracelessBinaryOperator A class which gtoups common features of binary field operators.
    • class SymTracelessConjugate A class which implements conjugation of all the elements of a symmetric-traceless matrix.
    • class SymTracelessField A class which implements symmetric-traceless matrix field used for GWs.
    • class SymTracelessFieldAsFourier A class which treats a symmetric-traceless field as an object in fourier space.
    • class SymTracelessFieldFourierView A class which holds symmetric-traceless field in fourier space.
    • class SymTracelessFieldShifter A class which implements spatial shifts for symmetric traceless algebra.
    • class SymTracelessFieldShifterByOne
    • struct SymTracelessGetGetReturnType A class which unpack the return type of a complex type.
    • class SymTracelessGetter A class which get real and imaginary part.
    • class SymTracelessOperator
    • class SymTracelessSubtraction A class which implements complex subtraction.
    • class SymTracelessUnaryOperator A class which groups common features of unary complex field operators.
    • class SymTracelessWrapper A class which wraps six expressions as a symmetric 3x3 matrix whose trace is subtracted on evaluation.
    • class SymWrapper A class which wraps six expressions, the upper triangle, as a symmetric 3x3 matrix.
    • namespace Symbols A namespace which contains symbols such as the epsilon tensor.
    • class TDDAssertion The function to call for the evaluation of each test.
    • class TDDContainer The container to instantiate if you want to register your class for testing.
    • class TDDContainerBase A class which provides the interface for TDDContainers.
    • class TDDContainerDummy
    • class TDDRegister A class which registers all unit tests in the currently linked binaries, and runs all the unit tests when called accordingly.
    • class Tag A class which implements homemade compile time constants.
    • class TagListBase A class which implements an enumerated list.
    • struct TagListHelper
    • struct TagListHelper< I, I >
    • class TempLatArray A class which makes array compatible which getComp algebra.
    • class TempLatVector A class which makes vector compatible with GetComponent algebra and defines a operator(int i).
    • class ThreadSettings A class which does bookkeeping, number of threads allowed by hardware, number of threads allowed by user, etc.
    • class TimeSpent A class which measures the wall time since its construction.
    • class Timer A simple timer class to measure elapsed time.
    • class ToolWithOwnMemory A base class for powerspectrum and twopointcorrelator: holds an optionally persistent block of memory of the same shape as the Getter that you pass to it.
    • class TopologicalChargesMeasurer A class to measure gauge fields topological charges.
    • class TranspositionMap A class which maps between two orderings.
    • class TripleStateLayouts A class which keeps three layouts of the memory for one MPI task in a global exact hypercube.
    • struct TupleMakerHelper
    • struct TupleMakerHelper< R, true >
    • class U1Base
    • class U1Exponential Exponential map for U(1).
    • class U1Initializer A class that initializes the U(1) gauge sector (both Abelian gauge fields and complex scalars)
    • class U1Kernels A class that computes the kernel of the U(1) gauge fields.
    • class U1Measurer A class which contains standard measurements for the U1 gauge fields.
    • class UnaryOperator A parent class which implements the common methods that all unary operators (-, sqrt ) share.
    • class UnbinnedPowerSpectrumMeasurer A class which computes the power spectrum, with the appropriate rescaling to make it volume independent.
    • class UnbinnedRadialProjectionResult A class which holds the result of a radial projection without binning. For each possible value of the Fourier coordinate it saves: the average value, the sample variance (= <f^2> - <f>^2 ) of the values, and the number of entries in a bin (multiplicity).
    • class VectorDotter A class which takes two VectorGetters, and implements a special get method which returns the dot-product / contraction of the two vectors.
    • class VectorFieldCollection A class which allows to make collections of vector fields.
    • class VelocityVerlet A class which implements a velocity verlet algorithm that evolves scalar singlets, complex scalars, SU2 doublets, and U(1) and SU(2) gauge fields.
    • struct VelocityVerletParameters A class which stores the composition parameters. See appendix in "The art of simulating the early Universe", arXiv:2006.15122.
    • struct VerbosityLevels A struct with a bunch of flags with enable various output messages. Use to your advantage.
    • class WallAverager A class which computes the average value of a getter over the first n-1 coordinates, returns a vector.
    • class WaveNumber A class which allows for accessing (unscaled, dimensionless, index-valued) various expressions involving the fourier coordinates.
    • class Weights A class that defines the weights used to measure the energy contained in the strings. Vy defect, we use weights based on the potential, normalized such that they are equal to unity at the core of the defects.
    • struct ZeroType A class which represents zero. Attempt to simplify derivative expressions.
    • namespace detail
    • namespace device
    • namespace device_kokkos
      • class DeviceGuard A class to manage and initialize the Kokkos runtime environment and its dependencies.
      • struct GetKokkosNDStarType
      • struct GetKokkosNDStarType< 1, T >
      • struct KokkosNDLambdaWrapper This is a functor which wraps a lambda. Basically, this is necessary when one wants to call a variadic lambda on an NVIDIA GPU. CUDA seems to be unable to expand the variadic arguments - in contrast, a direct approach does indeed work for openMP or serial compilation. To get around this limitation, the KokkosNDLambdaWrapper packs the indices into an array. If you wonder, whether there's a difference when using tie and tuples:https://godbolt.org/z/M3bG39rsM No. Therefore, we spare the ourselves the hassle and simply use an array.
      • struct KokkosNDLambdaWrapperInnerLoop The CPU dispatch: a functor which wraps a lambda and walks the contiguous last dimension itself.
      • struct KokkosNDLambdaWrapperReduction This is a functor which wraps a lambda for reduction. Basically, this is necessary when one wants to call a variadic lambda on an NVIDIA GPU. CUDA seems to be unable to expand the variadic arguments - in contrast, a direct approach does indeed work for openMP or serial compilation. To get around this limitation, the KokkosNDLambdaWrapperReduction packs the indices into an array. If you wonder, whether there's a difference when using tie and tuples:https://godbolt.org/z/M3bG39rsM No. Therefore, we spare the ourselves the hassle and simply use an array.
      • namespace iteration
      • namespace memory
    • struct holdStaticGuard I wrapped this in a struct for a very specific case: If we have multiple translation units (cpp files) which include this header, and each calls getFFTSessionGuards, then we will have multiple static variables, one per translation unit, and the guards will not work as intended. By wrapping it in a struct, we ensure that there is only one instance of the static variable, no matter how many translation units include this header.
    • struct is_std_vector
    • struct is_std_vector< std::vector< T, A > >
    • struct number_to_skip_as_tuple A class which make a tuple from a composite object.
    • struct number_to_skip_as_tuple< R, std::void_t< decltype(R::numberToSkipAsTuple)> >
    • struct static_max A class which compute the maximum at compile time.
    • struct std_atomic_type A SFINAE struct to get the base type of a composite container.
    • struct std_atomic_type< T, std::void_t< typename T::value_type > >
    • namespace std_device
    • struct tuple_size
    • struct tuple_size< Tuple, std::void_t< decltype(Tuple::size)> >
    • struct tuple_size_helper A class which overloads tuple_size for the fcn composite objects.
    • struct tuple_size_helper< Tuple, std::void_t< decltype(std::tuple_size< Tuple >::value)> >
    • struct warn_if A compile-time warning based on template programming values. Taken from https://www.reddit.com/r/cpp/comments/66o1ju/does_a_static_warn_exist/ .
    • struct warn_if< false >
  • struct TrueKeccak WV: turned this in a class for lazy inlining.
  • namespace json
  • namespace json
  • union BackingData
  • namespace std