diff_system.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_SYSTEM_H
#define LIBMESH_DIFF_SYSTEM_H

// Local Includes
#include "libmesh/auto_ptr.h" // deprecated
#include "libmesh/diff_context.h"
#include "libmesh/diff_physics.h"
#include "libmesh/diff_qoi.h"
#include "libmesh/implicit_system.h"
#include "libmesh/time_solver.h"

// C++ includes
#include <memory>

namespace libMesh
{

// Forward Declarations
class TimeSolver;

template <typename T> class NumericVector;

class DifferentiableSystem : public ImplicitSystem,
                             public virtual DifferentiablePhysics,
                             public virtual DifferentiableQoI
{
public:

  DifferentiableSystem (EquationSystems & es,
                        const std::string & name,
                        const unsigned int number);

  virtual ~DifferentiableSystem ();

  typedef DifferentiableSystem sys_type;

  typedef ImplicitSystem Parent;

  virtual void clear () override;

  virtual void reinit () override;

  virtual void assemble () override;

  virtual LinearSolver<Number> * get_linear_solver() const override;

  virtual std::pair<unsigned int, Real>
  get_linear_solve_parameters() const override;

  virtual void release_linear_solver(LinearSolver<Number> *) const override;

  virtual void assembly (bool get_residual,
                         bool get_jacobian,
                         bool apply_heterogeneous_constraints = false,
                         bool apply_no_constraints = false) override = 0;

  virtual void solve () override;

  virtual std::pair<unsigned int, Real>
  adjoint_solve (const QoISet & qoi_indices = QoISet()) override;

  virtual std::unique_ptr<DifferentiablePhysics> clone_physics() override
  {
    libmesh_not_implemented();
    // dummy
    return std::unique_ptr<DifferentiablePhysics>(this);
  }

  virtual std::unique_ptr<DifferentiableQoI> clone() override
  {
    libmesh_not_implemented();
    // dummy
    return std::unique_ptr<DifferentiableQoI>(this);
  }

  const DifferentiablePhysics * get_physics() const
  { return this->_diff_physics; }

  DifferentiablePhysics * get_physics()
  { return this->_diff_physics; }

  void attach_physics( DifferentiablePhysics * physics_in )
  { this->_diff_physics = (physics_in->clone_physics()).release();
    this->_diff_physics->init_physics(*this);}

  void swap_physics ( DifferentiablePhysics * & swap_physics );

  const DifferentiableQoI * get_qoi() const
  { return this->diff_qoi; }

  DifferentiableQoI * get_qoi()
  { return this->diff_qoi; }

  void attach_qoi( DifferentiableQoI * qoi_in )
  { this->diff_qoi = (qoi_in->clone()).release();
    // User needs to resize qoi system qoi accordingly
    this->diff_qoi->init_qoi( this->qoi );}

  std::unique_ptr<TimeSolver> time_solver;

  void set_time_solver(std::unique_ptr<TimeSolver> _time_solver)
  {
    time_solver.reset(_time_solver.release());
  }

  TimeSolver & get_time_solver();

  const TimeSolver & get_time_solver() const;

  Real deltat;

  virtual std::unique_ptr<DiffContext> build_context();

  virtual void postprocess () {}

  virtual void element_postprocess (DiffContext &) {}

  virtual void side_postprocess (DiffContext &) {}

  unsigned int get_second_order_dot_var( unsigned int var ) const;

  bool have_first_order_scalar_vars() const;

  bool have_second_order_scalar_vars() const;

  bool postprocess_sides;

  bool print_solution_norms;

  bool print_solutions;

  bool print_residual_norms;

  bool print_residuals;

  bool print_jacobian_norms;

  bool print_jacobians;

  bool print_element_solutions;

  bool print_element_residuals;

  bool print_element_jacobians;

protected:

  DifferentiablePhysics * _diff_physics;

  DifferentiableQoI * diff_qoi;

  virtual void init_data () override;

  void add_second_order_dot_vars();

  void add_dot_var_dirichlet_bcs( unsigned int var_idx, unsigned int dot_var_idx);

};

// --------------------------------------------------------------
// DifferentiableSystem inline methods
inline
TimeSolver & DifferentiableSystem::get_time_solver()
{
  libmesh_assert(time_solver.get());
  libmesh_assert_equal_to (&(time_solver->system()), this);
  return *time_solver;
}

inline
const TimeSolver & DifferentiableSystem::get_time_solver() const
{
  libmesh_assert(time_solver.get());
  libmesh_assert_equal_to (&(time_solver->system()), this);
  return *time_solver;
}

} // namespace libMesh


#endif // LIBMESH_DIFF_SYSTEM_H