ProcessGrid.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2017 - 2019 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dftefeProcessGrid_h
#define dftefeProcessGrid_h
 
#include <utils/MPIWrapper.h>
 
namespace dftefe
{
  namespace linearAlgebra
  {
    // Forward declaration of class ScaLAPACKMatrix for ProcessGrid
    // template <typename NumberType>
    // class ScaLAPACKMatrix;
 
    class ProcessGrid
    {
    public:
      // // Declare class ScaLAPACK as friend to provide access to private
      // members. template <typename NumberType> friend class ScaLAPACKMatrix;
 
      ProcessGrid(const utils::mpi::MPIComm &mpi_communicator,
                  const unsigned int         n_rows,
                  const unsigned int         n_columns);
 
      ProcessGrid(const utils::mpi::MPIComm &mpi_communicator,
                  const unsigned int         n_rows_matrix,
                  const unsigned int         n_columns_matrix,
                  const unsigned int         row_block_size,
                  const unsigned int         column_block_size);
 
      ~ProcessGrid();
 
      const int &
      get_blacs_context() const;
 
 
      const int &
      get_process_grid_rows() const;
 
      const int &
      get_process_grid_columns() const;
 
      const int &
      get_this_process_row() const;
 
      const int &
      get_this_process_column() const;
 
      template <typename NumberType>
      void
      send_to_inactive(NumberType *value, const int count = 1) const;
 
      const bool &
      is_process_active() const;
 
      const utils::mpi::MPIComm &
      get_mpi_communicator() const;
 
    private:
      ProcessGrid(const utils::mpi::MPIComm &                  mpi_communicator,
                  const std::pair<unsigned int, unsigned int> &grid_dimensions);
 
      utils::mpi::MPIComm mpi_communicator;
 
      utils::mpi::MPIComm mpi_communicator_inactive_with_root;
 
      int blacs_context;
 
      const unsigned int this_mpi_process;
 
      const unsigned int n_mpi_processes;
 
      int n_process_rows;
 
      int n_process_columns;
 
      int this_process_row;
 
      int this_process_column;
 
      bool mpi_process_is_active;
    };
 
    /*--------------------- Inline functions --------------------------------*/
 
    inline const int &
    ProcessGrid::get_blacs_context() const
    {
      return blacs_context;
    }
 
    inline const int &
    ProcessGrid::get_process_grid_rows() const
    {
      return n_process_rows;
    }
 
    inline const int &
    ProcessGrid::get_process_grid_columns() const
    {
      return n_process_columns;
    }
 
    inline const int &
    ProcessGrid::get_this_process_row() const
    {
      return this_process_row;
    }
 
    inline const int &
    ProcessGrid::get_this_process_column() const
    {
      return this_process_column;
    }
 
    inline const bool &
    ProcessGrid::is_process_active() const
    {
      return mpi_process_is_active;
    }
 
    inline const utils::mpi::MPIComm &
    ProcessGrid::get_mpi_communicator() const
    {
      return mpi_communicator;
    }
 
  } // namespace linearAlgebra
} // end of namespace dftefe
 
#endif