Epetra_BlockMap.h

Go to the documentation of this file.

/*
//@HEADER
// ************************************************************************
//
//               Epetra: Linear Algebra Services Package
//                 Copyright 2011 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 Michael A. Heroux (maherou@sandia.gov)
//
// ************************************************************************
//@HEADER
*/

#ifndef EPETRA_BLOCKMAP_H
#define EPETRA_BLOCKMAP_H

#if defined(Epetra_SHOW_DEPRECATED_WARNINGS)
#ifdef __GNUC__
#warning "The Epetra package is deprecated"
#endif
#endif



#include "Epetra_ConfigDefs.h"
#include "Epetra_Object.h"
#include "Epetra_BlockMapData.h"



class EPETRA_LIB_DLL_EXPORT Epetra_BlockMap: public Epetra_Object {
  friend class Epetra_Directory;
  friend class Epetra_LocalMap;
 public:


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  Epetra_BlockMap(int NumGlobalElements, int ElementSize, int IndexBase, const Epetra_Comm& Comm);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  Epetra_BlockMap(long long NumGlobalElements, int ElementSize, int IndexBase, const Epetra_Comm& Comm);
  Epetra_BlockMap(long long NumGlobalElements, int ElementSize, long long IndexBase, const Epetra_Comm& Comm);
#endif


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  Epetra_BlockMap(int NumGlobalElements, int NumMyElements,
     int ElementSize, int IndexBase, const Epetra_Comm& Comm);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  Epetra_BlockMap(long long NumGlobalElements, int NumMyElements,
    int ElementSize, int IndexBase, const Epetra_Comm& Comm);
  Epetra_BlockMap(long long NumGlobalElements, int NumMyElements,
    int ElementSize, long long IndexBase, const Epetra_Comm& Comm);
#endif


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  Epetra_BlockMap(int NumGlobalElements, int NumMyElements,
                  const int *MyGlobalElements,
       int ElementSize, int IndexBase, const Epetra_Comm& Comm);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  Epetra_BlockMap(long long NumGlobalElements, int NumMyElements,
                  const long long *MyGlobalElements,
      int ElementSize, int IndexBase, const Epetra_Comm& Comm);
  Epetra_BlockMap(long long NumGlobalElements, int NumMyElements,
                  const long long *MyGlobalElements,
      int ElementSize, long long IndexBase, const Epetra_Comm& Comm);
#endif


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  Epetra_BlockMap(int NumGlobalElements, int NumMyElements,
                  const int *MyGlobalElements,
      const int *ElementSizeList, int IndexBase,
                  const Epetra_Comm& Comm);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  Epetra_BlockMap(long long NumGlobalElements, int NumMyElements,
                  const long long *MyGlobalElements,
      const int *ElementSizeList, int IndexBase,
                  const Epetra_Comm& Comm);
  Epetra_BlockMap(long long NumGlobalElements, int NumMyElements,
                  const long long *MyGlobalElements,
      const int *ElementSizeList, long long IndexBase,
                  const Epetra_Comm& Comm);
#endif

#if defined(EPETRA_NO_32BIT_GLOBAL_INDICES) && defined(EPETRA_NO_64BIT_GLOBAL_INDICES)
  // default implementation so that no compiler/linker error in case neither 32 nor 64
  // bit indices present.
  Epetra_BlockMap() {}
#endif

#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  Epetra_BlockMap(long long NumGlobal_Elements, int NumMy_Elements,
                  const long long * myGlobalElements,
                  int ElementSize, int indexBase,
                  const Epetra_Comm& comm,
                  bool UserIsDistributedGlobal,
                  long long UserMinAllGID, long long UserMaxAllGID);
  Epetra_BlockMap(long long NumGlobal_Elements, int NumMy_Elements,
                  const long long * myGlobalElements,
                  int ElementSize, long long indexBase,
                  const Epetra_Comm& comm,
                  bool UserIsDistributedGlobal,
                  long long UserMinAllGID, long long UserMaxAllGID);
#endif

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  Epetra_BlockMap(int NumGlobal_Elements, int NumMy_Elements,
                 const int * myGlobalElements,
                 int ElementSize, int indexBase,
                 const Epetra_Comm& comm,
                 bool UserIsDistributedGlobal,
                 int UserMinAllGID, int UserMaxAllGID);
#endif


  Epetra_BlockMap(const Epetra_BlockMap& map);

  virtual ~Epetra_BlockMap(void);



#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int RemoteIDList(int NumIDs, const int * GIDList, int * PIDList, int * LIDList) const {
    return(RemoteIDList(NumIDs, GIDList, PIDList, LIDList, 0));
  };
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int RemoteIDList(int NumIDs, const long long * GIDList, int * PIDList, int * LIDList) const {
    return(RemoteIDList(NumIDs, GIDList, PIDList, LIDList, 0));
  };
#endif


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int RemoteIDList(int NumIDs, const int * GIDList, int * PIDList, int * LIDList, int * SizeList) const;
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int RemoteIDList(int NumIDs, const long long * GIDList, int * PIDList, int * LIDList, int * SizeList) const;
#endif

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int  LID(int GID) const;
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int  LID(long long GID) const;
#endif

#if defined(EPETRA_NO_32BIT_GLOBAL_INDICES) && defined(EPETRA_NO_64BIT_GLOBAL_INDICES)
  // default implementation so that no compiler/linker error in case neither 32 nor 64
  // bit indices present.
  int  LID(long long GID) const { return -1; }
  bool MyGID(long long GID_in) const { return false; }
#endif

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int  GID(int LID) const;
#endif
  long long  GID64(int LID) const;

  int FindLocalElementID(int PointID, int & ElementID, int & ElementOffset)  const;

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  bool  MyGID(int GID_in) const {return(LID(GID_in)!=-1);};
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  bool  MyGID(long long GID_in) const {return(LID(GID_in)!=-1);};
#endif

  // bool  MyLID(int LID_in) const {return(GID64(LID_in)!=BlockMapData_->IndexBase_-1);};
  bool MyLID(int lid) const {
    if ((BlockMapData_->NumMyElements_ == 0) ||
        (lid < BlockMapData_->MinLID_) || (lid > BlockMapData_->MaxLID_)) {
      return false;
    }
    return true;
  }

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int  MinAllGID() const {
    if(GlobalIndicesInt())
      return (int) MinAllGID64();
    throw "Epetra_BlockMap::MinAllGID: GlobalIndices not int.";
  }
#endif
  long long  MinAllGID64() const {return(BlockMapData_->MinAllGID_);};

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int  MaxAllGID() const {
    if(GlobalIndicesInt())
      return (int) MaxAllGID64();
    throw "Epetra_BlockMap::MaxAllGID: GlobalIndices not int.";
  }
#endif
  long long  MaxAllGID64() const {return(BlockMapData_->MaxAllGID_);};

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int  MinMyGID() const {
    if(GlobalIndicesInt())
      return (int) MinMyGID64();
    throw "Epetra_BlockMap::MinMyGID: GlobalIndices not int.";
  }
#endif
  long long  MinMyGID64() const {return(BlockMapData_->MinMyGID_);};

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int  MaxMyGID() const {
    if(GlobalIndicesInt())
      return (int) MaxMyGID64();
    throw "Epetra_BlockMap::MaxMyGID: GlobalIndices not int.";
  }
#endif
  long long  MaxMyGID64() const {return(BlockMapData_->MaxMyGID_);};

  int  MinLID() const {return(BlockMapData_->MinLID_);};

  int  MaxLID() const {return(BlockMapData_->MaxLID_);};


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int  NumGlobalElements() const {
    if(GlobalIndicesInt())
      return (int) NumGlobalElements64();
    throw "Epetra_BlockMap::NumGlobalElements: GlobalIndices not int.";
  }
#endif
  long long  NumGlobalElements64() const {return(BlockMapData_->NumGlobalElements_);};

  int  NumMyElements() const {return(BlockMapData_->NumMyElements_);};

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int MyGlobalElements(int * MyGlobalElementList) const;
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int MyGlobalElements(long long * MyGlobalElementList) const;
#endif

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int MyGlobalElementsPtr(int *& MyGlobalElementList) const;
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int MyGlobalElementsPtr(long long *& MyGlobalElementList) const;
#endif

  int  ElementSize() const {return(BlockMapData_->ElementSize_);};

  int  ElementSize(int LID) const;


  int  FirstPointInElement(int LID) const;

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int  IndexBase() const {
    if(GlobalIndicesInt() || IndexBase64() == (long long) static_cast<int>(IndexBase64()))
      return (int) IndexBase64();
    throw "Epetra_BlockMap::IndexBase: GlobalIndices not int and IndexBase cannot fit an int.";
  }
