SigmaPhysics Class Reference

#include <sigma_physics.h>

Inheritance diagram for SigmaPhysics:

Public Member Functions
	SigmaPhysics ()
	SigmaPhysics (SigmaPhysics &&)=default
	SigmaPhysics (const SigmaPhysics &)=default
SigmaPhysics &	operator= (const SigmaPhysics &)=default
SigmaPhysics &	operator= (SigmaPhysics &&)=default
virtual	~SigmaPhysics ()=default
Real &	k ()
bool &	analytic_jacobians ()
virtual void	init_data (System &sys)
virtual std::unique_ptr< DifferentiablePhysics >	clone_physics () override
	Copy of this object. More...
virtual bool	eulerian_residual (bool request_jacobian, DiffContext &context) override
	Adds a pseudo-convection 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 &) override
	Subtracts a mass vector contribution on elem from elem_residual. 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_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, 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	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	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 pointer-to-member-function 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 Member Functions
virtual void	init_context (DiffContext &context) override
virtual bool	element_time_derivative (bool request_jacobian, DiffContext &context) override
	Adds the time derivative contribution on elem to elem_residual. More...

Protected Attributes
Real	_k
Number	computed_QoI [1]
std::string	_fe_family
unsigned int	_fe_order
unsigned int	T_var
bool	_analytic_jacobians
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...

Detailed Description

Definition at line 12 of file sigma_physics.h.

Constructor & Destructor Documentation

SigmaPhysics() [1/3]

SigmaPhysics::SigmaPhysics ( )

inline

Definition at line 16 of file sigma_physics.h.

: FEMPhysics() {}

SigmaPhysics() [2/3]

SigmaPhysics::SigmaPhysics ( SigmaPhysics &&  )

default

SigmaPhysics() [3/3]

SigmaPhysics::SigmaPhysics ( const SigmaPhysics &  )

default

~SigmaPhysics()

virtual SigmaPhysics::~SigmaPhysics ( )

virtualdefault

Member Function Documentation

_eulerian_time_deriv()

bool libMesh::DifferentiablePhysics::_eulerian_time_deriv ( bool  request_jacobian, DiffContext &  context  )

inherited

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

Definition at line 96 of file diff_physics.C.

References libMesh::DifferentiablePhysics::element_time_derivative(), and libMesh::DifferentiablePhysics::eulerian_residual().

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

{
  // For any problem we need time derivative terms
  request_jacobian =
    this->element_time_derivative(request_jacobian, context);

  // For a moving mesh problem we may need the pseudoconvection term too
  return this->eulerian_residual(request_jacobian, context) &&
    request_jacobian;
}

analytic_jacobians()

bool& SigmaPhysics::analytic_jacobians ( )

inline

Definition at line 26 of file sigma_physics.h.

{ return _analytic_jacobians; }

clear_physics()

void libMesh::DifferentiablePhysics::clear_physics ( )

virtualinherited

Clear any data structures associated with the physics.

Definition at line 28 of file diff_physics.C.

References libMesh::DifferentiablePhysics::_time_evolving.

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

{
  _time_evolving.resize(0);
}

clone_physics()

std::unique_ptr< DifferentiablePhysics > SigmaPhysics::clone_physics ( )

overridevirtual

Copy of this object.

User should override to copy any needed state.

Implements libMesh::DifferentiablePhysics.

Definition at line 174 of file sigma_physics.C.

{
  return std::make_unique<SigmaPhysics>(*this);
}

damping_residual()

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.

Reimplemented in SecondOrderScalarSystemFirstOrderTimeSolverBase, and SecondOrderScalarSystemSecondOrderTimeSolverBase.

Definition at line 360 of file diff_physics.h.

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

  {
    return request_jacobian;
  }

element_constraint()

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

Reimplemented in CoupledSystem, and NavierSystem.

Definition at line 144 of file diff_physics.h.

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

  {
    return request_jacobian;
  }

element_time_derivative()

bool SigmaPhysics::element_time_derivative ( bool  request_jacobian, DiffContext &    )

