libMesh::FEMPhysics Class Referenceabstract

#include <fem_physics.h>

Inheritance diagram for libMesh::FEMPhysics:

Public Member Functions

 FEMPhysics ()
 
virtual ~FEMPhysics ()
 
virtual bool eulerian_residual (bool request_jacobian, DiffContext &context) libmesh_override
 
virtual bool mass_residual (bool request_jacobian, DiffContext &) libmesh_override
 
virtual UniquePtr< DifferentiablePhysicsclone_physics ()=0
 
virtual void clear_physics ()
 
virtual void init_physics (const System &sys)
 
virtual bool element_time_derivative (bool request_jacobian, DiffContext &)
 
virtual bool element_constraint (bool request_jacobian, DiffContext &)
 
virtual bool side_time_derivative (bool request_jacobian, DiffContext &)
 
virtual bool side_constraint (bool request_jacobian, DiffContext &)
 
virtual bool nonlocal_time_derivative (bool request_jacobian, DiffContext &)
 
virtual bool nonlocal_constraint (bool request_jacobian, DiffContext &)
 
virtual void time_evolving (unsigned int var)
 
virtual void time_evolving (unsigned int var, unsigned int order)
 
bool is_time_evolving (unsigned int var) const
 
virtual bool side_mass_residual (bool request_jacobian, DiffContext &)
 
virtual bool nonlocal_mass_residual (bool request_jacobian, DiffContext &c)
 
virtual bool damping_residual (bool request_jacobian, DiffContext &)
 
virtual bool side_damping_residual (bool request_jacobian, DiffContext &)
 
virtual bool nonlocal_damping_residual (bool request_jacobian, DiffContext &)
 
virtual void init_context (DiffContext &)
 
virtual void set_mesh_system (System *sys)
 
const Systemget_mesh_system () const
 
Systemget_mesh_system ()
 
virtual void set_mesh_x_var (unsigned int var)
 
unsigned int get_mesh_x_var () const
 
virtual void set_mesh_y_var (unsigned int var)
 
unsigned int get_mesh_y_var () const
 
virtual void set_mesh_z_var (unsigned int var)
 
unsigned int get_mesh_z_var () const
 
bool _eulerian_time_deriv (bool request_jacobian, DiffContext &)
 
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
 

Protected Attributes

System_mesh_sys
 
unsigned int _mesh_x_var
 
unsigned int _mesh_y_var
 
unsigned int _mesh_z_var
 
std::vector< unsigned int > _time_evolving
 
std::set< unsigned int > _first_order_vars
 
std::set< unsigned int > _second_order_vars
 
std::map< unsigned int, unsigned int > _second_order_dot_vars
 

Detailed Description

This class provides a specific system class. It aims to generalize any system, linear or nonlinear, which provides both a residual and a Jacobian.

This class is part of the new DifferentiableSystem framework, which is still experimental. Users of this framework should beware of bugs and future API changes.

Author
Roy H. Stogner
Date
2012

Definition at line 45 of file fem_physics.h.

Constructor & Destructor Documentation

libMesh::FEMPhysics::FEMPhysics ( )
inline

Constructor.

Definition at line 52 of file fem_physics.h.

virtual libMesh::FEMPhysics::~FEMPhysics ( )
inlinevirtual

Destructor.

Definition at line 59 of file fem_physics.h.

References eulerian_residual(), and mass_residual().

59 {}

Member Function Documentation

bool libMesh::DifferentiablePhysics::_eulerian_time_deriv ( bool  request_jacobian,
DiffContext  
)
inherited

This method simply combines element_time_derivative() and eulerian_residual(), which makes its address useful as a pointer-to-member-function when refactoring.

Referenced by libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::NewmarkSolver::element_residual(), and libMesh::DifferentiablePhysics::init_context().

virtual void libMesh::DifferentiablePhysics::clear_physics ( )
virtualinherited

Clear any data structures associated with the physics.

Referenced by libMesh::DifferentiableSystem::clear(), and libMesh::DifferentiablePhysics::DifferentiablePhysics().

virtual UniquePtr<DifferentiablePhysics> libMesh::DifferentiablePhysics::clone_physics ( )
pure virtualinherited

Copy of this object. User should override to copy any needed state.

Implemented in libMesh::DifferentiableSystem.

Referenced by libMesh::DifferentiableSystem::attach_physics(), and libMesh::DifferentiablePhysics::DifferentiablePhysics().

