Ifpack_SerialTriDiSolver.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
*/

#ifndef IFPACK_SERIALTRIDISOLVER_H
#define IFPACK_SERIALTRIDISOLVER_H

#if defined(Ifpack_SHOW_DEPRECATED_WARNINGS)
#ifdef __GNUC__
#warning "The Ifpack package is deprecated"
#endif
#endif
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 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 */