overrideprotectedvirtual

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 from libMesh::DifferentiablePhysics.

Definition at line 106 of file sigma_physics.C.

References _analytic_jacobians, compute_jacobian(), libMesh::Real, and T_var.

{
  bool compute_jacobian = request_jacobian && _analytic_jacobians;

  FEMContext & c = cast_ref<FEMContext &>(context);

  // First we get some references to cell-specific data that
  // will be used to assemble the linear system.
  FEBase * elem_fe = nullptr;
  c.get_element_fe(T_var, elem_fe);

  // Element Jacobian * quadrature weights for interior integration
  const std::vector<Real> & JxW = elem_fe->get_JxW();

  // Element basis functions
  const std::vector<std::vector<Real>> & phi = elem_fe->get_phi();
  const std::vector<std::vector<RealGradient>> & dphi = elem_fe->get_dphi();

  // The number of local degrees of freedom in each variable
  const unsigned int n_u_dofs = c.n_dof_indices(T_var);

  // The subvectors and submatrices we need to fill:
  DenseSubMatrix<Number> & K = c.get_elem_jacobian(T_var, T_var);
  DenseSubVector<Number> & F = c.get_elem_residual(T_var);

  // Quadrature point locations
  const std::vector<Point > & q_point = elem_fe->get_xyz();

  // Now we will build the element Jacobian and residual.
  // Constructing the residual requires the solution and its
  // gradient from the previous timestep.  This must be
  // calculated at each quadrature point by summing the
  // solution degree-of-freedom values by the appropriate
  // weight functions.
  unsigned int n_qpoints = c.get_element_qrule().n_points();

  // Conductivity
  Real sigma = 1.0;

  // Forcing function
  Real f = 1.0;

  for (unsigned int qp=0; qp != n_qpoints; qp++)
    {
      // Compute the solution gradient at the Newton iterate
      Gradient grad_T = c.interior_gradient(T_var, qp);

      // Location of the current qp
      const Real x = q_point[qp](0);

      // Spatially varying conductivity
      sigma = 0.001 + x;

      for (unsigned int i=0; i != n_u_dofs; i++)
      {
F(i) += JxW[qp] * ( ( -sigma * (grad_T * dphi[i][qp]) ) + (f * phi[i][qp]) );
      }

      if (compute_jacobian)
        for (unsigned int i=0; i != n_u_dofs; i++)
          for (unsigned int j=0; j != n_u_dofs; ++j)
            K(i,j) += JxW[qp] * -sigma * (dphi[i][qp] * dphi[j][qp]);
    } // end of the quadrature point qp-loop

  return compute_jacobian;
}

eulerian_residual()

bool libMesh::FEMPhysics::eulerian_residual ( bool  request_jacobian, DiffContext &  context  )

overridevirtualinherited

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.

Reimplemented in SolidSystem.

Definition at line 38 of file fem_physics.C.

References libMesh::DifferentiablePhysics::_mesh_sys, libMesh::DifferentiablePhysics::_mesh_x_var, libMesh::DifferentiablePhysics::_mesh_y_var, libMesh::DifferentiablePhysics::_mesh_z_var, libMesh::FEMContext::get_element_qrule(), libMesh::FEMContext::interior_gradient(), libMesh::invalid_uint, libMesh::DifferentiablePhysics::is_time_evolving(), libMesh::libmesh_assert(), libMesh::libmesh_real(), libMesh::make_range(), libMesh::DiffContext::n_vars(), and libMesh::UnsteadySolver::old_nonlinear_solution().