virtual bool libMesh::DifferentiablePhysics::damping_residual ( bool  request_jacobian,
DiffContext  
)
inlinevirtualinherited

Subtracts a damping vector contribution on elem from elem_residual. This method is not used in first-order-in-time problems. For second-order-in-time problems, this is the $ C(u,\ddot{u})\ddot{u} $ term. This method is only called for UnsteadySolver-based 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 "do-nothing" is correct. Otherwise, this must be reimplemented.

Definition at line 372 of file diff_physics.h.

Referenced by libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), and libMesh::NewmarkSolver::element_residual().

373  {
374  return request_jacobian;
375  }
virtual bool libMesh::DifferentiablePhysics::element_constraint ( bool  request_jacobian,
DiffContext  
)
inlinevirtualinherited

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().

Definition at line 142 of file diff_physics.h.

Referenced by libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::SteadySolver::element_residual(), libMesh::NewmarkSolver::element_residual(), and libMesh::EigenTimeSolver::element_residual().

143  {
144  return request_jacobian;
145  }
virtual bool libMesh::DifferentiablePhysics::element_time_derivative ( bool  request_jacobian,
DiffContext  
)
inlinevirtualinherited

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().

Definition at line 124 of file diff_physics.h.

Referenced by libMesh::SteadySolver::element_residual(), and libMesh::EigenTimeSolver::element_residual().

125  {
126  return request_jacobian;
127  }
virtual bool libMesh::FEMPhysics::eulerian_residual ( bool  request_jacobian,
DiffContext context 
)
virtual

Adds a pseudo-convection contribution on elem to elem_residual, if the nodes of elem are being translated by a moving mesh.

This function assumes that the user's time derivative equations (except for any equations involving unknown mesh xyz coordinates themselves) are expressed in an Eulerian frame of reference, and that the user is satisfied with an unstabilized convection term. Lagrangian equations will probably require overriding eulerian_residual() with a blank function; ALE or stabilized formulations will require reimplementing eulerian_residual() entirely.

Reimplemented from libMesh::DifferentiablePhysics.

Referenced by ~FEMPhysics().

const std::set<unsigned int>& libMesh::DifferentiablePhysics::get_first_order_vars ( ) const
inlineinherited

Returns the set of first order in time variable indices. May be empty.

Definition at line 515 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_first_order_vars.

Referenced by libMesh::DifferentiableSystem::have_first_order_scalar_vars().

516  { return _first_order_vars; }
std::set< unsigned int > _first_order_vars
Definition: diff_physics.h:557
const System * libMesh::DifferentiablePhysics::get_mesh_system ( ) const
inlineinherited

Returns a const reference to the system with variables corresponding to mesh nodal coordinates, or NULL if the mesh is fixed. Useful for ALE calculations.

Definition at line 622 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_sys.

Referenced by libMesh::FEMSystem::build_context(), and libMesh::DifferentiablePhysics::init_context().

623 {
624  return _mesh_sys;
625 }
System * libMesh::DifferentiablePhysics::get_mesh_system ( )
inlineinherited

Returns a reference to the system with variables corresponding to mesh nodal coordinates, or NULL if the mesh is fixed.

Definition at line 628 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_sys.

629 {
630  return _mesh_sys;
631 }
unsigned int libMesh::DifferentiablePhysics::get_mesh_x_var ( ) const
inlineinherited

Returns the variable number corresponding to the mesh x coordinate. Useful for ALE calculations.

Definition at line 634 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_x_var.

Referenced by libMesh::FEMSystem::build_context(), and libMesh::DifferentiablePhysics::init_context().

635 {
636  return _mesh_x_var;
637 }
unsigned int libMesh::DifferentiablePhysics::get_mesh_y_var ( ) const
inlineinherited

Returns the variable number corresponding to the mesh y coordinate. Useful for ALE calculations.

Definition at line 640 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_y_var.

Referenced by libMesh::FEMSystem::build_context(), and libMesh::DifferentiablePhysics::init_context().

641 {
642  return _mesh_y_var;
643 }
unsigned int libMesh::DifferentiablePhysics::get_mesh_z_var ( ) const
inlineinherited

Returns the variable number corresponding to the mesh z coordinate. Useful for ALE calculations.

Definition at line 646 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_z_var.

Referenced by libMesh::FEMSystem::build_context(), and libMesh::DifferentiablePhysics::init_context().