#endif
  long long  IndexBase64() const {return(BlockMapData_->IndexBase_);};

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int  NumGlobalPoints() const {
    if(GlobalIndicesInt())
      return (int) NumGlobalPoints64();
    throw "Epetra_BlockMap::NumGlobalPoints: GlobalIndices not int.";
  }
#endif
  long long  NumGlobalPoints64() const {return(BlockMapData_->NumGlobalPoints_);};

  int  NumMyPoints() const {return(BlockMapData_->NumMyPoints_);};

  int  MinMyElementSize() const {return(BlockMapData_->MinMyElementSize_);};

  int  MaxMyElementSize() const {return(BlockMapData_->MaxMyElementSize_);};

  int  MinElementSize() const {return(BlockMapData_->MinElementSize_);};

  int  MaxElementSize() const {return(BlockMapData_->MaxElementSize_);};



  bool  UniqueGIDs() const {return(IsOneToOne());};

/*
*******************************************************************************
  Ideally GlobalIndicesInt and GlobalIndicesLongLong should be within the
  preprocessor macros and any code using them should also be within the
  corresponding macro.  However, when initially moving to 64-bit we did not
  have macros and all the code is written using run-time checks.  In future,
  the code can be converted to follow the macro system.  Hence this comment.
  -- Chetan Jhurani

  Future code:

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  bool  GlobalIndicesInt()      const { return BlockMapData_->GlobalIndicesInt_; }
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  bool  GlobalIndicesLongLong() const { return BlockMapData_->GlobalIndicesLongLong_; }
#endif
*******************************************************************************
*/

  bool  GlobalIndicesInt()      const { return BlockMapData_->GlobalIndicesInt_; }
  bool  GlobalIndicesLongLong() const { return BlockMapData_->GlobalIndicesLongLong_; }

  template<typename int_type>
  bool GlobalIndicesIsType() const;

  bool GlobalIndicesTypeValid() const { return BlockMapData_->GlobalIndicesInt_ || BlockMapData_->GlobalIndicesLongLong_; }

  bool GlobalIndicesTypeMatch(const Epetra_BlockMap& other) const
  {
    return
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
      GlobalIndicesInt() == other.GlobalIndicesInt() &&
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
      GlobalIndicesLongLong() == other.GlobalIndicesLongLong() &&
#endif
      true;
  }

  bool  ConstantElementSize() const {return(BlockMapData_->ConstantElementSize_);};

  bool SameBlockMapDataAs(const Epetra_BlockMap & Map) const;

  bool SameAs(const Epetra_BlockMap & Map) const;


  bool PointSameAs(const Epetra_BlockMap & Map) const;

  bool  LinearMap() const {return(BlockMapData_->LinearMap_);};

  bool  DistributedGlobal() const {return(BlockMapData_->DistributedGlobal_);};



