diff_physics.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2019 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 
 
#ifndef LIBMESH_DIFF_PHYSICS_H
#define LIBMESH_DIFF_PHYSICS_H
 
// Local Includes
#include "libmesh/libmesh.h"
 
// C++ includes
#include <map>
#include <memory>
#include <set>
#include <vector>
 
namespace libMesh
{
 
// Forward Declarations
class System;
class DiffContext;
 
class DifferentiablePhysics
{
public:
 
  DifferentiablePhysics () :
    compute_internal_sides (false),
    _mesh_sys              (nullptr),
    _mesh_x_var            (libMesh::invalid_uint),
    _mesh_y_var            (libMesh::invalid_uint),
    _mesh_z_var            (libMesh::invalid_uint)
  {}
 
  virtual ~DifferentiablePhysics ();
 
  virtual std::unique_ptr<DifferentiablePhysics> clone_physics() = 0;
 
  virtual void clear_physics ();
 
  virtual void init_physics (const System & sys);
 
  virtual bool element_time_derivative (bool request_jacobian,
                                        DiffContext &) {
    return request_jacobian;
  }
 
  virtual bool element_constraint (bool request_jacobian,
                                   DiffContext &) {
    return request_jacobian;
  }
 
  bool compute_internal_sides;
 
  virtual bool side_time_derivative (bool request_jacobian,
                                     DiffContext &) {
    return request_jacobian;
  }
 
  virtual bool side_constraint (bool request_jacobian,
                                DiffContext &) {
    return request_jacobian;
  }
 
  virtual bool nonlocal_time_derivative (bool request_jacobian,
                                         DiffContext &) {
    return request_jacobian;
  }
 
  virtual bool nonlocal_constraint (bool request_jacobian,
                                    DiffContext &) {
    return request_jacobian;
  }
 
 
#ifdef LIBMESH_ENABLE_DEPRECATED
  virtual void time_evolving (unsigned int var)
  {
    libmesh_deprecated();
    this->time_evolving(var,1);
  }
#endif
 
  virtual void time_evolving (unsigned int var, unsigned int order);
 
  bool is_time_evolving (unsigned int var) const
  {
    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];
  }
 
  virtual bool eulerian_residual (bool request_jacobian,
                                  DiffContext &) {
    return request_jacobian;
  }
 
  virtual bool mass_residual (bool request_jacobian,
                              DiffContext &) {
    return request_jacobian;
  }
 
  virtual bool side_mass_residual (bool request_jacobian,
                                   DiffContext &) {
    return request_jacobian;
  }
 
  virtual bool nonlocal_mass_residual (bool request_jacobian,
                                       DiffContext & c);
 
  virtual bool damping_residual (bool request_jacobian,
                                 DiffContext &) {
    return request_jacobian;
  }
 
  virtual bool side_damping_residual (bool request_jacobian,
                                      DiffContext &) {
    return request_jacobian;
  }
 
  virtual bool nonlocal_damping_residual (bool request_jacobian,
                                          DiffContext &) {
    return request_jacobian;
  }
 
  /*
   * Prepares the result of a build_context() call for use.
   *
   * Most FEMSystem-based problems will need to reimplement this in order to
   * call FE::get_*() as their particular physics requires.
   */
  virtual void init_context(DiffContext &) {}
 
  virtual void set_mesh_system(System * sys);
 
  const System * get_mesh_system() const;
 
  System * get_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
  { return !_first_order_vars.empty(); }
 
  const std::set<unsigned int> & get_first_order_vars() const
  { return _first_order_vars; }
 
  bool is_first_order_var( unsigned int var ) const
  { return _first_order_vars.find(var) != _first_order_vars.end(); }
 
 
  bool have_second_order_vars() const
  { return !_second_order_vars.empty(); }
 
  const std::set<unsigned int> & get_second_order_vars() const
  { return _second_order_vars; }
 
  bool is_second_order_var( unsigned int var ) const
  { return _second_order_vars.find(var) != _second_order_vars.end(); }
 
 
protected:
 
  System * _mesh_sys;
 
  unsigned int _mesh_x_var, _mesh_y_var, _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;
 
};
 
// ------------------------------------------------------------
// DifferentiablePhysics inline methods
 
 
inline
void DifferentiablePhysics::set_mesh_system(System * sys)
{
  // 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;
}
 
 
 
inline
void DifferentiablePhysics::set_mesh_x_var (unsigned int var)
{
  _mesh_x_var = var;
}
 
 
 
inline
void DifferentiablePhysics::set_mesh_y_var (unsigned int var)
{
  _mesh_y_var = var;
}
 
 
 
inline
void DifferentiablePhysics::set_mesh_z_var (unsigned int var)
{
  _mesh_z_var = var;
}
 
 
 
inline
const System * DifferentiablePhysics::get_mesh_system() const
{
  return _mesh_sys;
}
 
inline
System * DifferentiablePhysics::get_mesh_system()
{
  return _mesh_sys;
}
 
inline
unsigned int DifferentiablePhysics::get_mesh_x_var() const
{
  return _mesh_x_var;
}
 
inline
unsigned int DifferentiablePhysics::get_mesh_y_var() const
{
  return _mesh_y_var;
}
 
inline
unsigned int DifferentiablePhysics::get_mesh_z_var() const
{
  return _mesh_z_var;
}
 
 
 
} // namespace libMesh
 
 
#endif // LIBMESH_DIFF_PHYSICS_H