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_