{
  // Only calculate a mesh movement residual if it's necessary
  if (!_mesh_sys)
    return request_jacobian;

  libmesh_not_implemented();

#if 0
  FEMContext & context = cast_ref<FEMContext &>(c);

  // This function only supports fully coupled mesh motion for now
  libmesh_assert_equal_to (_mesh_sys, this);

  unsigned int n_qpoints = (context.get_element_qrule())->n_points();

  const unsigned int n_x_dofs = (_mesh_x_var == libMesh::invalid_uint) ?
    0 : context.dof_indices_var[_mesh_x_var].size();
  const unsigned int n_y_dofs = (_mesh_y_var == libMesh::invalid_uint) ?
    0 : context.dof_indices_var[_mesh_y_var].size();
  const unsigned int n_z_dofs = (_mesh_z_var == libMesh::invalid_uint) ?
    0 : context.dof_indices_var[_mesh_z_var].size();

  const unsigned int mesh_xyz_var = n_x_dofs ? _mesh_x_var :
    (n_y_dofs ? _mesh_y_var :
     (n_z_dofs ? _mesh_z_var :
      libMesh::invalid_uint));

  // If we're our own _mesh_sys, we'd better be in charge of
  // at least one coordinate, and we'd better have the same
  // FE type for all coordinates we are in charge of
  libmesh_assert_not_equal_to (mesh_xyz_var, libMesh::invalid_uint);
  libmesh_assert(!n_x_dofs || context.element_fe_var[_mesh_x_var] ==
                 context.element_fe_var[mesh_xyz_var]);
  libmesh_assert(!n_y_dofs || context.element_fe_var[_mesh_y_var] ==
                 context.element_fe_var[mesh_xyz_var]);
  libmesh_assert(!n_z_dofs || context.element_fe_var[_mesh_z_var] ==
                 context.element_fe_var[mesh_xyz_var]);

  const std::vector<std::vector<Real>>     & psi =
    context.element_fe_var[mesh_xyz_var]->get_phi();

  for (auto var : make_range(context.n_vars()))
    {
      // Mesh motion only affects time-evolving variables
      if (this->is_time_evolving(var))
        continue;

      // The mesh coordinate variables themselves are Lagrangian,
      // not Eulerian, and no convective term is desired.
      if (/*_mesh_sys == this && */
          (var == _mesh_x_var ||
           var == _mesh_y_var ||
           var == _mesh_z_var))
        continue;

      // Some of this code currently relies on the assumption that
      // we can pull mesh coordinate data from our own system
      if (_mesh_sys != this)
        libmesh_not_implemented();

      // This residual should only be called by unsteady solvers:
      // if the mesh is steady, there's no mesh convection term!
      UnsteadySolver * unsteady;
      if (this->time_solver->is_steady())
        return request_jacobian;
      else
        unsteady = cast_ptr<UnsteadySolver*>(this->time_solver.get());

      const std::vector<Real> & JxW =
        context.element_fe_var[var]->get_JxW();

      const std::vector<std::vector<Real>> & phi =
        context.element_fe_var[var]->get_phi();

      const std::vector<std::vector<RealGradient>> & dphi =
        context.element_fe_var[var]->get_dphi();

      const unsigned int n_u_dofs = context.dof_indices_var[var].size();

      DenseSubVector<Number> & Fu = *context.elem_subresiduals[var];
      DenseSubMatrix<Number> & Kuu = *context.elem_subjacobians[var][var];

      DenseSubMatrix<Number> * Kux = n_x_dofs ?
        context.elem_subjacobians[var][_mesh_x_var] : nullptr;
      DenseSubMatrix<Number> * Kuy = n_y_dofs ?
        context.elem_subjacobians[var][_mesh_y_var] : nullptr;
      DenseSubMatrix<Number> * Kuz = n_z_dofs ?
        context.elem_subjacobians[var][_mesh_z_var] : nullptr;

      std::vector<Real> delta_x(n_x_dofs, 0.);
      std::vector<Real> delta_y(n_y_dofs, 0.);
      std::vector<Real> delta_z(n_z_dofs, 0.);

      for (unsigned int i = 0; i != n_x_dofs; ++i)
        {
          unsigned int j = context.dof_indices_var[_mesh_x_var][i];
          delta_x[i] = libmesh_real(this->current_solution(j)) -
            libmesh_real(unsteady->old_nonlinear_solution(j));
        }

      for (unsigned int i = 0; i != n_y_dofs; ++i)
        {
          unsigned int j = context.dof_indices_var[_mesh_y_var][i];
          delta_y[i] = libmesh_real(this->current_solution(j)) -
            libmesh_real(unsteady->old_nonlinear_solution(j));
        }

      for (unsigned int i = 0; i != n_z_dofs; ++i)
        {
          unsigned int j = context.dof_indices_var[_mesh_z_var][i];
          delta_z[i] = libmesh_real(this->current_solution(j)) -
            libmesh_real(unsteady->old_nonlinear_solution(j));
        }

      for (unsigned int qp = 0; qp != n_qpoints; ++qp)
        {
          Gradient grad_u = context.interior_gradient(var, qp);
          RealGradient convection(0.);

          for (unsigned int i = 0; i != n_x_dofs; ++i)
            convection(0) += delta_x[i] * psi[i][qp];
          for (unsigned int i = 0; i != n_y_dofs; ++i)
            convection(1) += delta_y[i] * psi[i][qp];
          for (unsigned int i = 0; i != n_z_dofs; ++i)
            convection(2) += delta_z[i] * psi[i][qp];

          for (unsigned int i = 0; i != n_u_dofs; ++i)
            {
              Number JxWxPhiI = JxW[qp] * phi[i][qp];
              Fu(i) += (convection * grad_u) * JxWxPhiI;
              if (request_jacobian)
                {
                  Number JxWxPhiI = JxW[qp] * phi[i][qp];
                  for (unsigned int j = 0; j != n_u_dofs; ++j)
                    Kuu(i,j) += JxWxPhiI * (convection * dphi[j][qp]);

                  Number JxWxPhiIoverDT = JxWxPhiI/this->deltat;

                  Number JxWxPhiIxDUDXoverDT = JxWxPhiIoverDT * grad_u(0);
                  for (unsigned int j = 0; j != n_x_dofs; ++j)
                    (*Kux)(i,j) += JxWxPhiIxDUDXoverDT * psi[j][qp];

                  Number JxWxPhiIxDUDYoverDT = JxWxPhiIoverDT * grad_u(1);
                  for (unsigned int j = 0; j != n_y_dofs; ++j)
                    (*Kuy)(i,j) += JxWxPhiIxDUDYoverDT * psi[j][qp];

                  Number JxWxPhiIxDUDZoverDT = JxWxPhiIoverDT * grad_u(2);
                  for (unsigned int j = 0; j != n_z_dofs; ++j)
                    (*Kuz)(i,j) += JxWxPhiIxDUDZoverDT * psi[j][qp];
                }
            }
        }
    }
#endif // 0

  return request_jacobian;
}

