preconditioner.h

Go to the documentation of this file.

// LIC// ====================================================================
// LIC// This file forms part of oomph-lib, the object-oriented,
// LIC// multi-physics finite-element library, available
// LIC// at http://www.oomph-lib.org.
// LIC//
// LIC// Copyright (C) 2006-2022 Matthias Heil and Andrew Hazel
// LIC//
// LIC// This library is free software; you can redistribute it and/or
// LIC// modify it under the terms of the GNU Lesser General Public
// LIC// License as published by the Free Software Foundation; either
// LIC// version 2.1 of the License, or (at your option) any later version.
// LIC//
// LIC// This library is distributed in the hope that it will be useful,
// LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
// LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// LIC// Lesser General Public License for more details.
// LIC//
// LIC// You should have received a copy of the GNU Lesser General Public
// LIC// License along with this library; if not, write to the Free Software
// LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// LIC// 02110-1301  USA.
// LIC//
// LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
// LIC//
// LIC//====================================================================
// Include guards
#ifndef OOMPH_PRECONDITION_HEADER
#define OOMPH_PRECONDITION_HEADER
 
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
#include "matrices.h"
 
 
namespace oomph
{
  // Forward declaration of block preconditioners (for turn into subs.)
  template<typename MATRIX>
  class BlockPreconditioner;
 
  // Forward declaration of problem class (for obsolete setup function)
  class Problem;
 
  //=============================================================================
  //=============================================================================
  class Preconditioner : public DistributableLinearAlgebraObject
  {
  public:
    Preconditioner()
      : Silent_preconditioner_setup(false),
        Stream_pt(0),
        Matrix_pt(0),
        Comm_pt(0),
        Setup_time(0){};
 
    Preconditioner(const Preconditioner&) = delete;
 
    void operator=(const Preconditioner&) = delete;
 
    virtual ~Preconditioner() {}
 
    virtual void preconditioner_solve(const DoubleVector& r,
                                      DoubleVector& z) = 0;
 
