fei_MatrixReducer.hpp

/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the 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.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/
 
#ifndef _fei_MatrixReducer_hpp_
#define _fei_MatrixReducer_hpp_
 
#include <fei_iosfwd.hpp>
#include <fei_mpi.h>
#include <fei_defs.h>
 
#include <fei_Matrix.hpp>
#include <fei_Reducer.hpp>
#include <fei_MatrixGraph.hpp>
#include <fei_Matrix_core.hpp>
 
#undef fei_file
#define fei_file "fei_MatrixReducer.hpp"
#include <fei_ErrMacros.hpp>
 
namespace fei {
 
  class MatrixReducer : public fei::Matrix {
  public:
    MatrixReducer(fei::SharedPtr<fei::Reducer> reducer,
                  fei::SharedPtr<fei::Matrix> target);

    virtual ~MatrixReducer();

    fei::SharedPtr<fei::Matrix> getTargetMatrix()
      { return(target_); }

    const char* typeName() { return(target_->typeName()); }

    int parameters(const fei::ParameterSet& paramset);
 
    fei::SharedPtr<fei::MatrixGraph> getMatrixGraph() const
      {return( target_->getMatrixGraph() ); }

    void setMatrixGraph(fei::SharedPtr<fei::MatrixGraph> matrixGraph);

    int getGlobalNumRows() const;

    int getLocalNumRows() const;

    int putScalar(double scalar);

    int getRowLength(int row, int& length) const;

    int copyOutRow(int row, int len, double* coefs, int* indices) const;

    int sumIn(int numRows, const int* rows,
        int numCols, const int* cols,
        const double* const* values,
        int format=0);

    int copyIn(int numRows, const int* rows,
         int numCols, const int* cols,
         const double* const* values,
         int format=0);

    int sumInFieldData(int fieldID,
           int idType,
           int rowID,
           int colID,
           const double* const* data,
           int format=0);

    int sumInFieldData(int fieldID,
           int idType,
           int rowID,
           int colID,
           const double* data,
           int format=0);

    int sumIn(int blockID, int connectivityID,
        const double* const* values,
        int format=0);

    int globalAssemble();

    int multiply(fei::Vector* x,
     fei::Vector* y);
 
    void setCommSizes() { target_->setCommSizes(); }

    int gatherFromOverlap(bool accumulate = true);

    int writeToFile(const char* filename,
        bool matrixMarketFormat=true);

 
    int writeToStream(FEI_OSTREAM& ostrm,
          bool matrixMarketFormat=true);
 
    bool usingBlockEntryStorage()
      { return(target_->usingBlockEntryStorage()); }

    int giveToUnderlyingMatrix(int numRows, const int* rows,
             int numCols, const int* cols,
             const double* const* values,
             bool sumInto,
             int format);

    int giveToUnderlyingBlockMatrix(int row,
            int rowDim,
            int numCols,
            const int* cols,
            const int* LDAs,
            const int* colDims,
            const double* const* values,
            bool sumInto);
 
    void markState();
 
    bool changedSinceMark();
 
  private:
    int giveToMatrix(int numRows, const int* rows,
         int numCols, const int* cols,
         const double* const* values,
         bool sumInto,
         int format);
 
    int giveToBlockMatrix(int numRows, const int* rows,
        int numCols, const int* cols,
        const double* const* values,
        bool sumInto);
 
    fei::SharedPtr<fei::Reducer> reducer_;
    fei::SharedPtr<fei::Matrix> target_;
    bool globalAssembleCalled_;
    bool changedSinceMark_;
  };//class MatrixReducer
}//namespace fei
 
#endif