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::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::StepperExplicit< Scalar >	Thyra Base interface for implicit time steppers
▶CTempus::StepperExplicitRK< Scalar >	Explicit Runge-Kutta time stepper
CTempus::StepperERK_3_8Rule< Scalar >	Explicit RK 3/8th Rule Butcher Tableau
CTempus::StepperERK_3Stage3rdOrder< Scalar >	RK Explicit 3 Stage 3rd order
CTempus::StepperERK_3Stage3rdOrderHeun< Scalar >	RK Explicit 3 Stage 3rd order by Heun
CTempus::StepperERK_3Stage3rdOrderTVD< Scalar >	RK Explicit 3 Stage 3rd order TVD
CTempus::StepperERK_4Stage3rdOrderRunge< Scalar >	RK Explicit 4 Stage 3rd order by Runge
CTempus::StepperERK_4Stage4thOrder< Scalar >	Runge-Kutta 4th order Butcher Tableau
CTempus::StepperERK_5Stage3rdOrderKandG< Scalar >	RK Explicit 5 Stage 3rd order by Kinnmark and Gray
CTempus::StepperERK_BogackiShampine32< Scalar >	Explicit RK Bogacki-Shampine Butcher Tableau
CTempus::StepperERK_ForwardEuler< Scalar >	Forward Euler Runge-Kutta Butcher Tableau
CTempus::StepperERK_General< Scalar >	General Explicit Runge-Kutta Butcher Tableau
CTempus::StepperERK_Merson45< Scalar >	Explicit RK Merson Butcher Tableau
CTempus::StepperERK_Midpoint< Scalar >	RK Explicit Midpoint
CTempus::StepperERK_Ralston< Scalar >	RK Explicit Ralston
CTempus::StepperERK_SSPERK54< Scalar >	Strong Stability Preserving Explicit RK Butcher Tableau
CTempus::StepperERK_Trapezoidal< Scalar >	RK Explicit Trapezoidal
CTempus::StepperForwardEuler< Scalar >	Forward Euler time stepper
CTempus::StepperLeapfrog< Scalar >	Leapfrog time stepper
CTempus::StepperNewmarkExplicitAForm< Scalar >	Newmark Explicit time stepper
CTempus_Test::StepperPhysicsStateTest< 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::StepperDIRK_1Stage1stOrderRadauIA< Scalar >	RK Implicit 1 Stage 1st order Radau IA
CTempus::StepperDIRK_1StageTheta< Scalar >	SDIRK 1 Stage Theta
CTempus::StepperDIRK_2Stage2ndOrderLobattoIIIB< Scalar >	RK Implicit 2 Stage 2nd order Lobatto IIIB
CTempus::StepperDIRK_BackwardEuler< Scalar >	Backward Euler Runge-Kutta Butcher Tableau
CTempus::StepperDIRK_General< Scalar >	General Implicit Runge-Kutta Butcher Tableau
CTempus::StepperEDIRK_2Stage3rdOrder< Scalar >	EDIRK 2 Stage 3rd order
CTempus::StepperEDIRK_2StageTheta< Scalar >	EDIRK 2 Stage Theta Method
CTempus::StepperEDIRK_TrapezoidalRule< Scalar >	RK Trapezoidal Rule (A.K.A. RK Crank-Nicolson)
CTempus::StepperSDIRK_21Pair< Scalar >	SDIRK 2(1) pair
CTempus::StepperSDIRK_2Stage2ndOrder< Scalar >	SDIRK 2 Stage 2nd order
CTempus::StepperSDIRK_2Stage3rdOrder< Scalar >	SDIRK 2 Stage 3rd order
CTempus::StepperSDIRK_3Stage2ndOrder< Scalar >	SDIRK 3 Stage 2nd order
CTempus::StepperSDIRK_3Stage4thOrder< Scalar >	SDIRK 3 Stage 4th order
CTempus::StepperSDIRK_5Stage4thOrder< Scalar >	SDIRK 5 Stage 4th order
CTempus::StepperSDIRK_5Stage5thOrder< Scalar >	SDIRK 5 Stage 5th order
CTempus::StepperSDIRK_ImplicitMidpoint< Scalar >	SDIRK Implicit Midpoint
CTempus::StepperSDIRK_SSPDIRK22< Scalar >	Strong Stability Preserving Diagonally-Implicit RK Butcher Tableau
CTempus::StepperSDIRK_SSPDIRK23< Scalar >	Strong Stability Preserving Diagonally-Implicit RK Butcher Tableau
CTempus::StepperSDIRK_SSPDIRK32< Scalar >	Strong Stability Preserving Diagonally-Implicit RK Butcher Tableau
CTempus::StepperSDIRK_SSPDIRK33< Scalar >	Strong Stability Preserving Diagonally-Implicit RK Butcher Tableau
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::StepperOperatorSplit< Scalar >	OperatorSplit stepper loops through the Stepper list
▶CTempus::StepperRKBase< Scalar >	Base class for Runge-Kutta methods, ExplicitRK, DIRK and IMEX
CTempus::StepperDIRK< Scalar >	Diagonally Implicit Runge-Kutta (DIRK) time stepper
CTempus::StepperExplicitRK< Scalar >	Explicit Runge-Kutta 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::StepperStaggeredForwardSensitivity< Scalar >	A stepper implementing staggered forward sensitivity analysis
CTempus::StepperSubcycling< Scalar >	Subcycling time stepper
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:
CExplicitODEParameters< Scalar >
CTempus::ImplicitODEParameters< Scalar >
▶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 is a composite 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::IntegratorObserverNoOp< Scalar >	IntegratorObserverNoOp class for time integrators. This basic class has simple no-op functions, as all basic functionality should be handled through other methods
CTempus::IntegratorObserverSubcycling< Scalar >	IntegratorObserverSubcycling class for time integrators. This basic class has simple no-op functions, as all basic functionality should be handled through other methods
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::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::StepperStaggeredForwardSensitivity< Scalar >	A stepper implementing staggered forward sensitivity analysis
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_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(x,\dot{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::StepperBackwardEulerAppAction< Scalar >	Application Action for StepperBackwardEuler
CTempus::StepperBackwardEulerAppActionComposite< Scalar >	This composite AppAction loops over added AppActions
▶CTempus::StepperBackwardEulerModifierBase< Scalar >	Base modifier for StepperBackwardEuler
CTempus::StepperBackwardEulerModifierDefault< Scalar >	Default modifier for StepperBackwardEuler
▶CTempus::StepperBackwardEulerModifierXBase< Scalar >	Base ModifierX for StepperBackwardEuler
CTempus::StepperBackwardEulerModifierXDefault< Scalar >	Default ModifierX for StepperBackwardEuler
▶CTempus::StepperBackwardEulerObserverBase< Scalar >	Base observer for StepperBackwardEuler
CTempus::StepperBackwardEulerObserverDefault< Scalar >	Default observer for StepperBackwardEuler
▶CTempus::StepperBackwardEulerAppAction< double >
▶CTempus::StepperBackwardEulerModifierBase< double >
CTempus_Unit_Test::StepperBackwardEulerModifierTest
▶CTempus::StepperBackwardEulerModifierXBase< double >
CTempus_Unit_Test::StepperBackwardEulerModifierXTest
▶CTempus::StepperBackwardEulerObserverBase< double >
CTempus_Unit_Test::StepperBackwardEulerObserverTest
CTempus::StepperFactory< Scalar >	Stepper factory
▶CTempus::StepperForwardEulerAppAction< Scalar >	Application Action for StepperForwardEuler
CTempus::StepperForwardEulerAppActionComposite< Scalar >	This composite AppAction loops over added AppActions
▶CTempus::StepperForwardEulerModifierBase< Scalar >	Base modifier for StepperBackwardEuler
CTempus::StepperForwardEulerModifierDefault< Scalar >	Default modifier for StepperForwardEuler
▶CTempus::StepperForwardEulerModifierXBase< Scalar >	Base ModifierX for StepperForwardEuler
CTempus::StepperForwardEulerModifierXDefault< Scalar >	Default ModifierX for StepperForwardEuler
▶CTempus::StepperForwardEulerObserverBase< Scalar >	Base observer for StepperForwardEuler
CTempus::StepperForwardEulerObserverDefault< Scalar >	Default observer for StepperForwardEuler
▶CTempus::StepperForwardEulerAppAction< double >
▶CTempus::StepperForwardEulerModifierBase< double >
CTempus_Unit_Test::StepperForwardEulerModifierTest
▶CTempus::StepperForwardEulerModifierXBase< double >
CTempus_Unit_Test::StepperForwardEulerModifierXTest
▶CTempus::StepperForwardEulerObserverBase< double >
CTempus_Unit_Test::StepperForwardEulerObserverTest
▶CTempus::StepperObserver< Scalar >	StepperObserver class for Stepper class
CTempus::StepperBackwardEulerObserver< Scalar >	StepperBackwardEulerObserver class for StepperBackwardEuler
CTempus::StepperBDF2Observer< Scalar >	StepperBDF2Observer class for StepperBDF2
CTempus::StepperForwardEulerObserver< Scalar >	StepperForwardEulerObserver class for StepperForwardEuler
CTempus::StepperLeapfrogObserver< Scalar >	StepperLeapfrogObserver class for StepperLeapfrog
CTempus::StepperObserverBasic< Scalar >	StepperObserverBasic class for Stepper class
CTempus::StepperObserverComposite< Scalar >	This observer is a composite observer,
CTempus::StepperOperatorSplitObserver< Scalar >	StepperOperatorSplitObserver class for StepperOperatorSplit
▶CTempus::StepperRKObserver< Scalar >	StepperRKObserver class for StepperRK
CTempus::StepperRKObserverComposite< Scalar >	This observer is a composite observer,
CTempus::StepperRKObserverLogging< 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::StepperSubcyclingObserver< Scalar >	StepperSubcyclingObserver class for StepperSubcycling
CTempus::StepperTrapezoidalObserver< Scalar >	StepperTrapezoidalObserver class for StepperTrapezoidal
▶CTempus::StepperOperatorSplitAppAction< Scalar >	StepperOperatorSplitAppAction class for StepperOperatorSplit
CTempus::StepperOperatorSplitAppActionComposite< Scalar >	This composite AppAction loops over added AppActions
▶CTempus::StepperOperatorSplitModifierBase< Scalar >	Base modifier for OperatorSplit
CTempus::StepperOperatorSplitModifierDefault< Scalar >	Default modifier for StepperOperatorSplit
▶CTempus::StepperOperatorSplitModifierXBase< Scalar >	Base ModifierX for StepperOperatorSplit
CTempus::StepperOperatorSplitModifierXDefault< Scalar >	Default ModifierX for StepperOperatorSplit
▶CTempus::StepperOperatorSplitObserverBase< Scalar >	Base observer for StepperOperatorSplit
CTempus::StepperOperatorSplitObserverDefault< Scalar >	Default observer for StepperOperatorSplit
▶CTempus::StepperOperatorSplitAppAction< double >
▶CTempus::StepperOperatorSplitModifierBase< double >
CTempus_Unit_Test::StepperOperatorSplitModifierTest
▶CTempus::StepperOperatorSplitModifierXBase< double >
CTempus_Unit_Test::StepperOperatorSplitModifierXTest
▶CTempus::StepperOperatorSplitObserverBase< double >
CTempus_Unit_Test::StepperOperatorSplitObserverTest
▶CTempus::StepperOptimizationInterface< Scalar >	Stepper interface to support full-space optimization
CTempus::StepperBackwardEuler< Scalar >	Backward Euler time stepper
▶CTempus::StepperRKAppAction< Scalar >	Application Action for StepperRKBase
CTempus::StepperRKAppActionComposite< Scalar >	This composite AppAction loops over added AppActions
▶CTempus::StepperRKModifierBase< Scalar >	Base modifier for StepperRK
CTempus::StepperRKModifierDefault< Scalar >	Default modifier for StepperRK
▶CTempus::StepperRKModifierXBase< Scalar >	Base ModifierX for StepperRK
CTempus::StepperRKModifierXDefault< Scalar >	Default ModifierX for StepperRK
▶CTempus::StepperRKObserverBase< Scalar >	Base observer for StepperRK
CTempus::StepperRKObserverDefault< Scalar >	Default observer for StepperRK
▶CTempus::StepperRKAppAction< double >
▶CTempus::StepperRKModifierBase< double >
CTempus_Unit_Test::StepperRKModifierTest	Unit test class for RK Stepper Modifier AppAction
▶CTempus::StepperRKModifierXBase< double >
CTempus_Unit_Test::StepperRKModifierXTest
▶CTempus::StepperRKObserverBase< double >
CTempus_Unit_Test::StepperRKObserverTest	Unit test class for RK Stepper Observer AppAction
▶CTempus::StepperSubcyclingAppAction< Scalar >	Application Action for StepperSubcycling
CTempus::StepperSubcyclingAppActionComposite< Scalar >	This composite AppAction loops over added AppActions
▶CTempus::StepperSubcyclingModifierBase< Scalar >	Base modifier for StepperSubcycling
CTempus::StepperSubcyclingModifierDefault< Scalar >	Default modifier for StepperSubcycling
▶CTempus::StepperSubcyclingModifierXBase< Scalar >	Base ModifierX for StepperSubcycling
CTempus::StepperSubcyclingModifierXDefault< Scalar >	Default ModifierX for StepperSubcycling
▶CTempus::StepperSubcyclingObserverBase< Scalar >	Base observer for StepperSubcycling
CTempus::StepperSubcyclingObserverDefault< Scalar >	Default observer for StepperSubcycling
▶CTempus::StepperSubcyclingAppAction< double >
▶CTempus::StepperSubcyclingModifierBase< double >
CTempus_Unit_Test::StepperSubcyclingModifierTest
▶CTempus::StepperSubcyclingModifierXBase< double >
CTempus_Unit_Test::StepperSubcyclingModifierXTest
▶CTempus::StepperSubcyclingObserverBase< double >
CTempus_Unit_Test::StepperSubcyclingObserverTest
▶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
▶CTempus::TimeEventBase< Scalar >	This class defines time events which can be used to "trigger" an action. Time events are points in time and/or timestep index where an an action should occur, such as, solution output (mesh and solution) diagnostic output, restart, screen dump, in-situ visualization, user-specified, or any other action
CTempus::TimeEventComposite< Scalar >	This composite TimeEvent loops over added TimeEvents
CTempus::TimeEventList< Scalar >	TimeEventList specifies a list of time events
CTempus::TimeEventListIndex< Scalar >	TimeEventListIndex specifies a list of index events
CTempus::TimeEventRange< Scalar >	TimeEventRange specifies a start, stop and stride time
CTempus::TimeEventRangeIndex< Scalar >	TimeEventRangeIndex specifies a start, stop and stride index
▶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: