Ifpack_SerialTriDiSolver.h

/*
//@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
*/
 
#ifndef IFPACK_SERIALTRIDISOLVER_H
#define IFPACK_SERIALTRIDISOLVER_H
class Ifpack_SerialTriDiMatrix;
//class Epetra_SerialDenseVector;
class Epetra_SerialDenseMatrix;
 
#include "Epetra_Object.h"
#include "Epetra_CompObject.h"
#include "Epetra_BLAS.h"
#include "Teuchos_LAPACK.hpp"
 
 
 
//=========================================================================
class EPETRA_LIB_DLL_EXPORT Ifpack_SerialTriDiSolver :
  public Epetra_CompObject, public Epetra_BLAS,
  public Epetra_Object    {
  public:
  
 
  Ifpack_SerialTriDiSolver();
 
 
  virtual ~Ifpack_SerialTriDiSolver();
 
 
 
  int SetMatrix(Ifpack_SerialTriDiMatrix & A);
 
 
  int SetVectors(Epetra_SerialDenseMatrix & X, Epetra_SerialDenseMatrix & B);
 
 
 
 
 
  //  void FactorWithEquilibration(bool Flag) {Equilibrate_ = Flag; return;};
 
  void SolveWithTranspose(bool Flag) {Transpose_ = Flag; if (Flag) TRANS_ = 'T'; else TRANS_ = 'N'; return;};
 
  void SolveToRefinedSolution(bool Flag) {RefineSolution_ = Flag; return;};
 
 
  void EstimateSolutionErrors(bool Flag) ;
 
 
 
 
  virtual int Factor(void);
 
 
  virtual int Solve(void);
 
 
  virtual int Invert(void);
 
 
  virtual int ApplyRefinement(void);
 
 
  // int UnequilibrateLHS(void);
 
 
  virtual int ReciprocalConditionEstimate(double & Value);
 
 
 
  bool Transpose() {return(Transpose_);};
 
  bool Factored() {return(Factored_);};
 
  bool SolutionErrorsEstimated() {return(SolutionErrorsEstimated_);};
 
  bool Inverted() {return(Inverted_);};
 
  bool ReciprocalConditionEstimated() {return(ReciprocalConditionEstimated_);};
 
  bool Solved() {return(Solved_);};
 
  bool SolutionRefined() {return(SolutionRefined_);};
 
 
 
   Ifpack_SerialTriDiMatrix * Matrix()  const {return(Matrix_);};
 
   Ifpack_SerialTriDiMatrix * FactoredMatrix()  const {return(Factor_);};
 
  Epetra_SerialDenseMatrix * LHS()  const {return(LHS_);};
 
  Epetra_SerialDenseMatrix * RHS()  const {return(RHS_);};
 
  int N()  const {return(N_);};
 
  double * A()  const {return(A_);};
 
  int LDA()  const {return(LDA_);};
 
  double * B()  const {return(B_);};
 
  int LDB()  const {return(LDB_);};
 
  int NRHS()  const {return(NRHS_);};
 
  double * X()  const {return(X_);};
 
  int LDX()  const {return(LDX_);};
 
  double * AF()  const {return(AF_);};
 
  int LDAF()  const {return(LDAF_);};
 
  int * IPIV()  const {return(IPIV_);};
 
  double ANORM()  const {return(ANORM_);};
 
  double RCOND()  const {return(RCOND_);};
 
 
  double ROWCND()  const {return(ROWCND_);};
 
 
  double COLCND()  const {return(COLCND_);};
 
  double AMAX()  const {return(AMAX_);};
 
  double * FERR()  const {return(FERR_);};
 
  double * BERR()  const {return(BERR_);};
 
 
 
  virtual void Print(std::ostream& os) const;
 protected:
 
  void AllocateWORK() {if (WORK_==0) {LWORK_ = 4*N_; WORK_ = new double[LWORK_];} return;};
  void AllocateIWORK() {if (IWORK_==0) IWORK_ = new int[N_]; return;};
  void InitPointers();
  void DeleteArrays();
  void ResetMatrix();
  void ResetVectors();
 
  bool Transpose_;
  bool Factored_;
  bool EstimateSolutionErrors_;
  bool SolutionErrorsEstimated_;
  bool Solved_;
  bool Inverted_;
  bool ReciprocalConditionEstimated_;
  bool RefineSolution_;
  bool SolutionRefined_;
 
  char TRANS_;
 
  int N_;
  int Min_MN_;
  int NRHS_;
  int LDA_;
  int LDAF_;
  int LDB_;
  int LDX_;
  int INFO_;
  int LWORK_;
 
  int * IPIV_;
  int * IWORK_;
 
  double ANORM_;
  double RCOND_;
  double ROWCND_;
  double COLCND_;
  double AMAX_;
 
  Ifpack_SerialTriDiMatrix * Matrix_;
  Epetra_SerialDenseMatrix * LHS_;
  Epetra_SerialDenseMatrix * RHS_;
  Ifpack_SerialTriDiMatrix * Factor_;
 
  double * A_;
  double * FERR_;
  double * BERR_;
  double * AF_;
  double * WORK_;
 
  double * B_;
  double * X_;
 
 
 private:
  Teuchos::LAPACK<int,double> lapack;
  // Ifpack_SerialTriDiSolver copy constructor (put here because we don't want user access)
 
  Ifpack_SerialTriDiSolver(const Ifpack_SerialTriDiSolver& Source);
  Ifpack_SerialTriDiSolver & operator=(const Ifpack_SerialTriDiSolver& Source);
};
 
#endif /* EPETRA_SERIALTRIDISOLVER_H */