#LyX 2.1 created this file. For more info see http://www.lyx.org/
\lyxformat 474
\begin_document
\begin_header
\textclass article
\use_default_options true
\maintain_unincluded_children false
\language english
\language_package default
\inputencoding auto
\fontencoding global
\font_roman default
\font_sans default
\font_typewriter default
\font_math auto
\font_default_family default
\use_non_tex_fonts false
\font_sc false
\font_osf false
\font_sf_scale 100
\font_tt_scale 100
\graphics default
\default_output_format default
\output_sync 0
\bibtex_command default
\index_command default
\paperfontsize default
\spacing single
\use_hyperref false
\papersize default
\use_geometry true
\use_package amsmath 1
\use_package amssymb 1
\use_package cancel 1
\use_package esint 1
\use_package mathdots 1
\use_package mathtools 1
\use_package mhchem 1
\use_package stackrel 1
\use_package stmaryrd 1
\use_package undertilde 1
\cite_engine basic
\cite_engine_type default
\biblio_style plain
\use_bibtopic false
\use_indices false
\paperorientation portrait
\suppress_date false
\justification true
\use_refstyle 1
\index Index
\shortcut idx
\color #008000
\end_index
\leftmargin 1in
\topmargin 1in
\rightmargin 1in
\bottommargin 1in
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\paragraph_indentation default
\quotes_language english
\papercolumns 1
\papersides 1
\paperpagestyle default
\tracking_changes false
\output_changes false
\html_math_output 0
\html_css_as_file 0
\html_be_strict false
\end_header

\begin_body

\begin_layout Section
Basic Time-Integration Requirements
\end_layout

\begin_layout Standard
The following is a list of basic requirements needed by most time integrators.
\end_layout

\begin_layout Enumerate
General requirements
\end_layout

\begin_deeper
\begin_layout Enumerate
Easy to use! Keep it very simple!
\end_layout

\begin_deeper
\begin_layout Enumerate
Simple integrators should be simple to do! Complex integrators may (and
 usually do) require complex methods.
\end_layout

\end_deeper
\end_deeper
\begin_layout Enumerate
Input specification
\end_layout

\begin_deeper
\begin_layout Enumerate
Simple to setup time integrators.
\end_layout

\begin_layout Enumerate
Keep number of lists and nesting to a minimum.
\end_layout

\begin_layout Enumerate
Common parameters should move up the hierarchy.
\end_layout

\begin_layout Enumerate
Separate list for time-integrator construction and runtime execution.
\end_layout

\end_deeper
\begin_layout Enumerate
Output specification
\end_layout

\begin_deeper
\begin_layout Enumerate
Have a coherent method for verbosity specification (too easy to get too
 much information).
\end_layout

\begin_layout Enumerate
Ensure default output is not too verbose.
\end_layout

\begin_layout Enumerate
Needs simple clear organization.
\end_layout

\end_deeper
\begin_layout Enumerate
Software design (General)
\end_layout

\begin_deeper
\begin_layout Enumerate
Keep a simple object hierarchy.
\end_layout

\begin_layout Enumerate
Modular setup and usage.
\end_layout

\begin_layout Enumerate
Do not use too many levels of indirection.
\end_layout

\begin_layout Enumerate
Use a simple naming convention.
\end_layout

\begin_layout Enumerate
Make usage of methods clean and straight forward.
 (Usage of implicit methods is clunky.)
\end_layout

\begin_layout Enumerate
Time integrators and steppers need to be well documented
\end_layout

\begin_deeper
\begin_layout Enumerate
Capabilities and properties of each integrator and stepper needs to be documente
d.
\end_layout

\begin_layout Enumerate
Stability, order, ...
\end_layout

\begin_layout Enumerate
What is functional and what is not? Ramping, error control, ...
\end_layout

\begin_layout Enumerate
Examples demonstrating capabilities.
\end_layout

\begin_deeper
\begin_layout Enumerate
If a capability is not regression tested, it does not exist.
\end_layout

\end_deeper
\end_deeper
\begin_layout Enumerate
Needs to be built with
\end_layout

\begin_deeper
\begin_layout Enumerate
Thyra and/or adaptor interface
\end_layout

\begin_layout Enumerate
ModelEvaluator and/or adaptor interface
\end_layout

\begin_layout Enumerate
Templated on scalar types
\end_layout