get_first_order_vars()

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

References libMesh::DifferentiablePhysics::_first_order_vars.

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

  { return _first_order_vars; }

get_mesh_system() [1/2]

const System * libMesh::DifferentiablePhysics::get_mesh_system ( ) const

inlineinherited

Returns

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

Definition at line 613 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_sys.

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

{
  return _mesh_sys;
}

get_mesh_system() [2/2]

System * libMesh::DifferentiablePhysics::get_mesh_system ( )

inlineinherited

Returns

A reference to the system with variables corresponding to mesh nodal coordinates, or nullptr if the mesh is fixed.

Definition at line 619 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_mesh_sys.

{
  return _mesh_sys;
}

get_mesh_x_var()

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

References libMesh::DifferentiablePhysics::_mesh_x_var.

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

{
  return _mesh_x_var;
}

get_mesh_y_var()

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

References libMesh::DifferentiablePhysics::_mesh_y_var.

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

{
  return _mesh_y_var;
}

get_mesh_z_var()

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

References libMesh::DifferentiablePhysics::_mesh_z_var.

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

{
  return _mesh_z_var;
}

get_second_order_vars()

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

inlineinherited

Returns

The set of second order in time variable indices. May be empty.

Definition at line 519 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_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().

  { return _second_order_vars; }

have_first_order_vars()

bool libMesh::DifferentiablePhysics::have_first_order_vars ( ) const

inlineinherited

Definition at line 500 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_first_order_vars.

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

  { return !_first_order_vars.empty(); }

