Namespace List#
|
DiFfRG
Discretization Framework for functional Renormalization Group flows
|
Namespace List
Here is a list of all namespaces with brief descriptions:
[detail level 123456]
| ►Nautodiff | |
| ►Ndetail | |
| CArithmeticTraits<::Kokkos::complex< T > > | |
| ►NDiFfRG | |
| ►NCG | |
| ►Ninternal | |
| ►CCopyData_I | |
| CCopyFaceData_I | |
| CCopyData_J | |
| CCopyData_R | |
| CScratchData | Class to hold data for each assembly thread, i.e. FEValues for cells, interfaces, as well as pre-allocated data structures for the solutions |
| CAssembler | The basic assembler that can be used for any standard CG scheme with flux and source |
| CDiscretization | Class to manage the system on which we solve, i.e. fe spaces, grids, etc. This class is a System for CG systems |
| Ncompute | |
| ►NdDG | |
| ►Ninternal | |
| ►CCopyData_I | |
| CCopyFaceData_I | |
| ►CCopyData_J | |
| CCopyDataFace_J | |
| ►CCopyData_R | |
| CCopyDataFace_R | |
| CScratchData | Class to hold data for each assembly thread, i.e. FEValues for cells, interfaces, as well as pre-allocated data structures for the solutions |
| CAssembler | The basic assembler that can be used for any standard DG scheme with flux and source |
| ►Ndef | This namespace contains all default implementations and definitions needed for numerical models |
| ►Ninternal | |
| CAD_tools | |
| CAD_tools< autodiff::dual > | |
| CAD_tools< autodiff::real > | |
| CAbstractModel | The abstract interface for any numerical model. Most methods have a standard implementation, which can be overwritten if needed. To see how the models are used, refer to the DiFfRG::AbstractAssembler class and the Numerical Models guide in the documentation |
| CAD_dual | |
| CAD_real | |
| CADjacobian_boundary_numflux | |
| CADjacobian_extractors | |
| CADjacobian_flux | |
| CADjacobian_flux_source | |
| CADjacobian_mass | |
| CADjacobian_numflux | |
| CADjacobian_source | |
| CADjacobian_variables | |
| CFE_AD | |
| CFlowBoundaries | |
| CFlowDirections | |
| CfRG | Used to keep track of the RG time and the cutoff scale |
| CLDGUpDownFluxes | |
| CLLFFlux | |
| CNoJacobians | |
| CNoNumFlux | |
| CTime | |
| CUpDown | |
| CUpDownFlux | |
| Ndevice | |
| ►NDG | |
| ►Ninternal | |
| ►CCopyData_I | |
| CCopyFaceData_I | |
| ►CCopyData_J | |
| CCopyDataFace_J | |
| ►CCopyData_R | |
| CCopyDataFace_R | |
| CScratchData | Class to hold data for each assembly thread, i.e. FEValues for cells, interfaces, as well as pre-allocated data structures for the solutions |
| CAssembler | The basic assembler that can be used for any standard DG scheme with flux and source |
| CDiscretization | Class to manage the system on which we solve, i.e. fe spaces, grids, etc. This class is a System for DG systems, i.e. without LDG |
| ►NFE | |
| CFlowingVariables | A class to set up initial data for whatever discretization we have chosen. Also used to switch/manage memory, vectors, matrices over interfaces between spatial discretization and separate variables |
| ►NfRG | |
| NTFLitimSpatial | Here, useful threshold functions obtained by performing loop integrals with the litim regulator are collected. For explicit expressions, see the appendix of https://arxiv.org/abs/1909.02991 |
| ►NFV | |
| ►NKurganovTadmor | |
| ►Ninternal | |
| ►CCopyData_I | |
| CCopyFaceData_I | |
| ►CCopyData_J | |
| CCopyDataFace_J | |
| ►CCopyData_R | |
| CCopyDataFace_R | |
| CScratchData | Class to hold data for each assembly thread, i.e. FEValues for cells, interfaces, as well as pre-allocated data structures for the solutions |
| CAssembler | |
| CDiscretization | Class to manage the system on which we solve, i.e. fe spaces, grids, etc. This class is a System for FV systems |
| ►Nget_type | |
| ►Ninternal | |
| C_ctype | |
| C_ctype< autodiff::Real< 1, complex< double > > > | |
| C_ctype< autodiff::Real< 1, complex< float > > > | |
| C_ctype< autodiff::Real< 1, double > > | |
| C_ctype< autodiff::Real< 1, float > > | |
| C_ctype< complex< double > > | |
| C_ctype< complex< float > > | |
| C_ctype< double > | |
| C_ctype< float > | |
| C_InverseSparseMatrixType | |
| C_InverseSparseMatrixType< dealii::BlockSparseMatrix< NT > > | |
| C_InverseSparseMatrixType< dealii::SparseMatrix< NT > > | |
| C_NumberType | |
| C_NumberType< dealii::BlockVector< NT > > | |
| C_NumberType< dealii::Vector< NT > > | |
| C_SparsityPattern | |
| C_SparsityPattern< dealii::BlockSparseMatrix< NT > > | |
| C_SparsityPattern< dealii::SparseMatrix< NT > > | |
| ►Nhdf5 | |
| Ndetail | |
| CDataset | |
| CDataspace | |
| CDatatype | |
| CFile | |
| CGroup | |
| CHandle | |
| CTypeTrait | |
| CTypeTrait< autodiff::Real< N, T > > | |
| CTypeTrait< DiFfRG::complex< T > > | |
| CTypeTrait< DiFfRG::device::array< T, N > > | |
| CTypeTrait< std::array< T, N > > | |
| CTypeTrait< std::string > | Variable-length UTF-8 string |
| ►Ninternal | |
| C_has_dim | |
| CFunctionFromLambda | |
| CMatsubaraStorage | A class that stores Matsubara quadrature points and weights for a given T, E. Its main purpose is to avoid recomputing the quadrature points and weights for each Matsubara integrator and provide a search algorithm to find previously computed Matsubara quadratures |
| CQuadratureStorage | A class that stores Quadrature points and weights for a given type and order Its main purpose is to avoid recomputing the quadrature points and weights for each integrator and provide a search algorithm to find previously computed quadratures |
| CTransform_fT_p2 | |
| CTransform_fT_p2_1ang | |
| CTransform_fT_p2_4D_2ang | |
| CTransform_p2 | |
| CTransform_p2_1ang | |
| CTransform_p2_4D_2ang | |
| CTransform_p2_4D_3ang | |
| ►NInterpolation | |
| CBarycentric | This class takes in x-dependent data and interpolates it to a given x on request |
| CCubicSpline | This class takes in x-dependent data and interpolates it to a given x on request. This class uses the cubic spline methods from gsl to interpolate the data |
| ►NLDG | |
| ►Ninternal | |
| ►CCopyData_I | |
| CCopyFaceData_I | |
| ►CCopyData_J | |
| CCopyDataFace_J | |
| ►CCopyData_J_full | |
| CCopyDataFace_J | |
| ►CCopyData_R | |
| CCopyDataFace_R | |
| CScratchData | Class to hold data for each assembly thread, i.e. FEValues for cells, interfaces, as well as pre-allocated data structures for the solutions |
| CAssembler | The LDG assembler that can be used for any LDG scheme, with as many levels as one wants |
| CDiscretization | Class to manage the system on which we solve, i.e. fe spaces, grids, etc. This class is a System for LDG systems, i.e. DG with additional projections (e.g. derivatives) |
| CLDGAssemblerBase | |
| NLoopIntegrals | |
| NMPI | |
| ►NVariables | |
| CAssembler | The basic assembler that can be used for any standard CG scheme with flux and source |
| CAbstractAdaptor | Implement a simple interface to do all adaptivity tasks, i.e. solution transfer, reinit of dofHandlers, etc |
| CAbstractAssembler | This is the general assembler interface for any kind of discretization. An assembler is responsible for calculating residuals and their jacobians for any given discretization, including both the spatial part and any further variables. Any assembler for a specific spatial discretization must fully implement this interface |
| CAbstractFlowingVariables | A class to set up initial data for whatever discretization we have chosen. Also used to switch/manage memory, vectors, matrices over interfaces between spatial discretization and separate variables |
| CAbstractIntegrator | |
| CAbstractLinearSolver | |
| CAbstractMinimizer | Abstract class for minimization in arbitrary dimensions |
| CAbstractMinimizer< 1 > | |
| CAbstractRootFinder | |
| CAbstractRootFinder< 1 > | |
| ►CAbstractTimestepper | The abstract base class for all timestepping algorithms. It provides a standard constructor which populates typical timestepping parameters from a given JSONValue object, such as the timestep sizes, tolerances, verbosity, etc. that are used in the timestepping algorithms |
| CConsoleOutStats | |
| CExplicitParameters | |
| CImplicitParameters | |
| CBisectionRootFinder | |
| CBosonicCoordinates1DFiniteT | |
| CBosonicMatsubaraValues | |
| CBosonicRegulator | Implements one of the standard exponential regulators, i.e |
| CBosonicRegulatorOpts | |
| CComponentDescriptor | A class to describe how many FE functions, additional variables and extractors are used in a model |
| CConfigurationHelper | Class to read parameters given from the command line and from a parameter file |
| CCoordinatePackND | Utility class for combining multiple coordinate systems into one |
| CCsvOutput | A class to output data to a CSV file |
| CCSVReader | This class reads a .csv file and allows to access the data |
| CDataOutput | Class to manage writing to files. FEM functions are written to vtk files and other data is written to csv files |
| CExecutionSpaces | |
| CExponentialRegulator | Implements one of the standard exponential regulators, i.e |
| CExponentialRegulatorOpts | |
| CExternalDataInterpolator | This class takes in a .csv file with x-dependent data and interpolates it to a given x on request |
| CFEMAssembler | The basic assembler that can be used for any standard CG scheme with flux and source |
| CFEOutput | A class to output finite element data to disk as .vtu files and .pvd time series |
| CFEOutput< 0, VectorType > | |
| CFermionicCoordinates1DFiniteT | |
| CFermionicMatsubaraValues | |
| CFixedString | A fixed size compile-time string |
| CFlowingVariables | A class to set up initial data for whatever discretization we have chosen. Also used to switch/manage memory, vectors, matrices over interfaces between spatial discretization and separate variables |
| CFunctionND | A class to describe a function with a compile-time name and a fixed number of dimensions |
| CGetKokkosNDStarType | |
| CGetKokkosNDStarType< 1, T > | |
| CGLQuadrature | |
| CGLQuadrature< 1, ctype > | |
| CGLQuadrature< 10, ctype > | |
| CGLQuadrature< 11, ctype > | |
| CGLQuadrature< 12, ctype > | |
| CGLQuadrature< 128, ctype > | |
| CGLQuadrature< 13, ctype > | |
| CGLQuadrature< 14, ctype > | |
| CGLQuadrature< 15, ctype > | |
| CGLQuadrature< 16, ctype > | |
| CGLQuadrature< 2, ctype > | |
| CGLQuadrature< 20, ctype > | |
| CGLQuadrature< 24, ctype > | |
| CGLQuadrature< 3, ctype > | |
| CGLQuadrature< 32, ctype > | |
| CGLQuadrature< 4, ctype > | |
| CGLQuadrature< 48, ctype > | |
| CGLQuadrature< 5, ctype > | |
| CGLQuadrature< 6, ctype > | |
| CGLQuadrature< 64, ctype > | |
| CGLQuadrature< 7, ctype > | |
| CGLQuadrature< 8, ctype > | |
| CGLQuadrature< 9, ctype > | |
| CGLQuadrature< 96, ctype > | |
| CGMRES | |
| CGSLMinimizer1D | Minimizer in 1D using either the golden section, Brent or quadratic method from GSL |
| CGSLSimplexMinimizer | Minimizer using the Nelder-Mead simplex algorithm from GSL |
| CHAdaptivity | Implement a simple interface to do all adaptivity tasks, i.e. solution transfer, reinit of dofHandlers, etc |
| Chas_n_call_operator_helper | |
| CHDF5Input | A class to output data to a CSV file |
| CHDF5Output | A class to output data to a CSV file |
| CIndexStack | |
| CInit | |
| CIntegrationLoadBalancer | |
| CIntegrator_fT | |
| CIntegrator_fT_p2 | |
| CIntegrator_fT_p2_1ang | |
| CIntegrator_fT_p2_4D_2ang | |
| CIntegrator_p2 | Integrator_p2 integrates a kernel \(K(p,\ldots)\) depending on the radial momentum \(p\) as $$ \frac{S_d}{(2\pi)^{d}}\,\int_0^\infty dp^2 p^{d-2} K(p, \ldots) $$ where \(S_d\) is the solid angle in $d$ dimensions |
| CIntegrator_p2_1ang | Integrator_p2_1ang integrates a kernel \(K(p,\cos,\ldots)\) depending on the radial momentum \(p\) and the cosine of the single polar angle between the loop and external momentum as $$ \frac{S_{d-1}}{(2\pi)^{d}}\,\int_{-1}^1 dc\,(1-c^2)^{\frac{d-3}{2}}\,\int_0^\infty dp\, p^{d-1} K(p,c,\ldots) $$ in \(d\) dimensions, where \(S_{d-1}\) is the solid angle of the \((d-2)\)-sphere remaining after the polar angle is singled out. The zonal measure \((1-c^2)^{(d-3)/2}\) is supplied exactly by a Gauss-Jacobi angular quadrature, so it does not appear in the kernel |
| CIntegrator_p2_4D_2ang | Integrator_p2_4D_2ang integrates a kernel \(K(p,\cos_1,\cos_2,\ldots)\) depending on the radial momentum \(p\) and two angles on \([0,\pi]\) as $$ \frac{2\pi}{(2\pi)^{d}} \,\int_0^\pi d\cos_1\,\int_0^\pi d\cos_2\,\int_0^\infty dp^2 p^{d-2} K(p,\cos_1,\cos_2,\ldots) $$ in \(d=4\) dimensions |
| CIntegrator_p2_4D_3ang | Integrator_p2_4D_3ang integrates a kernel \(K(p,\cos_1,\cos_2,\ldots)\) depending on the radial momentum \(p\) and two angles on \([0,\pi]\) and one angle on \([0,2\pi]\) as $$ \frac{1}{(2\pi)^{d}} \,\int_0^\pi d\cos_1\,\int_0^\pi d\cos_2\,\int_0^{2\pi}d\phi\,\int_0^\infty dp^2 p^{d-2} K(p,\cos_1,\cos_2,\pi,\ldots) $$ in \(d=4\) dimensions |
| CIntegratorLat1D | |
| CIntegratorLat2D | |
| CIntegratorLat3D | |
| CIntegratorLat4D | |
| Cis_complex | |
| Cis_complex< complex< T > > | |
| Cis_complex< cxReal< N, T > > | |
| CJSONValue | A wrapper around the boost json value class |
| CKINSOL | A newton solver, using local error estimates for each vector component |
| CKokkosNDLambdaWrapper | 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 |
| CKokkosNDLambdaWrapperReduction | This is a functor which wraps a lambda for reduction. Basically, this is necessary when one wants to call a variadic lambda on an NVIDIA GPU. CUDA seems to be unable to expand the variadic arguments - in contrast, a direct approach does indeed work for openMP or serial compilation. To get around this limitation, the KokkosNDLambdaWrapperReduction packs the indices into an array. Uses compile-time index sequences to extract the first dim args as indices and the last arg as the reduction value, avoiding recursive tuple_first/tuple_cat overhead per GPU thread |
| CKokkosNDRangeHelper | |
| CKokkosNDRangeHelper< 1, ExecutionSpace > | |
| CLinearCoordinates1D | |
| CLinearInterpolator1D | A linear interpolator for 1D data, both on GPU and CPU |
| CLinearInterpolator2D | A linear interpolator for 2D data, both on GPU and CPU |
| CLinearInterpolator3D | A linear interpolator for 3D data, both on GPU and CPU |
| CLinearInterpolatorND_helper | |
| CLinearInterpolatorND_helper< 1, NT, Coordinates, DefaultMemorySpace > | |
| CLinearInterpolatorND_helper< 2, NT, Coordinates, DefaultMemorySpace > | |
| CLinearInterpolatorND_helper< 3, NT, Coordinates, DefaultMemorySpace > | |
| CLitimRegulator | Implements the Litim regulator, i.e |
| CLogarithmicCoordinates1D | |
| CMatsubaraQuadrature | A quadrature rule for (bosonic) Matsubara frequencies, based on the method of Monien [1]. This class provides nodes and weights for the summation |
| Cnamed_tuple | A class to store a tuple with elements that can be accessed by name. The names are stored as FixedString objects and their lookup is done at compile time |
| CNewton | A newton solver, using local error estimates for each vector component |
| CNoAdaptivity | |
| CNodeDistribution | |
| CPolynomial | A class representing a polynomial |
| CPolynomialExpRegulator | Implements a regulator given by |
| CPolynomialExpRegulatorOpts | |
| CQuadrature | |
| CQuadratureIntegrator | This class performs numerical integration over a d-dimensional hypercube using quadrature rules |
| CQuadratureIntegrator< dim, NT, KERNEL, TBB_exec > | |
| CQuadratureIntegrator_fT | |
| CQuadratureIntegrator_fT< dim, NT, KERNEL, TBB_exec > | |
| CQuadratureProvider | A class that provides quadrature points and weights, in host and device memory. The quadrature points and weights are computed either the GSL quadratures or the MatsubaraQuadrature class. This avoids recomputing the quadrature points and weights for each integrator |
| CQuadratureType | |
| CRationalExpRegulator | Implements a regulator given by |
| CRationalExpRegulatorOpts | |
| CRectangularMesh | Class to manage the discretization mesh, also called grid and triangluation, on which we simulate. This class only builds cartesian, regular grids, however cell density in all directions can be chosen independently |
| CScalar | |
| CSimpleMatrix | A simple NxM-matrix class, which is used for cell-wise Jacobians |
| CSmoothedLitimRegulator | Implements one of the standard exponential regulators, i.e |
| CSmoothedLitimRegulatorOpts | |
| CSplineInterpolator1D | A spline interpolator for 1D data, both on GPU and CPU |
| CSplineInterpolator1DStack | A linear interpolator for 1D data, using texture memory on the GPU and floating point arithmetic on the CPU |
| CstepperChoice | |
| CStringSet | |
| CSubCoordinates | |
| CSubDescriptor | |
| CSumPlus | An extension of the Kokkos::Sum reducer that adds a constant value to the result |
| CTBB_ExecutionSpace | This execution space is optimal when used in conjunction with the FE discretizations |
| CTC_Default | This is a default time controller implementation which should be used as a base class for any other time controller. It only implements the basic tasks that should be done when advancing time, i.e. saving, logging if the stepper got stuck, checking if the simulation is finished and restricting the minimal timestep |
| CTC_PI | A simple PI controller which adjusts time steps in a smooth fashion depending on how well the solver performs, taking into account the most recent time step, too |
| CTimeStepperBoostABM | A class to perform time stepping using the Boost Adams-Bashforth-Moulton method. This stepper uses fixed time steps and is fully explicit |
| CTimeStepperBoostRK | A class to perform time stepping using adaptive Boost Runge-Kutta methods. This stepper uses adaptive time steps and is fully explicit |
| CTimeStepperExplicitEuler | |
| CTimeStepperImplicitEuler | |
| CTimeStepperRK | |
| CTimeStepperSUNDIALS_IDA | A class to perform time stepping using the SUNDIALS IDA solver. This stepper uses adaptive time steps and is fully implicit. Furthermore, IDA allows for the solution of DAEs |
| CTimeStepperSUNDIALS_IDA_BoostABM | A class to perform time stepping using the Boost Adams-Bashforth-Moulton method for the explicit part and SUNDIALS IDA for the implicit part. This stepper uses fixed time steps in the explicit part and adaptive time steps in the implicit part. IDA acts as the controller and the ABM stepper solves the explicit part of the problem on-demand |
| CTimeStepperSUNDIALS_IDA_BoostRK | A class to perform time stepping using the adaptive Boost Runge-Kutta method for the explicit part and SUNDIALS IDA for the implicit part. In this scheme, the IDA stepper is the controller and the Boost RK stepper solves the explicit part of the problem on-demand |
| CTimeStepperTRBDF2 | |
| CUMFPack | |
| RNamedTuple | Concept for a named tuple |
| Ris_container | |
| Ris_sized_container | |
| Rhas_n_call_operator | |
| RMeshIsRectangular | |
| Ris_coordinates | |
| Rhas_integrator_AD | |
| Rhas_set_k | |
| Rhas_set_T | |
| Rhas_set_typical_E | |
| Rhas_set_x_extent | |
| Rprovides_regulator | |
| Rprovides_kernel | |
| Rprovides_constant | |
| Ris_valid_kernel | |
| Rhas_interpolator_types | Checks that an interpolator class provides the required type aliases (value_type, ctype) |
| Rhas_interpolator_methods | Checks that an interpolator class provides the required methods (get_coordinates, get_on<CPU_memory>, get_on<GPU_memory>) and a call operator with the correct arity |
| Ris_interpolator | A concept for what is an interpolator class |
| ►Nintegrators | |
| ►Ncore | |
| ►Ncuda | |
| ►Ndetail | |
| Ccuda_error | |
| Ccuda_memory | |
| Ngeneric | |
| Ccallback_params_t | |
| Chas_batching_impl | |
| Chas_batching_impl< I, T, D, U, std::void_t< decltype(std::declval< I >().operator()(std::declval< D * >(), std::declval< T * >(), std::declval< U >()))> > | |
| Cleast_squares_wrapper_t | |
| ►Nfitfunctions | |
| CNone | |
| CNoneFunction | |
| CNoneImpl | |
| CNoneTransform | |
| CPolySingular | |
| CPolySingularFunction | |
| CPolySingularHessian | |
| CPolySingularImpl | |
| CPolySingularJacobian | |
| CPolySingularTransform | |
| Ngeneratingvectors | |
| Nmath | |
| Noverloads | |
| ►Ntransforms | |
| ►Ndetail | |
| CBinomial | |
| CFactorial | |
| CFactorial< n, typename std::enable_if< n==0 >::type > | |
| CIPow | |
| CIPow< D, n, typename std::enable_if< n%2 !=0 &&n !=0 >::type > | |
| CIPow< D, n, typename std::enable_if< n==0 >::type > | |
| CKorobovCoefficient | |
| CKorobovCoefficient< D, k, a, b, typename std::enable_if< k==0 >::type > | |
| CKorobovTerm | |
| CKorobovTerm< D, k, a, b, typename std::enable_if< k==0 >::type > | |
| CSidiCoefficient | |
| CSidiCoefficient< D, k, r, typename std::enable_if<(r % 2) !=0 >::type > | |
| CSidiCoefficient< D, k, r, typename std::enable_if<(r % 2)==0 >::type > | |
| CSidiTerm | |
| CSidiTerm< D, k, r, typename std::enable_if<((r % 2) !=0) &&(k==0)>::type > | |
| CSidiTerm< D, k, r, typename std::enable_if<((r % 2)==0) &&(k==0)>::type > | |
| CSidiTerm< D, k, r, typename std::enable_if<(r % 2) !=0 &&(k !=0)>::type > | |
| CSidiTerm< D, k, r, typename std::enable_if<(r % 2)==0 &&(k !=0)>::type > | |
| CBaker | |
| CBakerImpl | |
| CKorobov | |
| CKorobovImpl | |
| CNone | |
| CNoneImpl | |
| CSidi | |
| CSidiImpl | |
| CSidiImpl< I, D, r, typename std::enable_if< r==0 >::type > | |
| CSidiImpl< I, D, r, typename std::enable_if<(r % 2) !=0 &&(r !=0)>::type > | |
| CSidiImpl< I, D, r, typename std::enable_if<(r % 2)==0 &&(r !=0)>::type > | |
| CLogger | |
| CQmc | |
| Cresult | |
| Csamples | |
| ►NKokkos | |
| Creduction_identity< autodiff::Real< N, T > > |
Generated by
1.9.8