\begin_layout Enumerate
Will entail using the Data Warehouse?
\end_layout

\end_deeper
\begin_layout Enumerate
Needs to be easy to write a time integrator
\end_layout

\begin_deeper
\begin_layout Enumerate
Insulate users and application developers from gory details (Thyra, ModelEvaluat
or) as much as possible.
\end_layout

\begin_layout Enumerate
Have a pure virtual interface, and a default implementation (stay away from
 mix-in interfaces i.e., multiple inheritance interfaces)
\end_layout

\end_deeper
\begin_layout Enumerate
Should not incur any additional costs to use the time-integration package.
\end_layout

\begin_deeper
\begin_layout Enumerate
Obviously minor cost differences should be OK, but with explicit evaluations
 any additional costs may not be acceptable.
\end_layout

\begin_layout Enumerate
Computational cost of time-integrators are very small.
\end_layout

\end_deeper
\end_deeper
\begin_layout Enumerate
Software design (Specific)
\end_layout

\begin_deeper
\begin_layout Enumerate
Construction from ParameterList, solution vector, initial guess, ...
\end_layout

\begin_layout Enumerate
Easy accessors to objects and parameters
\end_layout

\begin_deeper
\begin_layout Enumerate
Time step, preferred next time step, time step limits (max/min), ...
\end_layout

\begin_layout Enumerate
Time-integration errors
\end_layout

\end_deeper
\begin_layout Enumerate
Ability to set/reset functions: ramping, error control, timestep limit functions
, ...
\end_layout

\begin_layout Enumerate
Ability to take a single time step
\end_layout

\begin_layout Enumerate
Ability to advance the solution to a specific time, and get solutions out
 at specific times (check pointed solutions not interpolations).
\end_layout

\begin_layout Enumerate
Ability for step/error control
\end_layout

\begin_deeper
\begin_layout Enumerate
For a single time step just return error estimates
\end_layout

\begin_layout Enumerate
For time advance, control step size and error to tolerances and return vector
 of step sizes taken and error estimates.
\end_layout

\begin_layout Enumerate
Adjust timestep size based on stability limits (e.g., CFL limits) for each
 physics.
\end_layout

\begin_deeper
\begin_layout Enumerate
This will require hooks for the physics to supply timestep limit functions.
\end_layout

\end_deeper
\begin_layout Enumerate
Adjusting timestep size based on temporal errors should be something handled
 internal to the time integration.
\end_layout

\end_deeper
\begin_layout Enumerate
Ability to ramp the timestep size
\end_layout

\begin_layout Enumerate
Need access to previous time steps/errors
\end_layout

\begin_layout Enumerate
Ability to insert observers into the time integration
\end_layout

\begin_deeper
\begin_layout Enumerate
Need observers between RK stages
\end_layout

\end_deeper
\begin_layout Enumerate
Ability for 
\begin_inset Quotes eld
\end_inset

out of the box
\begin_inset Quotes erd
\end_inset

 time integration (i.e., use functionality already available in time-integration
 package).
\end_layout

\begin_deeper
\begin_layout Enumerate
For simple time-integration schemes, the user should be able to construct
 a time integrator and advance a solution 
\begin_inset Quotes eld
\end_inset

out of the box
\begin_inset Quotes erd
\end_inset

.
\end_layout

\end_deeper
\begin_layout Enumerate
Ability for 
\begin_inset Quotes eld
\end_inset

build your own
\begin_inset Quotes erd
\end_inset

 time integration to construct a specialized time integration scheme
\end_layout

\begin_deeper
\begin_layout Enumerate
This requires a simple, clear, well-documented definition of a time integrator.
\end_layout

\end_deeper
\begin_layout Enumerate
Forward and adjoint sensitivities.
\end_layout

\begin_deeper
\begin_layout Enumerate
Should be able to use Griewank's and Wang's method for checkpointing
\end_layout

\begin_layout Enumerate
Should be able to use reduced memory checkpointing.
\end_layout

\begin_layout Enumerate
Use Multi-Vector?
\end_layout

\begin_layout Enumerate
Get sensitivities of solution and response with respect to parameters.
\end_layout

\begin_layout Enumerate
Need an adjoint solve.
\end_layout

\end_deeper
\end_deeper
\begin_layout Section
ATDM Specific Time-Integration Requirements
\end_layout

