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