have_second_order_vars()

bool libMesh::DifferentiablePhysics::have_second_order_vars ( ) const

inlineinherited

Definition at line 513 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_second_order_vars.

Referenced by libMesh::EulerSolver::element_residual(), and libMesh::DifferentiableSystem::have_second_order_scalar_vars().

  { return !_second_order_vars.empty(); }

init_context()

void SigmaPhysics::init_context ( DiffContext &  context )

overrideprotectedvirtual

Reimplemented from libMesh::DifferentiablePhysics.

Definition at line 63 of file sigma_physics.C.

References libMesh::NumericVector< Number >, and T_var.

{
  FEMContext & c = cast_ref<FEMContext &>(context);

  FEBase * elem_fe = nullptr;
  c.get_element_fe(T_var, elem_fe);

  // Now make sure we have requested all the data
  // we need to build the linear system.
  elem_fe->get_JxW();
  elem_fe->get_dphi();
  elem_fe->get_phi();
  elem_fe->get_xyz();

  // Don't waste time on side computations for T
  FEBase * side_fe = nullptr;
  c.get_side_fe(T_var, side_fe);
  side_fe->get_nothing();

  // We'll have a more automatic solution to preparing adjoint
  // solutions for time integration, eventually...
  if (c.is_adjoint())
    {
      // A reference to the system context is built with
      const System & sys = c.get_system();

      // Get a pointer to the adjoint solution vector
      NumericVector<Number> & adjoint_solution0 =
        const_cast<System &>(sys).get_adjoint_solution(0);

      // Add this adjoint solution to the vectors that diff context should localize
      c.add_localized_vector(adjoint_solution0, sys);

      // Get a pointer to the adjoint solution vector
      NumericVector<Number> & adjoint_solution1 =
        const_cast<System &>(sys).get_adjoint_solution(1);

      // Add this adjoint solution to the vectors that diff context should localize
      c.add_localized_vector(adjoint_solution1, sys);
    }

}

init_data()

void SigmaPhysics::init_data ( System &  sys )

virtual

Definition at line 39 of file sigma_physics.C.

References _analytic_jacobians, _k, libMesh::LAGRANGE, T_var, libMesh::DifferentiablePhysics::time_evolving(), and libMesh::zero.

{
  T_var = dynamic_cast<FEMSystem&>(sys).add_variable ("T", static_cast<Order>(1), LAGRANGE);

  GetPot infile("heat.in");
  _k = infile("k", 1.0);
  _analytic_jacobians = infile("analytic_jacobians", true);

  // The temperature is evolving, with a first order time derivative
  this->time_evolving(T_var, 1);

  ZeroFunction<Number> zero;

  ConstFunction<Number> one(1.0);

  // Dirichlet boundary conditions for the primal.
  sys.get_dof_map().add_dirichlet_boundary(DirichletBoundary ({0,1,2,3}, {T_var}, &one));

  // Set adjoint boundary conditions.
  sys.get_dof_map().add_adjoint_dirichlet_boundary(DirichletBoundary ({0,1,2,3}, {T_var}, &zero), 0);
  sys.get_dof_map().add_adjoint_dirichlet_boundary(DirichletBoundary ({0,1,2,3}, {T_var}, &zero), 1);

}

init_physics()

void libMesh::DifferentiablePhysics::init_physics ( const System &  sys )

virtualinherited

Initialize any data structures associated with the physics.

Definition at line 35 of file diff_physics.C.

References libMesh::DifferentiablePhysics::_time_evolving, and libMesh::System::n_vars().

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

{
  // give us flags for every variable that might be time evolving
  _time_evolving.resize(sys.n_vars(), false);
}

is_first_order_var()

bool libMesh::DifferentiablePhysics::is_first_order_var ( unsigned int  var ) const

inlineinherited

Definition at line 509 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_first_order_vars.

  { return _first_order_vars.find(var) != _first_order_vars.end(); }

is_second_order_var()

bool libMesh::DifferentiablePhysics::is_second_order_var ( unsigned int  var ) const