    virtual void preconditioner_solve_transpose(const DoubleVector& r,
                                                DoubleVector& z)
    {
      // Throw an error
      throw OomphLibError("This function hasn't been implemented yet!",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
 
    void setup(DoubleMatrixBase* matrix_pt)
    {
      // Store matrix pointer
      set_matrix_pt(matrix_pt);
 
      // Extract and store communicator pointer
      DistributableLinearAlgebraObject* dist_obj_pt =
        dynamic_cast<DistributableLinearAlgebraObject*>(matrix_pt);
      if (dist_obj_pt != 0)
      {
        set_comm_pt(dist_obj_pt->distribution_pt()->communicator_pt());
      }
      else
      {
        set_comm_pt(0);
      }
 
      double setup_time_start = TimingHelpers::timer();
      setup();
      double setup_time_finish = TimingHelpers::timer();
      Setup_time = setup_time_finish - setup_time_start;
    }
 
    void setup(const Problem* problem_pt, DoubleMatrixBase* matrix_pt)
    {
      ObsoleteCode::obsolete();
      setup(matrix_pt);
    }
 
    void enable_silent_preconditioner_setup()
    {
      // Set the appropriate (silencing) boolean to true
      Silent_preconditioner_setup = true;
    } // End of enable_silent_preconditioner_setup
 
 
    void disable_silent_preconditioner_setup()
    {
      // Set the appropriate (silencing) boolean to false
      Silent_preconditioner_setup = false;
    } // End of disable_silent_preconditioner_setup
 
 
    virtual void setup() = 0;
 
    virtual void clean_up_memory() {}
 
    virtual DoubleMatrixBase* matrix_pt() const
    {
#ifdef PARANOID
      if (Matrix_pt == 0)
      {
        std::ostringstream error_msg;
        error_msg << "Matrix pointer is null.";
        throw OomphLibError(
          error_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return Matrix_pt;
    }
 
    virtual void set_matrix_pt(DoubleMatrixBase* matrix_pt)
    {
      Matrix_pt = matrix_pt;
    }
 
    virtual const OomphCommunicator* comm_pt() const
    {
      // If we are using MPI then the comm pointer should not be null.
#ifdef OOMPH_HAS_MPI
#ifdef PARANOID
      if (Comm_pt == 0)
      {
        std::ostringstream error_msg;
        error_msg << "Tried to access a null communicator pointer. This might "
                     "mean you are\n"
                  << "trying to use it in a non-parallel case. Or it might "
                     "mean you haven't\n"
                  << "set it properly.";
        throw OomphLibError(
          error_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
#endif
      return Comm_pt;
    }
 
    virtual void set_comm_pt(const OomphCommunicator* const comm_pt)
    {
      Comm_pt = comm_pt;
    }
 
    double setup_time() const
    {
      return Setup_time;
    }
 
    virtual void turn_into_subsidiary_block_preconditioner(
      BlockPreconditioner<CRDoubleMatrix>* master_block_prec_pt,
      const Vector<unsigned>& doftype_in_master_preconditioner_coarse)
    {
    }
 
    virtual void turn_into_subsidiary_block_preconditioner(
      BlockPreconditioner<CRDoubleMatrix>* master_block_prec_pt,
      const Vector<unsigned>& doftype_in_master_preconditioner_coarse,
      const Vector<Vector<unsigned>>& doftype_coarsen_map_coarse)
    {
    }
 
  protected:
    bool Silent_preconditioner_setup;
 
    std::ostream* Stream_pt;
 
  private:
    DoubleMatrixBase* Matrix_pt;
 
    const OomphCommunicator* Comm_pt;
 
    double Setup_time;
 
  }; // Preconditioner
 
 
  //=============================================================================
  //=============================================================================
  class IdentityPreconditioner : public Preconditioner
  {
  public:
    // Constructor - nothing to construct
    IdentityPreconditioner() {}
 
    IdentityPreconditioner(const IdentityPreconditioner&) = delete;
 
    void operator=(const IdentityPreconditioner&) = delete;
 
    virtual ~IdentityPreconditioner() {}
 
    virtual void setup()
    {
      // first attempt to cast to DistributableLinearAlgebraObject
      DistributableLinearAlgebraObject* dist_matrix_pt =
        dynamic_cast<DistributableLinearAlgebraObject*>(matrix_pt());
 
      // if it is a distributable matrix
      if (dist_matrix_pt != 0)
      {
        // store the distribution
        this->build_distribution(dist_matrix_pt->distribution_pt());
      }
      // else it is not a distributable matrix
      else
      {
        // # of rows in the matrix
        unsigned n_row = matrix_pt()->nrow();
 
        LinearAlgebraDistribution dist(comm_pt(), n_row, false);
        this->build_distribution(dist);
      }
    }
 
    virtual void preconditioner_solve(const DoubleVector& r, DoubleVector& z)
    {
#ifdef PARANOID
      if (*r.distribution_pt() != *this->distribution_pt())
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "The r vector must have the same distribution as the "
             "preconditioner. "
          << "(this is the same as the matrix passed to setup())";
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
      if (z.built())
      {
        if (*z.distribution_pt() != *this->distribution_pt())
        {
          std::ostringstream error_message_stream;
          error_message_stream
            << "The z vector distribution has been setup; it must have the "
            << "same distribution as the r vector (and preconditioner).";
          throw OomphLibError(error_message_stream.str(),
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
      }
#endif
 
      // apply
      z = r;
    }
 
 
    void preconditioner_solve_transpose(const DoubleVector& r, DoubleVector& z)
    {
      // Applying the preconditioner to the transposed system is exactly the
      // same as applying the preconditioner to the original system
      preconditioner_solve(r, z);
    }
  };
} // namespace oomph
 
#endif