fei_Matrix_core.hpp

#ifndef _fei_Matrix_core_hpp_
#define _fei_Matrix_core_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.                    */
/*--------------------------------------------------------------------*/

#include <fei_macros.hpp>
#include <fei_mpi.h>
#include <fei_EqnComm.hpp>
#include <fei_fwd.hpp>
#include <fei_Vector.hpp>
#include <fei_CommUtils.hpp>
#include <fei_FillableMat.hpp>
#include <fei_MatrixGraph.hpp>
#include <fei_Logger.hpp>

#include <vector>

namespace fei {
class Matrix_core : protected fei::Logger {
 public:

  Matrix_core(fei::SharedPtr<fei::MatrixGraph> matrixGraph, int numLocalEqns);

  virtual ~Matrix_core();

  virtual int giveToMatrix(int numRows, const int* rows,
                           int numCols, const int* cols,
                           const double* const* values,
                           bool sumInto,
                           int format) = 0;

  static void copyTransposeToWorkArrays(int numRows, int numCols,
                                       const double*const* values,
                                       std::vector<double>& work_1D,
                                       std::vector<const double*>& work_2D);

  void setRHS(fei::SharedPtr<fei::Vector> rhsvector);

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

  fei::SharedPtr<fei::MatrixGraph> getMatrixGraph() const { return( matrixGraph_ ); }

  const FillableMat* getRemotelyOwnedMatrix(int proc) const
  {
    if (proc_last_requested_ == proc) {
      return remotelyOwned_last_requested_;
    }
    FillableMat* remote_mat = NULL;
    std::map<int,FillableMat*>::const_iterator it = remotelyOwned_.find(proc);
    if (it != remotelyOwned_.end()) {
      remote_mat = it->second;
      remotelyOwned_last_requested_ = remote_mat;
      proc_last_requested_ = proc;
    }
    return( remote_mat );
  }

  FillableMat* getRemotelyOwnedMatrix(int proc)
  {
    if (proc_last_requested_ == proc) {
      return remotelyOwned_last_requested_;
    }
    proc_last_requested_ = proc;
    FillableMat* remote_mat = NULL;
    std::map<int,FillableMat*>::iterator it = remotelyOwned_.find(proc);
    if (it == remotelyOwned_.end()) {
      remote_mat = new FillableMat;
      remotelyOwned_.insert(std::make_pair(proc, remote_mat));
    }
    else {
      remote_mat = it->second;
    }
    remotelyOwned_last_requested_ = remote_mat;
    return( remote_mat );
  }

  std::map<int,FillableMat*>& getRemotelyOwnedMatrices();

  void putScalar_remotelyOwned(double scalar);

  void setEqnComm(fei::SharedPtr<fei::EqnComm> eqnComm);

 protected:
  void parameters(const fei::ParameterSet& paramset);

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

  virtual int giveToBlockMatrix(int numRows, const int* rows,
                                          int numCols, const int* cols,
                                          const double* const* values,
                                          bool sumInto) = 0;

  virtual int giveToUnderlyingBlockMatrix(int row,
                                          int rowDim,
                                          int numCols,
                                          const int* cols,
                                          const int* LDAs,
                                          const int* colDims,
                                          const double* const* values,
                                          bool sumInto) = 0;

  void setName(const char* name);

  void setCommSizes();
  int gatherFromOverlap(bool accumulate);

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

  int copyPointRowsToBlockRow(int numPtRows,
                              int numPtCols,
                              const double*const* ptValues,
                              int numBlkCols,
                              const int* blkColDims,
                              double** blkValues);

  int convertPtToBlk(int numRows,
                       const int* rows,
                       int numCols,
                       const int* cols,
                       int* blkRows,
                       int* blkRowOffsets,
                       int* blkCols,
                       int* blkColOffsets);

  MPI_Comm getCommunicator() const { return( comm_ ); }

  const fei::SharedPtr<fei::VectorSpace> vecSpace() const { return( vecSpace_ ); }
  fei::SharedPtr<fei::VectorSpace> vecSpace() { return( vecSpace_ ); }

  std::vector<int>& globalOffsets() { return( globalOffsets_ ); }
  const std::vector<int>& globalOffsets() const { return( globalOffsets_ ); }

  int firstLocalOffset() const { return( firstLocalOffset_ ); }
  int lastLocalOffset() const  { return( lastLocalOffset_ ); }

  int numProcs() const { return( numProcs_ ); }
  int localProc() const { return( localProc_ ); }

  bool haveBlockMatrix() const { return( haveBlockMatrix_ ); }
  void setBlockMatrix(bool flag) {haveBlockMatrix_ = flag; }

  bool haveFEMatrix() const { return( haveFEMatrix_ ); }
  void setFEMatrix(bool flag) {haveFEMatrix_ = flag; }

  int getOwnerProc(int globalEqn) const;

  std::string name_;

  std::vector<int> work_indices_;
  std::vector<int> work_indices2_;

  std::vector<int> work_ints_;

  std::vector<double> work_data1D_;
  std::vector<const double*> work_data2D_;

 protected:
  fei::SharedPtr<fei::EqnComm> eqnComm_;

 private:
  fei::SharedPtr<fei::Vector> rhsVector_;

  MPI_Comm comm_;

  int localProc_, numProcs_;

  fei::SharedPtr<fei::VectorSpace> vecSpace_;
  fei::SharedPtr<fei::MatrixGraph> matrixGraph_;

  std::map<int,FillableMat*> remotelyOwned_;
  mutable FillableMat* remotelyOwned_last_requested_;
  std::vector<int> sendProcs_;
  std::vector<int> recvProcs_;
  std::vector<std::vector<char> > recv_chars_;
  std::vector<std::vector<char> > send_chars_;
  bool sendRecvProcsNeedUpdated_;
  mutable int proc_last_requested_;

  bool haveBlockMatrix_;
  bool haveFEMatrix_;

  std::vector<int> globalOffsets_;
  int firstLocalOffset_, lastLocalOffset_;
};//class Matrix_core
}//namespace fei

#endif