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_