Amesos_Lapack.h

Go to the documentation of this file.

// @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_LAPACK_H
#define AMESOS_LAPACK_H
 
#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_Comm.h"
#include "Epetra_Map.h"
#include "Epetra_SerialDenseMatrix.h"
#include "Epetra_SerialDenseVector.h"
#include "Epetra_SerialDenseSolver.h"
#include "Epetra_CrsMatrix.h"
#include "Epetra_Import.h"
#include "Epetra_Export.h"
class Epetra_RowMatrix;
class Epetra_LinearProblem;
#include "Teuchos_RCP.hpp"
 
 
class Amesos_Lapack: public Amesos_BaseSolver,
                     private Amesos_Time,
                     private Amesos_NoCopiable,
                     private Amesos_Utils,
         private Amesos_Control, 
                     private Amesos_Status 
{
public: 
 
 
  Amesos_Lapack(const Epetra_LinearProblem& LinearProblem );
 
 
  ~Amesos_Lapack(void);
  
 
 
  int SymbolicFactorization() ;
 
  int NumericFactorization() ;
 
  int Solve();
 
 
 
  const Epetra_LinearProblem *GetProblem() const { return(Problem_); };
 
  bool MatrixShapeOK() const;
 
  int SetUseTranspose(bool UseTranspose_in) {
    UseTranspose_ = UseTranspose_in; 
    return(0);
  }
 
  bool UseTranspose() const {return(UseTranspose_);};
 
  const Epetra_Comm & Comm() const {
    return(GetProblem()->GetOperator()->Comm());
  }
 
 
  void setParameterList(Teuchos::RCP<Teuchos::ParameterList> const& paramList) ;
 
  Teuchos::RCP<Teuchos::ParameterList> unsetParameterList() ;
 
 
  int SetParameters( Teuchos::ParameterList &ParameterList )  ;
 
 
  int GEEV(Epetra_Vector& Er, Epetra_Vector& Ei);
 
  int NumSymbolicFact() const { return( Amesos_Status::NumSymbolicFact_ ); }
 
  int NumNumericFact() const { return( Amesos_Status::NumNumericFact_ ); }
 
  int NumSolve() const { return( Amesos_Status::NumSolve_ ); }
 
  void PrintTiming() const;
  
  void PrintStatus() const;
 
  void GetTiming( Teuchos::ParameterList &TimingParameterList ) const { Amesos_Time::GetTiming(TimingParameterList); }
  
 
protected:
 
  const Epetra_RowMatrix* Matrix() const
  {
    return(Problem_->GetMatrix());
  }
 
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
  inline int NumGlobalRows() const
  {
    return(Matrix()->NumGlobalRows());
  }
#endif
 
  inline long long NumGlobalRows64() const
  {
    return(Matrix()->NumGlobalRows64());
  }
 
  inline int NumMyRows() const
  {
    return(Matrix()->NumMyRows());
  }
 
  inline const Epetra_Map& SerialMap()
  {
    return(*(SerialMap_.get()));
  }
 
  inline Epetra_RowMatrix& SerialMatrix()
  {
    return(*(SerialMatrix_.get()));
  }
 
  inline Epetra_CrsMatrix& SerialCrsMatrix()
  {
    return(*(SerialCrsMatrix_.get()));
  }
 
  const Epetra_Import& MatrixImporter()
  {
    return(*(MatrixImporter_.get()));
  }
 
  const Epetra_Export& RhsExporter()
  {
    return(*(RhsExporter_.get()));
  }
 
  const Epetra_Import& SolutionImporter()
  {
    return(*(SolutionImporter_.get()));
  }
 
  Teuchos::RCP<Teuchos::ParameterList> pl_ ; 
 
  int SolveSerial(Epetra_MultiVector& X,
      const Epetra_MultiVector& B);
  
  int SolveDistributed(Epetra_MultiVector& X,
           const Epetra_MultiVector& B);
  
  int DistributedToSerial();
 
  int SerialToDense();
 
  int DenseToFactored();
 
  Teuchos::RCP<Epetra_RowMatrix> SerialMatrix_;
  Teuchos::RCP<Epetra_CrsMatrix> SerialCrsMatrix_;
  Teuchos::RCP<Epetra_Map> SerialMap_;
  Teuchos::RCP<Epetra_Import> MatrixImporter_;
  Teuchos::RCP<Epetra_Export> RhsExporter_;
  Teuchos::RCP<Epetra_Import> SolutionImporter_;
 
  Epetra_SerialDenseMatrix DenseMatrix_;
  Epetra_SerialDenseMatrix DenseLHS_;
  Epetra_SerialDenseMatrix DenseRHS_;
  Epetra_SerialDenseSolver DenseSolver_;
 
  bool UseTranspose_;
  const Epetra_LinearProblem* Problem_;
 
  int MtxRedistTime_, MtxConvTime_, VecRedistTime_, SymFactTime_, NumFactTime_, SolveTime_;
 
  long long NumGlobalRows_;
  long long NumGlobalNonzeros_;
 
  Teuchos::RCP<Teuchos::ParameterList> ParameterList_ ; 
 
};  // End of  class Amesos_Lapack
#endif /* AMESOS_LAPACK_H */