inlineinherited

Definition at line 522 of file diff_physics.h.

References libMesh::DifferentiablePhysics::_second_order_vars.

Referenced by libMesh::FirstOrderUnsteadySolver::compute_second_order_eqns().

  { return _second_order_vars.find(var) != _second_order_vars.end(); }

is_time_evolving()

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

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

Referenced by libMesh::FEMPhysics::eulerian_residual(), libMesh::FEMSystem::init_context(), libMesh::FEMPhysics::mass_residual(), and libMesh::DifferentiablePhysics::nonlocal_mass_residual().

  {
    libmesh_assert_less(var,_time_evolving.size());
    libmesh_assert( _time_evolving[var] == 0 ||
                    _time_evolving[var] == 1 ||
                    _time_evolving[var] == 2 );
    return _time_evolving[var];
  }

k()

Real& SigmaPhysics::k ( )

inline

Definition at line 25 of file sigma_physics.h.

{ return _k; }

mass_residual()

bool libMesh::FEMPhysics::mass_residual ( bool  request_jacobian, DiffContext &  c  )

overridevirtualinherited

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.

Reimplemented in SecondOrderScalarSystemFirstOrderTimeSolverBase, SecondOrderScalarSystemSecondOrderTimeSolverBase, FirstOrderScalarSystemBase, ElasticitySystem, ElasticitySystem, and NavierSystem.

Definition at line 200 of file fem_physics.C.

References libMesh::DiffContext::elem_solution_rate_derivative, libMesh::DiffContext::get_dof_indices(), libMesh::DiffContext::get_elem_jacobian(), libMesh::DiffContext::get_elem_residual(), libMesh::FEMContext::get_element_fe(), libMesh::FEMContext::get_element_qrule(), libMesh::FEAbstract::get_JxW(), libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::FEMContext::interior_rate(), libMesh::DifferentiablePhysics::is_time_evolving(), libMesh::make_range(), libMesh::QBase::n_points(), and libMesh::DiffContext::n_vars().

{
  FEMContext & context = cast_ref<FEMContext &>(c);

  unsigned int n_qpoints = context.get_element_qrule().n_points();

  for (auto var : make_range(context.n_vars()))
    {
      if (!this->is_time_evolving(var))
        continue;

      FEBase * elem_fe = nullptr;
      context.get_element_fe( var, elem_fe );

      const std::vector<Real> & JxW = elem_fe->get_JxW();

      const std::vector<std::vector<Real>> & phi = elem_fe->get_phi();

      const unsigned int n_dofs = cast_int<unsigned int>
        (context.get_dof_indices(var).size());

      DenseSubVector<Number> & Fu = context.get_elem_residual(var);
      DenseSubMatrix<Number> & Kuu = context.get_elem_jacobian( var, var );

      for (unsigned int qp = 0; qp != n_qpoints; ++qp)
        {
          Number uprime;
          context.interior_rate(var, qp, uprime);
          const Number JxWxU = JxW[qp] * uprime;
          for (unsigned int i = 0; i != n_dofs; ++i)
            {
              Fu(i) -= JxWxU * phi[i][qp];
              if (request_jacobian && context.elem_solution_rate_derivative)
                {
                  const Number JxWxPhiIxDeriv = JxW[qp] * phi[i][qp] *
                    context.elem_solution_rate_derivative;
                  Kuu(i,i) -= JxWxPhiIxDeriv * phi[i][qp];
                  for (unsigned int j = i+1; j < n_dofs; ++j)
                    {
                      const Number Kij = JxWxPhiIxDeriv * phi[j][qp];
                      Kuu(i,j) -= Kij;
                      Kuu(j,i) -= Kij;
                    }
                }
            }
        }
    }

  return request_jacobian;
}

nonlocal_constraint()

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

Definition at line 233 of file diff_physics.h.

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

  {
    return request_jacobian;
  }

nonlocal_damping_residual()

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

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

  {
    return request_jacobian;
  }

nonlocal_mass_residual()

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.

