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

// Local Includes
#include "libmesh/auto_ptr.h"
#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

namespace libMesh
{

// Forward Declarations
class TimeSolver;

template <typename T> class NumericVector;

// ------------------------------------------------------------
// DifferentiableSystem class definition

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

  virtual void reinit ();

  virtual void assemble ();

  virtual LinearSolver<Number> *get_linear_solver() const;

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

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

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

  virtual void solve ();

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

  virtual UniquePtr<DifferentiablePhysics> clone_physics()
  {
    libmesh_not_implemented();
    // dummy
    return UniquePtr<DifferentiablePhysics>(this);
  }

  virtual UniquePtr<DifferentiableQoI> clone()
  {
    libmesh_not_implemented();
    // dummy
    return UniquePtr<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);}

  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 );}

  UniquePtr<TimeSolver> time_solver;

  void set_time_solver(UniquePtr<TimeSolver> _time_solver)
  {
    time_solver.reset(_time_solver.release());
  }

  TimeSolver& get_time_solver();

  const TimeSolver& get_time_solver() const;

  Real deltat;

  virtual UniquePtr<DiffContext> build_context();

  virtual void postprocess (){}

  virtual void element_postprocess (DiffContext &) {}

  virtual void side_postprocess (DiffContext &) {}

  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 ();
};

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