MsrsbLevelBuilder.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_MSRSBSTRATEGY_HPP
#define GEOS_LINEARALGEBRA_MULTISCALE_MSRSBSTRATEGY_HPP
 
#include "linearAlgebra/common/PreconditionerBase.hpp"
#include "linearAlgebra/multiscale/mesh/DofManager.hpp"
#include "linearAlgebra/multiscale/mesh/MeshLevel.hpp"
#include "linearAlgebra/multiscale/msrsb/MsrsbLevelBuilderBase.hpp"
 
namespace geos
{
namespace multiscale
{
 
template< typename LAI >
class MsrsbLevelBuilder : public MsrsbLevelBuilderBase< LAI >
{
public:
 
  using Base = MsrsbLevelBuilderBase< LAI >;
 
  using Vector = typename Base::Vector;
 
  using Matrix = typename Base::Matrix;
 
  explicit MsrsbLevelBuilder( string name, LinearSolverParameters params );
 
  virtual void initializeFineLevel( DomainPartition & domain,
                                    geos::DofManager const & dofManager,
                                    MPI_Comm const & comm ) override;
 
  virtual void initializeCoarseLevel( LevelBuilderBase< LAI > & fineLevel,
                                      Matrix const & fineMatrix ) override;
 
  multiscale::MeshLevel & mesh()       { return m_mesh; }
 
  multiscale::MeshLevel const & mesh() const { return m_mesh; }
 
  multiscale::MeshObjectManager & manager()
  {
    return m_location == FieldLocation::Node ? m_mesh.nodeManager() : m_mesh.cellManager();
  }
 
  multiscale::MeshObjectManager const & manager() const
  {
    return m_location == FieldLocation::Node ? m_mesh.nodeManager() : m_mesh.cellManager();
  }
 
  integer numComp() const { return m_dofManager.numComponents(); }
 
  virtual bool updateProlongation( Matrix const & fineMatrix ) override;
 
  virtual std::unique_ptr< PreconditionerBase< LAI > > makeCoarseSolver() const override;
 
private:
 
  void createSmoothers();
 
  void writeProlongationForDebug() const;
 
  using Base::m_params;
  using Base::m_name;
  using Base::m_prolongation;
  using Base::m_restriction;
  using Base::m_matrix;
  using Base::m_dofManager;
  using Base::m_preSmoother;
  using Base::m_postSmoother;
  using Base::m_fineLevel;
 
  FieldLocation m_location = FieldLocation::Node;
 
  multiscale::MeshLevel m_mesh;
 
  array1d< globalIndex > m_boundaryDof;
 
  array1d< globalIndex > m_interiorDof;
 
  integer m_lastNumIter = std::numeric_limits< integer >::max();
 
  integer m_updateLag = 0;
};
 
} // namespace multiscale
} // namespace geos
 
#endif //GEOS_LINEARALGEBRA_MULTISCALE_MSRSBSTRATEGY_HPP