diff_physics.h

Go to the documentation of this file.

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

// C++ includes
#include <vector>

namespace libMesh
{

// Forward Declarations
class System;
class TimeSolver;

template <typename T> class NumericVector;

// ------------------------------------------------------------
// DifferentiablePhysics class definition

class DifferentiablePhysics
{
public:

  DifferentiablePhysics () :
    compute_internal_sides (false),
    _mesh_sys              (NULL),
    _mesh_x_var            (libMesh::invalid_uint),
    _mesh_y_var            (libMesh::invalid_uint),
    _mesh_z_var            (libMesh::invalid_uint)
  {}

  virtual ~DifferentiablePhysics ();

  virtual UniquePtr<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;
  }


  virtual void time_evolving (unsigned int var) {
    if (_time_evolving.size() <= var)
      _time_evolving.resize(var+1, false);
    _time_evolving[var] = true;
  }

  bool is_time_evolving (unsigned int var) const {
    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);

  /*
   * 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&);


protected:

  System *_mesh_sys;

  unsigned int _mesh_x_var, _mesh_y_var, _mesh_z_var;

  std::vector<bool> _time_evolving;
};



// ------------------------------------------------------------
// 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