diff_system.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2026 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/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>
#include <stack>
 
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);
 
  DifferentiableSystem (const DifferentiableSystem &) = delete;
  DifferentiableSystem & operator= (const DifferentiableSystem &) = delete;
  DifferentiableSystem (DifferentiableSystem &&) = default;
  DifferentiableSystem & operator= (DifferentiableSystem &&) = delete;
  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 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 to avoid compiler warnings, not a real implementation
    return std::unique_ptr<DifferentiablePhysics>(nullptr);
  }
 
  virtual std::unique_ptr<DifferentiableQoI> clone() override
  {
    libmesh_not_implemented();
    // dummy to avoid compiler warnings, not a real implementation
    return std::unique_ptr<DifferentiableQoI>(nullptr);
  }
 
  const DifferentiablePhysics * get_physics() const
  { if (this->_diff_physics.empty())
      return this;
    return this->_diff_physics.top().get(); }
 
  DifferentiablePhysics * get_physics()
  { if (this->_diff_physics.empty())
      return this;
    return this->_diff_physics.top().get(); }
 
  void attach_physics( DifferentiablePhysics * physics_in )
  { this->_diff_physics.push(physics_in->clone_physics());
    this->_diff_physics.top()->init_physics(*this);}
 
  void push_physics ( DifferentiablePhysics & new_physics );
 
  void pop_physics ();
 
  const DifferentiableQoI * get_qoi() const
  { if (this->_diff_qoi.empty())
      return this;
    return this->_diff_qoi.top().get(); }
 
  DifferentiableQoI * get_qoi()
  { if (this->_diff_qoi.empty())
      return this;
    return this->_diff_qoi.top().get(); }
 
  void attach_qoi( DifferentiableQoI * qoi_in );
 
  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;
 
  virtual void set_constrain_in_solver(bool enable);
 
  virtual bool get_constrain_in_solver()
  {
    return _constrain_in_solver;
  }
 
protected:
 
  virtual void init_data () override;
 
  void add_second_order_dot_vars();
 
#ifdef LIBMESH_ENABLE_DIRICHLET
  void add_dot_var_dirichlet_bcs( unsigned int var_idx, unsigned int dot_var_idx);
#endif
 
  bool _constrain_in_solver;
 
private:
  std::stack<std::unique_ptr<DifferentiablePhysics>,
    std::vector<std::unique_ptr<DifferentiablePhysics>>> _diff_physics;
 
  std::stack<std::unique_ptr<DifferentiableQoI>,
    std::vector<std::unique_ptr<DifferentiableQoI>>> _diff_qoi;
};
 
// --------------------------------------------------------------
// 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