Epetra_OskiMatrix.h

Go to the documentation of this file.

/*
//@HEADER
// ************************************************************************
//
//               Epetra: Linear Algebra Services Package
//                 Copyright 2011 Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ************************************************************************
//@HEADER
*/

// Author: Ian Karlin ikarlin@sandia.gov 05-28-2008

#ifndef EPETRA_OSKIMATRIX_H
#define EPETRA_OSKIMATRIX_H

#include "Epetra_OskiMultiVector.h"
#include "Epetra_OskiVector.h"
#include "Epetra_CrsMatrix.h"
#include "Epetra_OskiPermutation.h"
#include "Teuchos_ParameterList.hpp"
#include "Epetra_Comm.h"
extern "C" {
  #include "oski/oski.h"
}

class Epetra_OskiVector;
class Epetra_OskiMultiVector;
class Teuchos_ParameterList;
class Epetra_OskiPermutation;


class Epetra_OskiMatrix: public Epetra_CrsMatrix{
 public:

        Epetra_OskiMatrix(const Epetra_OskiMatrix& Source); //not in use for now


  Epetra_OskiMatrix(const Epetra_CrsMatrix& Source, const Teuchos::ParameterList& List);
  
  virtual ~Epetra_OskiMatrix();



  int ReplaceMyValues(int MyRow,
          int NumEntries,
          double* Values,
          int* Indices);


  int SumIntoMyValues(int MyRow,
          int NumEntries,
          double* Values,
          int* Indices);



  int ExtractDiagonalCopy(Epetra_Vector& Diagonal) const;
  

  int ReplaceDiagonalValues(const Epetra_OskiVector& Diagonal);



    int Multiply(bool TransA,
             const Epetra_Vector& x,
         Epetra_Vector& y) const;
  

    int Multiply(bool TransA,
             const Epetra_Vector& x,
         Epetra_Vector& y,
         double Alpha,
         double Beta = 0.0) const;
  

    int Multiply(bool TransA,
               const Epetra_MultiVector& X,
             Epetra_MultiVector& Y) const;


    int Multiply(bool TransA,
               const Epetra_MultiVector& X,
             Epetra_MultiVector& Y,
         double Alpha,
             double Beta = 0.0) const;


        int Solve(bool Upper, bool TransA, bool UnitDiagonal, const Epetra_Vector& x, Epetra_Vector &y) const;


        int Solve(bool TransA, const Epetra_Vector& x, Epetra_Vector& y, double Alpha = 1.0) const;


        int Solve(bool Upper, bool TransA, bool UnitDiagonal, const Epetra_MultiVector& X, Epetra_MultiVector& Y) const;


        int Solve(bool TransA, const Epetra_MultiVector& X, Epetra_MultiVector& Y, double Alpha = 1.0) const;



  int MatTransMatMultiply(bool ATA,
        const Epetra_Vector& x,
        Epetra_Vector& y,
        Epetra_Vector* t,
        double Alpha = 1.0,
        double Beta = 0.0) const;


  int MatTransMatMultiply(bool ATA,
        const Epetra_MultiVector& X,
        Epetra_MultiVector& Y,
        Epetra_MultiVector* T,
        double Alpha = 1.0,
        double Beta = 0.0) const;
  

  int MultiplyAndMatTransMultiply(bool TransA,
          const Epetra_Vector& x,
          Epetra_Vector& y,
          const Epetra_Vector& w,
          Epetra_Vector& z,
          double Alpha = 1.0,
          double Beta = 0.0,
          double Omega = 1.0,
          double Zeta = 0.0) const;


  int MultiplyAndMatTransMultiply(bool TransA,
          const Epetra_MultiVector& X,
          Epetra_MultiVector& Y,
          const Epetra_MultiVector& W,
          Epetra_MultiVector& Z,
          double Alpha = 1.0,
          double Beta = 0.0,
          double Omega = 1.0,
          double Zeta = 0.0) const;


  int MatPowMultiply(bool TransA,
         const Epetra_Vector& x,
         Epetra_Vector& y,
         Epetra_MultiVector& T,
         int Power = 2,
         double Alpha = 1.0,
         double Beta = 0.0) const;


  int MatPowMultiply(bool TransA,
         const Epetra_Vector& x,
         Epetra_Vector& y,
         int Power = 2,
         double Alpha = 1.0,
         double Beta = 0.0) const;



  int SetHint(const Teuchos::ParameterList& List);

  

  int SetHintMultiply(bool TransA,
          double Alpha,
          const Epetra_OskiMultiVector& InVec,
          double Beta,
          const Epetra_OskiMultiVector& OutVec,
          int NumCalls,
          const Teuchos::ParameterList& List);
  

  int SetHintSolve(bool TransA,
             double Alpha,
             const Epetra_OskiMultiVector& Vector,
         int NumCalls,
         const Teuchos::ParameterList& List);
  

  int SetHintMatTransMatMultiply(bool ATA,
                     double Alpha,
                 const Epetra_OskiMultiVector& InVec,
                 double Beta,
               const Epetra_OskiMultiVector& OutVec,
               const Epetra_OskiMultiVector& Intermediate,
                 int NumCalls,
                 const Teuchos::ParameterList& List);


  int SetHintMultiplyAndMatTransMultiply(bool TransA,
                         double Alpha,
                     const Epetra_OskiMultiVector& InVec,
                     double Beta,
                     const Epetra_OskiMultiVector& OutVec,
                         double Omega,
                     const Epetra_OskiMultiVector& InVec2,
                     double Zeta,
                     const Epetra_OskiMultiVector& OutVec2,
                     int NumCalls,
                     const Teuchos::ParameterList& List);


  int SetHintPowMultiply(bool TransA,
             double Alpha,
             const Epetra_OskiMultiVector& InVec,
             double Beta,
             const Epetra_OskiMultiVector& OutVec,
             const Epetra_OskiMultiVector& Intermediate,
             int Power,
             int NumCalls,
             const Teuchos::ParameterList& List);


  int TuneMatrix();


  int IsMatrixTransformed() const;

  const Epetra_OskiMatrix& ViewTransformedMat() const;

  const Epetra_OskiPermutation& ViewRowPermutation() const;
  
  const Epetra_OskiPermutation& ViewColumnPermutation() const;
  

  char* GetMatrixTransforms() const;


  int ApplyMatrixTransforms(const char* Transforms);

 protected:

 private:
  const Epetra_CrsMatrix* Epetra_View_;
  oski_matrix_t A_tunable_;
  bool Copy_Created_;
};
#endif /* EPETRA_OSKIMATRIX_H */