►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 |
CCleanHistory | Clean time stepper history after a substep |
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 |
►CRandomizeVariables | Optionally add random noise to the initial guess |
►CRandomParameters | |
CAmplitude | |
CSeed | |
CRandomParametersOptionTag | |
CRandomParametersTag | |
CRecordTimeStepperData | Records the variables and their time derivatives in the time stepper history |
CRunEventsOnFailure | Invokes all events specified in Tags::EventsRunAtCleanup |
CSetData | Mutate the DataBox tags in TagsList according to the data |
CUpdateConservatives | Compute the conservative variables from the primitive variables |
CUpdateMessageQueue | Add data to a LinkedMessageQueue |
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 DistributedObject class. It should not be considered as part of the user interface |
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,...) |
►Nader | Namespace containing functions and classes for ADER |
Ncerk | Namespace containing functions and classes for ADER-CERK |
Ncg | Namespace containing functions and classes for ADER-CG |
Ndg | Namespace containing functions and classes for ADER-DG |
►Nah | |
►Ncallbacks | |
CObserveCenters | Writes the center of an apparent horizon to disk in both the Frame template parameter frame and Frame::Inertial frame. Intended to be used in the post_horizon_find_callbacks list of an InterpolationTargetTag |
►NTags | |
CFastFlow | |
CObserveCenters | Simple tag for whether to write the centers of the horizons to disk. Currently this tag is not creatable by options |
CObserveCentersBase | Base tag for whether or not to write the centers of the horizons to disk. Most likely to be used in the ObserveCenters post horizon find callback |
CComputeExcisionBoundaryVolumeQuantities | Given the generalized harmonic variables in the volume, computes the quantities that will be interpolated onto an excision boundary |
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 |
►NActions | Actions for adaptive mesh refinement |
CAdjustDomain | Adjusts the domain given the refinement criteria |
CCollectDataFromChildren | Collects data from child elements to send to their parent element during adaptive mesh refinement |
CCreateChild | Creates a new element in an ArrayAlgorithm whose id is child_id |
CCreateParent | Creates a new element in an ArrayAlgorithm whose id is parent_id |
CEvaluateRefinementCriteria | Evaluates the refinement criteria in order to set the amr::Info of an Element and sends this information to the neighbors of the Element |
CInitializeChild | Initializes the data of a newly created child element from the data of its parent element |
CInitializeParent | Initializes the data of a newly created parent element from the data of its children elements |
CRunAmrDiagnostics | Use the AMR diagnostics gathered from all of the Elements |
CSendAmrDiagnostics | Send AMR diagnostics about Elements to amr::Component |
CSendDataToChildren | Sends data from the parent element to its children elements during adaptive mesh refinement |
CUpdateAmrDecision | Given the AMR decision of a neighboring Element, potentially update the AMR decision of the target Element |
►NCriteria | Criteria for deciding how a mesh should be adapted |
►NOptionTags | Option tags for AMR criteria |
CCriteria | Options for AMR criteria |
►NTags | Tags for adaptive mesh refinement criteria |
CCriteria | The set of adaptive mesh refinement criteria |
►CConstraints | Refine the grid towards the target constraint violation |
CAbsoluteTarget | |
CCoarseningFactor | |
CConstraintsToMonitor | |
►CDriveToTarget | Refine the grid towards the target number of grid points and refinement levels in each dimension and then oscillate about the target |
COscillationAtTarget | The AMR flags chosen when the target number of grid points and refinement levels are reached |
CTargetNumberOfGridPoints | The target number of grid point in each dimension |
CTargetRefinementLevels | The target refinement level in each dimension |
CIncreaseResolution | Uniformly increases the number of grid points by one |
►CLoehner | H-refine the grid based on a smoothness indicator |
CAbsoluteTolerance | |
CCoarseningFactor | |
CRelativeTolerance | |
CVariablesToMonitor | |
►CPersson | H-refine the grid based on power in the highest modes |
CAbsoluteTolerance | |
CCoarseningFactor | |
CExponent | |
CNumHighestModes | |
CVariablesToMonitor | |
►CRandom | Randomly refine (or coarsen) an Element in each dimension |
CProbabilityWeights | |
►CTruncationError | Refine the grid towards the target truncation error |
CAbsoluteTargetTruncationError | |
CRelativeTargetTruncationError | |
CVariablesToMonitor | |
►NInitialization | Mutators used for initialization of adaptive mesh refinement |
CDomain | Initialize items related to the structure of a Domain |
CInitialize | Initialize items related to adaptive mesh refinement |
►NOptionTags | Option tags for AMR polocies |
CAmrGroup | |
CPolicies | Options for AMR policies |
►Nprojectors | AMR projectors |
CCopyFromCreatorOrLeaveAsIs | For h-refinement copy the items from the parent/child, while for p-refinement leave the items unchanged |
CDefaultInitialize | Value initialize the items corresponding to Tags |
CProjectTensors | Update the Tensors corresponding to TensorTags after an AMR change |
CProjectVariables | Update the Variables corresponding to VariablesTags after an AMR change |
►Nprotocols | AMR protocols |
►CAmrMetavariables | Compile-time information for AMR projectors |
Ctest | |
►CProjector | A DataBox mutator used in AMR actions |
Ctest | |
►NTags | Tags for adaptive mesh refinement |
CInfo | Amr::Info for an Element |
CNeighborInfo | Amr::Info for the neighbors of an Element |
CPolicies | The policies for adaptive mesh refinement |
CComponent | A singleton parallel component to manage adaptive mesh refinement |
CCriterion | Base class for something that determines how an adaptive mesh should be changed |
CInfo | Information about an element that is communicated by AMR actions |
►CLimits | The limits on refinement level and resolution for AMR |
CNumGridPoints | Inclusive bounds on the number of grid points per dimension |
CRefinementLevel | Inclusive bounds on the refinement level |
►CPolicies | A set of runtime policies controlling adaptive mesh refinement |
CEnforceTwoToOneBalanceInNormalDirection | Whether or not to enforce 2:1 balance in the direction normal to element faces |
CIsotropy | The isotropy of AMR |
CLimits | The limits on refinement level and resolution for AMR |
►Nblaze | |
CAddTrait< ComplexModalVector, ComplexModalVector > | |
CAddTrait< ModalVector, ModalVector > | |
CDivTrait< ComplexModalVector, double > | |
CDivTrait< ModalVector, double > | |
CIntegerPow | |
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 > | |
►NBnsInitialData | Items related to solving for irrotational Binary Neutron Star initial data |
►NTags | Items related to solving for irrotational bns initial data |
CDerivLogLapseTimesDensityOverSpecificEnthalpy | The derivative \(D_i \ln (\alpha \rho/h)\) |
CDerivSpatialRotationalKillingVector | |
CEulerEnthalpyConstant | |
CRotationalShift | The shift plus a spatial vector \( k^i\) \(B^i = \beta^i + k^i\) |
CRotationalShiftStress | The stress-energy corresponding to the rotation shift |
CSpatialRotationalKillingVector | |
CVelocityPotential | The velocity potential for the fluid flow \(\Phi\), i.e. the curl-free part of the fluid is given by \(\nabla_a \Phi = h u_a\) |
CFirstOrderSystem | The Irrotational Bns equations From Baumgarte and Shapiro Chapter 15 formulated as a set of coupled first-order PDEs |
CFluxes | Compute the fluxes \(F^i\) for the curved-space Irrotatational BNS equations on a spatial metric \(\gamma_{ij}\) |
CSources | Add the sources \(S_A\) for the curved-space Irrotatioanl BNS equation on a spatial metric \(\gamma_{ij}\) |
►NBnsInitialData | |
►NBoundaryConditions | |
CStarSurface | |
►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 > | |
Cvector_space_norm_inf< boost::math::quaternion< double > > | |
►Nbrigand | |
►Nlazy | |
Clist_contains | Check if a typelist contains an item |
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 |
CDemandOutgoingCharSpeeds | A boundary condition that only verifies that all characteristic speeds are directed out of the domain; no boundary data is altered by this boundary condition |
►CDirichlet | |
CU | |
►CDirichletAnalytic | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
CAnalyticPrescription | What analytic solution/data to prescribe |
►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 |
►Nfd | Finite difference functionality for Burgers system |
►NOptionTags | |
CReconstructor | Holds the subcell reconstructor in the input file |
►NTags | |
CReconstructor | Tag for the reconstructor |
CBoundaryConditionGhostData | Computes finite difference ghost data for external boundary conditions |
CMonotonisedCentral | Monotonised central reconstruction. See fd::reconstruction::monotonised_central() for details |
CReconstructor | The base class from which all reconstruction schemes must inherit |
►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 | |
►Nsubcell | Code required by the DG-subcell/FD hybrid solver for Burgers system |
CGhostVariables | Returns \(U\), the variables needed for reconstruction |
CNeighborPackagedData | On elements using DG, reconstructs the interface data from a neighboring element doing subcell |
CSetInitialRdmpData | Sets the initial RDMP data |
CTciOnDgGrid | The troubled-cell indicator run on the DG grid to check if the solution is admissible |
CTciOnFdGrid | Troubled-cell indicator applied to the finite difference subcell solution to check if the corresponding DG solution is admissible |
CTimeDerivative | Compute the time derivative on the subcell grid using FD reconstruction |
►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 |
CBoundaryComputeAndSendToEvolution< KleinGordonH5WorldtubeBoundary< Metavariables >, EvolutionComponent > | Obtains the Klein-Gordon 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 |
CCalculatePsi0AndDerivAtInnerBoundary | Calculate \(\Psi_0\) and its radial derivative \(\partial_\underline{\lambda}\Psi_0\) at the inner boundary of the CCE grid |
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 |
CInitializeKleinGordonFirstHypersurface | Given initial boundary data for the Klein-Gordon variable \(\Psi\), computes its initial hypersurface data |
CInitializeKleinGordonVariables | Initialize the data storage for the scalar field in the KleinGordonCharacteristicExtract component, which is the singleton that handles the main evolution system for Klein-Gordon CCE computations |
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 |
CInitializeWorldtubeBoundary< KleinGordonH5WorldtubeBoundary< Metavariables > > | Initializes a KleinGordonH5WorldtubeBoundary |
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 |
CPrecomputeKleinGordonSourceVariables | Compute the set of inputs to ComputeKleinGordonSource |
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 |
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 |
CSendGhVarsToCce | Interpolates and sends points to the CceWorldtubeTarget |
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 |
CWriteScriBondiQuantities | Write a single row of data into an h5::Cce subfile within an H5 file |
►NEvents | |
►CObserveFields | Event to observe fields/variables in a characteristic evolution |
CVariablesToObserve | |
►CObserveTimeStep | Observe the size of the time steps on the characteristic evolution |
CPrintTimeToTerminal | |
CSubfileName | The name of the subfile inside the HDF5 file |
►NFrame | |
CRadialNull | The frame for the spherical metric in which the radial coordinate is an affine parameter along outward-pointing null geodesics |
►NInitializationTags | |
CScriInterpolationOrder | |
CScriOutputDensity | |
►NInitializeJ | Contains utilities and DataBox mutators for generating data for \(J\) on the initial CCE hypersurface |
►CConformalFactor | Generate initial data that has a conformal factor \(\omega\) chosen to compensate for the boundary value of \(\beta\) so that the initial time coordinate is approximately inertial at \(I^+\) |
CAngularCoordinateTolerance | |
CConformalFactorIterationHeuristic | |
CInputModes | |
CInputModesFromFile | |
CMaxIterations | |
COptimizeL0Mode | |
CRequireConvergence | |
CUseBetaIntegralEstimate | |
CUseInputModes | |
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 | |
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 interpolation between provided GH data |
CBoundaryInterpolator | |
CGhLockstep | Simple implementation of a GhInterfaceManager that only provides boundary data on matching TimeStepId s |
►NOptionTags | |
CAnalyticSolution | |
CBondiSachsOutputFilePrefix | |
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 | |
CKleinGordonBoundaryDataFilename | |
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 [11] |
CAmplitude | |
CDuration | |
CExtractionRadius | |
CFrequency | |
CMass | |
CPeakTime | |
►CLinearizedBondiSachs | Computes the analytic data for a Linearized solution to the Bondi-Sachs equations described in [11] |
CExtractionRadius | |
CFrequency | |
CInitialModes | |
►CRobinsonTrautman | An analytic solution representing a specialization of the radiative Robinson-Trautman solution described in [51] |
CExtractionRadius | |
CInitialModes | |
CLMax | |
CStartTime | |
CTolerance | |
►CRotatingSchwarzschild | Computes the analytic data for the rotating Schwarzschild solution described in [11], 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 [11] |
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 [136], but without hat |
CCauchyGaugeD | The spin-weight 0 angular Jacobian factor in the Cauchy coordinates, similar to Eq. (31b) of [136], but without hat |
CCauchyGaugeOmega | The conformal factor in the Cauchy coordinates, similar to Eq. (32) of [136], 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 [136] |
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)\) |
CExtractionRadius | |
CExtractionRadiusFromH5 | |
CExtractionRadiusSimple | |
CFilePrefix | |
CFilterLMax | |
CGhInterfaceManager | |
CH5WorldtubeBoundaryDataManager | A tag that constructs a MetricWorldtubeDataManager or BondiWorldtubeDataManager 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 |
CInterpolationManager | |
CJbarQMinus2EthBeta | The value \( \bar{J} (Q - 2 \eth \beta ) \) |
CKleinGordonH5WorldtubeBoundaryDataManager | A tag that constructs a KleinGordonWorldtubeDataManager from options |
CKleinGordonPsi | |
CKleinGordonSource | A prefix tag representing Klein-Gordon sources in Cce hypersurface equations |
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 [136] |
CPartiallyFlatGaugeD | The spin-weight 0 angular Jacobian factor in the partially flat Bondi-like coordinates, see Eq. (31b) of [136] |
CPartiallyFlatGaugeOmega | The conformal factor in the partially flat Bondi-like coordinates, associated with an angular transformation, see Eq. (32) of [136] |
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::KleinGordonPsi > > | Computes the leading part of the scalar field \(\psi\) near \(\mathcal I^+\) |
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::PoleOfIntegrand< Tags::KleinGordonPi > > | Computes the pole part of the integrand (right-hand side) of the equation which determines the radial (y) dependence of the scalar quantity \(\Pi\) |
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\) |
CComputeBondiIntegrand< Tags::RegularIntegrand< Tags::KleinGordonPi > > | Computes the regular part of the integrand (right-hand side) of the equation which determines the radial (y) dependence of the scalar quantity \(\Pi\) |
CComputeKleinGordonSource | Computes Tags::KleinGordonSource<Tag> for the tags evolved by Klein-Gordon Cce |
CComputeKleinGordonSource< Tags::BondiBeta > | Computes the Klein-Gordon source of the Bondi \(\beta\) |
CComputeKleinGordonSource< Tags::BondiH > | Computes the Klein-Gordon source of the Bondi \(H\) |
CComputeKleinGordonSource< Tags::BondiQ > | Computes the Klein-Gordon source of the Bondi \(Q\) |
CComputeKleinGordonSource< Tags::BondiU > | Computes the Klein-Gordon source of the Bondi \(U\) |
CComputeKleinGordonSource< Tags::BondiW > | Computes the Klein-Gordon source of the Bondi \(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 |
CGaugeAdjustedBoundaryValue< Tags::KleinGordonPi > | Computes the evolution gauge quantity \(\hat \Pi\) for the scalar field 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 |
CInnerBoundaryWeyl | Compute the Weyl scalar \(\Psi_0\) and its radial derivative \(\partial_\lambda \Psi_0\) on the inner boundary of CCE domain. The quantities are in the Cauchy coordinates |
CKleinGordonCharacteristicEvolution | The component for handling the CCE evolution for the Klein-Gordon system coupled with General Relativity |
CKleinGordonH5WorldtubeBoundary | Component that supplies scalar-tensor worldtube boundary data |
CKleinGordonSystem | Performing Cauchy characteristic evolution and Cauchy characteristic matching for Einstein-Klein-Gordon system |
CKleinGordonWorldtubeDataManager | |
CKleinGordonWorldtubeH5BufferUpdater | A WorldtubeBufferUpdater specialized to the Klein-Gordon input worldtube H5 file produced by the SpEC format. We assume the scalar field is real-valued |
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 | |
Cmock_klein_gordon_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 | |
CTransformBondiJToCauchyCoords | Transform Tags::BondiJ from the partially flat coordinates to the Cauchy coordinates |
CVolumeWeyl< Tags::Psi0 > | Compute the Weyl scalar \(\Psi_0\) in the volume according to a standard set of Newman-Penrose vectors |
CVolumeWeyl< Tags::Psi0Match > | Compute the Weyl scalar \(\Psi_0\) in the volume for the purpose of CCM, the quantity is in the Cauchy coordinates |
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. BoundaryTags is a tmpl::list of tags on the worldtube boundary |
►NCcz4 | Items related to evolving the first-order CCZ4 system |
►NOptionTags | Input option tags for the CCZ4 evolution system |
CGroup | |
►NTags | Tags for the CCZ4 formulation of Einstein equations |
CATilde | The trace-free part of the extrinsic curvature |
CATildeMinusOneThirdConformalMetricTimesTraceATilde | The CCZ4 temporary expression \(\tilde{A}_{ij} - \frac{1}{3} \tilde{\gamma}_{ij} tr \tilde{A}\) |
CChristoffelSecondKind | The spatial christoffel symbols of the second kind |
CConformalChristoffelSecondKind | The conformal spatial christoffel symbols of the second kind |
CConformalFactor | The conformal factor that rescales the spatial metric |
CConformalFactorSquared | The square of the conformal factor that rescales the spatial metric |
CConformalMetricTimesFieldB | The CCZ4 temporary expression \(\tilde{\gamma}_{ki} B_j{}^k\) |
CConformalMetricTimesTraceATilde | The CCZ4 temporary expression \(\tilde{\gamma}_{ij} tr \tilde{A}\) |
CContractedConformalChristoffelSecondKind | The contraction of the conformal spatial Christoffel symbols of the second kind |
CContractedFieldB | The CCZ4 temporary expression \(B_k{}^k\) |
CDerivConformalChristoffelSecondKind | The spatial derivative of the conformal spatial christoffel symbols of the second kind |
CDerivContractedConformalChristoffelSecondKind | The spatial derivative of the contraction of the conformal spatial Christoffel symbols of the second kind |
CDivergenceLapse | The divergence of the lapse |
CFieldA | Auxiliary variable which is analytically the spatial derivative of the natural log of the lapse |
CFieldB | Auxiliary variable which is analytically the spatial derivative of the shift |
CFieldD | Auxiliary variable which is analytically half the spatial derivative of the conformal spatial metric |
CFieldDUp | Identity which is analytically negative one half the spatial derivative of the inverse conformal spatial metric |
CFieldDUpTimesATilde | The CCZ4 temporary expression \(D_k{}^{nm} \tilde{A}_{nm}\) |
CFieldP | Auxiliary variable which is analytically the spatial derivative of the natural log of the conformal factor |
CGammaHat | The CCZ4 evolved variable \(\hat{\Gamma}^i\) |
CGammaHatMinusContractedConformalChristoffel | The CCZ4 temporary expression \(\hat{\Gamma}^i - \tilde{\Gamma}^i\) |
CGradGradLapse | The gradient of the gradient of the lapse |
CGradSpatialZ4Constraint | The gradient of the spatial part of the Z4 constraint |
CInverseConformalMetricTimesDerivATilde | The CCZ4 temporary expression \(\tilde{\gamma}^{nm} \partial_k \tilde{A}_{nm}\) |
CInverseTauTimesConformalMetric | The CCZ4 temporary expression \(\tau^{-1} \tilde{\gamma}_{ij}\) |
CKMinus2ThetaC | The CCZ4 temporary expression \(K - 2 \Theta c\) |
CKMinusK0Minus2ThetaC | The CCZ4 temporary expression \(K - K_0 - 2 \Theta c\) |
CLapseTimesATilde | The CCZ4 temporary expression \(\alpha \tilde{A}_{ij}\) |
CLapseTimesDerivATilde | The CCZ4 temporary expression \(\alpha \partial_k \tilde{A}_{ij}\) |
CLapseTimesFieldA | The CCZ4 temporary expression \(\alpha A_k\) |
CLapseTimesRicciScalarPlus2DivergenceZ4Constraint | The CCZ4 temporary expression \(\alpha (R + 2 \nabla_k Z^k)\) |
CLapseTimesSlicingCondition | The CCZ4 temporary expression \(\alpha g(\alpha)\) |
CLogConformalFactor | The natural log of the conformal factor |
CLogLapse | The natural log of the lapse |
CRicci | The spatial Ricci tensor |
CRicciScalarPlusDivergenceZ4Constraint | The sum of the Ricci scalar and twice the divergence of the upper spatial Z4 constraint |
CShiftTimesDerivGammaHat | The CCZ4 temporary expression \(\beta^k \partial_k \hat{\Gamma}^i\) |
CSpatialZ4Constraint | The spatial part of the Z4 constraint |
CSpatialZ4ConstraintUp | The spatial part of the upper Z4 constraint |
CTraceATilde | The trace of the trace-free part of the extrinsic curvature |
CTimeDerivative | Compute the RHS of the first order CCZ4 formulation of Einstein's equations [60] |
►Ncontrol_system | Control systems and related functionality |
►NActions | All Actions related to the control system |
CInitialize | Initialize items related to the control system |
CInitializeMeasurements | Set up the element component for control-system measurements |
CLimitTimeStep | Limit the step size in a GTS evolution to prevent deadlocks from control system measurements |
CPrintCurrentMeasurement | Simple action that will print the control_system::Tags::CurrentNumberOfMeasurements for whatever control system it is run on |
►NControlErrors | All control errors that will be used in control systems |
CExpansion | Control error in the 3D CubicScale coordinate map |
CRotation | Control error in the 3D Rotation coordinate map |
CShape | Control error in the Shape coordinate map |
►CSize | Control error in the for the \(l=0\) component of the domain::CoordinateMaps::TimeDependent::Shape map |
►CDeltaRDriftOutwardOptions | |
CMaxAllowedRadialDistance | |
COutwardDriftTimescale | |
COutwardDriftVelocity | |
CInitialState | |
CMaxNumTimesForZeroCrossingPredictor | |
CSmoothAvgTimescaleFraction | |
CSmootherTuner | |
CTranslation | Control error in the 3D Translation coordinate map |
►Nmeasurements | |
►NTags | |
CNeutronStarCenter | DataBox tag for location of neutron star center (or more accurately, center of mass of the matter in the x>0 (label A) or x<0 (label B) region, in grid coordinates) |
►CBothHorizons | A control_system::protocols::Measurement that relies on two apparent horizons |
CFindHorizon | A control_system::protocols::Submeasurement that starts the interpolation to the interpolation target in order to find the apparent horizon given by the template parameter Horizon |
►CBothNSCenters | Measurement providing the location of the center of mass of the matter in the \(x>0\) and \(x<0\) regions (assumed to correspond to the center of mass of the two neutron stars in a BNS merger) |
CFindTwoCenters | |
►CCharSpeed | A control_system::protocols::Measurement that relies on one apparent horizon, the template parameter Object , and one excision surface |
CExcision | A control_system::protocols::Submeasurement that does an interpolation to the excision boundary for this Object from the elements |
CHorizon | A control_system::protocols::Submeasurement that starts the interpolation to the interpolation target in order to find the apparent horizon |
CPostReductionSendBNSStarCentersToControlSystem | Simple action called after reduction of the center of mass data |
►CSingleHorizon | A control_system::protocols::Measurement that relies on only one apparent horizon; the template parameter Horizon |
CSubmeasurement | A control_system::protocols::Submeasurement that starts the interpolation to the interpolation target in order to find the apparent horizon |
►Nmetafunctions | Metafunctions associated with the control systems |
Ccontrol_systems_with_measurement | Given a list of control systems, extract those using a given measurement |
Cevent_from_submeasurement | |
Cmeasurement | Extract the measurement alias from a control system struct |
Cmeasurements | Given a list of control systems, obtain a list of distinct control system measurement structs used by them |
Csubmeasurements | Given a measurement, obtain a list of its submeasurements (i.e., Measurement::submeasurements ) |
►NOptionTags | All option tags related to the control system |
CControlSystemGroup | Options group for all control system options |
CControlSystemInputs | Option tag for each individual control system. The name of this option is the name of the ControlSystem struct it is templated on. This way all control systems will have a unique name |
CMeasurementsPerUpdate | Option tag that determines how many measurements will occur per control system update |
CVerbosity | Verbosity tag for printing diagnostics about the control system algorithm. This does not control when data is written to disk |
CWriteDataToDisk | Option tag on whether to write data to disk |
►Nprotocols | Protocols for control systems |
►CControlError | Definition of a control error |
Ctest | |
►CControlSystem | Definition of a control system |
►Ctest | |
Ccheck_process_measurement_argument_tags | |
►CMeasurement | Definition of a measurement for the control systems |
Ctest | |
►CSubmeasurement | Definition of a portion of a measurement for the control systems |
Ctest | |
►NQueueTags | All tags that will be used in the LinkedMessageQueue's within control systems |
CCenter | Holds the centers of each horizon from measurements as DataVectors |
CExcisionSurface | Holds a full strahlkorper from measurements for the excision surface |
CHorizon | Holds a full strahlkorper from measurements that represents a horizon |
CInverseSpatialMetricOnExcisionSurface | Holds the inverse spatial metric on the ExcisionSurface |
CLapseOnExcisionSurface | Holds the lapse on the ExcisionSurface |
CShiftyQuantity | Holds a quantity that's similar to the shift, but isn't the shift, on the ExcisionSurface |
CSizeExcisionQuantities | A queue tag that holds a TaggedTuple of all quantities needed for the excision measurement of size control |
CSizeHorizonQuantities | A queue tag that holds a TaggedTuple of all quantities needed for the horizon measurement of size control |
CSpatialMetricOnExcisionSurface | Holds the spatial metric on the ExcisionSurface |
►Nsize | Classes and functions used in implementation of size control |
►NStates | |
CAhSpeed | |
CDeltaR | |
CDeltaRDriftOutward | |
CInitial | |
CControlErrorArgs | Packages some of the inputs to the State::control_error, so that State::control_error doesn't need a large number of arguments |
CCrossingTimeInfo | Holds information about crossing times, as computed by ZeroCrossingPredictors |
CErrorDiagnostics | A simple struct to hold diagnostic information about computing the size control error |
CInfo | Holds information that is saved between calls of SizeControl |
Cis_size | |
Cis_size< Systems::Size< Label, DerivOrder > > | |
CState | Represents a 'state' of the size control system |
CStateHistory | A struct for holding a history of control errors for each state in the control_system::Systems::Size control system |
CStateUpdateArgs | Packages some of the inputs to the State::update, so that State::update doesn't need a large number of arguments |
►NSystems | All control systems |
►CExpansion | Controls the 3D CubicScale map |
CMeasurementQueue | |
Cprocess_measurement | |
►CRotation | Controls the 3D Rotation map |
CMeasurementQueue | |
Cprocess_measurement | |
►CShape | Controls the Shape map |
CMeasurementQueue | |
Cprocess_measurement | |
►CSize | Controls the \(l=0\) component of the Shape map |
CMeasurementQueue | |
Cprocess_measurement | |
►CTranslation | Controls the 3D Translation map |
CMeasurementQueue | |
Cprocess_measurement | |
►NTags | All DataBox tags related to the control system |
CAverager | DataBox tag for the averager |
CControlError | DataBox tag for the control error |
CController | DataBox tag for the controller |
CCurrentNumberOfMeasurements | DataBox tag that keeps track of which measurement we are on |
CFunctionsOfTimeInitialize | The FunctionsOfTime initialized from a DomainCreator, initial time, and control system OptionHolders |
CFutureMeasurements | Measurement times for a set of control systems sharing a measurement |
►CIsActiveMap | Tag that holds a map between control system name and whether that control system is active. Can be used in the GlobalCache |
Csystem | |
CMeasurementsPerUpdate | Tag that determines how many measurements will occur per control system update. This will usually be stored in the global cache |
CMeasurementTimescales | The measurement timescales associated with domain::Tags::FunctionsOfTime |
CObserveCenters | DataBox tag for writing the centers of the horizons to disk |
CSystemToCombinedNames | Tag meant to be stored in the GlobalCache that stores a map between names of control systems and the "combined" name that that control system is part of |
CTimescaleTuner | DataBox tag for the timescale tuner |
CUpdateAggregators | Map between "combined" names and the control_system::UpdateAggregator s that go with each |
CVerbosity | DataBox tag that holds the verbosity used to print info about the control system algorithm |
CWriteDataToDisk | DataBox tag for writing control system data to disk |
►NTestHelpers | |
CControlError | |
CExampleControlError | [Measurement] |
►CExampleControlSystem | [ControlError] |
CExampleSubmeasurementQueueTag | |
CMeasurementQueue | |
Cprocess_measurement | |
CExampleMeasurement | [Submeasurement] |
CExampleSubmeasurement | [Submeasurement] |
CFakeCreator | |
CMeasurement | |
CMeasurementResultTag | |
CMeasurementResultTime | |
CMockControlComponent | |
CMockElementComponent | |
►CMockMetavars | |
Cfactory_creation | |
CMockObserverWriter | |
CSomeControlSystemUpdater | |
CSomeEvent | |
CSomeOtherTagOnElement | |
CSomeOtherTagOnElementCompute | |
CSomeTagOnElement | |
CSubmeasurement | |
►CSystem | |
Cprocess_measurement | |
CSystemHelper | Helper struct for testing basic control systems |
CTestEvent | |
CAggregateUpdate | Simple action that updates the appropriate UpdateAggregator for the templated ControlSystem |
CBNSEvent | An Event that computes the center of mass for \(x > 0\) and \(x < 0\) where \(x\) is the in the Frame::Grid |
CFutureMeasurements | Class for computing the upcoming measurement times for a control system measurement |
►COptionHolder | Holds all options for a single control system |
CAverager | |
CControlError | |
CController | |
CIsActive | |
CTimescaleTuner | |
CRunCallbacks | Apply the process_measurement struct of each of the ControlSystems to the result of the Submeasurement |
CTrigger | Trigger for control system measurements |
CUpdateAggregator | A class for collecting and storing information related to updating functions of time and measurement timescales |
CUpdateControlSystem | Functor for updating control systems when they are ready |
CUpdateMultipleFunctionsOfTime | Updates several FunctionOfTimes in the global cache at once. Intended to be used in Parallel::mutate |
CUpdateSingleFunctionOfTime | Updates a FunctionOfTime in the global cache. Intended to be used in Parallel::mutate |
►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 or termination 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 |
►NActions | |
CCalculateGrVars | Action that initializes or updates items related to the spacetime background of the CurvedScalarWave system |
►NAnalyticData | Holds classes implementing analytic data for the CurvedScalarWave system |
►CPureSphericalHarmonic | Analytic initial data for a pure spherical harmonic in three dimensions |
CMode | |
CRadius | |
CWidth | |
►NBoundaryConditions | Boundary conditions for the curved scalar wave system |
►CAnalyticConstant | A BoundaryCondition that imposes the scalar to be constant at the outer boundary |
CAmplitude | |
CBoundaryCondition | The base class off of which all boundary conditions must inherit |
CConstraintPreservingSphericalRadiation | Implements constraint-preserving boundary conditions with a second order Bayliss-Turkel radiation boundary condition |
CDemandOutgoingCharSpeeds | A BoundaryCondition that only verifies that all characteristic speeds are directed out of the domain; no boundary data is altered by this boundary condition |
CWorldtube | Sets boundary conditions for the elements abutting the worldtube using a combination of constraint-preserving boundary conditions and the local solution evolved inside the worldtube |
►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 |
►NInitialization | |
CInitializeConstraintDampingGammas | Mutator meant to be used with Initialization::Actions::AddSimpleTags to initialize the constraint damping parameters of the CurvedScalarWave system |
CInitializeEvolvedVariables | Analytic initial data for scalar waves in curved spacetime |
►NOptionTags | |
CBackgroundSpacetime | |
CBackgroundSpacetimeGroup | |
►NTags | Tags for the curved scalar wave system |
CBackgroundSpacetime | The background spacetime on which the scalar wave propagates |
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 |
CPhi | Auxiliary variable which is analytically the spatial derivative of the scalar field |
CPi | The conjugate momentum of the scalar field |
CPsi | The scalar field |
CPsiSquared | The square of the scalar field \(\Psi\) |
CPsiSquaredCompute | Compute tag that calculates the square of the scalar field \(\Psi\) |
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 | |
►NWorldtube | The set of utilities for performing CurvedScalarWave evolution with a worldtube excision scheme |
►NActions | |
CChangeSlabSize | Waits for the data from all neighboring elements and changes the slab size if a change in the global time step is detected |
CIterateAccelerationTerms | Computes the next iteration of the acceleration due to scalar self force from the current iteration of the regular field |
CIteratePunctureField | Computes an updated iteration of the puncture field given the current acceleration of the charge sent by the worldtube singleton |
CObserveWorldtubeSolution | When Tags::ObserveCoefficientsTrigger is triggered, write the coefficients of the Taylor expansion of the regular field to file |
CReceiveElementData | Adds up the spherical harmonic projections from the different elements abutting the worldtube |
CReceiveWorldtubeData | Checks if the regular field has been received from the worldtube and computes the retarded field for boundary conditions |
CSendToElements | Sends the regular field coefficients to each element abutting the worldtube |
CSendToWorldtube | Projects the regular field \(\Psi^R\) and its time derivative \(\partial_t \Psi^R\) onto real spherical harmonics and sends the result to the worldtube |
►NInitialization | |
CInitializeConstraintDampingGammas | Initializes the constraint damping parameters \(\gamma_1\) and \(\gamma_2\) |
CInitializeCurrentIteration | Sets the initial value of `CurrentIteration to 0 |
CInitializeElementFacesGridCoordinates | Initializes a map of the grid coordinates centered on the worldtube of all faces that abut the worldtube with corresponding ElementIds |
CInitializeEvolvedVariables | Initializes the time stepper and evolved variables used by the worldtube system. Also sets Tags::CurrentIteration to 0 |
►NOptionTags | Option tags for the worldtube |
CCharge | The value of the scalar charge in units of the black hole mass M |
CExcisionSphere | Name of the excision sphere designated to act as a worldtube |
CExpansionOrder | The internal expansion order of the worldtube solution |
CObserveCoefficientsTrigger | Triggers at which to write the coefficients of the worldtube's internal Taylor series to file |
►CSelfForceOptions | Options for the scalar self-force. Select None for a purely geodesic evolution |
CIterations | |
CMass | |
CWorldtube | Options for the worldtube |
►NTags | Tags related to the worldtube |
CBackgroundQuantities | A tuple of Tensors evaluated at the charge depending only the background and the particle's position and velocity. These values are effectively cached between different iterations of the worldtube scheme |
CBackgroundQuantitiesCompute | |
CCharge | The value of the scalar charge |
CCheckInputFile | Dummy tag that throws an error if the input file does not describe a circular orbit |
CCurrentIteration | The current number of iterations that has been applied to the acceleration of the particle |
CdtPsi0 | Holds the time derivative of Psi0 which is used as a reduction variable |
CElementFacesGridCoordinates | A map that holds the grid coordinates centered on the worldtube of all element faces abutting the worldtube with the corresponding ElementIds |
CEvolvedParticlePositionVelocityCompute | The position and velocity of the scalar charge particle orbiting a central black hole given in inertial coordinates. This compute tag is meant to be used by the worldtube singleton which evolves the position and velocity according to an ODE along with the DG evolution |
CEvolvedPosition | The position of the scalar charge evolved by the worldtube singleton. This tag is meant to be used by the worldtube singleton to evolve the orbit |
CEvolvedVelocity | The velocity of the scalar charge evolved by the worldtube singleton. This tag is meant to be used by the worldtube singleton to evolve the orbit |
CExcisionSphere | The excision sphere corresponding to the worldtube |
CExpansionOrder | The internal expansion order of the worldtube solution |
CFaceCoordinates | An optional that holds the coordinates of an element face abutting the worldtube excision sphere. If the element does not abut the worldtube, this holds std::nullopt. This tag should be in the databox of element chares. The available frames are Grid and Inertial. The Centered template tag can be turned on to center the coordinates around the position of the scalar charge |
CFaceCoordinatesCompute | |
CFaceQuantities | The value of the scalar field and its time derivative on element faces forming the worldtube boundary, as well as the Euclidean area element of the face |
CFaceQuantitiesCompute | |
CGeodesicAcceleration | Computes the coordinate geodesic acceleration of the particle in the inertial frame in Kerr-Schild coordinates |
CGeodesicAccelerationCompute | |
CInitialPositionAndVelocity | The initial position and velocity of the scalar charge in inertial coordinates |
CIteratedPunctureField | Holds the current iteration of the puncture field computed with the current iteration of the acceleration which includes the scalar self-force. It is computed in Actions::IteratePunctureField |
CMass | The mass of the scalar charge. Only has a value if the scalar self force is applied |
CMaxIterations | The maximum number of iterations that will be applied to the acceleration of the particle |
CObserveCoefficientsTrigger | Triggers at which to write the coefficients of the worldtube's internal Taylor series to file |
CParticlePositionVelocity | The position and velocity of the scalar charge particle orbiting a central black hole given in inertial coordinates. This compute tag is meant to be used by the elements |
CParticlePositionVelocityCompute | |
CPsi0 | Holds the constant coefficient of the regular field inside the worldtube |
CPsiWorldtube | The scalar field inside the worldtube |
CPunctureField | |
CPunctureFieldCompute | |
CRegularFieldInbox | Inbox of the element chares that contains the coefficients of a Taylor Series of the regular field \(\Psi^R\) as well as its time derivative. The elements may evaluate the coefficients at their inertial coordinates |
CSelfForceInbox | Inbox of the element chares that contains the current iteration of the acceleration of the particle |
CSphericalHarmonicsInbox | Inbox of the worldtube singleton chare which receives quantities projected onto spherical harmonics |
CTimeDilationFactor | The coordinate time dilation factor of the scalar charge, i.e. the 0th component of its 4-velocity |
CWorldtubeSolution | The solution inside the worldtube, evaluated at the face coordinates of an abutting element. This tag is used to provide boundary conditions to the element in CurvedScalarWave::BoundaryConditions::Worldtube |
CRegistration | |
CUpdateAcceleration | Computes the final acceleration of the particle at this time step |
►CWorldtubeSingleton | The singleton component that represents the worldtube |
Cworldtube_system | |
CCharacteristicFieldsCompute | |
CCharacteristicSpeedsCompute | |
CEvolvedFieldsFromCharacteristicFieldsCompute | |
CSystem | |
CTimeDerivative | Compute the time derivative of the evolved variables of the first-order scalar wave system on a curved background |
Ncylindrical_endcap_helpers | Functions used in more than one cylindrical_endcap map |
►Ndb | Namespace for DataBox related things |
►Nprotocols | |
►CMutator | A DataBox mutator |
Ctest | |
►NTestHelpers | |
CExampleMutator | |
CExampleSimpleTag0 | |
CExampleSimpleTag1 | |
CExampleSimpleTag2 | |
COptionTag | |
CAccess | A class for retrieving items from a DataBox without needing to know all the tags in the box |
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::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 > > > | |
►Ndeadlock | Namespace for actions related to debugging deadlocks in communication |
CPrintElementInfo | Simple action that will print a variety of information on evolution DG elements |
►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 | |
►CObserveFields< VolumeDim, tmpl::list< Tensors... >, tmpl::list< NonTensorComputeTags... >, ArraySectionIdTag > | 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 | |
►CObserveTimeStepVolume | Observe the time step in the volume |
CCoordinatesFloatingPointType | The floating point type/precision with which to write the coordinates to disk |
CFloatingPointType | The floating point type/precision with which to write the data to disk |
CSubfileName | The name of the subfile inside the HDF5 file |
►NOptionTags | |
CDiscontinuousGalerkinGroup | Group holding options for controlling the DG discretization |
CFormulation | |
►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 | |
►Ndo_implicit_step_helpers | |
►CNonautonomousSector | |
Cinitial_guess | |
►CSolveAttempt | |
Csource | |
CNonautonomousSystem | |
►CSector | |
Cinitial_guess | |
►CSolveAttempt | |
Csource | |
CSystem | |
CVar1 | |
CVar2 | |
►Ndomain | Holds entities related to the computational domain |
►NActions | |
CCheckFunctionsOfTimeAreReady | Check that functions of time are up-to-date |
►NBoundaryConditions | Domain support for applying boundary conditions |
CBoundaryCondition | Base class from which all system-specific base classes must inherit |
CMarkAsNone | |
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 |
►NShapeMapTransitionFunctions | |
CShapeMapTransitionFunction | Abstract base class for the transition functions used by the domain::CoordinateMaps::TimeDependent::Shape map |
CSphereTransition | A transition function that falls off as \(f(r) = g(r) / r\) where \(g(r) = ar + b\) |
CWedge | A transition function that falls off linearly from an inner surface of a wedge to an outer surface of a wedge. Meant to be used in domain::CoordinateMaps::Wedge blocks |
►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 | Time-dependent spatial rotation in two or three dimensions |
CRotScaleTrans | RotScaleTrans map which applies a combination of rotation, expansion, and translation based on which maps are supplied |
CShape | Distorts a distribution of points radially according to a spherical harmonic expansion while preserving angles |
CSphericalCompression | Time-dependent compression of a finite 3D spherical volume |
CTranslation | Translation map defined by \(\vec{x} = \vec{\xi}+F(r)\vec{T}(t)\) where \(F(r)\) takes on different forms based on which constructor is used |
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 |
CComposition | A composition of coordinate maps at runtime |
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\) |
CInterval | Maps \(\xi\) in the 1D interval \([A, B]\) to \(x\) in the interval \([a, b]\) according to a domain::CoordinateMaps::Distribution |
CKerrHorizonConforming | Distorts cartesian coordinates \(x^i\) such that a coordinate sphere \(\delta_{ij}x^ix^j=C^2\) 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 |
CUniformCylindricalEndcap | Map from 3D unit right cylinder to a volume that connects portions of two spherical surfaces |
CUniformCylindricalFlatEndcap | Map from 3D unit right cylinder to a 3D volume that connects a portion of a spherical surface with a disk |
CUniformCylindricalSide | Map from 3D unit right cylindrical shell to a volume that connects portions of two spherical surfaces |
CWedge | Map from a square or cube to a wedge |
►Ncreators | Defines classes that create Domains |
►Nbco | Namespace used to hold things used in both the BinaryCompactObject and CylindricalBinaryCompactObject domain creators |
►CTimeDependentMapOptions | This holds all options related to the time dependent maps of the binary compact object domains |
►CExpansionMapOptions | Options for the expansion map. The outer boundary radius of the map is always set to the outer boundary of the Domain, so there is no option here to set the outer boundary radius |
CAsymptoticVelocityOuterBoundary | |
CDecayTimescaleOuterBoundaryVelocity | |
CInitialValues | |
CInitialTime | The initial time of the functions of time |
►CRotationMapOptions | |
CInitialAngularVelocity | |
►CTranslationMapOptions | Options for the Translation Map, the outer radius is always set to the outer boundary of the Domain, so there's no option needed for outer boundary |
CInitialValues | |
►Nsphere | |
►CTimeDependentMapOptions | This holds all options related to the time dependent maps of the domain::creators::Sphere domain creator |
►CExpansionMapOptions | |
CDecayTimescaleExpansion | |
CDecayTimescaleExpansionOuterBoundary | |
CInitialValues | |
CInitialValuesOuterBoundary | |
CInitialTime | The initial time of the functions of time |
►CRotationMapOptions | |
CDecayTimescaleRotation | |
CInitialValues | |
►CTranslationMapOptions | |
CInitialValues | |
►Ntime_dependence | Classes and functions for adding time dependence to a domain |
►CCubicScale | A linear or cubic radial scaling time dependence |
CAcceleration | The acceleration of the expansion factors |
CInitialExpansion | The initial values of the expansion factors |
CInitialTime | The initial time of the functions of time |
COuterBoundary | The outer boundary or pivot point of the domain::CoordinateMaps::TimeDependent::CubicScale map |
CUseLinearScaling | Whether to use linear scaling or cubic scaling |
CVelocity | The velocity of the expansion factors |
CNone | Make the mesh time independent so that it isn't moving |
►CRotationAboutZAxis | A spatially uniform rotation about the \(z\) axis: |
CInitialAngle | |
CInitialAngularAcceleration | |
CInitialAngularVelocity | The \(x\)-, \(y\)-, and \(z\)-velocity |
CInitialTime | The initial time of the function of time |
►CScalingAndZRotation | Cubic scaling, followed by uniform rotation about the \(z\) axis: |
CAcceleration | The acceleration of the expansion factors |
CAngularVelocity | The \(x\)-, \(y\)-, and \(z\)-velocity |
CInitialExpansion | The initial values of the expansion factors |
CInitialTime | The initial time of the function of time |
COuterBoundary | The outer boundary or pivot point of the domain::CoordinateMaps::TimeDependent::CubicScale map |
CUseLinearScaling | Whether to use linear scaling or cubic scaling |
CVelocity | The velocity of the expansion factors |
►CShape | A Shape whose inner surface conforms to a surface of constant Boyer-Lindquist radius, in Kerr-Schild coordinates as given by domain::CoordinateMaps::TimeDependent::Shape |
CCenter | Center for the Shape map |
CInitialTime | The initial time of the function of time |
CInnerRadius | The inner radius of the Shape map, the radius at which to begin applying the map |
CLMax | The max angular resolution l of the Shape |
CMass | The mass of the Kerr black hole |
COuterRadius | The outer radius of the Shape map, beyond which it is no longer applied |
CSpin | The dimensionless spin of the Kerr black hole |
►CSphericalCompression | A spherical compression about some center, as given by domain::CoordinateMaps::TimeDependent::SphericalCompression<false> |
CCenter | Center for the SphericalCompression map |
CInitialAcceleration | Initial radial acceleration for the function of time for the spherical compression |
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 |
►CUniformTranslation | A uniform translation in the \(x-, y-\) and \(z-\)direction |
CInitialTime | The initial time of the functions of time |
CVelocity | The \(x\)-, \(y\)-, and \(z\)-velocity |
►Ntime_dependent_options | |
►Nnames | Structs meant to be used as template parameters for the domain::creators::time_dependent_options::FromVolumeFile classes |
CExpansion | |
CRotation | |
CShapeSize | |
CTranslation | |
CFromVolumeFile | Read in FunctionOfTime coefficients from an H5 file and volume subfile |
CFromVolumeFile< names::Expansion > | |
CFromVolumeFile< names::Rotation > | |
CFromVolumeFile< names::ShapeSize< Object > > | |
►CKerrSchildFromBoyerLindquist | Mass and spin necessary for calculating the \( Y_{lm} \) coefficients of a Kerr horizon of certain Boyer-Lindquist radius for the shape map of the Sphere domain creator |
CMass | The mass of the Kerr black hole |
CSpin | The dimensionless spin of the Kerr black hole |
►CShapeMapOptions | Class to be used as an option for initializing shape map coefficients |
CInitialValues | |
CLMax | |
CSizeInitialValues | |
CTransitionEndsAtCube | |
CSpherical | Label for shape map options |
►CYlmsFromFile | |
CCheckFrame | |
CH5Filename | |
CMatchTime | |
CMatchTimeEpsilon | |
CSetL1CoefsToZero | |
CSubfileNames | |
►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 |
►CCartesianCubeAtXCoord | |
CXCoord | |
CEnvelope | |
CEnvelopeRadius | |
►CExcision | Options for an excision region in the domain |
CBoundaryCondition | |
CInitialGridPoints | |
CInitialRefinement | |
►CObject | Options for one of the two objects in the binary domain |
CExciseInterior | |
CInnerRadius | |
CInterior | |
COuterRadius | |
CUseLogarithmicMap | |
CXCoord | |
CObjectA | |
CObjectB | |
COpeningAngle | |
COuterBoundaryCondition | |
COuterRadius | |
COuterShell | |
CRadialDistributionEnvelope | |
CRadialDistributionOuterShell | |
CTimeDependentMaps | |
CUseEquiangularMap | |
►CBrick | Create a 3D Domain consisting of a single Block |
CBoundaryCondition | |
CInitialGridPoints | |
CInitialRefinement | |
CIsPeriodicIn | |
CLowerBound | |
►CLowerUpperBoundaryCondition | |
CLowerBC | |
CUpperBC | |
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 | |
CDistributionInZ | |
CInitialGridPoints | |
CInitialRefinement | |
CInnerRadius | |
CIsPeriodicInZ | |
CLowerZBound | |
CLowerZBoundaryCondition | |
CMantleBoundaryCondition | |
COuterRadius | |
CPartitioningInZ | |
CRadialDistribution | |
CRadialPartitioning | |
CUpperZBound | |
CUpperZBoundaryCondition | |
CUseEquiangularMap | |
►CCylindricalBinaryCompactObject | A general domain for two compact objects based on cylinders |
CBoundaryConditions | |
CCenterA | |
CCenterB | |
CIncludeInnerSphereA | |
CIncludeInnerSphereB | |
CIncludeOuterSphere | |
CInitialGridPoints | |
CInitialRefinement | |
CInnerBoundaryCondition | |
COuterBoundaryCondition | |
COuterRadius | |
CRadiusA | |
CRadiusB | |
CTimeDependentMaps | |
CUseEquiangularMap | |
►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 | |
CDistribution | |
CInitialGridPoints | |
CInitialRefinement | |
CIsPeriodicIn | |
CLowerBound | |
CLowerBoundaryCondition | |
CSingularity | |
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 | |
CTimeDependence | |
CUpperBound | |
CUpperBoundaryCondition | |
►CRotatedRectangles | Create a 2D Domain consisting of four rotated Blocks |
CBoundaryCondition | |
CInitialGridPoints | |
CInitialRefinement | |
CIsPeriodicIn | |
CLowerBound | |
CMidpoint | |
CUpperBound | |
►CSphere | A 3D cubed sphere |
CEquatorialCompression | |
►CEquatorialCompressionOptions | Options for the EquatorialCompression map |
CAspectRatio | |
CIndexPolarAxis | |
CInitialGridPoints | |
CInitialRefinement | |
CInnerRadius | |
CInterior | |
COuterBoundaryCondition | |
COuterRadius | |
CRadialDistribution | |
CRadialPartitioning | |
CTimeDependentMaps | |
CUseEquiangularMap | |
CWhichWedges | |
►NFunctionsOfTime | Contains functions of time to support the dual frame system |
►NFunctionOfTimeHelpers | |
►CThreadsafeList | A list of time intervals that allows safe access to existing elements even during modification |
CIntervalInfo | |
Citerator | |
►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 |
CIntegratedFunctionOfTime | A function that is integrated manually |
CPiecewisePolynomial | A function that has a piecewise-constant MaxDeriv th derivative |
CQuaternionFunctionOfTime | A FunctionOfTime that stores quaternions for the rotation map |
CSettleToConstant | Given an initial function of time, transitions the map to a constant-in-time value |
CSettleToConstantQuaternion | Given an initial function of time that is a unit quaternion, transitions to a constant-in-time unit quaternion |
NInitialization | |
►NOptionTags | |
CDomainCreator | The input file tag for the DomainCreator to use |
►CElementDistribution | |
CRoundRobin | |
CRadiallyCompressedCoordinates | |
►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 |
CDetJacobian | The determinant of the Jacobian from the source frame to the target frame |
CDetSurfaceJacobian | The determinant of the induced Jacobian on a surface |
CDetTimesInvJacobian | The inverse Jacobian times the determinant of the Jacobian |
CDirection | Direction to an interface |
CDivMeshVelocity | The divergence of the mesh velocity |
CDomain | The Domain |
CElement | The Element associated with the DataBox |
CElementDistribution | Tag that holds method for how to distribute the elements on the given resources |
CElementMap | The coordinate map from the ElementLogical frame to the TargetFrame |
CElementToInertialInverseJacobian | Computes the Logical to Inertial inverse Jacobian from CoordinatesVelocityAndJacobians |
CExternalBoundaryConditions | |
CFaceNormalVector | The normalized face normal vector, i.e. the FaceNormal raised with the spatial metric |
CFaces | The Tag on element faces |
CFlatLogicalMetric | The flat metric in element-logical coordinates |
CFlatLogicalMetricCompute | Compute the flat metric in element-logical coordinates from the inverse Jacobian |
CFunctionsOfTime | Tag to retrieve the FunctionsOfTime from the GlobalCache |
CFunctionsOfTimeInitialize | The FunctionsOfTime initialized from a DomainCreator |
CGridToInertialInverseJacobian | Computes the Grid to Inertial inverse Jacobian from CoordinatesVelocityAndJacobians . If the mesh is not moving, requesting this tag will throw an error because the Jacobian is just the identity |
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 |
CJacobianDiagnostic | A diagnostic comparing the analytic and numerical Jacobians for a map. See domain::jacobian_diagnostic for details |
CJacobianDiagnosticCompute | Computes the Jacobian diagnostic, which compares the analytic Jacobian (provided by some coordinate map) to a numerical Jacobian computed using numerical partial derivatives. The coordinates must be in the target frame of the map. See domain::jacobian_diagnostic for details of the calculation |
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 | |
CNeighborMesh | Holds the mesh of each neighboring element |
CObjectCenter | The grid frame center of the given object |
CRadiallyCompressedCoordinates | Coordinates suitable for visualizing large radii by compressing them logarithmically or inversely |
CRadiallyCompressedCoordinatesCompute | |
CRadiallyCompressedCoordinatesOptions | Options for radially compressed coordinates, or std::nullopt if none were specified in the input file |
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, where Element s are distributed across CPUs |
CCheckFunctionsOfTimeAreReadyPostprocessor | Dense-output postprocessor to check that functions of time are up-to-date |
CCoordinateMap | A coordinate map or composition of coordinate maps |
CCoordinateMapBase | Abstract base class for CoordinateMap |
CExpandOverBlocks | Produce a std::vector<T> over all blocks of the domain |
Cmake_faces_tag | Wrap Tag in domain::Tags::Faces , unless Tag is in the VolumeTags list |
Cobject_list | Similar to a tmpl::list but for ObjectLabel s |
►CRadiallyCompressedCoordinatesOptions | Options for radially compressed coordinates |
CCompression | |
CInnerRadius | |
COuterRadius | |
►NElasticity | Items related to solving elasticity problems |
►NActions | Actions related to solving Elasticity systems |
CInitializeConstitutiveRelation | Initialize the constitutive relation describing properties of the elastic material |
►NBoundaryConditions | |
►CLaserBeam | A laser beam with Gaussian profile normally incident to the surface |
CBeamWidth | |
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 | |
►NOptionTags | |
CConstitutiveRelation | |
CConstitutiveRelationPerBlock | |
►NSolutions | |
►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 |
CConstitutiveRelationPerBlock | A constitutive relation in every block of the domain |
CConstitutiveRelationPerBlockBase | A constitutive relation in every block of the domain |
CConstitutiveRelationReference | References the constitutive relation for the element's block, which is stored in the global cache |
CDisplacement | The material displacement field \(\boldsymbol{u}(x)\) |
CMaterialBlockGroups | Stores the names of the block groups that split the domain into layers with different material properties. Useful to observe quantities in each layer |
CMaterialLayerName | The name of the material layer (name of a block group with some material) |
CMinusStress | Minus the Stress , i.e. \(-T^{ij}\). 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 |
CStress | The symmetric stress, i.e. \(T^{ij}\), describing pressure within the elastic material |
CStressCompute | |
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 |
►Nelliptic | Items related to composing nonlinear elliptic solver executables |
►NActions | |
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 | Place the analytic solution of the system fields in the DataBox |
CRunEventsAndTriggers | Run the events and triggers |
►Namr | |
►NActions | Actions to control the elliptic AMR algorithm |
CIncrementIterationId | Increment the AMR iteration ID and determine convergence |
CInitialize | Initializes items for the elliptic AMR algorithm projector |
CStopAmr | Stop the algorithm if it has converged |
►Nanalytic_data | Items related to pointwise analytic data for elliptic solves, such as initial guesses, analytic solutions, and background quantities in elliptic PDEs |
CAnalyticSolution | Subclasses represent analytic solutions of elliptic systems |
CBackground | Subclasses supply variable-independent background data for an elliptic solve |
CInitialGuess | Subclasses represent an initial guess for an elliptic solve |
►NBoundaryConditions | Boundary conditions for elliptic systems |
►CAnalyticSolution< System, Dim, tmpl::list< FieldTags... >, tmpl::list< FluxTags... > > | Impose the analytic solution on the boundary. Works only if an analytic solution exists |
CSolution | |
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 |
CDgOperator | Apply the DG operator to the PrimalFieldsTag and write the result to the OperatorAppliedToFieldsTag |
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 | |
CFormulation | |
CMassive | |
CPenaltyParameter | |
CQuadrature | |
►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 |
CFormulation | The DG formulation to use (strong or weak) |
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 |
CPenaltyFactor | The penalty factor in internal penalty fluxes |
CPenaltyParameter | The prefactor to the penalty term of the numerical flux |
CQuadrature | The quadrature method used for the elliptic DG discretization |
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 |
CProjectGeometry | |
►NOptionTags | Option tags for nonlinear elliptic solver executables |
CBackground | |
CBoundaryConditionType | |
CGmresGroup | |
CInitialGuess | |
CLinearSolverGroup | |
CMultigridGroup | |
CNewtonRaphsonGroup | |
CNonlinearSolverGroup | |
CSchwarzSmootherGroup | |
►Nprotocols | Protocols related to elliptic systems |
►CFirstOrderSystem | A system of elliptic equations in first-order "flux" formulation |
Ctest | |
►Nsubdomain_preconditioners | Linear solvers that approximately invert the elliptic::dg::subdomain_operator::SubdomainOperator to make the Schwarz subdomain solver converge faster |
►NRegistrars | |
CMinusLaplacian | |
►CMinusLaplacian | Approximate the subdomain operator with a flat-space Laplacian for every tensor component separately |
CBoundaryConditions | |
CSolverOptionTag | |
►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 |
CBoundaryFieldsCompute | The FieldsTag on external boundaries |
CBoundaryFluxesCompute | The Tags::NormalDotFlux<FieldsTag> on external boundaries |
CInitialGuess | The initial guess for the elliptic solve |
►NTriggers | Triggers for elliptic executables |
►CEveryNIterations | Trigger every N iterations of the solver identifid by the Label , after a given offset |
CN | |
COffset | |
CHasConverged | Trigger when the solver identified by the Label has converged |
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 |
►CSolver | A complete nonlinear elliptic solver stack. Use to compose an executable |
CRandomizeInitialGuess | |
►NEqualWithinRoundoffImpls | Specializations of EqualWithinRoundoffImpl for custom types, to add support for the equal_within_roundoff function |
CEqualWithinRoundoffImpl | Specialize this class to add support for the equal_within_roundoff function |
CEqualWithinRoundoffImpl< Lhs, Rhs, Requires< tt::is_iterable_v< Lhs > and not tt::is_maplike_v< Lhs > and tt::is_iterable_v< Rhs > and not tt::is_maplike_v< Rhs > > > | |
CEqualWithinRoundoffImpl< Variables< LhsTagList >, Variables< RhsTagList > > | |
►NEquationsOfState | Contains all equations of state, including base class |
►CBarotropic2D | A 2D equation of state representing a barotropic fluid |
CUnderlyingEos | |
►CBarotropic3D | A 3D equation of state representing a barotropic fluid |
CUnderlyingEos | |
►CDarkEnergyFluid | Equation of state for a dark energy fluid |
CParameterW | |
►CEnthalpy | An equation of state given by parametrized enthalpy |
CCosCoefficients | |
CMaximumDensity | |
CMinimumDensity | |
CPolynomialCoefficients | |
CReferenceDensity | |
CSinCoefficients | |
CStitchedLowDensityEoS | |
CTransitionDeltaEpsilon | |
CTrigScaling | |
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 |
CEquationOfState< IsRelativistic, 3 > | Base class for equations of state which need three independent thermodynamic variables in order to determine the pressure |
►CEquilibrium3D | A 3D equation of state representing a fluid in compositional equalibrium |
CUnderlyingEos | |
Cget_eos_base_impl | |
Cget_eos_base_impl< EquationsOfState::EquationOfState< IsRelativistic, ThermodynamicDim > > | |
►CHybridEos | Hybrid equation of state combining a barotropic EOS for cold (zero-temperature) part with a simple thermal part |
CColdEos | |
CThermalAdiabaticIndex | |
►CIdealFluid | Equation of state for an ideal fluid |
CAdiabaticIndex | |
►CPiecewisePolytropicFluid | Equation of state for a piecewise polytropic fluid |
CPiecewisePolytropicTransitionDensity | The density demarcating the high and low density descriptions of the fluid |
CPolytropicConstantLow | The constant \(K\) scaling the low density material \(p=K\rho^{\Gamma}\) |
CPolytropicExponentHigh | The exponent \(\Gamma\), scaling the high density material \(p=K\rho^{\Gamma}\) |
CPolytropicExponentLow | The exponent \(\Gamma\), scaling the low density material \(p=K\rho^{\Gamma}\) |
►CPolytropicFluid | Equation of state for a polytropic fluid |
CPolytropicConstant | |
CPolytropicExponent | |
►CSpectral | A spectral equation of state |
CCoefficients | |
CReferenceDensity | |
CReferencePressure | |
CUpperDensity | |
►CTabulated3D | Nuclear matter equation of state in tabulated form |
CTableFilename | |
CTableSubFilename | |
►NEvents | |
►NTags | |
CObserverCoordinates | The coordinates used for observation |
CObserverCoordinatesCompute | Sets the ObserverCoordinates to domain::Tags::Coordinates |
CObserverDetInvJacobian | The determinant of the inverse Jacobian used for observation |
CObserverDetInvJacobianCompute | Sets the ObserverDetInvJacobian to domain::Tags::DetInvJacobian |
CObserverInverseJacobian | The inverse Jacobian used for observation |
CObserverInverseJacobianCompute | Sets the ObserverInverseJacobian to domain::Tags::InverseJacobian |
CObserverJacobian | The Jacobian used for observation |
CObserverJacobianCompute | Sets the ObserverJacobian to domain::Tags::Jacobian |
CObserverMesh | The mesh for the observation computational grid. For hybrid methods like DG-FD the observer mesh changes throughout the evolution |
CObserverMeshCompute | Sets the ObserverMesh to domain::Tags::Mesh |
CObserverMeshVelocity | The mesh velocity used for observations |
CObserverMeshVelocityCompute | Sets the ObserverMeshVelocty to domain::Tags::MeshVelocty |
►CChangeSlabSize | Trigger a slab size change |
CDelayChange | |
CStepChoosers | |
CCompletion | Sets the termination flag for the code to exit |
►CErrorIfDataTooBig | ERROR if tensors get too big |
CThreshold | |
CVariablesToCheck | |
►CMonitorMemory | Event run on the DgElementArray that will monitor the memory usage of parallel components in megabytes |
CComponentsToMonitor | |
►CObserveAdaptiveSteppingDiagnostics | Observe diagnostics about adaptive time-stepping |
CSubfileName | The name of the subfile inside the HDF5 file |
CObserveAdmIntegrals | Observe ADM integrals after the XCTS solve |
CObserveAtExtremum | Find the extremum of a Scalar<DataVector> over all elements, as well as the value of other functions at the location of that extremum |
►CObserveAtExtremum< tmpl::list< ObservableTensorTags... >, tmpl::list< NonTensorComputeTags... >, ArraySectionIdTag > | |
CSubfileName | The name of the subfile inside the HDF5 file |
CTensorsToObserve | The scalar to extremize, and other tensors to observe at extremum |
CObserveDataBox | Event that will collect the size in MBs used by each DataBox item on each parallel component |
CObserveNorms | Compute norms of tensors in the DataBox and write them to disk |
►CObserveNorms< tmpl::list< ObservableTensorTags... >, tmpl::list< NonTensorComputeTags... >, ArraySectionIdTag, OptionName > | |
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 |
CObservePerCore | |
CPrintTimeToTerminal | |
CSubfileName | The name of the subfile inside the HDF5 file |
►Nevolution | Functionality for evolving hyperbolic partial differential equations |
►NActions | |
CInitializeRunEventsAndDenseTriggers | |
CProjectRunEventsAndDenseTriggers | Initialize/update items related to events and dense triggers after an AMR change |
CRunEventsAndDenseTriggers | Run the events and dense triggers |
CRunEventsAndTriggers | Run the events and 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 |
CApplyBoundaryCorrectionsToTimeDerivative | Computes the boundary corrections for global time-stepping and adds them to the time derivative |
CApplyLtsBoundaryCorrections | Computes the boundary corrections for local time-stepping and adds them to the variables |
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 |
CProjectDomain | Initialize/update items related to coordinate maps after an AMR change |
CProjectMortars | Initialize/update items related to mortars after an AMR change |
►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 |
CComputeAndSendTciOnInitialGrid | Apply the TCI on the FD grid to the initial data and send the TCI decision to neighboring elements |
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 |
CSetAndCommunicateInitialRdmpData | Sets the RDMP data from the initial data and sends it to neighboring elements |
CSetInitialGridFromTciData | Using the local and neighboring TCI decisions, switches the element to DG if the DG solution was determined to be admissible |
CSetSubcellGrid | Initialize the subcell grid, including the size of the evolved Variables and, if present, primitive Variables |
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 element logical frame to the grid frame at the cell centers |
CDetInverseJacobianLogicalToGridCompute | Compute item for the determinant of the inverse jacobian matrix from logical to grid coordinates |
CDetInverseJacobianLogicalToInertial | The determinant of the inverse Jacobian from the element logical frame to the inertial frame at the cell centers |
CDetInverseJacobianLogicalToInertialCompute | Compute item for the determinant of the inverse jacobian matrix from logical to inertial coordinates |
CInverseJacobianLogicalToGrid | The inverse Jacobian from the element logical frame to the grid frame at the cell centers |
CInverseJacobianLogicalToGridCompute | Compute item for the inverse jacobian matrix from logical to grid coordinates |
CInverseJacobianLogicalToInertial | The inverse Jacobian from the element logical frame to the inertial frame at the cell centers |
CInverseJacobianLogicalToInertialCompute | Compute item for the inverse jacobian matrix from logical to inertial coordinates |
CCellCenteredFlux | Mutator that wraps the system's FluxMutator to correctly set the cell-centered fluxes on the subcell grid |
Nfv | Code specific to a finite volume subcell limiter |
►NOptionTags | Option tags for the DG-subcell solver |
CActiveGrid | |
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 |
CCellCenteredFlux | Holds the cell-centered fluxes on the subcell mesh |
CCoordinates | The coordinates in a given frame |
CDataForRdmpTci | The data for the RDMP troubled-cell indicator |
CDidRollback | Tag indicating whether we are retrying a step after a rollback of a failed DG step |
CGhostDataForReconstruction | The ghost data used for reconstructing the solution on the interfaces between elements |
CInactive | Mark a tag as holding data for the inactive grid |
CInertialCoordinatesCompute | The inertial coordinates on the subcell grid |
CInitialTciData | Inbox tag for communicating the RDMP and TCI status/decision during initialization |
CInterpolatorsFromDgToNeighborFd | An intrp::Irregular from our DG grid to our neighbors' FD grid |
CInterpolatorsFromFdToNeighborFd | An intrp::Irregular from our FD grid to our neighbors' FD grid |
CInterpolatorsFromNeighborDgToFd | An intrp::Irregular from our neighbors' DG grid to our FD grid |
CLogicalCoordinatesCompute | The element logical coordinates on the subcell grid |
CMesh | The mesh on the subcells |
CMeshCompute | |
CMethodOrder | The order of the numerical method used |
CMethodOrderCompute | |
CNeighborTciDecisions | The TCI decision of neighboring elements |
CObserverCoordinatesCompute | "Computes" the active coordinates by setting the DataVector s to point into the coordinates of either the DG or subcell grid |
CObserverInverseJacobianCompute | Computes the active inverse Jacobian |
CObserverJacobianAndDetInvJacobianCompute | Computes the active Jacobian and determinant of the inverse Jacobian |
CObserverMeshCompute | Computes the active mesh, which is the DG mesh if ActiveGrid is Dg and the subcell mesh if ActiveGrid is Subcell |
CObserverMeshVelocityCompute | Computes the mesh velocity on the active grid |
COnSubcellFaces | Mark a tag as the being on the subcell faces |
COnSubcells | Mark a tag as the being on the subcell grid |
CReconstructionOrder | The reconstruction order |
CReconstructor | Base tag for reconstructors |
CStepsSinceTciCall | Keeps track of the number of steps since the TCI was called on the FD grid. This is not used on the DG grid |
CSubcellOptions | System-agnostic options for DG-subcell |
CTciCallsSinceRollback | Keeps track of the number of times the TCI was called after a rollback |
CTciDecision | Stores the status of the troubled cell indicator in the element as an int |
CTciGridHistory | A record of which grid the TCI requested we use |
CTciStatus | Stores the status of the troubled cell indicator in the element (TciDecision) as a Scalar<DataVector> so it can be observed |
CTciStatusCompute | Compute tag to get a TciStatus from a TciDecision |
CBackgroundGrVars | Allocate or assign background general relativity quantities on cell-centered and face-centered FD grid points, for evolution systems run on a curved spacetime without solving Einstein equations (e.g. ValenciaDivclean, ForceFree), |
CGhostData | |
CInitialTciData | Used to communicate the RDMP and TCI status/decision during initialization |
CRdmpTciData | Holds data needed for the relaxed discrete maximum principle troubled-cell indicator |
CSetInterpolators | Sets the intrp::IrregularInterpolant s for interpolating to ghost zone data at block boundaries |
►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 |
CFdToDgTci | |
CFiniteDifferenceDerivativeOrder | The order of the FD derivative used |
CMinimumClearTcis | The number of time steps/TCI calls that the TCI needs to have decided switching to DG is fine before we actually do the switch |
CMinTciCallsAfterRollback | The number of time steps/TCI calls after a switch from DG to FD before we allow switching back to DG |
CNumberOfStepsBetweenTciCalls | The number of time steps taken between calls to the TCI to check if we can go back to the DG grid. A value of 1 means every time step, while 2 means every other time step |
COnlyDgBlocksAndGroups | A list of block names on which to never do subcell |
CPerssonExponent | The exponent \(\alpha\) passed to the Persson troubled-cell indicator |
CPerssonNumHighestModes | The number of highest modes the Persson troubled-cell indicator monitors |
CPerssonTci | |
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 |
CRdmpTci | |
CSubcellToDgReconstructionMethod | Method to use for reconstructing the DG solution from the subcell solution |
CTroubledCellIndicator | Parameters related to the troubled cell indicator (TCI) that determines when to switch between DG and FD |
CUseHalo | Use a width-one halo of FD elements around any troubled element |
►NTags | Tags used for DG evolution scheme |
CBoundaryCorrectionAndGhostCellsInbox | The inbox tag for boundary correction communication and DG-subcell ghost zone cells |
CBoundaryData | Simple tag used to store inbox data in the DataBox |
CBoundaryMessageFromInbox | The BoundaryMessage received from the inbox |
CBoundaryMessageInbox | The inbox tag for boundary correction communication and DG-subcell ghost zone cells using a BoundaryMessage object |
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 |
CApplyBoundaryCorrections | Apply corrections from boundary communication |
CAtomicInboxBoundaryData | Holds the data in the different directions for the nodegroup DgElementArray implementation |
CBackgroundGrVars | Allocate or assign background general relativity quantities needed for evolution systems run on a curved spacetime without solving Einstein equations (e.g. ValenciaDivclean, ForceFree) |
CBoundaryData | The data communicated between neighber elements |
CBoundaryMessage | [Charm++ Message] (https://charm.readthedocs.io/en/latest/charm%2B%2B/manual.html#messages) intended to be used in receive_data calls on the elements to send boundary data from one element on one node, to a different element on a (potentially) different node |
Cis_atomic_inbox_boundary_data | std::true if T is a AtomicInboxBoundaryData |
CMortarData | Data on the mortar used to compute the boundary correction for the DG scheme |
CMortarDataHolder | Data on each side of the mortar used to compute the boundary correction for the DG scheme using global time stepping |
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 |
►Ninitial_data | Namespace for things related to initial data used for evolution systems |
►NOptionTags | Option tags for initial data of evolution system |
CInitialData | Class holding options for initial data of evolution system |
►NTags | Tags for initial data of evolution system |
CInitialData | The global cache tag for the initial data type |
CInitialData | The abstract base class for initial data of evolution systems. All analytic solutions and analytic data must virtually inherit from this class |
►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 |
CGroup | Groups option tags related to the time evolution, e.g. time step and time stepper |
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 | |
NRingdown | Functionality for evolving a ringdown following a compact-binary merger |
►NTags | |
CAnalyticSolutionsCompute | Computes the analytic solution and adds Tags::Analytic of the std::optional<Tensor> s to the DataBox |
CBoundaryCorrection | The boundary correction used for coupling together neighboring cells or applying boundary conditions |
CNumericInitialData | Use in place of an analytic solution or analytic data to start an evolution with numeric initial data loaded from a data file |
CPassVariables | Used to make a time derivative mutator as requesting the time derivatives and temporaries in a Variables |
►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 |
CBlocksToFilter | |
CEnable | Turn the filter off |
CHalfPower | Half of the exponent in the exponential |
NFirstOrderEllipticSolutionsTestHelpers | |
►NForceFree | Items related to evolving the GRFFE system with divergence cleaning |
►NAnalyticData | Holds classes implementing analytic data for the GRFFE system |
CFfeBreakdown | A test problem designed to show that the system initially satisfying the force-free conditions may violate those in a later time |
►CMagnetosphericWald | The magnetospheric Wald problem proposed in [107] |
CSpin | |
►CRotatingDipole | The magnetosphere of an isolated rotating star with dipolar initial magnetic field in the flat spacetime. This is a toy model of a pulsar magnetosphere |
CAngularVelocity | |
CDelta | |
CTiltAngle | |
CVarpi0 | |
CVectorPotentialAmplitude | |
►NBoundaryConditions | Boundary conditions for the GRFFE system |
CBoundaryCondition | The base class of which all boundary conditions must inherit |
CDemandOutgoingCharSpeeds | A boundary condition that only verifies that all characteristic speeds are directed out of the domain; no boundary data is altered by this boundary condition |
►CDirichletAnalytic | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
CAnalyticPrescription | What analytic solution/data to prescribe |
►NBoundaryCorrections | Boundary corrections/numerical fluxes for the GRFFE sytem |
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 |
►Nfd | Finite difference functionality for ForceFree evolution system |
►NOptionTags | |
CReconstructor | Holds the subcell reconstructor in the input file |
►NTags | |
CReconstructor | Tag for the reconstructor |
►CAdaptiveOrder | Adaptive order FD reconstruction. See fd::reconstruction::positivity_preserving_adaptive_order() for details. Note that in the ForceFree evolution system no variable needs to be kept positive |
CAlpha5 | |
CAlpha7 | |
CAlpha9 | |
CLowOrderReconstructor | |
CMonotonisedCentral | Monotonised central reconstruction. See fd::reconstruction::monotonised_central() for details |
CReconstructor | The base class from which all reconstruction schemes must inherit |
►CWcns5z | Fifth order weighted nonlinear compact scheme reconstruction using the Z oscillation indicator. See fd::reconstruction::wcns5z() for details |
CEpsilon | |
CFallbackReconstructor | |
CMaxNumberOfExtrema | |
CNonlinearWeightExponent | |
NImex | Code related to IMEX time integration of ForceFree evolution system |
►NOptionTags | |
CConstraintDampingGroup | Groups option tags related to the divergence cleaning of the GRFFE system |
CForceFreeCurrentGroup | Groups option tags related to the electric current of the GRFFE system |
CForceFreeGroup | Groups option tags related to the GRFFE evolution system |
CKappaPhi | The constraint damping parameter for divergence cleaning of magnetic fields |
CKappaPsi | The constraint damping parameter for divergence cleaning of electric fields |
CParallelConductivity | The damping parameter in the electric current density to impose force-free conditions. Physically, this parameter is the conductivity parallel to magnetic field lines |
►NSolutions | Holds classes implementing a solution to the GRFFE system |
►CAlfvenWave | Alfven wave propagating along \(x\) direction in flat spacetime with the wave speed \(\mu\) |
CWaveSpeed | The wave speed |
►CExactWald | An exact electrovacuum force-free solution of Maxwell's equations in the Schwarzschild spacetime by Wald [191] |
CMagneticFieldAmplitude | |
CFastWave | An electromagnetic wave propagating into \(+x\) direction in flat spacetime |
►Nsubcell | Code required by the DG-FD hybrid solver |
►NOptionTags | |
CTciOptions | |
►NTags | |
CTciOptions | |
CGhostVariables | Returns \(\tilde{J}^i\), \(\tilde{E}^i\), \(\tilde{B}^i\), \(\tilde{\psi}\), \(\tilde{\phi}\) and \(\tilde{q}\) for FD reconstruction |
CNeighborPackagedData | On elements using DG, reconstructs the interface data from a neighboring element doing subcell |
CSetInitialRdmpData | Sets the initial RDMP data |
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 | |
CTildeQCutoff | The cutoff of the absolute value of the generalized charge density \(\tilde{Q}\) in an element to apply the Persson TCI |
►NTags | Tags for the GRFFE system with divergence cleaning |
CChargeDensity | The electric charge density \(q\equiv-n_\mu J^\mu\) where \(n^\mu\) is the normal to hypersurface and \(J^\mu\) is the 4-current |
CChargeDensityCompute | Compute item for electric charge density \(q\) from TildeQ |
CComputeTildeJ | Computes the densitized electric current density \(\tilde{J}^i\) |
CElectricCurrentDensity | The spatial electric current density \(J^i\) |
CElectricCurrentDensityCompute | Compute item for electric current density \(J^i\) from TildeJ |
CElectricDivergenceCleaningField | The divergence cleaning scalar field \(\psi\) coupled to the electric field |
CElectricField | The electric field \(E^i\) |
CElectricFieldCompute | Compute item for electric field \(E^i\) from TildeE |
CKappaPhi | The constraint damping parameter \(\kappa_\phi\) for divergence cleaning of magnetic fields |
CKappaPsi | The constraint damping parameter \(\kappa_\psi\) for divergence cleaning of electric fields |
CLargestCharacteristicSpeed | The largest characteristic speed |
CLargestCharacteristicSpeedCompute | Compute the largest characteristic speed of the GRFFE system with divergence cleaning |
CMagneticDivergenceCleaningField | The divergence cleaning scalar field \(\phi\) coupled to the magnetic field |
CMagneticField | The magnetic field \(B^i\) |
CMagneticFieldCompute | Compute item for magnetic field \(B^i\) from TildeB |
CNsInteriorMask | An optional scalar variable used for masking the interior of neutron star(s) when running neutron star magnetosphere simulations |
CParallelConductivity | The damping parameter \(\eta\) in the electric current density to impose force-free conditions. Physically, this parameter is the conductivity parallel to magnetic field lines |
CTildeB | The densitized magnetic field \(\tilde{B}^i = \sqrt{\gamma}B^i\) |
CTildeE | The densitized electric field \(\tilde{E}^i = \sqrt{\gamma}E^i\) |
CTildeJ | The densitized electric current density \(\tilde{J}^i = \alpha\sqrt{\gamma}J^i\) |
CTildePhi | The densitized divergence cleaning field \(\tilde{\phi} = \sqrt{\gamma}\phi\) associated with the magnetic field |
CTildePsi | The densitized divergence cleaning field \(\tilde{\psi} = \sqrt{\gamma}\psi\) associated with the electric field |
CTildeQ | The densitized electric charge density \(\tilde{q} = \sqrt{\gamma}q\) |
CComputeDriftTildeJ | Computes the non-stiff part \(\tilde{J}^i_\mathrm{drift}\) of the generalized electric current density \(\tilde{J}^i\) |
CComputeParallelTildeJ | Computes the stiff part \(\tilde{J}^i_\mathrm{parallel}\) of the generalized electric current density \(\tilde{J}^i\) |
CFluxes | Compute the fluxes of the GRFFE system with divergence cleaning |
CMaskNeutronStarInterior | Assign the masking scalar variable (see Tags::NsInteriorMask) at the initialization phase in NS magnetosphere simulations |
CSources | Compute the source terms for the GRFFE system with divergence cleaning |
CSystem | General relativistic force-free electrodynamics (GRFFE) system with divergence cleaning |
►CTimeDerivativeTerms | Compute the time derivative of the conserved variables for the GRFFE equations with divergence cleaning |
CLapseTimesElectricFieldOneForm | |
CLapseTimesMagneticFieldOneForm | |
CTildeJDrift | |
Nformaline | Functions for retrieving system and source tree information |
►NFrame | Indicates the Frame that a TensorIndexType is in |
CBlockLogical | |
CDistorted | |
CElementLogical | |
CFluid | |
CFrameIsPhysical | Marks a Frame as being "physical" in the sense that it is meaningful to evaluate an analytic solution in that frame |
CGrid | |
CInertial | |
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 |
CElementWise | Function that applies C to every element of the operands. This function is currently only tested for std::vector operands. Operands other than the first may be a single value, which is applied element-wise to the vector. If needed, this function can be generalized further |
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 ArgumentIndex th 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 |
CMerge | Function that merges two containers using the merge method of the first container. Can be used to collect data in a std::map in a reduction |
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>() |
►Ngh | Items related to evolving the first-order generalized harmonic system |
►NActions | |
CInitializeGhAnd3Plus1Variables | |
CReceiveNumericInitialData | Receive numeric initial data loaded by gh::Actions::SetInitialData |
CSetInitialData | Dispatch loading numeric initial data from files or set analytic initial data |
►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 | |
CDemandOutgoingCharSpeeds | A BoundaryCondition that only verifies that all characteristic speeds are directed out of the domain; no boundary data is altered by this boundary condition |
►CDirichletAnalytic | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
CAnalyticPrescription | What analytic solution/data to prescribe |
CDirichletMinkowski | Sets Dirichlet boundary conditions to a Minkowski spacetime |
►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. [119]) |
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. [119]) |
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. [119]) |
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\) |
►CConstant | A constant function: \(f = C\) |
CValue | |
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 | |
CGaussian | |
CWidth | |
►Ngauges | Gauge conditions for generalized harmonic evolution systems |
►NOptionTags | |
CDhGaugeParameters | |
CGaugeCondition | |
►NTags | |
CDhGaugeParameters | Input option tags for the generalized harmonic evolution system |
CGaugeAndDerivativeCompute | Gauge condition \(H_a\) and its spacetime derivative \(\partial_b H_a\) |
CGaugeCondition | The gauge condition to impose |
►CAnalyticChristoffel | Imposes the analytic gauge condition, \(H_a=\Gamma_a^{\mathrm{analytic}}\) from an analytic solution or analytic data |
CAnalyticPrescription | What analytic solution/data to prescribe |
►CDampedHarmonic | Impose damped harmonic gauge |
CAmplitudes | The amplitudes for the L1, L2, and S terms, respectively, for the damped harmonic gauge |
CExponents | The exponents for the L1, L2, and S terms, respectively, for the damped harmonic gauge |
CSpatialDecayWidth | The width of the Gaussian for the spatial decay of the damped harmonic gauge |
CDhGaugeParameters | A struct holding the parameters for initializing damped harmonic gauge |
CGaugeCondition | Base class for GH gauge conditions |
CHarmonic | Imposes the harmonic gauge condition, \(H_a=0\) |
CSetPiAndPhiFromConstraints | Set \(\Pi_{ab}\) from the gauge source function (or 1-index constraint) and \(\Phi_{iab}\) from the 3-index constraint |
►NOptionTags | Input option tags for the generalized harmonic evolution system |
CGroup | |
►NScalarTensor | |
NAnalyticData | ScalarTensor solutions wrapped for GH |
►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 , gh::Tags::Pi , and gh::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 |
CHalfPhiTwoNormals | \(0.5\Phi_{iab}n^an^b\) |
CHalfPiTwoNormals | \(0.5\Pi_{ab}n^an^b\) |
CInitialGaugeH | Initial value of the gauge source function for the generalized harmonic system |
CLargestCharacteristicSpeed | |
CMeshVelocityDotThreeIndexConstraint | \(\v^i_g \mathcal{C}_{iab}\) |
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\) |
CPi | Conjugate momentum to the spacetime metric |
CPiCompute | Compute item the conjugate momentum \(\Pi_{ab}\) of the spacetime metric \( g_{ab} \) |
CPiOneNormal | \(\Pi_{ab}n^a\) |
CPiSecondIndexUp | \(\Pi_a{}^b\) |
CSecondTimeDerivOfSpacetimeMetricCompute | Compute item to get second time derivative of the spacetime metric from generalized harmonic and geometric variables |
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 ( \(\alpha\)) 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 | |
CCharacteristicSpeedsOnStrahlkorper | |
CCharacteristicSpeedsOnStrahlkorperCompute | |
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 | |
►CNumericInitialData | Numeric initial data loaded from volume data files |
CAdmVars | |
CGhVars | |
CVariables | |
CVarName | Name of a variable in the volume data file |
CSystem | |
CTimeDerivative | Compute the RHS of the Generalized Harmonic formulation of Einstein's equations |
►Ngr | Holds functions related to general relativity |
►NAnalyticData | Classes which implement analytic data for general relativity |
►CBrillLindquist | Brill Lindquist data [30] corresponding to two black holes momentarily at rest |
CCenterA | |
CCenterB | |
CIntermediateComputer | Computes the intermediates and quantities that we do not want to recompute across the solution's implementation |
CIntermediateVars | Computes and returns spacetime quantities of interest |
Cinternal_tags | Tags defined for intermediates specific to BrillLindquist data |
CMassA | |
CMassB | |
►CSpecInitialData | Vacuum initial data generated by SpEC |
CDataDirectory | |
►NSolutions | Classes which implement analytic solutions to Einstein's equations |
►CGaugePlaneWave | Gauge plane wave in flat spacetime |
CProfile | |
CWaveVector | |
►CGaugeWave | Gauge wave in flat spacetime |
CAmplitude | |
CWavelength | |
►CHarmonicSchwarzschild | Schwarzschild black hole in Cartesian coordinates with harmonic gauge |
CCenter | |
CIntermediateComputer | Computes the intermediates and quantities that we do not want to recompute across the solution's implementation |
CIntermediateVars | Computes and returns spacetime quantities of interest |
Cinternal_tags | Tags defined for intermediates specific to the harmonic Schwarzschild solution |
CMass | |
►CKerrSchild | Kerr black hole in Kerr-Schild coordinates |
CCenter | |
CIntermediateComputer | |
CIntermediateVars | |
Cinternal_tags | |
CMass | |
CSpin | |
CVelocity | |
CMinkowski | The Minkowski solution for flat space in Dim spatial dimensions |
►CSphericalKerrSchild | Kerr black hole in Spherical Kerr-Schild coordinates |
CCenter | |
CIntermediateComputer | |
CIntermediateVars | |
Cinternal_tags | |
CMass | |
CSpin | |
►Nsurfaces | |
►NTags | Holds tags and ComputeItems associated with a ylm::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 [25] 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 |
CDimensionlessSpinMagnitude | The dimensionless spin magnitude of a Strahlkorper |
CDimensionlessSpinMagnitudeCompute | Computes the dimensionless spin magnitude \(\chi = \frac{S}{M^2}\) from the dimensionful spin magnitude \(S\) and the christodoulou mass \(M\) of a black hole |
CDimensionlessSpinVector | The dimensionless spin angular momentum vector |
CDimensionlessSpinVectorCompute | Computes the dimensionless spin angular momentum vector |
CExtrinsicCurvatureCompute | |
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 |
CIrreducibleMass | The Irreducible (areal) mass of an apparent horizon |
CIrreducibleMassCompute | Computes the Irreducible mass of an apparent horizon from its area |
CSpatialChristoffelSecondKindCompute | |
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 | |
►NTags | |
CConformal | The quantity Tag scaled by a conformal factor to the given Power |
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 |
CDerivDetSpatialMetric | Derivative of the determinant of the spatial metric |
CDerivInverseSpatialMetric | Spatial derivative of the inverse of the spatial metric |
CDetAndInverseSpatialMetric | |
CDetAndInverseSpatialMetricCompute | Compute item for spatial metric determinant \(\gamma\) and inverse \(\gamma^{ij}\) in terms of the spatial metric \(\gamma_{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 | |
CHamiltonianConstraint | The ADM Hamiltonian constraint \(\frac{1}{2} \left(R + K^2 - K_{ij} K^{ij}\right) - 8 \pi \rho\) (see e.g. Eq. (2.132) in [13]) |
CInverseSpacetimeMetric | |
CInverseSpacetimeMetricCompute | Compute item for inverse spacetime metric \(g^{ab}\) in terms of the lapse \(\alpha\), shift \(\beta^i\), and inverse spatial metric \(\gamma^{ij}\) |
CInverseSpatialMetric | Inverse of the spatial metric |
CLapse | |
CLapseCompute | Compute item for lapse \(\alpha\) from the spacetime metric \(g_{ab}\) and the shift \(\beta^i\) |
CMomentumConstraint | The ADM momentum constraint \(\nabla_j (K^{ij} - \gamma^{ij} K) - 8 \pi S^i\), where \(\nabla\) denotes the covariant derivative associated with the spatial metric \(\gamma_{ij}\) (see e.g. Eq. (2.133) in [13]) |
CMomentumDensity | The spatial momentum density \(S^i=-\gamma^{ij}n^aT_{aj}\), where \(n_a\) denotes the normal to the spatial hypersurface |
CPsi4Real | Computes the real part of \(\Psi_4\) |
CPsi4RealCompute | Computes the real part of the Newman Penrose quantity \(\Psi_4\) using \(\Psi_4[Real] = -0.5*U^{8+}_{ij}*(x^ix^j - y^iy^j)\) |
CShift | |
CShiftCompute | Compute item for shift \(\beta^i\) from the spacetime metric \(g_{ab}\) and the inverse spatial metric \(\gamma^{ij}\) |
CShiftyQuantity | Holds a quantity that's similar to the shift, but isn't the shift |
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 \(g_{ab}\) from the lapse \(\alpha\), shift \(\beta^i\), and spatial metric \(\gamma_{ij}\) |
CSpacetimeNormalOneForm | |
CSpacetimeNormalOneFormCompute | Compute item for spacetime normal oneform \(n_a\) from the lapse \(\alpha\) |
CSpacetimeNormalVector | |
CSpacetimeNormalVectorCompute | Compute item for spacetime normal vector \(n^a\) from the lapse \(\alpha\) and the shift \(\beta^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 \(\gamma_{ij}\) from the spacetime metric \(g_{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 |
CSpatialRicciScalar | Simple tag for the spatial Ricci scalar |
CSpatialRicciScalarCompute | Computes the spatial Ricci scalar using the spatial Ricci tensor and the inverse spatial metric |
CSqrtDetSpatialMetric | |
CSqrtDetSpatialMetricCompute | Compute item to get the square root of the determinant of the spatial metric \(\sqrt{\gamma}\) 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 |
CTraceSpacetimeChristoffelSecondKind | Trace of the spacetime Christoffel symbols of the second kind \(\Gamma^{i} = \Gamma^i_{jk}g^{jk}\), where \(\Gamma^i_{jk}\) are Christoffel symbols of the second kind and \(g^{jk}\) is the inverse spacetime metric |
CTraceSpatialChristoffelFirstKind | Trace of the spatial Christoffel symbols of the first kind \(\Gamma_{i} = \Gamma_{ijk}\gamma^{jk}\), where \(\Gamma_{ijk}\) are Christoffel symbols of the first kind and \(\gamma^{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 |
CWeylMagnetic | The magnetic part of the Weyl tensor in vacuum \(B_{ij}\) |
CWeylMagneticCompute | Compute item for the magnetic part of the weyl tensor in vacuum Computed from the ExtrinsicCurvature and SpatialMetric |
CWeylMagneticScalar | The square \(B_{ij} B^{ij}\) of the magnetic part of the Weyl tensor \(B_{ij}\) |
CWeylMagneticScalarCompute | Can be retrieved using gr::Tags::WeylMagneticScalar Computes magnetic part of the Weyl tensor |
CWeylTypeD1 | Computes a quantity measuring how far from type D spacetime is, using measure D1 [Eq. (8)] of [19] |
CWeylTypeD1Compute | Compute item for WeylTypeD1 Computed from WeylElectric, SpatialMetric, and InverseSpatialMetric |
CWeylTypeD1Scalar | Computes the scalar \(D_{ij} D^{ij}\) (Eq. (8) of [19]) from \(D_{ij}\) and the inverse spatial metric \(\gamma^{ij}\), i.e. \(D = \gamma^{ik}\gamma^{jl}D_{ij}D_{kl}\) |
CWeylTypeD1ScalarCompute | Can be retrieved using gr::Tags::WeylTypeD1Scalar |
CAnalyticDataBase | Base struct for properties common to all GR analytic data classes |
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 |
►NInitialMagneticFields | Things related to the initial (seed) magnetic field that can be superposed on GRMHD initial data |
CInitialMagneticField | The abstract base class for initial magnetic field configurations |
►CPoloidal | Poloidal magnetic field for GRMHD initial data |
CCenter | |
CCutoffPressure | |
CMaxDistanceFromCenter | |
CPressureExponent | |
CVectorPotentialAmplitude | |
►CToroidal | Toroidal magnetic field for GRMHD initial data |
CCenter | |
CCutoffPressure | |
CMaxDistanceFromCenter | |
CPressureExponent | |
CVectorPotentialAmplitude | |
►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 |
►CCcsnCollapse | Evolve a stellar collapse (progenitor) profile through collapse |
CAdiabaticIndex | Adiabatic index of the system at readin |
CCentralAngularVelocity | Central angular velocity artificially assigned at readin |
CDifferentialRotationParameter | Differential rotation parameter for artificially assigned rotation profile |
CMaxDensityRatioForLinearInterpolation | Maximum density ratio for linear interpolation |
CPolytropicConstant | The polytropic constant of the fluid |
CProgenitorFilename | The massive star progenitor data file |
►CFukaInitialData | Hydro initial data generated by FUKA |
CElectronFraction | |
CInfoFilename | |
►CKhInstability | Analytic initial data for a Kelvin-Helmholtz instability simulation |
CAdiabaticIndex | The adiabatic index of the fluid |
CBackgroundDensity | The mass density outside of the strip |
CBackgroundVelocity | The velocity along \(x\) outside of the strip |
CMagneticField | The uniform magnetic field |
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 |
►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 |
CMagneticFields | |
COrszagTangVortex | Analytic initial data for the relativistic Orszag-Tang vortex |
►CPolarMagnetizedFmDisk | Magnetized fluid disk orbiting a Kerr black hole in the Kerr-Schild Cartesian coordinates, but in a toroidal mesh defined from a torus map (see grmhd::AnalyticData::SphericalTorus) |
CDiskParameters | |
CTorusParameters | |
►CRiemannProblem | Initial conditions for relativistic MHD Riemann problems |
CAdiabaticIndex | |
CLapse | |
CLeftMagneticField | |
CLeftPressure | |
CLeftRestMassDensity | |
CLeftSpatialVelocity | |
CRightMagneticField | |
CRightPressure | |
CRightRestMassDensity | |
CRightSpatialVelocity | |
CShiftX | |
►CSlabJet | Analytic initial data for a slab jet |
CAdiabaticIndex | |
CAmbientDensity | |
CAmbientElectronFraction | |
CAmbientPressure | |
CInletRadius | |
CJetDensity | |
CJetElectronFraction | |
CJetPressure | |
CJetVelocity | |
CMagneticField | |
►CSpecInitialData | Hydro initial data generated by SpEC |
CDataDirectory | |
CDensityCutoff | |
CElectronFraction | |
►CSphericalTorus | Torus made by removing two polar cones from a spherical shell |
CFractionOfTorus | |
CMinPolarAngle | |
CRadialRange | |
►NGhValenciaDivClean | Namespace associated with utilities for the combined Generalized Harmonic and Valencia formulation of ideal GRMHD with divergence cleaning systems |
►NActions | |
CReceiveNumericInitialData | Receive numeric initial data loaded by grmhd::GhValenciaDivClean::Actions::SetInitialData |
CSetInitialData | Dispatch loading numeric initial data from files |
►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 |
CConstraintPreservingFreeOutflow | Sets constraint-preserving boundary conditions on the spacetime variables and hydro free outflow on the GRMHD variables |
►CDirichletAnalytic | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
CAnalyticPrescription | What analytic solution/data to prescribe |
►CDirichletFreeOutflow | Sets Dirichlet boundary conditions using the analytic solution or analytic data on the spacetime variables and hydro free outflow on the GRMHD variables |
CAnalyticPrescription | What analytic solution/data to prescribe |
►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 | |
►Nfd | Finite difference functionality for the coupled Generalized Harmonic and ValenciaDivClean equations |
►NOptionTags | Option tags for finite difference solver |
CFilterOptions | Option tag for the filter/dissipation options |
CReconstructor | Option tag for the reconstructor |
►NTags | Tags for finite difference solver |
CFilterOptions | Tag for filter/dissipation options |
CReconstructor | Tag for the reconstructor |
CBoundaryConditionGhostData | Computes finite difference ghost data for external boundary conditions |
►CFilterOptions | Filtering/dissipation options |
CSpacetimeDissipation | Kreiss-Oliger dissipation applied to metric variables |
CMonotonisedCentralPrim | Monotonised central reconstruction on the GRMHD primitive variables (see fd::reconstruction::monotonised_central() for details) and unlimited 3rd order (degree 2 polynomial) reconstruction on the metric variables |
►CPositivityPreservingAdaptiveOrderPrim | Positivity-preserving adaptive order reconstruction. See fd::reconstruction::positivity_preserving_adaptive_order() for details. The rest mass density, electron fraction, and the pressure are kept positive. Use unlimited 5th order (degree 4 polynomial) reconstruction on the metric variables |
CAlpha5 | |
CAlpha7 | |
CAlpha9 | |
CLowOrderReconstructor | |
CReconstructor | The base class from which all reconstruction schemes must inherit |
►CWcns5zPrim | Fifth order weighted nonlinear compact scheme reconstruction using the Z oscillation indicator. See fd::reconstruction::wcns5z() for details |
CEpsilon | |
CFallbackReconstructor | |
CMaxNumberOfExtrema | |
CNonlinearWeightExponent | |
►Nsubcell | Code required by the DG-subcell/FD hybrid solver |
CFixConservativesAndComputePrims | Fix the conservative variables and compute the primitive variables |
CNeighborPackagedData | On elements using DG, reconstructs the interface data from a neighboring element doing subcell |
CPrimitiveGhostVariables | Computes the rest mass density \(\rho\), electron fraction \(Y_e\), pressure \(p\), Lorentz factor times the spatial velocity \(W v^i\), magnetic field \(B^i\), the divergence cleaning field \(\Phi\), and the generalized harmonic evolved variables \(g_{ab}\), \(\Phi_{iab}\) and \(\Pi_{ab}\) on the subcells so they can be used for 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 | If the grid is switched from subcell to DG, then this mutator resizes the primitive variables to the DG grid and computes the primitive variables on the DG grid |
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 |
CTimeDerivative | Compute the time derivative on the subcell grid using FD reconstruction |
►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\) |
CComputeLargestCharacteristicSpeed | Computes the largest magnitude of the characteristic speeds |
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\) |
CLargestCharacteristicSpeed | |
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 |
►CNumericInitialData | Numeric initial data loaded from volume data files |
CGhVariables | |
CHydroVariables | |
CSetPiAndPhiFromConstraints | Set \(\Pi_{ab}\) from the gauge source function |
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 |
CElectronFraction | The constant electron fraction throughout the fluid |
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 [128] 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 | |
CLeftElectronFraction | |
CLeftMagneticField | |
CLeftPressure | |
CLeftRestMassDensity | |
CLeftSpatialVelocity | |
CRightElectronFraction | |
CRightMagneticField | |
CRightPressure | |
CRightRestMassDensity | |
CRightSpatialVelocity | |
CShockSpeed | |
CSmoothFlow | Periodic GrMhd solution in Minkowski spacetime |
►NValenciaDivClean | Items related to the Valencia formulation of ideal GRMHD with divergence cleaning coupled with electron fraction |
►NActions | |
CReadNumericInitialData | Dispatch loading numeric initial data from files |
CSetNumericInitialData | Receive numeric initial data loaded by grmhd::ValenciaDivClean::Actions::ReadNumericInitialData |
►NBoundaryConditions | Boundary conditions for the GRMHD Valencia Divergence Cleaning system |
CBoundaryCondition | The base class off of which all boundary conditions must inherit |
CDemandOutgoingCharSpeeds | A BoundaryCondition that only verifies that all characteristic speeds are directed out of the domain; no boundary data is altered by this boundary condition |
►CDirichletAnalytic | Sets Dirichlet boundary conditions using the analytic solution or analytic data |
CAnalyticPrescription | What analytic solution/data to prescribe |
CHydroFreeOutflow | Apply hydrodynamic free outflow and no inflow boundary condition to GRMHD primitive variables |
►CReflective | Apply "soft" reflective boundary condition as described in [167] |
CReflectBoth | |
►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 |