647 {
648  return _mesh_z_var;
649 }
const std::set<unsigned int>& libMesh::DifferentiablePhysics::get_second_order_vars ( ) const
inlineinherited
bool libMesh::DifferentiablePhysics::have_first_order_vars ( ) const
inlineinherited

Definition at line 509 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_first_order_vars.

Referenced by libMesh::DifferentiableSystem::have_first_order_scalar_vars().

510  { return !_first_order_vars.empty(); }
std::set< unsigned int > _first_order_vars
Definition: diff_physics.h:557
bool libMesh::DifferentiablePhysics::have_second_order_vars ( ) const
inlineinherited
virtual void libMesh::DifferentiablePhysics::init_physics ( const System sys)
virtualinherited
bool libMesh::DifferentiablePhysics::is_first_order_var ( unsigned int  var) const
inlineinherited

Definition at line 518 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_first_order_vars.

519  { return _first_order_vars.find(var) != _first_order_vars.end(); }
std::set< unsigned int > _first_order_vars
Definition: diff_physics.h:557
bool libMesh::DifferentiablePhysics::is_second_order_var ( unsigned int  var) const
inlineinherited
bool libMesh::DifferentiablePhysics::is_time_evolving ( unsigned int  var) const
inlineinherited

Returns 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 275 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_time_evolving, and libMesh::libmesh_assert().

Referenced by libMesh::FEMSystem::init_context().

276  {
277  libmesh_assert_less(var,_time_evolving.size());
278  libmesh_assert( _time_evolving[var] == 0 ||
279  _time_evolving[var] == 1 ||
280  _time_evolving[var] == 2 );
281  return _time_evolving[var];
282  }
libmesh_assert(j)
std::vector< unsigned int > _time_evolving
Definition: diff_physics.h:552
virtual bool libMesh::FEMPhysics::mass_residual ( bool  request_jacobian,
DiffContext  
)
virtual

Subtracts a mass vector contribution on 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.

Many 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 will need to reimplement this themselves.

Reimplemented from libMesh::DifferentiablePhysics.

Referenced by ~FEMPhysics().

virtual bool libMesh::DifferentiablePhysics::nonlocal_constraint ( bool  request_jacobian,
DiffContext  
)
inlinevirtualinherited

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 non-tranient equations have been added.

Definition at line 227 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().

228  {
229  return request_jacobian;
230  }
virtual bool libMesh::DifferentiablePhysics::nonlocal_damping_residual ( bool  request_jacobian,
DiffContext  
)
inlinevirtualinherited

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 404 of file diff_physics.h.

Referenced by libMesh::EulerSolver::nonlocal_residual(), libMesh::Euler2Solver::nonlocal_residual(), and libMesh::NewmarkSolver::nonlocal_residual().

405  {
406  return request_jacobian;
407  }
virtual bool libMesh::DifferentiablePhysics::nonlocal_mass_residual ( bool  request_jacobian,
DiffContext c 
)
virtualinherited

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.

Referenced by libMesh::EulerSolver::nonlocal_residual(), libMesh::Euler2Solver::nonlocal_residual(), libMesh::EigenTimeSolver::nonlocal_residual(), libMesh::NewmarkSolver::nonlocal_residual(), and libMesh::DifferentiablePhysics::side_mass_residual().

virtual bool libMesh::DifferentiablePhysics::nonlocal_time_derivative ( bool  request_jacobian,
DiffContext  
)
inlinevirtualinherited

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 209 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().

210  {
211  return request_jacobian;
212  }
void libMesh::DifferentiablePhysics::set_mesh_system ( System sys)
inlinevirtualinherited

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 578 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_sys, and libMesh::sys.

Referenced by libMesh::DifferentiablePhysics::init_context().

579 {
580  // For now we assume that we're doing fully coupled mesh motion
581  // if (sys && sys != this)
582  // libmesh_not_implemented();
583 
584  // For the foreseeable future we'll assume that we keep these
585  // Systems in the same EquationSystems
586  // libmesh_assert_equal_to (&this->get_equation_systems(),
587  // &sys->get_equation_systems());
588 
589  // And for the immediate future this code may not even work
590  libmesh_experimental();
591 
592  _mesh_sys = sys;
593 }
ImplicitSystem & sys
void libMesh::DifferentiablePhysics::set_mesh_x_var ( unsigned int  var)
inlinevirtualinherited

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 598 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_x_var.

Referenced by libMesh::DifferentiablePhysics::init_context().

