// @HEADER
// ***********************************************************************
//
// Amesos: Direct Sparse Solver Package
// Copyright (2004) Sandia Corporation
//
// Under 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.
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
// @HEADER
#ifndef AMESOS_PARDISO_H
#define AMESOS_PARDISO_H
#if defined(Amesos_SHOW_DEPRECATED_WARNINGS)
#ifdef __GNUC__
#warning "The Amesos package is deprecated"
#endif
#endif
#include "Amesos_ConfigDefs.h"
#include "Amesos_BaseSolver.h"
#include "Amesos_NoCopiable.h"
#include "Amesos_Utils.h"
#include "Amesos_Time.h"
#include "Amesos_Status.h"
#include "Amesos_Control.h"
#include "Epetra_LinearProblem.h"
#include "Epetra_Time.h"
#include "Epetra_Map.h"
#include "Epetra_Import.h"
#include "Epetra_Comm.h"
#include "Epetra_RowMatrix.h"
#include "Epetra_CrsMatrix.h"
#include "Teuchos_ParameterList.hpp"
#include "Teuchos_RCP.hpp"
//! Amesos_Pardiso: Interface to the PARDISO package.
/*!
\author Marzio Sala, SNL 9214
\date Last updated on June 2005
*/
class Amesos_Pardiso: public Amesos_BaseSolver,
private Amesos_Time,
private Amesos_NoCopiable,
private Amesos_Utils,
private Amesos_Control,
private Amesos_Status {
public:
//@{ \name Constructor methods
//! Constructor.
Amesos_Pardiso(const Epetra_LinearProblem& LinearProblem );
//! Destructor.
~Amesos_Pardiso();
//@}
//@{ \name Mathematical functions.
//! Performs SymbolicFactorization on the matrix A.
int SymbolicFactorization() ;
//! Performs NumericFactorization on the matrix A.
int NumericFactorization() ;
//! Solves A X = B (or AT X = B)
int Solve();
//@}
//@{ \name Additional methods required to support the Epetra_Operator interface.
//! Get a pointer to the Problem.
const Epetra_LinearProblem* GetProblem() const { return(Problem_); }
//! Returns true if PARDISO can handle this matrix shape
/*! Returns true if the matrix shape is one that PARDISO can
handle. PARDISO only works with square matrices.
*/
bool MatrixShapeOK() const;
//! SetUseTranpose()
/*!
If SetUseTranspose() is set to true,
\f$A^T X = B\f$ is computed.
*/
int SetUseTranspose(bool UseTranspose) { UseTranspose_ = UseTranspose; return(0); }
//! Returns the current UseTranspose setting.
bool UseTranspose() const { return(UseTranspose_); }
//! Returns a pointer to the Epetra_Comm communicator associated with this matrix.
const Epetra_Comm& Comm() const { return(GetProblem()->GetOperator()->Comm()); }
//! Set parameters from the input parameters list, returns 0 if successful.
int SetParameters( Teuchos::ParameterList &ParameterList );
//! Returns the number of symbolic factorizations performed by this object.
int NumSymbolicFact() const { return( Amesos_Status::NumSymbolicFact_ ); }
//! Returns the number of numeric factorizations performed by this object.
int NumNumericFact() const { return( Amesos_Status::NumNumericFact_ ); }
//! Returns the number of solves performed by this object.
int NumSolve() const { return( Amesos_Status::NumSolve_ ); }
//! Prints timing information
void PrintTiming() const;
//! Prints information about the factorization and solution phases.
void PrintStatus() const;
//! Extracts timing information from the current solver and places it in the parameter list.
void GetTiming( Teuchos::ParameterList &TimingParameterList ) const { Amesos_Time::GetTiming(TimingParameterList); }
//@}
private:
int CheckError(const int error) const;
inline const Epetra_Map& Map() const
{
return(Matrix_->RowMatrixRowMap());
}
inline const Epetra_RowMatrix& Matrix() const
{
return(*Matrix_);
}
inline Epetra_Map& SerialMap()
{
return(*(SerialMap_.get()));
}
inline Epetra_RowMatrix& SerialMatrix()
{
return(*(SerialMatrix_.get()));
}
inline Epetra_CrsMatrix& SerialCrsMatrix()
{
return(*(SerialCrsMatrix_.get()));
}
inline Epetra_Import& Importer()
{
return(*(Importer_.get()));
}
int ConvertToSerial();
int ConvertToPardiso();
int PerformSymbolicFactorization();
int PerformNumericFactorization();
Teuchos::RCP SerialMap_;
Teuchos::RCP SerialCrsMatrix_;
Teuchos::RCP SerialMatrix_;
Teuchos::RCP Importer_;
const Epetra_Map* Map_;
const Epetra_RowMatrix* Matrix_;
//! If \c true, the transpose of A is used.
bool UseTranspose_;
//! Pointer to the linear system problem.
const Epetra_LinearProblem* Problem_;
//! Quick access pointers to the internal timing data.
int MtxConvTime_, MtxRedistTime_, VecRedistTime_;
int SymFactTime_, NumFactTime_, SolveTime_;
// Data for PARDISO
std::vector aa_;
std::vector ia_;
std::vector ja_;
bool pardiso_initialized_ ;
int mtype_;
void* pt_[64];
int iparm_[64];
double dparm_[64];
int maxfct_; // Maximal number of factors with idential nonzero pattern (always 1)
int mnum_; //! Actual matrix for solution phase (always 1)
int msglvl_; //! Output level
int nrhs_; // Number of RHS
Teuchos::ParameterList param_;
}; // class Amesos_Pardiso
#endif