Class List

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

[detail level 12345678]

▼Nserif
►Nbackend
►Nmfem
►Nserialize
►Ndetail
CError	Identify the component or field that could not be saved or reconstructed
COwnedBindings
►CTopModelSampler	Sample copied coefficients on a private deformed geometry; the original state and mesh remain untouched
CImpl
CResources	Own meshes and finite-element resources in reverse dependency order, for creation and archive restoration
CResourceWriter	Collect shared meshes, collections and spaces once while recording their associations
CSaveOptions	Choose whether reference meshes travel with the archive or are resolved by their content identity
►Nshared
CBoundaryElement	Borrow one boundary element and its oriented coordinates during a traversal
CBoundaryFailure	Explain why canonical boundary coordinates or their local assembly were rejected
CReferenceMeshSnapshot	The external mesh metadata consumed by a graph input
CReferenceSpaceSnapshot	Identity and revision of the space that gives coefficients their physical meaning
►Ncompile_time_checks
►Nbarotropic_density
CBoundDescription
CMechanicalBarotrope	Declare only the mechanical EOS capabilities; no enthalpy, polytropic parameters, or curvature is available
►Ndensity_primal
CBoundDescription
►Neos_meanfield
►Nconsumer_contracts
CSingleRelationEOS	Describe exactly one EOS relation; unrelated consumer capabilities remain absent
►Nsurface_boundary
CCentralMultiplier	An enthalpy-dimensioned global multiplier must not be mistaken for the enthalpy carrier
CForwardOnly
CGas
CMissingInversePartial
CMissingPartials
COtherDensity
COtherTemperature
CReversedInverseRelations
►CScalarTerm
Cresidual
Cvalue
CSymbolicEOS
CTwoInverseRelations
CUniformTemperature
►Ndimensions
CAcceleration	Dimension of Acceleration
CAngularAcceleration	Angular acceleration, distinct from angular velocity despite sharing its chosen axis
CAngularMomentum	Dimension of Angular Momentum
CAngularVelocity	Dimension of Angular Velocity
CArea	Dimension of Area
CBarotropicPressurePotential	The barotropic pressure primitive A with dA/density = (dP/density)/density
CChemicalPotential	Dimension of Chemical Potential
CDimensionless	Non dimensional type
CDynamicViscosity	Dimension of Dynamic Viscosity
CEnergy	Dimension of Energy
CEnergyDensity	Dimension of Energy Density
CEntropy	Dimension of Entropy
CForce	Dimension of Force
CForceDensity	Force per unit volume
CFrequency	Dimension of Frequency
CGravitationalConstant	Newton's gravitational constant, expressed in the selected system of units
CGravitationalPotential	Dimension of Gravitational Potential
CInternalEnergy	Dimension of Internal Energy
CInverseTimeSquared	Inverse time squared, the physical dimension of a Poisson residual
CIsQuantityValue
CIsQuantityValue< QuantityValue< Quantity > >
CKinematicViscosity	Dimension of Kinematic Viscosity
CLength	Dimension of Length
CLuminosity	Dimension of Luminosity
CMagneticFluxDensity	Dimension of Magnetic Flux Density
CMass	Dimension of mass
CMassDensity	Dimension of Mass Density
CMassDensityRate	Mass density divided by time,
CMassFlowRate	Dimension of Mass Flow Rate
CMomentOfInertia	Dimension of Moment Of Inertia
CMomentum	Dimension of Momentum
CNumberDensity	Dimension of Number Density
COpacity	Dimension of Opacity
CPartialDerivative	Class to represent a compile time derivative relation between two quantities. Note that this class does not, in fact cannot, compute any derivatives itself. Rather, this is a way for the compiler to understand higher level mathematical relations. Unless you are really in the weeds of the development team you will likely not need to interact with this directly. Further note that this class does include (unlike the more basic dimension system) some basic dimensional analysis. Specifically, there are some overloaded operators that allow for certain specializations of PartialDerivative to operate on one and other conditioned on what their input and output types are. This does not do any thing like convert area to length^2. However, it will do more basic things like ensure that you can only add two partials which agree on their dimensions exactly. Or that while you can multiple a partial by any scalar, you cannot multiply arbitrary partials
CPhysicalQuantity
CPower	Dimension of Power
CPressure	Dimension of Pressure
CPressureLaplacian	Pressure divided by length squared
CQuantityAt
CQuantityAt< Index, QuantityList< Quantities... > >
CQuantityList
CQuantityOf
CQuantityOf< QuantityValue< Quantity > >
CQuantityValue	This is the non derivative equivalent to PartialDerivative. This associates a dimension with a value and, if that value can be determined at compile time, can be decomposed to a transparent double through .value()
CSecondPartialDerivative	A second EOS partial retains both differentiation quantities in its type
CSpecificEnergy	Dimension of Specific Energy
CSpecificEnthalpy	Dimension of Specific Enthalpy
CSpecificEntropy	Dimension of Specific Entropy
CSpecificInternalEnergy	Dimension of Specific Internal Energy
CTemperature	Dimension of Temperature
CThermodynamicQuantity
CTime	Dimension of Time
CTorque	Dimension of Torque
CVelocity	Dimension of Velocity
CVolume	Dimension of Volume
CWithRespectTo	A type that is empty at runtime but allows for the developer to specify to the compiler what quantity the partial is with respect to
►Ndiscretization
►Nbackend
►Nmfem
CBasisEvaluation	Represents an element-local basis evaluation operator, supporting dense or tensor contractions, pointwise mappings, and transpose application
CBasisWorkspace	Reusable scratch storage for basis contractions, reducing repeated allocations
CCoefficientTracking	Track coefficient values using an owned snapshot and the identity of their binding
►CDofMap	A mapping from a full MFEM finite-element space to a reduced set of DOFs that are supporter by the given element support. That is to say that if one has some set of dofs D (perhaps it looks like [0, 1, 2, 3, 4] as a hypothetical) and dofs 0, 2, and 4 are associated to domain A while 1 and 3 are associated to domain B. Then if one were to construct a DofMap with element support [1, 0, 1, 0, 1] (where 1 indicates that the element is supported and 0 indicates that it is not) then the reduced dof map would be [0, 2, 4] and the full to reduced map would be [-1, -1, 0, -1, 1]
CElements	Borrow element access for one traversal after checking the complete binding
CDofSelection	A selection of supported DOFs from a term binding, with boundary attribute information. The purpose here is to allow for the selection of a subset of DOFs from a term binding, such as those associated with a particular boundary, while still retaining the ability to validate the selection against the underlying mesh and term binding
CElementCoordinates	One element's native orientation and its supported full/reduced coefficient coordinates
CElementReconstruction	An element's radial reconstruction; the enclosing plan owns its profile
CFieldValues	Read a field using the same representation and mappings as its equation operators
COwnedBindings
COwnedBindings< Context, utils::dependencies::KeyList< Keys... > >	Keep typed bindings alive beside the resources they borrow; neither copying a configuration nor restoring it copies these resources
CReconstructionPlan	Immutable reconstruction selected on material-side surface elements and validated against their interfaces
CResources	Own meshes and finite-element resources in reverse dependency order, for creation and archive restoration
CScalarBoundaryTrace	An immutable scalar interpolation operator from supported coefficients to selected residual nodes
►CTensorBasis	A class that represents a tensor basis for a finite element. This class is used to evaluate the basis functions and their derivatives at a set of reference points
CProduct	A struct that represents a product of one-dimensional basis functions
►CTensorBasisCache	Share immutable tensor plans within one operator; copied rules are keyed by their contents
CEntry	A struct that represents an entry in the TensorBasisCache. Each entry contains a non-owning pointer to a finite element, the reference operation, the number of copies, the points used to construct the TensorBasis, and a shared pointer to the TensorBasis itself
CTensorWorkspace	A workspace for tensor contractions to avoid repeated allocations and pack memory (TODO: does this actual pack memory in a useful manner when using mfem vectors? Probably something to look into)
CTermBinding	A runtime binding between a term descriptor and its MFEM finite-element space. This is used to project down the compile time term descriptors into runtime reinterpretations which can then be used to extract things like the list of dofs, the element support, and the mesh. Note that this is a child of DofMap, therefor all term bindings are also dof maps
►Nblocks
►Nkeys
CLayout	Share one independently ordered state and residual layout across numerical services
►Cbarotropic_constant	This field holds the effective potential level on the stellar isobar. The level is solved together with the fixed total mass. The barotropic_constant name is retained as an internal coordinate identity. In the density formulation its value is Us, the gravitational potential minus the centrifugal potential on the surface; it is not the polytropic EOS constant K
Cmass_normalization	The value of this global scalar is the effective surface-potential level Us. Its paired residual enforces the prescribed total mass. The surface equation supplies the dependence on Us, while the mass equation integrates the density over the star
Cblock	Base class for all block types in the discretization framework
CBlockVectorView	Build a non-owning view of a packed layout as a span
►Cdensity	The density field used to represent the distribution of mass in the system. This is a scalar field that is associated with the mass density of the system. The density field is used to enforce the mass conservation condition in the weak form
►Cmass	The mass density term for the system. Note that the naming here could be a bit confusing as FEM also uses the term "mass" to represent the canonical mass matrix. This is a more standard physics reading of what is going on here. We define that this space is a third order scalar H1 space. This gives density a continuous surface trace and a weak spatial gradient
Cresidual	The residual block is a block that contains the residual of the mass density term. It is a scalar field that is associated with the mass density of the system
Cvalue	The value block is a block that contains the value of the mass density term. It is a scalar field that is associated with the mass density of the system
►Cdisplacement	The displacement field is a 3 vector H1 field (C0 continuous) that is used to represent continuous nodal displacement over the entire domain
►Cvector	Displacement vector term is a 3 vector H1 field (C0 continuous) that is used to represent continuous nodal displacement over the entire domain. This is a vector field that is associated with the mapping of the domain from the reference to physical spaces. E.g. if there is some domain O_ref which n nodal positions x^i_ref then there is some other domain O_phys with n nodel positions such that x^i_phys = x^i_ref + d^i where d^i is the displacement vector at node i
Cresidual	The residual block is a block that contains the residual of the displacement vector term. It is a vector field that is associated with the mapping of the domain from the reference to physical spaces
Cvalue	The value block is a block that contains the value of the displacement vector term. It is a vector field that is associated with the mapping of the domain from the reference to physical spaces
Cfield	The field struct is a tag type that is used to identify a field in the discretization. It is used to group together terms that belong to the same field. Each field should have a unique name and a list of terms that belong to it
CFieldDescriptor	Runtime descriptor for a field, containing its name. Two FieldDescriptors are equal if they have identical names
►Cframe_acceleration	Uniform translation reaction, one global scalar per Cartesian axis, to be paired with BarycenterConstraint (for example when an external companion potential acts on the star). It must vanish in a physical equilibrium
Ccomponent
►Cglobal_scalar	A global scalar is a term that has a single value over the entire domain (think angular momentum or total mass). Broadly we need to separate these from the other terms since they require different (often less enriched) information at compile time
Cresidual	The residual block is a block that contains the residual of the global scalar. It is a single value over the entire domain and is not associated with any particular functional space. For something like total mass this would be the residual of the mass of the system (i.e. the difference between the current mass and the target mass)
Cvalue	The value block is a block that contains the value of the global scalar. It is a single value over the entire domain and is not associated with any particular functional space. For something like total mass this would be the actual value of the mass of the system
►Cgravity	The gravity field contains the scalar potential. The primal formulation solves the potential and obtains its gradient by differentiation
►Cpotential	The gravitational potential term is a fourth order H1 scalar field that is used to represent the gravitational potential of the system. Its continuous trace supports the surface potential condition, and its spatial gradient supplies gravity in the primal formulation
Cresidual	The residual block is a block that contains the residual of the gravitational potential term. It is a scalar field that is associated with the gravitational potential of the system
Cvalue	The value block is a block that contains the value of the gravitational potential term. It is a scalar field that is associated with the gravitational potential of the system
Cresidual_block	Final class for residual blocks with a fixed index, derived from residual_block_base
Cresidual_block_base	Base class for residual blocks, derived from block
►Crotation	The rotational field, represented as the angular velocity term, given that we currently only model rigid rotation this is a global scalar. A future extension which models differential rotation will likely need to modify this to some vector field or other more complex representation of the rotation
Cangular_velocity	The angular_velocity term represents the angular velocity of the system. It is a global scalar that is associated with the rotation of the system. This is used to enforce the rotation condition in the weak form when we are in the rigid rotation case. Note that downstream the way that this currently works is to calculate the expected angular velocity given the current mass, geometry, density, and angular momentum and then prescribe, given those, what the angular velocity should be. Therefore, this does not enforce that the angular velocity must be constant over the entire solver run, but rather that the angular velocity is consistent with the current state of the system
CSpatialTermTraits	Helper struct representing the traits of some spatial term type, including its functional space, support, family, order, and rank
►Csurface_deformation	The surface corollary field to the full displacement field. This is in some ways more general than the others in so far as it is not pointwise defined over the domain. Rather, it is some general field of numbers, divorced from the underlying discrimination, that is used to represent the surface deformation of the system. This may be used, for example to represent spherical harmonic coefficients of the surface deformation. For more information see the surface and deformation systems
►Ccoefficients	The coefficients term represents some set of coefficients associated with whatever surface representation is being used to represent the surface deformation. Note how we do not have a functional space, support, or a quantity. This is also where we associate the values with
Cvalue	The actual values of the coefficients for whatever surface representation is being used
►Cshape_equilibrium	The shape equilibrium term represents the shape equilibrium condition of the system. This is a term that is associated with the surface deformation field and is used to enforce the shape equilibrium condition in the weak form. This is where we associate the residuals with. Note how we do not have a functional space, support, or a quantity. This is because the shape equilibrium condition is a global condition that is not associated with any particular functional space, support, or quantity
Cresidual	The residuals of the shape equilibrium condition
CSystemLayout	Describe the independently ordered physical state and residual coordinates of a discrete system
Cterm	The term struct is a tag type that is used to identify a term in the discretization. It is used to group together terms that belong to the same field. Each term should have a unique name and a list of blocks that belong to it. Note that generally you should always use term rather than term_base as term associates to a particular field at compile time
Cterm_base	The term_base struct is a tag type that is used to identify a term in the discretization. It is used to group together terms that belong to the same field. Each term should have a unique name and a list of blocks that belong to it. Generally you should always use term rather than term_base as term associates to a particular field at compile time
CTermDescriptor	Runtime descriptor for a term, containing its associated field and name. Two TermDescriptors are equal if they have identical fields and names
Cvalue_block	Final class for value blocks with a fixed index, derived from value_block_base
Cvalue_block_base	Base class for value blocks, derived from block
►Ndomain
►Nids
►Nlists
CBoundaryIDList	A list of boundary IDs in the discretization framework
CDomainIDList	A list of domain IDs in the discretization framework
CBoundaryDescriptor	The BoundaryDescriptor struct is a runtime representation of a boundary, containing its name and integer attribute ID. This is used to project compile-time BoundaryID types into runtime values
CBoundaryID	The BoundaryID struct is a compile-time type that associates a semantic boundary (a Boundary) with an integer attribute in the mesh file. This allows the discretization framework to identify which boundary elements in the mesh correspond to which semantic boundaries in the simulation
CDomainDescriptor	The DomainDescriptor struct is a runtime representation of a domain, containing its name and integer attribute ID. This is used to project compile-time DomainID types into runtime values
CDomainID	The DomainID struct is a compile-time type that associates a semantic domain (a Domain) with an integer attribute in the mesh file. This allows the discretization framework to identify which elements in the mesh correspond to which semantic domains in the simulation
►Nmesh
CFaceElements	A simple struct to hold the IDs of the two elements that share a face. If the face is a boundary face, one of the element IDs will be -1
CMeshTopology	Provides a convenient interface for querying the topological relationships between elements, faces, and boundaries in a mesh
CMeshTopologyData	Backend-independent material labels and face connectivity;
►Nrelation
►Nlists
CRelationList	Compile-time list of relations, used to group relations together for operations and forms. This struct is a variadic template that takes a list of relation types as template parameters
►Nvalidation
CRelationsUseRegisteredEntities	Compile time type to check if a list of relations uses the registered entities
CRelationsUseRegisteredEntities< DomainIDsT, BoundaryIDsT, lists::RelationList< RelationTs... > >	Compile time type to check if a list of relations uses the registered entities. This specialization is for the RelationList type, which is a variadic template that takes a list of relation types as template parameters. It checks if all relations in the list use registered entities based on the provided domain and boundary IDs. This will distribute to the various specializations of the singular RelationUsesRegisteredEntities struct while folding at compile time
CRelationUsesRegisteredEntities	Compile-time validation to check if a relation uses registered entities based on provided domain and boundary IDs. This struct is specialized for different relation types to determine if they use registered entities
CRelationUsesRegisteredEntities< DomainBoundary< BoundaryT, DomainTs... >, DomainIDsT, BoundaryIDsT >	Compile-time validation to check if a relation uses registered entities based on provided domain and boundary IDs. This specialization is for the Relation type DomainBoundary. DomainBoundary requires a boundary and one or more domains, and we enforce that the boundary and all domains are registered
CRelationUsesRegisteredEntities< FullyConnected< DomainT >, DomainIDsT, BoundaryIDsT >	Compile-time validation to check if a relation uses registered entities based on provided domain and boundary IDs. This specialization is for the Relation type FullyConnected. Fully connected only requires a single domain so we only enforce that the domain is registered
CRelationUsesRegisteredEntities< Inscribed< InnerDomainT, OuterDomainT >, DomainIDsT, BoundaryIDsT >	Compile-time validation to check if a relation uses registered entities based on provided domain and boundary IDs. This specialization is for the Relation type Inscribed. Inscribed requires two domains, an inner and an outer domain, and we enforce that both domains are registered
►CRelationValidationResult	Struct representing the result of validating a relation in the domain module. It contains information about the validation failure, if any, and optional diagnostics for specific relation types
CConnectedDiagnostics	Optional diagnostics for the FullyConnected relation type. It contains information about the element ID, domain element count, and visited element count
CDomainBoundaryDiagnostics	Optional diagnostics for the DomainBoundary relation type. It contains information about the face ID, boundary element ID, expected boundary ID, actual boundary ID, first element ID, second element ID, first domain ID, and second domain ID
CInscribedDiagnostics	Optional diagnostics for the Inscribed relation type. It contains information about the face ID, inner element ID, adjacent element ID, and adjacent domain ID
CDomainBoundary	Compile time type representing the domain boundary relation between a boundary and one or two domains. This relation states that the boundary is exactly the surface between the specified domains. We enforce here that the size of the DomainTs pack is either one or two, as a boundary can only be associated with one or two domains. If it is one domain then the boundary is the surface of that domain, if it is two domains then the boundary is the interface between those two domains
CDomainRelation	Base class for all relations in the domain module. This class is used to define compile-time tags for relations that can be declared about a mesh
CFullyConnected	Compile time type representing the fully connected relation for a domain or set. This relation states that the domain is a single connected blob of elements, not two separate pieces
CInscribed	Compile time type representing the inscribed relation between two domains or sets. This relation states that every face of the inner domain (A) that is not interior to A borders the outer domain (B)
►Nschema
►Nvalidation
CDomainBoundary	Compile time type representing the domain boundary relation between a boundary and one or two domains. This relation states that the boundary is exactly the surface between the specified domains. We enforce here that the size of the DomainTs pack is either one or two, as a boundary can only be associated with one or two domains. If it is one domain then the boundary is the surface of that domain, if it is two domains then the boundary is the interface between those two domains
CFullyConnected	Compile time type representing the fully connected relation for a domain or set. This relation states that the domain is a single connected blob of elements, not two separate pieces
CInscribed	Compile time type representing the inscribed relation between two domains or sets. This relation states that every face of the inner domain (A) that is not interior to A borders the outer domain (B)
►CRelationValidationResult	Struct representing the result of validating a relation in the domain module. It contains information about the validation failure, if any, and optional diagnostics for specific relation types
CConnectedDiagnostics	Optional diagnostics for the FullyConnected relation type. It contains information about the element ID, domain element count, and visited element count
CDomainBoundaryDiagnostics	Optional diagnostics for the DomainBoundary relation type. It contains information about the face ID, boundary element ID, expected boundary ID, actual boundary ID, first element ID, second element ID, first domain ID, and second domain ID
CInscribedDiagnostics	Optional diagnostics for the Inscribed relation type. It contains information about the face ID, inner element ID, adjacent element ID, and adjacent domain ID
CRelationValidator	Primary template for RelationValidator. Each relation kind is validated by an explicit specialization of this template, which lives in a sibling header (inscribed.hpp, connected.hpp, boundary.hpp)
CRelationValidator< DomainBoundary< BoundaryT, DomainTs... > >	Specialization of RelationValidator for DomainBoundary relations. This relation enforces that a boundary element is adjacent to exactly one or two volume elements
CRelationValidator< FullyConnected< DomainT > >	Specialization of RelationValidator for FullyConnected relations. This relation enforces that a domain is fully connected, meaning that all elements of the domain are reachable from any other element of the domain
CRelationValidator< Inscribed< InnerT, OuterT > >	Specialization of RelationValidator for Inscribed relations. This relation enforces that an inner domain is inscribed within an outer domain, meaning that every face where the inner domain stops must have the outer domain on the far side
CSchemaRelationValidationResult	The result of validating a single relation against a mesh
CSchemaRelationValidator	Fold that runs one validator per declared relation in a schema
CSchemaRelationValidator< SchemaT, relation::lists::RelationList< RelationTs... > >	Fold that runs one validator per declared relation in a schema. This specialization is for a RelationList of arbitrary length
CSchemaValidationResult	The result of validating a schema against a mesh
CBoundaryID	The BoundaryID struct is a compile-time type that associates a semantic boundary (a Boundary) with an integer attribute in the mesh file. This allows the discretization framework to identify which boundary elements in the mesh correspond to which semantic boundaries in the simulation
CBoundaryIDList	A list of boundary IDs in the discretization framework
CDomainID	The DomainID struct is a compile-time type that associates a semantic domain (a Domain) with an integer attribute in the mesh file. This allows the discretization framework to identify which elements in the mesh correspond to which semantic domains in the simulation
CDomainIDList	A list of domain IDs in the discretization framework
CDomainSchema	A DomainSchema is a collection of relations that describe the relationships between domains and boundaries in a mesh. It is used to validate that a mesh has the expected set of domains and boundaries, and that those domains and boundaries have the expected topological relations. This is important for ensuring that the mesh is suitable for the intended simulation or analysis. There is one primary schema we define for SERiF, that is three domains (core, envelope, and vacuum) and two boundaries (stellar surface and infinity surface). See schemas.hpp for more information on this schema
CRelationList	Compile-time list of relations, used to group relations together for operations and forms. This struct is a variadic template that takes a list of relation types as template parameters
CBoundary	A Boundary is a surface in the mesh. It is a base class for all boundary types
CBoundaryIDResolver	A specialization of the DomainIDResolver struct for a DomainOrSet type. This struct is used to resolve the domain IDs for a given DomainOrSet type
CBoundaryIDResolver< BoundarySet< BoundaryTs... >, ids::lists::BoundaryIDList< BoundaryIDTs... > >	A specialization of the BoundaryIDResolver struct for a BoundarySet type. This struct is used to resolve the boundary IDs for a given BoundarySet type
CBoundaryIDResolver< BoundaryT, ids::lists::BoundaryIDList< BoundaryIDTs... > >	A specialization of the BoundaryIDResolver struct for a single Boundary type. This struct is used to resolve the boundary ID for a given Boundary type
CBoundarySet	A BoundarySet is a collection of boundaries. It is used to group multiple boundaries together for convenience
CCoreDomain	The CoreDomain is the central, cartesian, region of the star. It is a derived class of Domain
CDomain	A Domain is a volume in the mesh. It is a base class for all domain types
CDomainIDResolver
CDomainIDResolver< DomainSet< DomainTs... >, ids::lists::DomainIDList< DomainIDTs... > >	A specialization of the DomainIDResolver struct for a DomainSet type. This struct is used to resolve the domain IDs for a given DomainSet type
CDomainIDResolver< DomainT, ids::lists::DomainIDList< DomainIDTs... > >	A specialization of the DomainIDResolver struct for a single Domain type. This struct is used to resolve the domain ID for a given Domain type
CDomainOrSet	A DomainOrSet is a type that can represent either a single domain or a set of domains
CDomainOrSetList	A list of DomainOrSet types
CDomainSet	A DomainSet is a collection of domains. It is used to group multiple domains together for convenience
CEnvelopeDomain	The EnvelopeDomain is the outer, spherical, region of the star. It is a derived class of Domain
CInfinitySurfaceBoundary	The InfinitySurfaceBoundary is the surface at infinity. It is a derived class of Boundary. More generally this is the outer boundary of the vacuum region; however, since we really need the boundary conditions to be applied at infinity, we call it the infinity surface
CStellarSurfaceBoundary	The StellarSurfaceBoundary is the surface of the star. It is a derived class of Boundary
CVacuumDomain	The VacuumDomain is the vacuum region surrounding the star. It is a derived class of Domain
►Nforms
Cboundary_flux	The boundary_flux form represents the boundary flux operation in the discretization framework. It takes a trial term and a test term as template parameters and defines the operand types for the boundary flux operation
Cdivergence	The divergence form represents the divergence operation in the discretization framework. It takes a trial term and a test term as template parameters and defines the operand types for the divergence operation
Cforce	The force form represents the force term in the discretization framework. It takes a trial term and a test term as template parameters and defines the operand types for the force operation
Cform	The form struct is a tag type that is used to identify a form in the discretization. It is used to group together forms that belong to the same mathematical operation. Each form should have a unique name and a list of operand types that belong to it
CFormDescriptor	Runtime form descriptor including runtime term information. Used to represented the compile-time form type at runtime
CFormTraits	Compile-time traits for forms, used to extract types and properties from template parameters. This struct is specialized for each form type to provide specific traits such as trial and test order reductions
CFormTraits< boundary_flux< TrialT, TestT > >	Specialization of FormTraits for the boundary_flux form, which has no order reduction for either trial or test terms
CFormTraits< divergence< TrialT, TestT > >	Specialization of FormTraits for the divergence form, which has an order reduction of 1, to satisfy the Inf-Sup condition, for the trial term and no order reduction for the test term
CFormTraits< force< TrialT, TestT > >	Specialization of FormTraits for the force form, which has no order reduction for either trial or test terms
CFormTraits< mass< TrialT, TestT > >	Specialization of FormTraits for the mass form, which has no order reduction for either trial or test terms
CFormTraits< projection< TrialT, TestT > >	Specialization of FormTraits for the projection form, which has no order reduction for either trial or test terms
CFormTraits< source< TrialT, TestT > >	Specialization of FormTraits for the source form, which has no order reduction for either trial or test terms
Cmass	The mass form represents the mass matrix operation in the discretization framework. It takes a trial term and a test term as template parameters and defines the operand types for the mass operation
COperand	Compile time representation of some operand. An operand associates a term to an operation type (e.g. the gradient of gravitational potential where gravitational potential is the term and gradient is the operation)
COperandResult	General case for compile time metadata associating some operand to the value type of its result. These use the OperationValue struct and the information in the operand to determine the value type of the result of that operand
COperandResult< OperandT >	Specialization of the OperandResult struct for operands that are valid operands (satisfy the IsOperand concept) and are spatial terms (e.g defined over the domain, think mass density). This specialization uses the OperationValue struct to determine the value type of the result of the operand based on its term type and operation type
►COperation	The Operation struct defines a set of operations that can be applied to terms in the context of a form. These operations include value, gradient, divergence, curl, and normal trace. Similar to the statement I made at the top of forms.hpp, if you are a developer looking to extend the mathematical capabilities of SERiF this is a place you should be looking early on
CCurl	Operation tag for evaluating a curl
CDivergence	Operation tag for evaluating a divergence
CGradient	Operation tag for evaluating a gradient
CNormalTrace	Operation tag for evaluating the normal flux along a boundary
CValue	Operation tag for evaluating a value
COperationValue	General case for compile time metadata associating a tensor rank to an operation. The specialization of this will also specific what the return value of an operation of that rank will be
COperationValue< 0, Operation::Gradient >	The gradient of a rank 0 tensor is a rank 1 tensor (a vector of doubles)
COperationValue< 0, Operation::Value >	The value of a rank 0 tensor is a scalar, a double in the case of SERiF where we restrict ourselves to double precision
COperationValue< 1, Operation::Curl >	The curl of a rank 1 tensor is a rank 1 tensor (a vector of doubles)
COperationValue< 1, Operation::Divergence >	The divergence of a rank one tensor is a scalar (a double)
COperationValue< 1, Operation::Gradient >	Vector gradients use G[component][derivative] = partial_derivative(u_component, x_derivative)
COperationValue< 1, Operation::NormalTrace >
COperationValue< 1, Operation::Value >	The value of a rank 1 tensor is a rank 1 tensor (a vector of doubles in SERiF)
Cprojection	The projection form represents the projection operation in the discretization framework. It takes a trial term and a test term as template parameters and defines the operand types for the projection operation
Csource	The source form represents the source term in the discretization framework. It takes a trial term and a test term as template parameters and defines the operand types for the source operation
CValueComponents	Helper variable template to determine the number of components in the value type of an operand. This is a convenience variable that allows you to easily access the number of components in the value type of an operand without having to explicitly use the OperandResult struct
CValueComponents< double >
CValueComponents< std::array< Entry, Size > >
CValueComponents< void >
►Nfunctional_space
CDiscreteFunctionalSpace	Compile-time descriptor for a discrete functional space. The difference between a FunctionalSpace and a discrete functional space is that a discrete functional space carries some additional information which is needed to actually construct a finite element space (e.g. polynomial order, and rank). Once you have a discrete functional space you have, for MFEM at least, enough information to fully define a finite element space
CRank	Compile-time descriptor for the rank of a functional space
CSpaceDescriptor	Compile-time descriptor for a functional space. This struct is used to describe the family, continuity, trace, and mapping of a functional space at compile time
►Nquadrature
►Nbackend
►Nmfem
CMFEMOperandListOrder	A helper struct to compute the static order of an MFEM integrator for a given list of operands
CMFEMOperandListOrder< utils::types::TypeList< OperandTs... > >	A specialization of the MFEMOperandListOrder struct for a list of operand types. This struct is used to compute the static order of an MFEM integrator for a given list of operands
CMFEMQuadratureContext	The MFEMQuadratureContext struct is used to describe the context in which we are trying to resolve an MFEM integration rule. This includes the geometry type, the order of the geometry weight, any dynamic orders, the domain or set of domains, and the mapping kind
CMFEMResolver	Used to resolve the appropriate MFEM integration rule for a given quadrature context. It uses a policy to determine the appropriate order and other relevant information for the integration rule
CMFEMRule	The MFEMRule struct is used to describe the result of resolving an MFEM integration rule. This includes the resolution (which contains the order and any other relevant information) and a pointer to the integration rule itself
CFormRule	A struct to represent a form rule, which contains a form descriptor and a rule control. Used to tie some form to a specific quadrature rule control
CPolicy	Used to determine the appropriate order and other relevant information for the integration rule based on a given quadrature query. It uses a RuleSet to determine the appropriate order and other relevant information for the integration rule
CQuery	The Query struct is used to represent a quadrature query, which contains all the information needed to determine the appropriate order and other relevant information for the integration rule
CResolution	A struct to hold the resolution of a quadrature query. This contains the base order, boost, and final order of the quadrature rule, as well as a flag indicating whether a fixed order was used
CRuleControl	A struct to control the behavior of a quadrature rule for a given form or role. Rule control always contains boost (default to 0) and may contain some fixed order (think of this as an override). If the fixed order is empty then the quadrature system will determine the order based on the form and role + boost
CRuleSet	Used to determine the appropriate order and other relevant information for the integration rule based on a given quadrature query. It contains a set of form rules and role controls, as well as a fallback control
►Nreconstruction
CRadialProfile	One-dimensional nodal reconstruction, evaluated only while preparing reference operators
CSurfaceAdjacent	Select material elements touching a typed boundary, resolved through the mesh schema
CSurfacePower	Request density proportional to inward distance raised to density_exponent near a vacuum surface
CSurfacePowerProfile	Complete nodal basis whose homogeneous surface trace spans t^n times degree-(p-1) polynomials
CSurfaceRegion	Name the boundary whose material-side elements use reconstruction
►Neos
►Nmodels
CImplementsPartialDerivative_t	A trait to determine if a type implements a partial derivative for a given relation and input quantity. This is the default false specialization
CImplementsRelation_t	A trait to determine if a type is an equation of state model. This is the default false specialization
CImplementsRelationCatalog_t	A specialization of the ImplementsRelation_t trait for a relation. This is used to determine if an EOS type implements a given relation
CImplementsRelationCatalog_t< EOS, relations::RelationCatalog< Relations... > >	A specialization of the ImplementsRelationCatalog_t trait for a relation catalog. This is used to determine if an EOS type implements all relations in a given relation catalog
CImplementsSecondPartialDerivative_t	A second partial is available only for two actual inputs of the relation
CIsEquationOfStateModel_t	A trait to determine if a type is an equation of state model. This is the default false specialization
CIsEquationOfStateModel_t< EOSCandidate, std::void_t< typename std::remove_cvref_t< EOSCandidate >::Relations > >	A specialization of the IsEquationOfStateModel_t trait for a type that has a Relations type alias. A candidate is an equation of state model if it has a valid relation catalog and implements all relations in that catalog
CPolytrope
CPolytropeParameters	A struct to hold the parameters for a polytropic equation of state
►Nrelations
CCatalogContainsRelation	A trait to determine if a catalog contains a given relation. This is the default false specialization
CCatalogContainsRelation< RelationCatalog< Relations... >, RelationT >	A specialization of the CatalogContainsRelation trait for a RelationCatalog. This trait is used to determine if a RelationCatalog contains a given relation. This is true so long as any of the relations in the catalog match the relation type being checked for
CIsThermodynamicRelation	A trait to determine if a type is a valid thermodynamic relation. This is the default false specialization
CIsThermodynamicRelation< Relation< Output, Inputs... > >	A specialization of the IsThermodynamicRelation trait for a Relation. This trait is used to determine if a Relation is a valid thermodynamic relation. A relation is considered valid if its output quantity and all of its input quantities are valid thermodynamic quantities, and if all of its input quantities are unique types
CIsValidRelationCatalog	A trait to determine if a type is a valid relation catalog. This is the default false specialization
CIsValidRelationCatalog< RelationCatalog< Relations... > >	A specialization of the IsValidRelationCatalog trait for a RelationCatalog. This trait is used to determine if a RelationCatalog is a valid relation catalog. A relation catalog is considered valid if it contains at least one relation, if all of its relations are valid thermodynamic relations, and if all of its relations are unique types
CRelation	A struct to represent a relation between physical quantities. This is used to define the relations that an EOS model supports
CRelationCatalog	A struct to represent a catalog of relations between physical quantities. This is used to group relations for use in EOS models
CRelationContainsInput	A trait to determine if a relation contains a given input quantity. This is the default false specialization
CRelationContainsInput< Relation< Output, Inputs... >, Quantity >	A specialization of the RelationContainsInput trait for a Relation. This trait is used to determine if a Relation contains a given input quantity. This is true so long as any of the input quantities in the relation match the quantity type being checked for
CEOSEvaluationError	An exception class to represent errors that occur during the evaluation of an EOS model. This class inherits from std::domain_error and is used to provide a more specific exception type for EOS evaluation errors
►Nequations
CAngularMomentumConstraint	Angular momentum constraint equation, which enforces a global constraint on the total angular momentum of a system
CBarotropicDensityBalance	Enforce A(rho) - A(rho_surface) + Phi - Omega^2 Psi - U_surface = 0 using density test values. This closure assumes a connected barotrope in rigid rotation
CBarycenterConstraint	Fix one component of integral rho (x-center)/M_target
CContribution	A helper struct for authoring equations with fewer lines of boiler-plate. The idea here is that every equation must report certain members so that the backend can inspect at compile time. An author could certainly write these members themselves, but the Contribution struct auto generates those members based on its template parameters. Therefore, by inheriting from the Contribution struct an equation author can avoid writing those members themselves. Note that while this is inheritance it is still a compile-time relation. Contribution does not add any runtime overhead to the equation
CContributions	Helper struct to pack a list of contributions into a tuple. This is used to define the set of contributions of an equation
CContributions< T, std::void_t< decltype(std::declval< const T & >().contributions())> >	Specialization of Contributions for types that have the contributions() method
CContributionSupport	Helper alias to extract the support type for a given contribution
CContributionSupport< T, std::void_t< typename T::Support > >	Specialization of ContributionSupport for types that have a Support member type. This allows us to extract the support type from contributions or equations that define a Support type
CContributionTuple	Type representing the contributions of an equation
CContributionTuple< std::tuple< Ts... >, std::void_t< decltype(std::tuple_cat(std::declval< typename Contributions< std::remove_cvref_t< Ts > >::type >()...))> >	Specialization of ContributionTuple for tuples of contributions. This allows us to extract the contributions from a tuple of contributions
CEquationPoint	A struct to represent the values of operands at a given point in space
CEquationRegistry	A compile-time registry of equations
CMassNormalization	Mass normalization equation, which enforces a global constraint on the total mass of a system
COperandValues	A helper struct to store the values of operands. There is some convention here, specifically if OutputT is void then this struct represents the values of the operands, otherwise it represents the local derivatives of the operands with respect to OutputT
COperandValues< utils::types::TypeList< Operands... >, OutputT >
CPointLinearization	A struct to represent the linearization of a pointwise equation at a given point in space. This includes the residual and the local derivatives of the operands with respect to the test operand value, as well as the local derivative of the test operand value with respect to position
CPointMassCompanion	The potential -G M_c/|x - x_c| of a point-mass companion outside the star
►CPrimalPoissonBalance	Solve Delta(Phi) = 4 pi G rho with one conforming scalar potential field
CDensitySource	Integrate +4 pi G v rho only where matter is supported
CPotentialFlux	Integrate grad(v) dot grad(Phi) throughout the star and vacuum
CRigidRotation	A class that implements rigid rotation, providing methods to compute the centrifugal potential, its gradient, and its Hessian
CSurfacePotentialBalance	Set the effective potential to one unknown level on the selected isobar
CTestOperandTraits	A helper struct to extract the test operand type from a contribution or equation. This is used to determine the test type of an equation or contribution
CTestOperandTraits< T, std::void_t< typename T::TestOperand > >	Specialization of TestOperandTraits for types that have a TestOperand member type. This allows us to extract the test operand type from contributions or equations that define a TestOperand type
CValidContributions	A compile-time check to ensure that a tuple of contributions is valid for a given residual row type. This is the default false specialization
CValidContributions< RowT, std::tuple< C... > >
►Ngeometry
►Ndeformation
►Nbackend
►Nmfem
►Ndetail
CLocatedBoundaryPoint	A structure representing a located boundary point, including the boundary element index and the integration point on that element
►Nvolume_displacement_keys
CCheckedBinding
CCoefficients
►CConstrainedRadialExtension	Keep radial displacement continuous across hanging faces in local component-block coordinates
CWorkspace	Reserve separate local and independent vectors for each caller's actions
CDeformationValueTracking	Equal physical values remain reusable when a context is reconstructed
CGeometrySampleRule	Borrow one sampling rule; repeat an element to retain the actual union of downstream rules
CReferenceDiscretization	Borrow the paired reference meshes; attributes retain their physical domain meaning
►CReferenceDiscretizationTracking	Logical interpolation depends on paired topology and logical coordinates, not physical coordinates
CSnapshot
CShapeCoefficientTracking	Capture the values behind a shape view, independently of its temporary wrapper
CSurfaceDiscretization	The surface selection needs only its scalar space and boundary label
►CSurfaceDiscretizationTracking	Track topology and labels once, independently of changes to physical coordinates
CSnapshot
►Ndetail
CActionInput	Pair each action input with the dimension of its mathematical space
►Nkeys
CDomainMap
CInteriorModel
CLinearization
CRadialInterpolation
CReferenceCoordinates
CReferenceDiscretization
CReferenceSurface
CShapeCoefficients
CSurfaceDiscretization
CSurfaceDisplacement
CSurfaceMap
CSurfaceMetric
CSurfaceModel
CSurfaceNodes
CVacuumModel
CVolumeDisplacement
CVolumeExtension
►Nspaces
CShapeParameters	Independent coordinates belonging to the selected surface representation
CSurfaceDisplacement	Cartesian surface traces with components interleaved at each canonical node
CVolumeDisplacement	Displacement coefficients in the declared volume discretization
►CComposedDeformation	Compose shape-to-surface and surface-to-volume maps with the complete derivative chain rule
CCurvatureWorkspace	Nonlinear actions retain the tangent and the two contributions to the shape-force derivative
CWorkspace
CDeformationFailure	Describe a rejected geometry calculation; the dependency cache publishes results only after success
CDeformationLinearization	Freeze the shape coordinates associated with a derivative, independently of mutable caller inputs
CDomainDeformation	State how the stellar surface moves and how that motion extends into the two surrounding regions
CEmptyDeformationWorkspace	Stateless maps require no numerical scratch, while retaining the same explicit action interface
CFixedInfinityRadialExtension	Reduce surface motion linearly to zero at reference infinity in logical reference radius
CGeometryStepLimit	Geometry-only bound at the supplied sample points, with a location for the first obstruction
CGeometryStepOptions	Numerical controls for keeping a straight volume-displacement step above a Jacobian determinant floor
CNodalRadialSurface	Give each surface node an independent radial displacement, measured in physical length
CPowerLawRadialExtension	Extend surface motion toward a fixed stellar center using a power of logical reference radius
CRadialExtension	Extend one interleaved surface vector into the MFEM component-block volume layout. Stellar ownership wins at shared nodes. Both actions use the same scalar interpolation, so their pairing is Euclidean virtual work without an additional surface-area weight
CRadialInterpolation	A checked, immutable interpolation table; changing a radial law never revalidates its topology
CRadialInterpolationData	Own the surface interpolation shared by the stellar and vacuum extensions
CReferenceSurface	Own fixed surface positions and their canonical ascending scalar-node indices
CSphericalHarmonicMode	Identify a real harmonic, with negative orders using sine and positive orders using cosine
CSphericalHarmonicSurface	Represent radial displacement lengths with normalized real spherical harmonics on the reference surface
CSurfaceEmbedding	Own a linear conversion from radial displacement lengths to Cartesian surface displacements
►Nsurface
►Nbackend
►Nmfem
►Ndetail
CBoundaryTracking	Shared traces have stable identity; validation catches changes outside the coefficient vectors
►Nkeys
CBoundaryDiscretization
CBoundarySamples	Keep sampled boundary state distinct from volume coefficient sources for the same term
CPressureBoundary	The selected equation rows and the finite-element traces supplying their physical state
►Ndetail
CAreSurfaceBindings
CAreSurfaceBindings< utils::dependencies::Bindings< Entries... > >
CBoundaryValueTracking
CMatchingPressureRelations
CMatchingPressureRelations< EOS, Bindings, Carrier, eos::relations::RelationCatalog< Relations... > >
CPressureConditionTracking
CPressureSurfaceDescription	Common physical metadata; numerical values and preparation belong to the dependency context and cache
CRelationQuantities
CRelationQuantities< eos::relations::Relation< Output, Inputs... > >
CSelectedPressureSurface
CSelectedPressureSurface< std::tuple< Candidate > >
CSurfaceOperands
CSurfaceOperands< utils::dependencies::KeyList< Terms... > >
CUniqueTerms
CUniqueTerms< utils::types::TypeList< Terms... > >
►Nkeys
CEOSResponse
CEquationOfState
CLinearization
CPressureCondition
CAutomaticPressureSurface	Compile an isobaric condition from available physical fields, actual equation rows, and the EOS catalog
CBoundaryValues	Values of one scalar term at an ordered collection of boundary points
CDirectPressureSurfaceFormulation	Enforce P_EOS(state) - P_surface = 0 without inventing an inverse EOS relation
CInversePressureSurfaceFormulation	A selected explicit inverse relation; choosing it requires no numerical EOS inversion
►CIsobaricSurface
CParameters
CPressureFieldSurfaceFormulation	An existing pressure unknown enforces P - P_surface directly, without evaluating the EOS
CPressureSurfaceDescriptor
CPressureSurfaceFormulation	The boundary residual is carrier minus the EOS value at prescribed pressure; no carrier quantity is privileged
CSurfaceEOSResponse	An EOS value and all of its local derivatives, evaluated together at one state
CSurfaceFailure	A rejected thermodynamic candidate, with a sample index when evaluating a boundary batch
►Nmapping
►Ncompactification
CExteriorDomainMap	Abstract interface for some mapping from reference coordinates to physical coordinates in the exterior domain. Currently the only concrete implementation of this is the kelvin compactification
CExteriorMapDirection	Structure representing the direction of the variation in the exterior domain mapping. This includes the variation of the displaced position and the variation of the displacement Jacobian
CExteriorMapInput	Structure representing the input to the exterior domain mapping. This includes the reference position, displaced position, displacement Jacobian, compactification coordinate gradient, and compactification coordinate
CExteriorMapResult	Structure representing the result of the exterior domain mapping. This includes the physical position and the Jacobian of the mapping
CExteriorMapVariation	Structure representing the variation of the exterior domain mapping. This includes the variation of the physical position and the variation of the mapping Jacobian
►CKelvinCompactification	Concrete implementation of the ExteriorDomainMap interface for the Kelvin compactification
CRadialFactors	A struct to hold the radial factors for the Kelvin compactification mapping
CCompactificationPointData	A structure representing the compactification point data, including the compactification coordinate and coordinate gradient
CDMFixedMeshGeometry	A structure representing the fixed mesh geometry at a specific point, including position, Jacobian, inverse Jacobian, and weight
CDMReferenceDisplacementSample	A structure representing a sample of the reference displacement, including the value and gradient of the displacement at a specific point
CDMWorkspace	A class representing a workspace for displacement mapping operations, including various vectors and matrices used in the mapping process. primarily this is just a separate class so we can more easily make this code thread-safe in the future. At construction of an instance of this class loads of Heap allocation is done (or really whatever mfem does internally for allocation for vector which dependents on the selected device) and then that allocation can be reused
CDomainMapper
CElementCompactificationData	A class representing the compactification data for a finite element, including the finite element and degrees of freedom
CElementDisplacementData	A class representing the displacement data for a finite element, including the finite element, degree of freedom matrix, and dimension
CElementMappingData
CFaceMappingContext	A structure representing the context of a face mapping, including the mapping point context and face quadrature context
CFaceMappingVariation
CFaceQuadratureContext	A structure representing the context of a face quadrature point, including the normal vector, surface weight, and scale factor for the dot product of the velocity and normal vector
CGridFunctionMappingEvaluator
CMappingPointContext	A structure representing the context of a mapping point, including the reference position, displaced position, physical position, displacement Jacobian, mapping Jacobian, inverse mapping Jacobian, mapping determinant, and compactification status
CMappingPointVariation
CVolumeMappingCache
CVolumeMappingContext	A structure representing the context of a volume mapping, including the mapping point context and volume quadrature context
CVolumeMappingVariation
CVolumeQuadratureContext	A structure representing the context of a volume quadrature point, including the inverse Jacobian of the mapping and the determinant of the mapping
►Nmodel
►Nbackend
►Nmfem
►Ndetail
CNoAdditionalComputations	Ordinary model evaluation adds no caller-selected preparation computations
CPhysicalEvaluation	Select physical coordinates without adding normalization graph services
CStateCoefficients
CStateCoefficients< Discretization, Layout, Prescribed, utils::dependencies::KeyList< Fields... > >	Borrow an owning state's fields for one synchronous equation evaluation
CSystemData	Retain accepted blocks and the stable external resources borrowed by those blocks
CBoundModel	Retain physical descriptions and all numerical bindings behind one stable owner
CColumnContribution	A coupling from state coordinates into an ordered selection of replacement rows
CCoordinateRange	One contiguous range of equation or state coordinates in an evaluated system
CDeformationDiscretization	Numerical surface representation and its reference geometry, separate from force equations
CEquilibriumEvaluator	Evaluate explicit stellar candidates using one reusable dependency cache
CJacobianContribution	One frozen physical Jacobian coupling; overlapping contributions add
►CLinearizedBlock	An accepted physical block with optional efficient diagonal and sparse assembly operations
CData
CNoDeformation	Prescribe displacement externally when no shape unknown is selected
CNormalizedSystem	A frozen physical preparation and its owning solver coordinates, safe after later graph preparation
CPhysicalSystem	Own one evaluated residual and Jacobian, retaining the discretization owner used by every child action
CPreconditionedSystem	Retain one evaluated star and its matching inverse for a linear solve
CResidualContribution	One evaluated equation contribution in the independently ordered residual coordinates
CRowReplacement	Replace complete equations after all ordinary and generated contributions have been added
CShapeDerivatives	Share one accepted deformation and its projected derivative across all physical equations
CStellarDiscretization	Bind physical terms to existing finite-element resources with one explicit lifetime owner
CSurfacePotentialLinearization	Accepted surface moments and derivatives in existing shape and field coordinates
►Nchecks
CBinding	Only the binding's physical identity is needed to check public overload constraints
CBound
CFixedPlan
►CMovingPlan
CSurface
►Ncomputations
CContributions	Ordinary equations, point constraints and row replacements share one small assembly result
CInteriorContribution	One equation's accepted contribution to the complete physical system
CPotentialInfinityContribution	The zero potential trace at compactified infinity, independent of the stellar isobar
CPressureBoundaryContribution	The complete isobaric replacement applied after ordinary and generated equation contributions
CScalarResidualRow	One global scalar equation's accepted derivative in complete physical state coordinates
CShapeContribution
CShapeDerivatives
►Ndetail
CArgumentsMatch
CArgumentsMatch< utils::types::TypeList< Specifications... >, Arguments... >
CCanonicalSpecifications
CCanonicalSpecifications< Head, Tail... >
CCanonicalSpecifications<>
CCartesianCouplings
CCartesianCouplings< utils::dependencies::KeyList< Rows... >, utils::dependencies::KeyList< Fields... > >
CEndpointOwner	Recognize generated endpoint identities without interpreting unrelated physical names
CEndpointOwner< ConstraintOf< Specification > >
CEndpointOwner< GeneratedCoordinateOf< Specification > >
CEnforcementDependencies	Legacy prescriptions retain their original dependencies unless an equation explicitly registers another enforcement
CEnforcementDependencies< Specification, Bindings, true >
CEquationCouplings
CEquationCouplings< Equation, utils::types::TypeList< Columns... > >
CEquilibriumCouplings
CExecutionInputs
CExecutionInputs< Plan, std::void_t< typename Plan::PhysicalInputs, typename Plan::InactiveRows > >
CExecutionSurface
CExecutionSurface< Plan, std::void_t< typename Plan::Surface > >
CInsertSpecification
CInsertSpecification< Specification, utils::types::TypeList< Head, Tail... > >
CInsertSpecification< Specification, utils::types::TypeList<> >
CInteriorCouplings
CInteriorCouplings< equations::EquationRegistry< Equations... > >
CInteriorPlan
CInteriorPlan< equations::EquationRegistry< Equations... > >
COperandTerms
COperandTerms< utils::types::TypeList< Operands... > >
CPreferredSurfaceField
CPreferredSurfaceField< utils::types::TypeList< Equations... > >
CRemoveKeys
CRemoveKeys< utils::dependencies::KeyList< Keys... >, Excluded >
CResolvedEndpoints
CResolvedEndpoints< Owner, utils::types::TypeList< Endpoints... >, Bindings >
CResolvedSpecification	Share resolved physical identities between endpoint and numerical-provider checks
CSelectedSurface	A disabled or unavailable boundary has no compiled field or row requirements
CSelectedSurface< Selection, true >
CSelectRole
CShapePlan
CShapePlan< equations::SurfacePotentialBalance >	The isobar level couples only existing scalar potential, rotation and mass coordinates
CShapePlan< NoShapeForce >
CSurfaceFieldHint
CSurfaceFieldHint< Equation, std::void_t< typename Equation::IsobaricSurfaceField > >	An equation author may disambiguate surface enforcement without changing the physical condition
CSurfacePlan
CSurfacePlan< geometry::surface::Isobaric, EOS, Fields, Rows, Solved, Equations >	Compile the condition once; planning, graph assembly and validation share the selected formulation
CSurfacePlan< NoSurfaceCondition, EOS, Fields, Rows, Solved, Equations >
CUniqueSurfaceField
CUniqueSurfaceField< utils::dependencies::KeyList< Field, Others... > >
CUniqueSurfaceField< utils::dependencies::KeyList<> >
►Nequation
CHydrostaticBalance
COwnConstraint
CPoissonBalance
CSurfaceShapeBalance
►Nkeys
CPhysicalSystem	The complete accepted physical residual and its matching Jacobian
►Nnormalization
►Ndetail
CAutomaticRules
CAutomaticRules< Coordinates, Plan, dependencies::KeyList< Values... >, utils::types::TypeList< Equations... > >	Equation residual quantities remain independent from the unknowns occupying their rows
CConfigurationTracking	Rebuilding the input context does not change the identity of an immutable configuration
CInfinityRule	Pointwise infinity values have potential units rather than integrated Poisson units
CMethodMetrics
CMethodMetrics< numerical::DimensionlessRieszCoordinate< Quantity, Metric, Geometry > >
CMethodMetrics< numerical::PhysicalRieszCoordinate< Quantity, Metric > >
CMethodMetrics< numerical::WithPointRows< Method, Quantity, Selection > >
CMetric
CMetric< Term, true >
CResidualRules
CResidualRules< dependencies::Bindings< Interior... >, dependencies::Bindings< Shape... > >
CRuleMetrics
CRuleMetrics< dependencies::Bindings< Rules... > >
CSelectPlan
CSelectPlan< numerical::AutomaticPlan, Coordinates, Bound >
CSurfaceRule
CSurfaceRule< Method, Row, Plan, true >
CValueRule
CValueRule< Coordinates, blocks::surface_deformation::coefficients >
CVolumeMetric
CVolumeMetric< solver::normalization::ReferenceVolumeMetric< TermT > >
CConfiguration
CInfinityRows	Potential rows replaced by the zero trace at compactified infinity
CPreparedSystem
CSurfaceRows	Reduced equation rows whose volume residual is replaced by the selected surface condition
►Npreconditioning
CNone	Evaluate physical equations without preparing an inverse until a recipe is selected
CPreparedSystem	An owning evaluated system and its matching preconditioner
►Nstate
CDensity
CGravitationalPotential
COwnGeneratedCoordinate
CSurfaceShape
CConstraintOf	Identify a generated residual independently from its target and unknown units
CDiscretizationOptions	Select a descriptive star, its existing finite-element resources, and its numerical coordinates
CEnforcementOf	Select an explicit numerical enforcement while preserving the public physical prescription
CEosReference	Reuse one immutable EOS in equation objects, optionally retaining shared ownership
CEquilibriumEquations	State the chosen equations explicitly, without selecting physics from the EOS
CEquilibriumPlan	Collect the explicitly selected physical coefficients and supported constraint coordinates
►CFixedAngularMomentum	Prescribe angular momentum while angular velocity remains an independent solved coordinate
CParameters
►CFixedTotalMass	Prescribe total stellar mass while the effective surface-potential level remains an independent solved coordinate
CParameters
CGeneratedCoordinateOf	Name another prescription, including a forward declaration, without erasing its identity
CModelPlan	Derive physical coordinates from explicit equations, independently of numerical solvability
CNoShapeForce	Explicitly omit a shape equation from a declarative formulation
CNoSurfaceCondition	Explicitly omit a surface prescription from a declarative formulation
CScalarConstraint	Declare independent target, unknown and residual units and stable descriptive identities
CSpecificationDefinition	Declare a prescription once; numerical providers and normalization consume this metadata
CSpecificationDescriptor	Inspect canonical prescription identity without claiming numerical availability
CStellarMeshOptions	Resolve a spherical stellar interior and a compactified exterior on a curved reference mesh
CStellarModel
CStellarModel< EquationOfStateT, EquationDefinitionT, utils::types::TypeList< Specifications... > >	Own immutable physics and an explicit formulation, independently of meshes, caches and solvers
CStellarState	Own one stellar candidate in physical coordinates, including any solved surface shape
CStellarSurfaceRefinementOptions	Add mesh resolution at the stellar interface before creating field spaces
►Noperators
►Nbackend
►Nmfem
►Ndetail
CCoefficientExpansion	Weighted reduced coordinates of each local coordinate, as CSR: local i owns [offsets[i], offsets[i+1])
CConstrainedElementBlock	One element's probed block on constrained bindings: column-major values and both constraint expansions
CProbedElementBlock	One element's probed block: column c's integrated values for every local row, column-major
CProbeScratch	Per-worker scratch for probing element blocks
►CVolumeFieldOperator	Retain accepted data while applying a single field coupling with reusable contraction scratch
CScratch	One worker's element scratch
►Nvolume_keys
►CScoped	Keep equation-local stages distinct while sharing physical coefficient sources
CBasis
CBindings
CGeometry
CGeometryDerivatives	Weighted local displacement derivatives, owned and invalidated by the graph
CLinearization
CPhysicalValues
CQuadratureLinearization
CReferenceValues
CBasisBindings
CBasisEvaluation	Represents an element-local basis evaluation operator, supporting dense or tensor contractions, pointwise mappings, and transpose application
CBasisWorkspace	Reusable scratch storage for basis contractions, reducing repeated allocations
CClosure	A minimal density-valued volume equation, sufficient to instantiate a volume cache
CCoefficientTracking	Track coefficient values using an owned snapshot and the identity of their binding
CCoefficientView
CCompactificationCoefficients
CContributionData
CDisplacementCoefficients
CElementBasis	Fixed-mesh basis samples; independent of the current coefficient values and displacement
CElementData	Weighted equation data retains the exact basis, geometry, and samples used to compute it
CElementGeometry	Physical mapping and mapped bases for one frozen displacement
CJacobianOperator
►CLinearizedBlock	An accepted physical block with optional efficient diagonal and sparse assembly operations
CData
CMappingCoefficients
CMetadataTracking	Validate external mesh resources before the graph compares their metadata
CNumericalWork	Numerical work derived from the dependency engine's most recent report
COperandEvaluator
COperandEvaluator< OperandT >	Scalar and vector H1 gradients share the existing value/divergence coefficient contractions
COperandSamples	Reference samples remain available for derivatives through the physical mapping
CPreparationRejection
►CTensorBasisCache	Share immutable tensor plans within one operator; copied rules are keyed by their contents
CEntry	A struct that represents an entry in the TensorBasisCache. Each entry contains a non-owning pointer to a finite element, the reference operation, the number of copies, the points used to construct the TensorBasis, and a shared pointer to the TensorBasis itself
CVolumeConfiguration	Stable equation ownership also retains temporary and move-only contribution trees
CVolumeData	One accepted result contains ordered contribution batches and the assembled residual
CVolumeDiscretization	Borrowed discretization objects must outlive their graph and its accepted results
CVolumeOptions	Numerical choices fixed when the graph is constructed
CVolumeScratch	Scratch belongs to graph callables and is never a dependency source
CWorkspace	Reusable scratch for applying the accepted element linearization
►Ndetail
CAsKeyList
CAsKeyList< utils::types::TypeList< T... > >
CColumns
CColumns< utils::types::TypeList< O... > >
CContributionChildren
CContributionOperands
CContributionOperands< std::tuple< C... > >
CCouplingForm
CJoin
CBadContributionCollection
CBadContributionRow
CContributionBinding	Retain one leaf equation and the constant coefficient of its arithmetic expression
►CDiscontinuousScalar
Cresidual
CEquationPlan
CEquationPlan< EquationT, utils::types::TypeList< O... > >
CEquationRegistry	A compile-time registry of equations
CGradientRequest
CHasScalarVolumeOperands
CHasScalarVolumeOperands< EquationT, utils::types::TypeList< Operands... > >
►CLinearizedBlock	An accepted physical block with optional efficient diagonal and sparse assembly operations
CData
CLinearizedSystemView	Borrow an accepted collection of physical blocks and its independently ordered system layout
CNestedBadCollection
CNodalRequest
COperandValues	A helper struct to store the values of operands. There is some convention here, specifically if OutputT is void then this struct represents the values of the operands, otherwise it represents the local derivatives of the operands with respect to OutputT
CPhysicalBlock	Identify a physical Jacobian block by its equation rows and unknown coordinates
CVolumeContributions
CVolumeContributions< std::tuple< C... > >
CVolumeOperands
CVolumeOperands< C, utils::types::TypeList< O... > >
►Nsolver
►Nadmissibility
►Nbackend
►Nmfem
CGeometryDirection	Retain one accepted displacement and direction while backtracking changes the current candidate
CGeometrySamplingRules	The union of reference rules used by geometry inspection and all volume equations
►Nbackend
►Nmfem
CStellarProblem	Adapt existing stellar preparation to Newton without giving acceptance to the model
►Ncontinuation
►Ndetail
CAllIdentified
CAllIdentified< utils::types::TypeList< Specifications... > >
CCatalog
CCatalog< Owner, std::void_t< typename SpecificationTraits< Owner >::Parameters > >
CContained
CContained< ParameterList< Parameters... >, Superset >
CCopyEquations
CFamilyTraits
CFamilyTraits< ParameterList< Selected... >, std::tuple< Laws... > >
CParameterCatalog
CParameterCatalog< Owner, std::void_t< typename Owner::ContinuationParameters > >
CRequiredDependents
CRequiredDependents< Parameter, std::void_t< typename Parameter::RequiredDependentParameters > >
CAngularMomentum
CBoundFamily
►CBoundFamily< Model, ParameterList< Selected... >, std::tuple< Laws... >, EquationFactory >	Own target physics and construct fresh family members without a mesh, evaluator, or mutable solve context
CValues
CCoordinateController	Own only the continuation path; a caller promotes physical states after successful correction
CCoordinateCounters
CCoordinateOptions	Numerical increments are fractions of each coordinate's complete physical span
CCoordinateProposal
CCorrectionControls
CFailure
CFamily	Own a reusable physical family definition before selecting a target model
CIdentifiedEquations	Give a deferred equation definition an explicit physical identity without runtime polymorphism
CNumericalControls
COptions	Bound continuation work and storage independently of Newton's per-correction controls
COrdering
CParameterDescriptor
CParameterLaw
CPolytropicConstant
CPolytropicIndex
CPreservePressureAtReferenceDensity	Vary K with n to preserve pressure at one explicitly selected physical reference density
CResult	Retain the last converged physical state separately from the requested endpoint and failed candidates
CSpecificationTraits	Add continuation access without imposing numerical dependencies on a physical prescription
CSpecificationTraits< eos::models::Polytrope >
CSpecificationTraits< model::FixedAngularMomentum >
CSpecificationTraits< Specification >	Preserve unselected scalar prescriptions in the complete physical identity
CStageRecord
CStartingAt
CStartingStar	A supplied physical anchor still requires fresh qualification at the continuation tolerance
►Ndetail
CInitialEvaluation	Keep a freshly qualified metric beside the exact system from which it was measured
CNewtonFailure	Explain why a candidate cannot provide a usable nonlinear metric
CQualifiedStep	Own a qualified trial; a terminal root deliberately has no prepared inverse
CSolveObservation	Adapt callbacks and latch requests; only the Newton driver decides when stopping is safe
►Nlinear
CApplicationFailure	Bridge a failed checked inner solve through MFEM's void operator-application interface. Only this numerical failure is intercepted by the checked backend. Dimension, ownership, and other callback errors retain their original exception types and reach the library's caller
CControl	Accuracy is measured against the current right-hand side, independently of the initial guess
CFGMRES	Flexible GMRES accepts both fixed linear inverses and variable inner preconditioners
CReport	Bounded diagnostics from one solve, including an independently evaluated true residual
►Nnormalization
►Nbackend
►Nmfem
►Ndetail
CScaledOperator	Common algebra for a Jacobian L J S^-1 and an inverse S M^-1 L^-1
CScaledPreconditioner	MFEM solver adapter which always binds the physical inverse to its dimensional Jacobian
CScaledPreconditionerStatistics	Counts physical bindings and normalized applications without instrumenting the inverse itself
►Nchecks
CAliasesOnlyLayout
CBorrowedPreparationResult
CCentralRow
CConvertiblePrescription
CCustomDensityMetric
CCustomMetric
CDerivedPrescription
CDuplicateMetricCoordinates
CFirstResidual
CFirstValue
CForeignCoordinate
CMalformedMetric
CMassRow
CMissingMetricMetadata
CMoveOnlyPrescription
CPreparedPrescription
CPressureRow
CPretendRieszMethod
CSecondResidual
CSecondValue
CSelectedSurfaceRows
CSelection
CSharedFieldMetric
CStateOnlyPrescription
CTemperatureCoordinate
CTemperatureMetric
CTemperatureScales
CUntypedTemperatureScales
CWrongPreparationResult
►Ndetail
CMethodSupports
CMethodSupports< DimensionlessRieszCoordinate< QuantityT, MetricT, Geometry >, KeyT, Kind >
CMethodSupports< IdentityCoordinate, KeyT, Kind >
CMethodSupports< PhysicalRieszCoordinate< QuantityT, MetricT >, KeyT, Kind >
CMethodSupports< RuntimePreparedCoordinate< PrescriptionT >, KeyT, Kind >
CMethodSupports< WithPointRows< DimensionlessRieszCoordinate< QuantityT, MetricT, Geometry >, PointQuantityT, SelectionT >, KeyT, discretization::blocks::RepresentedValueKind::residual >
CMethodSupports< WithPointRows< PhysicalRieszCoordinate< QuantityT, MetricT >, PointQuantityT, SelectionT >, KeyT, discretization::blocks::RepresentedValueKind::residual >
CRuleKeys
CRuleKeys< utils::dependencies::Bindings< Rules... > >
CValidRules
CValidRules< utils::dependencies::Bindings< Rules... >, Kind >
►Nkeys
CFactors	Distinguish state and residual factors even when they share the same physical term
CNormalization
CPrescription	Bind the exact custom prescription named by a runtime-prepared coordinate
CReferenceBinding
CScales
CAutomaticPlan	Derive the coordinate rules from the selected fields, equations and boundary formulation
CDiagonalNormalization	Own the frozen, independent state and residual transformations used by one solve
CDimensionless	Remove physical and geometric units from the solver's coordinates and norms
CDimensionlessMetricGeometry	Require custom metrics to declare their geometric convention explicitly
CDimensionlessMetricGeometry< geometry::deformation::keys::SurfaceMetric >
CDimensionlessMetricGeometry< ReferenceVolumeMetric< TermT > >
CDimensionlessMetricGeometry< UnitMetric >
CDimensionlessRieszCoordinate	Measure coordinates using dimensionless physical fields and reference geometry
CFromModel	Obtain a reference value from the corresponding descriptive model prescription
CIdentityCoordinate	Leave the declared coordinates unchanged, including their physical units
CLaneEmdenApproximation	Estimate a reference radius from a Lane–Emden shape, mass and central density
CMetricCoordinates	Metric keys advertise the coordinate identities they measure; a same-sized unrelated metric is insufficient
CMetricCoordinates< geometry::deformation::keys::SurfaceMetric >	Consume deformation's existing metric directly in both native shape-coordinate roles
CMetricCoordinates< MetricT, std::void_t< typename MetricT::Coordinates > >
CMetricCoordinates< UnitMetric >	Permit a Euclidean norm of algebraic surface moments after their measure is made dimensionless
CNormalizationOptions	Declare normalization without evaluating a reference star or allocating coordinate factors
CNormalizationPlan	Independent term-to-method and row-to-method maps; their order does not define the packed layout
CNormalizationPrescriptionTag
CPhysicalRieszCoordinate	Measure a physical quantity with the named reference Gram diagonal
CReferenceVolumeMetric	Identify a reference volume metric by its physical term, including its support and FE representation
CRuntimePreparedCoordinate	Identify the exact prescription supplying positive factors; this never claims identity scaling
CStellarReferenceScales	Fixed reference scales used throughout a solve, independent of its candidate state
CUnitMetric	A unit Gram metric for algebraic coordinates, still subject to physical scaling
CWithPointRows	Replace selected volume residual rows by point residuals with their own physical quantity
►Npreconditioner
►Nbackend
►Nmfem
►Ndetail
►CDirectLU
CState
►CDirectLUPattern	Symbolic analysis (fill-reducing ordering) of one sparsity pattern, shared by the numeric factorizations of every matrix with that pattern. Implemented by the backend chosen with the sparse_direct Meson option (direct_lu_accelerate.cpp, direct_lu_umfpack.cpp or direct_lu_none.cpp)
CState
CInverse	An owning approximate inverse and the application guarantee required by its compositions
CSolver	Expose one accepted inverse to MFEM while binding it to exactly its accepted physical Jacobian
►CSparseDirectCache	The symbolic analysis (fill-reducing ordering) of the last matrix factored through this cache
CState
CTwoBlockCouplings	The two Jacobian actions between independently ordered equation and unknown groups
►Nchecks
CExtraField
CExtraRow
CExtraValue
►Ncomputations
►Ndetail
CPhysicalSources
CPhysicalSources< utils::dependencies::KeyList< Keys... > >
►Ndetail
CPrimalCoordinates	Separate the primal fields from scalar constraints and optional shape coordinates
CPrimalCoordinates< utils::dependencies::KeyList< Coordinates... >, Shape >
►Nkeys
CDiagonal
CInverse	The inverse maps the selected equation residuals back to their physical unknowns
CMatrix
CPreconditioner
►Nstrategies
►Ncoupling
CSecondThenFirst	Correct the first subsystem using the second subsystem's update
►Ninverse
CDenseDirect	Directly solve a small dense system; optionally reject an unreliable infinity-norm condition estimate
CDiagonal	Invert each diagonal entry independently
CFixedAMG	Apply a fixed number of BoomerAMG cycles from zero, preserving a fixed linear inverse
CSparseDirect	Exact inverse of the assembled block through a sparse LU factorization, prepared once per state
CBlockPreconditioner	Select a physical equation/unknown pair and the numerical approximation to its inverse
CBorderedPreconditioner	Correct a physical field inverse through its dense constraint Schur system
CConstraintCoordinates	Select arbitrary constraint rows and unknowns, including coupled generated scalars
CCoupledPreconditioner	Compose physical subsystem descriptions without creating an additional preparation owner
CFailure	A recoverable preparation failure, including the numerical reason and how to correct it
CSolver	Expose one accepted inverse to MFEM while binding it to exactly its accepted physical Jacobian
►Nseed
►Nbackend
►Nmfem
CProjectionOptions	Allow for the reference mesh's finite-order approximation to a spherical seed surface
CFittedRadialSeed	An explicitly stretched initial guess, distinct from an equilibrium Lane–Emden scaling
CPolytropeOptions	Numerical choices for an EOS-consistent spherical starting guess, separate from solver normalization
CRadialSeed	Own a spherical physical profile and its first rotation estimate without changing the stellar model
CBacktracking	Shorten a Newton step until the complete residual merit decreases sufficiently
CDirectionAssessment	A modified direction must report whether it is usable and any measured merit slope
CMetricEvaluation	Separate the convergence norm from the line-search merit for custom metrics
CNewton	Accuracy and work limits for finding one equilibrium star
CNewtonCheckpoint	Own the accepted physical star and the small amount of Newton history needed to continue it
CNewtonProgress	Numerical continuation data at one accepted Newton boundary
CNoModel	Marker for algebraic tests and custom problems without a stellar description
CNoObserver	Disable observation without introducing runtime callback allocation
CNormalizedResidualMetric	Use the Euclidean norm of SERiF's normalized residual and half its square
CSolveDiagnostics	Bounded work totals; accepted physical snapshots are stored separately from diagnostics
CSolveEvent	Small event record suitable for logging without retaining every iterate
CSolveResult	Own the last accepted physical state, matching frozen system, and descriptive model
CSolverOptions	Select numerical policies while keeping equilibrium physics in the model
CSolveTiming	Optional elapsed wall time, kept separately from numerical restart history
CStandardNewton	Ordinary Newton supplies every strategy phase; custom policies may replace individual phases explicitly
CTimedObserver	Measure solves explicitly while retaining an ordinary progress or stop callback
CTrialAssessment	A numerical policy explicitly accepts its work or explains why this candidate must be rejected
►Nutils
►Ndependencies
►Ndetail
CAppendBinding
CAppendBinding< Bindings< BindingsTs... >, BindingT >
CAppendKeys
CAppendKeys< ResultT, FirstT, Rest... >
CAppendUnique
CAppendUnique< KeyList< Keys... >, T >
CBindingLookup
CBindingLookup< Bindings< BindingTs... > >	Share one compile-time lookup structure across all keys in a binding collection
CBorrowedValue
CBoundType
CCachedResult
CComputationCacheStorage
CComputationCacheStorage< GraphT, BindingsT, types::TypeList< Resources... >, std::index_sequence< Indices... > >
CComputationCacheTraits
CComputationCacheTraits< GraphT, ContextT, ErrorT, true >
CComputationGraphSchema
CComputationGraphSchema< GraphT, ContextT, true >
CGraph	Immutable topology of computed nodes; context sources are resolved separately
CHasBinding
CHasBinding< Bindings< BindingTs... >, KeyT >
CInvocation	Ill-formed calls fail the graph concept instead of producing a hard instantiation error
CInvocation< ComputationT, types::TypeList< Arguments... >, std::void_t< InvocationResult< ComputationT, Arguments... > > >
CKeyListSize
CKeyListSize< KeyList< Keys... > >
CMergeKeyLists
CMergeKeyLists< ResultT, KeyList< Keys... >, Rest... >
CNodeObservation	Each started hook owns one invocation state and finishes once, including on exceptional exit
COwnedValue
CResolveComputation	Missing inputs stop resolution before instantiating the callable or its result type
CResolveComputation< ComputationT, BindingsT, true >
CResolveGraph	Walk execution positions, appending each result type to the available input bindings
CResolveGraph< GraphT, BindingsT, Position, false >
CResolveGraph< GraphT, BindingsT, Position, true >
CResolveStep	An invalid callable must not instantiate the remaining graph or access a missing Value type
CResolveStep< GraphT, BindingsT, Position, ComputationT, true >
CResourceKeys
CResourceKeys< types::TypeList< Resources... > >
CResult	Computations publish owned, movable values, either directly or through std::expected
CResult< std::expected< ValueT, ErrorT > >
CSourceSnapshot
►CUsedResource
CPredicate
CValidObservers
CValidObservers< Observers< Registrations... >, GraphT, ContextT, true >
►Nkeys
CCoordinates	Positions supplied to a computation, in the caller's coordinate convention
CInput	The main input to a computation
COutput	The main result of a computation
CParameters	Configuration values that can affect the result
CScale	A multiplicative scale supplied as an input
CAllNodesObserver	One registration can inspect every result without building a graph-sized observer tuple
CBinding
CBindings
CBoundType
CComputation
CComputationCache	Execute a computational graph on demand, publishing immutable results only after the entire request succeeds
CComputationGraph
CDependencyContext
CDependencyContextView
CDependencyContextView< ParentT, KeyList< KeyTs... > >
CEdgeObserver
CGraphTiming	Collect independent graph bindings without mixing timers into numerical restart history
CGraphTimingFactory	Bind one generic timing observer after the model's complete graph type is known
CGraphTimingRun	One graph binding's declaration-ordered catalog, including nodes which never execute
CHasBinding
CKeyList	An ordered collection of role keys, independent of their associated value types
CKeyListBindings
CKeyListBindings< BindingsT, KeyList< KeyTs... > >
CNodeObserver
CNodeTiming	Wall time for attempted node work, independently of later cache or Newton acceptance
CNoGraphObservers	Default high-level binding adds no observation storage, timers, or callback work
CObservers	Own registrations; execution state lasts for one invocation and is never part of the numerical cache
CPreparationFailure
CPreparationReport
CProjectedSnapshot
CResolveKeys
CResolveKeys< BindingsT, KeyList< KeyTs... > >
CResource
CSteadyNodeClock	Read monotonic elapsed wall time without changing physical computations
CValueSnapshot	Default tracking owns an exact value copy; noncopyable resources supply another policy
►Nerrors
CNonFiniteValue	A numerical action produced a nonfinite coefficient, distinguishable from a broken API contract. Most numerical interfaces report rejection as a value. MFEM operator applications return void, so their checked caller intercepts this specific bridge while other exceptions propagate
Cserif_error_printer
►Nlaneemden
CIntegrationOptions	Dimensionless integration controls; the surface tolerance does not bound the global integration error
CPhysicalSample	Physical scalar fields; gravity is the outward potential derivative, not the inward force component
CPhysicalScales	A physical conversion of one finite-radius dimensionless polytrope, in the caller's consistent units
CSample	The regular Lane–Emden solution and its first derivative at one dimensionless radius
CSolution	A regular profile, ending at its first zero or the requested integration radius
►Nmisc
►Nconcepts
CConcat
CConcat< types::TypeList< LhsTs... >, types::TypeList< RhsTs... >, Rest... >
CConcat< types::TypeList< Ts... > >
CConcat<>
CFilter
CFilter< types::TypeList< Head, Tail... >, Predicate >
CFilter< types::TypeList<>, Predicate >
CPrepend
CPrepend< T, types::TypeList< Ts... > >
►Nprojection
►Nbackend
►Nmfem
CRadialProjectionOptions	Sample physical radii about a center, optionally through SERiF's existing geometry mapping. The mapping must use the projection space's mesh and must be refreshed after its input fields change
►Nserialize
CEntry	The ledger locates each independent field without decoding the rest of the archive
CEnumSerializer	Encode enumerations by declared stable spellings, never compiler-dependent integers
CError	Identify the component or field that could not be saved or reconstructed
CField	Associate a field name with an already encoded child
CMember	Name a typed field expected by a component's loader
CNamedMember	Name a plain configuration member without adding persistence methods to its owner
CNode	A named component owns its fields, stable schema identifier, and schema version
CPack	A pack owns its data immediately, so subsequent model changes cannot alter a pending write
CReader	Inspect the ledger first, then seek directly to whichever components are actually needed
CReadOptions	Bound resource use when inspecting an unfamiliar archive; limits may be raised explicitly
CRecipeSerializer	Preserve the selected equation/unknown identities in every composed inverse
CSchemaSerializer	Reconstruct stateless typed numerical declarations only when all their identities match
CSerializer	Specialize this protocol beside a component without adding I/O methods to the component itself
CSerializer< char[Size]>
CSerializer< dependencies::Binding< Key, Target > >
CSerializer< dependencies::Bindings< Bindings... > >
CSerializer< dependencies::DependencyContext< Resources... > >
CSerializer< dependencies::DependencyContext<> >
CSerializer< dependencies::KeyList< Terms... > >
CSerializer< dependencies::Resource< Key, Storage, Policy > >
CSerializer< dependencies::ValueSnapshot >
CSerializer< dimensions::QuantityValue< Quantity > >
CSerializer< discretization::blocks::SystemLayout< Values, Residuals > >
CSerializer< discretization::quadrature::Policy >
CSerializer< discretization::quadrature::RuleControl >
CSerializer< discretization::quadrature::RuleSet >
CSerializer< eos::models::Polytrope >
CSerializer< equations::AngularMomentumConstraint >
CSerializer< equations::BarotropicDensityBalance< EOS > >
CSerializer< equations::BarycenterConstraint< Axis, Row > >
CSerializer< equations::EquationRegistry< Equations... > >
CSerializer< equations::MassNormalization >
CSerializer< equations::PointMassCompanion >
CSerializer< equations::PrimalPoissonBalance >
CSerializer< equations::SurfacePotentialBalance >
CSerializer< geometry::deformation::DomainDeformation< Surface, Interior, Vacuum > >
CSerializer< geometry::deformation::FixedInfinityRadialExtension >
CSerializer< geometry::deformation::GeometryStepLimit >	Store bounded numerical history as named data, without runtime operators or graph caches
CSerializer< geometry::deformation::keys::SurfaceMetric >
CSerializer< geometry::deformation::NodalRadialSurface >
CSerializer< geometry::deformation::PowerLawRadialExtension >
CSerializer< geometry::deformation::SphericalHarmonicSurface >
CSerializer< geometry::surface::IsobaricSurface >
CSerializer< laneemden::IntegrationOptions >
CSerializer< model::backend::mfem::StellarDiscretization< Owner, Bindings, Deformation > >	Integrate native discretizations into packs while keeping application-owner reconstruction explicit
CSerializer< model::DiscretizationOptions< Model, FiniteElements, Normalization, Preconditioner > >
CSerializer< model::EosReference< EOS > >
CSerializer< model::EquilibriumEquations< Interior, Shape, Surface > >
CSerializer< model::FixedAngularMomentum >
CSerializer< model::FixedTotalMass >
CSerializer< model::normalization::SurfaceRows >
CSerializer< model::NoShapeForce >
CSerializer< model::NoSurfaceCondition >
CSerializer< model::preconditioning::None >
CSerializer< model::StellarModel< EOS, Definition, types::TypeList< Specifications... > > >
CSerializer< model::StellarState< Layout > >
CSerializer< Node >	Preserve a raw component when inspection, rather than typed reconstruction, is wanted
CSerializer< operators::backend::mfem::VolumeOptions >	Preserve quadrature and contraction choices separately from physical coefficients
CSerializer< solver::Backtracking >
CSerializer< solver::linear::Control >
CSerializer< solver::linear::FGMRES >
CSerializer< solver::linear::Report >	Store bounded numerical history as named data, without runtime operators or graph caches
CSerializer< solver::linear::Status >	Preserve stable termination names independently of enum storage or declaration order
CSerializer< solver::MetricEvaluation >	Store bounded numerical history as named data, without runtime operators or graph caches
CSerializer< solver::Newton >
CSerializer< solver::NewtonCheckpoint< State > >	Save a portable accepted physical state together with its complete supported Newton history
CSerializer< solver::NewtonProgress >	Store bounded numerical history as named data, without runtime operators or graph caches
CSerializer< solver::normalization::AutomaticPlan >
CSerializer< solver::normalization::DiagonalNormalization >
CSerializer< solver::normalization::Dimensionless >
CSerializer< solver::normalization::DimensionlessRieszCoordinate< Quantity, Metric, Geometry > >
CSerializer< solver::normalization::FromModel >
CSerializer< solver::normalization::IdentityCoordinate >
CSerializer< solver::normalization::LaneEmdenApproximation< Mass, Density > >
CSerializer< solver::normalization::NormalizationOptions< Scheme, Coordinates, Plan, Sources, Computations > >
CSerializer< solver::normalization::NormalizationPlan< Values, Residuals > >
CSerializer< solver::normalization::PhysicalRieszCoordinate< Quantity, Metric > >
CSerializer< solver::normalization::ReferenceVolumeMetric< Term > >
CSerializer< solver::normalization::StellarReferenceScales >
CSerializer< solver::normalization::UnitMetric >
CSerializer< solver::normalization::WithPointRows< Volume, Quantity, Selection > >
CSerializer< solver::NormalizedResidualMetric >
CSerializer< solver::preconditioner::BlockPreconditioner< Row, Field, Strategy > >
CSerializer< solver::preconditioner::BorderedPreconditioner< Fields, Constraints > >
CSerializer< solver::preconditioner::CoupledPreconditioner< First, Second, Policy > >
CSerializer< solver::preconditioner::strategies::coupling::SecondThenFirst >
CSerializer< solver::preconditioner::strategies::inverse::DenseDirect >
CSerializer< solver::preconditioner::strategies::inverse::Diagonal >
CSerializer< solver::preconditioner::strategies::inverse::FixedAMG >
CSerializer< solver::preconditioner::strategies::inverse::SparseDirect >
CSerializer< solver::SolveDiagnostics >	Store bounded numerical history as named data, without runtime operators or graph caches
CSerializer< solver::SolveResult< State, System, Model > >	Export scientific results and supported restart data without pretending frozen operators are persistent
CSerializer< solver::SolverOptions< Metric, Strategies, Linear > >
CSerializer< solver::SolveStatus >	Preserve stable termination names independently of enum storage or declaration order
CSerializer< solver::StandardNewton >
CSerializer< std::array< T, Size > >
CSerializer< std::optional< T > >
CSerializer< std::string >
CSerializer< std::string_view >
CSerializer< std::tuple< T... > >
CSerializer< std::vector< T > >	Arrays of coefficients are contiguous payloads, while compound values retain named children
CSerializer< T >	Store numeric values using explicit portable widths
CStructSerializer	Compose an explicitly listed aggregate; the field list is also its constructor order
CTermIdentity	Register stable coordinate identities separately from compiler-generated display names
CTermIdentity< discretization::blocks::barotropic_constant::mass_normalization >
CTermIdentity< discretization::blocks::density::mass >
CTermIdentity< discretization::blocks::displacement::vector >
CTermIdentity< discretization::blocks::gravity::potential >
CTermIdentity< discretization::blocks::rotation::angular_velocity >
CTermIdentity< discretization::blocks::surface_deformation::coefficients >
CTermIdentity< discretization::blocks::surface_deformation::shape_equilibrium >
CTermIdentity< model::ConstraintOf< Specification > >
CTermIdentity< model::GeneratedCoordinateOf< Specification > >
CTopExportOptions	Sampling and admissibility limits for TOP's single-domain polytrope reader
CTopExportReport	Export scales and sampled projection defects; these do not certify oscillation accuracy
CTopPolytropeSource	Physical samples in a centered frame whose polar axis is the rotation axis
CWriteOptions	Annotations belong to the written observation, not to the stellar physics
►Ntypes
CCTString
CFixedString
CTypeList
►Nuser_options
CDomainMapperOptions
CKelvinCompactificationOptions
CCompensatedSum	Neumaier summation retains small terms when a scalar reduction contains cancellation
▼Nstd	STL namespace
Cformatter< serif::discretization::blocks::FieldDescriptor >	Specialization of std::formatter for FieldDescriptor and TermDescriptor to enable formatting with std::format
Cformatter< serif::discretization::blocks::TermDescriptor >	Specialization of std::formatter for TermDescriptor to enable formatting with std::format
Cformatter< serif::discretization::domain::DomainOrSet >	Specialization of std::formatter for DomainOrSet. This allows us to use std::format to format DomainOrSet objects
Cformatter< serif::discretization::domain::schema::validation::SchemaValidationResult >	Specialization of std::formatter for SchemaValidationResult to enable formatting with std::format
Cformatter< serif::discretization::forms::FormDescriptor >	Overload to allow println for FormDescriptors
Cformatter< serif::discretization::functional_space::Continuity >	Specialization of the std::formatter for the Continuity enum. This allows us to use std::format to format the Continuity enum as strings
Cformatter< serif::discretization::functional_space::DiscreteFunctionalSpace< Space, Order, R > >	Specialization of the std::formatter for the DiscreteFunctionalSpace types. This allows us to use std::format to format the DiscreteFunctionalSpace types as strings
Cformatter< serif::discretization::functional_space::Family >	Specialization of the std::formatter for the Family enum. This allows us to use std::format to format the Family enum as strings
Cformatter< serif::discretization::functional_space::Mapping >	Specialization of the std::formatter for the Mapping enum. This allows us to use std::format to format the Mapping enum as strings
Cformatter< serif::discretization::functional_space::Rank< R > >	Specialization of the std::formatter for the functional space types. This allows us to use std::format to format the functional space types as strings
Cformatter< serif::discretization::functional_space::SpaceDescriptor >	Specialization of the std::formatter for the SpaceDescriptor types. This allows us to use std::format to format the SpaceDescriptor types as strings
Cformatter< serif::discretization::functional_space::Trace >	Specialization of the std::formatter for the Trace enum. This allows us to use std::format to format the Trace enum as strings
Cformatter< serif::discretization::quadrature::FormRule >	A specialization of the std::formatter for the FormRule type. This allows for easy formatting of the FormRule type using std::format
Cformatter< serif::discretization::quadrature::MappingKind >	Specializations of the std::formatter for the MappingKind type. This allows for easy formatting of the MappingKind type using std::format
Cformatter< serif::discretization::quadrature::QuadratureRole >	Specializations of the std::formatter for the QuadratureRole, MappingKind, RuleControl, FormRule, and RuleSet types. This allows for easy formatting of these types using std::format
Cformatter< serif::discretization::quadrature::Query >	A specialization of the std::formatter for the Query struct. This allows for easy formatting of Query objects using std::format
Cformatter< serif::discretization::quadrature::RuleControl >	A specialization of the std::formatter for the RuleControl type. This allows for easy formatting of the RuleControl type using std::format
Cformatter< serif::discretization::quadrature::RuleSet >	A specialization of the std::formatter for the RuleSet type. This allows for easy formatting of the RuleSet type using std::format
Cformatter< serif::utils::dependencies::NodeOutcome >
Cformatter< serif::utils::laneemden::IntegrationOptions >
Cformatter< serif::utils::laneemden::Sample >	Select all sample values, or one named component with :xi, :theta, or :derivative
Cformatter< serif::utils::laneemden::Solution >	Describe the solution while applying one shared selection to its profile and optional surface sample