fei_Matrix_Local.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*    Copyright 2007 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_Matrix_Local_hpp_
#define _fei_Matrix_Local_hpp_
 
#include <fei_SharedPtr.hpp>
#include <fei_MatrixGraph.hpp>
#include <fei_Matrix.hpp>
#include <fei_SparseRowGraph.hpp>
 
#include <vector>
 
namespace fei {
class Matrix_Local : public fei::Matrix {
 public:
  Matrix_Local(fei::SharedPtr<fei::MatrixGraph> matrixGraph,
               fei::SharedPtr<fei::SparseRowGraph> sparseRowGraph);
 
  virtual ~Matrix_Local();
 
  static fei::SharedPtr<fei::Matrix>
    create_Matrix_Local(fei::SharedPtr<fei::MatrixGraph> matrixGraph,
                        bool blockEntry);
 
  const char* typeName();
 
  int parameters(const fei::ParameterSet& paramset);
 
  int parameters(int numParams, const char* const* paramStrings);
 
    fei::SharedPtr<fei::MatrixGraph> getMatrixGraph() const;
 
    void setMatrixGraph(fei::SharedPtr<fei::MatrixGraph> matrixGraph);
 
    int getGlobalNumRows() const;
 
    int getLocalNumRows() const;
 
    int getRowLength(int row, int& length) const;
 
    int putScalar(double scalar);
 
    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();
 
    int gatherFromOverlap(bool accumulate = true);
 
    int writeToFile(const char* filename,
                            bool matrixMarketFormat=true);
 
    int writeToStream(FEI_OSTREAM& ostrm,
                              bool matrixMarketFormat=true);
 
    bool usingBlockEntryStorage();
 
    void markState();
 
    bool changedSinceMark();
 
    const std::vector<int>& getRowNumbers() const;
 
    const std::vector<int>& getRowOffsets() const;
 
    const std::vector<int>& getColumnIndices() const;
 
    const std::vector<double>& getCoefs() const;
 
 private:
  int getRowIndex(int rowNumber) const;
 
  int giveToMatrix(int numRows, const int* rows,
                      int numCols, const int* cols,
                      const double* const* values,
                      bool sumInto, int format);
 
  fei::SharedPtr<fei::MatrixGraph> matrixGraph_;
  fei::SharedPtr<fei::SparseRowGraph> sparseRowGraph_;
  std::vector<double> coefs_;
  bool stateChanged_;
  std::vector<double> work_data1D_;
  std::vector<const double*> work_data2D_;
};//class Matrix_Local
}//namespace fei
 
#endif