#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int * MyGlobalElements() const;
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  long long * MyGlobalElements64() const;
#endif

  // Helper function to avoid scattering ifdef in other code.
  void MyGlobalElements(const int*& IntGIDs, const long long*& LLGIDs) const {
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    if(GlobalIndicesInt()) {
      IntGIDs = MyGlobalElements();
      return;
    }
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
    if(GlobalIndicesLongLong()) {
      LLGIDs = MyGlobalElements64();
      return;
    }
#endif
  }

  // Helper function to avoid scattering ifdef in other code.
  void MyGlobalElements(int*& IntGIDs, long long*& LLGIDs) {
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
    if(GlobalIndicesInt()) {
      IntGIDs = MyGlobalElements();
      return;
    }
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
    if(GlobalIndicesLongLong()) {
      LLGIDs = MyGlobalElements64();
      return;
    }
#endif
  }


  int * FirstPointInElementList() const;

  int * ElementSizeList() const;

  int * PointToElementList() const;

  int ElementSizeList(int * ElementSizeList)const;

  int FirstPointInElementList(int * FirstPointInElementList)const;

  int PointToElementList(int * PointToElementList) const;




  virtual void Print(std::ostream & os) const;

  const Epetra_Comm & Comm() const {return(*BlockMapData_->Comm_);}

  bool IsOneToOne() const;

  Epetra_BlockMap & operator=(const Epetra_BlockMap & map);





  int ReferenceCount() const {return(BlockMapData_->ReferenceCount());}


  const Epetra_BlockMapData * DataPtr() const {return(BlockMapData_);}

  Epetra_BlockMap * RemoveEmptyProcesses() const;

  Epetra_BlockMap* ReplaceCommWithSubset(const Epetra_Comm * Comm) const;


 private: // These need to be accessible to derived map classes.

  void GlobalToLocalSetup();
  bool DetermineIsOneToOne() const;
  bool IsDistributedGlobal(long long NumGlobalElements, int NumMyElements) const;
  void CheckValidNGE(long long NumGlobalElements);
  void EndOfConstructorOps();

 protected:
  void CleanupData();

  Epetra_BlockMapData * BlockMapData_;

private:


  void ConstructAutoUniform(long long NumGlobal_Elements, int Element_Size,
      long long Index_Base, const Epetra_Comm& comm, bool IsLongLong);

  void ConstructUserLinear(long long NumGlobal_Elements, int NumMy_Elements,
      int Element_Size, long long Index_Base, const Epetra_Comm& comm, bool IsLongLong);

  template<typename int_type>
  void ConstructUserConstant(int_type NumGlobal_Elements, int NumMy_Elements,
      const int_type * myGlobalElements,
      int Element_Size, int_type indexBase,
      const Epetra_Comm& comm, bool IsLongLong);

  template<typename int_type>
  void ConstructUserVariable(int_type NumGlobal_Elements, int NumMy_Elements,
      const int_type * myGlobalElements,
      const int *elementSizeList, int_type indexBase,
      const Epetra_Comm& comm, bool IsLongLong);

  template<typename int_type>
  void ConstructUserConstantNoComm(int_type NumGlobal_Elements, int NumMy_Elements,
      const int_type * myGlobalElements,
      int ElementSize, int_type indexBase,
      const Epetra_Comm& comm, bool IsLongLong,
      bool UserIsDistributedGlobal,
      int_type UserMinAllGID, int_type UserMaxAllGID);

  template<typename int_type>
  int_type& MyGlobalElementVal(int i);

  template<typename int_type>
  int_type MyGlobalElementValGet(int i);

  template<typename int_type>
  int SizeMyGlobalElement(int n);

  template<typename int_type>
  void TGlobalToLocalSetup();
};

#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
template<> inline bool       Epetra_BlockMap::GlobalIndicesIsType<long long>() const { return BlockMapData_->GlobalIndicesLongLong_; }
template<> inline long long& Epetra_BlockMap::MyGlobalElementVal<long long>(int i) { return BlockMapData_->MyGlobalElements_LL_[i]; }
template<> inline long long  Epetra_BlockMap::MyGlobalElementValGet<long long>(int i) { return BlockMapData_->MyGlobalElements_LL_[i]; }
template<> inline int        Epetra_BlockMap::SizeMyGlobalElement<long long>(int n) { return BlockMapData_->MyGlobalElements_LL_.Size(n); }
#endif

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
template<> inline bool Epetra_BlockMap::GlobalIndicesIsType<int>()       const { return BlockMapData_->GlobalIndicesInt_; }
template<> inline int& Epetra_BlockMap::MyGlobalElementVal<int>      (int i) { return BlockMapData_->MyGlobalElements_int_[i]; }
template<> inline int  Epetra_BlockMap::MyGlobalElementValGet<int>      (int i) { return BlockMapData_->MyGlobalElements_int_[i]; }
template<> inline int  Epetra_BlockMap::SizeMyGlobalElement<int>      (int n) { return BlockMapData_->MyGlobalElements_int_.Size(n); }
#endif

#endif /* EPETRA_BLOCKMAP_H */