preconditioner_array.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_ARRAY_HEADER
#define OOMPH_PRECONDITION_ARRAY_HEADER
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
// oomph-lib includes
#include "Vector.h"
#include "double_vector.h"
#include "matrices.h"
#include "preconditioner.h"
 
 
// Preconditioner array is only really possible and useful if we have MPI
// (and it uses a lot of MPI functions in the .cc file so changing that
// would be hard). So if we don't have MPI just define a dummy
// implementation that throws an error if you try to use it.
#ifndef OOMPH_HAS_MPI
namespace oomph
{
  class PreconditionerArray
  {
  public:
    void setup_preconditioners(Vector<CRDoubleMatrix*> matrix_pt,
                               Vector<Preconditioner*> prec_pt,
                               const OomphCommunicator* comm_pt)
    {
      throw OomphLibError("PreconditionerArray requires MPI",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
 
    void solve_preconditioners(const Vector<DoubleVector>& r,
                               Vector<DoubleVector>& z)
    {
      throw OomphLibError("PreconditionerArray requires MPI",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
  };
} // namespace oomph
 
// Otherwise (if we have MPI do the real implementation)
#else
 
#include "mpi.h"
 
 
namespace oomph
{
  //=============================================================================
  //=============================================================================
  class PreconditionerArray
  {
  public:
    PreconditionerArray()
      : Preconditioner_pt(0),
        Global_communicator_pt(0),
        Local_communicator_pt(0)
    {
      Method = 0;
      Nprec = 0;
    };
 
    PreconditionerArray(const PreconditionerArray&) = delete;
 
    void operator=(const PreconditionerArray&) = delete;
 
    ~PreconditionerArray()
    {
      this->clean_up_memory();
    }
 
    void setup_preconditioners(Vector<CRDoubleMatrix*> matrix_pt,
                               Vector<Preconditioner*> prec_pt,
                               const OomphCommunicator* comm_pt);
 
    void solve_preconditioners(const Vector<DoubleVector>& r,
                               Vector<DoubleVector>& z);
 
    void clean_up_memory()
    {
      // delete the preconditioner pt
      delete Preconditioner_pt;
      Preconditioner_pt = 0;
 
      // delete the communicators
      delete Global_communicator_pt;
      Global_communicator_pt = 0;
      delete Local_communicator_pt;
      Local_communicator_pt = 0;
 
      // clear vectors
      First_row_for_proc.clear();
      Nrow_local_for_proc.clear();
      First_row_from_proc.clear();
      Nrow_local_from_proc.clear();
      First_proc_for_prec.clear();
      Nproc_for_prec.clear();
 
      // zero
      Color = 0;
 
#ifdef PARANOID
      // delete PARANOID check distribution pts
      for (unsigned i = 0; i < Nprec; i++)
      {
        delete Distribution_pt[i];
      }
      Distribution_pt.resize(0);
#endif
    }
 
    // access function to Method
    unsigned& method()
    {
      return Method;
    }
 
  private:
    int compute_tag(const int& nproc,
                    const int& source,
                    const int& dest,
                    const int& type)
    {
      return source + (nproc * dest) + (nproc * nproc * type);
    }
 
    unsigned Nprec;
 
    Preconditioner* Preconditioner_pt;
 
    Vector<unsigned> First_proc_for_prec;
 
    Vector<unsigned> Nproc_for_prec;
 
    Vector<Vector<unsigned>> First_row_for_proc;
 
    Vector<Vector<unsigned>> Nrow_local_for_proc;
 
    Vector<Vector<unsigned>> First_row_from_proc;
 
    Vector<Vector<unsigned>> Nrow_local_from_proc;
 
    unsigned Color;
 
    OomphCommunicator* Global_communicator_pt;
 
    OomphCommunicator* Local_communicator_pt;
 
#ifdef PARANOID
    // Vector of distribution of each preconditioner - for PARANOID checks only
    Vector<LinearAlgebraDistribution*> Distribution_pt;
#endif
 
    unsigned Method;
 
  }; // PreconditionerArray
} // namespace oomph
 
// End of "if we have MPI"
#endif
 
// End of include guard
#endif