MueLu_LocalLexicographicIndexManager_decl.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//        MueLu: A package for multigrid based preconditioning
//
// Copyright 2012 NTESS and the MueLu contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef MUELU_LOCALLEXICOGRAPHICINDEXMANAGER_DECL_HPP
#define MUELU_LOCALLEXICOGRAPHICINDEXMANAGER_DECL_HPP
 
// use for Teuchos:Comm<T>
#include "Teuchos_CommHelpers.hpp"
 
#include <Xpetra_Map_fwd.hpp>
 
#include "MueLu_ConfigDefs.hpp"
#include "MueLu_IndexManager.hpp"
#include "MueLu_LocalLexicographicIndexManager_fwd.hpp"
 
/*****************************************************************************
 
****************************************************************************/
 
namespace MueLu {
 
template <class LocalOrdinal, class GlobalOrdinal, class Node>
class LocalLexicographicIndexManager : public IndexManager<LocalOrdinal, GlobalOrdinal, Node> {
#undef MUELU_LOCALLEXICOGRAPHICINDEXMANAGER_SHORT
#include "MueLu_UseShortNamesOrdinal.hpp"
 
 public:
  LocalLexicographicIndexManager() = default;
 
  LocalLexicographicIndexManager(const RCP<const Teuchos::Comm<int> > comm, const bool coupled,
                                 const int NumDimensions, const int interpolationOrder,
                                 const int MyRank, const int NumRanks,
                                 const Array<GO> GFineNodesPerDir,
                                 const Array<LO> LFineNodesPerDir,
                                 const Array<LO> CoarseRate, const Array<GO> MeshData);
 
  virtual ~LocalLexicographicIndexManager() {}
 
  void computeGlobalCoarseParameters();
 
  void getGhostedNodesData(const RCP<const Map> fineMap,
                           Array<LO>& ghostedNodeCoarseLIDs,
                           Array<int>& ghostedNodeCoarsePIDs,
                           Array<GO>& ghostedNodeCoarseGIDs) const;
 
  void getCoarseNodesData(const RCP<const Map> fineCoordinatesMap,
                          Array<GO>& coarseNodeCoarseGIDs,
                          Array<GO>& coarseNodeFineGIDs) const;
 
  std::vector<std::vector<GO> > getCoarseMeshData() const;
 
  void getFineNodeGlobalTuple(const GO myGID, GO& i, GO& j, GO& k) const;
 
  void getFineNodeLocalTuple(const LO myLID, LO& i, LO& j, LO& k) const;
 
  void getFineNodeGhostedTuple(const LO myLID, LO& i, LO& j, LO& k) const;
 
  void getFineNodeGID(const GO i, const GO j, const GO k, GO& myGID) const;
 
  void getFineNodeLID(const LO i, const LO j, const LO k, LO& myLID) const;
 
  void getCoarseNodeGlobalTuple(const GO myGID, GO& i, GO& j, GO& k) const;
 
  void getCoarseNodeLocalTuple(const LO myLID, LO& i, LO& j, LO& k) const;
 
  void getCoarseNodeGID(const GO i, const GO j, const GO k, GO& myGID) const;
 
  void getCoarseNodeLID(const LO i, const LO j, const LO k, LO& myLID) const;
 
  void getCoarseNodeGhostedLID(const LO i, const LO j, const LO k, LO& myLID) const;
 
  void getCoarseNodeFineLID(const LO i, const LO j, const LO k, LO& myLID) const;
 
  void getGhostedNodeFineLID(const LO i, const LO j, const LO k, LO& myLID) const;
 
  void getGhostedNodeCoarseLID(const LO i, const LO j, const LO k, LO& myLID) const;
 
 private:
  const int myRank;    
  const int numRanks;  
 
  // Iterator delimiting the entries in meshData that correspond to the block that owns the local
  // part of the mesh.
  typename std::vector<std::vector<GO> >::iterator myBlockStart, myBlockEnd;
 
  int pi, pj, pk;  
 
  int numBlocks;  
  int myBlock;    
 
  int myRankIndex;                               
  Array<int> rankIndices;                        
  std::vector<std::vector<GO> > meshData;        
  std::vector<std::vector<GO> > coarseMeshData;  
 
  void sortLocalLexicographicData();
 
  void computeCoarseLocalLexicographicData();
 
  void getGIDLocalLexicographic(const LO iGhosted, const LO jGhosted, const LO kGhosted,
                                const Array<LO> coarseNodeFineIndices, GO& myGID, LO& myPID,
                                LO& myLID) const;
};
 
}  // namespace MueLu
 
#define MUELU_LOCALLEXICOGRAPHICINDEXMANAGER_SHORT
#endif  // MUELU_LOCALLEXICOGRAPHICINDEXMANAGER_DECL_HPP