Teko_MLPreconditionerFactory.hpp

#ifndef __Teko_MLPrecondtionerFactory_hpp__
#define __Teko_MLPrecondtionerFactory_hpp__

#include "Teko_BlockPreconditionerFactory.hpp"

#include "ml_include.h"
#include "ml_operator.h"

namespace ML_Epetra {
   class MultiLevelPreconditioner;
}

namespace Teko {

class MLPreconditionerState : public BlockPreconditionerState {
public:
   MLPreconditionerState();

   Teuchos::RCP<ML_Epetra::MultiLevelPreconditioner> 
   constructMLPreconditioner(const Teuchos::ParameterList & mainList,
                             const std::vector<Teuchos::RCP<const Teuchos::ParameterList> > & coarseningParams);

   // Set functions

   void setMLComm(ML_Comm * comm);

   void setMLOperator(ML_Operator * op);

   void setIsFilled(bool value);

   void setAggregationMatrices(const std::vector<Epetra_RowMatrix *> & diags);

   // Get functions

   bool isFilled() const;

protected:
   static void cleanup_ML_Comm(ML_Comm * mlComm);
   static void cleanup_ML_Operator(ML_Operator * mlComm);

   bool isFilled_;
   Teuchos::RCP<ML_Comm> mlComm_; // note that this has to be properly clean up!
   Teuchos::RCP<ML_Operator> mlOp_; // note that this has to be properly clean up!

   std::vector<Epetra_RowMatrix*> diagonalOps_; // patterns for setting up aggregation
   Teuchos::RCP<ML_Epetra::MultiLevelPreconditioner> mlPreconditioner_;
};

class MLPreconditionerFactory : public BlockPreconditionerFactory {
public:
   MLPreconditionerFactory();

   virtual LinearOp buildPreconditionerOperator(BlockedLinearOp & blo,BlockPreconditionerState & state) const;

   virtual Teuchos::RCP<PreconditionerState> buildPreconditionerState() const;

   void initializeFromParameterList(const Teuchos::ParameterList & settings);

protected:
   
   void fillMLPreconditionerState(const BlockedLinearOp & blo,MLPreconditionerState & mlState) const;

   int blockRowCount_;
   std::vector<Teuchos::RCP<const Teuchos::ParameterList> > coarseningParams_;
   Teuchos::ParameterList mainParams_;
};

} // end namespace Teko

#endif