Epetra_IntMultiVector.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_INTMULTIVECTOR_H
#define EPETRA_INTMULTIVECTOR_H
 
class Epetra_Comm;
class Epetra_BlockMap;
class Epetra_Map;
class Epetra_Import;
class Epetra_Export;
class Epetra_Distributor;
class Epetra_IntVector;
 
#include "Epetra_ConfigDefs.h"
#include "Epetra_DistObject.h"
#include "Epetra_CompObject.h"
#include "Epetra_BLAS.h"
#include "Epetra_Util.h"


 
//==========================================================================
class EPETRA_LIB_DLL_EXPORT Epetra_IntMultiVector: public Epetra_DistObject, public Epetra_CompObject, public Epetra_BLAS {
 
 public:



  Epetra_IntMultiVector(const Epetra_BlockMap& Map, int NumVectors, bool zeroOut = true);

 
  Epetra_IntMultiVector(const Epetra_IntMultiVector& Source);


  Epetra_IntMultiVector(Epetra_DataAccess CV, const Epetra_BlockMap& Map,
         int *A, int MyLDA, int NumVectors);


  Epetra_IntMultiVector(Epetra_DataAccess CV, const Epetra_BlockMap& Map,
         int **ArrayOfPointers, int NumVectors);


  Epetra_IntMultiVector(Epetra_DataAccess CV,
         const Epetra_IntMultiVector& Source, int *Indices, int NumVectors);


  Epetra_IntMultiVector(Epetra_DataAccess CV,
         const Epetra_IntMultiVector& Source, int StartIndex,
         int NumVectors);

  virtual ~Epetra_IntMultiVector();




#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int ReplaceGlobalValue(int GlobalRow, int VectorIndex, int OrdinalValue);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int ReplaceGlobalValue(long long GlobalRow, int VectorIndex, int OrdinalValue);
#endif
 


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int ReplaceGlobalValue(int GlobalBlockRow, int BlockRowOffset, int VectorIndex, int OrdinalValue);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int ReplaceGlobalValue(long long GlobalBlockRow, int BlockRowOffset, int VectorIndex, int OrdinalValue);
#endif
 


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int SumIntoGlobalValue(int GlobalRow, int VectorIndex, int OrdinalValue);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int SumIntoGlobalValue(long long GlobalRow, int VectorIndex, int OrdinalValue);
#endif
 


#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int SumIntoGlobalValue(int GlobalBlockRow, int BlockRowOffset, int VectorIndex, int OrdinalValue);
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
  int SumIntoGlobalValue(long long GlobalBlockRow, int BlockRowOffset, int VectorIndex, int OrdinalValue);
#endif


  int ReplaceMyValue(int MyRow, int VectorIndex, int OrdinalValue);
 


  int ReplaceMyValue(int MyBlockRow, int BlockRowOffset, int VectorIndex, int OrdinalValue);
 


  int SumIntoMyValue(int MyRow, int VectorIndex, int OrdinalValue);
 


  int SumIntoMyValue(int MyBlockRow, int BlockRowOffset, int VectorIndex, int OrdinalValue);


  int PutScalar (int OrdinalConstant);





  int ExtractCopy(int *A, int MyLDA) const;


  int ExtractCopy(int **ArrayOfPointers) const;
 
  // ExtractView functions
 


  int ExtractView(int **A, int *MyLDA) const;


  int ExtractView(int ***ArrayOfPointers) const;





  int MinValue  (int * Result) const;


  int MaxValue  (int * Result) const;





  Epetra_IntMultiVector& operator = (const Epetra_IntMultiVector& Source);
 
  // Local element access functions
 
  //


  int*& operator [] (int i) { return Pointers_[i]; }

  //  const int*& operator [] (int i) const;
  int * const & operator [] (int i) const { return Pointers_[i]; }


  Epetra_IntVector * & operator () (int i);

  const Epetra_IntVector * & operator () (int i) const;




  int NumVectors() const {return(NumVectors_);}

  int MyLength() const {return(MyLength_);}

#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int GlobalLength() const {
    if(Map().GlobalIndicesInt())
      return (int) GlobalLength_;
    throw "Epetra_MultiVector::GlobalLength: GlobalIndices not int.";
  }
#endif
  long long GlobalLength64() const {return(GlobalLength_);}

  int Stride() const {return(Stride_);}

  bool ConstantStride() const {return(ConstantStride_);}

  int ReplaceMap(const Epetra_BlockMap& map);



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




 
  int ResetView(int ** ArrayOfPointers);

  int* Values() const {return Values_;}

  int** Pointers() const {return Pointers_;}
 
  // Expert-only function
  //  SuperLU defines Reduce to be a macro in util.h
#ifdef Reduce
#undef Reduce
#endif
  int Reduce();
 
 protected:
 
  // Internal utilities
  void Assign(const Epetra_IntMultiVector& rhs);
  int CheckInput();
 
  int *Values_;    // local MultiVector coefficients
 
 private:
 
 
  // Internal utilities
 
  int AllocateForCopy(void);
  int DoCopy(void);
 
  inline void UpdateOrdinalTemp() const
  {if (OrdinalTemp_==0) OrdinalTemp_=new int[NumVectors_+1]; return;}
 
  inline void UpdateIntVectors()  const {if (IntVectors_==0) { IntVectors_ = new Epetra_IntVector *[NumVectors_];
    for (int i=0; i<NumVectors_; i++) IntVectors_[i] = 0;}
    return;
  }
 
  int AllocateForView(void);
  int DoView(void);
  template<typename int_type>
  int ChangeGlobalValue(int_type GlobalBlockRow,
                        int BlockRowOffset,
                        int VectorIndex,
                        int OrdinalValue,
                        bool SumInto);
  int ChangeMyValue(int MyBlockRow,
                    int BlockRowOffset,
                    int VectorIndex,
                    int OrdinalValue,
                    bool SumInto);
 
  int CheckSizes(const Epetra_SrcDistObject& A);
 
  int CopyAndPermute(const Epetra_SrcDistObject & Source,
                     int NumSameIDs,
                     int NumPermuteIDs,
                     int * PermuteToLIDs,
                     int * PermuteFromLIDs,
                     const Epetra_OffsetIndex * Indexor,
                     Epetra_CombineMode CombineMode = Zero);
 
  int PackAndPrepare(const Epetra_SrcDistObject & Source,
                     int NumExportIDs,
                     int * ExportLIDs,
                     int & LenExports,
                     char * & Exports,
                     int & SizeOfPacket,
                     int * Sizes,
                     bool & VarSizes,
                     Epetra_Distributor & Distor);
 
  int UnpackAndCombine(const Epetra_SrcDistObject & Source,
                       int NumImportIDs,
                       int * ImportLIDs,
                       int LenImports,
                       char * Imports,
                       int & SizeOfPacket,
                       Epetra_Distributor & Distor,
                       Epetra_CombineMode CombineMode,
                       const Epetra_OffsetIndex * Indexor );
 
  int **Pointers_;        // Pointers to each vector;
 
  int MyLength_;
  long long GlobalLength_;
  int NumVectors_;
  bool UserAllocated_;
  bool ConstantStride_;
  int Stride_;
  bool Allocated_;
  mutable int * OrdinalTemp_;
  mutable Epetra_IntVector ** IntVectors_;
  Epetra_Util Util_;
 
};
 
#endif /* EPETRA_INTMULTIVECTOR_H */