Epetra_MultiVector.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_MULTIVECTOR_H
#define EPETRA_MULTIVECTOR_H
 
class Epetra_Comm;
class Epetra_BlockMap;
class Epetra_Map;
class Epetra_Import;
class Epetra_Export;
class Epetra_Distributor;
class Epetra_Vector;
 
#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_MultiVector: public Epetra_DistObject, public Epetra_CompObject, public Epetra_BLAS {
 
 public:



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

 
  Epetra_MultiVector(const Epetra_MultiVector& Source);


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


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


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


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

  virtual ~Epetra_MultiVector();




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


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


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


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


  int ReplaceMyValue(int MyRow, int VectorIndex, double ScalarValue);
 


  int ReplaceMyValue(int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue);
 


  int SumIntoMyValue(int MyRow, int VectorIndex, double ScalarValue);
 


  int SumIntoMyValue(int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue);


  int PutScalar (double ScalarConstant);


  int Random();





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


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


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


  int ExtractView(double ***ArrayOfPointers) const;





  int Dot(const Epetra_MultiVector& A, double *Result) const;


  int Abs(const Epetra_MultiVector& A);


  int Reciprocal(const Epetra_MultiVector& A);


  int Scale(double ScalarValue);


  int Scale(double ScalarA, const Epetra_MultiVector& A);


  int Update(double ScalarA, const Epetra_MultiVector& A, double ScalarThis);


  int Update(double ScalarA, const Epetra_MultiVector& A,
       double ScalarB, const Epetra_MultiVector& B, double ScalarThis);


  int Norm1   (double * Result) const;


  int Norm2   (double * Result) const;


  int NormInf (double * Result) const;


  int NormWeighted   (const Epetra_MultiVector& Weights, double * Result) const;


  int MinValue  (double * Result) const;


  int MaxValue  (double * Result) const;


  int MeanValue (double * Result) const;
 


  int Multiply(char TransA, char TransB, double ScalarAB,
         const Epetra_MultiVector& A, const Epetra_MultiVector& B,
         double ScalarThis );
 
 


  int Multiply(double ScalarAB, const Epetra_MultiVector& A, const Epetra_MultiVector& B,
         double ScalarThis );
 


  int ReciprocalMultiply(double ScalarAB, const Epetra_MultiVector& A, const Epetra_MultiVector& B,
       double ScalarThis );



 


  int SetSeed(unsigned int Seed_in){return(Util_.SetSeed(Seed_in));};


  unsigned int Seed(){return(Util_.Seed());};





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


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

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


  Epetra_Vector * & operator () (int i);

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




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

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

  int GlobalLength() const { int ret_val = GlobalLength_; return ret_val; }

  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(double ** ArrayOfPointers);

  double* Values() const {return Values_;};

  double** Pointers() const {return Pointers_;};
 
  // Expert-only function
#ifdef Reduce
#undef Reduce
#endif
  int Reduce();
 
 protected:
 
  // Internal utilities
  void Assign(const Epetra_MultiVector& rhs);
  int CheckInput();
 
  double *Values_;    // local MultiVector coefficients
 
 private:
 
 
  // Internal utilities
 
  int AllocateForCopy(void);
  int DoCopy(void);
 
  inline void UpdateDoubleTemp() const
  {if (DoubleTemp_==0) DoubleTemp_=new double[NumVectors_+1]; return;}
 
  inline void UpdateVectors()  const {if (Vectors_==0) { Vectors_ = new Epetra_Vector *[NumVectors_];
    for (int i=0; i<NumVectors_; i++) Vectors_[i] = 0;}
    return;
  }
 
  int AllocateForView(void);
  int DoView(void);
  template<typename int_type>
  int ChangeGlobalValue(int_type GlobalBlockRow,
                        int BlockRowOffset,
                        int VectorIndex,
                        double ScalarValue,
                        bool SumInto);
  int ChangeMyValue(int MyBlockRow,
                    int BlockRowOffset,
                    int VectorIndex,
                    double ScalarValue,
                    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 );
 
  double **Pointers_;        // Pointers to each vector;
 
  int MyLength_;
  long long GlobalLength_;
  int NumVectors_;
  bool UserAllocated_;
  bool ConstantStride_;
  int Stride_;
  bool Allocated_;
  mutable double * DoubleTemp_;
  mutable Epetra_Vector ** Vectors_;
  Epetra_Util Util_;
 
};
 
#endif /* EPETRA_MULTIVECTOR_H */