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 <Xpetra_Vector_fwd.hpp>
#include <Xpetra_VectorFactory_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 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 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_;}

    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