EpetraExt_BlockDiagMatrix.h

Go to the documentation of this file.

//@HEADER
// ***********************************************************************
//
//     EpetraExt: Epetra Extended - 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 EPETRAEXT_BLOCKDIAGMATRIX_H
#define EPETRAEXT_BLOCKDIAGMATRIX_H
 
#include "Epetra_BLAS.h"
#include "Epetra_LAPACK.h"
#include "Epetra_DistObject.h"
#include "Epetra_BlockMap.h"
#include "Epetra_Map.h"
#include "Epetra_Operator.h"
#include "Teuchos_ParameterList.hpp"
 
class Epetra_Comm;
 
 
//=========================================================================
class EpetraExt_BlockDiagMatrix : public virtual Epetra_Operator, public Epetra_DistObject,public Epetra_BLAS {
 
 public:
  EpetraExt_BlockDiagMatrix(const Epetra_BlockMap& Map,bool zero_out=true);
 
 
  EpetraExt_BlockDiagMatrix(const EpetraExt_BlockDiagMatrix& Source);
 
  virtual ~EpetraExt_BlockDiagMatrix();
 
 
  EpetraExt_BlockDiagMatrix& operator = (const EpetraExt_BlockDiagMatrix& Source);
 
 
  double* operator [] (int index) {return &Values_[DataMap_->FirstPointInElement(index)];}
 
  const double* operator [] (int index) const {return &Values_[DataMap_->FirstPointInElement(index)];}
 
 
 
 
  virtual int SetUseTranspose(bool /* useTranspose */){return -1;}
 
  virtual int SetParameters(Teuchos::ParameterList & List);
 
  virtual int Compute();
 
 
 
 
 
  virtual const char * Label() const{return "EpetraExt::BlockDiagMatrix";}//HAQ
 
  virtual bool UseTranspose() const {return false;}
 
  virtual bool HasNormInf() const {return false;}
 
  virtual const Epetra_Comm & Comm() const {return Map().Comm();}
 
  virtual const Epetra_Map & OperatorDomainMap() const {return *dynamic_cast<const Epetra_Map*>(&Map());}
 
  virtual const Epetra_Map & OperatorRangeMap() const {return *dynamic_cast<const Epetra_Map*>(&Map());}
 
  virtual const Epetra_BlockMap & BlockMap() const {return Map();}
 
  double* Values() const {return(Values_);}
 
  int BlockSize(int LID) const {return Map().ElementSize(LID);}
 
  int DataSize(int LID) const {return DataMap_->ElementSize(LID);}
 
  bool ConstantBlockSize() const {return Map().ConstantElementSize();}
 
  int NumMyBlocks() const {return(Map().NumMyElements());}
 
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int NumGlobalBlocks() const {return(Map().NumGlobalElements());}
#endif
  long long NumGlobalBlocks64() const {return(Map().NumGlobalElements64());}
 
  int NumMyUnknowns() const {return(Map().NumMyPoints());}
 
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  int NumGlobalUnknowns() const {return(Map().NumGlobalPoints());}
#endif
  long long NumGlobalUnknowns64() const {return(Map().NumGlobalPoints64());}
 
  int NumData() const {return DataMap_->NumMyPoints();}
 
  int GetApplyMode() {return ApplyMode_;}
 
  virtual void Print(std::ostream & os) const;
 
 
 
 
 
 
  virtual int Apply(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const {return -1;}
 
 
  virtual int ApplyInverse(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const;
 
  virtual double NormInf() const{return -1;}
 
  void PutScalar(double value);
 
  virtual const Epetra_BlockMap & DataMap() const {return *DataMap_;}
 
 
 
private:
  void Allocate();
 
  int DoCopy(const EpetraExt_BlockDiagMatrix& Source);
 
  // Routines to implement Epetra_DistObject virtual methods
  // Allows the source and target (\e this) objects to be compared for compatibility, return nonzero if not.
  int CheckSizes(const Epetra_SrcDistObject& Source);
  // Perform ID copies and permutations that are on processor.
  int CopyAndPermute(const Epetra_SrcDistObject& Source,
                     int NumSameIDs,
                     int NumPermuteIDs,
                     int * PermuteToLIDs,
                     int * PermuteFromLIDs,
                     const Epetra_OffsetIndex * Indexor,
                     Epetra_CombineMode CombineMode = Zero);
 
  // Perform any packing or preparation required for call to DoTransfer().
  int PackAndPrepare(const Epetra_SrcDistObject& Source,
                     int NumExportIDs,
                     int* ExportLIDs,
                     int& LenExports,
                     char*& Exports,
                     int& SizeOfPacket,
                     int* Sizes,
                     bool & VarSizes,
                     Epetra_Distributor& Distor);
 
  // Perform any unpacking and combining after call to DoTransfer().
  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);
 
  Epetra_LAPACK LAPACK;
  Teuchos::ParameterList List_;
 
  bool HasComputed_;
 
  int ApplyMode_;
 
  Epetra_BlockMap* DataMap_;
 
  double *Values_;
 
  int *Pivots_;
 
};  /* EPETRAEXT_BLOCKDIAGMATRIX_H */
 
#endif