This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

CTempus_Test::Basis
▶CDescribable
▶CTempus::Integrator< Scalar >	Thyra Base interface for time integrators. Time integrators are designed to advance the solution from an initial time, , to a final time,
CTempus::IntegratorAdjointSensitivity< Scalar >	Time integrator suitable for adjoint sensitivity analysis
CTempus::IntegratorBasic< Scalar >	Basic time integrator
CTempus::IntegratorForwardSensitivity< Scalar >	Time integrator implementing forward sensitivity analysis
CTempus::IntegratorPseudoTransientAdjointSensitivity< Scalar >	Time integrator suitable for pseudotransient adjoint sensitivity analysis
CTempus::IntegratorPseudoTransientForwardSensitivity< Scalar >	Time integrator suitable for pseudotransient forward sensitivity analysis
▶CTempus::Interpolator< Scalar >	Base strategy class for interpolation functionality
CTempus::InterpolatorLagrange< Scalar >	Concrete implemenation of `Interpolator` that does simple lagrange interpolation
▶CTempus::PhysicsState< Scalar >	PhysicsState is a simple class to hold information about the physics
CTempus_Test::PhysicsStateCounter< Scalar >	PhysicsStateCounter is a simple PhysicsState that counts steps
▶CTempus::RKButcherTableau< Scalar >	Runge-Kutta methods
CTempus::BackwardEuler_RKBT< Scalar >	Backward Euler Runge-Kutta Butcher Tableau
CTempus::EDIRK2Stage3rdOrder_RKBT< Scalar >	EDIRK 2 Stage 3rd order
CTempus::EDIRK2StageTheta_RKBT< Scalar >
CTempus::Explicit2Stage2ndOrderRunge_RKBT< Scalar >	RK Explicit 2 Stage 2nd order by Runge
CTempus::Explicit3_8Rule_RKBT< Scalar >	Explicit RK 3/8th Rule Butcher Tableau
CTempus::Explicit3Stage3rdOrder_RKBT< Scalar >	RK Explicit 3 Stage 3rd order
CTempus::Explicit3Stage3rdOrderHeun_RKBT< Scalar >	RK Explicit 3 Stage 3rd order by Heun
CTempus::Explicit3Stage3rdOrderTVD_RKBT< Scalar >	RK Explicit 3 Stage 3rd order TVD
CTempus::Explicit4Stage3rdOrderRunge_RKBT< Scalar >	RK Explicit 4 Stage 3rd order by Runge
CTempus::Explicit4Stage4thOrder_RKBT< Scalar >	Runge-Kutta 4th order Butcher Tableau
CTempus::Explicit5Stage3rdOrderKandG_RKBT< Scalar >	RK Explicit 5 Stage 3rd order by Kinnmark and Gray
CTempus::ExplicitBogackiShampine32_RKBT< Scalar >	Explicit RK Bogacki-Shampine Butcher Tableau
CTempus::ExplicitMerson45_RKBT< Scalar >	Explicit RK Merson Butcher Tableau
CTempus::ExplicitTrapezoidal_RKBT< Scalar >	RK Explicit Trapezoidal
CTempus::ForwardEuler_RKBT< Scalar >	Forward Euler Runge-Kutta Butcher Tableau
▶CTempus::General_RKButcherTableau< Scalar >
CTempus::GeneralDIRK_RKBT< Scalar >	General Implicit Runge-Kutta Butcher Tableau
CTempus::GeneralExplicit_RKBT< Scalar >	General Explicit Runge-Kutta Butcher Tableau
CTempus::Implicit1Stage1stOrderRadauA_RKBT< Scalar >
CTempus::Implicit1Stage1stOrderRadauB_RKBT< Scalar >
CTempus::Implicit1Stage2ndOrderGauss_RKBT< Scalar >
CTempus::Implicit2Stage2ndOrderLobattoA_RKBT< Scalar >
CTempus::Implicit2Stage2ndOrderLobattoB_RKBT< Scalar >
CTempus::Implicit2Stage2ndOrderLobattoC_RKBT< Scalar >
CTempus::Implicit2Stage3rdOrderRadauA_RKBT< Scalar >
CTempus::Implicit2Stage3rdOrderRadauB_RKBT< Scalar >
CTempus::Implicit2Stage4thOrderGauss_RKBT< Scalar >
CTempus::Implicit2Stage4thOrderHammerHollingsworth_RKBT< Scalar >
CTempus::Implicit3Stage4thOrderLobattoA_RKBT< Scalar >
CTempus::Implicit3Stage4thOrderLobattoB_RKBT< Scalar >
CTempus::Implicit3Stage4thOrderLobattoC_RKBT< Scalar >
CTempus::Implicit3Stage5thOrderRadauA_RKBT< Scalar >
CTempus::Implicit3Stage5thOrderRadauB_RKBT< Scalar >
CTempus::Implicit3Stage6thOrderGauss_RKBT< Scalar >
CTempus::Implicit3Stage6thOrderKuntzmannButcher_RKBT< Scalar >
CTempus::Implicit4Stage6thOrderLobattoA_RKBT< Scalar >
CTempus::Implicit4Stage6thOrderLobattoB_RKBT< Scalar >
CTempus::Implicit4Stage6thOrderLobattoC_RKBT< Scalar >
CTempus::Implicit4Stage8thOrderKuntzmannButcher_RKBT< Scalar >
CTempus::IRK1StageTheta_RKBT< Scalar >
CTempus::SDIRK1Stage1stOrder_RKBT< Scalar >	SDIRK 1 Stage 1st order
CTempus::SDIRK21_RKBT< Scalar >	SDIRK 2(1) pair
CTempus::SDIRK2Stage2ndOrder_RKBT< Scalar >	SDIRK 2 Stage 2nd order
CTempus::SDIRK2Stage3rdOrder_RKBT< Scalar >	SDIRK 2 Stage 3rd order
CTempus::SDIRK3Stage4thOrder_RKBT< Scalar >
CTempus::SDIRK5Stage4thOrder_RKBT< Scalar >
CTempus::SDIRK5Stage5thOrder_RKBT< Scalar >
CTempus::SolutionHistory< Scalar >	SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of SolutionStates for later retrival and reuse, such as checkpointing, restart, and undo operations
CTempus::SolutionState< Scalar >	Solution state for integrators and steppers. SolutionState contains the metadata for solutions and the solutions themselves
CTempus::SolutionStateMetaData< Scalar >	Solution state meta data
▶CTempus::Stepper< Scalar >	Thyra Base interface for time steppers
CTempus::StepperExplicitRK< Scalar >	Explicit Runge-Kutta time stepper
▶CTempus::StepperForwardEuler< Scalar >	Forward Euler time stepper
CTempus_Test::PhysicsStateTest_StepperForwardEuler< Scalar >	This is a Forward Euler time stepper to test the PhysicsState
▶CTempus::StepperImplicit< Scalar >	Thyra Base interface for implicit time steppers
CTempus::StepperBackwardEuler< Scalar >	Backward Euler time stepper
CTempus::StepperBDF2< Scalar >	BDF2 (Backward-Difference-Formula-2) time stepper
CTempus::StepperDIRK< Scalar >	Diagonally Implicit Runge-Kutta (DIRK) time stepper
CTempus::StepperHHTAlpha< Scalar >	HHT-Alpha time stepper
CTempus::StepperIMEX_RK< Scalar >	Implicit-Explicit Runge-Kutta (IMEX-RK) time stepper
CTempus::StepperIMEX_RK_Partition< Scalar >	Partitioned Implicit-Explicit Runge-Kutta (IMEX-RK) time stepper
CTempus::StepperNewmarkImplicitAForm< Scalar >	Newmark time stepper in acceleration form (a-form)
CTempus::StepperNewmarkImplicitDForm< Scalar >	Newmark time stepper
CTempus::StepperTrapezoidal< Scalar >	Trapezoidal method time stepper
CTempus::StepperLeapfrog< Scalar >	Leapfrog time stepper
CTempus::StepperNewmarkExplicitAForm< Scalar >	Newmark Explicit time stepper. This is the specific case of the more general Newmark time stepper in the case this stepper is explicit (beta = 0). Newmark Explicit is hence an explicit time stepper (i.e., no solver used)
CTempus::StepperOperatorSplit< Scalar >	OperatorSplit stepper loops through the Stepper list
CTempus::StepperStaggeredForwardSensitivity< Scalar >	A stepper implementing staggered forward sensitivity analysis
CTempus::StepperState< Scalar >	StepperState is a simple class to hold state information about the stepper
CTempus::TimeStepControl< Scalar >	TimeStepControl manages the time step size. There several mechanicisms that effect the time step size and handled with this class:
▶CTempus::IntegratorObserver< Scalar >	IntegratorObserver class for time integrators
CTempus::IntegratorObserverBasic< Scalar >	IntegratorObserverBasic class for time integrators. This basic class has simple no-op functions, as all basic functionality should be handled through other methods
CTempus::IntegratorObserverComposite< Scalar >	This observer
CTempus::IntegratorObserverLogging< Scalar >	This observer logs calls to observer functions. This observer simply logs and counts the calls to each of the observer functions. This is useful in monirtoring and debugging the time integration
CTempus::InterpolatorFactory< Scalar >	Interpolator factory
▶CLinearOpWithSolveBase
CThyra::ScaledIdentityLinearOpWithSolve< Scalar >	Implicit concrete `LinearOpBase` subclass that takes a flattended out multi-vector and performs a multi-RHS apply with it
▶CLinearOpWithSolveFactoryBase
CThyra::AdjointLinearOpWithSolveFactory< Scalar >	Create a LinearOpWithSolveFactory for an adjoint linear op
CThyra::BlockedTriangularLinearOpWithSolveFactory< Scalar >	Implicit subclass that takes a blocked triangular LOWB object and turns it into a LOWSB object
CThyra::MultiVectorLinearOpWithSolveFactory< Scalar >	Create a LinearOpWithSolveFactory for a flattened-out multi-vector
CThyra::ReuseLinearOpWithSolveFactory< Scalar >	A LinearOpWithSolveFactory that is designed to reuse an already created/initialized preconditioner
CThyra::ScaledIdentityLinearOpWithSolveFactory< Scalar >	Create a LinearOpWithSolveFactory for a flattened-out multi-vector
CTempus_Test::LinearRegression< Scalar >	Linear regression class. Copied and modified from Rythmos
CTempus_Test::ModelEvaluator1DFEM< Scalar >
▶CModelEvaluatorDefaultBase
▶CTempus::SensitivityModelEvaluatorBase< Scalar >	A ModelEvaluator decorator for sensitivity analysis
CTempus::CombinedForwardSensitivityModelEvaluator< Scalar >	Transform a ModelEvaluator's sensitivity equations to its residual
CTempus::StaggeredForwardSensitivityModelEvaluator< Scalar >	Transform a ModelEvaluator's sensitivity equations to its residual
CTempus::WrapperModelEvaluatorPairIMEX_CombinedFSA< Scalar >	Specialization of IMEX ME for "combined" FSA method
CTempus::WrapperModelEvaluatorPairIMEX_StaggeredFSA< Scalar >	Specialization of IMEX ME for "staggered" FSA method
CTempus::WrapperModelEvaluatorPairPartIMEX_CombinedFSA< Scalar >	Specialization of IMEX-Part ME for "combined" FSA method
CTempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA< Scalar >	Specialization of IMEX-Part ME for "combined" FSA method
▶CParameterListAcceptor
CTempus::Integrator< Scalar >	Thyra Base interface for time integrators. Time integrators are designed to advance the solution from an initial time, , to a final time,
CTempus::Interpolator< Scalar >	Base strategy class for interpolation functionality
CTempus::RKButcherTableauBuilder< Scalar >	Runge-Kutta Builder class. This factory creates RKButcherTableau objects given the description string from the RKButcherTableau object
CTempus::SolutionHistory< Scalar >	SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of SolutionStates for later retrival and reuse, such as checkpointing, restart, and undo operations
CTempus::Stepper< Scalar >	Thyra Base interface for time steppers
CTempus::TimeStepControl< Scalar >	TimeStepControl manages the time step size. There several mechanicisms that effect the time step size and handled with this class:
▶CTempus::TimeStepControlStrategy< Scalar >	StepControlStrategy class for TimeStepControl
CTempus::TimeStepControlStrategyBasicVS< Scalar >	StepControlStrategy class for TimeStepControl
CTempus::TimeStepControlStrategyComposite< Scalar >	StepControlStrategy class for TimeStepControl
CTempus::TimeStepControlStrategyConstant< Scalar >	StepControlStrategy class for TimeStepControl
CTempus::TimeStepControlStrategyIntegralController< Scalar >	StepControlStrategy class for TimeStepControl
CTempus::TimeStepControlStrategyPID< Scalar >	StepControlStrategy class for TimeStepControl
▶CParameterListAcceptorDefaultBase
CTempus::RKButcherTableau< Scalar >	Runge-Kutta methods
CTempus_Test::HarmonicOscillatorModel< Scalar >	Consider the ODE: $m\ddot{x} + c\dot{x} + kx=f$ where $k \geq 0$ is a constant, is a constant damping parameter, is a constant forcing parameter, and is a constant mass parameter, with initial conditions are: $\begin{eqnarray} x(0) & = & 0\\ \dot{x}(0) & = & 1 \end{eqnarray}$ It is straight-forward to show that the exact solution to this ODE is: $\begin{eqnarray} x(t) & = & t(1+0.5\tilde{f}t), \hspace{3.6cm} if \hspace{0.2cm} k = c = 0 \\ & = & \frac{(\tilde{c}-\tilde{f})}{\tilde{c}^2}(1-e^{-\tilde{c}t}) + \frac{f}{c}t, \hspace{1.9cm} if \hspace{0.2cm} k = 0, c\neq 0 \\ & = & \frac{1}{\sqrt{\tilde{k}}}\sin(\sqrt{\tilde{k}}t) + \frac{f}{k}\left(1-\cos(\sqrt{\tilde{k}}t) \right), \hspace{0.2cm} if \hspace{0.2cm} k > 0, c = 0 \end{eqnarray}$ where $\tilde{c}\equiv c/m$ , $\tilde{k}\equiv k/m$ and $\tilde{f}\equiv f/m$ . While it is possible to derive the solution to this ODE for the case when and $c \neq 0$ , we do not consider that case here. When , , and , our ODE simplies to a canonical differential equation model of a ball thrown up in the air, with a parabolic trajectory solution, namely $x(t) = t(1-0.5t)$ where $t\in [0,2]$ . An EpetraExt version of this simplified version of the test is implemented in Piro::MockModelEval_B (see Trilinos/packages/piro/test), where it is used to test the Piro (EpetraExt) Newmark-Beta scheme (see input_Solver_NB.xml input file). When and , this test is equivalent to the SinCos model.
CTempus_Test::SinCosModel< Scalar >	Sine-Cosine model problem from Rythmos. This is a canonical Sine-Cosine differential equation $\mathbf{\ddot{x}}=-\mathbf{x}$ with a few enhancements. We start with the exact solution to the differential equation $\begin{eqnarray} x_{0}(t) & = & a+b\sin((f/L)t+\phi)\\ x_{1}(t) & = & b(f/L)\cos((f/L)t+\phi) \end{eqnarray}$ then the form of the model is $\begin{eqnarray} \frac{d}{dt}x_{0}(t) & = & x_{1}(t)\\ \frac{d}{dt}x_{1}(t) & = & \left(\frac{f}{L}\right)^{2}(a-x_{0}(t)) \end{eqnarray}$ where the default parameter values are , , and , and the initial conditions $\begin{eqnarray} x_{0}(t_{0}=0) & = & \gamma_{0}[=0]\\ x_{1}(t_{0}=0) & = & \gamma_{1}[=1] \end{eqnarray}$ determine the remaining coefficients $\begin{eqnarray} \phi & = & \arctan(((f/L)/\gamma_{1})(\gamma_{0}-a))-(f/L)t_{0}[=0]\\ b & = & \gamma_{1}/((f/L)cos((f/L)t_{0}+\phi))[=1] \end{eqnarray*}$
CTempus_Test::SteadyQuadraticModel< Scalar >	Simple quadratic equation with a stable steady-state. This is a simple differential equation $\mathbf{\dot{x}}=\mathbf{x}^2 - b^2$ which has steady state solutions $\mathbf{x} = \pm b$ . The solution $\mathbf{x} = b$ is stable if and the solution $\mathbf{x} = -b$ is stable if . This model is used to test pseudo-transient sensitivity analysis methods
CTempus_Test::VanDerPol_IMEX_ExplicitModel< Scalar >	Van der Pol model formulated for IMEX
CTempus_Test::VanDerPol_IMEX_ImplicitModel< Scalar >	Van der Pol model formulated for IMEX-RK
CTempus_Test::VanDerPol_IMEXPart_ImplicitModel< Scalar >	Van der Pol model formulated for the partitioned IMEX-RK
CTempus_Test::VanDerPolModel< Scalar >	Van der Pol model problem for nonlinear electrical circuit
▶CPreconditionerBase
CThyra::AdjointPreconditioner< Scalar >	Concrete `PreconditionerBase` subclass that wraps a preconditioner operator in MultiVectorLinearOp
CThyra::MultiVectorPreconditioner< Scalar >	Concrete `PreconditionerBase` subclass that wraps a preconditioner operator in MultiVectorLinearOp
▶CPreconditionerFactoryBase
CThyra::AdjointPreconditionerFactory< Scalar >	Concrete `PreconditionerFactoryBase` subclass that wraps a preconditioner in AdjointPreconditioner
CThyra::MultiVectorPreconditionerFactory< Scalar >	Concrete `PreconditionerFactoryBase` subclass that wraps a preconditioner in MultiVectorPreconditioner
CThyra::ReusePreconditionerFactory< Scalar >	Concrete `PreconditionerFactoryBase` subclass that just returns an already created/initialized preconditioner object
▶CRowStatLinearOpBase
CThyra::MultiVectorLinearOp< Scalar >	Implicit concrete `LinearOpBase` subclass that takes a flattended out multi-vector and performs a multi-RHS apply with it
▶CScaledLinearOpBase
CThyra::MultiVectorLinearOp< Scalar >	Implicit concrete `LinearOpBase` subclass that takes a flattended out multi-vector and performs a multi-RHS apply with it
▶CStateFuncModelEvaluatorBase
CTempus::AdjointAuxSensitivityModelEvaluator< Scalar >	ModelEvaluator for forming adjoint sensitivity equations
CTempus::AdjointSensitivityModelEvaluator< Scalar >	ModelEvaluator for forming adjoint sensitivity equations
CTempus::AuxiliaryIntegralModelEvaluator< Scalar >	ModelEvaluator for integrating auxiliary equations
CTempus::CombinedForwardSensitivityModelEvaluator< Scalar >	Transform a ModelEvaluator's sensitivity equations to its residual
CTempus::StaggeredForwardSensitivityModelEvaluator< Scalar >	Transform a ModelEvaluator's sensitivity equations to its residual
▶CTempus::WrapperModelEvaluator< Scalar >	A ModelEvaluator which wraps the application ModelEvaluator
CTempus::WrapperModelEvaluatorBasic< Scalar >	A ModelEvaluator for residual evaluations given a state. This ModelEvaluator takes a state, x, and determines its residual, , which is suitable for a nonlinear solve. This is accomplished by computing the time derivative of the state, x_dot, (through Lambda functions), supplying the current time, and calling the application application ModelEvaluator, $f(\dot{x},x,t)$
▶CTempus::WrapperModelEvaluatorPairIMEX< Scalar >	ModelEvaluator pair for implicit and explicit (IMEX) evaluations
▶CTempus::WrapperModelEvaluatorPairIMEX_Basic< Scalar >	ModelEvaluator pair for implicit and explicit (IMEX) evaulations
CTempus::WrapperModelEvaluatorPairIMEX_CombinedFSA< Scalar >	Specialization of IMEX ME for "combined" FSA method
CTempus::WrapperModelEvaluatorPairIMEX_StaggeredFSA< Scalar >	Specialization of IMEX ME for "staggered" FSA method
▶CTempus::WrapperModelEvaluatorPairPartIMEX_Basic< Scalar >	ModelEvaluator pair for implicit and explicit (IMEX) evaulations
CTempus::WrapperModelEvaluatorPairPartIMEX_CombinedFSA< Scalar >	Specialization of IMEX-Part ME for "combined" FSA method
CTempus::WrapperModelEvaluatorPairPartIMEX_StaggeredFSA< Scalar >	Specialization of IMEX-Part ME for "combined" FSA method
CTempus::WrapperModelEvaluatorSecondOrder< Scalar >	A ModelEvaluator for residual evaluations given a state. This ModelEvaluator takes a state, x, and determines its residual, , which is suitable for a nonlinear solve. This is accomplished by computing the time derivative of the state, x_dot, (through Lambda functions), supplying the current time, and calling the application application ModelEvaluator, $f(\dot{x},x,t)$
CTempus_Test::CDR_Model< Scalar >	1D CGFEM model for convection/diffusion/reaction
CTempus_Test::HarmonicOscillatorModel< Scalar >	Consider the ODE: $m\ddot{x} + c\dot{x} + kx=f$ where $k \geq 0$ is a constant, is a constant damping parameter, is a constant forcing parameter, and is a constant mass parameter, with initial conditions are: $\begin{eqnarray} x(0) & = & 0\\ \dot{x}(0) & = & 1 \end{eqnarray}$ It is straight-forward to show that the exact solution to this ODE is: $\begin{eqnarray} x(t) & = & t(1+0.5\tilde{f}t), \hspace{3.6cm} if \hspace{0.2cm} k = c = 0 \\ & = & \frac{(\tilde{c}-\tilde{f})}{\tilde{c}^2}(1-e^{-\tilde{c}t}) + \frac{f}{c}t, \hspace{1.9cm} if \hspace{0.2cm} k = 0, c\neq 0 \\ & = & \frac{1}{\sqrt{\tilde{k}}}\sin(\sqrt{\tilde{k}}t) + \frac{f}{k}\left(1-\cos(\sqrt{\tilde{k}}t) \right), \hspace{0.2cm} if \hspace{0.2cm} k > 0, c = 0 \end{eqnarray}$ where $\tilde{c}\equiv c/m$ , $\tilde{k}\equiv k/m$ and $\tilde{f}\equiv f/m$ . While it is possible to derive the solution to this ODE for the case when and $c \neq 0$ , we do not consider that case here. When , , and , our ODE simplies to a canonical differential equation model of a ball thrown up in the air, with a parabolic trajectory solution, namely $x(t) = t(1-0.5t)$ where $t\in [0,2]$ . An EpetraExt version of this simplified version of the test is implemented in Piro::MockModelEval_B (see Trilinos/packages/piro/test), where it is used to test the Piro (EpetraExt) Newmark-Beta scheme (see input_Solver_NB.xml input file). When and , this test is equivalent to the SinCos model.
CTempus_Test::SinCosModel< Scalar >	Sine-Cosine model problem from Rythmos. This is a canonical Sine-Cosine differential equation $\mathbf{\ddot{x}}=-\mathbf{x}$ with a few enhancements. We start with the exact solution to the differential equation $\begin{eqnarray} x_{0}(t) & = & a+b\sin((f/L)t+\phi)\\ x_{1}(t) & = & b(f/L)\cos((f/L)t+\phi) \end{eqnarray}$ then the form of the model is $\begin{eqnarray} \frac{d}{dt}x_{0}(t) & = & x_{1}(t)\\ \frac{d}{dt}x_{1}(t) & = & \left(\frac{f}{L}\right)^{2}(a-x_{0}(t)) \end{eqnarray}$ where the default parameter values are , , and , and the initial conditions $\begin{eqnarray} x_{0}(t_{0}=0) & = & \gamma_{0}[=0]\\ x_{1}(t_{0}=0) & = & \gamma_{1}[=1] \end{eqnarray}$ determine the remaining coefficients $\begin{eqnarray} \phi & = & \arctan(((f/L)/\gamma_{1})(\gamma_{0}-a))-(f/L)t_{0}[=0]\\ b & = & \gamma_{1}/((f/L)cos((f/L)t_{0}+\phi))[=1] \end{eqnarray*}$
CTempus_Test::SteadyQuadraticModel< Scalar >	Simple quadratic equation with a stable steady-state. This is a simple differential equation $\mathbf{\dot{x}}=\mathbf{x}^2 - b^2$ which has steady state solutions $\mathbf{x} = \pm b$ . The solution $\mathbf{x} = b$ is stable if and the solution $\mathbf{x} = -b$ is stable if . This model is used to test pseudo-transient sensitivity analysis methods
CTempus_Test::VanDerPol_IMEX_ExplicitModel< Scalar >	Van der Pol model formulated for IMEX
CTempus_Test::VanDerPol_IMEX_ImplicitModel< Scalar >	Van der Pol model formulated for IMEX-RK
CTempus_Test::VanDerPol_IMEXPart_ImplicitModel< Scalar >	Van der Pol model formulated for the partitioned IMEX-RK
CTempus_Test::VanDerPolModel< Scalar >	Van der Pol model problem for nonlinear electrical circuit
CTempus::StepperFactory< Scalar >	Stepper factory
▶CTempus::StepperObserver< Scalar >	StepperObserver class for Stepper class
CTempus::StepperBackwardEulerObserver< Scalar >	StepperBackwardEulerObserver class for StepperBackwardEuler
CTempus::StepperBDF2Observer< Scalar >	StepperBDF2Observer class for StepperBDF2
CTempus::StepperDIRKObserver< Scalar >	StepperDIRKObserver class for StepperDIRK
CTempus::StepperExplicitRKObserver< Scalar >	StepperExplicitRKObserver class for StepperExplicitRK
CTempus::StepperForwardEulerObserver< Scalar >	StepperForwardEulerObserver class for StepperForwardEuler
CTempus::StepperIMEX_RKObserver< Scalar >	StepperIMEX_RKObserver class for StepperIMEX_RK
CTempus::StepperIMEX_RKPartObserver< Scalar >	StepperIMEX_RKPartObserver class for StepperIMEX_RK_Partition
CTempus::StepperLeapfrogObserver< Scalar >	StepperLeapfrogObserver class for StepperLeapfrog
CTempus::StepperObserverBasic< Scalar >	StepperObserverBasic class for Stepper class
CTempus::StepperOperatorSplitObserver< Scalar >	StepperOperatorSplitObserver class for StepperOperatorSplit
CTempus::StepperTrapezoidalObserver< Scalar >	StepperTrapezoidalObserver class for StepperTrapezoidal
▶CTempus::StepperOptimizationInterface< Scalar >	Stepper interface to support full-space optimization
CTempus::StepperBackwardEuler< Scalar >	Backward Euler time stepper
▶CTempus::TimeDerivative< Scalar >	This interface defines the time derivative connection between an implicit Stepper and WrapperModelEvaluator
CTempus::StepperBackwardEulerTimeDerivative< Scalar >	Time-derivative interface for Backward Euler
CTempus::StepperBDF2TimeDerivative< Scalar >	Time-derivative interface for BDF2
CTempus::StepperDIRKTimeDerivative< Scalar >	Time-derivative interface for DIRK
CTempus::StepperIMEX_RKPartTimeDerivative< Scalar >	Time-derivative interface for Partitioned IMEX RK
CTempus::StepperIMEX_RKTimeDerivative< Scalar >	Time-derivative interface for IMEX RK
CTempus::StepperTrapezoidalTimeDerivative< Scalar >	Time-derivative interface for Trapezoidal method
▶CVerboseObject
CTempus::Integrator< Scalar >	Thyra Base interface for time integrators. Time integrators are designed to advance the solution from an initial time, , to a final time,
CTempus::Interpolator< Scalar >	Base strategy class for interpolation functionality
CTempus::PhysicsState< Scalar >	PhysicsState is a simple class to hold information about the physics
CTempus::RKButcherTableau< Scalar >	Runge-Kutta methods
CTempus::SolutionHistory< Scalar >	SolutionHistory is basically a container of SolutionStates. SolutionHistory maintains a collection of SolutionStates for later retrival and reuse, such as checkpointing, restart, and undo operations
CTempus::SolutionState< Scalar >	Solution state for integrators and steppers. SolutionState contains the metadata for solutions and the solutions themselves
CTempus::SolutionStateMetaData< Scalar >	Solution state meta data
CTempus::Stepper< Scalar >	Thyra Base interface for time steppers
CTempus::StepperState< Scalar >	StepperState is a simple class to hold state information about the stepper
CTempus::TimeStepControl< Scalar >	TimeStepControl manages the time step size. There several mechanicisms that effect the time step size and handled with this class: