ExplicitTimeIntegrator.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "TimeIntegrator.h"
#include "MeshChangedInterface.h"
 
#include "libmesh/linear_solver.h"
#include "libmesh/preconditioner.h"
#include "libmesh/numeric_vector.h"
 
class ExplicitTimeIntegrator;
class LumpedPreconditioner;
 
template <>
InputParameters validParams<ExplicitTimeIntegrator>();
 
class ExplicitTimeIntegrator : public TimeIntegrator, public MeshChangedInterface
{
public:
  static InputParameters validParams();
 
  ExplicitTimeIntegrator(const InputParameters & parameters);
 
  virtual void initialSetup() override;
  virtual void init() override;
  virtual void preSolve() override;
  virtual void meshChanged() override;
 
protected:
  enum SolveType
  {
    CONSISTENT,
    LUMPED,
    LUMP_PRECONDITIONED
  };
 
  bool performExplicitSolve(SparseMatrix<Number> & mass_matrix);
 
  bool solveLinearSystem(SparseMatrix<Number> & mass_matrix);
 
  bool checkLinearConvergence();
 
  MooseEnum _solve_type;
 
  NumericVector<Real> & _explicit_residual;
 
  NumericVector<Real> & _solution_update;
 
  NumericVector<Real> & _mass_matrix_diag;
 
  NumericVector<Real> * _ones;
 
  TagID _Ke_time_tag;
 
  std::unique_ptr<LinearSolver<Number>> _linear_solver;
 
  std::unique_ptr<LumpedPreconditioner> _preconditioner;
 
  Real _current_time;
};
 
class LumpedPreconditioner : public Preconditioner<Real>
{
public:
  static InputParameters validParams();
 
  LumpedPreconditioner(const NumericVector<Real> & diag_inverse)
    : Preconditioner(diag_inverse.comm()), _diag_inverse(diag_inverse)
  {
  }
 
  virtual void init() override
  {
    // No more initialization needed here
    _is_initialized = true;
  }
 
  virtual void apply(const NumericVector<Real> & x, NumericVector<Real> & y) override
  {
    y.pointwise_mult(_diag_inverse, x);
  }
 
protected:
  const NumericVector<Real> & _diag_inverse;
};