fei_Vector_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.                    */
/*--------------------------------------------------------------------*/

#ifndef _fei_Vector_core_hpp_
#define _fei_Vector_core_hpp_

#include <fei_iosfwd.hpp>
#include <fei_CSVec.hpp>
#include <fei_VectorSpace.hpp>
#include <fei_Reducer.hpp>
#include <fei_Logger.hpp>
#include <fei_SharedPtr.hpp>
#include <fei_EqnComm.hpp>

namespace fei {

class Vector_core : protected fei::Logger {
 public:
  Vector_core(fei::SharedPtr<fei::VectorSpace> vecSpace, int numLocalEqns);

  virtual ~Vector_core();

  int copyOut(int numValues,
        const int* indices,
        double* values,
        int vectorIndex=0) const;

  virtual int sumIntoFEVector(int blockID,
            int connOffset,
            int numNodes,
            const int* nodeNumbers,
            const int* numIndicesPerNode,
            const int* dof_ids,
            const double* values) = 0;

  virtual int copyOut_FE(int nodeNumber, int dofOffset, double& value) = 0;

  int giveToVector(int numValues,
       const int* indices,
       const double* values,
       bool sumInto=true,
       int vectorIndex=0);

  virtual int scatterToOverlap();

  void setOverlap(int numRemoteEqns=0, const int* remoteEqns=NULL);

 protected:
  int assembleFieldData(int fieldID,
      int idType,
      int numIDs,
      const int* IDs,
      const double* data,
      bool sumInto=true,
      int vectorIndex=0);

  int assembleFieldDataLocalIDs(int fieldID,
      int idType,
      int numIDs,
      const int* localIDs,
      const double* data,
      bool sumInto=true,
      int vectorIndex=0);

  void setCommSizes();
  virtual int gatherFromOverlap(bool accumulate = true);

  virtual int copyOutFieldData(int fieldID,
             int idType,
             int numIDs,
             const int* IDs,
             double* data,
             int vectorIndex=0);

  virtual int giveToUnderlyingVector(int numValues,
             const int* indices,
             const double* values,
             bool sumInto=true,
             int vectorIndex=0) = 0;

  virtual int copyOutOfUnderlyingVector(int numValues,
          const int* indices,
          double* values,
          int vectorIndex=0) const = 0;

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

  virtual int writeToStream(FEI_OSTREAM& ostrm,
          bool matrixMarketFormat=true);

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

  void set_vector_space(fei::SharedPtr<fei::VectorSpace> vspace)
    {
      vecSpace_ = vspace;
    }

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

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

  std::vector<int>& work_indices() { return( work_indices_ ); }
  std::vector<int>& work_indices2(){ return( work_indices2_); }

  bool haveFEVector() { return( haveFEVector_ ); }
  void setFEVector(bool flag) {haveFEVector_ = flag; }

  std::vector<CSVec*>& remotelyOwned() { return( remotelyOwned_ ); }
  const std::vector<CSVec*>& remotelyOwned() const { return( remotelyOwned_ ); }
  std::vector<int>& remotelyOwnedProcs() { return( remotelyOwnedProcs_ ); }
  const std::vector<int>& remotelyOwnedProcs() const { return( remotelyOwnedProcs_ ); }

  fei::CSVec* getRemotelyOwned(int proc) {
    std::vector<int>::iterator iter = std::lower_bound(remotelyOwnedProcs_.begin(), remotelyOwnedProcs_.end(), proc);
    fei::CSVec* return_vec = NULL;
    size_t offset = iter - remotelyOwnedProcs_.begin();
    if (iter == remotelyOwnedProcs_.end() || *iter != proc) {
      remotelyOwnedProcs_.insert(iter, proc);
      return_vec = new fei::CSVec;
      remotelyOwned_.insert(remotelyOwned_.begin()+offset, return_vec);
    }
    else {
      return_vec = remotelyOwned_[offset];
    }
 
    return return_vec;
  }

  const fei::CSVec* getRemotelyOwned(int proc) const {
    std::vector<int>::const_iterator iter = std::lower_bound(remotelyOwnedProcs_.begin(), remotelyOwnedProcs_.end(), proc);
    if (iter == remotelyOwnedProcs_.end() || *iter != proc) {
      throw std::runtime_error("failed to find remote-vec for specified processor.");
    }

    size_t offset = iter - remotelyOwnedProcs_.begin();
    return remotelyOwned_[offset];
  }

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

 private:
  void pack_send_buffers(const std::vector<int>& sendProcs,
                       const std::vector<fei::CSVec*>& remotelyOwned,
                       std::vector<std::vector<char> >& send_chars,
                       bool resize_buffer,
                       bool zeroRemotelyOwnedAfterPacking);

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

  MPI_Comm comm_;

  int firstLocalOffset_, lastLocalOffset_, numLocal_;

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

  bool haveFEVector_;

  std::vector<int> remotelyOwnedProcs_;
  std::vector<CSVec*> remotelyOwned_;
  std::vector<int> sendProcs_;
  std::vector<int> recvProcs_;
  std::vector<int> recv_sizes_;
  std::vector<std::vector<char> > recv_chars_;
  std::vector<std::vector<char> > send_chars_;
  bool sendRecvProcsNeedUpdated_;

  bool overlapAlreadySet_;
  std::string dbgprefix_;
};//class Vector_core

}//namespace fei

#endif