\begin_layout Enumerate
Build the time-integrator package from the ATDM applications, and generalize
 from there.
\end_layout

\begin_layout Enumerate
Time-integration package needs to handle
\end_layout

\begin_deeper
\begin_layout Enumerate
Multi-physics, Multi-scale
\end_layout

\begin_layout Enumerate
Inter-node Asynchronous Multi-Task (AMT)
\end_layout

\begin_deeper
\begin_layout Enumerate
New physics startup (ex: ablation needing new physics, PIC particle hitting
 boundary creating new particle/physics?)
\end_layout

\begin_deeper
\begin_layout Itemize
Does this mean just terms in the equations and/or new equations?
\end_layout

\end_deeper
\begin_layout Enumerate
New work distributions
\end_layout

\end_deeper
\end_deeper
\begin_layout Enumerate
Steppers
\end_layout

\begin_deeper
\begin_layout Enumerate
First-order PDEs
\end_layout

\begin_deeper
\begin_layout Enumerate
Forward and Backward Euler
\end_layout

\begin_layout Enumerate
Runge-Kutta
\end_layout

\begin_layout Enumerate
Implicit and Explicit (IMEX) schemes
\end_layout

\begin_deeper
\begin_layout Enumerate
Currently working through Piro, but has some issues.
 (EM)
\end_layout

\begin_layout Enumerate
Need to be able to solve for explicit variables, and eliminate them from
 the implicit solve.
\end_layout

\begin_layout Enumerate
Need to be able to handle the cases of Lagrangian and ALE formulation (mass
 matrix).
\end_layout

\end_deeper
\end_deeper
\begin_layout Enumerate
Operator-Splitting
\end_layout

\begin_deeper
\begin_layout Enumerate
First-Order split
\end_layout

\begin_layout Enumerate
Strang/Marchuk splitting
\end_layout

\begin_layout Enumerate
Subcycling?
\end_layout

\begin_layout Enumerate
Can re-solve the current time step
\end_layout

\begin_deeper
\begin_layout Enumerate
In multi-physics black-box mode coupling, 
\end_layout

\begin_deeper
\begin_layout Itemize
User queries each physics for preferred timestep size, and timestep limits.
\end_layout

\begin_layout Itemize
Next timestep is negotiated between the preferred timestep sizes.
\end_layout

\begin_layout Itemize
Each physics takes the negotiated timestep size.
\end_layout

\begin_layout Itemize
If any of the physics fails the timestep, tell ALL physics to reject the
 current solution and re-solve using a new negotiated (smaller) timestep.
\end_layout

\begin_layout Itemize
The PIKE black-box ModelEvaluator is an example of this.
\end_layout

\end_deeper
\end_deeper
\end_deeper
\begin_layout Enumerate
L-stable methods
\end_layout

\begin_layout Enumerate
SSP methods
\end_layout

\begin_layout Enumerate
Second-order PDEs
\end_layout

\begin_deeper
\begin_layout Enumerate
Trapezoidal Rule 
\end_layout

\begin_layout Enumerate
Newmark-
\begin_inset Formula $\beta$
\end_inset


\end_layout

\begin_layout Enumerate
Generalized-
\begin_inset Formula $\alpha$
\end_inset

 Method (Emphasis, Charon 2)
\end_layout

\begin_layout Enumerate
Leap-Frog, Velocity-Verlet (PIC)
\end_layout

\end_deeper
\begin_layout Enumerate
BDF (predictor-corrector)
\end_layout

\begin_deeper
\begin_layout Enumerate
For multi-step time integrators, ability to reset the history and restart
 with new time integrator
\end_layout

\begin_deeper
\begin_layout Enumerate
Solve to steady state, throw away history, restart with new time integrator
\end_layout

\end_deeper
\end_deeper
\end_deeper
\begin_layout Enumerate
Need to be able to re-calculate the state/residual from scratch, and when
 only part of the state has changed.
\end_layout

\begin_deeper
\begin_layout Enumerate
Example: in a Lagrangian calculation, you might need to recalculate but
 the mesh coordinates have not changed.
\end_layout

\end_deeper
\begin_layout Section
Additional Time-Integration Requirements
\end_layout

\begin_layout Enumerate
Ability to switch between time integrators
\end_layout

\begin_layout Enumerate
Ability to input user-defined Butcher Tableaus
\end_layout

\begin_layout Enumerate
Ability to do Matrix-Free implicit methods
\end_layout

\begin_layout Enumerate
Uncertainty Quantification
\end_layout

\begin_deeper
\begin_layout Enumerate
Embedded Ensemble Propagation
\end_layout

\begin_layout Enumerate
Embedded Stochastic Galerkin (SG) - Polynomial chaos approximation
\end_layout

\end_deeper
\begin_layout Enumerate
Get the time derivatives of auxiliary variables that are not part of the
 solution vector
\end_layout

\begin_deeper
\begin_layout Enumerate
Analytic (chain rule)
\end_layout

\begin_deeper
\begin_layout Enumerate
(+) Provides a conservative (as in conservation of energy) value.
\end_layout

\begin_deeper
\begin_layout Enumerate
Maintain divergence-free properties.
\end_layout

\end_deeper
\begin_layout Enumerate
(-) As the number of dependent variables of the auxiliary variable changes,
 you need to recode the chain rule.
\end_layout

\end_deeper
\begin_layout Enumerate
Finite-difference/polynomial interpolation
\end_layout

\begin_deeper
\begin_layout Enumerate
(-) Does not necessarily provide a conservative (as in conversation of energy)
 value.
\end_layout

\begin_layout Enumerate
(+) Insensitive to the number of dependent variables.
\end_layout

\begin_layout Enumerate
(-) Need a stateless function evaluation for the auxiliary variable.
\end_layout

\end_deeper
\begin_layout Enumerate
Can we use the DAE index 
\begin_inset Quotes eld
\end_inset

evaluation
\begin_inset Quotes erd
\end_inset

 to get the time derivative of the auxiliary 
\begin_inset Quotes eld
\end_inset

algebraic
\begin_inset Quotes erd
\end_inset

 variable? This is probably very similar to the analytic and chain rule
 method.
\end_layout

\begin_layout Enumerate
This should include time integrated values (e.g., some adjoint and optimization
 quantities).
\end_layout

\end_deeper
\begin_layout Enumerate
Steppers
\end_layout

\begin_deeper
\begin_layout Enumerate
Explicit time integrator
\end_layout

\begin_deeper
\begin_layout Enumerate
Central difference (transient dynamics, CompSim User's Manual Salinas)
\end_layout

\end_deeper
\end_deeper
\begin_layout Enumerate
Support Hessian information for forward sensitivities (i.e., second derivatives
 wrt parameters).
\end_layout

\begin_layout Enumerate
Support Space-Time formulation
\end_layout

\begin_layout Enumerate
Support for full-space optimization methods
\end_layout

\begin_deeper
\begin_layout Enumerate
Full KKT system
\end_layout

\end_deeper
\begin_layout Enumerate
Provide time-integration interface for third-party libraries
\end_layout

\begin_deeper
\begin_layout Enumerate
This could provide comparisons for verification and performance assessment.
\end_layout

\begin_layout Enumerate
SUNDIALS (Carol Woodward, LLNL, and Dan Reynolds, SMU) is a candidate for
 this.
\end_layout

\end_deeper
\begin_layout Section
Interoperability
\end_layout

\begin_layout Standard
Other packages that the time integrator needs to interact with.
\end_layout

\begin_layout Subsection
Thyra
\end_layout

\begin_layout Subsection
ModelEvaluator
\end_layout

\begin_layout Enumerate
Motivation for MEs
\end_layout

\begin_deeper
\begin_layout Enumerate
Provide single interface from nonlinear ANAs (NOX, Rythmos, LOCA, MOOCHO)
 to applications (for numerical algorithms.
 Still need a 
\begin_inset Quotes eld
\end_inset

usage
\begin_inset Quotes erd
\end_inset

 interface to each ANA.).
\end_layout

\begin_layout Enumerate
Provides shared, uniform access to linear solver capabilities 
\end_layout

\begin_layout Enumerate
Once an application implements support for one ANA, support for other ANAs
 can quickly follow (Incremental support for sensitivities, optimization,
 and UQ)
\end_layout

\begin_layout Enumerate
Mixed problem types will become more and more common and must be easy to
 support
\end_layout

\begin_deeper
\begin_layout Enumerate
Transient optimization
\end_layout

\begin_layout Enumerate
Uncertainty in transient simulations 
\end_layout

\begin_layout Enumerate
Stability of an optimum under uncertainty of a transient problem 
\end_layout

\end_deeper
\end_deeper
\begin_layout Enumerate
MEs are stateless!
\end_layout

\begin_deeper
\begin_layout Enumerate
State values are passed in as a parameter.
\end_layout

\begin_deeper
\begin_layout Enumerate
This requires complete recompute of the ME.
\end_layout

\begin_layout Enumerate
What if some compute extensive pieces of the state do not need to be recomputed?
 Wasted cycles!
\end_layout

\begin_layout Enumerate
Can we have a 
\begin_inset Quotes eld
\end_inset

stateful
\begin_inset Quotes erd
\end_inset

 ME, which could keep track the of state through the InArgs?
\end_layout

\end_deeper
\end_deeper
\begin_layout Enumerate
InArgs and OutArgs
\end_layout

\begin_deeper
\begin_layout Enumerate
Are confusing - 
\begin_inset Quotes eld
\end_inset

not intuitive
\begin_inset Quotes erd
\end_inset


\end_layout

\begin_layout Enumerate
Eric Cyr proposed alternative methods using templating?
\end_layout

\end_deeper
\begin_layout Enumerate
Need MEs for time integration
\end_layout

\begin_deeper
\begin_layout Enumerate
This will inherently cause any new design of the numerical algorithms to
 look similar to Rythmos.
\end_layout

\begin_layout Enumerate
Can we improve the situation?
\end_layout

\begin_deeper
\begin_layout Enumerate
Refactor of the current ME classes.
\end_layout

\begin_layout Enumerate
Create an adapter from the ME to the new time integrator.
\end_layout

\begin_deeper
\begin_layout Itemize
Some packages are already doing this (Piro (Opt), Drekar (SimOpt), ROL,
 ...)
\end_layout

\begin_layout Itemize
Abstract operator and vector
\end_layout

\end_deeper
\end_deeper
\end_deeper
\begin_layout Enumerate
Material Models have state!
\end_layout

\begin_deeper
\begin_layout Enumerate
Linear Visco-elastic
\end_layout

\begin_layout Enumerate
Joints and hysteresis.
\end_layout

\end_deeper
\begin_layout Subsection
PIRO
\end_layout

\begin_layout Enumerate
PIRO (Parameters In, Response Out)
\end_layout

\begin_deeper
\begin_layout Enumerate
Collection of steps of the common usage for NOX, Rythmos, LOCA, ...
\end_layout

\begin_layout Enumerate
Takes in a ME and ParameterList
\end_layout

\begin_deeper
\begin_layout Enumerate
Constructor of Rythmos time integrator
\end_layout

\begin_layout Enumerate
Passes ParameterList to Rythmos -- Solve
\end_layout

\begin_layout Enumerate
Sensitivity Analysis
\end_layout

\end_deeper
\begin_layout Enumerate
ROME for ROL and Dakota
\end_layout

\begin_layout Enumerate
PIRO has functioning second-order PDE time integrator
\end_layout

\begin_deeper
\begin_layout Enumerate
Methods
\end_layout

\begin_deeper
\begin_layout Enumerate
Newmark-
\begin_inset Formula $\beta$
\end_inset


\end_layout

\begin_layout Enumerate
Trapezoidal rule?
\end_layout

\begin_layout Enumerate
Velocity-Verlet
\end_layout

\end_deeper
\begin_layout Enumerate
Constant time step
\end_layout

\begin_layout Enumerate
No sensitivity analysis
\end_layout

\begin_layout Enumerate
EpetraEXT versions only (Ross is putting in Thyra capabilities shortly?)
\end_layout

\begin_layout Enumerate
Material model state through observe_solution
\end_layout

\begin_layout Enumerate
Can integrate energy though may still have some bugs.
\end_layout

\begin_layout Enumerate
Ability to invert mass matrix for explicit methods (IMMD - Invert Mass Matrix
 Decorator)
\begin_inset Formula 
\begin{eqnarray*}
\mbox{Albany sees}\qquad M\dot{x} & = & F(x)\\
\mbox{Rythmos sees}\qquad\dot{x} & = & M^{-1}F(x)
\end{eqnarray*}

\end_inset


\end_layout

\begin_layout Enumerate
Ability to lump
\end_layout

\end_deeper
\end_deeper
\begin_layout Subsection
Sacado
\end_layout

\end_body
\end_document
