| CDiFfRG::internal::__TLITypes< NT > | |
| CDiFfRG::internal::__TLITypes< autodiff::real > | |
| CDiFfRG::internal::__TLITypes< double > | |
| CDiFfRG::internal::__TLITypes< float > | |
| CDiFfRG::get_type::internal::_ctype< CT > | |
| CDiFfRG::get_type::internal::_ctype< autodiff::Real< 1, complex< double > > > | |
| CDiFfRG::get_type::internal::_ctype< autodiff::Real< 1, complex< float > > > | |
| CDiFfRG::get_type::internal::_ctype< autodiff::Real< 1, double > > | |
| CDiFfRG::get_type::internal::_ctype< autodiff::Real< 1, float > > | |
| CDiFfRG::get_type::internal::_ctype< complex< double > > | |
| CDiFfRG::get_type::internal::_ctype< complex< float > > | |
| CDiFfRG::get_type::internal::_ctype< double > | |
| CDiFfRG::get_type::internal::_ctype< float > | |
| CDiFfRG::get_type::internal::_InverseSparseMatrixType< SparseMatrixType > | |
| CDiFfRG::get_type::internal::_InverseSparseMatrixType< dealii::BlockSparseMatrix< NT > > | |
| CDiFfRG::get_type::internal::_InverseSparseMatrixType< dealii::SparseMatrix< NT > > | |
| CDiFfRG::get_type::internal::_NumberType< VectorType > | |
| CDiFfRG::get_type::internal::_NumberType< dealii::BlockVector< NT > > | |
| CDiFfRG::get_type::internal::_NumberType< dealii::Vector< NT > > | |
| CDiFfRG::get_type::internal::_SparsityPattern< SparseMatrixType > | |
| CDiFfRG::get_type::internal::_SparsityPattern< dealii::BlockSparseMatrix< NT > > | |
| CDiFfRG::get_type::internal::_SparsityPattern< dealii::SparseMatrix< NT > > | |
| ►CDiFfRG::AbstractAdaptor< VectorType > | Implement a simple interface to do all adaptivity tasks, i.e. solution transfer, reinit of dofHandlers, etc |
| CDiFfRG::NoAdaptivity< VectorType > | |
| ►CDiFfRG::AbstractAdaptor< Assembler::Discretization::VectorType > | |
| CDiFfRG::HAdaptivity< Assembler > | Implement a simple interface to do all adaptivity tasks, i.e. solution transfer, reinit of dofHandlers, etc |
| CDiFfRG::AbstractAssembler< VectorType, SparseMatrixType, dim > | 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 |
| ►CDiFfRG::AbstractAssembler< Discretization_::VectorType, Discretization_::SparseMatrixType, Discretization_::dim > | |
| ►CDiFfRG::FEMAssembler< Discretization_, Model_ > | The basic assembler that can be used for any standard CG scheme with flux and source |
| CDiFfRG::CG::Assembler< Discretization_, Model_ > | The basic assembler that can be used for any standard CG scheme with flux and source |
| CDiFfRG::DG::Assembler< Discretization_, Model_ > | The basic assembler that can be used for any standard DG scheme with flux and source |
| CDiFfRG::dDG::Assembler< Discretization_, Model_ > | The basic assembler that can be used for any standard DG scheme with flux and source |
| CDiFfRG::FV::KurganovTadmor::Assembler< Discretization_, Model_ > | |
| ►CDiFfRG::LDG::LDGAssemblerBase< Discretization_, Model_ > | |
| CDiFfRG::LDG::Assembler< Discretization_, Model_ > | The LDG assembler that can be used for any LDG scheme, with as many levels as one wants |
| ►CDiFfRG::AbstractAssembler< Vector< double >, SparseMatrix< double >, 0 > | |
| CDiFfRG::Variables::Assembler< Model_ > | The basic assembler that can be used for any standard CG scheme with flux and source |
| CDiFfRG::AbstractFlowingVariables< NumberType > | 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 |
| ►CDiFfRG::AbstractFlowingVariables< Discretization::NumberType > | |
| CDiFfRG::FE::FlowingVariables< Discretization > | 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 |
| ►CDiFfRG::AbstractFlowingVariables< double > | |
| CDiFfRG::FlowingVariables< NT > | 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 |
| ►CDiFfRG::AbstractLinearSolver< SparseMatrixType, VectorType > | |
| CDiFfRG::GMRES< SparseMatrixType, VectorType > | |
| CDiFfRG::UMFPack< SparseMatrixType, VectorType > | |
| ►CDiFfRG::AbstractMinimizer< dim > | Abstract class for minimization in arbitrary dimensions |
| CDiFfRG::GSLSimplexMinimizer< dim > | Minimizer using the Nelder-Mead simplex algorithm from GSL |
| ►CDiFfRG::AbstractMinimizer< 1 > | |
| CDiFfRG::GSLMinimizer1D | Minimizer in 1D using either the golden section, Brent or quadratic method from GSL |
| CDiFfRG::def::AbstractModel< Model, Components_ > | 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 guide |
| CDiFfRG::AbstractRootFinder< dim > | |
| ►CDiFfRG::AbstractRootFinder< 1 > | |
| CDiFfRG::BisectionRootFinder | |
| CDiFfRG::AbstractTimestepper< VectorType_, SparseMatrixType_, dim_ > | 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 |
| ►CAbstractTimestepper< VectorType, dealii::SparseMatrix< get_type::NumberType< VectorType > >, 0 > | |
| CDiFfRG::TimeStepperBoostABM< VectorType, SparseMatrixType, dim > | A class to perform time stepping using the Boost Adams-Bashforth-Moulton method. This stepper uses fixed time steps and is fully explicit |
| CDiFfRG::TimeStepperExplicitEuler< VectorType, SparseMatrixType, dim > | |
| CDiFfRG::TimeStepperRK< VectorType, SparseMatrixType, dim > | |
| ►CDiFfRG::AbstractTimestepper< VectorType, SparseMatrixType, dim > | |
| CDiFfRG::TimeStepperBoostRK< VectorType, SparseMatrixType, dim, prec > | A class to perform time stepping using adaptive Boost Runge-Kutta methods. This stepper uses adaptive time steps and is fully explicit |
| CDiFfRG::TimeStepperImplicitEuler< VectorType, SparseMatrixType, dim, LinearSolver > | |
| CDiFfRG::TimeStepperSUNDIALS_ARKode< VectorType, SparseMatrixType, dim, LinearSolver > | This timestepping class utilizes the ARKode solver from SUNDIALS. It is specifically meant to be used for a spatial discretization which uses implicit timestepping and coupled to additional variables which are evolved explicitly. Therefore, this solver is an ImEx solver and requires the dynamics of the additional variables to be far slower than the dynamics of the spatial discretization. In the used Assembler, the two additional methods residual_variables and set_additional_data must be implemented, which are used to compute the explicit residual and to make the additional variables available to the implicit residual |
| CDiFfRG::TimeStepperSUNDIALS_IDA< VectorType, SparseMatrixType, dim, LinearSolver > | 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 |
| CDiFfRG::TimeStepperSUNDIALS_IDA_ARKode< VectorType, SparseMatrixType, dim, LinearSolver > | This timestepping class utilizes the ARKode solver from SUNDIALS for explicitly evolving the variables and SUNDIALS IDA for implicitly evolving the spatial discretization. In this scheme, the IDA stepper is the controller and the ARKode stepper solves the explicit part of the problem on-demand |
| CDiFfRG::TimeStepperSUNDIALS_IDA_BoostABM< VectorType, SparseMatrixType, dim, LinearSolver > | 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 |
| CDiFfRG::TimeStepperSUNDIALS_IDA_BoostRK< VectorType, SparseMatrixType, dim, LinearSolver, prec > | 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 |
| CDiFfRG::TimeStepperTRBDF2< VectorType, SparseMatrixType, dim, LinearSolver > | |
| CDiFfRG::def::internal::AD_tools< AD_type > | |
| CDiFfRG::def::internal::AD_tools< autodiff::dual > | |
| CDiFfRG::def::internal::AD_tools< autodiff::real > | |
| CDiFfRG::def::ADjacobian_boundary_numflux< Model, AD_type > | |
| ►CDiFfRG::def::ADjacobian_boundary_numflux< Model, autodiff::dual > | |
| CDiFfRG::def::AD_dual< Model > | |
| ►CDiFfRG::def::ADjacobian_boundary_numflux< Model, autodiff::real > | |
| CDiFfRG::def::AD_real< Model > | |
| CDiFfRG::def::FE_AD< Model > | |
| CDiFfRG::def::ADjacobian_extractors< Model, AD_type > | |
| ►CDiFfRG::def::ADjacobian_extractors< Model, autodiff::dual > | |
| CDiFfRG::def::AD_dual< Model > | |
| ►CDiFfRG::def::ADjacobian_extractors< Model, autodiff::real > | |
| CDiFfRG::def::AD_real< Model > | |
| CDiFfRG::def::ADjacobian_flux< Model, AD_type > | |
| ►CDiFfRG::def::ADjacobian_flux< Model, autodiff::dual > | |
| CDiFfRG::def::AD_dual< Model > | |
| ►CDiFfRG::def::ADjacobian_flux< Model, autodiff::real > | |
| CDiFfRG::def::AD_real< Model > | |
| CDiFfRG::def::FE_AD< Model > | |
| CDiFfRG::def::ADjacobian_mass< Model, AD_type > | |
| ►CDiFfRG::def::ADjacobian_mass< Model, autodiff::dual > | |
| CDiFfRG::def::AD_dual< Model > | |
| ►CDiFfRG::def::ADjacobian_mass< Model, autodiff::real > | |
| CDiFfRG::def::AD_real< Model > | |
| CDiFfRG::def::FE_AD< Model > | |
| CDiFfRG::def::ADjacobian_numflux< Model, AD_type > | |
| ►CDiFfRG::def::ADjacobian_numflux< Model, autodiff::dual > | |
| CDiFfRG::def::AD_dual< Model > | |
| ►CDiFfRG::def::ADjacobian_numflux< Model, autodiff::real > | |
| CDiFfRG::def::AD_real< Model > | |
| CDiFfRG::def::FE_AD< Model > | |
| CDiFfRG::def::ADjacobian_source< Model, AD_type > | |
| ►CDiFfRG::def::ADjacobian_source< Model, autodiff::dual > | |
| CDiFfRG::def::AD_dual< Model > | |
| ►CDiFfRG::def::ADjacobian_source< Model, autodiff::real > | |
| CDiFfRG::def::AD_real< Model > | |
| CDiFfRG::def::FE_AD< Model > | |
| CDiFfRG::def::ADjacobian_variables< Model, AD_type > | |
| ►CDiFfRG::def::ADjacobian_variables< Model, autodiff::dual > | |
| CDiFfRG::def::AD_dual< Model > | |
| ►CDiFfRG::def::ADjacobian_variables< Model, autodiff::real > | |
| CDiFfRG::def::AD_real< Model > | |
| ►CArithmeticTraits | |
| Cautodiff::detail::ArithmeticTraits<::cuda::std::__4::complex< T > > | |
| Cintegrators::transforms::Baker | |
| Cintegrators::transforms::BakerImpl< I, D > | |
| CDiFfRG::Interpolation::Barycentric | This class takes in x-dependent data and interpolates it to a given x on request |
| Cintegrators::transforms::detail::Binomial< n, k, typename > | |
| CDiFfRG::BosonicCoordinates1DFiniteT< Idx, NT > | |
| CDiFfRG::BosonicMatsubaraValues< Idx, NT > | |
| CDiFfRG::BosonicRegulator< OPTS > | Implements one of the standard exponential regulators, i.e |
| CDiFfRG::BosonicRegulatorOpts | |
| Cintegrators::core::callback_params_t | |
| CDiFfRG::ComponentDescriptor< _FEFunctionDescriptor, _VariableDescriptor, _ExtractorDescriptor, LDGDescriptors > | A class to describe how many FE functions, additional variables and extractors are used in a model |
| CDiFfRG::ConfigurationHelper | Class to read parameters given from the command line and from a parameter file |
| CDiFfRG::CoordinatePackND< Coordinates > | Utility class for combining multiple coordinate systems into one |
| CDiFfRG::CG::internal::CopyData_I< NumberType > | |
| CDiFfRG::dDG::internal::CopyData_I< NumberType > | |
| CDiFfRG::DG::internal::CopyData_I< NumberType > | |
| CDiFfRG::FV::KurganovTadmor::internal::CopyData_I< NumberType > | |
| CDiFfRG::LDG::internal::CopyData_I< NumberType > | |
| CDiFfRG::CG::internal::CopyData_J< NumberType > | |
| CDiFfRG::dDG::internal::CopyData_J< NumberType > | |
| CDiFfRG::DG::internal::CopyData_J< NumberType > | |
| CDiFfRG::FV::KurganovTadmor::internal::CopyData_J< NumberType > | |
| CDiFfRG::LDG::internal::CopyData_J< NumberType > | |
| CDiFfRG::LDG::internal::CopyData_J_full< NumberType, n_fe_subsystems > | |
| CDiFfRG::CG::internal::CopyData_R< NumberType > | |
| CDiFfRG::dDG::internal::CopyData_R< NumberType > | |
| CDiFfRG::DG::internal::CopyData_R< NumberType > | |
| CDiFfRG::FV::KurganovTadmor::internal::CopyData_R< NumberType > | |
| CDiFfRG::LDG::internal::CopyData_R< NumberType > | |
| CDiFfRG::dDG::internal::CopyData_J< NumberType >::CopyDataFace_J | |
| CDiFfRG::DG::internal::CopyData_J< NumberType >::CopyDataFace_J | |
| CDiFfRG::FV::KurganovTadmor::internal::CopyData_J< NumberType >::CopyDataFace_J | |
| CDiFfRG::LDG::internal::CopyData_J< NumberType >::CopyDataFace_J | |
| CDiFfRG::LDG::internal::CopyData_J_full< NumberType, n_fe_subsystems >::CopyDataFace_J | |
| CDiFfRG::dDG::internal::CopyData_R< NumberType >::CopyDataFace_R | |
| CDiFfRG::DG::internal::CopyData_R< NumberType >::CopyDataFace_R | |
| CDiFfRG::FV::KurganovTadmor::internal::CopyData_R< NumberType >::CopyDataFace_R | |
| CDiFfRG::LDG::internal::CopyData_R< NumberType >::CopyDataFace_R | |
| CDiFfRG::CG::internal::CopyData_I< NumberType >::CopyFaceData_I | |
| CDiFfRG::dDG::internal::CopyData_I< NumberType >::CopyFaceData_I | |
| CDiFfRG::DG::internal::CopyData_I< NumberType >::CopyFaceData_I | |
| CDiFfRG::FV::KurganovTadmor::internal::CopyData_I< NumberType >::CopyFaceData_I | |
| CDiFfRG::LDG::internal::CopyData_I< NumberType >::CopyFaceData_I | |
| CDiFfRG::CsvOutput | A class to output data to a CSV file |
| CDiFfRG::CSVReader | This class reads a .csv file and allows to access the data |
| CDiFfRG::Interpolation::CubicSpline | 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 |
| Cintegrators::core::cuda::detail::cuda_memory< Tin > | |
| CDiFfRG::DataOutput< dim, VectorType > | Class to manage writing to files. FEM functions are written to vtk files and other data is written to csv files |
| CDiFfRG::DataOutput< 0, Vector< double > > | |
| CDiFfRG::CG::Discretization< Components_, NumberType_, Mesh_ > | Class to manage the system on which we solve, i.e. fe spaces, grids, etc. This class is a System for CG systems |
| CDiFfRG::DG::Discretization< Components_, NumberType_, Mesh_ > | 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 |
| CDiFfRG::FV::Discretization< Components_, NumberType_, Mesh_ > | Class to manage the system on which we solve, i.e. fe spaces, grids, etc. This class is a System for FV systems |
| CDiFfRG::LDG::Discretization< Components_, NumberType_, Mesh_ > | 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) |
| CDiFfRG::AbstractTimestepper< VectorType_, SparseMatrixType_, dim_ >::explicitParameters | |
| CDiFfRG::ExponentialRegulator< OPTS > | Implements one of the standard exponential regulators, i.e |
| CDiFfRG::ExponentialRegulatorOpts | |
| CDiFfRG::ExternalDataInterpolator | This class takes in a .csv file with x-dependent data and interpolates it to a given x on request |
| Cintegrators::transforms::detail::Factorial< n, typename > | |
| Cintegrators::transforms::detail::Factorial< n, typename std::enable_if< n==0 >::type > | |
| ►Cstd::false_type | |
| CDiFfRG::is_complex< T > | |
| Cintegrators::core::has_batching_impl< I, T, D, U, typename > | |
| CDiFfRG::FEOutput< dim, VectorType > | A class to output finite element data to disk as .vtu files and .pvd time series |
| CDiFfRG::FEOutput< 0, Vector< double > > | |
| CDiFfRG::FermionicCoordinates1DFiniteT< Idx, NT > | |
| CDiFfRG::FermionicMatsubaraValues< Idx, NT > | |
| CDiFfRG::FixedString< N > | A fixed size compile-time string |
| CDiFfRG::def::FlowBoundaries< Model > | |
| CDiFfRG::def::FlowDirections< n > | |
| CDiFfRG::FlowEquations | |
| CDiFfRG::FlowEquationsFiniteT | |
| CDiFfRG::def::fRG | Used to keep track of the RG time and the cutoff scale |
| ►CFunction | |
| CDiFfRG::internal::FunctionFromLambda< dim, NumberType > | |
| CDiFfRG::Integrator4DQMC< NT, KERNEL >::Functor< Args > | |
| CDiFfRG::IntegratorAngleQMC< d, NT, KERNEL >::Functor< Args > | |
| CDiFfRG::IntegratorQMC< d, NT, KERNEL >::Functor< Args > | |
| CDiFfRG::Integrator1DCartesianGPU< NT, KERNEL >::functor< T > | Custom functor for the thrust::transform_reduce function |
| CDiFfRG::Integrator4DGPU_fq< NT, KERNEL, q1, q2 >::functor< T > | |
| CDiFfRG::IntegratorGPU< d, NT, KERNEL >::functor< T > | Custom functor for the thrust::transform_reduce function |
| CDiFfRG::GLQuadrature< N, ctype > | |
| CDiFfRG::GLQuadrature< 1, ctype > | |
| CDiFfRG::GLQuadrature< 10, ctype > | |
| CDiFfRG::GLQuadrature< 11, ctype > | |
| CDiFfRG::GLQuadrature< 12, ctype > | |
| CDiFfRG::GLQuadrature< 128, ctype > | |
| CDiFfRG::GLQuadrature< 13, ctype > | |
| CDiFfRG::GLQuadrature< 14, ctype > | |
| CDiFfRG::GLQuadrature< 15, ctype > | |
| CDiFfRG::GLQuadrature< 16, ctype > | |
| CDiFfRG::GLQuadrature< 2, ctype > | |
| CDiFfRG::GLQuadrature< 20, ctype > | |
| CDiFfRG::GLQuadrature< 24, ctype > | |
| CDiFfRG::GLQuadrature< 3, ctype > | |
| CDiFfRG::GLQuadrature< 32, ctype > | |
| CDiFfRG::GLQuadrature< 4, ctype > | |
| CDiFfRG::GLQuadrature< 48, ctype > | |
| CDiFfRG::GLQuadrature< 5, ctype > | |
| CDiFfRG::GLQuadrature< 6, ctype > | |
| CDiFfRG::GLQuadrature< 64, ctype > | |
| CDiFfRG::GLQuadrature< 7, ctype > | |
| CDiFfRG::GLQuadrature< 8, ctype > | |
| CDiFfRG::GLQuadrature< 9, ctype > | |
| CDiFfRG::GLQuadrature< 96, ctype > | |
| CDiFfRG::AbstractTimestepper< VectorType_, SparseMatrixType_, dim_ >::implicitParameters | |
| CDiFfRG::IndexStack< Idx > | |
| ►Cstd::integral_constant | |
| Cstd::tuple_size< DiFfRG::named_tuple< tuple_type, strs... > > | |
| CDiFfRG::Integrator1DCartesianGPU< NT, KERNEL > | Integration of an arbitrary 1D function from qx_min to qx_max using CUDA |
| CDiFfRG::Integrator1DCartesianTBB< NT, KERNEL > | Integration of an arbitrary 1D function from qx_min to qx_max using TBB |
| CDiFfRG::Integrator2DCartesianGPU< NT, KERNEL > | Integration of an arbitrary 2D function from (qx_min, qy_min) to (qx_max, qy_max) using TBB |
| CDiFfRG::Integrator2DCartesianTBB< NT, KERNEL > | Integration of an arbitrary 2D function from (qx_min, qy_min) to (qx_max, qy_max) using TBB |
| CDiFfRG::Integrator2Dpq0GPU< NT, KERNEL > | Integrator for 2+1D integrals over p, q0 and an angle on the GPU. Calculates |
| CDiFfRG::Integrator2Dpq0TBB< NT, KERNEL > | Integrator for 2+1D integrals over p, q0 and an angle using TBB. Calculates |
| CDiFfRG::Integrator2Dpx0GPU< NT, KERNEL > | Integrator for 2+1D integrals over p, x0 and an angle using the GPU. Calculates |
| CDiFfRG::Integrator2Dpx0TBB< NT, KERNEL > | Integrator for 2+1D integrals over p, x0 and an angle using TBB. Calculates |
| CDiFfRG::Integrator3DCartesianGPU< NT, KERNEL > | |
| CDiFfRG::Integrator3DCartesianTBB< NT, KERNEL > | |
| CDiFfRG::Integrator3DGPU< NT, KERNEL > | |
| CDiFfRG::Integrator3Dpq0GPU< NT, KERNEL > | |
| CDiFfRG::Integrator3Dpq0TBB< NT, KERNEL > | |
| CDiFfRG::Integrator3Dpx0GPU< NT, KERNEL > | |
| CDiFfRG::Integrator3Dpx0TBB< NT, KERNEL > | |
| CDiFfRG::Integrator3DTBB< NT, KERNEL > | |
| CDiFfRG::Integrator4D2AngGPU< NT, KERNEL > | GPU integrator for the integration of a 4D function with two angles with CUDA. Calculates |
| CDiFfRG::Integrator4D2AngTBB< NT, KERNEL > | Integrator for the integration of a 4D function with two angles with CUDA. Calculates |
| CDiFfRG::Integrator4DFiniteTq0GPU< NT, KERNEL > | |
| CDiFfRG::Integrator4DFiniteTq0TBB< NT, KERNEL > | |
| CDiFfRG::Integrator4DFiniteTx0GPU< NT, KERNEL > | |
| CDiFfRG::Integrator4DFiniteTx0TBB< NT, KERNEL > | |
| CDiFfRG::Integrator4DGPU< NT, KERNEL > | GPU integrator for the integration of a 4D function with three angles with CUDA. Calculates |
| CDiFfRG::Integrator4DGPU_fq< NT, KERNEL, q1, q2 > | |
| CDiFfRG::Integrator4DOACC< NT, KERNEL > | |
| CDiFfRG::Integrator4DQMC< NT, KERNEL > | GPU integrator for the integration of a 4D function with three angles with quasi-Monte-Carlo. Calculates |
| CDiFfRG::Integrator4DTBB< NT, KERNEL > | Integrator for the integration of a 4D function with three angles with TBB. Calculates |
| CDiFfRG::IntegratorAngleFiniteTq0GPU< d, NT, KERNEL > | |
| CDiFfRG::IntegratorAngleFiniteTq0TBB< d, NT, KERNEL > | |
| CDiFfRG::IntegratorAngleFiniteTx0GPU< d, NT, KERNEL > | |
| CDiFfRG::IntegratorAngleFiniteTx0TBB< d, NT, KERNEL > | |
| CDiFfRG::IntegratorAngleGPU< d, NT, KERNEL > | GPU integrator for the integration of a function with one angle with CUDA. Calculates |
| CDiFfRG::IntegratorAngleQMC< d, NT, KERNEL > | GPU integrator for the integration of a function with one angle with quasi-Monte-Carlo. Calculates |
| CDiFfRG::IntegratorAngleTBB< d, NT, KERNEL > | Integrator for the integration of a function with one angle with TBB. Calculates |
| CDiFfRG::IntegratorConstant< d, NT, KERNEL > | |
| CDiFfRG::IntegratorFiniteTq0GPU< d, NT, KERNEL > | |
| CDiFfRG::IntegratorFiniteTq0TBB< d, NT, KERNEL > | |
| CDiFfRG::IntegratorFiniteTx0GPU< d, NT, KERNEL > | |
| CDiFfRG::IntegratorFiniteTx0TBB< d, NT, KERNEL > | |
| CDiFfRG::IntegratorGPU< d, NT, KERNEL > | |
| CDiFfRG::IntegratorQMC< d, NT, KERNEL > | |
| CDiFfRG::IntegratorTBB< d, NT, KERNEL > | |
| Cintegrators::transforms::detail::IPow< D, n, typename > | |
| Cintegrators::transforms::detail::IPow< D, n, typename std::enable_if< n%2 !=0 &&n !=0 >::type > | |
| Cintegrators::transforms::detail::IPow< D, n, typename std::enable_if< n==0 >::type > | |
| CDiFfRG::JSONValue | A wrapper around the boost json value class |
| CDiFfRG::KINSOL< VectorType_ > | A newton solver, using local error estimates for each vector component |
| Cintegrators::transforms::Korobov< r0, r1 > | |
| Cintegrators::transforms::detail::KorobovCoefficient< D, k, a, b, typename > | |
| Cintegrators::transforms::detail::KorobovCoefficient< D, k, a, b, typename std::enable_if< k==0 >::type > | |
| Cintegrators::transforms::KorobovImpl< I, D, r0, r1 > | |
| Cintegrators::transforms::detail::KorobovTerm< D, k, a, b, typename > | |
| Cintegrators::transforms::detail::KorobovTerm< D, k, a, b, typename std::enable_if< k==0 >::type > | |
| CDiFfRG::def::LDGUpDownFluxes< Model, Collections > | |
| Cintegrators::core::least_squares_wrapper_t< D, F1, F2, F3 > | |
| CDiFfRG::LinearCoordinates1D< NT > | |
| CDiFfRG::LinearInterpolator1D< NT, Coordinates > | A linear interpolator for 1D data, both on GPU and CPU |
| CDiFfRG::LinearInterpolator2D< NT, Coordinates > | A linear interpolator for 2D data, both on GPU and CPU |
| CDiFfRG::LinearInterpolator3D< NT, Coordinates > | A linear interpolator for 3D data, both on GPU and CPU |
| CDiFfRG::LitimRegulator< Dummy > | Implements the Litim regulator, i.e |
| CDiFfRG::def::LLFFlux< Model > | |
| CDiFfRG::LogarithmicCoordinates1D< NT > | |
| CDiFfRG::MatsubaraQuadrature< NT > | A quadrature rule for (bosonic) Matsubara frequencies, based on the method of Monien [1]. This class provides nodes and weights for the summation |
| CDiFfRG::internal::MatsubaraStorage | 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 |
| CDiFfRG::named_tuple< tuple_type, strs > | 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 |
| CDiFfRG::NDBlock< _str, _val > | |
| CDiFfRG::Newton< VectorType_ > | A newton solver, using local error estimates for each vector component |
| CDiFfRG::def::NoJacobians | |
| Cintegrators::fitfunctions::None | |
| Cintegrators::transforms::None | |
| Cintegrators::fitfunctions::NoneFunction< D > | |
| Cintegrators::fitfunctions::NoneImpl< I, D, M > | |
| Cintegrators::transforms::NoneImpl< I, D > | |
| Cintegrators::fitfunctions::NoneTransform< I, D, M > | |
| CDiFfRG::def::NoNumFlux< Model > | |
| CDiFfRG::Polynomial | A class representing a polynomial |
| CDiFfRG::PolynomialExpRegulator< OPTS > | Implements a regulator given by |
| CDiFfRG::PolynomialExpRegulatorOpts | |
| Cintegrators::fitfunctions::PolySingular | |
| Cintegrators::fitfunctions::PolySingularFunction< D > | |
| Cintegrators::fitfunctions::PolySingularHessian< D > | |
| Cintegrators::fitfunctions::PolySingularImpl< I, D, M > | |
| Cintegrators::fitfunctions::PolySingularJacobian< D > | |
| Cintegrators::fitfunctions::PolySingularTransform< I, D, M > | |
| Cintegrators::Qmc< T, D, M, P, F, G, H > | |
| Cintegrators::Qmc< NT, ctype, 1, integrators::transforms::NoneImpl > | |
| Cintegrators::Qmc< NT, ctype, 2, integrators::transforms::NoneImpl > | |
| Cintegrators::Qmc< NT, ctype, 4, integrators::transforms::NoneImpl > | |
| CDiFfRG::Quadrature< NT > | |
| CDiFfRG::QuadratureProvider | A class that provides quadrature points and weights, in host and device memory. The quadrature points and weights are computed either the GSL quadratures or the MatsubaraQuadrature class. This avoids recomputing the quadrature points and weights for each integrator |
| CDiFfRG::internal::QuadratureStorage | 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 |
| CDiFfRG::RationalExpRegulator< OPTS > | Implements a regulator given by |
| CDiFfRG::RationalExpRegulatorOpts | |
| CDiFfRG::RectangularMesh< dim_ > | 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 |
| ►Cstd::reference_wrapper | |
| Cintegrators::Logger | |
| Cintegrators::result< T > | |
| ►Cstd::runtime_error | |
| Cintegrators::core::cuda::detail::cuda_error | |
| Cintegrators::samples< T, D > | |
| CDiFfRG::CG::internal::ScratchData< Discretization > | Class to hold data for each assembly thread, i.e. FEValues for cells, interfaces, as well as pre-allocated data structures for the solutions |
| CDiFfRG::dDG::internal::ScratchData< Discretization > | Class to hold data for each assembly thread, i.e. FEValues for cells, interfaces, as well as pre-allocated data structures for the solutions |
| CDiFfRG::DG::internal::ScratchData< Discretization > | Class to hold data for each assembly thread, i.e. FEValues for cells, interfaces, as well as pre-allocated data structures for the solutions |
| CDiFfRG::FV::KurganovTadmor::internal::ScratchData< Discretization > | Class to hold data for each assembly thread, i.e. FEValues for cells, interfaces, as well as pre-allocated data structures for the solutions |
| CDiFfRG::LDG::internal::ScratchData< Discretization > | Class to hold data for each assembly thread, i.e. FEValues for cells, interfaces, as well as pre-allocated data structures for the solutions |
| Cintegrators::transforms::Sidi< r0 > | |
| Cintegrators::transforms::detail::SidiCoefficient< D, k, r, typename > | |
| Cintegrators::transforms::detail::SidiCoefficient< D, k, r, typename std::enable_if<(r % 2) !=0 >::type > | |
| Cintegrators::transforms::detail::SidiCoefficient< D, k, r, typename std::enable_if<(r % 2)==0 >::type > | |
| Cintegrators::transforms::SidiImpl< I, D, r, typename > | |
| Cintegrators::transforms::SidiImpl< I, D, r, typename std::enable_if< r==0 >::type > | |
| Cintegrators::transforms::SidiImpl< I, D, r, typename std::enable_if<(r % 2) !=0 &&(r !=0)>::type > | |
| Cintegrators::transforms::SidiImpl< I, D, r, typename std::enable_if<(r % 2)==0 &&(r !=0)>::type > | |
| Cintegrators::transforms::detail::SidiTerm< D, k, r, typename > | |
| Cintegrators::transforms::detail::SidiTerm< D, k, r, typename std::enable_if<((r % 2) !=0) &&(k==0)>::type > | |
| Cintegrators::transforms::detail::SidiTerm< D, k, r, typename std::enable_if<((r % 2)==0) &&(k==0)>::type > | |
| Cintegrators::transforms::detail::SidiTerm< D, k, r, typename std::enable_if<(r % 2) !=0 &&(k !=0)>::type > | |
| Cintegrators::transforms::detail::SidiTerm< D, k, r, typename std::enable_if<(r % 2)==0 &&(k !=0)>::type > | |
| CDiFfRG::SimpleMatrix< NT, N, M > | A simple NxM-matrix class, which is used for cell-wise Jacobians |
| CDiFfRG::SmoothedLitimRegulator< OPTS > | Implements one of the standard exponential regulators, i.e |
| CDiFfRG::SmoothedLitimRegulatorOpts | |
| CDiFfRG::stepperChoice< prec > | |
| CDiFfRG::SubDescriptor< _descriptors > | |
| ►CDiFfRG::TC_Default< NEWT > | 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 |
| CDiFfRG::TC_PI< NEWT > | 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 |
| CDiFfRG::TexLinearInterpolator1D< NT, Coordinates > | A linear interpolator for 1D data, using texture memory on the GPU and floating point arithmetic on the CPU |
| CDiFfRG::TexLinearInterpolator1DStack< NT, Coordinates, max_stack_size > | A linear interpolator for 1D data, using texture memory on the GPU and floating point arithmetic on the CPU |
| CDiFfRG::TexLinearInterpolator2D< NT, Coordinates > | A linear interpolator for 2D data, using texture memory on the GPU and floating point arithmetic on the CPU |
| CDiFfRG::TexLinearInterpolator3D< NT, Coordinates > | A linear interpolator for 3D data, using texture memory on the GPU and floating point arithmetic on the CPU |
| CDiFfRG::def::Time | |
| ►Cstd::true_type | |
| CDiFfRG::is_complex< complex< T > > | |
| CDiFfRG::is_complex< cxreal< N, T > > | |
| Cintegrators::core::has_batching_impl< I, T, D, U, std::void_t< decltype(std::declval< I >().operator()(std::declval< D * >(), std::declval< T * >(), std::declval< U >()))> > | |
| CDiFfRG::def::UpDown< n > | |
| CDiFfRG::def::UpDownFlux< T > | |
1.12.0