fei_MatrixTraits_FillableMat.hpp

/*--------------------------------------------------------------------*/
/*    Copyright 2008 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_MatrixTraits_FillableMat_hpp_
#define _fei_MatrixTraits_FillableMat_hpp_

//This file defines matrix traits for fei::FillableMat matrices
//

#include <fei_CSRMat.hpp>
#include <fei_CSVec.hpp>
#include <fei_Vector_Impl.hpp>

namespace fei {

  template<>
  struct MatrixTraits<FillableMat> {

    static const char* typeName()
      { return("FillableMat"); }

    static double* getBeginPointer(FillableMat* /*mat*/)
      {
        return NULL;
      }

    static int getOffset(FillableMat* /*mat*/, int /*row*/, int /*col*/)
      {
        return -1;
      }

    static int setValues(FillableMat* mat, double scalar)
      {
        mat->setValues(scalar);
        return(0);
      }

    static int getNumLocalRows(FillableMat* mat, int& numRows)
    {
      numRows = mat->getNumRows();
      return(0);
    }

    static int getRowLength(FillableMat* mat, int row, int& length)
      {
        try {
          const CSVec* matrixrow = mat->getRow(row);
          length = matrixrow->size();
        }
        catch(...) {
          length = 0;
        }
        return( 0 );
      }

    static int copyOutRow(FillableMat* mat,
                      int row, int len, double* coefs, int* indices)
      {
        try {
          const CSVec* matrixrow = mat->getRow(row);

          const std::vector<int>& row_indices = matrixrow->indices();
          const std::vector<double>& row_coefs = matrixrow->coefs();
          const int rowlen = row_indices.size();
          for(int i=0; i<rowlen; ++i) {
            if (i >= len) break;
            coefs[i] = row_coefs[i];
            indices[i] = row_indices[i];
          }
        }
        catch(...) {
          //what should we do here???
        }

        return( 0 );
      }

    static int putValuesIn(FillableMat* mat,
                           int numRows, const int* rows,
                           int numCols, const int* cols,
                           const double* const* values,
                           bool sum_into)
      {
        if (numCols < 1 || numRows < 1) return(0);
        if (sum_into) {
          for(int i=0; i<numRows; ++i) {
            mat->sumInRow(rows[i], cols, values[i], numCols);
          }
        }
        else {
          for(int i=0; i<numRows; ++i) {
            mat->putRow(rows[i], cols, values[i], numCols);
          }
        }

        return( 0 );
      }

    static int globalAssemble(FillableMat* mat)
    {
      return(0);
    }

    static int matvec(FillableMat* mat,
                      fei::Vector* x,
                      fei::Vector* y)
    {
      fei::Vector_Impl<CSVec>* fvx =
        dynamic_cast<fei::Vector_Impl<CSVec>* >(x);
      fei::Vector_Impl<CSVec>* fvy =
        dynamic_cast<fei::Vector_Impl<CSVec>* >(y);

      if (fvx == NULL || fvy == NULL) {
        return(-1);
      }

      fei::CSRMat A(*mat);
      fei::CSVec csx(*(fvx->getUnderlyingVector()));
      fei::CSVec csy(*(fvy->getUnderlyingVector()));

      fei::multiply_CSRMat_CSVec(A, csx, csy);

      return( 0 );
    }

  };//struct MatrixTraits
}//namespace fei

#endif // _fei_MatrixTraits_FillableMat_hpp_