fei_VectorReducer.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_VectorReducer_hpp_
#define _fei_VectorReducer_hpp_
 
#include <fei_iosfwd.hpp>
#include <fei_VectorSpace.hpp>
#include <fei_Reducer.hpp>
#include <fei_Vector.hpp>
 
#undef fei_file
#define fei_file "fei_VectorReducer.hpp"
 
#include <fei_ErrMacros.hpp>
 
namespace fei {
 
  class VectorReducer : public fei::Vector {
  public:
 
    VectorReducer(fei::SharedPtr<fei::Reducer> reducer,
                  fei::SharedPtr<fei::Vector> target,
            bool isSolutionVector=false);
 
    virtual ~VectorReducer();
 
    fei::SharedPtr<fei::Vector> getTargetVector()
      { return(target_); }
 
    const char* typeName() const { return(target_->typeName()); }
 
    int update(double a,
         const fei::Vector* x,
         double b);
 
    int scatterToOverlap();
 
    void setCommSizes() { target_->setCommSizes(); }
 
    int gatherFromOverlap(bool accumulate = true);
 
    int putScalar(double scalar);
 
    int sumIn(int numValues, const int* indices, const double* values,
        int vectorIndex=0);
 
    int copyIn(int numValues, const int* indices, const double* values,
         int vectorIndex=0);
 
    fei::SharedPtr<fei::VectorSpace> getVectorSpace() const
      { return(target_->getVectorSpace()); }
 
    void setVectorSpace(fei::SharedPtr<fei::VectorSpace> vecSpace)
    { target_->setVectorSpace( vecSpace ); }
 
    int sumInFieldData(int fieldID,
           int idType,
           int numIDs,
           const int* IDs,
           const double* data,
           int vectorIndex=0);
 
    int copyInFieldData(int fieldID,
      int idType,
      int numIDs,
      const int* IDs,
      const double* data,
      int vectorIndex=0);
 
    int copyInFieldDataLocalIDs(int fieldID,
      int idType,
      int numIDs,
      const int* localIDs,
      const double* data,
      int vectorIndex=0);
 
    int copyOutFieldData(int fieldID,
       int idType,
       int numIDs,
       const int* IDs,
       double* data,
       int vectorIndex=0);
 
    int writeToFile(const char* filename,
        bool matrixMarketFormat=true);
 
    int writeToStream(FEI_OSTREAM& ostrm,
          bool matrixMarketFormat=true);
 
    int copyOut(int numValues,
    const int* indices,
    double* values,
    int vectorIndex=0) const;
 
  private:
    int copyOut_FE(int nodeNumber, int dofOffset, double& value);
 
    int giveToUnderlyingVector(int numValues,
             const int* indices,
             const double* values,
             bool sumInto=true,
             int vectorIndex=0);
 
    int sumIntoFEVector(int blockID,
      int connOffset,
      int numNodes,
      const int* nodeNumbers,
      const int* numIndicesPerNode,
      const double* values);
 
    fei::SharedPtr<fei::Reducer> reducer_;
    fei::SharedPtr<fei::Vector> target_;
    bool isSolution_;
 
    int localProc_;
    int numProcs_;
  };//class VectorReducer
 
} //namespace fei
 
#endif // _fei_VectorReducer_hpp_