diff_physics.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2018 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"
#include "libmesh/auto_ptr.h" // deprecated

// C++ includes
#include <vector>
#include <memory>

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