MsrsbLevelBuilderBase.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2019 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2019 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2019 Total, S.A
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All right reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_LINEARALGEBRA_MULTISCALE_MSRSBLEVELBUILDERBASE_HPP
#define GEOS_LINEARALGEBRA_MULTISCALE_MSRSBLEVELBUILDERBASE_HPP
 
#include "linearAlgebra/common/PreconditionerBase.hpp"
#include "linearAlgebra/multiscale/mesh/DofManager.hpp"
#include "linearAlgebra/multiscale/mesh/MeshLevel.hpp"
#include "linearAlgebra/multiscale/LevelBuilderBase.hpp"
 
namespace geos
{
namespace multiscale
{
 
template< typename LAI >
class MsrsbLevelBuilderBase : public LevelBuilderBase< LAI >
{
public:
 
  using Base = LevelBuilderBase< LAI >;
 
  using Vector = typename Base::Vector;
 
  using Matrix = typename Base::Matrix;
 
  using Operator = typename Base::Operator;
 
  explicit MsrsbLevelBuilderBase( string name, LinearSolverParameters params );
 
  virtual Matrix const & prolongation() const override
  {
    return m_prolongation;
  }
 
  virtual Operator const & restriction() const override
  {
    return *m_restriction;
  }
 
  virtual Matrix const & matrix() const override
  {
    return m_matrix;
  }
 
  virtual PreconditionerBase< LAI > const * presmoother() const override
  {
    return m_preSmoother.get();
  }
 
  PreconditionerBase< LAI > * presmoother()
  {
    return m_preSmoother.get();
  }
 
  virtual PreconditionerBase< LAI > const * postsmoother() const override
  {
    return m_postSmoother.get();
  }
 
  PreconditionerBase< LAI > * postsmoother()
  {
    return m_postSmoother.get();
  }
 
  multiscale::DofManager & dofManager() { return m_dofManager; }
 
  multiscale::DofManager const & dofManager() const { return m_dofManager; }
 
  virtual void compute( Matrix const & fineMatrix ) override;
 
  virtual bool updateProlongation( Matrix const & fineMatrix ) = 0;
 
protected:
 
  using Base::m_params;
  using Base::m_name;
 
  MsrsbLevelBuilderBase const * m_fineLevel{};
 
  Matrix m_prolongation;
 
  std::unique_ptr< Operator > m_restriction;
 
  Matrix m_matrix;
 
  multiscale::DofManager m_dofManager;
 
  std::unique_ptr< PreconditionerBase< LAI > > m_preSmoother;
 
  std::unique_ptr< PreconditionerBase< LAI > > m_postSmoother;
};
 
} // multiscale
} // geos
 
#endif //GEOS_LINEARALGEBRA_MULTISCALE_MSRSBLEVELBUILDERBASE_HPP