MueLu_IndexManager_decl.hpp

Go to the documentation of this file.

// @HEADER
//
// ***********************************************************************
//
//        MueLu: A package for multigrid based preconditioning
//                  Copyright 2012 Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact
//                    Jonathan Hu        (jhu@sandia.gov)
//                    Ray Tuminaro       (rstumin@sandia.gov)
//                    Luc Berger-Vergiat (lberge@sandia.gov)
//
// ***********************************************************************
//
// @HEADER
#ifndef MUELU_INDEXMANAGER_DECL_HPP
#define MUELU_INDEXMANAGER_DECL_HPP
 
// use for Teuchos:Comm<T>
#include "Teuchos_CommHelpers.hpp"
#include "Teuchos_OrdinalTraits.hpp"
 
#include <Xpetra_Map_fwd.hpp>
 
#include "MueLu_ConfigDefs.hpp"
#include "MueLu_BaseClass.hpp"
#include "MueLu_IndexManager_fwd.hpp"
 
/*****************************************************************************
 
****************************************************************************/
 
namespace MueLu {

 
  template <class LocalOrdinal, class GlobalOrdinal, class Node>
  class IndexManager : public BaseClass {
#undef MUELU_INDEXMANAGER_SHORT
#include "MueLu_UseShortNamesOrdinal.hpp"
 
  private:
 
  protected:
 
    const RCP<const Teuchos::Comm<int> > comm_; 
    const bool coupled_;                
    const bool singleCoarsePoint_;      
    const int numDimensions;            
    const int interpolationOrder_;      
 
    Array<int> coarseRate;              
    Array<int> endRate;                 
 
    GO gNumFineNodes;                   
    GO gNumFineNodes10;                 
    const Array<GO> gFineNodesPerDir;   
 
    LO lNumFineNodes;                   
    LO lNumFineNodes10;                 
    const Array<LO> lFineNodesPerDir;   
 
    GO gNumCoarseNodes;                 
    GO gNumCoarseNodes10;               
    Array<GO> gCoarseNodesPerDir;       
 
    LO lNumCoarseNodes;                 
    LO lNumCoarseNodes10;               
    Array<LO> lCoarseNodesPerDir;       
 
    LO numGhostNodes;                   
    LO numGhostedNodes;                 
    LO numGhostedNodes10;               
    Array<LO> ghostedNodesPerDir;       
 
    GO minGlobalIndex;                  
    Array<LO> offsets;                  
    Array<LO> coarseNodeOffsets;        
    Array<GO> startIndices;             
    Array<GO> startGhostedCoarseNode;   
 
    bool meshEdge[6] =       {false};   
    bool ghostInterface[6] = {false};   
    bool ghostedDir[6] =     {false};   
 
  public:
 
    IndexManager() = default;
 
    IndexManager(const RCP<const Teuchos::Comm<int> > comm, const bool coupled,
                 const bool singleCoarsePoint, const int NumDimensions,
                 const int interpolationOrder, const Array<GO> GFineNodesPerDir,
                 const Array<LO> LFineNodesPerDir);
 
    virtual ~IndexManager() {}

    void computeMeshParameters();
 
    virtual void computeGlobalCoarseParameters() = 0;
 
    virtual void getGhostedNodesData(const RCP<const Map> fineMap,
                                     Array<LO>&  ghostedNodeCoarseLIDs,
                                     Array<int>& ghostedNodeCoarsePIDs,
                                     Array<GO>&  ghostedNodeCoarseGIDs) const = 0;
 
    virtual void getCoarseNodesData(const RCP<const Map> fineCoordinatesMap,
                                    Array<GO>& coarseNodeCoarseGIDs,
                                    Array<GO>& coarseNodeFineGIDs) const = 0;
 
    bool isAggregationCoupled() const {return coupled_;}
 
    bool isSingleCoarsePoint() const {return singleCoarsePoint_;}
 
    int getNumDimensions() const {return numDimensions;}
 
    int getInterpolationOrder() const {return interpolationOrder_;}
 
    GO getNumGlobalFineNodes() const {return gNumFineNodes;}
 
    GO getNumGlobalCoarseNodes() const {return gNumCoarseNodes;}
 
    LO getNumLocalFineNodes() const {return lNumFineNodes;}
 
    LO getNumLocalCoarseNodes() const {return lNumCoarseNodes;}
 
    LO getNumLocalGhostedNodes() const {return numGhostedNodes;}
 
    Array<int> getCoarseningRates() const {return coarseRate;}
 
    int getCoarseningRate(const int dim) const {return coarseRate[dim];}
 
    Array<int> getCoarseningEndRates() const {return endRate;}
 
    int getCoarseningEndRate(const int dim) const {return endRate[dim];}
 
    bool getMeshEdge(const int dir) const {return meshEdge[dir];}
 
    bool getGhostInterface(const int dir) const {return ghostInterface[dir];}
 
    Array<LO> getOffsets() const {return offsets;}
 
    LO getOffset(int const dim) const {return offsets[dim];}
 
    Array<LO> getCoarseNodeOffsets() const {return coarseNodeOffsets;}
 
    LO getCoarseNodeOffset(int const dim) const {return coarseNodeOffsets[dim];}
 
    Array<GO> getStartIndices() const {return startIndices;}
 
    GO getStartIndex(int const dim) const {return startIndices[dim];}
 
    Array<GO> getStartGhostedCoarseNodes() const {return startGhostedCoarseNode;}
 
    GO getStartGhostedCoarseNode(int const dim) const {return startGhostedCoarseNode[dim];}
 
    Array<LO> getLocalFineNodesPerDir() const {return lFineNodesPerDir;}
 
    LO getLocalFineNodesInDir(const int dim) const {return lFineNodesPerDir[dim];}
 
    Array<GO> getGlobalFineNodesPerDir() const {return gFineNodesPerDir;}
 
    GO getGlobalFineNodesInDir(const int dim) const {return gFineNodesPerDir[dim];}
 
    Array<LO> getLocalCoarseNodesPerDir() const {return lCoarseNodesPerDir;}
 
    LO getLocalCoarseNodesInDir(const int dim) const {return lCoarseNodesPerDir[dim];}
 
    Array<GO> getGlobalCoarseNodesPerDir() const {return gCoarseNodesPerDir;}
 
    GO getGlobalCoarseNodesInDir(const int dim) const {return gCoarseNodesPerDir[dim];}
 
    Array<LO> getGhostedNodesPerDir() const {return ghostedNodesPerDir;}
 
    LO getGhostedNodesInDir(const int dim) const {return ghostedNodesPerDir[dim];}
 
    virtual std::vector<std::vector<GO> > getCoarseMeshData() const = 0;
 
    virtual void getFineNodeGlobalTuple(const GO myGID, GO& i, GO& j, GO& k) const = 0;
 
    virtual void getFineNodeLocalTuple(const LO myLID, LO& i, LO& j, LO& k) const = 0;
 
    virtual void getFineNodeGhostedTuple(const LO myLID, LO& i, LO& j, LO& k) const = 0;
 
    virtual void getFineNodeGID(const GO i, const GO j, const GO k, GO& myGID) const = 0;
 
    virtual void getFineNodeLID(const LO i, const LO j, const LO k, LO& myLID) const = 0;
 
    virtual void getCoarseNodeGlobalTuple(const GO myGID, GO& i, GO& j, GO& k) const = 0;
 
    virtual void getCoarseNodeLocalTuple(const LO myLID, LO& i, LO& j, LO& k) const = 0;
 
    virtual void getCoarseNodeGID(const GO i, const GO j, const GO k, GO& myGID) const = 0;
 
    virtual void getCoarseNodeLID(const LO i, const LO j, const LO k, LO& myLID) const = 0;
 
    virtual void getCoarseNodeGhostedLID(const LO i, const LO j, const LO k, LO& myLID) const = 0;
 
    virtual void getCoarseNodeFineLID(const LO i, const LO j, const LO k, LO& myLID) const = 0;
 
    virtual void getGhostedNodeFineLID(const LO i, const LO j, const LO k, LO& myLID) const = 0;
 
    virtual void getGhostedNodeCoarseLID(const LO i, const LO j, const LO k, LO& myLID) const = 0;
 
  };
 
} //namespace MueLu
 
#define MUELU_INDEXMANAGER_SHORT
#endif // MUELU_INDEXMANAGER_DECL_HPP