| Ndft | |
| ▼Ndftefe | Dealii includes |
| ►Natoms | |
| ►NAtomSphericalDataEnrichmentXMLLocal | |
| CXPathInfo | |
| NAtomSphericalDataPSPXMLLocal | |
| ►NAtomSphericalElectronicDataXMLLocal | |
| CXPathInfo | |
| NBoostAutoDiffInternal | |
| NSphericalDataAnalyticalInternal | |
| NSphericalDataMixedInternal | |
| NSphericalDataNumericalInternal | |
| NSphericalHarmonicFunctionsInternal | |
| CAtomSevereFunction | |
| CAtomSevereFuncType | |
| CAtomSphDataPSPDefaults | |
| CAtomSuperpositionFunction | |
| CAtomTCIASpline | |
| COverlappingAtomIds | Class to get the Ids of the Atoms overlapping a particular Processor for a particular field. Each Processor stores info of all the atoms |
| CSphericalData | |
| CSphericalDataAnalytical | |
| CSphericalDataDefaults | |
| CSphericalDataMixed | |
| ►CSphericalDataNumerical | |
| CFunc | |
| CSphericalHarmonicFunctions | |
| CTCIADataParams | |
| ►Nbasis | |
| NAtomCenterNonLocalOpContextFEInternal | |
| NAtomIdsPartitionInternal | |
| NCFEBasisDataStorageDealiiInternal | |
| NCFEBasisDofHandlerInternal | |
| NCFEBDSOnTheFlyComputeDealiiInternal | |
| ►NCFEOverlapInverseOpContextGLLInternal | |
| COverlapMatrixInverseLinearSolverFunctionFE | |
| NCFEOverlapOperatorContextInternal | |
| NEFEBasisDataStorageDealiiInternal | |
| NEFEBasisDofHandlerInternal | |
| NEFEBDSOnTheFlyComputeDealiiInternal | |
| NEnrichmentIdsPartitionInternal | |
| NFEBasisManagerInternal | |
| NGenerateMeshInternal | |
| NL2ProjectionLinearSolverFunctionInternal | |
| NOEFEAtomBlockOverlapInvOpContextGLLInternal | |
| ►NOrthoEFEOverlapInverseOpContextGLLInternal | |
| COverlapMatrixInverseLinearSolverFunctionFE | |
| NOrthoEFEOverlapOperatorContextInternal | |
| NPristineEFEOverlapOperatorContextInternal | |
| Nrealspace | |
| CAtomCenterNonLocalOpContextFE | |
| CAtomIdsPartition | Class to get the renumbered Ids of the locally owned Atom ids returns the vector of no of atoms in each processor and the vector of old atom ids. so oldatomid(0) = 2 and so on. So also newatomid(2) = 0; but you do not need to store as oldatomid vector is same as newatomid i.e. memory layout should be 'locally owned enriched ids' should be consecutive integers |
| CBasisDataStorage | An abstract class to store and access data for a given basis, such as the basis function values on a quadrature grid, the overlap matrix of the basis, etc |
| CBasisDataStorageDefaults | |
| CBasisDofHandler | |
| CBasisManager | An abstract class to encapsulate the partitioning of a basis across multiple processors |
| CBasisOperations | |
| CCellMappingBase | An abstract class to map a real point to parametric point and vice-versa |
| CCFEBasisDataStorageDealii | An abstract class to store and access data for a given basis, such as the basis function values on a quadrature grid, the overlap matrix of the basis, etc |
| CCFEBasisDofHandlerDealii | |
| CCFEBDSOnTheFlyComputeDealii | An abstract class to store and access data for a given basis, such as the basis function values on a quadrature grid, the overlap matrix of the basis, etc |
| CCFEConstraintsLocalDealii | |
| CCFEOverlapInverseOpContextGLL | |
| CCFEOverlapOperatorContext | A derived class of linearAlgebra::OperatorContext to encapsulate the action of a discrete operator on vectors, matrices, etc |
| CConstraintsInternal | |
| CConstraintsLocal | |
| CDealiiFEEvaluationWrapper | |
| CECIDefaults | |
| CEFEBasisDataStorage | An abstract class to store and access data for a given basis, such as the basis function values on a quadrature grid, the overlap matrix of the basis, etc |
| CEFEBasisDataStorageDealii | An abstract class to store and access data for enriched fe basis, such as the basis function values on a quadrature grid, the overlap matrix of the basis, etc |
| CEFEBasisDofHandler | |
| CEFEBasisDofHandlerDealii | |
| CEFEBDSOnTheFlyComputeDealii | An abstract class to store and access data for a given basis, such as the basis function values on a quadrature grid, the overlap matrix of the basis, etc |
| CEFEConstraintsLocalDealii | |
| CEnrichmentClassicalInterfaceSpherical | Class to get the interface between Classical and Enrichment basis. It takes as the classical basis as input. The main functionalities of the class are: |
| CEnrichmentDataEvalKernels | |
| CEnrichmentFunctionManagerAtomCenteredNumerical | A class which provides access to spherical atom-centered enrichment functions, with the radial part given numerically on a grid. This specifically assumes the dimensionality of the problem to be 3. Thus, an enrichment function \(
N^{\boldsymbol{\textbf{R}}}(\boldsymbol{\textbf{r}})\), centered on a point \(\boldsymbol{\textbf{R}}\) can be written as |
| CEnrichmentIdAttribute | |
| CEnrichmentIdsPartition | Class to get the gost and locally owned enrichment ids from the renumbered atom ids in Atom Partition i.e. memory layout should be 'locally owned enrichment ids which would be contiguous' -> 'ghost enrichment ids' The class gives us the vector of cell enrichment Ids, locallyowned enrichment ids range, ghost enrichment ids |
| CEnrichmentManager | Base class which provides access to the enrichment functions |
| CFEBasisDataStorage | An abstract class to store and access data for a given basis, such as the basis function values on a quadrature grid, the overlap matrix of the basis, etc |
| CFEBasisDofHandler | |
| CFEBasisManager | An abstract class to encapsulate the partitioning of a finite element basis across multiple processors |
| CFEBasisOperations | |
| CFECellBase | An abstract class for a finite element cell (can be of any dimension) This is created primarily to be a wrapper around deal.ii cells, so as to avoid the cascading of template parameters |
| CFECellDealii | |
| CFECellWiseDataOperations | |
| CFEEvaluationWrapperBase | |
| CFEEvaluationWrapperDerived | |
| CField | |
| CGenerateMesh | |
| CGenerateMeshDefaults | |
| CL2ProjectionDefaults | |
| CL2ProjectionLinearSolverFunction | A derived class of linearAlgebra::LinearSolverFunction to encapsulate the L2 Projecton partial differential equation (PDE) discretized in a finite element (FE) basis |
| CLinearCellMappingDealii | |
| CMaxSizeDefaults | |
| COEFEAtomBlockOverlapInvOpContextGLL | |
| COrthoEFEOverlapInverseOpContextGLL | |
| COrthoEFEOverlapOperatorContext | A derived class of linearAlgebra::OperatorContext to encapsulate the action of a discrete operator on vectors, matrices, etc. for enriched basis |
| CParentToChildCellsManagerBase | |
| CParentToChildCellsManagerDealii | |
| CPristineEFEOverlapOperatorContext | A derived class of linearAlgebra::OperatorContext to encapsulate the action of a discrete operator on vectors, matrices, etc. for enriched basis |
| CTriangulationBase | An abstract class for the triangulation class. The derived class specialises this class to dealii and otehr specialisations if required |
| CTriangulationCellBase | An abstract class for an geometric cell. This is done to prevent the template (as required by deal.ii objects) to propagate all across the code, |
| CTriangulationCellDealii | An interface to deal.ii geometric cell |
| CTriangulationDealiiParallel | |
| CTriangulationDealiiSerial | |
| ►Nelectrostatics | |
| NLaplaceOperatorContextFEInternal | |
| NPoissonLinearSolverFunctionFEInternal | |
| NPoissonSolverDealiiMatrixFreeFEInternal | |
| CLaplaceOperatorContextFE | A derived class of linearAlgebra::OperatorContext to encapsulate the action of a discrete operator on vectors, matrices, etc |
| CPoissonLinearSolverFunctionFE | A derived class of linearAlgebra::LinearSolverFunction to encapsulate the Poisson partial differential equation (PDE) discretized in a finite element (FE) basis. The Possion PDE is given as: \(\nabla^2 v(\textbf{r}) = -4 \pi \rho(\textbf{r})$\f
with the boundary condition on
\)@_fakenlv(\textbf{r})|_{\partial \Omega}=g(\textbf{r})$\f ( \(\\partial Omega$\f denoting the boundary of a domain \)\Omega$\f). Here \(v$\f has the physical notion of a potential (e.g.,
Hartree potential, nuclear potential, etc.) arising due to a charge
distributin \)\rho$\f |
| CPoissonSolverDealiiMatrixFreeFE | A derived class of linearAlgebra::LinearSolverFunction to encapsulate the Poisson partial differential equation (PDE) discretized in a finite element (FE) basis. The Possion PDE is given as: \(\nabla^2 v(\textbf{r}) = -4 \pi \rho(\textbf{r})$\f
with the boundary condition on
\)@_fakenlv(\textbf{r})|_{\partial \Omega}=g(\textbf{r})$\f ( \(\\partial Omega$\f denoting the boundary of a domain \)\Omega$\f). Here \(v$\f has the physical notion of a potential (e.g.,
Hartree potential, nuclear potential, etc.) arising due to a charge
distributin \)\rho$\f |
| ►Nksdft | |
| NElectrostaticLocalFEInternal | |
| Ninternal | |
| NKohnShamDFTInternal | |
| NKohnShamOperatorContextFEInternal | |
| CBisectionSolverDefaults | |
| CConstants | |
| CDensityCalculator | |
| CDensityCalculatorKernels | |
| CElectroHamiltonianDefaults | |
| CElectrostaticExcFE | |
| CElectrostaticFE | A derived class of linearAlgebra::OperatorContext to encapsulate the action of a discrete operator on vectors, matrices, etc |
| CElectrostaticLocalFE | |
| CElectrostaticONCVNonLocFE | |
| CEnergy | |
| CExcDensityGGAClass | |
| CExcDensityLDAClass | |
| CExchangeCorrelationFE | |
| CExcManager | |
| CExcSSDFunctionalBaseClass | This class provides the structure for all Exc functionals that can be written as a combination of functional of Single Slater determinant that results in a non-multiplicative potential plus a remainder functional dependent on density and Tau |
| CExcTauMGGAClass | |
| CFractionalOccupancyFunction | |
| CHamiltonian | |
| CHamiltonianSpinBlockCopyKernels | |
| CKineticFE | |
| CKohnShamDFT | |
| CKohnShamEigenSolver | |
| CKohnShamOperatorContextFE | A derived class of linearAlgebra::OperatorContext to encapsulate the action of a discrete Kohn-Sham operator on vectors |
| CKSDFTDefaults | |
| CLibxcDefaults | |
| CLinearEigenSolverDefaults | |
| CMaxSizeDefaults | |
| CMixingDefaults | |
| CMixingScheme | This class performs the anderson mixing in a variable agnostic way This class takes can take different input variables as input in a std::vector format and computes the mixing coefficients These coefficients can then be used to compute the new variable at the start of the SCF |
| CNewtonRaphsonSolverDefaults | |
| CPoissonProblemDefaults | |
| CRDM1 | Abstract class for the one-particle reduced density matrix |
| CRDM1Access | Resource Acquisition Is Initialization (RAII) wrapper that temporarily holds the SpectralRep moved out of an RDM1Spectral. On destruction (or returnBack()) the rep is returned via setSpectral() |
| CRDM1FE | Class to store the one-particle reduced density matrix using its spectral (eigen) representation in the finite-element basis |
| CRDM1Mixing | RDM1 implementation that performs Anderson mixing of the electron density. Derives directly from RDM1 — no spectral decomposition |
| CRDM1Spectral | Intermediate abstract class that stores the spectral (eigen) decomposition of the one-particle reduced density matrix — KS orbitals, occupancies, and orbital count via a SpectralRep bundle. Concrete subclasses (e.g. RDM1FE) implement getDescriptors() and getDensityObs() using this stored data |
| CSpectralRep | Plain data bundle holding the KS spectral decomposition: orbitals, occupancies (one vector per k-point/spin), and orbital count |
| CTCIADataDefaults | |
| ►NlinearAlgebra | |
| ►NblasLapack | |
| ►NblasLapackKernelsInternal | |
| CScalarProduct | |
| CScalarProduct< T1, T2, ScalarOp::Conj, ScalarOp::Conj > | |
| CScalarProduct< T1, T2, ScalarOp::Conj, ScalarOp::Identity > | |
| CScalarProduct< T1, T2, ScalarOp::Identity, ScalarOp::Conj > | |
| NblasWrapper | |
| NlapackWrapper | |
| ►NtypeInternal | |
| Creal_type_traits | |
| Creal_type_traits< std::complex< T > > | |
| Creal_type_traits< T > | |
| Creal_type_traits< T1, Types... > | |
| Cscalar_type_traits | |
| Cscalar_type_traits< std::complex< T1 >, std::complex< T2 > > | |
| Cscalar_type_traits< std::complex< T1 >, T2 > | |
| Cscalar_type_traits< T > | |
| Cscalar_type_traits< T1, std::complex< T2 > > | |
| Cscalar_type_traits< T1, T2 > | |
| Cscalar_type_traits< T1, T2, Types... > | |
| CCopyKernelOneValueType | |
| CCopyKernelTwoValueTypes | |
| CKernelsOneValueType | |
| CKernelsTwoValueTypes | Namespace class for BlasLapack kernels not present in blaspp |
| NCGLinearSolverInternal | |
| NelpaScalaOpInternal | |
| NLAPACKSupport | |
| NmultiVectorOpsInternal | |
| NOrthonormalizationFunctionsInternal | |
| Ntypes | |
| CBisectionError | |
| CBisectionErrorMsg | |
| CBisectionSolver | A class that implements the bisection method to find the root of a function, given an interval known to bracket it. Unlike NewtonRaphsonSolver, bisection only ever evaluates getValue() (never a derivative), so it cannot diverge - each iteration halves the bracket that is guaranteed to contain the root. This makes it a safe way to localize a root before handing off to NewtonRaphsonSolver for fast final convergence, mirroring DFT-FE's Fermi energy solver (src/dft/fermiEnergy.cc), which bisects before running Newton-Raphson |
| CBisectionSolverFunction | Interface a class must implement to have its root found by BisectionSolver. Unlike NewtonRaphsonSolverFunction, no derivative (getForce) is required - bisection only ever evaluates getValue(), which is what makes it immune to sharply-peaked or vanishing derivatives that can send Newton-Raphson to +-infinity |
| CChebyshevFilteredEigenSolver | A derived class of OperatorContext to encapsulate the action of a discrete operator on vectors, matrices, etc |
| CEigenSolverError | |
| CEigenSolverErrorMsg | |
| CElpaScalapackManager | Manager class for ELPA and ScaLAPACK |
| CIdentityOperatorContext | Abstract class to encapsulate the action of a discrete operator on vectors, matrices, etc |
| CJacobiPreconditioner | A class to encapsulate the Jacobi preconditioner in a linear or non-linear solve |
| CLanczosExtremeEigenSolver | A derived class of OperatorContext to encapsulate the action of a discrete operator on vectors, matrices, etc |
| CLapackError | |
| CLapackErrorMsg | A class to map Error to a message |
| CLinAlgOpContext | |
| CLinAlgOpContextDefaults | |
| CLinearAlgebraProfiler | |
| CLinearSolverDefaults | |
| CLinearSolverError | |
| CLinearSolverErrorMsg | A class to map Error to a message |
| CLinearSolverImpl | Abstract class that implements the LinearSolver algorithm. For example, the derived classes of it, such as CGLinearSolver, GMRESLinearSolver implement the Conjugate-Gradient (CG) and Generalized Minimum Residual (GMRES) Krylov subspace based approches, respectively, to solve a linear system of equations |
| CMultiPassOrthoDefaults | |
| CMultiVector | An class template to encapsulate a MultiVector. A MultiVector is a collection of \(N\) vectors belonging to the same finite-dimensional vector space, where usual notion of vector size denotes the dimension of the vector space. Note that this in the mathematical sense and not in the sense of an multi-dimensional array.The MultiVector is stored contiguously with the vector index being the fastest index, or in other words a matrix of size \(M \times N\) in row major format with \(M \) denoting the dimension of the vector space (size of individual vector) |
| CMultiVectorOps | Stateless class of static functions for spin-aware projection and rotation of product-space multivectors |
| CMultiVectorProductSpace | MultiVector for product spaces: flat layout M × S × N where S = numSpaces, N = numVectorsPerSpace |
| CMultiVectorProductSpaceBlocked | Type-tag subclass of MultiVectorProductSpace for collinear spin (S=2) |
| CMultivectorScratch | Shared scratch MultiVectors (large-batch and small-batch variants) that can be reused across ChebyshevFilteredEigenSolver, OrthonormalizationFunctions, RayleighRitzEigenSolver, and KohnShamEigenSolver to avoid redundant GPU allocations |
| CNewtonRaphsonError | |
| CNewtonRaphsonErrorMsg | |
| CNewtonRaphsonSolver | A class that implements the Newton-Raphson solver to find root of a function |
| CNewtonRaphsonSolverFunction | |
| COperatorContext | Abstract class to encapsulate the action of a discrete operator on vectors, matrices, etc |
| COrthonormalizationError | |
| COrthonormalizationErrorMsg | |
| COrthonormalizationFunctions | |
| CPreconditioner | Abstract class to encapsulate a preconditioner |
| CPreconditionerJacobi | Class to encapsulate the Jacobi preconditioner |
| CPreconditionerNone | Class to encapsulate the NONE preconditioner. Just takes in a vector and returns it |
| CPrintControlDefaults | |
| CProcessGrid | |
| CRayleighRitzDefaults | |
| CRayleighRitzEigenSolver | A derived class of OperatorContext to encapsulate the action of a discrete operator on vectors, matrices, etc |
| CScalapackError | |
| CScalapackErrorMsg | A class to map Error to a message |
| CScaLAPACKMatrix | Scalapack wrapper adapted from dealii library and extended implementation to complex datatype |
| CVector | A class that encapsulates a vector. This is a vector in the mathematical sense and not in the sense of an array or STL container. This class handles both serial and distributed vector in a unfied way. There are different constructors provided for the serial and distributed case |
| CVectorAttributes | |
| ►Nquadrature | |
| NQuadratureValuesContainerInternal | |
| CFuncEvalTag | |
| CQuadraturePointAttributes | Class to store the attributes of a quad point, such as the cell Id it belongs, the quadPointId within the cell it belongs to, and the quadrature rule (defined by quadratureRuleId) it is part of |
| CQuadratureRule | |
| CQuadratureRuleAdaptive | |
| CQuadratureRuleAdaptiveDefaults | |
| CQuadratureRuleAttributes | |
| CQuadratureRuleAttributesDefaults | |
| CQuadratureRuleContainer | |
| CQuadratureRuleGauss | |
| CQuadratureRuleGaussIterated | |
| CQuadratureRuleGaussSubdividedDefaults | |
| CQuadratureRuleGLL | |
| CQuadratureValuesContainer | |
| ►Nutils | |
| NmathConstants | |
| NmathFunctions | |
| ►Nmpi | |
| NMPIPatternP2PInternal | |
| CMinMaxAvg | |
| CMPICommunicatorP2P | |
| CMPIErrorCodeHandler | |
| CMPIPatternP2P | A class template to store the communication pattern (i.e., which entries/nodes to receive from which processor and which entries/nodes to send to which processor) |
| CMPIRequestersBase | |
| CMPIRequestersNBX | |
| CTypes | A simple struct to return the MPIDatatype based on the user provided primitive data type (e.g., int, double, char, etc) |
| CTypes< char > | |
| CTypes< double > | |
| CTypes< float > | |
| CTypes< int > | |
| CTypes< long > | |
| CTypes< long double > | |
| CTypes< long long int > | |
| CTypes< short > | |
| CTypes< signed char > | |
| CTypes< std::complex< double > > | |
| CTypes< std::complex< float > > | |
| CTypes< unsigned char > | |
| CTypes< unsigned int > | |
| CTypes< unsigned long > | |
| CTypes< unsigned long long int > | |
| CTypes< unsigned short > | |
| CTypes< wchar_t > | |
| NPeriodicTableInternal | |
| NSplineInternal | |
| ►NsplineInternal | |
| Cband_matrix | |
| NstringOps | |
| ►NTimerInternal | |
| CisDuration | |
| CisDuration< std::chrono::duration< Rep, Period > > | |
| CConditionalOStream | Provides an interface to print based on whether a certain condition is met or not. Typical use cases include: (a) printing based on different verbosity level (b) printing only from a certain processor while running in parallel |
| CConditionalOStreamDefaults | |
| CDiscontiguousDataOperations | |
| CExpModX | |
| CLogModX | |
| CMemoryManager | |
| CMemoryManager< ValueType, MemorySpace::HOST > | |
| CMemoryStorage | |
| CMemoryTransfer | |
| CMemoryTransfer< MemorySpace::HOST, MemorySpace::HOST > | |
| CMPICommunicatorP2PKernels | |
| COptimizedIndexSet | |
| CPeriodicTableManager | Provides a map from Atomic Number to Atomic Symbol |
| CPointChargePotentialFunction | |
| CPointImpl | |
| ►CProfiler | |
| CSection | |
| CRandNumGen | |
| CRandNumGen< double > | |
| CRandNumGen< float > | |
| CRandNumGen< int > | |
| CRandNumGen< long > | |
| CRandNumGen< long double > | |
| CRandNumGen< long long > | |
| CRandNumGen< short > | |
| CRandNumGen< std::complex< double > > | |
| CRandNumGen< std::complex< float > > | |
| CRandNumGen< std::complex< long double > > | |
| CRandNumGen< unsigned int > | |
| CRandNumGen< unsigned long > | |
| CRandNumGen< unsigned long long > | |
| CRandNumGen< unsigned short > | |
| CScalarSpatialFunction | Abstract base for scalar functions of a spatial point |
| CScalarSpatialFunctionReal1D | Abstract base for scalar functions of a single real variable |
| CScalarZeroFunctionReal | |
| CSmearChargeDensityFunction | |
| CSmearChargePotentialFunction | |
| ►CSpline | |
| CFunc | |
| ►CTimer | |
| CClockMeasurements | |
| CTypes | |
| CTypes< char > | |
| CTypes< double > | |
| CTypes< float > | |
| CTypes< int > | |
| CTypes< long int > | |
| CTypes< short int > | |
| CTypes< std::complex< double > > | |
| CTypes< std::complex< float > > | |
| CTypes< std::string > | |
| CTypes< unsigned int > | |
| CTypes< unsigned long int > | |
| CTypes< unsigned short int > | |
| CMatrixFree | MatrixFree class template. template parameter nDofsPerDim is the finite element polynomial order. nQuadPointsPerDim is the order of the Gauss quadrature rule. batchSize is the size of batch tuned to hardware |
| CMatrixFreeDevice | MatrixFreeDevice class template. template parameter nDofsPerDim is the finite element polynomial order. nQuadPointsPerDim is the order of the Gauss quadrature rule. batchSize is the size of batch tuned to hardware |
| CMatrixFreeWrapperClass | MatrixFreeWrapper class |
| CRealType | |
| CRealType< double > | |
| CRealType< float > | |
| CRealType< int > | |
| CRealType< std::complex< double > > | |
| CRealType< std::complex< float > > | |
1.9.5