Definition at line 57 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(), libMesh::DifferentiablePhysics::is_time_evolving(), libMesh::make_range(), 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(), and libMesh::NewmarkSolver::nonlocal_residual().

{
  FEMContext & context = cast_ref<FEMContext &>(c);

  for (auto var : make_range(context.n_vars()))
    {
      if (!this->is_time_evolving(var))
        continue;

      if (c.get_system().variable(var).type().family != SCALAR)
        continue;

      const std::vector<dof_id_type> & dof_indices =
        context.get_dof_indices(var);

      const unsigned int n_dofs = cast_int<unsigned int>
        (dof_indices.size());

      DenseSubVector<Number> & Fs = context.get_elem_residual(var);
      DenseSubMatrix<Number> & Kss = context.get_elem_jacobian( var, var );

      const libMesh::DenseSubVector<libMesh::Number> & Us =
        context.get_elem_solution(var);

      for (unsigned int i=0; i != n_dofs; ++i)
        {
          Fs(i) -= Us(i);

          if (request_jacobian)
            Kss(i,i) -= context.elem_solution_rate_derivative;
        }
    }

  return request_jacobian;
}

nonlocal_time_derivative()

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

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

  {
    return request_jacobian;
  }

operator=() [1/2]

SigmaPhysics& SigmaPhysics::operator= ( const SigmaPhysics &  )

default

operator=() [2/2]

SigmaPhysics& SigmaPhysics::operator= ( SigmaPhysics &&  )

default

set_mesh_system()

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

References libMesh::DifferentiablePhysics::_mesh_sys.

Referenced by SolidSystem::init_data().

{
  // For now we assume that we're doing fully coupled mesh motion
  //  if (sys && sys != this)
  //    libmesh_not_implemented();

  // For the foreseeable future we'll assume that we keep these
  // Systems in the same EquationSystems
  // libmesh_assert_equal_to (&this->get_equation_systems(),
  //                          &sys->get_equation_systems());

  // And for the immediate future this code may not even work
  libmesh_experimental();

  _mesh_sys = sys;
}

set_mesh_x_var()

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

References libMesh::DifferentiablePhysics::_mesh_x_var.

Referenced by SolidSystem::init_data().

{
  _mesh_x_var = var;
}

set_mesh_y_var()

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

References libMesh::DifferentiablePhysics::_mesh_y_var.

Referenced by SolidSystem::init_data().

{
  _mesh_y_var = var;
}

set_mesh_z_var()

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

References libMesh::DifferentiablePhysics::_mesh_z_var.

Referenced by SolidSystem::init_data().

{
  _mesh_z_var = var;
}

side_constraint()

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

Reimplemented in LaplaceSystem, LaplaceSystem, LaplaceSystem, and NavierSystem.

Definition at line 195 of file diff_physics.h.

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

  {
    return request_jacobian;
  }

side_damping_residual()

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

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

  {
    return request_jacobian;
  }

side_mass_residual()

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

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

  {
    return request_jacobian;
  }

side_time_derivative()

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

Reimplemented in ElasticitySystem, ElasticitySystem, CurlCurlSystem, CurlCurlSystem, and SolidSystem.

Definition at line 174 of file diff_physics.h.

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

  {
    return request_jacobian;
  }

time_evolving()

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

Definition at line 41 of file diff_physics.C.

References libMesh::DifferentiablePhysics::_first_order_vars, libMesh::DifferentiablePhysics::_second_order_vars, and libMesh::DifferentiablePhysics::_time_evolving.

Referenced by libMesh::DifferentiableSystem::add_second_order_dot_vars(), init_data(), CurlCurlSystem::init_data(), and HeatSystem::init_data().

{
  libmesh_error_msg_if(order != 1 && order != 2, "Input order must be 1 or 2!");

  if (_time_evolving.size() <= var)
    _time_evolving.resize(var+1, 0);

  _time_evolving[var] = order;

  if (order == 1)
    _first_order_vars.insert(var);
  else
    _second_order_vars.insert(var);
}

Member Data Documentation

_analytic_jacobians

bool SigmaPhysics::_analytic_jacobians

protected

Definition at line 57 of file sigma_physics.h.

Referenced by element_time_derivative(), and init_data().

_fe_family

std::string SigmaPhysics::_fe_family

protected

Definition at line 50 of file sigma_physics.h.

_fe_order

unsigned int SigmaPhysics::_fe_order

protected

Definition at line 51 of file sigma_physics.h.

_first_order_vars

std::set<unsigned int> libMesh::DifferentiablePhysics::_first_order_vars

protectedinherited

Variable indices for those variables that are first order in time.

Definition at line 548 of file diff_physics.h.

Referenced by libMesh::DifferentiablePhysics::get_first_order_vars(), libMesh::DifferentiablePhysics::have_first_order_vars(), libMesh::DifferentiablePhysics::is_first_order_var(), and libMesh::DifferentiablePhysics::time_evolving().

_k

Real SigmaPhysics::_k

protected

Definition at line 44 of file sigma_physics.h.

Referenced by init_data().

_mesh_sys

System* libMesh::DifferentiablePhysics::_mesh_sys

protectedinherited

System from which to acquire moving mesh information.

Definition at line 531 of file diff_physics.h.

Referenced by libMesh::FEMPhysics::eulerian_residual(), libMesh::DifferentiablePhysics::get_mesh_system(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::mesh_position_set(), libMesh::FEMSystem::numerical_jacobian(), and libMesh::DifferentiablePhysics::set_mesh_system().

_mesh_x_var

unsigned int libMesh::DifferentiablePhysics::_mesh_x_var

protectedinherited

Variables from which to acquire moving mesh information.

Definition at line 536 of file diff_physics.h.

Referenced by libMesh::FEMPhysics::eulerian_residual(), libMesh::DifferentiablePhysics::get_mesh_x_var(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::numerical_jacobian(), and libMesh::DifferentiablePhysics::set_mesh_x_var().

_mesh_y_var

unsigned int libMesh::DifferentiablePhysics::_mesh_y_var

protectedinherited

Definition at line 536 of file diff_physics.h.

Referenced by libMesh::FEMPhysics::eulerian_residual(), libMesh::DifferentiablePhysics::get_mesh_y_var(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::numerical_jacobian(), and libMesh::DifferentiablePhysics::set_mesh_y_var().

_mesh_z_var

unsigned int libMesh::DifferentiablePhysics::_mesh_z_var

protectedinherited

Definition at line 536 of file diff_physics.h.

Referenced by libMesh::FEMPhysics::eulerian_residual(), libMesh::DifferentiablePhysics::get_mesh_z_var(), libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::numerical_jacobian(), and libMesh::DifferentiablePhysics::set_mesh_z_var().

_second_order_dot_vars

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

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

_second_order_vars

std::set<unsigned int> libMesh::DifferentiablePhysics::_second_order_vars

protectedinherited

Variable indices for those variables that are second order in time.

Definition at line 553 of file diff_physics.h.

Referenced by libMesh::DifferentiablePhysics::get_second_order_vars(), libMesh::DifferentiablePhysics::have_second_order_vars(), libMesh::DifferentiablePhysics::is_second_order_var(), and libMesh::DifferentiablePhysics::time_evolving().

_time_evolving

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

Referenced by libMesh::DifferentiablePhysics::clear_physics(), libMesh::DifferentiablePhysics::init_physics(), libMesh::DifferentiablePhysics::is_time_evolving(), and libMesh::DifferentiablePhysics::time_evolving().

compute_internal_sides

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

computed_QoI

Number SigmaPhysics::computed_QoI[1]

protected

Definition at line 47 of file sigma_physics.h.

T_var

unsigned int SigmaPhysics::T_var

protected

Definition at line 54 of file sigma_physics.h.

Referenced by element_time_derivative(), init_context(), and init_data().

---

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

• examples/adjoints/adjoints_ex7/sigma_physics.h
• examples/adjoints/adjoints_ex7/sigma_physics.C