| ►NActions | |
| CAdvanceTime | Advance time one substep |
| CChangeSlabSize | Adjust the slab size based on previous executions of Events::ChangeSlabSize |
| CChangeStepSize | Adjust the step size for local time stepping |
| CComputeTimeDerivative | Compute the time derivative of the system variables |
| CComputeVolumeFluxes | Compute the volume fluxes of the evolved variables |
| CGoto | Jumps to a Label |
| CLabel | Labels a location in the action list that can be jumped to using Goto |
| CMutateApply | Apply the function Mutator::apply to the DataBox |
| CRecordTimeStepperData | Records the variables and their time derivatives in the time stepper history |
| CRunEventsAndTriggers | Run the events and triggers |
| CSetData | Mutate the DataBox tags in TagsList according to the data |
| CSetupDataBox | Add into the DataBox default constructed items for the collection of tags requested by any of the actions in the phase-dependent action list |
| CUpdateConservatives | Compute the conservative variables from the primitive variables |
| CUpdatePrimitives | Compute the primitive variables from the conservative variables |
| CUpdateU | Perform variable updates for one substep |
| ►NActionTesting | Structures used for mocking the parallel components framework in order to test actions |
| CGlobalCoreId | Wraps a size_t representing the global core number |
| CInitializeDataBox< tmpl::list< SimpleTags... >, ComputeTagsList > | |
| CLocalCoreId | Wraps a size_t representing the local core number. This is so the user can write things like emplace_array_component(NodeId{3},LocalCoreId{2},...) instead of emplace_array_component(3,2,...) |
| CMockArrayChare | A mock class for the CMake-generated Parallel::Algorithms::Array |
| ►CMockDistributedObject | MockDistributedObject mocks the AlgorithmImpl class. It should not be considered as part of the user interface |
| Cget_databox_types | |
| CMockGroupChare | A mock class for the CMake-generated Parallel::Algorithms::Group |
| CMockNodeGroupChare | A mock class for the CMake-generated Parallel::Algorithms::NodeGroup |
| ►CMockRuntimeSystem | A class that mocks the infrastructure needed to run actions. It simulates message passing using the inbox infrastructure and handles most of the arguments to the apply method. This mocks the Charm++ runtime system as well as the layer built on top of it as part of SpECTRE |
| CInboxesTag | |
| CMockDistributedObjectsTag | |
| CMockSingletonChare | A mock class for the CMake-generated Parallel::Algorithms::Singleton |
| CNodeId | Wraps a size_t representing the node number. This is so the user can write things like emplace_array_component(NodeId{3},...) instead of emplace_array_component(3,...) |
| ►Nah | |
| ►NTags | |
| CExtrinsicCurvatureCompute | |
| CFastFlow | |
| CInverseSpatialMetricCompute | These ComputeItems are different from those used in GeneralizedHarmonic evolution because these live only on the intrp::Actions::ApparentHorizon DataBox, not in the volume DataBox. And these ComputeItems can do fewer allocations than the volume ones, because (for example) Lapse, SpaceTimeNormalVector, etc. can be inlined instead of being allocated as a separate ComputeItem |
| CPreviousStrahlkorper | Tag for holding the previously-found value of a Strahlkorper, which is saved for extrapolation for future initial guesses and for recovering the initial guess on failure of the algorithm |
| CSpatialChristoffelSecondKindCompute | |
| CComputeHorizonVolumeQuantities | Given the generalized harmonic variables in the volume, computes the quantities that will be interpolated onto an apparent horizon |
| Nalg | Utility functions wrapping STL algorithms and additional algorithms |
| Namr | Items for adaptive mesh refinement |
| ►Nblaze | |
| CAddTrait< ComplexModalVector, ComplexModalVector > | |
| CAddTrait< ModalVector, ModalVector > | |
| CDivTrait< ComplexModalVector, double > | |
| CDivTrait< ModalVector, double > | |
| CMapTrait< ComplexDataVector, blaze::Abs > | |
| CMapTrait< ComplexDataVector, blaze::Imag > | |
| CMapTrait< ComplexDataVector, blaze::Real > | |
| CMapTrait< ComplexDataVector, DataVector, Operator > | |
| CMapTrait< ComplexDiagonalModalOperator, blaze::Imag > | |
| CMapTrait< ComplexDiagonalModalOperator, blaze::Real > | |
| CMapTrait< ComplexDiagonalModalOperator, ComplexDiagonalModalOperator, Operator > | |
| CMapTrait< ComplexDiagonalModalOperator, Operator > | |
| CMapTrait< ComplexModalVector, blaze::Imag > | |
| CMapTrait< ComplexModalVector, blaze::Real > | |
| CMapTrait< ComplexModalVector, ComplexModalVector, Operator > | |
| CMapTrait< ComplexModalVector, Operator > | |
| CMapTrait< DataVector, blaze::Imag > | |
| CMapTrait< DataVector, blaze::Real > | |
| CMapTrait< DataVector, ComplexDataVector, Operator > | |
| CMapTrait< DiagonalModalOperator, blaze::Imag > | |
| CMapTrait< DiagonalModalOperator, blaze::Real > | |
| CMapTrait< DiagonalModalOperator, DiagonalModalOperator, Operator > | |
| CMapTrait< DiagonalModalOperator, Operator > | |
| CMapTrait< ModalVector, blaze::Imag > | |
| CMapTrait< ModalVector, blaze::Real > | |
| CMapTrait< ModalVector, ModalVector, Operator > | |
| CMapTrait< ModalVector, Operator > | |
| CMultTrait< ComplexDiagonalModalOperator, ModalVector > | |
| CMultTrait< ModalVector, ComplexDiagonalModalOperator > | |
| CStepFunction | |
| CSubTrait< ComplexModalVector, ComplexModalVector > | |
| CSubTrait< ModalVector, ModalVector > | |
| CTransposeFlag< ComplexModalVector > | |
| CTransposeFlag< ModalVector > | |
| ►Nboost | |
| ►Nnumeric | |
| ►Nodeint | |
| Calgebra_dispatcher< ComplexDataVector > | |
| Calgebra_dispatcher< ComplexModalVector > | |
| Calgebra_dispatcher< DataVector > | |
| Calgebra_dispatcher< ModalVector > | |
| Cis_resizeable_sfinae< VectorType, typename boost::enable_if_c< is_derived_of_vector_impl_v< VectorType > >::type > | |
| Cresize_impl_sfinae< VectorType1, VectorType2, typename boost::enable_if_c< is_derived_of_vector_impl_v< VectorType1 > and is_derived_of_vector_impl_v< VectorType2 > >::type > | |
| ►Nbrigand | |
| Cadd_unique_vertex | |
| Cadd_unique_vertex< State, edge< Source, Destination, Weight > > | |
| Cbranch_if | |
| Cbranch_if< false > | |
| Cbranch_if< true > | |
| Ccompute_adjacency_list | |
| Ccompute_adjacency_list< VertexSeq< Vertices... >, F, Es... > | |
| Cconditional | |
| Cconditional< false > | |
| Cconditional< true > | |
| Cdigraph | |
| Cdigraph< List< edges... > > | |
| Cedge | |
| Cfactorial | |
| Cfactorial< uint64_t< 1 > > | |
| Cget_destination | |
| Cget_destination< edge< Source, Destination, Weight > > | |
| Cget_source | |
| Cget_source< edge< Source, Destination, Weight > > | |
| Cget_weight | |
| Cget_weight< edge< Source, Destination, Weight > > | |
| Chas_destination | |
| Chas_source | |
| Chas_source_and_destination | |
| Chas_source_and_destination< E< S, D, W >, S, D > | |
| Cingoing_edges_impl | |
| Cingoing_edges_impl< digraph< edgeList > > | |
| Coutgoing_edges_impl | |
| Coutgoing_edges_impl< digraph< edgeList > > | |
| Cpower | |
| ►NBurgers | Items related to evolving the Burgers equation \(0 = \partial_t U + \partial_x\left(U^2/2\right)\) |
| ►NAnalyticData | Holds classes implementing analytic data for Burgers equation |
| CSinusoid | Analytic data (with an "exact" solution known) that is periodic over the interval \([0,2\pi]\) |
| ►NBoundaryConditions | Boundary conditions for the Burgers system |
| CBoundaryCondition | The base class off of which all boundary conditions must inherit |
| ►CDirichlet | |
| CU | |
| CDirichletAnalytic | |
| COutflow | |
| ►NBoundaryCorrections | Boundary corrections/numerical fluxes |
| CBoundaryCorrection | The base class used to create boundary corrections from input files and store them in the global cache |
| CHll | An HLL (Harten-Lax-van Leer) Riemann solver |
| CRusanov | A Rusanov/local Lax-Friedrichs Riemann solver |
| ►NSolutions | Holds classes implementing a solution to the Burgers equation \(0 = \partial_t U + \partial_x\left(U^2/2\right)\) |
| ►CBump | A solution resembling a bump |
| CCenter | |
| CHalfWidth | |
| CHeight | |
| ►CLinear | A solution that is linear in space at all times |
| CShockTime | |
| ►CStep | A propagating shock between two constant states |
| CInitialPosition | |
| CLeftValue | |
| CRightValue | |
| ►NTags | |
| CCharacteristicSpeeds | The characteristic speeds |
| CCharacteristicSpeedsCompute | Computes the characteristic speeds |
| CComputeLargestCharacteristicSpeed | |
| CLargestCharacteristicSpeed | |
| CU | |
| CFluxes | The flux of \(U\) is \(\frac{1}{2} U^2\) |
| CSystem | |
| CTimeDerivativeTerms | Computes the time derivative terms needed for the Burgers system, which are just the fluxes |
| ►NCce | The set of utilities for performing Cauchy characteristic evolution and Cauchy characteristic matching |
| ►NActions | The set of actions for use in the CCE evolution system |
| CBoundaryComputeAndSendToEvolution | Obtains the CCE boundary data at the specified time, and reports it to the EvolutionComponent via Actions::ReceiveWorldtubeData |
| CBoundaryComputeAndSendToEvolution< AnalyticWorldtubeBoundary< Metavariables >, EvolutionComponent > | Calculates the analytic boundary data at the specified time, and sends the resulting Bondi-Sachs boundary data to the EvolutionComponent |
| CBoundaryComputeAndSendToEvolution< GhWorldtubeBoundary< Metavariables >, EvolutionComponent > | Submits a request for CCE boundary data at the specified time to the Cce::InterfaceManagers::GhInterfaceManager, and sends the data to the EvolutionComponent (template argument) if it is ready |
| CBoundaryComputeAndSendToEvolution< H5WorldtubeBoundary< Metavariables >, EvolutionComponent > | Obtains the CCE boundary data at the specified time, and reports it to the EvolutionComponent via Actions::ReceiveWorldtubeData |
| CCalculateIntegrandInputsForTag | Prepare the input quantities in the DataBox for the evaluation of the hypersurface integral used to compute BondiTag |
| CCalculateScriInputs | Calculates the Bondi quantities that are required for any of the CalculateScriPlusValue mutators |
| CExitIfEndTimeReached | Terminates if the current Tags::TimeStepId has time value later or equal to Tags::EndTime |
| CFilterSwshVolumeQuantity | Filters the spherical volume data stored in BondiTag according to the filter parameters in the Parallel::GlobalCache |
| CInitializeCharacteristicEvolutionScri | Initializes the CharacteristicEvolution component with contents needed to perform the interpolation at scri+ |
| CInitializeCharacteristicEvolutionTime | Initializes the contents of the CharacteristicEvolution component for performing the time evolution of the system, which is the singleton that handles the main evolution system for CCE computations |
| CInitializeCharacteristicEvolutionVariables | Initializes the main data storage for the CharacteristicEvolution component, which is the singleton that handles the main evolution system for CCE computations |
| CInitializeFirstHypersurface | Given initial boundary data for \(J\) and \(\partial_r J\), computes the initial hypersurface quantities \(J\) and gauge values |
| CInitializeWorldtubeBoundary | Generic action for initializing various worldtube boundary components |
| CInitializeWorldtubeBoundary< AnalyticWorldtubeBoundary< Metavariables > > | Initializes an AnalyticWorldtubeBoundary |
| CInitializeWorldtubeBoundary< GhWorldtubeBoundary< Metavariables > > | Initializes a GhWorldtubeBoundary |
| CInitializeWorldtubeBoundary< H5WorldtubeBoundary< Metavariables > > | Initializes a H5WorldtubeBoundary |
| CInsertInterpolationScriData | Places the data from the current hypersurface necessary to compute Tag in the ScriPlusInterpolationManager associated with the Tag |
| CPrecomputeGlobalCceDependencies | Perform all of the computations for dependencies of the hypersurface equations that do not themselves depend on any hypersurface integrations |
| CReceiveGhWorldtubeData | Stores the boundary data from the GH evolution in the Cce::InterfaceManagers::GhInterfaceManager, and sends to the EvolutionComponent (template argument) if the data fulfills a prior request |
| CReceiveNextElementTime | Stash the next_time in the Cce::InterfaceManagers::GhInterfaceManager to inform the local time-stepping logic for boundary interpolation/extrapolation |
| CReceiveWorldtubeData | Takes the boundary data needed to perform the CCE linear solves as arguments and puts them in the DataBox, updating the Cce::Tags::BoundaryTime accordingly |
| CRequestBoundaryData | Requests boundary data be sent from WorldtubeBoundaryComponent to EvolutionComponent (template parameters) |
| CRequestNextBoundaryData | Requests boundary data be sent from WorldtubeBoundaryComponent to EvolutionComponent |
| CScriObserveInterpolated | Checks the interpolation managers and if they are ready, performs the interpolation and sends the data to file via observers::ThreadedActions::WriteSimpleData |
| CSendNextTimeToCce | If the element contains the first point in the interpolation collection, sends the next (full) TimeStepId to the Metavariables::cce_boundary_component to inform the boundary local-time-stepping interpolation/extrapolation |
| CSendToEvolution | Computes Bondi boundary data from GH evolution variables and sends the result to the EvolutionComponent (template argument) |
| CUpdateGauge | Updates all of the gauge quantities associated with the additional regularity-preserving gauge transformation on the boundaries for a new set of Cauchy and partially flat Bondi-like coordinates |
| ►NFrame | |
| CRadialNull | The frame for the spherical metric in which the radial coordinate is an affine parameter along outward-pointing null geodesics |
| ►NInitializationTags | |
| CExtractionRadius | |
| CScriInterpolationOrder | |
| CScriOutputDensity | |
| ►NInitializeJ | Contains utilities and DataBox mutators for generating data for \(J\) on the initial CCE hypersurface |
| CGaugeAdjustInitialJ | Apply a radius-independent angular gauge transformation to a volume \(J\), for use with initial data generation |
| CInitializeJ< false > | Abstract base class for an initial hypersurface data generator for Cce, when the partially flat Bondi-like coordinates are not evolved |
| CInitializeJ< true > | Abstract base class for an initial hypersurface data generator for Cce, when the partially flat Bondi-like coordinates are evolved |
| CInverseCubic< false > | Initialize \(J\) on the first hypersurface from provided boundary values of \(J\), \(R\), and \(\partial_r J\) |
| CInverseCubic< true > | Initialize \(J\) on the first hypersurface from provided boundary values of \(J\), \(R\), and \(\partial_r J\) |
| ►CNoIncomingRadiation | Initialize \(J\) on the first hypersurface by constraining \(\Psi_0 = 0\) |
| CAngularCoordinateTolerance | |
| CMaxIterations | |
| CRequireConvergence | |
| ►CZeroNonSmooth | Initialize \(J\) on the first hypersurface to be vanishing, finding the appropriate angular coordinates to be continuous with the provided worldtube boundary data |
| CAngularCoordinateTolerance | |
| CMaxIterations | |
| CRequireConvergence | |
| ►NInterfaceManagers | Contains utilities for collecting, interpolating, and providing worldtube data for CCE that originates from other components in a running simulation |
| CGhInterfaceManager | Abstract base class for storage and retrieval of generalized harmonic quantities communicated from a Cauchy simulation to the Cce system |
| ►CGhLocalTimeStepping | Implementation of a GhInterfaceManager that provides data according to local time-stepping dense output |
| CAdamsBashforthOrder | |
| CGhLockstep | Simple implementation of a GhInterfaceManager that only provides boundary data on matching TimeStepIds |
| ►NOptionTags | |
| CAnalyticSolution | |
| CBoundaryDataFilename | |
| CCce | Option group |
| CCceEvolutionPrefix | A prefix for common tags (e.g. from Time/Tags.hpp) that are specific to CCE, so should be in the Cce::Evolution group |
| CEndTime | |
| CEvolution | Option group for evolution-related quantities in the CCE system |
| CExtractionRadius | |
| CFiltering | Option group |
| CFilterLMax | |
| CFixSpecNormalization | |
| CGhInterfaceManager | |
| CH5Interpolator | |
| CH5IsBondiData | |
| CH5LookaheadTimes | |
| CInitializeJ | |
| CLMax | |
| CNumberOfRadialPoints | |
| CObservationLMax | |
| CRadialFilterAlpha | |
| CRadialFilterHalfPower | |
| CScriInterpolationOrder | |
| CScriOutputDensity | |
| CStandaloneExtractionRadius | |
| CStartTime | |
| ►NReceiveTags | |
| CBoundaryData | A receive tag for the data sent to the CCE evolution component from the CCE boundary component |
| ►NSolutions | Analytic solutions for CCE worldtube data and corresponding waveform News |
| ►NTestHelpers | |
| CSphericalSolutionWrapper | |
| ►CBouncingBlackHole | Analytic solution representing a coordinate oscillation about a stationary Schwarzschild black hole |
| CAmplitude | |
| CExtractionRadius | |
| CMass | |
| CPeriod | |
| ►CGaugeWave | Computes the analytic data for a gauge wave solution described in [7] |
| CAmplitude | |
| CDuration | |
| CExtractionRadius | |
| CFrequency | |
| CMass | |
| CPeakTime | |
| ►CLinearizedBondiSachs | Computes the analytic data for a Linearized solution to the Bondi-Sachs equations described in [7] |
| CExtractionRadius | |
| CFrequency | |
| CInitialModes | |
| ►CRobinsonTrautman | An analytic solution representing a specialization of the radiative Robinson-Trautman solution described in [36] |
| CExtractionRadius | |
| CInitialModes | |
| CLMax | |
| CStartTime | |
| CTolerance | |
| ►CRotatingSchwarzschild | Computes the analytic data for the rotating Schwarzschild solution described in [7], section VI.C |
| CExtractionRadius | |
| CFrequency | |
| CMass | |
| CSphericalMetricData | Abstract base class for analytic worldtube data most easily derived in spherical coordinate form |
| ►CTeukolskyWave | Computes the analytic data for a Teukolsky wave solution described in [7] |
| CAmplitude | |
| CDuration | |
| CExtractionRadius | |
| ►CWorldtubeData | Abstract base class for analytic worldtube data for verifying the CCE system |
| CIntermediateCache | |
| CIntermediateCacheTag | |
| ►NTags | Tags for Cauchy Characteristic Extraction routines |
| CAnalyticBoundaryDataManager | A tag that constructs a AnalyticBoundaryDataManager from options |
| CAnalyticInitializeJ | |
| CBondiBeta | Bondi parameter \(\beta\) |
| CBondiJ | Bondi parameter \(J\) |
| CBondiJbar | Bondi parameter \(\bar{J}\) |
| CBondiJCauchyView | Bondi parameter \(\bar{J}\) in the Cauchy frame |
| CBondiK | Bondi parameter \(K = \sqrt{1 + J \bar{J}}\) |
| CBondiQ | Bondi parameter \(Q\) |
| CBondiQbar | Bondi parameter \(\bar{Q}\) |
| CBondiR | The Bondi radius \(R(u, \theta, \phi)\) is of the worldtube |
| CBondiU | Bondi parameter \(U\) |
| CBondiUAtScri | The surface quantity of Bondi \(U\) evaluated at the null spacetime boundary \(\mathcal I^+\) |
| CBondiUbar | Bondi parameter \(\bar{U}\) |
| CBondiW | Bondi parameter \(W\) |
| CBoundaryValue | A prefix tag representing the boundary data for a quantity on the extraction surface |
| CCauchyAngularCoords | |
| CCauchyCartesianCoords | |
| CCauchyGaugeC | The spin-weight 2 angular Jacobian factor in the Cauchy coordinates, similar to Eq. (31a) of [83], but without hat |
| CCauchyGaugeD | The spin-weight 0 angular Jacobian factor in the Cauchy coordinates, similar to Eq. (31b) of [83], but without hat |
| CCauchyGaugeOmega | The conformal factor in the Cauchy coordinates, similar to Eq. (32) of [83], but without hat |
| CCceEvolutionPrefix | Tag for duplicating functionality of another tag, but allows creation from options in the Cce::Evolution option group |
| CComplexInertialRetardedTime | Complex storage form for the asymptotically inertial retarded time, for taking spin-weighted derivatives |
| CDlambda | The derivative with respect to \(\lambda\), where \(\lambda\) is an affine parameter along \(l\), see Eq. (19a) of [83] |
| CDr | The derivative with respect to Bondi \(r\) |
| CDu | The derivative with respect to Bondi retarded time \(u\) |
| CDuR | A tag for the first time derivative of the worldtube parameter \(\partial_u R\), where \(R(u, \theta, \phi)\) is Bondi radius of the worldtube |
| CDuRDividedByR | The value \(\partial_u R / R\), where \(R(u, \theta, \phi)\) is Bondi radius of the worldtube |
| CDy | The derivative with respect to the numerical coordinate \(y = 1 - 2R/r\), where \(R(u, \theta, \phi)\) is Bondi radius of the worldtube |
| CEndTime | |
| CEndTimeFromFile | Represents the final time of a bounded CCE evolution, determined either from option specification or from the file |
| CEthEthbarRDividedByR | The value \(\eth \bar{\eth} R / R\), where \(R(u, \theta, \phi)\) is Bondi radius of the worldtube |
| CEthEthRDividedByR | The value \(\eth \eth R / R\), where \(R(u, \theta, \phi)\) is Bondi radius of the worldtube |
| CEthInertialRetardedTime | Represents \(\eth u_{\rm inertial}\), which is a useful quantity for asymptotic coordinate transformations |
| CEthRDividedByR | The value \(\eth R / R\), where \(R(u, \theta, \phi)\) is Bondi radius of the worldtube |
| CEvolutionGaugeBoundaryValue | A prefix tag representing the gauge-transformed boundary data for a quantity on the extraction surface |
| CExp2Beta | The value \(\exp(2\beta)\) |
| CFilterLMax | |
| CGhInterfaceManager | |
| CH5WorldtubeBoundaryDataManager | A tag that constructs a MetricWorldtubeDataManager from options |
| CInertialRetardedTime | The asymptotically inertial retarded time in terms of the evolution time variable |
| CInitializeJ | Tag for first-hypersurface initialization procedure specified by input options |
| CInitializeJBase | Base tag for first-hypersurface initialization procedure |
| CIntegrand | A prefix tag representing a quantity that will appear on the right-hand side of an explicitly regular differential equation |
| CInterfaceManagerInterpolationStrategy | Intended for use in the const global cache to communicate to the sending elements when they should be sending worldtube data for CCE to the interpolator |
| CInterpolationManager | |
| CJbarQMinus2EthBeta | The value \( \bar{J} (Q - 2 \eth \beta ) \) |
| CLinearFactor | A prefix tag representing a linear factor that acts on Tag. To determine the spin weight, It is assumed that the linear factor plays the role of \(L\) in an equation of the form, \( (y - 1) \partial_y H + L H + L^\prime \bar{H} = A + (1 - y) B \) |
| CLinearFactorForConjugate | A prefix tag representing a linear factor that acts on Tag. To determine the spin weight, it is assumed that the linear factor plays the role of \(L^\prime\) in an equation of the form, \( (y - 1) \partial_y H + L H + L^\prime \bar{H} = A + (1 - y) B \) |
| CLMax | |
| CNews | |
| CNoEndTime | Represents the final time of a CCE evolution that should just proceed until it receives no more boundary data and becomes quiescent |
| CNumberOfRadialPoints | |
| CObservationLMax | |
| COneMinusY | Coordinate value \((1 - y)\), which will be cached and sent to the implementing functions |
| COutputNoninertialNews | Represents whether the news should be provided at noninertial times |
| CPartiallyFlatAngularCoords | The angular coordinates for the partially flat Bondi-like coordinates |
| CPartiallyFlatCartesianCoords | The partially flat Bondi-like coordinates |
| CPartiallyFlatGaugeC | The spin-weight 2 angular Jacobian factor in the partially flat Bondi-like coordinates, see Eq. (31a) of [83] |
| CPartiallyFlatGaugeD | The spin-weight 0 angular Jacobian factor in the partially flat Bondi-like coordinates, see Eq. (31b) of [83] |
| CPartiallyFlatGaugeOmega | The conformal factor in the partially flat Bondi-like coordinates, associated with an angular transformation, see Eq. (32) of [83] |
| CPoleOfIntegrand | A prefix tag representing the coefficient of a pole part of the right-hand side of a singular differential equation |
| CPsi0 | The Weyl scalar \(\Psi_0\) |
| CPsi0Match | The Weyl scalar \(\Psi_0\) for matching (in the Cauchy frame) |
| CPsi1 | The Weyl scalar \(\Psi_1\) |
| CPsi2 | The Weyl scalar \(\Psi_2\) |
| CPsi3 | The Weyl scalar \(\Psi_3\) |
| CPsi4 | The Weyl scalar \(\Psi_4\) |
| CRadialFilterAlpha | |
| CRadialFilterHalfPower | |
| CRegularIntegrand | A prefix tag representing the regular part of the right-hand side of a regular differential equation |
| CScriPlus | A prefix tag representing the value at \(\mathcal I^+\) |
| CScriPlusFactor | A prefix tag representing an additional correction factor necessary to compute the quantity at \(\mathcal I^+\) |
| CSelfStartGhInterfaceManager | During self-start, we must be in lockstep with the GH system (if running concurrently), because the step size is unchangable during self-start |
| CSpecifiedEndTime | Represents the final time of a bounded CCE evolution that must be supplied in the input file (for e.g. analytic tests) |
| CSpecifiedStartTime | Represents the start time of a bounded CCE evolution that must be supplied in the input file (for e.g. analytic tests) |
| CStartTime | |
| CStartTimeFromFile | Represents the start time of a bounded CCE evolution, determined either from option specification or from the file |
| CStrain | The gravitational wave strain \(h\) |
| CTimeIntegral | A prefix tag representing the time integral of the value it prefixes |
| ►NTestHelpers | |
| CAngularCollocationsFor | |
| CCalculateSeparatedTag | |
| CCalculateSeparatedTag< Spectral::Swsh::Tags::Derivative< Tag, DerivKind > > | |
| CCalculateSeparatedTag< Tags::BondiJbar > | |
| CCalculateSeparatedTag< Tags::BondiQbar > | |
| CCalculateSeparatedTag< Tags::BondiUbar > | |
| CCalculateSeparatedTag< Tags::Dy< Tag > > | |
| CCalculateSeparatedTag<::Tags::Multiplies< LhsTag, RhsTag > > | |
| CCopyDataBoxTags | |
| CRadialPolyCoefficientsFor | |
| CWorldtubeModeRecorder | |
| CAnalyticBoundaryDataManager | A boundary data manager that constructs the desired boundary data into the Variables from the data provided by the analytic solution |
| CAnalyticWorldtubeBoundary | Component that supplies CCE worldtube boundary data sourced from an analytic solution |
| CApplySwshJacobianInplace | Performs a mutation to a spin-weighted spherical harmonic derivative value from the numerical coordinate (the spin-weighted derivative at fixed \(y\)) to the Bondi coordinates (the spin-weighted derivative at fixed \(r\)), inplace to the requested tag |
| CApplySwshJacobianInplace< Spectral::Swsh::Tags::Derivative< ArgumentTag, Spectral::Swsh::Tags::Eth > > | Specialization for the spin-weighted derivative \(\eth\) |
| CApplySwshJacobianInplace< Spectral::Swsh::Tags::Derivative< ArgumentTag, Spectral::Swsh::Tags::Ethbar > > | Specialization for the spin-weighted derivative \(\bar{\eth}\) |
| CApplySwshJacobianInplace< Spectral::Swsh::Tags::Derivative< ArgumentTag, Spectral::Swsh::Tags::EthbarEth > > | Specialization for the spin-weighted derivative \(\bar{\eth} \eth\) |
| CApplySwshJacobianInplace< Spectral::Swsh::Tags::Derivative< ArgumentTag, Spectral::Swsh::Tags::EthbarEthbar > > | Specialization for the spin-weighted derivative \(\bar{\eth} \bar{\eth}\) |
| CApplySwshJacobianInplace< Spectral::Swsh::Tags::Derivative< ArgumentTag, Spectral::Swsh::Tags::EthEth > > | Specialization for the spin-weighted derivative \(\eth \eth\) |
| CApplySwshJacobianInplace< Spectral::Swsh::Tags::Derivative< ArgumentTag, Spectral::Swsh::Tags::EthEthbar > > | Specialization for the spin-weighted derivative \(\eth \bar{\eth}\) |
| CBondiWorldtubeDataManager | Manages the 'reduced' cached buffer dataset associated with a CCE worldtube and interpolates to requested time points to provide worldtube boundary data to the main evolution routines |
| CBondiWorldtubeH5BufferUpdater | A WorldtubeBufferUpdater specialized to the CCE input worldtube H5 file produced by the reduced SpEC format |
| CCalculateScriPlusValue | |
| CCalculateScriPlusValue< Tags::EthInertialRetardedTime > | Determines the angular derivative of the asymptotic inertial time, useful for asymptotic coordinate transformations |
| CCalculateScriPlusValue< Tags::News > | Compute the Bondi news from the evolution quantities |
| CCalculateScriPlusValue< Tags::ScriPlus< Tags::Psi0 > > | Computes the leading part of \(\Psi_0\) near \(\mathcal I^+\) |
| CCalculateScriPlusValue< Tags::ScriPlus< Tags::Psi1 > > | Computes the leading part of \(\Psi_1\) near \(\mathcal I^+\) |
| CCalculateScriPlusValue< Tags::ScriPlus< Tags::Psi2 > > | Computes the leading part of \(\Psi_2\) near \(\mathcal I^+\) |
| CCalculateScriPlusValue< Tags::ScriPlus< Tags::Psi3 > > | Computes the leading part of \(\Psi_3\) near \(\mathcal I^+\) |
| CCalculateScriPlusValue< Tags::ScriPlus< Tags::Strain > > | Computes the leading part of the strain \(h\) near \(\mathcal I^+\) |
| CCalculateScriPlusValue< Tags::TimeIntegral< Tags::ScriPlus< Tags::Psi4 > > > | Compute the contribution to the leading \(\Psi_4\) that corresponds to a total time derivative |
| CCalculateScriPlusValue<::Tags::dt< Tags::InertialRetardedTime > > | Assign the time derivative of the asymptotically inertial time coordinate |
| CCceEvolutionLabelTag | |
| CCharacteristicEvolution | The component for handling the CCE evolution and waveform output |
| CComputeBondiIntegrand | Computes one of the inputs for the integration of one of the Characteristic hypersurface equations |
| CComputeBondiIntegrand< Tags::Integrand< Tags::BondiBeta > > | Computes the integrand (right-hand side) of the equation which determines the radial (y) dependence of the Bondi quantity \(\beta\) |
| CComputeBondiIntegrand< Tags::Integrand< Tags::BondiU > > | Computes the integrand (right-hand side) of the equation which determines the radial (y) dependence of the Bondi quantity \(U\) |
| CComputeBondiIntegrand< Tags::LinearFactor< Tags::BondiH > > | Computes the linear factor which multiplies \(H\) in the equation which determines the radial (y) dependence of the Bondi quantity \(H\) |
| CComputeBondiIntegrand< Tags::LinearFactorForConjugate< Tags::BondiH > > | Computes the linear factor which multiplies \(\bar{H}\) in the equation which determines the radial (y) dependence of the Bondi quantity \(H\) |
| CComputeBondiIntegrand< Tags::PoleOfIntegrand< Tags::BondiH > > | Computes the pole part of the integrand (right-hand side) of the equation which determines the radial (y) dependence of the Bondi quantity \(H\) |
| CComputeBondiIntegrand< Tags::PoleOfIntegrand< Tags::BondiQ > > | Computes the pole part of the integrand (right-hand side) of the equation which determines the radial (y) dependence of the Bondi quantity \(Q\) |
| CComputeBondiIntegrand< Tags::PoleOfIntegrand< Tags::BondiW > > | Computes the pole part of the integrand (right-hand side) of the equation which determines the radial (y) dependence of the Bondi quantity \(W\) |
| CComputeBondiIntegrand< Tags::RegularIntegrand< Tags::BondiH > > | Computes the pole part of the integrand (right-hand side) of the equation which determines the radial (y) dependence of the Bondi quantity \(H\) |
| CComputeBondiIntegrand< Tags::RegularIntegrand< Tags::BondiQ > > | Computes the regular part of the integrand (right-hand side) of the equation which determines the radial (y) dependence of the Bondi quantity \(Q\) |
| CComputeBondiIntegrand< Tags::RegularIntegrand< Tags::BondiW > > | Computes the regular part of the integrand (right-hand side) of the equation which determines the radial (y) dependence of the Bondi quantity \(W\) |
| CGaugeAdjustedBoundaryValue | Computes the gauge-transformed Tags::EvolutionGaugeBoundaryValue<Tag> for any of the boundary tags needed in the evolution |
| CGaugeAdjustedBoundaryValue< Tags::BondiBeta > | Computes the evolution gauge quantity \(\hat \beta\) on the worldtube |
| CGaugeAdjustedBoundaryValue< Tags::BondiH > | Computes the evolution gauge quantity \(\hat H\) on the worldtube |
| CGaugeAdjustedBoundaryValue< Tags::BondiJ > | Computes the evolution gauge quantity \(\hat J\) on the worldtube |
| CGaugeAdjustedBoundaryValue< Tags::BondiQ > | Computes the evolution gauge quantity \(\hat Q\) on the worldtube |
| CGaugeAdjustedBoundaryValue< Tags::BondiR > | Computes the evolution gauge Bondi \(\hat R\) on the worldtube from Cauchy gauge quantities |
| CGaugeAdjustedBoundaryValue< Tags::BondiU > | Computes the evolution gauge quantity \(\mathcal U\) on the worldtube |
| CGaugeAdjustedBoundaryValue< Tags::BondiW > | Computes the evolution gauge quantity \(\hat W\) on the worldtube |
| CGaugeAdjustedBoundaryValue< Tags::Dr< Tags::BondiJ > > | Computes the evolution gauge quantity \(\partial_{\hat r} \hat J\) on the worldtube |
| CGaugeAdjustedBoundaryValue< Tags::DuRDividedByR > | Computes the evolution gauge \(\partial_{\hat u} \hat R / \hat R\) on the worldtube |
| CGaugeUpdateAngularFromCartesian | Update the angular coordinates stored in AngularTag via trigonometric operations applied to the Cartesian coordinates stored in CartesianTag |
| CGaugeUpdateInertialTimeDerivatives | Update the inertial gauge cartesian coordinate derivative \(\partial_u \hat x(x)\) |
| CGaugeUpdateInterpolator | Update the interpolator stored in Spectral::Swsh::Tags::SwshInterpolator<AngularCoordinates> |
| CGaugeUpdateJacobianFromCoordinates | From the angular coordinates AngularCoordinateTag and the Cartesian coordinates CartesianCoordinateTag, determine the spin-weighted Jacobian factors GaugeFactorSpin2 and GaugeFactorSpin0 |
| CGaugeUpdateOmega | Update the quantity \(\hat \omega\) and \(\hat \eth \hat \omega\) for updated spin-weighted Jacobian quantities \(\hat c\) and \(\hat d\) |
| CGaugeUpdateTimeDerivatives | Update the Cauchy gauge cartesian coordinate derivative \(\partial_u x(\hat x)\), as well as remaining gauge quantities \(\mathcal U^{(0)}\), \(\hat U \equiv \mathcal U - \mathcal U^{(0)}\), and \(\partial_{\hat u} \hat \omega\) to maintain asymptotically inertial angular coordinates |
| CGhWorldtubeBoundary | Component that supplies CCE worldtube boundary data sourced from a running GH system |
| CH5WorldtubeBoundary | Component that supplies CCE worldtube boundary data |
| CInitializeGauge | Initialize to default values (identity transform) all of the angular gauge quantities for the boundary gauge transforms |
| CInitializeScriPlusValue | Initialize the \(\mathcal I^+\) value Tag for the first hypersurface |
| CInitializeScriPlusValue< Tags::InertialRetardedTime > | Initialize the inertial retarded time to the value provided in the mutator arguments |
| CMetricWorldtubeDataManager | Manages the cached buffer data associated with a CCE worldtube and interpolates to requested time points to provide worldtube boundary data to the main evolution routines |
| CMetricWorldtubeH5BufferUpdater | A WorldtubeBufferUpdater specialized to the CCE input worldtube H5 file produced by SpEC |
| Cmock_gh_worldtube_boundary | |
| Cmock_h5_worldtube_boundary | |
| Cpre_swsh_derivative_tags_to_compute_for | A typelist for the set of tags computed by the set of template specializations of ComputePreSwshDerivatives |
| CPrecomputeCceDependencies | A set of procedures for computing the set of inputs to the CCE integrand computations that can be computed before any of the intermediate integrands are evaluated |
| CPrecomputeCceDependencies< BoundaryPrefix, Tags::BondiK > | Computes \(K = \sqrt{1 + J \bar{J}}\) |
| CPrecomputeCceDependencies< BoundaryPrefix, Tags::BondiR > | Computes a volume version of Bondi radius of the worldtube \(R\) from its boundary value (by repeating it over the radial dimension) |
| CPrecomputeCceDependencies< BoundaryPrefix, Tags::DuRDividedByR > | Computes \(\partial_u R / R\) from its boundary value (by repeating it over the radial dimension) |
| CPrecomputeCceDependencies< BoundaryPrefix, Tags::EthEthbarRDividedByR > | Computes \(\eth \bar{\eth} R / R\) by differentiating and repeating the boundary value of \(R\) |
| CPrecomputeCceDependencies< BoundaryPrefix, Tags::EthEthRDividedByR > | Computes \(\eth \eth R / R\) by differentiating and repeating the boundary value of \(R\) |
| CPrecomputeCceDependencies< BoundaryPrefix, Tags::EthRDividedByR > | Computes \(\eth R / R\) by differentiating and repeating the boundary value of \(R\) |
| CPrecomputeCceDependencies< BoundaryPrefix, Tags::OneMinusY > | Computes \(1 - y\) for the CCE system |
| CPreSwshDerivatives | A set of procedures for computing the set of inputs to the CCE integrand computations that are to be performed prior to the spin-weighted spherical harmonic differentiation (and for the first step in the series of integrations, after the PrecomputeCceDependencies) |
| CPreSwshDerivatives< Tags::BondiJbar > | Compute \(\bar{J}\) |
| CPreSwshDerivatives< Tags::BondiQbar > | |
| CPreSwshDerivatives< Tags::BondiUbar > | Compute \(\bar{U}\) |
| CPreSwshDerivatives< Tags::ComplexInertialRetardedTime > | Copies the values of the inertial retarded time into a spin-weighted container so that spin-weighted derivatives can be taken |
| CPreSwshDerivatives< Tags::Du< Tags::BondiJ > > | Compute \(\partial_u J\) from \(H\) and the Jacobian factors |
| CPreSwshDerivatives< Tags::Dy< Spectral::Swsh::Tags::Derivative< Tag, DerivKind > > > | Compute the derivative with respect to the numerical radial coordinate \(y\) of a quantity which is a spin-weighted spherical harmonic derivative |
| CPreSwshDerivatives< Tags::Dy< Tag > > | Compute the derivative of the quantity represented by Tag with respect to the numerical radial coordinate \(y\) |
| CPreSwshDerivatives< Tags::Dy< Tags::BondiBeta > > | Computes the first derivative with respect to \(y\) of Tags::BondiBeta |
| CPreSwshDerivatives< Tags::Dy< Tags::BondiU > > | Computes the first derivative with respect to \(y\) of Tags::BondiU |
| CPreSwshDerivatives< Tags::Exp2Beta > | Compute \(\exp(2 \beta)\) |
| CPreSwshDerivatives< Tags::JbarQMinus2EthBeta > | Compute \(\bar{J} * (Q - 2 \eth \beta)\) |
| CPreSwshDerivatives<::Tags::Multiplies< Lhs, Rhs > > | Compute the product of Lhs and Rhs |
| CPreSwshDerivatives<::Tags::Multiplies< Lhs, Tags::BondiJbar > > | Compute the product of \(\bar{J}\) and the quantity represented by Rhs |
| CPreSwshDerivatives<::Tags::Multiplies< Tags::BondiJbar, Rhs > > | Compute the product of \(\bar{J}\) and the quantity represented by Rhs |
| CPreSwshDerivatives<::Tags::Multiplies< Tags::BondiUbar, Rhs > > | Compute the product of \(\bar{U}\) and the quantity represented by Rhs |
| CRadialIntegrateBondi | Computational structs for evaluating the hypersurface integrals during CCE evolution. These are compatible with use in db::mutate_apply |
| CRadialIntegrateBondi< BoundaryPrefix, Tags::BondiH > | |
| CRadialIntegrateBondi< BoundaryPrefix, Tags::BondiQ > | |
| CRadialIntegrateBondi< BoundaryPrefix, Tags::BondiW > | |
| CReducedWorldtubeModeRecorder | Records a compressed representation of SpEC-like worldtube data associated with just the spin-weighted scalars required to perform the CCE algorithm |
| CScriPlusInterpolationManager | Stores necessary data and interpolates on to new time points at scri+ |
| CScriPlusInterpolationManager< VectorTypeToInterpolate, ::Tags::Multiplies< MultipliesLhs, MultipliesRhs > > | Stores necessary data and interpolates on to new time points at scri+, multiplying two results together before supplying the result |
| CScriPlusInterpolationManager< VectorTypeToInterpolate, Tags::Du< Tag > > | Stores necessary data and interpolates on to new time points at scri+, differentiating before supplying the result |
| Csecond_swsh_derivative_tags_to_compute_for | A typelist for the set of tags computed by multiple spin-weighted differentiation using utilities from the Swsh namespace |
| Csingle_swsh_derivative_tags_to_compute_for | A typelist for the set of tags computed by single spin-weighted differentiation using utilities from the Swsh namespace |
| CSystem | |
| CVolumeWeyl< Tags::Psi0 > | Compute the Weyl scalar \(\Psi_0\) in the volume according to a standard set of Newman-Penrose vectors |
| CWorldtubeBufferUpdater | Abstract base class for utilities that are able to perform the buffer updating procedure needed by the WorldtubeDataManager |
| CWorldtubeComponentBase | Generic base class for components that supply CCE worldtube boundary data. See class specializations for specific worldtube boundary components |
| CWorldtubeDataManager | Abstract base class for managers of CCE worldtube data that is provided in large time-series chunks, especially the type provided by input h5 files |
| ►NConvergence | Items related to checking the convergence of numerical algorithms |
| ►NOptionTags | Option tags related to the convergence of iterative algorithms |
| CCriteria | |
| CIterations | |
| ►NTags | Tags related to the convergence of iterative algorithms |
| CCriteria | Convergence::Criteria that determine the iterative algorithm has converged |
| CHasConverged | Holds a Convergence::HasConverged flag that signals the iterative algorithm has converged, along with the reason for convergence |
| CIterationId | Identifies a step in an iterative algorithm |
| CIterations | A fixed number of iterations to run the iterative algorithm |
| ►CCriteria | Criteria that determine an iterative algorithm has converged |
| CAbsoluteResidual | |
| CMaxIterations | |
| CRelativeResidual | |
| CHasConverged | Signals convergence of the algorithm |
| ►Ncpp20 | C++ STL code present in C++20 |
| Carray | A std::array implementation with partial C++20 support |
| Cremove_cvref | |
| Ncpp2b | C++ STL code present in C++2b |
| ►NCurvedScalarWave | Items related to evolving a scalar wave on a curved background |
| ►NAnalyticData | Holds classes implementing analytic data for the CurvedScalarWave system |
| ►CScalarWaveGr | Analytic initial data for scalar waves in curved spacetime |
| CBackground | |
| CScalarField | |
| ►NBoundaryCorrections | Boundary corrections/numerical fluxes |
| CBoundaryCorrection | The base class used to make boundary corrections factory createable so they can be specified in the input file |
| CUpwindPenalty | Computes the upwind multipenalty boundary correction for scalar wave in curved spacetime |
| ►NTags | Tags for the curved scalar wave system |
| CCharacteristicFields | |
| CCharacteristicSpeeds | |
| CComputeLargestCharacteristicSpeed | Computes the largest magnitude of the characteristic speeds |
| CConstraintGamma1 | |
| CConstraintGamma2 | |
| CEvolvedFieldsFromCharacteristicFields | |
| CLargestCharacteristicSpeed | |
| COneIndexConstraint | Tag for the one-index constraint of the scalar wave system in curved spacetime |
| COneIndexConstraintCompute | Compute item to get the one-index constraint for the scalar-wave evolution system |
| CTwoIndexConstraint | Tag for the two-index constraint of the scalar wave system in curved spacetime |
| CTwoIndexConstraintCompute | Compute item to get the two-index constraint for the scalar-wave evolution system |
| CVMinus | |
| CVPlus | |
| CVPsi | Tags corresponding to the characteristic fields of the scalar-wave system in curved spacetime |
| CVZero | |
| CCharacteristicFieldsCompute | |
| CCharacteristicSpeedsCompute | |
| CComputeNormalDotFluxes | Compute fluxes for the scalar-wave system in curved spacetime |
| CEvolvedFieldsFromCharacteristicFieldsCompute | |
| CPhi | |
| CPi | |
| CPsi | |
| CSystem | |
| CTimeDerivative | Compute the time derivative of the evolved variables of the first-order scalar wave system on a curved background |
| ►Ndb | Namespace for DataBox related things |
| CBaseTag | Mark a (usually) empty struct as a base tag by inheriting from this |
| CComputeTag | Mark a struct as a compute tag by inheriting from this |
| CDataBox< tmpl::list< Tags... > > | A DataBox stores objects that can be retrieved by using Tags |
| Cis_base_tag | Check if Tag is a base DataBox tag |
| Cis_compute_tag | Check if Tag derives off of db::ComputeTag |
| Cis_immutable_item_tag | Check if Tag is a DataBox tag for an immutable item, i.e. a ComputeTag or ReferenceTag |
| Cis_mutable_item_tag | Check if Tag is a DataBox tag for a mutable item, i.e. a SimpleTag |
| Cis_non_base_tag | Check if Tag is not a base tag |
| Cis_reference_tag | Check if Tag derives off of db::ReferenceTag |
| Cis_simple_tag | Check if Tag is a simple tag |
| Cis_tag | Check if Tag is a DataBox tag, i.e. a BaseTag, SimpleTag, ComputeTag, or ReferenceTag |
| CPrefixTag | Mark a struct as a prefix tag by inheriting from this |
| CReferenceTag | Mark a struct as a reference tag by inheriting from this |
| CSimpleTag | Mark a struct as a simple tag by inheriting from this |
| CSubitems | Struct that can be specialized to allow DataBox items to have subitems. Specializations must define: |
| CSubitems< domain::Tags::Faces< Dim, VariablesTag >, Requires< tt::is_a_v< Variables, typename VariablesTag::type > > > | |
| CSubitems< domain::Tags::Interface< DirectionsTag, VariablesTag >, Requires< tt::is_a_v< Variables, typename VariablesTag::type > > > | |
| CSubitems< domain::Tags::InterfaceCompute< DirectionsTag, VariablesTag >, Requires< tt::is_a_v< Variables, typename VariablesTag::type > > > | |
| CSubitems< domain::Tags::Slice< DirectionsTag, VariablesTag >, Requires< tt::is_a_v< Variables, typename VariablesTag::type > > > | |
| CSubitems< LinearSolver::Schwarz::Tags::Overlaps< VariablesTag, Dim, OptionsGroup >, Requires< tt::is_a_v< Variables, typename VariablesTag::type > > > | |
| CSubitems< Tag, Requires< tt::is_a_v< Variables, typename Tag::type > > > | |
| ►NDenseTriggers | |
| ►CFilter | Filter activations of a dense trigger using a non-dense trigger |
| CFilterOption | |
| CTriggerOption | |
| COr | Trigger when any of a collection of DenseTriggers triggers |
| CTimes | Trigger at specified times |
| ►Ndg | Functionality related to discontinuous Galerkin schemes |
| ►NActions | |
| CFilter< FilterType, tmpl::list< TagsToFilter... > > | Applies a filter to the specified tags |
| ►NEvents | |
| CObserveErrorNorms | |
| ►CObserveErrorNorms< ObservationValueTag, tmpl::list< Tensors... > > | Observe the RMS errors in the tensors compared to their analytic solution |
| CSubfileName | The name of the subfile inside the HDF5 file |
| ►CObserveFields< VolumeDim, ObservationValueTag, tmpl::list< Tensors... >, tmpl::list< AnalyticSolutionTensors... >, tmpl::list< NonSolutionTensors... > > | Observe volume tensor fields |
| CCoordinatesFloatingPointType | The floating point type/precision with which to write the coordinates to disk |
| CFloatingPointTypes | The floating point type/precision with which to write the data to disk |
| CInterpolateToMesh | |
| CSubfileName | The name of the subfile inside the HDF5 file |
| CVariablesToObserve | |
| CObserveVolumeIntegrals | |
| ►CObserveVolumeIntegrals< VolumeDim, ObservationValueTag, tmpl::list< Tensors... > > | Observe the volume integrals of the tensors over the domain |
| CSubfileName | The name of the subfile inside the HDF5 file |
| ►NNumericalFluxes | |
| ►CHll | Compute the HLL numerical flux |
| CLargestIngoingSpeed | Estimate for the largest ingoing signal speed |
| CLargestOutgoingSpeed | Estimate for the largest outgoing signal speed |
| ►CLocalLaxFriedrichs | Compute the local Lax-Friedrichs numerical flux |
| CMaxAbsCharSpeed | The maximum characteristic speed modulus on one side of the interface |
| ►NOptionTags | |
| CDiscontinuousGalerkinGroup | Group holding options for controlling the DG discretization |
| CFormulation | |
| ►Nprotocols | Protocols related to Discontinuous Galerkin functionality |
| ►CNumericalFlux | Defines the interface for DG numerical fluxes |
| Ctest | |
| ►NTags | |
| CFormulation | The DG formulation to use |
| CSimpleBoundaryData | Distinguishes between field data, which can be projected to a mortar, and extra data, which will not be projected |
| CSimpleMortarData | Storage of boundary data on two sides of a mortar |
| ►NDistributedLinearSolverAlgorithmTestHelpers | Functionality to test parallel linear solvers on multiple elements |
| ►NOptionTags | |
| CExpectedResult | |
| CLinearOperator | |
| CSource | |
| CCollectOperatorAction | |
| CComputeOperatorAction | |
| CExpectedResult | |
| CInitializeElement | |
| CLinearOperator | |
| CScalarFieldTag | |
| CSource | |
| CTestResult | |
| ►Ndomain | |
| ►NBoundaryConditions | Domain support for applying boundary conditions |
| CBoundaryCondition | Base class from which all system-specific base classes must inherit |
| CMarkAsPeriodic | Mark a boundary condition as being periodic |
| CNone | None boundary conditions |
| CPeriodic | Periodic boundary conditions |
| ►NCoordinateMaps | Contains all coordinate maps |
| ►NFocallyLiftedInnerMaps | Contains FocallyLiftedInnerMaps |
| CEndcap | A FocallyLiftedInnerMap that maps a 3D unit right cylinder to a volume that connects portions of two spherical surfaces |
| CFlatEndcap | A FocallyLiftedInnerMap that maps a 3D unit right cylinder to a volume that connects a portion of a plane and a spherical surface |
| CFlatSide | A FocallyLiftedInnerMap that maps a 3D unit right cylinder to a volume that connects a 2D annulus to a spherical surface |
| CSide | A FocallyLiftedInnerMap that maps a 3D unit right cylindrical shell to a volume that connects portions of two spherical surfaces |
| NFocallyLiftedMapHelpers | Holds helper functions for use with domain::CoordinateMaps::FocallyLiftedMap |
| ►NTags | Tags for the coordinate maps |
| CCoordinateMap | The coordinate map from source to target coordinates |
| ►NTimeDependent | Contains the time-dependent coordinate maps |
| CCubicScale | Maps the radius as \(r(t) = a(t)\rho + \left(b(t) - a(t)\right) \frac{\rho^3} {R^2}\) where \(\rho\) is the radius of the source coordinates |
| CProductOf2Maps | Product of two codimension=0 CoordinateMaps, where one or both must be time-dependent |
| CProductOf3Maps | Product of three one-dimensional CoordinateMaps |
| CRotation< 2 > | Time-dependent spatial rotation in two dimensions |
| CSphericalCompression | Time-dependent compression of a finite 3D spherical volume |
| CTranslation | Translation map defined by \(x = \xi+T(t)\) |
| CAffine | Affine map from \(\xi \in [A, B]\rightarrow x \in [a, b]\) |
| CBulgedCube | Three dimensional map from the cube to a bulged cube. The cube is shaped such that the surface is compatible with the inner surface of Wedge<3>. The shape of the object can be chosen to be cubical, if the sphericity is set to 0, or to a sphere, if the sphericity is set to 1. The sphericity can be set to any number between 0 and 1 for a bulged cube |
| CCylindricalEndcap | Map from 3D unit right cylinder to a volume that connects portions of two spherical surfaces |
| CCylindricalFlatEndcap | Map from 3D unit right cylinder to a volume that connects a portion of a circle to a portion of a spherical surface |
| CCylindricalFlatSide | Map from 3D unit right cylindrical shell to a volume that connects a portion of an annulus to a portion of a spherical surface |
| CCylindricalSide | Map from a 3D unit right cylindrical shell to a volume that connects portions of two spherical surfaces |
| CDiscreteRotation | A CoordinateMap that swaps/negates the coordinate axes |
| CEquatorialCompression | Redistributes gridpoints on the sphere |
| CEquiangular | Non-linear map from \(\xi \in [A, B]\rightarrow x \in [a, b]\) |
| CFocallyLiftedMap | Map from \((\bar{x},\bar{y},\bar{z})\) to the volume contained between a 2D surface and the surface of a 2-sphere |
| CFrustum | A reorientable map from the cube to a frustum |
| CIdentity | Identity map from \(\xi \rightarrow x\) |
| CKerrHorizonConforming | Distorts cartesian coordinates \(x^i\) such that a coordinate sphere \(\delta_{ij}x^ix^j=C\) is mapped to an ellipsoid of constant Kerr-Schild radius \(r=C\) |
| CProductOf2Maps | Product of two codimension=0 CoordinateMaps |
| CProductOf3Maps | Product of three one-dimensional CoordinateMaps |
| CRotation< 2 > | Spatial rotation in two dimensions |
| CRotation< 3 > | Spatial rotation in three dimensions using Euler angles |
| CSpecialMobius | Redistributes gridpoints within the unit sphere |
| CWedge | Map from a square or cube to a wedge |
| ►Ncreators | Defines classes that create Domains |
| ►Ntime_dependence | Classes and functions for adding time dependence to a domain |
| CComposition | A TimeDependence that is a composition of various other TimeDependences |
| ►CCubicScale | A linear or cubic radial scaling time dependence |
| CAcceleration | The acceleration of the expansion factors |
| CFunctionOfTimeNames | The names of the functions of times to be added to the added to the DataBox |
| CInitialExpansion | The initial values of the expansion factors |
| CInitialExpirationDeltaT | The initial time interval for updates of the functions of time |
| CInitialTime | The initial time of the functions of time |
| COuterBoundary | The outer boundary or pivot point of the domain::CoordinateMaps::TimeDependent::CubicScale map |
| CVelocity | The velocity of the expansion factors |
| CNone | Make the mesh time independent so that it isn't moving |
| ►CSphericalCompression | A spherical compression about some center, as given by domain::CoordinateMaps::TimeDependent::SphericalCompression<false> |
| CCenter | Center for the SphericalCompression map |
| CFunctionOfTimeName | The name of the functions of time to be added to the added to the DataBox for the spherical compression |
| CInitialAcceleration | Initial radial acceleration for the function of time for the spherical compression |
| CInitialExpirationDeltaT | The time interval for updates of the functions of time |
| CInitialTime | The initial time of the function of time |
| CInitialValue | Initial value for function of time for the spherical compression |
| CInitialVelocity | Initial radial velocity for the function of time for the spherical compression |
| CMaxRadius | Maximum radius for the SphericalCompression map |
| CMinRadius | Minimum radius for the SphericalCompression map |
| CTimeDependence | The abstract base class off of which specific classes for adding time dependence into a domain creator must inherit off of |
| CTimeDependenceCompositionTag | A tag used by the Composition class to generate a TimeDependence that is a composition of existing TimeDependences |
| ►CUniformRotationAboutZAxis | A uniform rotation about the \(z\) axis: |
| CAngularVelocity | The \(x\)-, \(y\)-, and \(z\)-velocity |
| CFunctionOfTimeName | The name of the function of time to be added to the DataBox |
| CInitialExpirationDeltaT | The time interval for updates of the functions of time |
| CInitialTime | The initial time of the function of time |
| ►CUniformTranslation | A uniform translation in the \(x-, y-\) and \(z-\)direction |
| CFunctionOfTimeNames | The names of the functions of times to be added to the added to the DataBox |
| CInitialExpirationDeltaT | The time interval for updates of the functions of time |
| CInitialTime | The initial time of the functions of time |
| CVelocity | The \(x\)-, \(y\)-, and \(z\)-velocity |
| ►CAlignedLattice | Create a Domain consisting of multiple aligned Blocks arrayed in a lattice |
| CBlockBounds | |
| CBlocksToExclude | |
| CBoundaryCondition | |
| CInitialGridPoints | |
| CInitialLevels | |
| CIsPeriodicIn | |
| CRefinedGridPoints | |
| CRefinedLevels | |
| ►CBinaryCompactObject | A general domain for two compact objects |
| CAdditionToOuterLayerRadialRefinementLevel | |
| CEnvelopingCube | |
| ►CExcision | Options for an excision region in the domain |
| CBoundaryCondition | |
| CExpansionFunctionOfTimeNames | The names of the functions of times to be added to the DataBox for the expansion map |
| CExpansionMap | |
| CExpansionMapOuterBoundary | The outer boundary or pivot point of the domain::CoordinateMaps::TimeDependent::CubicScale map |
| CInitialAngularVelocity | The angular velocity of the rotation |
| CInitialExpansion | The initial values of the expansion factors |
| CInitialExpansionVelocity | The velocity of the expansion factors |
| CInitialExpirationDeltaT | The initial time interval for updates of the functions of time |
| CInitialGridPoints | |
| CInitialRefinement | |
| CInitialRotationAngle | The initial value of the rotation angle |
| CInitialSizeMapAccelerations | Initial accelerations for functions of time for size maps for objects A,B |
| CInitialSizeMapValues | Initial values for functions of time for size maps for objects A,B |
| CInitialSizeMapVelocities | Initial velocities for functions of time for size maps for objects A,B |
| CInitialTime | The initial time of the functions of time |
| ►CObject | Options for one of the two objects in the binary domain |
| CAdditionToRadialRefinementLevel | |
| CExciseInterior | |
| CInnerRadius | |
| CInterior | |
| COuterRadius | |
| CUseLogarithmicMap | |
| CXCoord | |
| CObjectA | |
| CObjectB | |
| COuterBoundaryCondition | |
| COuterSphere | |
| CRadiusEnvelopingCube | |
| CRadiusOuterSphere | |
| CRotationAboutZAxisFunctionOfTimeName | The name of the function of time to be added to the added to the DataBox for the rotation-about-the-z-axis map |
| CRotationAboutZAxisMap | |
| CSizeMap | |
| CSizeMapFunctionOfTimeNames | The names of the functions of times to be added to the added to the DataBox for the size map |
| CTimeDependentMaps | |
| CUseLogarithmicMapOuterSphericalShell | |
| CUseProjectiveMap | |
| ►CBrick | Create a 3D Domain consisting of a single Block |
| CBoundaryCondition | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CIsPeriodicIn | |
| CLowerBound | |
| CTimeDependence | |
| CUpperBound | |
| ►CCylinder | Create a 3D Domain in the shape of a cylinder where the cross-section is a square surrounded by four two-dimensional wedges (see Wedge) |
| CBoundaryConditions | |
| CHeightPartitioning | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CInnerRadius | |
| CIsPeriodicInZ | |
| CLowerBound | |
| CLowerBoundaryCondition | |
| CMantleBoundaryCondition | |
| COuterRadius | |
| CRadialDistribution | |
| CRadialPartitioning | |
| CUpperBound | |
| CUpperBoundaryCondition | |
| CUseEquiangularMap | |
| ►CCylindricalBinaryCompactObject | A general domain for two compact objects based on cylinders |
| CBoundaryConditions | |
| CCenterA | |
| CCenterB | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CInnerBoundaryCondition | |
| COuterBoundaryCondition | |
| COuterRadius | |
| CRadiusA | |
| CRadiusB | |
| CTimeDependence | |
| ►CDisk | Create a 2D Domain in the shape of a disk from a square surrounded by four wedges |
| CBoundaryCondition | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CInnerRadius | |
| COuterRadius | |
| CUseEquiangularMap | |
| ►CFrustalCloak | Create a 3D cubical domain with two equal-sized abutting excised cubes in the center. This is done by combining ten frusta |
| CBoundaryCondition | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CLengthInnerCube | |
| CLengthOuterCube | |
| COriginPreimage | |
| CProjectionFactor | |
| CUseEquiangularMap | |
| ►CInterval | Create a 1D Domain consisting of a single Block |
| CBoundaryConditions | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CIsPeriodicIn | |
| CLowerBound | |
| CLowerBoundaryCondition | |
| CTimeDependence | |
| CUpperBound | |
| CUpperBoundaryCondition | |
| ►CRectangle | Create a 2D Domain consisting of a single Block |
| CBoundaryCondition | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CIsPeriodicIn | |
| CLowerBound | |
| CTimeDependence | |
| CUpperBound | |
| ►CRefinementRegion | |
| CLowerCornerIndex | |
| CRefinement | |
| CUpperCornerIndex | |
| ►CRotatedBricks | Create a 3D Domain consisting of eight rotated Blocks |
| CBoundaryCondition | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CIsPeriodicIn | |
| CLowerBound | |
| CMidpoint | |
| CUpperBound | |
| ►CRotatedIntervals | Create a 1D Domain consisting of two rotated Blocks. The left block has its logical \(\xi\)-axis aligned with the grid x-axis. The right block has its logical \(\xi\)-axis opposite to the grid x-axis. This is useful for testing code that deals with unaligned blocks |
| CBoundaryConditions | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CIsPeriodicIn | |
| CLowerBound | |
| CLowerBoundaryCondition | |
| CMidpoint | |
| CUpperBound | |
| CUpperBoundaryCondition | |
| ►CRotatedRectangles | Create a 2D Domain consisting of four rotated Blocks |
| CBoundaryCondition | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CIsPeriodicIn | |
| CLowerBound | |
| CMidpoint | |
| CUpperBound | |
| ►CShell | Creates a 3D Domain in the shape of a hollow spherical shell consisting of six wedges |
| CAspectRatio | |
| CBoundaryConditions | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CInnerBoundaryCondition | |
| CInnerRadius | |
| COuterBoundaryCondition | |
| COuterRadius | |
| CRadialDistribution | |
| CRadialPartitioning | |
| CTimeDependence | |
| CUseEquiangularMap | |
| CWhichWedges | |
| ►CSphere | Create a 3D Domain in the shape of a sphere consisting of six wedges and a central cube. For an image showing how the wedges are aligned in this Domain, see the documentation for Shell |
| CBoundaryCondition | |
| CInitialGridPoints | |
| CInitialRefinement | |
| CInnerRadius | |
| COuterRadius | |
| CUseEquiangularMap | |
| ►NFunctionsOfTime | Contains functions of time to support the dual frame system |
| ►NFunctionOfTimeHelpers | |
| CStoredInfo | Stores info at a particlar time about a function and its derivatives |
| CStoredInfo< MaxDerivPlusOne, false > | |
| ►NOptionTags | |
| CCubicFunctionOfTimeOverride | Groups options for reading in FunctionOfTime data from SpEC |
| CFunctionOfTimeFile | Path to an H5 file containing SpEC FunctionOfTime data |
| CFunctionOfTimeNameMap | Pairs of strings mapping SpEC FunctionOfTime names to SpECTRE names |
| CFixedSpeedCubic | Sets \(f(t)\) and derivatives using cubic rational functions, such that the first derivative approaches a constant and the second derivative approaches zero |
| CFunctionOfTime | Base class for FunctionsOfTime |
| CPiecewisePolynomial | A function that has a piecewise-constant MaxDerivth derivative |
| CSettleToConstant | Given an initial function of time, transitions the map to a constant-in-time value |
| NInitialization | |
| ►NOptionTags | |
| CDomainCreator | The input file tag for the DomainCreator to use |
| ►Nprotocols | |
| ►CMetavariables | Compile-time options for a Domain |
| Ctest | |
| ►NTags | Tags for the domain |
| CBoundaryCoordinates | Computes the coordinates in the frame Frame on the faces defined by Direction. Intended to be prefixed by a Tags::InterfaceCompute to define the directions on which to compute the coordinates |
| CBoundaryDirectionsExterior | The set of directions which correspond to external boundaries. To be used to represent data which exists on the exterior side of the external boundary faces |
| CBoundaryDirectionsExteriorCompute | |
| CBoundaryDirectionsInterior | The set of directions which correspond to external boundaries. Used for representing data on the interior side of the external boundary faces |
| CBoundaryDirectionsInteriorCompute | |
| CCharSpeedCompute | Compute the characteristic speeds on the moving mesh given the characteristic speeds if the mesh were stationary |
| CCoordinates | The coordinates in a given frame |
| CCoordinatesMeshVelocityAndJacobians | The Inertial coordinates, the inverse Jacobian from the Grid to the Inertial frame, the Jacobian from the Grid to the Inertial frame, and the Inertial mesh velocity |
| CCoordinatesMeshVelocityAndJacobiansCompute | Computes the Inertial coordinates, the inverse Jacobian from the Grid to the Inertial frame, the Jacobian from the Grid to the Inertial frame, and the Inertial mesh velocity |
| CDetInvJacobian | The determinant of the inverse Jacobian from the source frame to the target frame |
| CDetInvJacobianCompute | Computes the determinant of the inverse Jacobian |
| CDirection | Direction to an interface |
| CDivMeshVelocity | The divergence of the mesh velocity |
| CDomain | The Domain |
| CElement | The Element associated with the DataBox |
| CElementMap | The coordinate map from logical to grid coordinate |
| CElementToInertialInverseJacobian | Computes the Logical to Inertial inverse Jacobian from CoordinatesVelocityAndJacobians |
| CFaces | The Tag on element faces |
| CFunctionsOfTime | The FunctionsOfTime initialized from a DomainCreator or (if override_functions_of_time is true in the metavariables) read from a file |
| CInertialFromGridCoordinatesCompute | Computes the Inertial coordinates from CoordinatesVelocityAndJacobians |
| CInertialMeshVelocityCompute | Computes the Inertial mesh velocity from CoordinatesVelocityAndJacobians |
| CInitialExtents | The number of grid points per dimension for all elements in each block of the initial computational domain |
| CInitialRefinementLevels | The initial refinement level per dimension for all elements in each block of the initial computational domain |
| CInterface | Tag which is either a SimpleTag for quantities on an interface, base tag to a compute item which acts on tags on an interface, or base tag to a compute item which slices a tag from the volume to an interface |
| CInterfaceCompute | Compute tag for representing items computed on a set of interfaces. Can be retrieved using Tags::Interface<DirectionsTag, Tag> |
| CInterfaceCompute< Tags::BoundaryDirectionsExterior< VolumeDim >, UnnormalizedFaceNormalCompute< VolumeDim, Frame > > | Specialisation of UnnormalizedFaceNormal for the external boundaries which inverts the normals. Since ExternalBoundariesDirections are meant to represent ghost elements, the normals should correspond to the normals in said element, which are inverted with respect to the current element |
| CInterfaceCompute< Tags::BoundaryDirectionsExterior< VolumeDim >, UnnormalizedFaceNormalMovingMeshCompute< VolumeDim > > | |
| CInterfaceMesh | Computes the VolumeDim-1 dimensional mesh on an interface from the volume mesh. Tags::InterfaceCompute<Dirs, InterfaceMesh<VolumeDim>> is retrievable as Tags::Interface<Dirs, Mesh<VolumeDim>> from the DataBox |
| CInternalDirections | The set of directions to neighboring Elements |
| CInternalDirectionsCompute | |
| CInverseJacobian | The inverse Jacobian from the source frame to the target frame |
| CInverseJacobianCompute | Computes the inverse Jacobian of the map held by MapTag at the coordinates held by SourceCoordsTag. The coordinates must be in the source frame of the map |
| CJacobian | The Jacobian from the source frame to the target frame |
| CJacobianCompute | Computes the Jacobian of the map from the InverseJacobian<Dim, SourceFrame, TargetFrame> tag |
| CLogicalCoordinates | The logical coordinates in the Element |
| CMappedCoordinates | The coordinates in the target frame of MapTag. The SourceCoordsTag's frame must be the source frame of MapTag |
| CMesh | The computational grid of the Element in the DataBox |
| CMeshVelocity | The mesh velocity |
| CMinimumGridSpacing | The minimum coordinate distance between grid points |
| CMinimumGridSpacingCompute | |
| CSizeOfElement | The inertial-coordinate size of an element along each of its logical directions |
| CSizeOfElementCompute | |
| CSlice | Compute tag for representing a compute item that slices data from the volume to a set of interfaces |
| CUnnormalizedFaceNormal | The unnormalized face normal one form |
| CUnnormalizedFaceNormalCompute | |
| CUnnormalizedFaceNormalMovingMeshCompute | |
| CVariablesBoundaryData | Base tag for boundary data needed for updating the variables |
| CBlockId | Index a block of the computational domain |
| CBlockZCurveProcDistribution | Distribution strategy for assigning elements to CPUs using a Morton ('Z-order') space-filling curve to determine placement within each block |
| CCoordinateMap | A coordinate map or composition of coordinate maps |
| CCoordinateMapBase | Abstract base class for CoordinateMap |
| CExpandOverBlocks | Produce a distribution of type T over all blocks and dimensions in the domain, based on values T of variable isotropy and homogeneity |
| Cmake_faces_tag | Wrap Tag in domain::Tags::Faces, unless Tag is in the VolumeTags list |
| ►NElasticity | Items related to solving elasticity problems |
| ►NAnalyticData | Analytic data for the Elasticity system |
| CAnalyticData | Base class for the background of the Elasticity system, i.e. its variable-independent quantities. Derived classes must provide a constitutive relation |
| ►NBoundaryConditions | |
| CLaserBeam | A laser beam with Gaussian profile normally incident to the surface |
| CZero | Impose zero Dirichlet ("fixed") or Neumann ("free") boundary conditions |
| ►NConstitutiveRelations | Constitutive (stress-strain) relations that characterize the elastic properties of a material |
| CConstitutiveRelation | Base class for constitutive (stress-strain) relations that characterize the elastic properties of a material |
| ►CCubicCrystal | A cubic crystalline material |
| CC_11 | |
| CC_12 | |
| CC_44 | |
| ►CIsotropicHomogeneous | An isotropic and homogeneous material |
| CBulkModulus | |
| CShearModulus | |
| ►NSolutions | Analytic solutions of the linear Elasticity equations |
| CAnalyticSolution | Base class for analytic solutions of the linear Elasticity equations |
| ►CBentBeam | A state of pure bending of an elastic beam in 2D |
| CBendingMoment | |
| CHeight | |
| CLength | |
| CMaterial | |
| ►CHalfSpaceMirror | The solution for a half-space mirror deformed by a laser beam |
| CAbsoluteTolerance | |
| CBeamWidth | |
| CIntegrationIntervals | |
| CMaterial | |
| CRelativeTolerance | |
| CZero | The trivial solution \(\xi^i(x)=0\) of the Elasticity equations. Useful as initial guess |
| ►NTags | |
| CConstitutiveRelation | The elastic material's constitutive relation |
| CConstitutiveRelationReference | Reference the constitutive relation provided by the ProviderTag |
| CDisplacement | The material displacement field \(\boldsymbol{u}(x)\) |
| CMinusStress | Minus the symmetric stress, i.e. \(-T^{ij}\), describing pressure within the elastic material. This tag can be used for the flux in a first-order formulation of the elasticity system |
| CPotentialEnergyDensity | The energy density \(U=-\frac{1}{2}S_{ij}T^{ij}\) stored in the deformation of the elastic material |
| CPotentialEnergyDensityCompute | Computes the energy density stored in the deformation of the elastic material |
| CStrain | The symmetric strain \(S_{ij}=\nabla_{(i}u_{j)}\), describing the deformation of the elastic material |
| CStrainCompute | The symmetric strain \(S_{ij}=\nabla_{(i} \xi_{j)}\) in the elastic material |
| CFirstOrderSystem | The linear elasticity equation formulated as a set of coupled first-order PDEs |
| CFluxes | Compute the fluxes \(F^i_A\) for the Elasticity equation on a flat metric in Cartesian coordinates |
| CSources | Add the sources \(S_A\) for the Elasticity equation |
| ►Nelliptic | Functionality related to solving elliptic partial differential equations |
| ►NActions | |
| CInitializeAnalyticSolution | Place the analytic solution of the system fields in the DataBox |
| CInitializeBackgroundFields | Initialize the variable-independent background fields for an elliptic solve |
| CInitializeFields | Initialize the dynamic fields of the elliptic system, i.e. those we solve for |
| CInitializeFixedSources | Initialize the "fixed sources" of the elliptic equations, i.e. their variable-independent source term \(f(x)\) |
| CInitializeOptionalAnalyticSolution | |
| ►NBoundaryConditions | Boundary conditions for elliptic systems |
| CAnalyticSolution< System, Dim, tmpl::list< FieldTags... >, tmpl::list< FluxTags... >, Registrars > | Impose the analytic solution on the boundary. Works only if an analytic solution exists |
| CBoundaryCondition | Base class for boundary conditions for elliptic systems |
| ►Ndg | Functionality related to discontinuous Galerkin discretizations of elliptic equations |
| ►NActions | Actions related to elliptic discontinuous Galerkin schemes |
| CImposeInhomogeneousBoundaryConditionsOnSource | For linear systems, impose inhomogeneous boundary conditions as contributions to the fixed sources (i.e. the RHS of the equations) |
| CInitializeDomain | Initialize items related to the basic structure of the element |
| ►NOptionTags | Option tags related to elliptic discontinuous Galerkin schemes |
| CDiscontinuousGalerkin | |
| CDiscretization | |
| CMassive | |
| CPenaltyParameter | |
| ►Nsubdomain_operator | Items related to the restriction of the DG operator to an element-centered subdomain |
| ►NActions | Actions related to the DG subdomain operator |
| CInitializeSubdomain | Initialize the geometry for the DG subdomain operator |
| ►NTags | |
| CExtrudingExtent | The number of points an element-centered subdomain extends into the neighbor, i.e. the "extruding" overlap extents. This tag is used in conjunction with LinearSolver::Schwarz::Tags::Overlaps to describe the extruding extent into each neighbor |
| CNeighborMortars | Data on the neighbor's side of a mortar. Used to store data for elements that do not overlap with the element-centered subdomain, but play a role in the DG operator nonetheless |
| CSubdomainOperator | The elliptic DG operator on an element-centered subdomain |
| ►NTags | DataBox tags related to elliptic discontinuous Galerkin schemes |
| CElementSize | A measure of element size perpendicular to an element face. Used to compute the penalty (see elliptic::dg::penalty) |
| CMassive | Whether or not to multiply the DG operator with the mass matrix. Massive DG operators can be easier to solve because they are symmetric, or at least closer to symmetry |
| CMortarData | Holds elliptic::dg::MortarData, i.e. boundary data on both sides of a mortar |
| CNormalDotFluxForJump | The quantity \(n_i F^i_u(n_j F^j_v(u))\) where \(F^i\) is the system flux for primal variables \(u\) and auxiliary variables \(v\), and \(n_i\) is the face normal. This quantity is projected to mortars to compute the jump term of the numerical flux |
| CPenaltyParameter | The prefactor to the penalty term of the numerical flux |
| CPerpendicularNumPoints | Number of grid points perpendicular to an element face. Used to compute the penalty (see elliptic::dg::penalty) |
| CInitializeBackground | Initialize background quantities for the elliptic DG operator, possibly including the metric necessary for normalizing face normals |
| CInitializeFacesAndMortars | Initialize the geometry on faces and mortars for the elliptic DG operator |
| CInitializeGeometry | Initialize the background-independent geometry for the elliptic DG operator |
| CMortarData | Boundary data on both sides of a mortar |
| CNormalizeFaceNormal | Normalize face normals, possibly using a background metric. Set InvMetricTag to void to normalize face normals with the Euclidean magnitude |
| ►NOptionTags | |
| CBackground | |
| CBoundaryConditionType | |
| CInitialGuess | |
| ►NTags | |
| CBackground | The variable-independent part of the elliptic equations, e.g. the fixed-sources \(f(x)\) in a Poisson equation \(-\Delta u=f(x)\), the matter-density in a TOV-solve or the conformal metric in an XCTS solve |
| CBoundaryConditionType | The elliptic::BoundaryConditionType to impose on the variable represented by Tag, e.g. Dirichlet or Neumann boundary conditions |
| CBoundaryConditionTypes | The elliptic::BoundaryConditionType to impose on the variables represented by Tags, e.g. Dirichlet or Neumann boundary conditions |
| CInitialGuess | The initial guess for the elliptic solve |
| ►NTriggers | |
| ►CEveryNIterations | Trigger every N iterations after a given offset |
| CN | |
| COffset | |
| CDefaultElementsAllocator | A Parallel::protocols::ArrayElementsAllocator that creates array elements to cover the initial computational domain |
| CDgElementArray | The parallel component responsible for managing the DG elements that compose the computational domain |
| ►NEquationsOfState | Contains all equations of state, including base class |
| ►CDarkEnergyFluid | Equation of state for a dark energy fluid |
| CParameterW | |
| CEquationOfState | Base class for equations of state depending on whether or not the system is relativistic, and the number of independent thermodynamic variables (ThermodynamicDim) needed to determine the pressure |
| CEquationOfState< IsRelativistic, 1 > | Base class for equations of state which need one thermodynamic variable in order to determine the pressure |
| CEquationOfState< IsRelativistic, 2 > | Base class for equations of state which need two independent thermodynamic variables in order to determine the pressure |
| ►CIdealFluid | Equation of state for an ideal fluid |
| CAdiabaticIndex | |
| ►CPolytropicFluid | Equation of state for a polytropic fluid |
| CPolytropicConstant | |
| CPolytropicExponent | |
| ►NEvents | |
| ►CChangeSlabSize | Trigger a slab size change |
| CDelayChange | |
| CStepChoosers | |
| CCompletion | Sets the termination flag for the code to exit |
| ►CObserveNorms< tmpl::list< ObservableTensorTags... > > | Compute norms of tensors in the DataBox and write them to disk |
| CSubfileName | The name of the subfile inside the HDF5 file |
| CTensorsToObserve | The tensor to observe and how to do the reduction |
| ►CObserveTimeStep | Observe the size of the time steps |
| CPrintTimeToTerminal | |
| CSubfileName | The name of the subfile inside the HDF5 file |
| ►Nevolution | Functionality for evolving hyperbolic partial differential equations |
| ►NActions | |
| CInitializeRunEventsAndDenseTriggers | |
| CRunEventsAndDenseTriggers | Run the events and dense triggers |
| ►Ndg | Functionality for evolving hyperbolic partial differential equations using the discontinuous Galerkin method |
| ►NActions | Actions for using the discontinuous Galerkin to evolve hyperbolic partial differential equations |
| CApplyBoundaryCorrections | Computes the boundary corrections and lifts them to the volume |
| CComputeTimeDerivative | Computes the time derivative for a DG time step |
| ►NInitialization | Functionality for initializing the discontinuous Galerkin to evolve hyperbolic partial differential equations |
| CDomain | Initialize items related to the basic structure of the element |
| CMortars | Initialize mortars between elements for exchanging boundary correction terms |
| ►NOptionTags | |
| CQuadrature | The quadrature points to use |
| ►Nsubcell | Implementation of a generic finite volume/conservative finite difference subcell limiter |
| ►NActions | Actions for the DG-subcell hybrid solver |
| ►NLabels | Labels used to navigate the action list when using a DG-subcell scheme |
| CBeginDg | Label marking the start of the unlimited DG solver |
| CBeginSubcell | Label marking the start of the subcell solver |
| CBeginSubcellAfterDgRollback | Label marking the part of the subcell solver that the unlimited DG solver jumps to after rolling back the unlimited DG step because it was inadmissible |
| CEndOfSolvers | Label marking the end of the step_actions, i.e. the end of both the unlimited DG solver and the subcell solver |
| CInitialize | Initialize the subcell grid, and switch from DG to subcell if the DG solution is inadmissible |
| CReceiveDataForReconstruction | Receive the subcell data from our neighbor, and accumulate the data from the relaxed discrete maximum principle troubled-cell indicator |
| CSelectNumericalMethod | Goes to Labels::BeginDg or Labels::BeginSubcell depending on whether the active grid is Dg or Subcell |
| CSendDataForReconstruction | Sets the local data from the relaxed discrete maximum principle troubled-cell indicator and sends ghost zone data to neighboring elements |
| CTciAndRollback | Run the troubled-cell indicator on the candidate solution and perform the time step rollback if needed |
| CTciAndSwitchToDg | Run the troubled-cell indicator on the subcell solution to see if it is safe to switch back to DG |
| ►Nfd | Code specific to a conservative finite difference subcell limiter |
| ►NActions | Actions specific to using a finite-difference subcell method |
| CTakeTimeStep | Take a finite-difference time step on the subcell grid |
| ►NTags | Tags for the DG-subcell finite difference solver |
| CDetInverseJacobianLogicalToGrid | The determinant of the inverse Jacobian from the logical frame to the grid frame at the cell centers |
| CInverseJacobianLogicalToGrid | The inverse Jacobian from the logical frame to the grid frame at the cell centers |
| Nfv | Code specific to a finite volume subcell limiter |
| ►NOptionTags | Option tags for the DG-subcell solver |
| CSubcellOptions | System-agnostic options for DG-subcell |
| CSubcellSolverGroup | Group holding options for controlling the subcell solver discretization |
| ►NTags | Tags for the DG-subcell solver |
| CActiveGrid | The grid currently used for the DG-subcell evolution on the element |
| CCoordinates | The coordinates in a given frame |
| CDidRollback | Tag indicating whether we are retrying a step after a rollback of a failed DG step |
| CInactive | Mark a tag as holding data for the inactive grid |
| CInactive<::Tags::Variables< TagList > > | Mark a tag as holding data for the inactive grid. |
| CLogicalCoordinatesCompute | The logical coordinates on the subcell grid |
| CMesh | The mesh on the subcells |
| CNeighborDataForReconstructionAndRdmpTci | The neighbor data for reconstruction and the RDMP troubled-cell indicator |
| COnSubcellFaces | Mark a tag as the being on the subcell faces |
| COnSubcells | Mark a tag as the being on the subcell grid |
| CSubcellOptions | System-agnostic options for DG-subcell |
| CTciGridHistory | A record of which grid the TCI requested we use |
| CTciStatus | Stores the status of the troubled cell indicator in the element as a Scalar<DataVector> so it can be observed |
| CTciStatusCompute | Computes the TCI status from the currently active grid and the TCI history |
| CNeighborData | Holds neighbor data needed for the TCI and reconstruction |
| ►CSubcellOptions | Holds the system-agnostic subcell parameters, such as numbers controlling when to switch between DG and subcell |
| CAlwaysUseSubcells | If true, then we always use the subcell method, not DG |
| CInitialData | |
| CInitialDataPerssonExponent | The exponent \(\alpha\) passed to the Persson troubled-cell indicator when applied to the initial data |
| CInitialDataRdmpDelta0 | The \(\delta_0\) parameter in the relaxed discrete maximum principle troubled-cell indicator when applied to the initial data |
| CInitialDataRdmpEpsilon | The \(\epsilon\) parameter in the relaxed discrete maximum principle troubled-cell indicator when applied to the initial data |
| CPerssonExponent | The exponent \(\alpha\) passed to the Persson troubled-cell indicator |
| CRdmpDelta0 | The \(\delta_0\) parameter in the relaxed discrete maximum principle troubled-cell indicator |
| CRdmpEpsilon | The \(\epsilon\) parameter in the relaxed discrete maximum principle troubled-cell indicator |
| ►NTags | Tags used for DG evolution scheme |
| CBoundaryCorrectionAndGhostCellsInbox | The inbox tag for boundary correction communication and DG-subcell ghost zone cells |
| CMagnitudeOfNormal | The magnitude of the unnormalized normal covector to the interface |
| CMortarData | Data on mortars, indexed by (Direction, ElementId) pairs |
| CMortarDataHistory | History of the data on mortars, indexed by (Direction, ElementId) pairs, and used by the linear multistep local time stepping code |
| CMortarMesh | Mesh on the mortars, indexed by (Direction, ElementId) pairs |
| CMortarNextTemporalId | The next temporal id at which to receive data on the specified mortar |
| CMortarSize | Size of a mortar, relative to the element face. That is, the part of the face that it covers |
| CNormalCovector | The normal covector to the interface |
| CNormalCovectorAndMagnitude | The normal covector and its magnitude for all internal faces of an element |
| CQuadrature | The quadrature points to use initially |
| CConservativeDuDt | Calculate \(\partial u/\partial t\) for a conservative system |
| CMortarData | Data on the mortar used to compute the boundary correction for the DG scheme |
| Cusing_subcell | If Metavars has a SubcellOptions member struct and SubcellOptions::subcell_enabled is true then inherits from std::true_type, otherwise inherits from std::false_type |
| ►Ndomain | |
| ►NTags | |
| CDivMeshVelocityCompute | The divergence of the frame velocity |
| ►NInitialization | |
| ►NActions | |
| CSetVariables | Sets variables needed for evolution of hyperbolic systems |
| ►NOptionTags | |
| CBoundaryCorrection | The boundary correction used for coupling the local PDE system solution to solutions from neighboring elements or applying boundary conditions |
| CEventsAndDenseTriggers | The Events to run based on DenseTriggers, similar to OptionTags::EventsAndTriggers |
| CGroup | Groups option tags related to the time evolution, e.g. time step and time stepper |
| CNumericInitialData | Holds option tags for importing numeric initial data for an evolution |
| CSystemGroup | Groups option tags related to the evolution system |
| ►Nprotocols | Protocols related to evolution systems |
| ►CNumericInitialData | Indicates the ConformingType represents the choice to start an evolution with numeric initial data |
| Ctest | |
| ►NTags | |
| CAnalyticCompute | Use the AnalyticSolutionTag to compute the analytic solution of the tags in AnalyticFieldsTagList |
| CBoundaryCorrection | The boundary correction used for coupling together neighboring cells or applying boundary conditions |
| CErrorsCompute | For each Tag in TagsList, compute its difference from the analytic solution |
| CEventsAndDenseTriggers | The Events to run based on DenseTriggers |
| CEventsAndDenseTriggers | Class that checks dense triggers and runs events |
| CNumericInitialData | Use in place of an analytic solution or analytic data to start an evolution with numeric initial data loaded from a data file |
| ►Nfd | Functions and classes for finite difference methods |
| Nreconstruction | Variable and flux vector splitting reconstruction schemes for finite difference methods |
| Nfile_system | A light-weight file system library based on POSIX |
| ►NFilters | |
| ►NTags | |
| CFilter | The global cache tag for the filter |
| ►CExponential | A cached exponential filter |
| CAlpha | The value of exp(-alpha) is what the highest modal coefficient is rescaled by |
| CDisableForDebugging | Turn the filter off |
| CHalfPower | Half of the exponent in the exponential |
| NFirstOrderEllipticSolutionsTestHelpers | |
| Nformaline | Functions for retrieving system and source tree information |
| ►NFrame | Indicates the Frame that a TensorIndexType is in |
| CDistorted | |
| CFrameIsPhysical | Marks a Frame as being "physical" in the sense that it is meaningful to evaluate an analytic solution in that frame |
| CGrid | |
| CInertial | |
| CLogical | |
| CNoFrame | Represents an index that is not in a known frame, e.g. some internal intermediate frame that is irrelevant to the interface |
| CSpherical | Represents a spherical-coordinate frame that is associated with a Cartesian frame, e.g. \((r,\theta,\phi)\) associated with the Inertial frame, as used on an apparent horizon or a wave-extraction surface |
| ►Nfuncl | Higher order function objects similar to std::plus, etc |
| CAbs | Functional for computing abs on an object |
| CAcos | Functional for computing acos on an object |
| CAcosh | Functional for computing acosh on an object |
| CAnd | Functional for computing and of two objects |
| CAsin | Functional for computing asin on an object |
| CAsinh | Functional for computing asinh on an object |
| CAssertEqual | Functional that asserts that the function object C applied to the first and second arguments are equal and returns the function object C applied to the first argument |
| CAtan | Functional for computing atan on an object |
| CAtan2 | Functional for computing atan2 from two objects |
| CAtanh | Functional for computing atanh on an object |
| CCbrt | Functional for computing cbrt on an object |
| CConj | Functional for computing conj on an object |
| CCos | Functional for computing cos on an object |
| CCosh | Functional for computing cosh on an object |
| CDivAssign | Functional for computing /= of two objects |
| CDivides | Functional for computing / of two objects |
| CErf | Functional for computing erf on an object |
| CExp | Functional for computing exp on an object |
| CExp2 | Functional for computing exp2 on an object |
| CFabs | Functional for computing fabs on an object |
| CGetArgument | Functional to retrieve the ArgumentIndexth argument |
| CHypot | Functional for computing hypot from two objects |
| CIdentity | The identity higher order function object |
| CImag | Functional for computing imag on an object |
| CInvCbrt | Functional for computing invcbrt on an object |
| CInvSqrt | Functional for computing invsqrt on an object |
| CLiteral | |
| CLog | Functional for computing log on an object |
| CLog10 | Functional for computing log10 on an object |
| CLog2 | Functional for computing log2 on an object |
| CMax | Functional for computing max from two objects |
| CMin | Functional for computing min from two objects |
| CMinus | Functional for computing - of two objects |
| CMinusAssign | Functional for computing -= of two objects |
| CMultAssign | Functional for computing *= of two objects |
| CMultiplies | Functional for computing * of two objects |
| CNegate | Functional for computing - on an object |
| COr | Functional for computing or of two objects |
| CPlus | Functional for computing + of two objects |
| CPlusAssign | Functional for computing += of two objects |
| CPow | Functional for computing pow from two objects |
| CReal | Functional for computing real on an object |
| CSin | Functional for computing sin on an object |
| CSinh | Functional for computing sinh on an object |
| CSqrt | Functional for computing sqrt on an object |
| CSquare | Function for squaring a quantity |
| CStepFunction | Functional for computing step_function on an object |
| CTan | Functional for computing tan on an object |
| CTanh | Functional for computing tanh on an object |
| CUnaryPow | Function for computing an integer power, forwards to template pow<N>() |
| CVectorPlus | Function for adding two std::vectors of double component-wise |
| ►NGeneralizedHarmonic | Items related to evolving the first-order generalized harmonic system |
| ►NActions | |
| CInitializeConstraints | |
| CInitializeGhAnd3Plus1Variables | |
| ►NBoundaryConditions | Boundary conditions for the generalized harmonic system |
| NBjorhus | Detailed implementation of Bjorhus-type boundary corrections |
| CBoundaryCondition | The base class off of which all boundary conditions must inherit |
| ►CConstraintPreservingBjorhus | Sets constraint preserving boundary conditions using the Bjorhus method |
| CTypeOptionTag | |
| CDirichletAnalytic | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
| COutflow | A BoundaryCondition that only verifies that all characteristic speeds are directed out of the domain; no boundary data is altered by this boundary condition |
| ►NBoundaryCorrections | Boundary corrections/numerical fluxes |
| CBoundaryCorrection | The base class used to make boundary corrections factory createable so they can be specified in the input file |
| CUpwindPenalty | Computes the generalized harmonic upwind multipenalty boundary correction |
| ►NConstraintDamping | Holds classes implementing DampingFunction (functions \(R^n \to R\)) |
| ►NOptionTags | |
| CDampingFunctionGamma0 | |
| CDampingFunctionGamma1 | |
| CDampingFunctionGamma2 | |
| ►NTags | |
| CConstraintGamma0 | Constraint dammping parameter \(\gamma_0\) for the generalized harmonic system (cf. [72]) |
| CConstraintGamma0Compute | Computes the constraint damping parameter \(\gamma_0\) from the coordinates and a DampingFunction |
| CConstraintGamma1 | Constraint dammping parameter \(\gamma_1\) for the generalized harmonic system (cf. [72]) |
| CConstraintGamma1Compute | Computes the constraint damping parameter \(\gamma_1\) from the coordinates and a DampingFunction |
| CConstraintGamma2 | Constraint dammping parameter \(\gamma_2\) for the generalized harmonic system (cf. [72]) |
| CConstraintGamma2Compute | Computes the constraint damping parameter \(\gamma_2\) from the coordinates and a DampingFunction |
| CDampingFunctionGamma0 | A DampingFunction to compute the constraint damping parameter \(\gamma_0\) |
| CDampingFunctionGamma1 | A DampingFunction to compute the constraint damping parameter \(\gamma_0\) |
| CDampingFunctionGamma2 | A DampingFunction to compute the constraint damping parameter \(\gamma_0\) |
| CDampingFunction | Base class defining interface for constraint damping functions |
| ►CGaussianPlusConstant | A Gaussian plus a constant: \(f = C + A \exp\left(-\frac{(x-x_0)^2}{w^2}\right)\) |
| CAmplitude | |
| CCenter | |
| CConstant | |
| CWidth | |
| ►CTimeDependentTripleGaussian | A sum of three Gaussians plus a constant, where the Gaussian widths are scaled by a domain::FunctionsOfTime::FunctionOfTime |
| CAmplitude | |
| CCenter | |
| CConstant | |
| CFunctionOfTimeForScaling | |
| CGaussian | |
| CWidth | |
| ►Ngauges | Gauge conditions for generalized harmonic evolution systems |
| ►NActions | |
| CInitializeDampedHarmonic | Initialize the damped harmonic gauge, either with or without a rollon function |
| ►NOptionTags | |
| CDhGaugeParameters | |
| ►NTags | |
| CDhGaugeParameters | Input option tags for the generalized harmonic evolution system |
| CDhGaugeParameters | A struct holding the parameters for initializing damped harmonic gauge |
| ►NOptionTags | Input option tags for the generalized harmonic evolution system |
| CGroup | |
| ►NSolutions | |
| CWrappedGr | A wrapper for general-relativity analytic solutions that loads the analytic solution and then adds a function that returns any combination of the generalized-harmonic evolution variables, specifically gr::Tags::SpacetimeMetric, GeneralizedHarmonic::Tags::Pi, and GeneralizedHarmonic::Tags::Phi |
| ►NTags | Tags for the generalized harmonic formulation of Einstein equations |
| CCharacteristicFields | |
| CCharacteristicSpeeds | |
| CComputeLargestCharacteristicSpeed | Computes the largest magnitude of the characteristic speeds |
| CConstraintEnergy | Tags corresponding to various constraints of the generalized harmonic system, and their diagnostically useful combinations. |
| CConstraintEnergyCompute | Compute item to get combined energy in all constraints for the generalized harmonic evolution system |
| CDerivLapseCompute | Compute item to get spatial derivatives of lapse from the generalized harmonic variables and spacetime unit normal one-form |
| CDerivShiftCompute | Compute item to get spatial derivatives of the shift vector from generalized harmonic and geometric variables |
| CDerivSpatialMetricCompute | Compute item to get spatial derivatives of the spatial metric from the generalized harmonic spatial derivative variable |
| CEvolvedFieldsFromCharacteristicFields | |
| CExtrinsicCurvatureCompute | Compute item to get extrinsic curvature from generalized harmonic variables and the spacetime normal vector |
| CFConstraint | Tags corresponding to various constraints of the generalized harmonic system, and their diagnostically useful combinations. |
| CFConstraintCompute | Compute item to get the F-constraint for the generalized harmonic evolution system |
| CFourIndexConstraint | Tags corresponding to various constraints of the generalized harmonic system, and their diagnostically useful combinations. |
| CFourIndexConstraintCompute | Compute item to get the four-index constraint for the generalized harmonic evolution system |
| CGamma1Gamma2 | \(\gamma_1 \gamma_2\) constraint damping product |
| CGamma1Plus1 | \(\gamma_1 + 1\) |
| CGaugeConstraint | Tags corresponding to various constraints of the generalized harmonic system, and their diagnostically useful combinations |
| CGaugeConstraintCompute | Compute item to get the gauge constraint for the generalized harmonic evolution system |
| CGaugeH | Gauge source function for the generalized harmonic system |
| CGaugeHImplicitFrom3p1QuantitiesCompute | Compute item to get the implicit gauge source function from 3 + 1 quantities |
| CInitialGaugeH | Initial value of the gauge source function for the generalized harmonic system |
| CLargestCharacteristicSpeed | |
| CNormalDotOneIndexConstraint | \(n^a \mathcal{C}_a\) |
| CPhi | Auxiliary variable which is analytically the spatial derivative of the spacetime metric |
| CPhiCompute | Compute item for the auxiliary variable \(\Phi_{iab}\) used by the generalized harmonic formulation of Einstein's equations |
| CPhiFirstIndexUp | \(\Phi^i{}_{ab}\) |
| CPhiOneNormal | \(\Phi_{iab}n^a\) |
| CPhiThirdIndexUp | \(\Phi_{ia}{}^b\) |
| CPhiTwoNormals | \(\Phi_{iab}n^an^b\) |
| CPi | Conjugate momentum to the spacetime metric |
| CPiCompute | Compute item the conjugate momentum \(\Pi_{ab}\) of the spacetime metric \( \psi_{ab} \) |
| CPiOneNormal | \(\Pi_{ab}n^a\) |
| CPiSecondIndexUp | \(\Pi_a{}^b\) |
| CPiTwoNormals | \(\Pi_{ab}n^an^b\) |
| CShiftDotThreeIndexConstraint | \(\beta^i \mathcal{C}_{iab}\) |
| CSpacetimeChristoffelFirstKindThirdIndexUp | \(\Gamma_{ab}{}^c\) |
| CSpacetimeDerivGaugeH | Spacetime derivatives of the gauge source function for the generalized harmonic system |
| CSpacetimeDerivGaugeHCompute | Compute item to get spacetime derivative of the gauge source function from its spatial and time derivatives |
| CSpacetimeDerivInitialGaugeH | Initial spacetime derivatives of the gauge source function for the generalized harmonic system |
| CThreeIndexConstraint | Tags corresponding to various constraints of the generalized harmonic system, and their diagnostically useful combinations. |
| CThreeIndexConstraintCompute | Compute item to get the three-index constraint for the generalized harmonic evolution system |
| CTimeDerivLapseCompute | Compute item to get time derivative of lapse (N) from the generalized harmonic variables, lapse, shift and the spacetime unit normal 1-form |
| CTimeDerivShiftCompute | Compute item to get time derivative of the shift vector from the generalized harmonic and geometric variables |
| CTimeDerivSpatialMetricCompute | Compute item to get time derivative of the spatial metric from generalized harmonic and geometric variables |
| CTraceExtrinsicCurvatureCompute | Compute item to get the trace of extrinsic curvature from generalized harmonic variables and the spacetime normal vector |
| CTwoIndexConstraint | Tags corresponding to various constraints of the generalized harmonic system, and their diagnostically useful combinations. |
| CTwoIndexConstraintCompute | Compute item to get the two-index constraint for the generalized harmonic evolution system |
| CVMinus | |
| CVPlus | |
| CVSpacetimeMetric | Tags corresponding to the characteristic fields of the generalized harmonic system |
| CVZero | |
| CCharacteristicFieldsCompute | |
| CCharacteristicSpeedsCompute | |
| CComputeNormalDotFluxes | Set the normal dot the flux to zero since the generalized harmonic system has no fluxes and they're currently still needed for the evolution scheme |
| CEvolvedFieldsFromCharacteristicFieldsCompute | |
| CSystem | |
| CTimeDerivative | Compute the RHS of the Generalized Harmonic formulation of Einstein's equations |
| ►CUpwindPenaltyCorrection | Computes the generalized harmonic upwind multipenalty boundary correction |
| CCharSpeedGamma2VSpacetimeMetric | |
| CCharSpeedNormalTimesVMinus | |
| CCharSpeedNormalTimesVPlus | |
| CTensorCharSpeeds | |
| ►Ngr | Holds functions related to general relativity |
| ►NSolutions | Classes which implement analytic solutions to Einstein's equations |
| ►CGaugeWave | Gauge wave in flat spacetime |
| CAmplitude | |
| CWavelength | |
| ►CKerrSchild | Kerr black hole in Kerr-Schild coordinates |
| CCenter | |
| CIntermediateComputer | |
| CIntermediateVars | |
| Cinternal_tags | |
| CMass | |
| CSpin | |
| CMinkowski | The Minkowski solution for flat space in Dim spatial dimensions |
| CTovSolution | TOV solver based on Lindblom's method |
| ►NTags | |
| CDerivativesOfSpacetimeMetric | Spacetime derivatives of the spacetime metric |
| CDerivativesOfSpacetimeMetricCompute | Compute item to get spacetime derivative of spacetime metric from spatial metric, lapse, shift, and their space and time derivatives |
| CDetAndInverseSpatialMetric | |
| CDetAndInverseSpatialMetricCompute | Compute item for spatial metric determinant \(g\) and inverse \(g^{ij}\) in terms of the spatial metric \(g_{ij}\) |
| CDetSpatialMetric | Determinant of the spatial metric |
| CEnergyDensity | The energy density \(E=n_a n_b T^{ab}\), where \(n_a\) denotes the normal to the spatial hypersurface |
| CExtrinsicCurvature | |
| CInverseSpacetimeMetric | |
| CInverseSpacetimeMetricCompute | Compute item for inverse spacetime metric \(\psi^{ab}\) in terms of the lapse \(N\), shift \(N^i\), and inverse spatial metric \(g^{ij}\) |
| CInverseSpatialMetric | Inverse of the spatial metric |
| CLapse | |
| CLapseCompute | Compute item for lapse \(N\) from the spacetime metric \(\psi_{ab}\) and the shift \(N^i\) |
| CMomentumDensity | The spatial momentum density \(S^i=-\gamma^{ij}n^aT_{aj}\), where \(n_a\) denotes the normal to the spatial hypersurface |
| CShift | |
| CShiftCompute | Compute item for shift \(N^i\) from the spacetime metric \(\psi_{ab}\) and the inverse spatial metric \(g^{ij}\) |
| CSpacetimeChristoffelFirstKind | |
| CSpacetimeChristoffelFirstKindCompute | Compute item for spacetime Christoffel symbols of the first kind \(\Gamma_{abc}\) computed from the first derivative of the spacetime metric |
| CSpacetimeChristoffelSecondKind | |
| CSpacetimeChristoffelSecondKindCompute | Compute item for spacetime Christoffel symbols of the second kind \(\Gamma^a_{bc}\) computed from the Christoffel symbols of the first kind and the inverse spacetime metric |
| CSpacetimeMetric | |
| CSpacetimeMetricCompute | Compute item for spacetime metric \(\psi_{ab}\) from the lapse \(N\), shift \(N^i\), and spatial metric \(g_{ij}\) |
| CSpacetimeNormalOneForm | |
| CSpacetimeNormalOneFormCompute | Compute item for spacetime normal oneform \(n_a\) from the lapse \(N\) |
| CSpacetimeNormalVector | |
| CSpacetimeNormalVectorCompute | Compute item for spacetime normal vector \(n^a\) from the lapse \(N\) and the shift \(N^i\) |
| CSpatialChristoffelFirstKind | |
| CSpatialChristoffelFirstKindCompute | Compute item for spatial Christoffel symbols of the first kind \(\Gamma_{ijk}\) computed from the first derivative of the spatial metric |
| CSpatialChristoffelSecondKind | |
| CSpatialChristoffelSecondKindCompute | Compute item for spatial Christoffel symbols of the second kind \(\Gamma^i_{jk}\) computed from the Christoffel symbols of the first kind and the inverse spatial metric |
| CSpatialChristoffelSecondKindContracted | Contraction of the first two indices of the spatial Christoffel symbols: \(\Gamma^i_{ij}\). Useful for covariant divergences |
| CSpatialMetric | |
| CSpatialMetricCompute | Compute item for spatial metric \(g_{ij}\) from the spacetime metric \(\psi_{ab}\) |
| CSpatialRicci | Computes the spatial Ricci tensor from the spatial Christoffel symbol of the second kind and its derivative |
| CSpatialRicciCompute | Compute item for spatial Ricci tensor \(R_{ij}\) computed from SpatialChristoffelSecondKind and its spatial derivatives |
| CSqrtDetSpatialMetric | |
| CSqrtDetSpatialMetricCompute | Compute item to get the square root of the determinant of the spatial metric \(\sqrt{g}\) via gr::Tags::DetAndInverseSpatialMetric |
| CStressTrace | The trace of the spatial stress-energy tensor \(S=\gamma^{ij}\gamma_{ia}\gamma_{jb}T^{ab}\) |
| CTraceExtrinsicCurvature | |
| CTraceSpacetimeChristoffelFirstKind | |
| CTraceSpacetimeChristoffelFirstKindCompute | Compute item for the trace of the spacetime Christoffel symbols of the first kind \(\Gamma_{a} = \Gamma_{abc}g^{bc}\) computed from the Christoffel symbols of the first kind and the inverse spacetime metric |
| CTraceSpatialChristoffelFirstKind | Trace of the spatial Christoffel symbols of the first kind \(\Gamma_{i} = \Gamma_{ijk}g^{jk}\), where \(\Gamma_{ijk}\) are Christoffel symbols of the first kind and \(g^{jk}\) is the inverse spatial metric |
| CTraceSpatialChristoffelFirstKindCompute | Compute item for the trace of the spatial Christoffel symbols of the first kind \(\Gamma_{i} = \Gamma_{ijk}\gamma^{jk}\) computed from the Christoffel symbols of the first kind and the inverse spatial metric |
| CTraceSpatialChristoffelSecondKind | |
| CTraceSpatialChristoffelSecondKindCompute | Compute item for the trace of the spatial Christoffel symbols of the second kind \(\Gamma^{i} = \Gamma^{i}_{jk}\gamma^{jk}\) computed from the Christoffel symbols of the second kind and the inverse spatial metric |
| CWeylElectric | Computes the electric part of the Weyl tensor in vacuum as: \( E_{ij} = R_{ij} + KK_{ij} - K^m_{i}K_{mj}\) where \(R_{ij}\) is the spatial Ricci tensor, \(K_{ij}\) is the extrinsic curvature, and \(K\) is the trace of \(K_{ij}\) |
| CWeylElectricCompute | Compute item for the electric part of the weyl tensor in vacuum Computed from the SpatialRicci, ExtrinsicCurvature, and InverseSpatialMetric |
| CWeylElectricScalar | Computes the scalar \(E_{ij} E^{ij}\) from the electric part of the Weyl tensor \(E_{ij}\) and the inverse spatial metric \(\gamma^{ij}\), i.e. \(E_{ij} E^{ij} = \gamma^{ik}\gamma^{jl}E_{ij}E_{kl}\) |
| CWeylElectricScalarCompute | Can be retrieved using gr::Tags::WeylElectricScalar |
| CAnalyticSolution | Base struct for properties common to all GR analytic solutions |
| CKerrSchildCoords | Contains helper functions for transforming tensors in Kerr spacetime to Kerr-Schild coordinates |
| ►Ngrmhd | Items related to general relativistic magnetohydrodynamics (GRMHD) |
| ►NAnalyticData | Holds classes implementing analytic data for the GrMhd system |
| ►CBlastWave | Analytic initial data for a cylindrical or spherical blast wave |
| CAdiabaticIndex | The adiabatic index of the ideal fluid |
| CGeometryOption | The geometry of the blast wave, i.e. Cylindrical or Spherical |
| CInnerDensity | Density at radii less than InnerRadius |
| CInnerPressure | Pressure at radii less than InnerRadius |
| CInnerRadius | Inside InnerRadius, density is InnerDensity |
| CMagneticField | The x,y,z components of the uniform magnetic field threading the matter |
| COuterDensity | Density at radii greater than OuterRadius |
| COuterPressure | Pressure at radii greater than OuterRadius |
| COuterRadius | Outside OuterRadius, density is OuterDensity |
| ►CBondiHoyleAccretion | Analytic initial data for axially symmetric Bondi-Hoyle accretion |
| CBhDimlessSpin | The dimensionless black hole spin, \(a_* = a/M\) |
| CBhMass | The mass of the black hole, \(M\) |
| CFlowSpeed | The magnitude of the spatial velocity far from the black hole |
| CMagFieldStrength | The strength of the magnetic field |
| CPolytropicConstant | The polytropic constant of the fluid |
| CPolytropicExponent | The polytropic exponent of the fluid |
| CRestMassDensity | The rest mass density of the fluid far from the black hole |
| ►CMagneticFieldLoop | Analytic initial data for an advecting magnetic field loop |
| CAdiabaticIndex | The adiabatic index for the ideal fluid |
| CAdvectionVelocity | The fluid velocity |
| CInnerRadius | The inner radius of the magnetic loop |
| CMagFieldStrength | The strength of the magnetic field |
| COuterRadius | The outer radius of the magnetic loop |
| CPressure | The pressure throughout the fluid |
| CRestMassDensity | The rest mass density throughout the fluid |
| ►CMagneticRotor | Analytic initial data for a magnetic rotor |
| CAdiabaticIndex | The adiabatic index of the ideal fluid |
| CAngularVelocity | Angular velocity inside the rotor |
| CBackgroundDensity | Density outside the rotor |
| CMagneticField | The x,y,z components of the uniform magnetic field threading the matter |
| CPressure | Uniform pressure inside and outside the rotor |
| CRotorDensity | Density inside the rotor |
| CRotorRadius | Radius of the rotor |
| ►CMagnetizedFmDisk | Magnetized fluid disk orbiting a Kerr black hole |
| CBFieldNormGridRes | Grid resolution used in magnetic field normalization |
| CInversePlasmaBeta | The maximum-magnetic-pressure-to-maximum-fluid-pressure ratio |
| CThresholdDensity | The rest mass density (in units of the maximum rest mass density in the disk) below which the matter in the disk is initially unmagetized |
| ►CMagnetizedTovStar | Magnetized TOV star initial data, where metric terms only account for the hydrodynamics not the magnetic fields |
| CCutoffPressureFraction | |
| CPressureExponent | |
| CVectorPotentialAmplitude | |
| COrszagTangVortex | Analytic initial data for the relativistic Orszag-Tang vortex |
| ►CRiemannProblem | Initial conditions for relativistic MHD Riemann problems |
| CAdiabaticIndex | |
| CLapse | |
| CLeftMagneticField | |
| CLeftPressure | |
| CLeftRestMassDensity | |
| CLeftSpatialVelocity | |
| CRightMagneticField | |
| CRightPressure | |
| CRightRestMassDensity | |
| CRightSpatialVelocity | |
| CShiftX | |
| ►NGhValenciaDivClean | Namespace associated with utilities for the combined Generalized Harmonic and Valencia formulation of ideal GRMHD with divergence cleaning systems |
| ►NBoundaryConditions | Boundary conditions for the combined Generalized Harmonic and Valencia GRMHD systems |
| CBoundaryCondition | The base class for Generalized Harmonic and Valencia combined boundary conditions; all boundary conditions for this system must inherit from this base class |
| ►CProductOfConditions | Apply a boundary condition to the combined Generalized Harmonic (GH) and Valencia GRMHD system using the boundary conditions defined separately for the GH and Valencia systems |
| CGhCondition | |
| CValenciaCondition | |
| ►NBoundaryCorrections | Boundary corrections/numerical fluxes |
| CBoundaryCorrection | The base class used to make boundary corrections factory createable so they can be specified in the input file |
| ►CProductOfCorrections | Apply a boundary condition to the combined Generalized Harmonic (GH) and Valencia GRMHD system using boundary corrections defined separately for the GH and Valencia systems |
| CGhCorrection | |
| CValenciaCorrection | |
| ►NTags | Tags for the combined system of the Generalized Harmonic formulation for the Einstein field equations and the Valencia GRMHD formulation |
| CComovingMagneticField | The comoving magnetic field \(b^\mu\) |
| CComovingMagneticFieldOneForm | The down-index comoving magnetic field \(b_\mu\) |
| CFConstraintCompute | Compute item to get the F-constraint for the generalized harmonic evolution system with an MHD stress-energy source |
| CFourVelocity | The fluid four-velocity \(u^\mu\) |
| CFourVelocityOneForm | The down-index four-velocity \(u_\mu\) |
| CStressEnergy | Represents the stress-energy tensor of the matter in the MHD sector of the GRMHD system |
| CTraceReversedStressEnergy | Represents the trace reversed stress-energy tensor of the matter in the MHD sector of the GRMHD system |
| CSystem | |
| CTimeDerivativeTerms | Compute the RHS terms and flux values for both the Generalized Harmonic formulation of Einstein's equations and the Valencia formulation of the GRMHD equations with divergence cleaning |
| ►NSolutions | Holds classes implementing a solution to the GrMhd system |
| ►CAlfvenWave | Circularly polarized Alfvén wave solution in Minkowski spacetime travelling along a background magnetic field |
| CAdiabaticIndex | The adiabatic index for the ideal fluid |
| CBackgroundMagneticField | The background static magnetic field vector |
| CPressure | The constant pressure throughout the fluid |
| CRestMassDensity | The constant rest mass density throughout the fluid |
| CWaveMagneticField | The sinusoidal magnetic field vector associated with the Alfvén wave, perpendicular to the background magnetic field vector |
| CWaveNumber | The wave number of the profile |
| ►CBondiMichel | Bondi-Michel accretion [79] with superposed magnetic field in Schwarzschild spacetime in Cartesian Kerr-Schild coordinates |
| CIntermediateVars | |
| CMagFieldStrength | The strength of the radial magnetic field |
| CMass | The mass of the black hole |
| CPolytropicExponent | The polytropic exponent for the polytropic fluid |
| CSonicDensity | The rest mass density of the fluid at the sonic radius |
| CSonicRadius | The radius at which the fluid becomes supersonic |
| ►CKomissarovShock | A one-dimensional shock solution for an ideal fluid in Minkowski spacetime |
| CAdiabaticIndex | |
| CLeftMagneticField | |
| CLeftPressure | |
| CLeftRestMassDensity | |
| CLeftSpatialVelocity | |
| CRightMagneticField | |
| CRightPressure | |
| CRightRestMassDensity | |
| CRightSpatialVelocity | |
| CShockSpeed | |
| CSmoothFlow | Periodic GrMhd solution in Minkowski spacetime |
| ►NValenciaDivClean | The Valencia formulation of ideal GRMHD with divergence cleaning |
| ►NBoundaryConditions | Boundary conditions for the GRMHD Valencia Divergence Cleaning system |
| CBoundaryCondition | The base class off of which all boundary conditions must inherit |
| CDirichletAnalytic | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
| COutflow | A BoundaryCondition that only verifies that all characteristic speeds are directed out of the domain; no boundary data is altered by this boundary condition |
| ►NBoundaryCorrections | Boundary corrections/numerical fluxes |
| CBoundaryCorrection | The base class used to make boundary corrections factory createable so they can be specified in the input file |
| ►CHll | An HLL Riemann solver |
| CLargestIngoingCharSpeed | |
| CLargestOutgoingCharSpeed | |
| CRusanov | A Rusanov/local Lax-Friedrichs Riemann solver |
| ►Nfd | Finite difference functionality for the ValenciaDivClean form of the GRMHD equations |
| ►NOptionTags | Option tags for reconstruction |
| CReconstructor | Option tag for the reconstructor |
| ►NTags | Tags for reconstruction |
| CReconstructor | Tag for the reconstructor |
| CMonotisedCentralPrim | Monotised central reconstruction. See fd::reconstruction::monotised_central() for details |
| CReconstructor | The base class from which all reconstruction schemes must inherit |
| ►NOptionTags | |
| CDampingParameter | The constraint damping parameter |
| CValenciaDivCleanGroup | Groups option tags related to the ValenciaDivClean evolution system |
| ►NPrimitiveRecoverySchemes | Schemes for recovering primitive variables from conservative variables |
| CKastaunEtAl | Compute the primitive variables from the conservative variables using the scheme of [61] |
| CNewmanHamlin | Compute the primitive variables from the conservative variables using the scheme of Newman and Hamlin, SIAM J. Sci. Comput., 36(4) B661-B683 (2014) |
| CPalenzuelaEtAl | Compute the primitive variables from the conservative variables using the scheme of Palenzuela et al, Phys. Rev. D 92, 044045 (2015) |
| CPrimitiveRecoveryData | Data determined by PrimitiveRecoverySchemes at a single grid point |
| ►Nsubcell | Code required by the DG-subcell/FD hybrid solver |
| ►NOptionTags | |
| CTciOptions | |
| ►NTags | |
| CTciOptions | |
| CDgInitialDataTci | The troubled-cell indicator run on DG initial data to see if we need to switch to subcell |
| CFixConservativesAndComputePrims | Fix the conservative variables and compute the primitive variables |
| CPrimitiveGhostDataOnSubcells | Computes the rest mass density \(\rho\), pressure \(p\), Lorentz factor times the spatial velocity \(W v^i\), magnetic field \(B^i\), and the divergence cleaning field \(\Phi\) on the subcells so they can be used for reconstruction |
| CPrimitiveGhostDataToSlice | Projects the rest mass density \(\rho\), pressure \(p\), Lorentz factor times the spatial velocity \(W v^i\), magnetic field \(B^i\), and the divergence cleaning field \(\Phi\) so they can be projected to the subcells and sent to neighbors for subcell reconstruction |
| CPrimsAfterRollback | Mutator that resizes the primitive variables to the subcell mesh and computes the primitives, but only if evolution::dg::subcell::Tags::DidRollback is true |
| CResizeAndComputePrims | Mutator that, if the active mesh is subcell, resizes the primitive variables to have the size of the subcell and then computes the primitive variables |
| CSwapGrTags | Swaps the inactive and active GR variables |
| CTciOnDgGrid | The troubled-cell indicator run on the DG grid to check if the solution is admissible |
| CTciOnFdGrid | The troubled-cell indicator run on the FD grid to check if the corresponding DG solution is admissible |
| ►CTciOptions | Class holding options using by the GRMHD-specific parts of the troubled-cell indicator |
| CAtmosphereDensity | The density cutoff where if the maximum value of the density in the DG element is below this value we skip primitive recovery and treat the cell as atmosphere |
| CMinimumValueOfD | Minimum value of rest-mass density times Lorentz factor before we switch to subcell. Used to identify places where the density has suddenly become negative |
| CSafetyFactorForB | Safety factor \(\epsilon_B\) |
| CTimeDerivative | Compute the time derivative on the subcell grid using FD reconstruction |
| ►NTags | Tags for the Valencia formulation of the ideal GRMHD equations with divergence cleaning |
| CCharacteristicSpeeds | The characteristic speeds |
| CCharacteristicSpeedsCompute | Compute the characteristic speeds for the Valencia formulation of GRMHD with divergence cleaning |
| CComputeLargestCharacteristicSpeed | |
| CConstraintDampingParameter | The constraint damping parameter for divergence cleaning |
| CLargestCharacteristicSpeed | |
| CTildeB | The densitized magnetic field \({\tilde B^i}\) |
| CTildeD | The densitized rest-mass density \({\tilde D}\) |
| CTildePhi | The densitized divergence-cleaning field \({\tilde \Phi}\) |
| CTildeS | The densitized momentum density \({\tilde S_i}\) |
| CTildeTau | The densitized energy density \({\tilde \tau}\) |
| CVariablesNeededFixing | Set to true if the variables needed fixing |
| CComputeFluxes | The fluxes of the conservative variables |
| CComputeSources | Compute the source terms for the flux-conservative Valencia formulation of GRMHD with divergence cleaning |
| CConservativeFromPrimitive | Compute the conservative variables from primitive variables |
| ►CFixConservatives | Fix conservative variables using method developed by Foucart |
| CCutoffD | Cutoff below which \(D = \rho W\) is set to MinimumValueOfD |
| CMinimumValueOfD | Minimum value of rest-mass density times lorentz factor |
| CSafetyFactorForB | Safety factor \(\epsilon_B\) |
| CSafetyFactorForS | Safety factor \(\epsilon_S\) |
| CPrimitiveFromConservative | Compute the primitive variables from the conservative variables |
| CSetVariablesNeededFixingToFalse | Mutator used with Initialization::Actions::AddSimpleTags to initialize the VariablesNeededFixing to false |
| CSystem | |
| ►CTimeDerivativeTerms | Compute the time derivative of the conserved variables for the Valencia formulation of the GRMHD equations with divergence cleaning |
| CDensitizedStress | |
| CEnthalpyTimesDensityWSquaredPlusBSquared | |
| CLapseTimesbOverW | |
| CMagneticFieldOneForm | |
| COneOverLorentzFactorSquared | |
| CPressureStar | |
| CPressureStarLapseSqrtDetSpatialMetric | |
| CTildeSUp | |
| CTransportVelocity | |
| CAnalyticDataBase | Base struct for properties common to all GRMHD analytic data classes |
| CAnalyticSolution | Base struct for properties common to all GRMHD analytic solutions |
| ►Ngsl | Implementations from the Guideline Support Library |
| Cnot_null | Require a pointer to not be a nullptr |
| Cspan | Create a span/view on a range, which is cheap to copy (one pointer) |
| ►Nh5 | Contains functions and classes for manipulating HDF5 files |
| CDat | Represents a multicolumn dat file inside an HDF5 file |
| CH5File | Opens an HDF5 file for access and allows manipulation of data |
| CHeader | Writes header info about the build, git commit, branch, etc |
| CObject | Abstract base class representing an object in an HDF5 file |
| CSourceArchive | Writes an archive of the source tree into a dataset |
| CStellarCollapseEos | Reads in tabulated equation of state file from stellarcollapse.org |
| CVersion | Used to store the version of the file |
| CVolumeData | A volume data subfile written inside an H5 file |
| ►Nhydro | Items related to hydrodynamic systems |
| ►NSolutions | Holds classes implementing common portions of solutions to various different (magneto)hydrodynamical systems |
| ►CSmoothFlow | Smooth sinusoidal density wave |
| CAdiabaticIndex | The adiabatic index for the ideal fluid |
| CMeanVelocity | The mean flow velocity |
| CPerturbationSize | The perturbation amplitude of the rest mass density of the fluid |
| CPressure | The constant pressure throughout the fluid |
| CWaveVector | The wave vector of the profile |
| ►NTags | Tags for hydrodynamic systems |
| CAlfvenSpeedSquared | The Alfvén speed squared \(v_A^2\) |
| CComovingMagneticField | The magnetic field \(b^\mu = u_\nu {}^\star\!F^{\mu \nu}\) measured by an observer comoving with the fluid with 4-velocity \(u_\nu\) where \({}^\star\!F^{\mu \nu}\) is the dual of the Faraday tensor. Note that \(b^\mu\) has a time component (that is, \(b^\mu n_\mu \neq 0\), where \(n_\mu\) is the normal to the spacelike hypersurface) |
| CComovingMagneticFieldSquared | The square of the comoving magnetic field, \(b^\mu b_\mu\) |
| CDivergenceCleaningField | The divergence-cleaning field \(\Phi\) |
| CEquationOfState | The equation of state |
| CEquationOfStateBase | Base tag for the equation of state |
| CLorentzFactor | The Lorentz factor \(W = (1-v^iv_i)^{-1/2}\), where \(v^i\) is the spatial velocity of the fluid |
| CLorentzFactorCompute | Compute item for Lorentz factor \(W\) |
| CLorentzFactorSquared | The square of the Lorentz factor \(W^2\) |
| CLorentzFactorTimesSpatialVelocity | The Lorentz factor \(W\) times the spatial velocity \(v^i\) |
| CLowerSpatialFourVelocity | The spatial components of the four-velocity one-form \(u_i\) |
| CMagneticField | The magnetic field \(B^i = n_\mu {}^\star\!F^{i \mu}\) measured by an Eulerian observer, where \(n_\mu\) is the normal to the spatial hypersurface and \({}^\star\!F^{\mu \nu}\) is the dual of the Faraday tensor. Note that \(B^i\) is purely spatial, and it can be lowered using the spatial metric |
| CMagneticFieldDotSpatialVelocity | The magnetic field dotted into the spatial velocity, \(B^iv_i\) where \(v_i\) is the spatial velocity one-form |
| CMagneticFieldOneForm | The one-form of the magnetic field. Note that \(B^i\) is raised and lowered with the spatial metric |
| CMagneticFieldSquared | The square of the magnetic field, \(B^iB_i\) |
| CMagneticPressure | The magnetic pressure \(p_m\) |
| CMassFlux | The vector \(J^i\) in \(\dot{M} = -\int J^i s_i d^2S\), representing the mass flux through a surface with normal \(s_i\) |
| CMassFluxCompute | Compute item for mass flux vector \(J^i\) |
| CPressure | The fluid pressure \(p\) |
| CRestMassDensity | The rest-mass density \(\rho\) |
| CSoundSpeedSquared | The sound speed squared \(c_s^2\) |
| CSoundSpeedSquaredCompute | Compute item for the sound speed squared \(c_s^2\) |
| CSpatialVelocity | The spatial velocity \(v^i\) of the fluid, where \(v^i=u^i/W + \beta^i/\alpha\). Here \(u^i\) is the spatial part of the 4-velocity of the fluid, \(W\) is the Lorentz factor, \(\beta^i\) is the shift vector, and \(\alpha\) is the lapse function. Note that \(v^i\) is raised and lowered with the spatial metric |
| CSpatialVelocityOneForm | The spatial velocity one-form \(v_i\), where \(v_i\) is raised and lowered with the spatial metric |
| CSpatialVelocitySquared | The spatial velocity squared \(v^2 = v_i v^i\) |
| CSpecificEnthalpy | The relativistic specific enthalpy \(h\) |
| CSpecificEnthalpyCompute | Compute item for the relativistic specific enthalpy \(h\) |
| CSpecificInternalEnergy | The specific internal energy \(\epsilon\) |
| ►Nimporters | Items related to loading data from files |
| ►NActions | |
| CReadAllVolumeDataAndDistribute | Read a volume data file and distribute the data to all registered elements |
| CReadVolumeData | Read a volume data file and distribute the data to all registered elements |
| CReceiveVolumeData | Wait for data from a volume data file to arrive and directly move it into the DataBox |
| CRegisterElementWithSelf | Invoked on the importers::ElementDataReader component to store the registered data |
| CRegisterWithElementDataReader | Register an element with the volume data reader component |
| ►NOptionTags | The input file options associated with the data importer |
| CFileName | The file to read data from |
| CGroup | Groups the data importer configurations in the input file |
| CObservationValue | The observation value at which to read data from the file |
| CSubgroup | The subgroup within the file to read data from |
| ►NTags | The DataBox tags associated with the data importer |
| CElementDataAlreadyRead | Indicates which volume data files have already been read |
| CFileName | The file to read data from |
| CObservationValue | The observation value at which to read data from the file |
| CRegisteredElements | The elements that will receive data from the importer |
| CSubgroup | The subgroup within the file to read data from |
| CVolumeData | Inbox tag that carries the data read from a volume data file |
| CElementDataReader | A nodegroup parallel component that reads in a volume data file and distributes its data to elements of an array parallel component |
| ►NInitialization | |
| ►NActions | Available actions to be used in the initialization |
| CAddComputeTags | Initialize the list of compute tags in ComputeTagsList |
| CAddSimpleTags | Initialize the list of simple tags in Mutators::return_tags by calling each mutator in the order they are specified |
| CConservativeSystem | Allocate variables needed for evolution of conservative systems |
| ►CDiscontinuousGalerkin | Initialize items related to the discontinuous Galerkin method |
| CImpl | |
| CImpl< LocalSystem, true > | |
| CGrTagsForHydro | Allocate and set general relativity quantities needed for evolution of some hydro systems |
| CMinmod | Allocate items for minmod limiter |
| CNonconservativeSystem | Allocate variables needed for evolution of nonconservative systems |
| CRemoveOptionsAndTerminatePhase | |
| CTimeAndTimeStep | Initialize items related to time, such as the time step |
| ►CTimeStepperHistory | Initialize time-stepper items |
| CComputeTags | |
| CComputeTags< System, true > | |
| ►Nsubcell | Generic initialization actions and mutators for the subcell solver |
| CGrTagsForHydro | Allocate and set general relativity quantities needed for evolution of hydro systems when using a DG-subcell hybrid scheme |
| ►NTags | Tags used during initialization of parallel components |
| CInitialSlabSize | |
| CInitialSlabSize< false > | |
| CInitialTime | |
| CInitialTimeDelta | |
| ►Nintegration | Numerical integration algorithms |
| CGslQuadAdaptive | A wrapper around the GSL adaptive integration procedures |
| CGslQuadAdaptive< GslIntegralType::InfiniteInterval > | Integrates a 1D-function over the interval \( (-\infty, +\infty) \) |
| CGslQuadAdaptive< GslIntegralType::IntegrableSingularitiesKnown > | Integrates a 1D-function where singularities are known |
| CGslQuadAdaptive< GslIntegralType::IntegrableSingularitiesPresent > | Integrates a 1D-function with singularities |
| CGslQuadAdaptive< GslIntegralType::LowerBoundaryInfinite > | Integrates a 1D-function over the interval \( (-\infty, b] \) |
| CGslQuadAdaptive< GslIntegralType::StandardGaussKronrod > | Use Gauss-Kronrod rule to integrate a 1D-function |
| CGslQuadAdaptive< GslIntegralType::UpperBoundaryInfinite > | Integrates a 1D-function over the interval \( [a, +\infty) \) |
| ►NInterpolateOnElementTestHelpers | Holds code that is shared between multiple tests. Currently used by |
| ►NTags | |
| CMultiplyByTwo | |
| CMultiplyByTwoCompute | |
| CTestSolution | |
| CTestTargetPoints | |
| Cmock_interpolation_target | |
| CMockInterpolationTargetVarsFromElement | |
| ►NInterpTargetTestHelpers | |
| Cmock_interpolation_target | |
| Cmock_interpolator | |
| CMockReceivePoints | |
| ►Nintrp | Contains classes and functions for interpolation |
| ►NActions | Holds Actions for Interpolator and InterpolationTarget |
| CAddTemporalIdsToInterpolationTarget | Adds temporal_ids on which this InterpolationTarget should be triggered |
| CCleanUpInterpolator | Cleans up stored volume data that is no longer needed |
| CDeregisterElement | Invoked on the Interpolator ParallelComponent to deregister an element with the Interpolator |
| CElementInitInterpPoints | Adds interpolation point holders to the Element's DataBox |
| CElementReceiveInterpPoints | Receives interpolation points from an InterpolationTarget |
| CInitializeInterpolationTarget | Initializes an InterpolationTarget |
| CInitializeInterpolator | Initializes an Interpolator |
| CInterpolateToTarget | Interpolates and sends points to an InterpolationTarget |
| CInterpolationTargetReceiveVars | Receives interpolated variables from an Interpolator on a subset of the target points |
| CInterpolationTargetSendTimeIndepPointsToElements | Sends interpolation points to all the Elements |
| CInterpolationTargetVarsFromElement | Receives interpolated variables from an Element on a subset of the target points |
| CInterpolatorReceiveVolumeData | Adds volume data from an Element |
| CReceivePoints | Receives target points from an InterpolationTarget |
| CRegisterElement | Invoked on the Interpolator ParallelComponent to register an element with the Interpolator |
| CRegisterElementWithInterpolator | Invoked on DgElementArray to register all its elements with the Interpolator |
| CSendPointsToInterpolator | Sets up points on an InterpolationTarget at a new temporal_id and sends these points to an Interpolator |
| CVerifyTemporalIdsAndSendPoints | Sends points to an Interpolator for verified temporal_ids |
| ►Ncallbacks | Contains callback functions called by InterpolationTargets |
| CErrorOnFailedApparentHorizon | Callback for a failed apparent horizon find that simply errors |
| CFindApparentHorizon | Post interpolation callback (see InterpolationTarget) that does a FastFlow iteration and triggers another one until convergence |
| CIgnoreFailedApparentHorizon | Callback for a failed apparent horizon find that prints a message (if sufficient Verbosity is enabled) but does not terminate the executable |
| CObserveTimeSeriesOnSurface | Post_interpolation_callback that outputs a time series on a surface |
| CSendGhWorldtubeData | Post_interpolation_callback that calls Cce::ReceiveGhWorldTubeData |
| ►NEvents | |
| CInterpolate | Does an interpolation onto InterpolationTargetTag by calling Actions on the Interpolator and InterpolationTarget components |
| CInterpolate< VolumeDim, InterpolationTargetTag, tmpl::list< Tensors... > > | |
| CInterpolateWithoutInterpComponent< VolumeDim, InterpolationTargetTag, Metavariables, tmpl::list< Tensors... > > | Does an interpolation onto an InterpolationTargetTag by calling Actions on the InterpolationTarget component |
| ►NOptionHolders | |
| ►CApparentHorizon | Options for finding an apparent horizon |
| CFastFlow | See FastFlow for suboptions |
| CInitialGuess | See Strahlkorper for suboptions |
| CVerbosity | |
| ►CKerrHorizon | A surface that conforms to the horizon of a Kerr black hole in Kerr-Schild coordinates |
| CCenter | |
| CDimensionlessSpin | |
| CLmax | |
| CMass | |
| CThetaVariesFastest | |
| ►CLineSegment | A line segment extending from Begin to End, containing NumberOfPoints uniformly-spaced points including the endpoints |
| CBegin | |
| CEnd | |
| CNumberOfPoints | |
| ►CSpecifiedPoints | A list of specified points to interpolate to |
| CPoints | |
| ►CWedgeSectionTorus | A solid torus of points, useful, e.g., when measuring data from an accretion disc |
| CMaxRadius | |
| CMaxTheta | |
| CMinRadius | |
| CMinTheta | |
| CNumberPhiPoints | |
| CNumberRadialPoints | |
| CNumberThetaPoints | |
| CUniformRadialGrid | |
| CUniformThetaGrid | |
| ►NOptionTags | |
| CApparentHorizon | |
| CApparentHorizons | |
| CInterpolationTargets | Groups option tags for InterpolationTargets |
| CKerrHorizon | |
| CLineSegment | |
| CSpecifiedPoints | |
| CWedgeSectionTorus | |
| ►NTags | Tags for items held in the DataBox of InterpolationTarget or Interpolator |
| CApparentHorizon | |
| CCompletedTemporalIds | temporal_ids that we have already interpolated onto. This is used to prevent problems with multiple late calls to AddTemporalIdsToInterpolationTarget |
| CIndicesOfFilledInterpPoints | Keeps track of which points have been filled with interpolated data |
| CIndicesOfInvalidInterpPoints | Keeps track of points that cannot be filled with interpolated data |
| CInterpolatedVars | Holds interpolated variables on an InterpolationTarget |
| CInterpolatedVarsHolders | TaggedTuple containing all local Vars::Holders for all InterpolationTargets |
| CInterpPointInfo | The following tag is for the case in which interpolation bypasses the Interpolator ParallelComponent. In that case, the Element must hold interpolation information in its DataBox |
| CKerrHorizon | |
| CLineSegment | |
| CNumberOfElements | Number of local Elements |
| CPendingTemporalIds | temporal_ids that have been flagged to interpolate on, but that have not yet been added to Tags::TemporalIds. A temporal_id is pending if the FunctionOfTimes are not up to date for the time associated with the temporal_id |
| CSpecifiedPoints | |
| CTemporalIds | temporal_ids on which to interpolate |
| CVarsToInterpolateToTarget | |
| ►CVolumeVarsInfo | Volume variables at all temporal_ids for all local Elements. Held by the Interpolator |
| CInfo | |
| CWedgeSectionTorus | |
| ►NTargetPoints | |
| CApparentHorizon | Computes points on a trial apparent horizon` |
| CKerrHorizon | Computes points on a Kerr horizon |
| CLineSegment | Computes points on a line segment |
| CSpecifiedPoints | Returns list of points as specified in input file |
| CWedgeSectionTorus | Computes points in a wedge-sectioned torus |
| ►NVars | Data structures holding quantities that are interpolated by Interpolator for use by InterpolationTargets |
| CHolder | Holds Infos at all temporal_ids for a given InterpolationTargetTag. Also holds temporal_ids when data has been interpolated; this is used for cleanup purposes. All Holders for all InterpolationTargetTags are held in a single TaggedTuple that is in the Interpolator's DataBox with the tag Tags::InterpolatedVarsHolders |
| CHolderTag | Indexes a particular Holder in the TaggedTuple that is accessed from the Interpolator's DataBox with tag Tags::InterpolatedVarsHolders |
| CInfo | Holds a Variables interpolated onto a list of points, and information about those points, for a local Interpolator |
| CPointInfoTag | |
| CBarycentricRational | A barycentric rational interpolation class |
| ►CBarycentricRationalSpanInterpolator | Performs a barycentric interpolation with an order in a range fixed at construction; this class can be chosen via the options factory mechanism as a possible SpanInterpolator |
| CMaxOrder | |
| CMinOrder | |
| CCubicSpanInterpolator | Performs a cubic interpolation; this class can be chosen via the options factory mechanism as a possible SpanInterpolator |
| CCubicSpline | A natural cubic spline interpolation class |
| ►CInterpolationTarget | ParallelComponent representing a set of points to be interpolated to and a function to call upon interpolation to those points |
| CRegistrationHelper | |
| CInterpolator | ParallelComponent responsible for collecting data from Elements and interpolating it onto InterpolationTargets |
| CIrregular | Interpolates a Variables onto an arbitrary set of points |
| CLinearSpanInterpolator | Performs a linear interpolation; this class can be chosen via the options factory mechanism as a possible SpanInterpolator |
| CRegularGrid | Interpolate data from a Mesh onto a regular grid of points |
| CSpanInterpolator | Base class for interpolators so that the factory options mechanism can be used |
| Nlapack | LAPACK wrappers |
| ►NLimiters | Things relating to limiting |
| ►NActions | |
| CLimit | Receive limiter data from neighbors, then apply limiter |
| CSendData | Send local data needed for limiting |
| ►NTags | |
| CLimiterCommunicationTag | The inbox tag for limiter communication |
| NTci | Troubled Cell Indicators that identify when limiting is needed |
| ►CKrivodonova< VolumeDim, tmpl::list< Tags... > > | An implementation of the Krivodonova limiter |
| CAlphas | The \(\alpha_i\) values in the Krivodonova algorithm |
| CDisableForDebugging | Turn the limiter off |
| CPackagedData | |
| CMinmod | A minmod-based generalized slope limiter |
| ►CMinmod< VolumeDim, tmpl::list< Tags... > > | |
| CDisableForDebugging | Turn the limiter off |
| CPackagedData | Data to send to neighbor elements |
| CTvbConstant | The TVB constant |
| CType | The MinmodType |
| CWeno | A compact-stencil WENO limiter for DG |
| ►CWeno< VolumeDim, tmpl::list< Tags... > > | |
| CDisableForDebugging | Turn the limiter off |
| CNeighborWeight | The linear weight given to each neighbor |
| CPackagedData | Data to send to neighbor elements |
| CTvbConstant | The TVB constant for the minmod TCI |
| CType | The WenoType |
| ►NLinearSolver | Functionality for solving linear systems of equations |
| ►NActions | Actions applicable to any parallel linear solver |
| CMakeIdentityIfSkipped | Make the iterative linear solve the identity operation on the source vector if no iterations were performed at all. Useful for disabling a preconditioner by setting its number of iterations to zero |
| ►Nasync_solvers | Functionality shared between parallel linear solvers that have no global synchronization points |
| CCompleteStep | Complete a step of the asynchronous linear solver |
| CInitializeElement | |
| CPrepareSolve | Prepare the asynchronous linear solver for a solve |
| CRegisterObservers | |
| CResidualReductionFormatter | |
| ►Ncg | Items related to the conjugate gradient linear solver |
| CConjugateGradient | A conjugate gradient solver for linear systems of equations \(Ax=b\) where the operator \(A\) is symmetric |
| ►Ngmres | Items related to the GMRES linear solver |
| CGmres | A GMRES solver for nonsymmetric linear systems of equations \(Ax=b\) |
| ►NInnerProductImpls | Implementations of LinearSolver::inner_product |
| CInnerProductImpl | The inner product between any types that have a dot product |
| CInnerProductImpl< Schwarz::ElementCenteredSubdomainData< Dim, LhsTagsList >, Schwarz::ElementCenteredSubdomainData< Dim, RhsTagsList > > | |
| CInnerProductImpl< Variables< LhsTagsList >, Variables< RhsTagsList > > | The inner product between Variables |
| ►Nmultigrid | Items related to the multigrid linear solver |
| ►NActions | Actions related to the Multigrid linear solver |
| CReceiveFieldsFromFinerGrid | Receive the FieldsTags communicated from the finer grid in the multigrid hierarchy |
| CSendFieldsToCoarserGrid | Communicate and project the FieldsTags to the next-coarser grid in the multigrid hierarchy |
| ►NOptionTags | |
| CMaxLevels | |
| COutputVolumeData | |
| ►NTags | DataBox tags for the LinearSolver::multigrid::Multigrid linear solver |
| CChildIds | The IDs of the elements that cover the same region on the finer (child) grid |
| CChildrenRefinementLevels | Initial refinement of the next-finer (child) grid |
| CIsFinestGrid | Indicates the root of the multigrid hierarchy, i.e. level 0 |
| CMaxLevels | Maximum number of multigrid levels that will be created. A value of '1' effectively disables the multigrid, and std::nullopt means the number of multigrid levels is not capped |
| CMultigridLevel | The multigrid level. The finest grid is always level 0 and the coarsest grid has the highest level |
| CObservationId | Continuously incrementing ID for volume observations |
| COutputVolumeData | Whether or not volume data should be recorded for debugging purposes |
| CParentId | The ID of the element that covers the same region or more on the coarser (parent) grid |
| CParentMesh | The mesh of the parent element. Needed for projections between grids |
| CParentRefinementLevels | Initial refinement of the next-coarser (parent) grid |
| CPostSmoothingInitial | |
| CPostSmoothingResidual | |
| CPostSmoothingResult | |
| CPostSmoothingSource | |
| CPreSmoothingInitial | Prefix tag for recording volume data in LinearSolver::multigrid::Tags::VolumeDataForOutput |
| CPreSmoothingResidual | |
| CPreSmoothingResult | |
| CPreSmoothingSource | |
| CVolumeDataForOutput | Buffer for recording volume data |
| CDataFromChildrenInboxTag | |
| CElementsAllocator | A Parallel::protocols::ArrayElementsAllocator that creates array elements to cover the initial computational domain multiple times at different refinement levels, suitable for the LinearSolver::multigrid::Multigrid algorithm |
| CMultigrid | A V-cycle geometric multgrid solver for linear equations \(Ax = b\) |
| CVcycleDownLabel | A label indicating the pre-smoothing step in a V-cycle multigrid algorithm, i.e. the smoothing step before sending the residual to the coarser (parent) grid |
| CVcycleUpLabel | A label indicating the post-smoothing step in a V-cycle multigrid algorithm, i.e. the smoothing step before sending the correction to the finer (child) grid |
| ►NRichardson | Items related to the Richardson linear solver |
| ►NOptionTags | |
| CRelaxationParameter | |
| ►NTags | |
| CRelaxationParameter | The Richardson relaxation parameter \(\omega\) |
| CRichardson | A simple Richardson scheme for solving a system of linear equations \(Ax=b\) |
| ►NSchwarz | Items related to the Schwarz linear solver |
| ►NActions | Actions related to the Schwarz solver |
| CReceiveOverlapFields | Receive data from regions of this element's subdomain that overlap with other elements |
| CResetSubdomainSolver | Reset the subdomain solver, clearing its caches related to the linear operator it has solved so far |
| CSendOverlapFields | Send data on regions that overlap with other subdomains to their corresponding elements |
| ►NOptionTags | Option tags related to the Schwarz solver |
| CMaxOverlap | |
| CSkipSubdomainSolverResets | |
| CSubdomainSolver | |
| ►NTags | Tags related to the Schwarz solver |
| CIntrudingExtents | The number of points a neighbor's subdomain extends into the element |
| CIntrudingOverlapWidths | The width in element-logical coordinates that a neighbor's subdomain extends into the element |
| CMaxOverlap | Number of points a subdomain can overlap with its neighbor |
| COverlaps | The Tag on the overlap region with each neighbor, i.e. on a region extruding from the central element |
| CSkipSubdomainSolverResets | Skip resets of the subdomain solver |
| CSubdomainSolver | The serial linear solver of type SolverType used to solve subdomain operators |
| CSubdomainSolverBase | The serial linear solver used to solve subdomain operators |
| CSummedIntrudingOverlapWeights | A diagnostic quantity to check that weights are conserved |
| CSummedIntrudingOverlapWeightsCompute | A diagnostic quantity to check that weights are conserved |
| CWeight | Weighting field for combining data from multiple overlapping subdomains |
| CElementCenteredSubdomainData | Data on an element-centered subdomain |
| CElementCenteredSubdomainDataIterator | Iterate over LinearSolver::Schwarz::ElementCenteredSubdomainData |
| COverlapIterator | Iterate over grid points in a region that extends partially into the volume |
| CSchwarz | An additive Schwarz subdomain solver for linear systems of equations \(Ax=b\) |
| CSubdomainOperator | Abstract base class for the subdomain operator, i.e. the linear operator restricted to an element-centered Schwarz subdomain |
| ►NSerial | |
| ►NRegistrars | Registrars for linear solvers |
| CGmres | Registers the LinearSolver::Serial::Gmres linear solver |
| CExplicitInverse | Linear solver that builds a matrix representation of the linear operator and inverts it directly |
| CGmres | A serial GMRES iterative solver for nonsymmetric linear systems of equations |
| CLinearSolver | Base class for serial linear solvers that supports factory-creation |
| CNoIterationCallback | Disables the iteration callback at compile-time |
| CNoPreconditioner | Indicates the linear solver uses no preconditioner. It may perform compile-time optimization for this case |
| ►CPreconditionedLinearSolver | Base class for serial linear solvers that supports factory-creation and nested preconditioning |
| CPreconditionerOption | |
| ►NTags | The DataBox tags associated with the linear solver |
| CKrylovSubspaceBasis | A set of \(n\) vectors that form a basis of the \(n\)-th Krylov subspace \(K_n(A,b)\) |
| CMagnitude | The magnitude \(\sqrt{\langle \cdot,\cdot\rangle}\) w.r.t. the LinearSolver::inner_product |
| CMagnitudeSquare | The magnitude square \(\langle \cdot,\cdot\rangle\) w.r.t. the LinearSolver::inner_product |
| COperand | The operand that the local linear operator \(A\) is applied to |
| COperatorAppliedTo | The linear operator \(A\) applied to the data in Tag |
| COrthogonalization | The prefix for tags related to an orthogonalization procedure |
| COrthogonalizationHistory | A Hessenberg matrix built up during an orthogonalization procedure |
| CPreconditioned | Indicates the Tag is related to preconditioning of the linear solve |
| CResidual | The residual \(r=b - Ax\) |
| CResidualCompute | Compute the residual \(r=b - Ax\) from the SourceTag \(b\) and the db::add_tag_prefix<LinearSolver::Tags::OperatorAppliedTo, FieldsTag> \(Ax\) |
| ►NLinearSolverAlgorithmTestHelpers | |
| ►NOptionTags | |
| CExpectedConvergenceReason | |
| CExpectedResult | |
| CInitialGuess | |
| CLinearOperator | |
| CSource | |
| CCleanOutput | |
| CComputeOperatorAction | |
| CElementArray | |
| CExpectedConvergenceReason | |
| CExpectedResult | |
| CInitialGuess | |
| CInitializeElement | |
| CLinearOperator | |
| COutputCleaner | |
| CSource | |
| CTestResult | |
| CVectorTag | |
| ►Nlogging | Items related to logging |
| ►NOptionTags | |
| CVerbosity | |
| ►NTags | |
| CVerbosity | Tag for putting Verbosity in a DataBox |
| ►NMakeWithValueImpls | Implementations of make_with_value |
| CMakeWithSize | Defines a method for producing an object representing a given number of points |
| CMakeWithSize< DenseVector< double, TF > > | |
| CMakeWithSize< SpinWeighted< SpinWeightedType, Spin > > | |
| CMakeWithSize< Tensor< T, Structure... > > | |
| CMakeWithSize< Variables< TagList > > | |
| CMakeWithValueImpl | |
| CMakeWithValueImpl< double, T > | Returns a double initialized to value (input is ignored) |
| CMakeWithValueImpl< LinearSolver::Schwarz::ElementCenteredSubdomainData< Dim, TagsListOut >, LinearSolver::Schwarz::ElementCenteredSubdomainData< Dim, TagsListIn > > | |
| CMakeWithValueImpl< Tensor< double, Structure... >, T > | |
| CMakeWithValueImpl< tuples::TaggedTuple< Tags... >, T > | Makes a TaggedTuple; each element of the TaggedTuple must be make_with_value-creatable from a T |
| CNumberOfPoints | Defines a method for determining the number of points represented by an object. This allows the object to appear as the input to make_with_value |
| CNumberOfPoints< DenseVector< double, TF > > | |
| CNumberOfPoints< size_t > | |
| CNumberOfPoints< SpinWeighted< SpinWeightedType, Spin > > | |
| CNumberOfPoints< Tensor< T, Structure... > > | |
| CNumberOfPoints< Variables< TagList > > | |
| ►NMathFunctions | Holds classes implementing MathFunction (functions \(R^n \to R\)) |
| ►CGaussian | Gaussian \(f = A \exp\left(-\frac{(x-x_0)^2}{w^2}\right)\) |
| CAmplitude | |
| CCenter | |
| CWidth | |
| ►CGaussian< 1, Fr > | 1D Gaussian \(f = A \exp\left(-\frac{(x-x_0)^2}{w^2}\right)\) |
| CAmplitude | |
| CCenter | |
| CWidth | |
| CPowX | |
| ►CPowX< 1, Fr > | Power of X \(f(x)=x^X\) |
| CPower | |
| CSinusoid | |
| ►CSinusoid< 1, Fr > | Sinusoid \(f = A \sin\left(k x + \delta \right)\) |
| CAmplitude | |
| CPhase | |
| CWavenumber | |
| CTensorProduct | Tensor product of one-dimensional MathFunctions |
| ►Nneutrinos | Namespace for neutrino physics |
| CElectronAntiNeutrinos | |
| CElectronNeutrinos | |
| CHeavyLeptonNeutrinos | |
| ►NNewtonianEuler | Items related to evolving the Newtonian Euler system |
| ►NAnalyticData | Holds classes implementing analytic data for the NewtonianEuler system |
| ►CKhInstability | Initial data to simulate the Kelvin-Helmholtz instability |
| CAdiabaticIndex | The adiabatic index of the fluid |
| CBackgroundDensity | The mass density outside of the strip |
| CBackgroundVelocity | The velocity along \(x\) outside of the strip |
| CPerturbAmplitude | The amplitude of the perturbation |
| CPerturbWidth | The characteristic length for the width of the perturbation |
| CPressure | The initial (constant) pressure of the fluid |
| CStripBimedianHeight | The vertical coordinate of the horizontal bimedian of the strip |
| CStripDensity | The mass density in the strip |
| CStripThickness | The thickness of the strip |
| CStripVelocity | The velocity along \(x\) in the strip |
| ►CShuOsherTube | Initial data for the Shu-Osher oscillatory shock tube [97] |
| CEpsilon | |
| CJumpPosition | Initial postition of the discontinuity |
| CLambda | |
| CLeftMassDensity | |
| CLeftPressure | |
| CLeftVelocity | |
| CRightPressure | |
| CRightVelocity | |
| ►CSodExplosion | A cylindrical or spherical Sod explosion [108] [98] |
| CInitialRadius | Initial radius of the discontinuity |
| CInnerMassDensity | |
| CInnerPressure | |
| COuterMassDensity | |
| COuterPressure | |
| ►NBoundaryConditions | Boundary conditions for the Newtonian Euler hydrodynamics system |
| CBoundaryCondition | The base class off of which all boundary conditions must inherit |
| CDirichletAnalytic | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
| ►NBoundaryCorrections | Boundary corrections/numerical fluxes |
| CBoundaryCorrection | The base class used to create boundary corrections from input files and store them in the global cache |
| ►CHll | An HLL (Harten-Lax-van Leer) Riemann solver for NewtonianEuler system |
| CLargestIngoingCharSpeed | |
| CLargestOutgoingCharSpeed | |
| ►CHllc | The HLLC (Harten-Lax-van Leer-Contact) Riemann solver for the NewtonianEuler system |
| CLargestIngoingCharSpeed | |
| CLargestOutgoingCharSpeed | |
| CRusanov | A Rusanov/local Lax-Friedrichs Riemann solver |
| ►Nfd | Finite difference functionality for Newtonian Euler |
| ►NOptionTags | Option tags for reconstruction |
| CReconstructor | Option tag for the reconstructor |
| ►NTags | Tags for reconstruction |
| CReconstructor | Tag for the reconstructor |
| ►CAoWeno53Prim | Adaptive-order WENO reconstruction hybridizing orders 5 and 3. See fd::reconstruction::aoweno_53() for details |
| CEpsilon | |
| CGammaHi | |
| CGammaLo | |
| CNonlinearWeightExponent | |
| CMonotisedCentralPrim | Monotised central reconstruction. See fd::reconstruction::monotised_central() for details |
| CReconstructor | The base class from which all reconstruction schemes must inherit |
| ►NLimiters | |
| NTci | |
| ►CMinmod | A minmod-based generalized slope limiter for the NewtonianEuler system |
| CApplyFlattener | |
| CVariablesToLimit | |
| ►CWeno | A compact-stencil WENO limiter for the NewtonianEuler system |
| CApplyFlattener | |
| CKxrcfConstant | |
| CTvbConstant | |
| CVariablesToLimit | |
| ►NNumericalFluxes | |
| ►CHllc | Compute the HLLC numerical flux |
| CLargestIngoingSpeed | Estimate for one of the signal speeds |
| CLargestOutgoingSpeed | Estimate for the other signal speed |
| CNormalVelocity | The normal component of the velocity |
| ►NSolutions | Holds classes implementing a solution to the Newtonian Euler system |
| ►CIsentropicVortex | Newtonian isentropic vortex in Cartesian coordinates |
| CAdiabaticIndex | The adiabatic index of the fluid |
| CCenter | The position of the center of the vortex at \(t = 0\) |
| CMeanVelocity | The mean flow velocity |
| CPerturbAmplitude | The amplitude of the perturbation generating a source term |
| CStrength | The strength of the vortex |
| ►CLaneEmdenStar | A static spherically symmetric star in Newtonian gravity |
| CCentralMassDensity | The central mass density of the star |
| CPolytropicConstant | The polytropic constant of the polytropic fluid |
| ►CRiemannProblem | Analytic solution to the Riemann Problem |
| CAdiabaticIndex | The adiabatic index of the fluid |
| CInitialData | Holds initial data on a side of the discontinuity and related quantities |
| CInitialPosition | Initial position of the discontinuity |
| CLeftMassDensity | The mass density on the left of the initial discontinuity |
| CLeftPressure | The pressure on the left of the initial discontinuity |
| CLeftVelocity | The velocity on the left of the initial discontinuity |
| CPressureStarTol | The tolerance for solving for \(p_*\) |
| CRightMassDensity | The mass density on the right of the initial discontinuity |
| CRightPressure | The pressure on the right of the initial discontinuity |
| CRightVelocity | The velocity on the right of the initial discontinuity |
| CSmoothFlow | Smooth density wave advecting across the domain |
| ►NSources | |
| CLaneEmdenGravitationalField | Source giving the acceleration due to gravity in the spherical, Newtonian Lane-Emden star solution |
| CNoSource | Used to mark that the initial data do not require source terms in the evolution equations |
| CUniformAcceleration | Source generated from an external uniform acceleration |
| CVortexPerturbation | Source generating a modified isentropic vortex |
| ►Nsubcell | Code required by the DG-subcell/FD hybrid solver |
| CDgInitialDataTci | The troubled-cell indicator run on DG initial data to see if we need to switch to subcell |
| CPrimitiveGhostDataOnSubcells | Computes the mass density, velocity, and pressure on the subcells so they can be sent to the neighbors for their reconstructions |
| CPrimitiveGhostDataToSlice | Projects the mass density, velocity, and pressure to the subcells so they can be sent to the neighbors for their reconstructions |
| CPrimsAfterRollback | Mutator that resizes the primitive variables to the subcell mesh and computes the primitives, but only if evolution::dg::subcell::Tags::DidRollback is true |
| CResizeAndComputePrims | Mutator that resizes the primitive variables to have the size of the active mesh and then computes the primitive variables on the active mesh |
| CTciOnDgGrid | Troubled-cell indicator applied to the DG solution |
| CTciOnFdGrid | Troubled-cell indicator applied to the finite difference subcell solution to check if the corresponding DG solution is admissible |
| ►NTags | Tags for the conservative formulation of the Newtonian Euler system |
| CCharacteristicSpeeds | The characteristic speeds |
| CCharacteristicSpeedsCompute | |
| CComputeLargestCharacteristicSpeed | |
| CEnergyDensity | The energy density of the fluid |
| CInternalEnergyDensity | The internal energy density |
| CInternalEnergyDensityCompute | Compute item for the internal energy density, \(\rho \epsilon\) |
| CKineticEnergyDensity | The kinetic energy density |
| CKineticEnergyDensityCompute | Compute item for the kinetic energy density, \(\rho v^2/2\) |
| CLargestCharacteristicSpeed | |
| CMachNumber | The local Mach number of the flow |
| CMachNumberCompute | Compute item for the local Mach number, \(\text{Ma}\) |
| CMassDensity | The mass density of the fluid |
| CMassDensityCons | The mass density of the fluid (as a conservative variable) |
| CMomentumDensity | The momentum density of the fluid |
| CPressure | The fluid pressure |
| CRamPressure | The ram pressure of the fluid |
| CRamPressureCompute | Compute item for the ram pressure, \(\rho v^i v^j\) |
| CSoundSpeed | The sound speed |
| CSoundSpeedCompute | Compute item for the sound speed \(c_s\) |
| CSoundSpeedSquared | The square of the sound speed |
| CSoundSpeedSquaredCompute | Compute item for the sound speed squared \(c_s^2\) |
| CSourceTerm | The source term in the evolution equations |
| CSourceTermBase | Base tag for the source term |
| CSpecificInternalEnergy | The specific internal energy of the fluid |
| CSpecificKineticEnergy | The specific kinetic energy |
| CSpecificKineticEnergyCompute | Compute item for the specific kinetic energy, \(v^2/2\) |
| CVelocity | The macroscopic or flow velocity of the fluid |
| CVMinus | The characteristic fields of the NewtonianEuler system |
| CVMomentum | |
| CVPlus | |
| CComputeFluxes | Compute the fluxes of the conservative variables of the Newtonian Euler system |
| CComputeSources | Compute the source terms for the NewtonianEuler evolution using a problem-specific source |
| CConservativeFromPrimitive | Compute the conservative variables from the primitive variables |
| CPrimitiveFromConservative | Compute the primitive variables from the conservative variables |
| CSystem | |
| CTimeDerivativeTerms | Compute the time derivative of the conserved variables for the Newtonian Euler system |
| ►NNonlinearSolver | Functionality for solving nonlinear systems of equations |
| ►Nnewton_raphson | Items related to the NewtonRaphson nonlinear solver |
| CNewtonRaphson | A Newton-Raphson correction scheme for nonlinear systems of equations \(A_\mathrm{nonlinear}(x)=b\) |
| ►NOptionTags | Options related to nonlinear solvers |
| CDampingFactor | Nonlinear solver steps are damped by this factor |
| CMaxGlobalizationSteps | The maximum number of allowed globalization steps |
| CSufficientDecrease | Sufficient decrease parameter of the line search globalization |
| ►NTags | |
| CCorrection | The correction \(\delta x\) to improve a solution \(x_0\) |
| CDampingFactor | Nonlinear solver steps are damped by this factor |
| CGlobalization | Prefix indicating the Tag is related to the globalization procedure |
| CMaxGlobalizationSteps | The maximum number of allowed globalization steps |
| COperatorAppliedTo | The nonlinear operator \(A_\mathrm{nonlinear}\) applied to the data in Tag |
| CResidual | The nonlinear residual \(r_\mathrm{nonlinear} = b - A_\mathrm{nonlinear}(\delta x)\) |
| CResidualCompute | Compute the residual \(r=b - Ax\) from the SourceTag \(b\) and the db::add_tag_prefix<NonlinearSolver::Tags::OperatorAppliedTo, FieldsTag> \(Ax\) |
| CStepLength | The length of nonlinear solver steps |
| CSufficientDecrease | Sufficient decrease parameter of the line search globalization |
| ►Nobservers | |
| ►NActions | Actions used by the observer parallel component |
| CContributeReductionData | Send reduction data to the observer group |
| CContributeVolumeData | Send volume tensor data to the observer |
| CDeregisterContributorWithObserver | Deregister the ArrayComponentId that will no longer send the data to the observer for the given ObservationIdRegistrationKey |
| CDeregisterReductionContributorWithObserverWriter | Deregister an ArrayComponentId that will no longer call observers::ThreadedActions::WriteReductionData or observers::ThreadedActions::ContributeReductionData for a specific ObservationIdRegistrationKey |
| CDeregisterReductionNodeWithWritingNode | Deregister a node with the node that writes the reduction data to disk |
| CDeregisterVolumeContributorWithObserverWriter | Deregister an ArrayComponentId with a specific ObservationIdRegistrationKey that will no longer call observers::ThreadedActions::ContributeVolumeData |
| CGetLockPointer | Local synchronous action for retrieving a pointer to the NodeLock with tag LockTag on the component |
| CInitialize | Initializes the DataBox on the observer parallel component |
| CInitializeWriter | Initializes the DataBox of the observer parallel component that writes to disk |
| CRegisterContributorWithObserver | Register the ArrayComponentId that will send the data to the observer for the given ObservationIdRegistrationKey |
| CRegisterEventsWithObservers | Registers this element of a parallel component with the local Observer parallel component for each triggered observation |
| CRegisterReductionContributorWithObserverWriter | Register an ArrayComponentId that will call observers::ThreadedActions::WriteReductionData or observers::ThreadedActions::ContributeReductionData for a specific ObservationIdRegistrationKey |
| CRegisterReductionNodeWithWritingNode | Register a node with the node that writes the reduction data to disk |
| CRegisterSingletonWithObserverWriter | Registers a singleton with the ObserverWriter |
| CRegisterVolumeContributorWithObserverWriter | Register an ArrayComponentId with a specific ObservationIdRegistrationKey that will call observers::ThreadedActions::ContributeVolumeData |
| CRegisterWithObservers | Register an observation ID with the observers |
| ►NOptionTags | Option tags related to recording data |
| CGroup | Groups option tags related to recording data, e.g. file names |
| CReductionFileName | The name of the H5 file on disk to which all reduction data is written |
| CVolumeFileName | The name of the H5 file on disk to which all volume data is written |
| ►Nprotocols | Protocols related to observers |
| ►CReductionDataFormatter | Conforming classes can create an informative message from reduction data. The message will be printed to screen when the formatter is passed to a reduction action such as observers::Actions::ContributeReductionData |
| Ctest | |
| ►NTags | Tags used on the observer parallel component |
| CContributorsOfReductionData | The set of ArrayComponentId that have contributed to each ObservationId for reductions |
| CContributorsOfTensorData | The set of ArrayComponentId that have contributed to each ObservationId for volume observation |
| CExpectedContributorsForObservations | The set of ArrayComponentIds that will contribute to each ObservationId for reduction |
| CH5FileLock | Node lock used when needing to read/write to H5 files on disk |
| CNodesExpectedToContributeReductions | The set of nodes that are registered with each ObservationIdRegistrationKey for writing reduction data |
| CNodesThatContributedReductions | The set of nodes that have contributed to each ObservationId for writing reduction data |
| CObservationKey | A string identifying observations related to the Tag |
| CReductionData | Reduction data to be written to disk |
| CReductionDataLock | Lock used when contributing reduction data |
| CReductionDataNames | Names of the reduction data to be written to disk |
| CReductionFileName | The name of the HDF5 file on disk into which reduction data is written |
| CTensorData | Volume tensor data to be written to disk |
| CVolumeDataLock | Lock used when contributing volume data |
| CVolumeFileName | The name of the HDF5 file on disk into which volume data is written |
| ►NThreadedActions | |
| CCollectReductionDataOnNode | Gathers all the reduction data from all processing elements/cores on a node |
| CContributeVolumeDataToWriter | Move data to the observer writer for writing to disk |
| CWriteReductionData | Write reduction data to disk from node 0 |
| CWriteSimpleData | Append data to an h5::Dat subfile of Tags::VolumeFileName |
| CArrayComponentId | An ID type that identifies both the parallel component and the index in the parallel component |
| Chas_register_with_observer | Inherits off of std::true_type if T has a member variable RegisterWithObserver |
| CNoFormatter | Indicates no formatter is selected |
| CObservationId | A unique identifier for an observation representing the type of observation and the instance (e.g. time) at which the observation occurs |
| CObservationKey | Used as a key in maps to keep track of how many elements have registered |
| CObserver | The group parallel component that is responsible for reducing data to be observed |
| CObserverWriter | The nodegroup parallel component that is responsible for writing data to disk |
| NOdeIntegration | For ODE integration, we suggest using the boost libraries whenever possible |
| ►NOptions | Utilities for parsing input files |
| ►NAutoLabel | The label representing the absence of a value for Options::Auto |
| CAuto | 'Auto' label |
| CNone | 'None' label |
| ►Nprotocols | |
| ►CFactoryCreation | Compile-time information for factory-creation |
| ►Ctest | |
| Cfactory_class_is_derived_from_base_class | |
| CAlternatives | Provide multiple ways to construct a class |
| CAuto | A class indicating that a parsed value can be automatically computed instead of specified |
| CComparator | An option-creatable mathematical comparison |
| CContext | Information about the nested operations being performed by the parser, for use in printing errors. A default-constructed Context is printed as an empty string. This struct is primarily used as an argument to PARSE_ERROR for reporting input file parsing errors. Users outside of the core option parsing code should not need to manipulate the contents |
| Ccreate_from_yaml | Used by the parser to create an object. The default action is to parse options using T::options. This struct may be specialized to change that behavior for specific types |
| Ccreate_from_yaml< Auto< T, Label > > | |
| Ccreate_from_yaml< Comparator > | |
| Ccreate_from_yaml< Convergence::Reason > | |
| Ccreate_from_yaml< DenseMatrix< T, SO > > | |
| Ccreate_from_yaml< DenseTriggers::Or > | |
| Ccreate_from_yaml< DenseTriggers::Times > | |
| Ccreate_from_yaml< DenseVector< T, TF > > | |
| Ccreate_from_yaml< domain::CoordinateMaps::Distribution > | |
| Ccreate_from_yaml< EventsAndTriggers > | |
| Ccreate_from_yaml< evolution::EventsAndDenseTriggers > | |
| Ccreate_from_yaml< FastFlow::FlowType > | |
| Ccreate_from_yaml< FloatingPointType > | |
| Ccreate_from_yaml< Limiters::MinmodType > | |
| Ccreate_from_yaml< Limiters::WenoType > | |
| Ccreate_from_yaml< NewtonianEuler::Limiters::VariablesToLimit > | |
| Ccreate_from_yaml< ShellWedges > | |
| Ccreate_from_yaml< StepChoosers::Constant< StepChooserUse > > | |
| Ccreate_from_yaml< Triggers::And > | |
| Ccreate_from_yaml< Triggers::NearTimes_enums::Unit > | |
| Ccreate_from_yaml< Triggers::Not > | |
| Ccreate_from_yaml< Triggers::Or > | |
| Ccreate_from_yaml< Triggers::Slabs > | |
| Ccreate_from_yaml< Triggers::Times > | |
| Ccreate_from_yaml< typename Triggers::NearTimes_enums::Direction > | |
| Ccreate_from_yaml< Verbosity > | |
| Ccreate_from_yaml< Xcts::Solutions::SchwarzschildCoordinates > | |
| CInputSource | Option parser tag to retrieve the YAML source and all applied overlays. This tag can be requested without providing it as a template parameter to the Parser |
| COption | The type that options are passed around as. Contains YAML node data and an Context |
| CParser | Class that handles parsing an input file |
| ►NOptionTags | |
| CAnalyticData | The analytic data, with the type of the analytic data set as the template parameter |
| CAnalyticDataGroup | Holds the OptionTags::AnalyticData option in the input file |
| CAnalyticSolution | The analytic solution, with the type of the analytic solution set as the template parameter |
| CAnalyticSolutionGroup | Holds the OptionTags::AnalyticSolution option in the input file |
| CBoundaryCondition | The boundary condition to be applied at all external boundaries |
| CEventsAndTriggers | Contains the events and triggers |
| CFilter | The option tag that retrieves the parameters for the filter from the input file |
| CFilteringGroup | Groups the filtering configurations in the input file |
| CInitialSlabSize | The initial slab size |
| CInitialTime | The time at which to start the simulation |
| CInitialTimeStep | The initial time step taken by the time stepper. This may be overridden by an adaptive stepper |
| CLimiter | The global cache tag that retrieves the parameters for the limiter from the input file |
| CLimiterGroup | Holds the OptionTags::Limiter option in the input file |
| CNumericalFlux | The option tag that retrieves the parameters for the numerical flux from the input file |
| CNumericalFluxGroup | Holds the OptionTags::NumericalFlux option in the input file |
| CStepChoosers | |
| CStepController | |
| CStrahlkorper | The input file tag for a Strahlkorper |
| CTimeStepper | |
| CVariableFixer | The global cache tag that retrieves the parameters for the variable fixer from the input file |
| CVariableFixingGroup | Groups the variable fixer configurations in the input file |
| ►NParallel | Functionality for parallelization |
| ►NActions | |
| CTerminatePhase | Terminate the algorithm to proceed to the next phase |
| ►NAlgorithms | |
| CArray | A struct that stores the charm++ types relevant for a particular array component |
| CGroup | A struct that stores the charm++ types relevant for a particular group component |
| CNodegroup | A struct that stores the charm++ types relevant for a particular nodegroup component |
| CSingleton | A struct that stores the charm++ types relevant for a particular singleton component |
| ►Ncharmxx | |
| CMainChareRegistrationConstructor | Class to mark a constructor as a constructor for the main chare |
| CRegisterChare | Derived class for registering chares |
| CRegisterGlobalCacheMutate | Derived class for registering GlobalCache::mutate |
| CRegisterMutableGlobalCacheMutate | Derived class for registering MutableGlobalCache::mutate |
| CRegisterParallelComponent | Derived class for registering parallel components |
| CRegisterPhaseChangeReduction | |
| CRegisterReceiveData | Derived class for registering receive_data functions |
| CRegisterReducerFunction | Class used for registering custom reduction function |
| CRegisterReductionAction | Derived class for registering reduction actions |
| CRegisterSimpleAction | Derived class for registering simple actions |
| CRegisterThreadedAction | Derived class for registering threaded actions |
| CRegistrationHelper | The base class used for automatic registration of entry methods |
| ►NInboxInserters | Structs that have insert_into_inbox methods for commonly used cases |
| CMap | Inserter for inserting data that is received as the value_type (with non-const key_type) of a map data structure |
| CMemberInsert | Inserter for inserting data that is received as the value_type of a data structure that has an insert(value_type&&) member function |
| CPushback | Inserter for inserting data that is received as the value_type of a data structure that has an push_back(value_type&&) member function |
| CValue | Inserter for data that is inserted by copy/move |
| ►Nprotocols | |
| ►CArrayElementsAllocator | Conforming types implement a strategy to create elements for array parallel components |
| Ctest | |
| ►NTags | |
| CFromGlobalCache | Tag used to retrieve data from the Parallel::GlobalCache. This is the recommended way for compute tags to retrieve data out of the global cache |
| CGlobalCache | Tag to retrieve the Parallel::GlobalCache from the DataBox |
| CGlobalCacheImpl | |
| CGlobalCacheImplCompute | |
| CGlobalCacheProxy | |
| CMetavariables | Tag to retrieve the Metavariables from the DataBox |
| CMetavariablesImpl | |
| CSection | The Parallel::Section<ParallelComponent, SectionIdTag> that this element belongs to |
| CAlgorithmImpl< ParallelComponent, tmpl::list< PhaseDepActionListsPack... > > | A distributed object (Charm++ Chare) that executes a series of Actions and is capable of sending and receiving data. Acts as an interface to Charm++ |
| CArrayIndex | The array index used for indexing Chare Arrays, mostly an implementation detail |
| CCallback | An abstract base class, whose derived class holds a function that can be invoked at a later time. The function is intended to be invoked only once |
| Cget_action_list_from_phase_dep_action_list | (Lazy) metafunction to get the action list from a PhaseActions |
| Cget_mutable_cache_tag | |
| Cget_phase_from_phase_dep_action_list | (Lazy) metafunction to get the phase as a std::integral_constant from a PhaseActions |
| Cget_phase_type_from_phase_dep_action_list | (Lazy) metafunction to get the phase type from a PhaseActions |
| CGlobalCache | A Charm++ chare that caches constant data once per Charm++ node or non-constant data once per Charm++ core |
| Chas_pup_member | Check if T has a pup member function |
| Cis_array_proxy | Check if T is a Charm++ proxy for an array chare |
| Cis_bound_array | Check if T is a ParallelComponent for a Charm++ bound array |
| Cis_chare_proxy | Check if T is a Charm++ proxy for a chare |
| Cis_group_proxy | Check if T is a Charm++ proxy for a group chare |
| Cis_node_group_proxy | Check if T is a Charm++ proxy for a node group chare |
| Cis_pupable | Check if type T has operator| defined for Charm++ serialization |
| CMain | The main function of a Charm++ executable. See the Parallelization documentation for an overview of Metavariables, Phases, and parallel components |
| CMutableCacheTag | |
| CMutableGlobalCache | A Charm++ chare that caches mutable data once per Charm++ core |
| CNodeLock | A typesafe wrapper for a lock for synchronization of shared resources on a given node, with safe creation, destruction, and serialization |
| CNoSection | Can be used instead of a Parallel::Section when no section is desired |
| CPerformAlgorithmCallback | Wraps a call to perform_algorithm |
| CPhaseActions | List of all the actions to be executed in the specified phase |
| CReductionData< ReductionDatum< Ts, InvokeCombines, InvokeFinals, InvokeFinalExtraArgsIndices >... > | Used for reducing a possibly heterogeneous collection of types in a single reduction call |
| CReductionDatum | The data to be reduced, and invokables to be called whenever two reduction messages are combined and after the reduction has been completed |
| CSection | A subset of chares in a parallel component |
| CSimpleActionCallback | Wraps a call to a simple action and its arguments. Can be invoked only once |
| CSimpleActionCallback< SimpleAction, Proxy > | Wraps a call to a simple action without arguments |
| ►NPhaseControl | Contains utilities for determining control-flow among phases |
| ►NActions | |
| CExecutePhaseChange | Check if any triggers are activated, and perform phase changes as needed |
| ►NOptionTags | |
| CPhaseChangeAndTriggers | Option tag for the collection of triggers that indicate synchronization points at which phase changes should be considered, and the associated PhaseChange objects for making the phase change decisions |
| ►NTags | |
| CPhaseChangeAndTriggers | Tag for the collection of triggers that indicate synchronization points at which phase changes should be considered, and the associated PhaseChange objects for making the phase change decisions |
| ►NTagsAndCombines | |
| CUsePhaseChangeArbitration | A tag for indicating that a halt was called by a trigger associated with PhaseChanges |
| CInitializePhaseChangeDecisionData | Initialize the Main chare's phase_change_decision_data for the option-selected PhaseChanges |
| CTagAndCombine | A type for denoting a piece of data for deciding a phase change |
| CTaggedTupleCombine | A flexible combine invokable that combines into a tuples::TaggedTuple a new tuples::TaggedTuple, and combines according to type aliases combination_methods that are required to be defined in each tag |
| CTaggedTupleMainCombine | A flexible combine invokable that combines into a tuples::TaggedTuple a new tuples::TaggedTuple with a subset of the original tags, and combines according to type aliases main_combine_methods that are required to be defined in each tag |
| ►NPoisson | Items related to solving a Poisson equation \(-\Delta u(x)=f(x)\) |
| ►NBoundaryConditions | |
| CRobin | Impose Robin boundary conditions \(a u + b n_i \nabla^i u = c\). The boundary condition is imposed as Neumann-type (i.e. on \(n_i \nabla^i u\)) if \(|b| > 0\) and as Dirichlet-type (i.e. on \(u\)) if \(b = 0\) |
| ►NSolutions | Analytic solutions of the Poisson equation |
| CAnalyticSolution | Base class for analytic solutions of the Poisson equation |
| CLorentzian | A Lorentzian solution to the Poisson equation |
| CMoustache | A solution to the Poisson equation with a discontinuous first derivative |
| ►CProductOfSinusoids | A product of sinusoids \(u(\boldsymbol{x}) = \prod_i \sin(k_i x_i)\) |
| CWaveNumbers | |
| CZero | The trivial solution \(u=0\) of a Poisson equation. Useful as initial guess |
| ►NTags | |
| CField | The scalar field \(u(x)\) to solve for |
| CFirstOrderSystem | The Poisson equation formulated as a set of coupled first-order PDEs |
| CFluxes< Dim, Geometry::Curved > | Compute the fluxes \(F^i_A\) for the curved-space Poisson equation on a spatial metric \(\gamma_{ij}\) |
| CFluxes< Dim, Geometry::FlatCartesian > | Compute the fluxes \(F^i_A\) for the Poisson equation on a flat metric in Cartesian coordinates |
| CSources< Dim, Geometry::Curved > | Add the sources \(S_A\) for the curved-space Poisson equation on a spatial metric \(\gamma_{ij}\) |
| CSources< Dim, Geometry::FlatCartesian > | Add the sources \(S_A\) for the Poisson equation on a flat metric in Cartesian coordinates |
| ►Npretty_type | Contains all functions that are part of PrettyType, used for printing types in a pretty manner |
| Cstl_templates | A list of type traits to check if something is an STL member |
| Npy_bindings | |
| ►Npypp | Contains all functions for calling python from C++ |
| CSetupLocalPythonEnvironment | Enable calling of python in the local scope, and add directory(ies) to the front of the search path for modules. The directory which is appended to the path is relative to the tests/Unit directory |
| ►NRadiationTransport | Items related to general relativistic radiation transport |
| ►NM1Grey | The M1 scheme for radiation transport |
| ►NActions | |
| CInitializeM1Tags | |
| ►NBoundaryConditions | Boundary conditions for the M1Grey radiation transport system |
| CBoundaryCondition | The base class off of which all boundary conditions must inherit |
| CDirichletAnalytic< tmpl::list< NeutrinoSpecies... > > | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
| ►NBoundaryCorrections | Boundary corrections/numerical fluxes |
| CBoundaryCorrection | The base class used to create boundary corrections from input files and store them in the global cache |
| CRusanov< tmpl::list< NeutrinoSpecies... > > | A Rusanov/local Lax-Friedrichs Riemann solver |
| ►NSolutions | Holds classes implementing a solution to the M1 system |
| ►CConstantM1 | Constant solution to M1 equations in Minkowski spacetime |
| CComovingEnergyDensity | The radiation comoving energy density |
| CMeanVelocity | The mean flow velocity |
| ►NTags | Tags for the evolution of neutrinos using a grey M1 scheme |
| CCharacteristicSpeeds | The characteristic speeds |
| CCharacteristicSpeedsCompute | Compute the characteristic speeds for the M1 system |
| CClosureFactor | The M1 closure factor of neutrinos of a given species \({\xi}\) |
| CGreyAbsorptionOpacity | The absorption opacity of the fluid for neutrinos of a given species |
| CGreyEmissivity | The emissivity of the fluid for neutrinos of a given species |
| CGreyScatteringOpacity | The scattering opacity of the fluid for neutrinos of a given species |
| CM1HydroCouplingNormal | The normal component of the source term coupling the M1 and hydro equations |
| CM1HydroCouplingSpatial | The spatial components of source term coupling the M1 and hydro equations |
| CTildeE | The densitized energy density of neutrinos of a given species \({\tilde E}\) |
| CTildeHNormal | The normal component of the fluid-frame momentum density of neutrinos of a given species \({\tilde H}^a t_a\) |
| CTildeHSpatial | The spatial components of the fluid-frame momentum density of neutrinos of a given species \({\tilde H}^a {\gamma}_{ia}\) |
| CTildeJ | The fluid-frame densitized energy density of neutrinos of a given species \({\tilde J}\) |
| CTildeP | The densitized pressure tensor of neutrinos of a given species \({\tilde P^{ij}}\) computed from \({\tilde E}\), \({\tilde S_i}\) using the M1 closure |
| CTildeS | The densitized momentum density of neutrinos of a given species \({\tilde S_i}\) |
| CTildeSVector | The upper index momentum density of a neutrino species |
| CComputeFluxes | The fluxes of the conservative variables in the M1 scheme |
| CComputeLargestCharacteristicSpeed | |
| CComputeM1Closure | |
| CComputeM1Closure< tmpl::list< NeutrinoSpecies... > > | |
| CComputeM1HydroCoupling | |
| CComputeM1HydroCoupling< tmpl::list< NeutrinoSpecies... > > | |
| CComputeSources | Compute the curvature source terms for the flux-balanced grey M1 radiation transport |
| CSystem | |
| CSystem< tmpl::list< NeutrinoSpecies... > > | |
| ►CTimeDerivativeTerms | |
| CTildeSUp | |
| ►NRegistration | Helpers for derived class registration |
| CRegistrar | A template for defining a registrar |
| ►NRelativisticEuler | Items related to evolving the relativistic Euler system |
| ►NSolutions | Holds classes implementing a solution to the relativistic Euler system |
| ►CFishboneMoncriefDisk | Fluid disk orbiting a Kerr black hole |
| CBhDimlessSpin | The dimensionless black hole spin, \(\chi = a/M\) |
| CBhMass | The mass of the black hole, \(M\) |
| CInnerEdgeRadius | The radial coordinate of the inner edge of the disk, in units of \(M\) |
| CIntermediateVariables | |
| CMaxPressureRadius | The radial coordinate of the maximum pressure, in units of \(M\) |
| CPolytropicConstant | The polytropic constant of the fluid |
| CPolytropicExponent | The polytropic exponent of the fluid |
| CSmoothFlow | Smooth wave propagating in Minkowski spacetime |
| ►CTovStar | A static spherically symmetric star |
| CCentralDensity | The central density of the star |
| CPolytropicConstant | The polytropic constant of the polytropic fluid |
| CPolytropicExponent | The polytropic exponent of the polytropic fluid |
| CRadialVariables | The radial variables needed to compute the full TOVStar solution |
| ►NValencia | The Valencia formulation of the relativistic Euler System See Chapter 7 of Relativistic Hydrodynamics by Luciano Rezzolla and Olindo Zanotti or http://iopscience.iop.org/article/10.1086/303604 |
| ►NBoundaryConditions | Boundary conditions for the relativistic Euler system |
| CBoundaryCondition | The base class off of which all boundary conditions must inherit |
| CDirichletAnalytic | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
| ►NBoundaryCorrections | Boundary corrections/numerical fluxes |
| CBoundaryCorrection | The base class used to create boundary corrections from input files and store them in the global cache |
| CRusanov | A Rusanov/local Lax-Friedrichs Riemann solver |
| ►NTags | Tags for the Valencia formulation of the relativistic Euler system |
| CCharacteristicSpeeds | The characteristic speeds |
| CCharacteristicSpeedsCompute | |
| CTildeD | The densitized rest-mass density \({\tilde D}\) |
| CTildeS | The densitized momentum density \({\tilde S_i}\) |
| CTildeTau | The densitized energy density \({\tilde \tau}\) |
| CComputeFluxes | The fluxes of the conservative variables |
| CComputeLargestCharacteristicSpeed | |
| CComputeSources | Compute the source terms for the flux-conservative Valencia formulation of the relativistic Euler system |
| CConservativeFromPrimitive | Compute the conservative variables from primitive variables |
| ►CFixConservatives | Fix conservative variables using the method proposed in F. Foucart's PhD thesis (Cornell) |
| CCutoffD | The cutoff below which \(D\) is set to MinimumValueOfD |
| CMinimumValueOfD | The minimum value of the rest mass density times the Lorentz factor, \(D\) |
| CSafetyFactorForS | The safety factor to fix \(\tilde S_i\) |
| CPrimitiveFromConservative | Compute the primitive variables from the conservative variables |
| CSystem | |
| ►CTimeDerivativeTerms | Compute the time derivative of the conserved variables for the Valencia formulation of the relativistic Euler equations |
| CDensitizedStress | |
| CPressureLapseSqrtDetSpatialMetric | |
| CTildeSUp | |
| CTransportVelocity | |
| CAnalyticSolution | Base struct for properties common to all Relativistic Euler analytic solutions |
| ►NResidualMonitorActionsTestHelpers | |
| CCheckObservationIdTag | |
| CCheckReductionDataTag | |
| CCheckReductionNamesTag | |
| CCheckSubfileNameTag | |
| CMockObserverWriter | |
| CMockWriteReductionData | |
| NRootFinder | |
| ►NScalarAdvection | Items related to evolving the scalar advection equation |
| ►NBoundaryConditions | Boundary conditions for the ScalarAdvection system |
| CBoundaryCondition | The base class off of which all boundary conditions must inherit |
| ►NBoundaryCorrections | Boundary corrections/numerical fluxes |
| CBoundaryCorrection | The base class used to create boundary corrections from input files and store them in the global cache |
| CRusanov | A Rusanov/local Lax-Friedrichs Riemann solver |
| ►NSolutions | Holds classes implementing a solution to the ScalarAdvection equation |
| CSinusoid | An 1D sinusoidal wave advecting with speed 1.0, periodic over the interval \([-1, 1]\) |
| ►NTags | Tags for the ScalarAdvection system |
| CLargestCharacteristicSpeed | The largest characteristic speed |
| CLargestCharacteristicSpeedCompute | Compute the largest characteristic speed of the ScalarAdvection system |
| CU | The scalar field to evolve |
| CVelocityField | The advection velocity field |
| CVelocityFieldCompute | Compute the advection velocity field \(v\) of the ScalarAdvection system |
| CFluxes | Compute the fluxes of the ScalarAdvection system \(F^i = v^iU\) where \(v^i\) is the velocity field |
| CSystem | |
| CTimeDerivativeTerms | Computes the time derivative terms needed for the ScalarAdvection system, which are just the fluxes |
| ►NScalarWave | Items related to evolving the scalar wave equation |
| ►NActions | |
| CInitializeConstraints | Initialize items related to constraints of the ScalarWave system |
| ►NBoundaryConditions | Boundary conditions for the scalar wave system |
| CBoundaryCondition | The base class off of which all boundary conditions must inherit |
| ►CConstraintPreservingSphericalRadiation | Constraint-preserving spherical radiation boundary condition that seeks to avoid ingoing constraint violations and radiation |
| CTypeOptionTag | |
| CDirichletAnalytic | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
| ►CSphericalRadiation | Impose spherical radiation boundary conditions |
| CTypeOptionTag | |
| ►NBoundaryCorrections | Boundary corrections/numerical fluxes |
| CBoundaryCorrection | The base class used to make boundary corrections factory createable so they can be specified in the input file |
| CUpwindPenalty | Computes the scalar wave upwind multipenalty boundary correction |
| ►NSolutions | Holds classes implementing a solution to the Euclidean wave equation \(0 = \frac{\partial^2 \Psi}{\partial t^2} - \nabla^2 \Psi\) |
| ►CPlaneWave | A plane wave solution to the Euclidean wave equation |
| CCenter | |
| CProfile | |
| CWaveVector | |
| ►CRegularSphericalWave | A 3D spherical wave solution to the Euclidean wave equation that is regular at the origin |
| CProfile | |
| ►CSemidiscretizedDg | An exact solution to the semidiscretized DG ScalarWave system with an upwind flux |
| CAmplitudes | |
| CHarmonic | |
| ►NTags | Tags for the ScalarWave evolution system |
| CCharacteristicFields | |
| CCharacteristicFieldsCompute | |
| CCharacteristicSpeeds | |
| CCharacteristicSpeedsCompute | |
| CComputeLargestCharacteristicSpeed | Compute the maximum magnitude of the characteristic speeds |
| CConstraintGamma2 | |
| CEnergyDensity | The energy density of the scalar wave |
| CEnergyDensityCompute | Computes the energy density using ScalarWave::energy_density() |
| CEvolvedFieldsFromCharacteristicFields | |
| CEvolvedFieldsFromCharacteristicFieldsCompute | |
| CLargestCharacteristicSpeed | |
| COneIndexConstraint | Tag for the one-index constraint of the ScalarWave system |
| COneIndexConstraintCompute | Compute item to get the one-index constraint for the scalar-wave evolution system |
| CTwoIndexConstraint | Tag for the two-index constraint of the ScalarWave system |
| CTwoIndexConstraintCompute | Compute item to get the two-index constraint for the scalar-wave evolution system |
| CVMinus | |
| CVPlus | |
| CVPsi | Tags corresponding to the characteristic fields of the flat-spacetime scalar-wave system |
| CVZero | |
| CComputeNormalDotFluxes | A relic of an old incorrect way of handling boundaries for non-conservative systems |
| CPhi | |
| CPi | |
| CPsi | |
| CSystem | |
| CTimeDerivative | Compute the time derivatives for scalar wave system |
| CUpwindPenaltyCorrection | Computes the scalar wave upwind multipenalty boundary correction |
| ►NSelfStart | Definition of the integrator self-starting procedure |
| ►NActions | Self-start actions |
| CCheckForCompletion | Resets the state for the next iteration if the current order is complete, and exits the self-start loop if the required order has been reached |
| CCheckForOrderIncrease | If we have taken enough steps for this order, set the next time to the start time and increment the slab number |
| CCleanup | Cleans up after the self-start procedure |
| CInitialize | Prepares the evolution for time-stepper self-starting |
| ►NTags | Self-start tags |
| CInitialValue | The initial value of a quantity. The contents are stored in a tuple to avoid putting duplicate tensors into the DataBox |
| ►NSolveElasticity | |
| ►NOptionTags | |
| CGmresGroup | |
| CLinearSolverGroup | |
| CSchwarzSmootherGroup | |
| ►NSolvePoisson | |
| ►NOptionTags | |
| CGmresGroup | |
| CLinearSolverGroup | |
| CSchwarzSmootherGroup | |
| ►NSolveXcts | |
| ►NOptionTags | |
| CGmresGroup | |
| CLinearSolverGroup | |
| CNewtonRaphsonGroup | |
| CNonlinearSolverGroup | |
| CSchwarzSmootherGroup | |
| ►NSpatialDiscretization | |
| ►NOptionTags | |
| CSpatialDiscretizationGroup | Group holding all the options for the spatial discretization of the PDE system |
| ►NSpectral | Functionality associated with a particular choice of basis functions and quadrature for spectral operations |
| Nfiltering | Matrices for filtering spectral coefficients |
| ►NSwsh | Namespace for spin-weighted spherical harmonic utilities |
| ►NTags | |
| CDerivative | Prefix tag representing the spin-weighted derivative of a spin-weighted scalar |
| CEth | Struct for labeling the \(\eth\) spin-weighted derivative in tags |
| CEthbar | Struct for labeling the \(\bar{\eth}\) spin-weighted derivative in tags |
| CEthbarEth | Struct for labeling the \(\bar{\eth} \eth\) spin-weighted derivative in tags |
| CEthbarEthbar | Struct for labeling the \(\bar{\eth}^2\) spin-weighted derivative in tags |
| CEthEth | Struct for labeling the \(\eth^2\) spin-weighted derivative in tags |
| CEthEthbar | Struct for labeling the \(\eth \bar{\eth}\) spin-weighted derivative in tags |
| CInverseEth | Struct for labeling the inverse \(\eth^{-1}\) spin-weighted derivative in tags |
| CInverseEthbar | Struct for labeling the inverse \(\bar{\eth}^{-1}\) spin-weighted derivative in tags |
| CLMax | Tag for the maximum spin-weighted spherical harmonic l; sets angular resolution |
| CLMaxBase | Base Tag for the maximum spin-weighted spherical harmonic l; sets angular resolution |
| CNoDerivative | Struct which acts as a placeholder for a spin-weighted derivative label in the spin-weighted derivative utilities, but represents a 'no-op': no derivative is taken |
| CNumberOfRadialPoints | Tag for the number of radial grid points in the three-dimensional representation of radially concentric spherical shells |
| CNumberOfRadialPointsBase | Base Tag for the number of radial grid points in the three-dimensional representation of radially concentric spherical shells |
| CSwshInterpolator | Tag for a SwshInterpolator associated with a particular set of angular coordinates |
| CSwshTransform | Prefix tag representing the spin-weighted spherical harmonic transform of a spin-weighted scalar |
| ►CCoefficientsMetadata | A container for libsharp metadata for the spin-weighted spherical harmonics modal representation |
| CCoefficientsIndexIterator | An iterator for easily traversing a libsharp-compatible spin-weighted spherical harmonic modal representation. The operator*() returns a LibsharpCoefficientInfo, which contains two offsets, transform_of_real_part_offset and transform_of_imag_part_offset, and the l_max, l and m associated with the values at those offsets |
| ►CCollocationMetadata | A wrapper class for the spherical harmonic library collocation data |
| CCollocationConstIterator | |
| CInverseSwshTransform | A DataBox mutate-compatible computational struct for performing several spin-weighted inverse spherical harmonic transforms. Internally dispatches to libsharp |
| CLibsharpCoefficientInfo | Points to a single pair of modes in a libsharp-compatible spin-weighted spherical harmonic modal representation |
| CLibsharpCollocationPoint | A container for reporting a single collocation point for libsharp compatible data structures |
| CSpinWeightedSphericalHarmonic | A utility for evaluating a particular spin-weighted spherical harmonic function at arbitrary points |
| CSwshInterpolator | Performs interpolation for spin-weighted spherical harmonics by taking advantage of the Clenshaw method of expanding recurrence relations |
| CSwshTransform | A DataBox mutate-compatible computational struct for performing several spin-weighted spherical harmonic transforms. Internally dispatches to libsharp |
| Nsr | Holds functions related to special relativity |
| ►NStepChoosers | Holds all the StepChoosers |
| ►NTags | |
| CPreviousStepError | The stepper error measure computed in the previous application of the StepChooser::ErrorControl step chooser |
| ►CByBlock | Suggests specified step sizes in each block |
| CSizes | |
| ►CCfl | Suggests a step size based on the CFL stability criterion |
| CSafetyFactor | |
| CConstant | Suggests a constant step size |
| ►CElementSizeCfl | Suggests a step size based on the CFL stability criterion, but uses the full size of the element as the length scale in question |
| CSafetyFactor | |
| ►CErrorControl | Suggests a step size based on a target absolute and/or relative error measure |
| CAbsoluteTolerance | |
| CMaxFactor | |
| CMinFactor | |
| CRelativeTolerance | |
| CSafetyFactor | |
| ►CIncrease | Suggests increasing the step size by a constant ratio |
| CFactor | |
| CPreventRapidIncrease | Avoids instabilities due to rapid increases in the step size by preventing the step size from increasing unless all steps in the time-stepper history are the same size. If there have been recent step size changes the new size bound is the size of the most recent step, otherwise it is infinite (no restriction is imposed) |
| ►CStepToTimes | Suggests step sizes to place steps at specific times |
| CTimes | |
| NStepChooserUse | The intended use for a step chooser. This is used to control the classes via factories |
| ►NStepControllers | Holds all the StepControllers |
| CBinaryFraction | A StepController that chooses steps to be 1/2^n of a slab |
| CFullSlab | A StepController that always chooses to step a full slab, independent of the desired step size. Intended for simuations using global time stepping |
| CSimpleTimes | A StepController that roughly splits the remaining time, but prefers simpler (smaller denominator) fractions of slabs |
| CSplitRemaining | A StepController that chooses steps to be 1/n of the remainder of the slab |
| ►NStrahlkorperGr | Contains functions that depend both on a Strahlkorper and a metric |
| ►NTags | Holds tags and ComputeItems associated with a Strahlkorper that also need a metric |
| CArea | Tag representing the surface area of a Strahlkorper |
| CAreaCompute | Computes the surface area of a Strahlkorer, \(A = \oint_S dA\) given an AreaElement \(dA\) and a Strahlkorper \(S\) |
| CAreaElement | Computes the area element on a Strahlkorper. Useful for integrals |
| CAreaElementCompute | |
| CChristodoulouMass | The Christodoulou mass, which is a function of the dimensionful spin angular momentum and the irreducible mass of a Strahlkorper |
| CChristodoulouMassCompute | Computes the Christodoulou mass from the dimensionful spin angular momentum and the irreducible mass of a Strahlkorper |
| CDimensionfulSpinMagnitude | The approximate-Killing-Vector quasilocal spin magnitude of a Strahlkorper (see Sec. 2.2 of [17] and references therein) |
| CDimensionfulSpinMagnitudeCompute | Computes the approximate-Killing-Vector quasilocal spin magnitude of a Strahlkorper |
| CDimensionfulSpinVector | The dimensionful spin angular momentum vector |
| CDimensionfulSpinVectorCompute | Computes the dimensionful spin angular momentum vector |
| CIrreducibleMass | The Irreducible (areal) mass of an apparent horizon |
| CIrreducibleMassCompute | Computes the Irreducible mass of an apparent horizon from its area |
| CSpinFunction | The spin function is proportional to the imaginary part of the Strahlkorper’s complex scalar curvature |
| CSpinFunctionCompute | Calculates the spin function which is proportional to the imaginary part of the Strahlkorper’s complex scalar curvature |
| CSurfaceIntegral | Computes the integral of a scalar over a Strahlkorper |
| CSurfaceIntegralCompute | |
| ►NStrahlkorperTags | Holds tags and ComputeItems associated with a Strahlkorper |
| Naliases | Defines type aliases used in Strahlkorper-related Tags |
| CCartesianCoords | CartesianCoords(i) is \(x_{\rm surf}^i\), the vector of \((x,y,z)\) coordinates of each point on the surface |
| CCartesianCoordsCompute | |
| CD2xRadius | D2xRadius(i,j) is \(\partial^2 r_{\rm surf}/\partial x^i\partial x^j\). Here \(r_{\rm surf}=r_{\rm surf}(\theta,\phi)\) is the function describing the surface, which is considered a function of Cartesian coordinates \(r_{\rm surf}=r_{\rm surf}(\theta(x,y,z),\phi(x,y,z))\) for this operation |
| CD2xRadiusCompute | |
| CDimensionfulSpinVector | |
| CDimensionfulSpinVectorCompute | |
| CDxRadius | DxRadius(i) is \(\partial r_{\rm surf}/\partial x^i\). Here \(r_{\rm surf}=r_{\rm surf}(\theta,\phi)\) is the function describing the surface, which is considered a function of Cartesian coordinates \(r_{\rm surf}=r_{\rm surf}(\theta(x,y,z),\phi(x,y,z))\) for this operation |
| CDxRadiusCompute | |
| CEuclideanAreaElement | Computes the Euclidean area element on a Strahlkorper. Useful for flat space integrals |
| CEuclideanAreaElementCompute | |
| CEuclideanSurfaceIntegral | Computes the flat-space integral of a scalar over a Strahlkorper |
| CEuclideanSurfaceIntegralCompute | |
| CEuclideanSurfaceIntegralVector | Computes the Euclidean-space integral of a vector over a Strahlkorper, \(\oint V^i s_i (s_j s_k \delta^{jk})^{-1/2} d^2 S\), where \(s_i\) is the Strahlkorper surface unit normal and \(\delta^{ij}\) is the Kronecker delta. Note that \(s_i\) is not assumed to be normalized; the denominator of the integrand effectively normalizes it using the Euclidean metric |
| CEuclideanSurfaceIntegralVectorCompute | |
| CExtrinsicCurvature | Extrinsic curvature of a 2D Strahlkorper embedded in a 3D space |
| CExtrinsicCurvatureCompute | Calculates the Extrinsic curvature of a 2D Strahlkorper embedded in a 3D space |
| CGradUnitNormalOneForm | The 3-covariant gradient \(D_i S_j\) of a Strahlkorper's normal |
| CGradUnitNormalOneFormCompute | Computes 3-covariant gradient \(D_i S_j\) of a Strahlkorper's normal |
| CInvHessian | InvHessian(k,i,j) is \(\partial (J^{-1}){}^k_j/\partial x^i\), where \((J^{-1}){}^k_j\) is the inverse Jacobian. InvHessian is not symmetric because the Jacobians are Pfaffian. InvHessian doesn't depend on the shape of the surface |
| CInvHessianCompute | |
| CInvJacobian | InvJacobian(0,i) is \(r\partial\theta/\partial x^i\), and InvJacobian(1,i) is \(r\sin\theta\partial\phi/\partial x^i\). Here \(r\) means \(\sqrt{x^2+y^2+z^2}\). InvJacobian doesn't depend on the shape of the surface |
| CInvJacobianCompute | |
| CJacobian | Jacobian(i,0) is \(\frac{1}{r}\partial x^i/\partial\theta\), and Jacobian(i,1) is \(\frac{1}{r\sin\theta}\partial x^i/\partial\phi\). Here \(r\) means \(\sqrt{x^2+y^2+z^2}\). Jacobian doesn't depend on the shape of the surface |
| CJacobianCompute | |
| CLaplacianRadius | \(\nabla^2 r_{\rm surf}\), the flat Laplacian of the surface. This is \(\eta^{ij}\partial^2 r_{\rm surf}/\partial x^i\partial x^j\), where \(r_{\rm surf}=r_{\rm surf}(\theta(x,y,z),\phi(x,y,z))\) |
| CLaplacianRadiusCompute | |
| CMaxRicciScalar | The pointwise maximum of the Strahlkorper's intrinsic Ricci scalar curvature |
| CMaxRicciScalarCompute | Computes the pointwise maximum of the Strahlkorper's intrinsic Ricci scalar curvature |
| CMinRicciScalar | The pointwise minimum of the Strahlkorper’s intrinsic Ricci scalar curvature |
| CMinRicciScalarCompute | Computes the pointwise minimum of the Strahlkorper’s intrinsic Ricci scalar curvature |
| CNormalOneForm | NormalOneForm(i) is \(s_i\), the (unnormalized) normal one-form to the surface, expressed in Cartesian components. This is computed by \(x_i/r-\partial r_{\rm surf}/\partial x^i\), where \(x_i/r\) is Rhat and \(\partial r_{\rm surf}/\partial x^i\) is DxRadius. See Eq. (8) of [9]. Note on the word "normal": \(s_i\) points in the correct direction (it is "normal" to the surface), but it does not have unit length (it is not "normalized"; normalization requires a metric) |
| CNormalOneFormCompute | |
| COneOverOneFormMagnitude | The OneOverOneFormMagnitude is the reciprocal of the magnitude of the one-form perpendicular to the horizon |
| COneOverOneFormMagnitudeCompute | Computes the reciprocal of the magnitude of the one form perpendicular to the horizon |
| CRadius | (Euclidean) distance \(r_{\rm surf}(\theta,\phi)\) from the center to each point of the surface |
| CRadiusCompute | |
| CRhat | Rhat(i) is \(\hat{r}^i = x_i/\sqrt{x^2+y^2+z^2}\) on the grid. Doesn't depend on the shape of the surface |
| CRhatCompute | |
| CRicciScalar | Ricci scalar is the two-dimensional intrinsic Ricci scalar curvature of a Strahlkorper |
| CRicciScalarCompute | Computes the two-dimensional intrinsic Ricci scalar of a Strahlkorper |
| CStrahlkorper | Tag referring to a Strahlkorper |
| CTangents | Tangents(i,j) is \(\partial x_{\rm surf}^i/\partial q^j\), where \(x_{\rm surf}^i\) are the Cartesian coordinates of the surface (i.e. CartesianCoords) and are considered functions of \((\theta,\phi)\) |
| CTangentsCompute | |
| CThetaPhi | \((\theta,\phi)\) on the grid. Doesn't depend on the shape of the surface |
| CThetaPhiCompute | |
| CUnitNormalOneForm | The unit normal one-form \(s_j\) to the horizon |
| CUnitNormalOneFormCompute | Computes the unit one-form perpendicular to the horizon |
| CUnitNormalVector | UnitNormalVector is defined as \(S^i = \gamma^{ij} S_j\), where \(S_j\) is the unit normal one form and \(\gamma^{ij}\) is the inverse spatial metric |
| CUnitNormalVectorCompute | Computes the UnitNormalVector perpendicular to the horizon |
| Nsys | |
| ►NTags | |
| CAnalytic | Prefix indicating the analytic solution value for a quantity |
| CAnalyticData | The analytic data, with the type of the analytic data set as the template parameter |
| CAnalyticDataBase | Can be used to retrieve the analytic solution from the cache without having to know the template parameters of AnalyticData |
| CAnalyticSolution | The analytic solution, with the type of the analytic solution set as the template parameter |
| CAnalyticSolutionBase | Can be used to retrieve the analytic solution from the cache without having to know the template parameters of AnalyticSolution |
| CAnalyticSolutionOrData | |
| CAnalyticSolutions | The analytic solutions for all FieldTags |
| CAnalyticSolutionsBase | Base tag for the analytic solution tensors. Retrieved values can be either Variables or std::optional<Variables> |
| CAnalyticSolutionsOptional | The analytic solutions for all FieldTags, or std::nullopt if no analytic solutions are available |
| CBoundaryCondition | The boundary condition to be applied at all external boundaries |
| CBoundaryConditionBase | Base tag with which to retrieve the BoundaryConditionType |
| CBoundaryHistory | Tag for TimeStepper boundary history |
| CCheckpointAndExitRequested | Stores whether the checkpoint and exit has been requested |
| CDataBox | Tag used to retrieve the DataBox from the db::get function |
| Cderiv | Prefix indicating spatial derivatives |
| Cderiv< Tag, Dim, Frame, Requires< tt::is_a_v< Tensor, typename Tag::type > > > | |
| CDerivCompute | Compute the spatial derivatives of tags in a Variables |
| Cdiv | Prefix indicating the divergence |
| CDivVariablesCompute | Compute the divergence of a Variables |
| CDivVectorCompute | Compute the divergence of a tnsr::I (vector) |
| Cdt | Prefix indicating a time derivative |
| CError | Prefix indicating the error of a value represented by Tag |
| CEuclideanMagnitude | The Euclidean magnitude of a (co)vector |
| CEventsAndTriggers | Contains the events and triggers |
| CFixedSource | Prefix indicating a source term that is independent of dynamic variables |
| CFlux | Prefix indicating a flux |
| CHistoryEvolvedVariables | Tag for the TimeStepper history |
| CInitial | Prefix indicating the initial value of a quantity |
| CIsUsingTimeSteppingErrorControl | A tag that is true if the ErrorControl step chooser is one of the option-created Events |
| CIsUsingTimeSteppingErrorControlBase | Base tag for reporting whether the ErrorControl step chooser is in use |
| CL2Norm | |
| CL2NormCompute | |
| CLimiter | The global cache tag for the limiter |
| CMagnitude | The magnitude of a (co)vector |
| CMean | Given the Tag holding a Tensor<DataVector, ...>, swap the DataVector with a double |
| CModal | Given the NodalTag holding a Tensor<DataVector, ...>, swap the DataVector with a ModalVector |
| CMortars | Data on mortars, indexed by (Direction, ElementId) pairs |
| CMortarSize | Size of a mortar, relative to the element face. That is, the part of the face that it covers |
| CMultiplies | A prefix tag representing the product of two other tags. Note that if non-spin-weighted types are needed in this tag, the type alias detail::product_t should be generalized to give a reasonable type for those cases, or template specializations should be constructed for this tag |
| CNeverUsingTimeSteppingErrorControl | Tag indicating that the ErrorControl step chooser will not be used |
| CNext | Prefix indicating the value a quantity will take on the next iteration of the algorithm |
| CNonEuclideanMagnitude | The magnitude of a (co)vector with respect to a specific metric |
| CNormalDotFlux | Prefix indicating a boundary unit normal vector dotted into the flux |
| CNormalDotFluxCompute | Prefix computing a boundary unit normal vector dotted into the flux from a flux on the boundary |
| CNormalDotNumericalFlux | Prefix indicating a boundary unit normal vector dotted into the numerical flux |
| CNormalized | The normalized (co)vector represented by Tag |
| CNormalizedCompute | Normalizes the (co)vector represented by Tag |
| CNumericalFlux | The global cache tag for the numerical flux |
| CPointwiseL2Norm | |
| CPointwiseL2NormCompute | |
| ►CRestartPhase | Storage in the phase change decision tuple so that the Main chare can record the phase to go to when restarting the run from a checkpoint file |
| Ccombine_method | |
| ►CReturnPhase | Storage in the phase change decision tuple so that the Main chare can record the phase to return to after a temporary phase |
| Ccombine_method | |
| CSimpleMortarData | Simple boundary communication data |
| CSource | Prefix indicating a source term |
| Cspacetime_deriv | Prefix indicating spacetime derivatives |
| Cspacetime_deriv< Tag, Dim, Frame, Requires< tt::is_a_v< Tensor, typename Tag::type > > > | |
| CSpinWeighted | Given a Tag with a type of Tensor<VectorType, ...>, acts as a new version of the tag with type of Tensor<SpinWeighted<VectorType, SpinConstant::value>, ...>, which is the preferred tensor type associated with spin-weighted quantities. Here, SpinConstant must be a std::integral_constant or similar type wrapper for a compile-time constant, in order to work properly with DataBox utilities |
| CSqrt | The square root of a scalar |
| CSqrtCompute | The square root of a scalar |
| CStepChoosers | Tag for a vector of StepChoosers |
| CStepController | Tag for a StepController |
| CStepperError | Tag for the stepper error measure |
| CStepperErrorUpdated | Tag indicating whether the stepper error has been updated on the current step |
| CSubitem | Reference tag that refers to a particular Tag that is a subitem of an item tagged with ParentTag |
| CSubitem<::domain::Tags::Interface< DirectionsTag, TensorTag >, ::domain::Tags::InterfaceCompute< DirectionsTag, VariablesTag > > | Specialization of a subitem tag for an interface compute tag of a Variables |
| CSubitem<::domain::Tags::Interface< DirectionsTag, TensorTag >, ::domain::Tags::Slice< DirectionsTag, VariablesTag > > | Specialization of a subitem tag for an interface compute tag of a sliced Variables |
| CSubstepTime | Tag for Time of the current substep |
| CSubstepTimeCompute | Tag for computing the substep time from (from Tags::TimeStepId) |
| CTemporaryPhaseRequested | Stores whether the phase in question has been requested |
| CTempTensor | |
| CTime | Tag for the current time as a double |
| CTimeStep | Tag for step size |
| CTimeStepId | Tag for TimeStepId for the algorithm state |
| CTimeStepper | Tag for a TimeStepper of type StepperType |
| CVariableFixer | The global cache tag for the variable fixer |
| CVariables | |
| ►CWallclockHoursAtCheckpoint | Storage in the phase change decision tuple so that the Main chare can record the elapsed wallclock time since the start of the run |
| Ccombine_method | |
| ►NTensorExpressions | |
| CAddSub | |
| CAddSub< T1, T2, ArgsList1< Args1... >, ArgsList2< Args2... >, Sign > | |
| CLhsTensorSymmAndIndices | Determines and stores a LHS tensor's symmetry and index list from a RHS tensor expression and desired LHS index order |
| CNumberAsExpression | Defines an expression representing a double |
| COuterProduct | Defines the tensor expression representing the outer product of two tensor expressions |
| ►COuterProduct< T1, T2, IndexList1< Indices1... >, IndexList2< Indices2... >, ArgsList1< Args1... >, ArgsList2< Args2... > > | |
| CGetOpTensorMultiIndex | Helper struct for computing the multi-index of a component of an operand of the outer product from the multi-index of a component of the outer product |
| CGetOpTensorMultiIndex< tmpl::list< OperandTensorIndices... > > | |
| CSquareRoot | Defines the tensor expression representing the square root of a tensor expression that evaluates to a rank 0 tensor |
| CTensorAsExpression | Defines an expression representing a Tensor |
| CTensorAsExpression< Tensor< X, Symm, IndexList< Indices... > >, ArgsList< Args... > > | |
| ►CTensorContract | |
| CComputeContraction | Helper struct for computing the contraction of one pair of indices |
| CComputeContraction< tmpl::list< UncontractedLhsTensorIndices... > > | |
| NTensorMetafunctions | Contains all metafunctions related to Tensor manipulations |
| ►NTestHelpers | |
| NAnalyticData | Functions for testing analytic data |
| NAnalyticSolutions | Functions for testing analytic solutions |
| ►NControlErrors | |
| CTranslation | |
| ►Ndb | |
| ►NTags | |
| CBad | |
| CBase | |
| CLabel | |
| CParentTag | |
| CSimple | |
| CSimpleCompute | |
| CSimpleReference | |
| CSimpleWithBase | |
| CSimpleWithBaseCompute | |
| CSimpleWithBaseReference | |
| ►NDenseTriggers | |
| ►CBoxTrigger | |
| CIsReady | |
| CIsTriggered | |
| CNextCheck | |
| ►CTestTrigger | |
| CIsReady | |
| CIsTriggered | |
| CNextCheck | |
| ►Ndg | |
| ►NEvents | |
| ►NObserveFields | |
| ►CComplicatedSystem | |
| CScalarVar | |
| Csolution_for_test | |
| CTensorVar | |
| CTensorVar2 | |
| CUnobservedVar | |
| CUnobservedVar2 | |
| CVectorVar | |
| CElementComponent | |
| ►CMetavariables | |
| Cfactory_creation | |
| ►CMockContributeVolumeData | |
| CResults | |
| CMockObserverComponent | |
| CObservationTimeTag | |
| ►CScalarSystem | |
| CScalarVar | |
| Csolution_for_test | |
| ►Ndomain | |
| ►NBoundaryConditions | Helpers for boundary conditions |
| CBoundaryConditionBase | A system-specific boundary condition base class |
| ►CMetavariablesWithBoundaryConditions | Metavariables with a system that has boundary conditions |
| Cfactory_creation | |
| ►CMetavariablesWithoutBoundaryConditions | Metavariables with a system that doesn't have boundary conditions |
| Cfactory_creation | |
| CSystemWithBoundaryConditions | Empty system that has boundary conditions |
| CSystemWithoutBoundaryConditions | Empty system that doesn't have boundary conditions |
| ►CTestBoundaryCondition | Concrete boundary condition |
| CBlockIdOptionTag | |
| CDirectionOptionTag | |
| Nelliptic | Helper functions to test elliptic first-order systems |
| NEquationsOfState | |
| ►Nevolution | |
| ►Ndg | |
| ►NTags | Tags for testing DG code |
| CPythonFunctionForErrorMessage | The name of the python function that returns the error message |
| CPythonFunctionName | Tag for a TaggedTuple that holds the name of the python function that gives the result for computing what Tag should be |
| CRange | Tag for a TaggedTuple that holds the range of validity for the variable associated with Tag |
| Ngr | Make random GR variables which correct physical behavior, e.g. spatial metric will be positive definite |
| Nhydro | Make random hydro variables which correct physical behavior, e.g. Lorentz factor will be greater or equal than one |
| NKerr | |
| ►NLinearSolver | |
| ►Nmultigrid | |
| ►NOptionTags | |
| CLinearOperator | |
| COperatorIsMassive | |
| CCollectOperatorAction | |
| CComputeOperatorAction | |
| CInitializeElement | |
| CLinearOperator | |
| COperatorIsMassive | |
| CTestResult | |
| CApplyMatrix | |
| CExactInversePreconditioner | |
| CJacobiPreconditioner | |
| CRichardsonPreconditioner | |
| NMathFunctions | |
| NMinkowski | |
| ►NNewtonianEuler | |
| CFirstArg | |
| CFourthArg | |
| CSecondArg | |
| CSomeOtherSourceType | |
| CSomeSourceType | |
| CTestInitialData | |
| CThirdArg | |
| ►NNonlinearSolver | |
| CElementArray | |
| CExpectedResult | |
| CInitialGuess | |
| CInitializeElement | |
| CSource | |
| CTestResult | |
| CVectorTag | |
| ►NNumericalFluxes | |
| ►NTags | |
| CCharacteristicSpeeds | |
| CVariable1 | |
| CVariable2 | |
| CVariable3 | |
| CVariable4 | |
| CSystem | |
| NSchwarzschild | |
| ►NTags | |
| CDerivOfVector | |
| COneForm | [simple_variables_tag] |
| CPrefix0 | [prefix_variables_tag] |
| CPrefix1 | [prefix_variables_tag] |
| CPrefix2 | |
| CPrefix3 | |
| CScalar | |
| CScalar2 | |
| CVector | [simple_variables_tag] |
| NTensorExpressions | |
| NVectorImpl | |
| NVerifyGrSolution | Functions for testing GR analytic solutions |
| ►NTimeSequences | Holds all the TimeSequences |
| ►CEvenlySpaced | A sequence of evenly spaced times |
| CInterval | |
| COffset | |
| ►CSpecified | An explicitly specified sequence of times |
| CValues | |
| ►NTimeSteppers | Holds classes that take time steps |
| ►CAdamsBashforthN | |
| COrder | |
| CBoundaryHistory | History data used by a TimeStepper for boundary integration |
| CDormandPrince5 | |
| CHistory | History data used by a TimeStepper |
| CHistoryIterator | Iterator over history data used by a TimeStepper. See History for details |
| CRungeKutta3 | A "strong stability-preserving" 3rd-order Runge-Kutta time-stepper, as described in [58] section 5.7 |
| CRungeKutta4 | |
| ►Ntmpl2 | Metaprogramming things that are not planned to be submitted to Brigand |
| Cvalue_list | A compile-time list of values of the same type |
| Ntnsr | Type aliases to construct common Tensors |
| Ntransform | Holds functions related to transforming between frames |
| ►NTriggers | |
| CAlways | Always triggers |
| CAnd | Short-circuiting logical AND of other triggers |
| ►CNearTimes | Trigger in intervals surrounding particular times |
| ►COptionTags | |
| CDirection | |
| CRange | |
| CTimes | |
| CUnit | |
| CNot | Negates another trigger |
| COr | Short-circuiting logical OR of other triggers |
| ►CSlabCompares | Trigger based on a comparison with the slab number |
| CComparison | |
| CValue | |
| CSlabs | Trigger at specified numbers of slabs after the simulation start |
| ►CTimeCompares | Trigger based on a comparison with the time |
| CComparison | |
| CValue | |
| CTimes | Trigger at particular times |
| ►Ntt | A collection of useful type traits |
| Ccan_be_copy_constructed | Check if T is copy constructible |
| CConformsTo | Indicate a class conforms to the Protocol |
| Cget_fundamental_type | Extracts the fundamental type for a container |
| Chas_equivalence | Check if type T has operator== defined |
| Chas_inequivalence | Check if type T has operator!= defined |
| Cis_a | Check if type T is a template specialization of U |
| Cis_callable | Check if a type T is callable, i.e. T(Args...) is evaluable |
| Cis_complex_of_fundamental | Determines if a type T is a std::complex of a fundamental type, is a std::true_type if so, and otherwise is a std::false_type |
| Cis_integer | Check if I is an integer type (non-bool, non-character), unlike std::is_integral |
| Cis_iterable | Check if type T has a begin() and end() function |
| Cis_maplike | Check if type T is like a std::map or std::unordored_map |
| Cis_std_array | Check if type T is a std::array |
| Cis_std_array_of_size | Check if type T is a std::array of a given size |
| Cis_streamable | Check if type T has operator<<(S, T) defined |
| Cis_tensor_index | Check if a type T is a TensorIndex used in TensorExpressions |
| Cis_tensor_index< TensorIndex< I > > | |
| Cis_tensor_index_type | Inherits from std::true_type if T is a TensorIndexType |
| Cremove_cvref_wrap | Removes std::reference_wrapper, references, and cv qualifiers |
| Cremove_reference_wrapper | Gets the underlying type if the type is a std::reference_wrapper, otherwise returns the type itself |
| ►Ntuples | |
| CTaggedTuple | An associative container that is indexed by structs |
| CTaggedTuple<> | |
| Ctuple_size | |
| Ctuple_size< const TaggedTuple< Tags... > > | |
| Ctuple_size< const volatile TaggedTuple< Tags... > > | |
| Ctuple_size< TaggedTuple< Tags... > > | |
| Ctuple_size< volatile TaggedTuple< Tags... > > | |
| ►NVariableFixing | Contains all variable fixers |
| ►NActions | |
| CFixVariables | Adjust variables with a variable fixer |
| ►CFixToAtmosphere | Fix the primitive variables to an atmosphere in low density regions |
| CDensityCutoff | Rest mass density at which to impose the atmosphere. Should be greater than or equal to the density of the atmosphere |
| CDensityOfAtmosphere | Rest mass density of the atmosphere |
| CMaxVelocityMagnitude | The maximum magnitude of the velocity when the density is below TransitionDensityCutoff |
| CTransitionDensityCutoff | For densities between DensityOfAtmosphere and TransitionDensityCutoff the velocity is transitioned away from atmosphere to avoid abrupt cutoffs |
| ►CLimitLorentzFactor | Limit the maximum Lorentz factor to LorentzFactorCap in regions where the density is below MaxDensityCutoff |
| CLorentzFactorCap | Largest Lorentz factor allowed. If a larger one is found, normalize velocity to have the Lorentz factor be this value |
| CMaxDensityCutoff | Do not apply the Lorentz factor cap above this density |
| ►CRadiallyFallingFloor | Applies a pressure and density floor dependent on the distance to the origin |
| CMinimumRadius | The minimum radius at which to begin applying the floors on the density and pressure |
| CPowerDensityFloor | The power of the radius of the floor of the rest mass density |
| CPowerPressureFloor | The power of the radius of the floor of the pressure |
| CScaleDensityFloor | The scale of the floor of the rest mass density |
| CScalePressureFloor | The scale of the floor of the pressure |
| Nvis | Holds functions needed for visualizing data |
| ►NXcts | Items related to solving the Extended Conformal Thin Sandwich (XCTS) decomposition of the Einstein constraint equations |
| ►NAnalyticData | Analytic data for the XCTS equations, i.e. field configurations that do not solve the equations but are used as background or initial guess |
| ►CBinary | Binary compact-object data in general relativity, constructed from superpositions of two isolated objects |
| CAngularVelocity | |
| CFalloffWidths | |
| CObjectA | |
| CObjectB | |
| CXCoords | |
| CCommonVariables | Implementations for variables that analytic-data classes can share |
| ►NBoundaryConditions | |
| CFlatness | Impose flat spacetime at this boundary |
| ►NSolutions | Analytic solutions of the XCTS equations |
| CAnalyticSolution | Base class for analytic solutions of the XCTS equations |
| CCommonVariables | Implementations for variables that solutions can share |
| CConstantDensityStar | A constant density star in general relativity |
| CFlatness | Flat spacetime in general relativity. Useful as initial guess |
| CKerr | Kerr spacetime in general relativity |
| CSchwarzschild | Schwarzschild spacetime in general relativity |
| ►NTags | Tags related to the XCTS equations |
| CConformal | The quantity Tag scaled by the Xcts::Tags::ConformalFactor to the given Power |
| CConformalChristoffelContracted | The Christoffel symbols of the second kind (related to the conformal metric \(\bar{\gamma}_{ij}\)) contracted in their first two indices: \(\bar{\Gamma}_k = \bar{\Gamma}^{i}_{ik}\) |
| CConformalChristoffelFirstKind | The Christoffel symbols of the first kind related to the conformal metric \(\bar{\gamma}_{ij}\) |
| CConformalChristoffelSecondKind | The Christoffel symbols of the second kind related to the conformal metric \(\bar{\gamma}_{ij}\) |
| CConformalFactor | The conformal factor \(\psi(x)\) that rescales the spatial metric \(\gamma_{ij}=\psi^4\bar{\gamma}_{ij}\) |
| CConformalRicciScalar | The Ricci scalar related to the conformal metric \(\bar{\gamma}_{ij}\) |
| CConformalRicciTensor | The Ricci tensor related to the conformal metric \(\bar{\gamma}_{ij}\) |
| CLapseTimesConformalFactor | The product of lapse \(\alpha(x)\) and conformal factor \(\psi(x)\) |
| CLongitudinalShiftBackgroundMinusDtConformalMetric | The conformal longitudinal operator applied to the background shift vector minus the time derivative of the conformal metric \((\bar{L}\beta_\mathrm{background})^{ij} - \bar{u}^{ij}\) |
| CLongitudinalShiftExcess | The conformal longitudinal operator applied to the shift excess \((\bar{L}\beta_\mathrm{excess})^{ij}\) |
| CLongitudinalShiftMinusDtConformalMetricOverLapseSquare | The conformal longitudinal operator applied to the shift vector minus the time derivative of the conformal metric, squared and divided by the square of the lapse: \(\frac{1}{\alpha^2}\left((\bar{L}\beta)^{ij} - \bar{u}^{ij}\right) \left((\bar{L}\beta)_{ij} - \bar{u}_{ij}\right)\) |
| CLongitudinalShiftMinusDtConformalMetricSquare | The conformal longitudinal operator applied to the shift vector minus the time derivative of the conformal metric, squared: \(\left((\bar{L}\beta)^{ij} - \bar{u}^{ij}\right) \left((\bar{L}\beta)_{ij} - \bar{u}_{ij}\right)\) |
| CShiftBackground | The constant part \(\beta^i_\mathrm{background}\) of the shift \(\beta^i=\beta^i_\mathrm{background} + \beta^i_\mathrm{excess}\) |
| CShiftDotDerivExtrinsicCurvatureTrace | The shift vector contracted with the gradient of the trace of the extrinsic curvature: \(\beta^i\partial_i K\) |
| CShiftExcess | The dynamic part \(\beta^i_\mathrm{excess}\) of the shift \(\beta^i=\beta^i_\mathrm{background} + \beta^i_\mathrm{excess}\) |
| CShiftStrain | The symmetric "strain" of the shift vector \(B_{ij} = \bar{D}_{(i}\bar{\gamma}_{j)k}\beta^k = \left(\partial_{(i}\bar{\gamma}_{j)k} - \bar{\Gamma}_{kij}\right)\beta^k\) |
| CFirstOrderSystem | The Extended Conformal Thin Sandwich (XCTS) decomposition of the Einstein constraint equations, formulated as a set of coupled first-order partial differential equations |
| CFluxes | The fluxes \(F^i\) for the first-order formulation of the XCTS equations |
| CLinearizedSources | The linearization of the sources \(S\) for the first-order formulation of the XCTS equations |
| CSources | The sources \(S\) for the first-order formulation of the XCTS equations |
| ►NYlmTestFunctions | |
| CFuncA | |
| CFuncB | |
| CFuncC | |
| CScalarFunctionWithDerivs | |
| CSimpleScalarFunction | |
| CY00 | |
| CY10 | |
| CY11 | |