EpetraExt_PointToBlockDiagPermute.h

Go to the documentation of this file.

/*
************************************************************************

              EpetraExt: Extended Linear Algebra Services Package 
                Copyright (2001) Sandia Corporation

Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
license for use of this work by or on behalf of the U.S. Government.

This library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of the
License, or (at your option) any later version.
 
This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA
Questions? Contact Michael A. Heroux (maherou@sandia.gov) 

************************************************************************
*/
//@HEADER

#ifndef EPETRAEXT_POINTTOBLOCKDIAGPERMUTE_H
#define EPETRAEXT_POINTTOBLOCKDIAGPERMUTE_H

#include "Epetra_DistObject.h"
#include "Epetra_BlockMap.h"
#include "Epetra_BlockMap.h"
#include "Epetra_Map.h"
#include "Epetra_Operator.h"
#include "Epetra_CrsMatrix.h"
#include "Epetra_FECrsMatrix.h"
#include "Teuchos_ParameterList.hpp"

class Epetra_Comm;
class Epetra_Import;
class Epetra_Export;
class EpetraExt_BlockDiagMatrix;


// NTS: Map() == RowMap is the convention

//=========================================================================
class EpetraExt_PointToBlockDiagPermute : public virtual Epetra_Operator, public Epetra_DistObject {
public:



  EpetraExt_PointToBlockDiagPermute(const Epetra_CrsMatrix& MAT);
  


  virtual ~EpetraExt_PointToBlockDiagPermute();

  


  virtual int SetParameters(Teuchos::ParameterList & List);
  
  virtual int SetUseTranspose(bool UseTranspose){return -1;}

  virtual int Compute();
  
  



  virtual int Apply(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const;


  virtual int ApplyInverse(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const;
  
  virtual double NormInf() const {return -1;}
  


  virtual const char * Label() const{return "Fix Me";}

  virtual bool UseTranspose() const {return false;}

  virtual bool HasNormInf() const {return false;}

  virtual const Epetra_Comm & Comm() const {return Map().Comm();}
  
  //operator. 
  virtual const Epetra_Map & OperatorDomainMap() const {return Matrix_->OperatorDomainMap();}

  //operator.
  virtual const Epetra_Map & OperatorRangeMap() const {return Matrix_->OperatorRangeMap();}

  
  virtual const EpetraExt_BlockDiagMatrix & BlockMatrix(){return *BDMat_;}
  

  virtual Epetra_FECrsMatrix * CreateFECrsMatrix();



  virtual void Print(ostream& os) const;






  int Import(const Epetra_SrcDistObject& A, const Epetra_Import& Importer, Epetra_CombineMode CombineMode, const Epetra_OffsetIndex * Indexor = 0);


  int Import(const Epetra_SrcDistObject& A, const Epetra_Export& Exporter, Epetra_CombineMode CombineMode, const Epetra_OffsetIndex * Indexor = 0);


  int Export(const Epetra_SrcDistObject& A, const Epetra_Import & Importer, Epetra_CombineMode CombineMode, const Epetra_OffsetIndex * Indexor = 0);


  int Export(const Epetra_SrcDistObject& A, const Epetra_Export& Exporter, Epetra_CombineMode CombineMode, const Epetra_OffsetIndex * Indexor = 0);
  
 protected:




  virtual int CheckSizes(const Epetra_SrcDistObject& Source);
  virtual int CopyAndPermute(const Epetra_SrcDistObject& Source,
                             int NumSameIDs, 
                             int NumPermuteIDs,
                             int * PermuteToLIDs,
                             int * PermuteFromLIDs,
                             const Epetra_OffsetIndex * Indexor);

  virtual int PackAndPrepare(const Epetra_SrcDistObject& Source,
                             int NumExportIDs,
                             int* ExportLIDs,
                             int& LenExports,
                             char*& Exports,
                             int& SizeOfPacket,
                             int* Sizes,
                             bool & VarSizes,
                             Epetra_Distributor& Distor);
  
  virtual 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);


private:
  int ExtractBlockDiagonal();

  int SetupContiguousMode();
  int CleanupContiguousMode();

  // Copied from Epetra_CrsMatrix
  void UpdateImportVector(int NumVectors) const;
  void UpdateExportVector(int NumVectors) const;

  Teuchos::ParameterList List_;
  const Epetra_CrsMatrix* Matrix_;  
  bool PurelyLocalMode_;  

  // For contiguous blocking only
  bool ContiguousBlockMode_;
  int ContiguousBlockSize_;

  int NumBlocks_;
  int *Blockstart_;
  int *Blockids_;
  Epetra_BlockMap *BDMap_;
  Epetra_Map *CompatibleMap_; //A map compatible with BD's block map - used for imports
  EpetraExt_BlockDiagMatrix* BDMat_;
  Epetra_Import *Importer_;
  Epetra_Export *Exporter_;
  mutable Epetra_MultiVector *ImportVector_;
  mutable Epetra_MultiVector *ExportVector_;
  

};  /* EPETRAEXT_POINTTOBLOCKDIAGPERMUTE_H */

#endif