599 {
600  _mesh_x_var = var;
601 }
void libMesh::DifferentiablePhysics::set_mesh_y_var ( unsigned int  var)
inlinevirtualinherited

Tells the DifferentiablePhysics that variable var from the mesh system should be used to update the y coordinate of mesh nodes.

Definition at line 606 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_y_var.

Referenced by libMesh::DifferentiablePhysics::init_context().

607 {
608  _mesh_y_var = var;
609 }
void libMesh::DifferentiablePhysics::set_mesh_z_var ( unsigned int  var)
inlinevirtualinherited

Tells the DifferentiablePhysics that variable var from the mesh system should be used to update the z coordinate of mesh nodes.

Definition at line 614 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_z_var.

Referenced by libMesh::DifferentiablePhysics::init_context().

615 {
616  _mesh_z_var = var;
617 }
virtual bool libMesh::DifferentiablePhysics::side_constraint ( bool  request_jacobian,
DiffContext  
)
inlinevirtualinherited

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().

Definition at line 191 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().

192  {
193  return request_jacobian;
194  }
virtual bool libMesh::DifferentiablePhysics::side_damping_residual ( bool  request_jacobian,
DiffContext  
)
inlinevirtualinherited

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 389 of file diff_physics.h.

Referenced by libMesh::EulerSolver::side_residual(), libMesh::Euler2Solver::side_residual(), and libMesh::NewmarkSolver::side_residual().

390  {
391  return request_jacobian;
392  }
virtual bool libMesh::DifferentiablePhysics::side_mass_residual ( bool  request_jacobian,
DiffContext  
)
inlinevirtualinherited

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 333 of file diff_physics.h.

References libMesh::DifferentiablePhysics::nonlocal_mass_residual().

Referenced by libMesh::EulerSolver::side_residual(), libMesh::Euler2Solver::side_residual(), libMesh::EigenTimeSolver::side_residual(), and libMesh::NewmarkSolver::side_residual().

334  {
335  return request_jacobian;
336  }
virtual bool libMesh::DifferentiablePhysics::side_time_derivative ( bool  request_jacobian,
DiffContext  
)
inlinevirtualinherited

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().

Definition at line 171 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().

172  {
173  return request_jacobian;
174  }
virtual void libMesh::DifferentiablePhysics::time_evolving ( unsigned int  var)
inlinevirtualinherited

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 reimplment this function; however any system which reimplements mass_residual() may have to reimplement time_evolving() to prepare data structures.

This method is deprecated. Instead, use the time_evolving override and specify the order-in-time of the variable, either 1 or 2. This method assumes the variable is first order for backward compatibility.

Definition at line 248 of file diff_physics.h.

Referenced by libMesh::DifferentiableSystem::add_second_order_dot_vars().

249  {
250  libmesh_deprecated();
251  this->time_evolving(var,1);
252  }
virtual void time_evolving(unsigned int var)
Definition: diff_physics.h:248
virtual void libMesh::DifferentiablePhysics::time_evolving ( unsigned int  var,
unsigned int  order 
)
virtualinherited

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 reimplment this function; however any system which reimplements mass_residual() may have to reimplement time_evolving() to prepare data structures.

Member Data Documentation

std::set<unsigned int> libMesh::DifferentiablePhysics::_first_order_vars
protectedinherited
System* libMesh::DifferentiablePhysics::_mesh_sys
protectedinherited
unsigned int libMesh::DifferentiablePhysics::_mesh_x_var
protectedinherited
unsigned int libMesh::DifferentiablePhysics::_mesh_y_var
protectedinherited
unsigned int libMesh::DifferentiablePhysics::_mesh_z_var
protectedinherited
std::map<unsigned int,unsigned int> libMesh::DifferentiablePhysics::_second_order_dot_vars
protectedinherited

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 569 of file diff_physics.h.

Referenced by libMesh::DifferentiableSystem::add_second_order_dot_vars(), and libMesh::DifferentiableSystem::get_second_order_dot_var().

std::set<unsigned int> libMesh::DifferentiablePhysics::_second_order_vars
protectedinherited
std::vector<unsigned int> libMesh::DifferentiablePhysics::_time_evolving
protectedinherited

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 552 of file diff_physics.h.

Referenced by libMesh::DifferentiablePhysics::is_time_evolving().

bool libMesh::DifferentiablePhysics::compute_internal_sides
inherited

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 153 of file diff_physics.h.


The documentation for this class was generated from the following file: