libMesh

This class provides a specific system class. More...
#include <diff_physics.h>
Public Member Functions  
DifferentiablePhysics ()  
Constructor. More...  
virtual  ~DifferentiablePhysics () 
Destructor. More...  
virtual UniquePtr< DifferentiablePhysics >  clone_physics ()=0 
Copy of this object. More...  
virtual void  clear_physics () 
Clear any data structures associated with the physics. More...  
virtual void  init_physics (const System &sys) 
Initialize any data structures associated with the physics. More...  
virtual bool  element_time_derivative (bool request_jacobian, DiffContext &) 
Adds the time derivative contribution on elem to elem_residual. More...  
virtual bool  element_constraint (bool request_jacobian, DiffContext &) 
Adds the constraint contribution on elem to elem_residual. More...  
virtual bool  side_time_derivative (bool request_jacobian, DiffContext &) 
Adds the time derivative contribution on side of elem to elem_residual. More...  
virtual bool  side_constraint (bool request_jacobian, DiffContext &) 
Adds the constraint contribution on side of elem to elem_residual. More...  
virtual bool  nonlocal_time_derivative (bool request_jacobian, DiffContext &) 
Adds any nonlocal time derivative contributions (e.g. More...  
virtual bool  nonlocal_constraint (bool request_jacobian, DiffContext &) 
Adds any nonlocal constraint contributions (e.g. More...  
virtual void  time_evolving (unsigned int var) 
Tells the DiffSystem that variable var is evolving with respect to time. More...  
virtual void  time_evolving (unsigned int var, unsigned int order) 
Tells the DiffSystem that variable var is evolving with respect to time. More...  
bool  is_time_evolving (unsigned int var) const 
virtual bool  eulerian_residual (bool request_jacobian, DiffContext &) 
Adds a pseudoconvection contribution on elem to elem_residual, if the nodes of elem are being translated by a moving mesh. More...  
virtual bool  mass_residual (bool request_jacobian, DiffContext &) 
Subtracts a mass vector contribution on elem from elem_residual. More...  
virtual bool  side_mass_residual (bool request_jacobian, DiffContext &) 
Subtracts a mass vector contribution on side of elem from elem_residual. More...  
virtual bool  nonlocal_mass_residual (bool request_jacobian, DiffContext &c) 
Subtracts any nonlocal mass vector contributions (e.g. More...  
virtual bool  damping_residual (bool request_jacobian, DiffContext &) 
Subtracts a damping vector contribution on elem from elem_residual. More...  
virtual bool  side_damping_residual (bool request_jacobian, DiffContext &) 
Subtracts a damping vector contribution on side of elem from elem_residual. More...  
virtual bool  nonlocal_damping_residual (bool request_jacobian, DiffContext &) 
Subtracts any nonlocal damping vector contributions (e.g. More...  
virtual void  init_context (DiffContext &) 
virtual void  set_mesh_system (System *sys) 
Tells the DifferentiablePhysics that system sys contains the isoparametric Lagrangian variables which correspond to the coordinates of mesh nodes, in problems where the mesh itself is expected to move in time. More...  
const System *  get_mesh_system () const 
System *  get_mesh_system () 
virtual void  set_mesh_x_var (unsigned int var) 
Tells the DifferentiablePhysics that variable var from the mesh system should be used to update the x coordinate of mesh nodes, in problems where the mesh itself is expected to move in time. More...  
unsigned int  get_mesh_x_var () const 
virtual void  set_mesh_y_var (unsigned int var) 
Tells the DifferentiablePhysics that variable var from the mesh system should be used to update the y coordinate of mesh nodes. More...  
unsigned int  get_mesh_y_var () const 
virtual void  set_mesh_z_var (unsigned int var) 
Tells the DifferentiablePhysics that variable var from the mesh system should be used to update the z coordinate of mesh nodes. More...  
unsigned int  get_mesh_z_var () const 
bool  _eulerian_time_deriv (bool request_jacobian, DiffContext &) 
This method simply combines element_time_derivative() and eulerian_residual(), which makes its address useful as a pointertomemberfunction when refactoring. More...  
bool  have_first_order_vars () const 
const std::set< unsigned int > &  get_first_order_vars () const 
bool  is_first_order_var (unsigned int var) const 
bool  have_second_order_vars () const 
const std::set< unsigned int > &  get_second_order_vars () const 
bool  is_second_order_var (unsigned int var) const 
Public Attributes  
bool  compute_internal_sides 
compute_internal_sides is false by default, indicating that side_* computations will only be done on boundary sides. More...  
Protected Attributes  
System *  _mesh_sys 
System from which to acquire moving mesh information. More...  
unsigned int  _mesh_x_var 
Variables from which to acquire moving mesh information. More...  
unsigned int  _mesh_y_var 
unsigned int  _mesh_z_var 
std::vector< unsigned int >  _time_evolving 
Stores unsigned int to tell us which variables are evolving as first order in time (1), second order in time (2), or are not time evolving (0). More...  
std::set< unsigned int >  _first_order_vars 
Variable indices for those variables that are first order in time. More...  
std::set< unsigned int >  _second_order_vars 
Variable indices for those variables that are second order in time. More...  
std::map< unsigned int, unsigned int >  _second_order_dot_vars 
If the user adds any second order variables, then we need to also cache the map to their corresponding dot variable that will be added by this TimeSolver class. More...  
This class provides a specific system class.
It aims to generalize any system, linear or nonlinear, which provides both a residual and a Jacobian. For first order (in time) systems, the (nonlinear) residual computed at each time step is
for unsteady TimeSolver and for steady TimeSolver. is computed by element/side_time_derivative, is computed using element/side_constraint, and is computed using the mass_residual methods.
For second order (in time) systems, the (nonlinear) residual computed at each time step is
for unsteady TimeSolver and for steady TimeSolver. is computed by element/side_time_derivative, is computed using element/side_constraint, is computed using the damping_residual methods and is computed using the mass_residual methods. This is the sign convention used by the default implementation; if the method is overridden, the user can choose any selfconsistent sign convention they wish.
FEMContext provides methods for querying values of the solution , its "rate" and its "acceleration" . Furthermore, derivatives of each of these w.r.t the nonlinear iteration unknown (e.g. in EulerSolver, the solution at the next time step ) are provided through DiffContext::get_elem_solution_derivative(), DiffContext::get_elem_solution_rate_derivative(), and DiffContext::get_elem_solution_accel_derivative(). The should be incorporated into the Jacobian evaluations, if the Jacobian is being provided.
Definition at line 74 of file diff_physics.h.
libMesh::DifferentiablePhysics::DifferentiablePhysics  (  ) 
Constructor.
Optionally initializes required data structures.
Definition at line 82 of file diff_physics.h.
References clear_physics(), clone_physics(), init_physics(), libMesh::sys, and ~DifferentiablePhysics().

virtual 
Destructor.
Definition at line 26 of file diff_physics.C.
References clear_physics().
Referenced by DifferentiablePhysics().
bool libMesh::DifferentiablePhysics::_eulerian_time_deriv  (  bool  request_jacobian, 
DiffContext &  context  
) 
This method simply combines element_time_derivative() and eulerian_residual(), which makes its address useful as a pointertomemberfunction when refactoring.
Definition at line 102 of file diff_physics.C.
References element_time_derivative(), and eulerian_residual().
Referenced by libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::NewmarkSolver::element_residual(), and init_context().

virtual 
Clear any data structures associated with the physics.
Definition at line 33 of file diff_physics.C.
References _time_evolving.
Referenced by libMesh::DifferentiableSystem::clear(), DifferentiablePhysics(), and ~DifferentiablePhysics().

pure virtual 
Copy of this object.
User should override to copy any needed state.
Implemented in libMesh::DifferentiableSystem.
Referenced by libMesh::DifferentiableSystem::attach_physics(), and DifferentiablePhysics().

virtual 
Subtracts a damping vector contribution on elem
from elem_residual.
This method is not used in firstorderintime problems. For secondorderintime problems, this is the term. This method is only called for UnsteadySolverbased TimeSolvers.
If this method receives request_jacobian = true, then it should compute elem_jacobian and return true if possible. If elem_jacobian has not been computed then the method should return false.
If the problem has no damping, the default "donothing" is correct. Otherwise, this must be reimplemented.
Reimplemented in SecondOrderScalarSystemFirstOrderTimeSolverBase, and SecondOrderScalarSystemSecondOrderTimeSolverBase.
Definition at line 373 of file diff_physics.h.
Referenced by libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), and libMesh::NewmarkSolver::element_residual().

virtual 
Adds the constraint contribution on elem
to elem_residual.
If this method receives request_jacobian = true, then it should compute elem_jacobian and return true if possible. If elem_jacobian has not been computed then the method should return false.
Users may need to reimplement this for their particular PDE.
To implement the constraint 0 = G(u), the user should examine u = elem_solution and add (G(u), phi_i) to elem_residual in elem_constraint().
Reimplemented in CoupledSystem, and NavierSystem.
Definition at line 141 of file diff_physics.h.
Referenced by libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::SteadySolver::element_residual(), libMesh::EigenTimeSolver::element_residual(), and libMesh::NewmarkSolver::element_residual().

virtual 
Adds the time derivative contribution on elem
to elem_residual.
If this method receives request_jacobian = true, then it should compute elem_jacobian and return true if possible. If elem_jacobian has not been computed then the method should return false.
Users need to reimplement this for their particular PDE.
To implement the physics model du/dt = F(u), the user should examine u = elem_solution and add (F(u), phi_i) to elem_residual in elem_time_derivative().
Reimplemented in SecondOrderScalarSystemFirstOrderTimeSolverBase, FirstOrderScalarSystemBase, HeatSystem, CoupledSystem, ElasticitySystem, LaplaceSystem, CurlCurlSystem, LaplaceSystem, PoissonSystem, LaplaceSystem, LaplaceSystem, CurlCurlSystem, L2System, SolidSystem, NavierSystem, and HeatSystem.
Definition at line 123 of file diff_physics.h.
Referenced by _eulerian_time_deriv(), libMesh::SteadySolver::element_residual(), and libMesh::EigenTimeSolver::element_residual().

virtual 
Adds a pseudoconvection contribution on elem
to elem_residual, if the nodes of elem
are being translated by a moving mesh.
The library provides a basic implementation in FEMPhysics::eulerian_residual()
Reimplemented in libMesh::FEMPhysics, and SolidSystem.
Definition at line 293 of file diff_physics.h.
Referenced by _eulerian_time_deriv().
const std::set<unsigned int>& libMesh::DifferentiablePhysics::get_first_order_vars  (  )  const 
Definition at line 516 of file diff_physics.h.
References _first_order_vars.
Referenced by libMesh::DifferentiableSystem::have_first_order_scalar_vars().
const System * libMesh::DifferentiablePhysics::get_mesh_system  (  )  const 
Definition at line 623 of file diff_physics.h.
References _mesh_sys.
Referenced by libMesh::FEMSystem::build_context(), and init_context().
System * libMesh::DifferentiablePhysics::get_mesh_system  (  ) 
Definition at line 629 of file diff_physics.h.
References _mesh_sys.
unsigned int libMesh::DifferentiablePhysics::get_mesh_x_var  (  )  const 
Definition at line 635 of file diff_physics.h.
References _mesh_x_var.
Referenced by libMesh::FEMSystem::build_context(), and init_context().
unsigned int libMesh::DifferentiablePhysics::get_mesh_y_var  (  )  const 
Definition at line 641 of file diff_physics.h.
References _mesh_y_var.
Referenced by libMesh::FEMSystem::build_context(), and init_context().
unsigned int libMesh::DifferentiablePhysics::get_mesh_z_var  (  )  const 
Definition at line 647 of file diff_physics.h.
References _mesh_z_var.
Referenced by libMesh::FEMSystem::build_context(), and init_context().
const std::set<unsigned int>& libMesh::DifferentiablePhysics::get_second_order_vars  (  )  const 
Definition at line 529 of file diff_physics.h.
References _second_order_vars.
Referenced by libMesh::DifferentiableSystem::add_second_order_dot_vars(), libMesh::DiffContext::DiffContext(), libMesh::Euler2Solver::element_residual(), libMesh::DifferentiableSystem::have_second_order_scalar_vars(), and libMesh::FEMContext::pre_fe_reinit().
bool libMesh::DifferentiablePhysics::have_first_order_vars  (  )  const 
Definition at line 510 of file diff_physics.h.
References _first_order_vars.
Referenced by libMesh::DifferentiableSystem::have_first_order_scalar_vars().
bool libMesh::DifferentiablePhysics::have_second_order_vars  (  )  const 
Definition at line 523 of file diff_physics.h.
References _second_order_vars.
Referenced by libMesh::EulerSolver::element_residual(), and libMesh::DifferentiableSystem::have_second_order_scalar_vars().

virtual 
Reimplemented in libMesh::FEMSystem, HeatSystem, CoupledSystem, ElasticitySystem, LaplaceSystem, CurlCurlSystem, LaplaceSystem, PoissonSystem, LaplaceSystem, LaplaceSystem, CurlCurlSystem, L2System, SolidSystem, NavierSystem, and HeatSystem.
Definition at line 416 of file diff_physics.h.
References _eulerian_time_deriv(), get_mesh_system(), get_mesh_x_var(), get_mesh_y_var(), get_mesh_z_var(), set_mesh_system(), set_mesh_x_var(), set_mesh_y_var(), and set_mesh_z_var().

virtual 
Initialize any data structures associated with the physics.
Definition at line 40 of file diff_physics.C.
References _time_evolving, and libMesh::System::n_vars().
Referenced by libMesh::DifferentiableSystem::attach_physics(), DifferentiablePhysics(), and libMesh::DifferentiableSystem::init_data().
bool libMesh::DifferentiablePhysics::is_first_order_var  (  unsigned int  var  )  const 
Definition at line 519 of file diff_physics.h.
References _first_order_vars.
bool libMesh::DifferentiablePhysics::is_second_order_var  (  unsigned int  var  )  const 
Definition at line 532 of file diff_physics.h.
References _second_order_vars.
Referenced by libMesh::FirstOrderUnsteadySolver::compute_second_order_eqns().
bool libMesh::DifferentiablePhysics::is_time_evolving  (  unsigned int  var  )  const 
true
iff variable var
is evolving with respect to time. In general, the user's init() function should have set time_evolving() for any variables which behave like du/dt = F(u), and should not call time_evolving() for any variables which behave like 0 = G(u). Definition at line 276 of file diff_physics.h.
References _time_evolving, and libMesh::libmesh_assert().
Referenced by libMesh::FEMPhysics::eulerian_residual(), libMesh::FEMSystem::init_context(), libMesh::FEMPhysics::mass_residual(), and nonlocal_mass_residual().

virtual 
Subtracts a mass vector contribution on elem
from elem_residual.
For firstorderintime problems, this is the term. For secondorderintime problems, this is the term. This method is only called for UnsteadySolverbased TimeSolvers.
If this method receives request_jacobian = true, then it should compute elem_jacobian and return true if possible. If elem_jacobian has not been computed then the method should return false.
Many firstorderintime problems can use the reimplementation in FEMPhysics::mass_residual which subtracts (du/dt,v) for each transient variable u; users with more complicated transient problems or secondorderintime problems will need to reimplement this themselves.
Reimplemented in SecondOrderScalarSystemFirstOrderTimeSolverBase, SecondOrderScalarSystemSecondOrderTimeSolverBase, FirstOrderScalarSystemBase, libMesh::FEMPhysics, ElasticitySystem, and NavierSystem.
Definition at line 317 of file diff_physics.h.
Referenced by libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::NewmarkSolver::element_residual(), and libMesh::EigenTimeSolver::element_residual().

virtual 
Adds any nonlocal constraint contributions (e.g.
some components of constraints in scalar variable equations) to elem_residual
If this method receives request_jacobian = true, then it should also modify elem_jacobian and return true if possible. If the Jacobian changes have not been computed then the method should return false.
Users may need to reimplement this for PDEs on systems to which SCALAR variables with nontransient equations have been added.
Definition at line 226 of file diff_physics.h.
Referenced by libMesh::EulerSolver::nonlocal_residual(), libMesh::Euler2Solver::nonlocal_residual(), libMesh::SteadySolver::nonlocal_residual(), libMesh::EigenTimeSolver::nonlocal_residual(), and libMesh::NewmarkSolver::nonlocal_residual().

virtual 
Subtracts any nonlocal damping vector contributions (e.g.
any first time derivative coefficients in scalar variable equations) from elem_residual
If this method receives request_jacobian = true, then it should also modify elem_jacobian and return true if possible. If the Jacobian changes have not been computed then the method should return false.
Definition at line 405 of file diff_physics.h.
Referenced by libMesh::EulerSolver::nonlocal_residual(), libMesh::Euler2Solver::nonlocal_residual(), and libMesh::NewmarkSolver::nonlocal_residual().

virtual 
Subtracts any nonlocal mass vector contributions (e.g.
any time derivative coefficients in scalar variable equations) from elem_residual
If this method receives request_jacobian = true, then it should also modify elem_jacobian and return true if possible. If the Jacobian changes have not been computed then the method should return false.
Many problems can use the reimplementation in FEMPhysics::mass_residual which subtracts (du/dt,v) for each transient scalar variable u; users with more complicated transient scalar variable equations will need to reimplement this themselves.
Definition at line 63 of file diff_physics.C.
References libMesh::DiffContext::elem_solution_rate_derivative, libMesh::FEType::family, libMesh::DiffContext::get_dof_indices(), libMesh::DiffContext::get_elem_jacobian(), libMesh::DiffContext::get_elem_residual(), libMesh::DiffContext::get_elem_solution(), libMesh::DiffContext::get_system(), is_time_evolving(), libMesh::DiffContext::n_vars(), libMesh::SCALAR, libMesh::Variable::type(), and libMesh::System::variable().
Referenced by libMesh::EulerSolver::nonlocal_residual(), libMesh::Euler2Solver::nonlocal_residual(), libMesh::EigenTimeSolver::nonlocal_residual(), libMesh::NewmarkSolver::nonlocal_residual(), and side_mass_residual().

virtual 
Adds any nonlocal time derivative contributions (e.g.
some components of time derivatives in scalar variable equations) to elem_residual
If this method receives request_jacobian = true, then it should also modify elem_jacobian and return true if possible. If the Jacobian changes have not been computed then the method should return false.
Users may need to reimplement this for PDEs on systems to which SCALAR variables have been added.
Definition at line 208 of file diff_physics.h.
Referenced by libMesh::EulerSolver::nonlocal_residual(), libMesh::Euler2Solver::nonlocal_residual(), libMesh::SteadySolver::nonlocal_residual(), libMesh::EigenTimeSolver::nonlocal_residual(), and libMesh::NewmarkSolver::nonlocal_residual().

virtual 
Tells the DifferentiablePhysics that system sys
contains the isoparametric Lagrangian variables which correspond to the coordinates of mesh nodes, in problems where the mesh itself is expected to move in time.
The system with mesh coordinate data (which may be this
system itself, for fully coupled moving mesh problems) is currently assumed to have new (end of time step) mesh coordinates stored in solution, old (beginning of time step) mesh coordinates stored in _old_nonlinear_solution, and constant velocity motion during each time step.
Activating this function ensures that local (but not neighbor!) element geometry is correctly repositioned when evaluating element residuals.
Currently sys
must be *this
for a tightly coupled moving mesh problem or NULL to stop mesh movement; loosely coupled moving mesh problems are not implemented.
This code is experimental. "Trust but verify, and not in that order"
Definition at line 579 of file diff_physics.h.
References _mesh_sys, and libMesh::sys.
Referenced by init_context(), and SolidSystem::init_data().

virtual 
Tells the DifferentiablePhysics that variable var
from the mesh system should be used to update the x coordinate of mesh nodes, in problems where the mesh itself is expected to move in time.
The system with mesh coordinate data (which may be this system itself, for fully coupled moving mesh problems) is currently assumed to have new (end of time step) mesh coordinates stored in solution, old (beginning of time step) mesh coordinates stored in _old_nonlinear_solution, and constant velocity motion during each time step.
Activating this function ensures that local (but not neighbor!) element geometry is correctly repositioned when evaluating element residuals.
Definition at line 599 of file diff_physics.h.
References _mesh_x_var.
Referenced by init_context(), and SolidSystem::init_data().

virtual 
Tells the DifferentiablePhysics that variable var
from the mesh system should be used to update the y coordinate of mesh nodes.
Definition at line 607 of file diff_physics.h.
References _mesh_y_var.
Referenced by init_context(), and SolidSystem::init_data().

virtual 
Tells the DifferentiablePhysics that variable var
from the mesh system should be used to update the z coordinate of mesh nodes.
Definition at line 615 of file diff_physics.h.
References _mesh_z_var.
Referenced by init_context(), and SolidSystem::init_data().

virtual 
Adds the constraint contribution on side
of elem
to elem_residual.
If this method receives request_jacobian = true, then it should compute elem_jacobian and return true if possible. If elem_jacobian has not been computed then the method should return false.
Users may need to reimplement this for their particular PDE depending on the boundary conditions.
To implement a weak form of the constraint 0 = G(u), the user should examine u = elem_solution and add (G(u), phi_i) boundary integral contributions to elem_residual in side_constraint().
Reimplemented in LaplaceSystem, LaplaceSystem, LaplaceSystem, and NavierSystem.
Definition at line 190 of file diff_physics.h.
Referenced by libMesh::EulerSolver::side_residual(), libMesh::Euler2Solver::side_residual(), libMesh::SteadySolver::side_residual(), libMesh::EigenTimeSolver::side_residual(), and libMesh::NewmarkSolver::side_residual().

virtual 
Subtracts a damping vector contribution on side
of elem
from elem_residual.
If this method receives request_jacobian = true, then it should compute elem_jacobian and return true if possible. If elem_jacobian has not been computed then the method should return false.
For most problems, the default implementation of "do nothing" is correct; users with boundary conditions including first time derivatives may need to reimplement this themselves.
Definition at line 390 of file diff_physics.h.
Referenced by libMesh::EulerSolver::side_residual(), libMesh::Euler2Solver::side_residual(), and libMesh::NewmarkSolver::side_residual().

virtual 
Subtracts a mass vector contribution on side
of elem
from elem_residual.
If this method receives request_jacobian = true, then it should compute elem_jacobian and return true if possible. If elem_jacobian has not been computed then the method should return false.
For most problems, the default implementation of "do nothing" is correct; users with boundary conditions including time derivatives may need to reimplement this themselves.
Definition at line 334 of file diff_physics.h.
References nonlocal_mass_residual().
Referenced by libMesh::EulerSolver::side_residual(), libMesh::Euler2Solver::side_residual(), libMesh::EigenTimeSolver::side_residual(), and libMesh::NewmarkSolver::side_residual().

virtual 
Adds the time derivative contribution on side
of elem
to elem_residual.
If this method receives request_jacobian = true, then it should compute elem_jacobian and return true if possible. If elem_jacobian has not been computed then the method should return false.
Users may need to reimplement this for their particular PDE depending on the boundary conditions.
To implement a weak form of the source term du/dt = F(u) on sides, such as might arise in a flux boundary condition, the user should examine u = elem_solution and add (F(u), phi_i) boundary integral contributions to elem_residual in side_constraint().
Reimplemented in ElasticitySystem, CurlCurlSystem, CurlCurlSystem, and SolidSystem.
Definition at line 170 of file diff_physics.h.
Referenced by libMesh::EulerSolver::side_residual(), libMesh::Euler2Solver::side_residual(), libMesh::SteadySolver::side_residual(), libMesh::EigenTimeSolver::side_residual(), and libMesh::NewmarkSolver::side_residual().

virtual 
Tells the DiffSystem that variable var is evolving with respect to time.
In general, the user's init() function should call time_evolving() for any variables which behave like du/dt = F(u), and should not call time_evolving() for any variables which behave like 0 = G(u).
Most derived systems will not have to reimplement this function; however any system which reimplements mass_residual() may have to reimplement time_evolving() to prepare data structures.
Definition at line 248 of file diff_physics.h.
Referenced by libMesh::DifferentiableSystem::add_second_order_dot_vars(), CurlCurlSystem::init_data(), and HeatSystem::init_data().
Tells the DiffSystem that variable var is evolving with respect to time.
In general, the user's init() function should call time_evolving() with order 1 for any variables which behave like du/dt = F(u), with order 2 for any variables that behave like d^2u/dt^2 = F(u), and should not call time_evolving() for any variables which behave like 0 = G(u).
Most derived systems will not have to reimplement this function; however any system which reimplements mass_residual() may have to reimplement time_evolving() to prepare data structures.
Definition at line 46 of file diff_physics.C.
References _first_order_vars, _second_order_vars, and _time_evolving.

protected 
Variable indices for those variables that are first order in time.
Definition at line 558 of file diff_physics.h.
Referenced by get_first_order_vars(), have_first_order_vars(), is_first_order_var(), and time_evolving().

protected 
System from which to acquire moving mesh information.
Definition at line 541 of file diff_physics.h.
Referenced by libMesh::FEMPhysics::eulerian_residual(), get_mesh_system(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::mesh_position_set(), libMesh::FEMSystem::numerical_jacobian(), and set_mesh_system().

protected 
Variables from which to acquire moving mesh information.
Definition at line 546 of file diff_physics.h.
Referenced by libMesh::FEMPhysics::eulerian_residual(), get_mesh_x_var(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::numerical_jacobian(), and set_mesh_x_var().

protected 
Definition at line 546 of file diff_physics.h.
Referenced by libMesh::FEMPhysics::eulerian_residual(), get_mesh_y_var(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::numerical_jacobian(), and set_mesh_y_var().

protected 
Definition at line 546 of file diff_physics.h.
Referenced by libMesh::FEMPhysics::eulerian_residual(), get_mesh_z_var(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::numerical_jacobian(), and set_mesh_z_var().

protected 
If the user adds any second order variables, then we need to also cache the map to their corresponding dot variable that will be added by this TimeSolver class.
Definition at line 570 of file diff_physics.h.
Referenced by libMesh::DifferentiableSystem::add_second_order_dot_vars(), and libMesh::DifferentiableSystem::get_second_order_dot_var().

protected 
Variable indices for those variables that are second order in time.
Definition at line 563 of file diff_physics.h.
Referenced by get_second_order_vars(), have_second_order_vars(), is_second_order_var(), and time_evolving().

protected 
Stores unsigned int to tell us which variables are evolving as first order in time (1), second order in time (2), or are not time evolving (0).
Definition at line 553 of file diff_physics.h.
Referenced by clear_physics(), init_physics(), is_time_evolving(), and time_evolving().
bool libMesh::DifferentiablePhysics::compute_internal_sides 
compute_internal_sides
is false by default, indicating that side_* computations will only be done on boundary sides.
If compute_internal_sides is true, computations will be done on sides between elements as well.
Definition at line 152 of file diff_physics.h.