Teko_PreconditionerFactory.cpp

/*
// @HEADER
// 
// ***********************************************************************
// 
//      Teko: A package for block and physics based preconditioning
//                  Copyright 2010 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 Eric C. Cyr (eccyr@sandia.gov)
// 
// ***********************************************************************
// 
// @HEADER

*/

#include "Teko_Config.h"
#include "Teko_PreconditionerFactory.hpp"

#include "Teko_InverseLibrary.hpp"
#include "Teko_Preconditioner.hpp"

// Specific preconditioners included for dynamic creation
#include "Teko_JacobiPreconditionerFactory.hpp"
#include "Teko_GaussSeidelPreconditionerFactory.hpp"
#include "Teko_AddPreconditionerFactory.hpp"
#include "Teko_MultPreconditionerFactory.hpp"
#include "Teko_LU2x2PreconditionerFactory.hpp"
#include "Teko_IterativePreconditionerFactory.hpp"
#include "Teko_DiagnosticPreconditionerFactory.hpp"
#include "Teko_DiagonallyScaledPreconditionerFactory.hpp"
#include "Teko_DiagonalPreconditionerFactory.hpp"
#include "Teko_ProbingPreconditionerFactory.hpp"
#include "NS/Teko_LSCPreconditionerFactory.hpp"
#include "NS/Teko_SIMPLEPreconditionerFactory.hpp"

#ifdef Teko_ENABLE_ML_SMOOTHERS
#include "Teko_SmootherPreconditionerFactory.hpp"
#include "Teko_MLPreconditionerFactory.hpp"
#endif


#include "Thyra_DefaultPreconditioner.hpp"

using namespace Thyra;
using Teuchos::RCP;

namespace Teko {

bool PreconditionerFactory::isCompatible(const Thyra::LinearOpSourceBase<double> &fwdOpSrc) const
{
   RCP<const Thyra::LinearOpBase<double> > A = fwdOpSrc.getOp();
   return A!=Teuchos::null;
}

RCP<Thyra::PreconditionerBase<double> > PreconditionerFactory::createPrec() const
{
   // build a preconditioner, give it some inital state
   RCP<Preconditioner> bp = rcp(new Preconditioner());
   bp->setStateObject(buildPreconditionerState());
   bp->getStateObject()->setInitialized(false);

   return bp;
}

void PreconditionerFactory::initializePrec(const RCP<const LinearOpSourceBase<double> > & ASrc,
                    PreconditionerBase<double> * prec,
                    const ESupportSolveUse supportSolveUse) const
{
   // get the blocked linear operator
   LinearOp A = Teuchos::rcp_const_cast<Thyra::LinearOpBase<double> >(ASrc->getOp());

   Preconditioner * blkPrec = dynamic_cast<Preconditioner *>(prec);
   TEUCHOS_ASSERT(blkPrec!=0);
 
   // grab the state object
   RCP<PreconditionerState> state = blkPrec->getStateObject();
   state->setInitialized(false);

   // build the preconditioner
   const RCP<const LinearOpBase<double> > M = buildPreconditionerOperator(A,*state);

   // set the request handler for the 
   setOpRequestHandler(*this,M);

   // must first cast that to be initialized
   DefaultPreconditioner<double> & dPrec = Teuchos::dyn_cast<DefaultPreconditioner<double> >(*prec);
   dPrec.initializeUnspecified(Teuchos::rcp_const_cast<LinearOpBase<double> >(M));
}

void PreconditionerFactory::initializePrec(const RCP<const LinearOpSourceBase<double> > & ASrc,
                                                const RCP<const Thyra::MultiVectorBase<double> > & solnVec,
                                                PreconditionerBase<double> * prec,
                                                const ESupportSolveUse supportSolveUse) const
{
   Preconditioner * blkPrec = dynamic_cast<Preconditioner *>(prec);
   blkPrec->setSourceVector(Teuchos::rcp_const_cast<Thyra::MultiVectorBase<double> >(solnVec));

   initializePrec(ASrc,prec,supportSolveUse);
}

void PreconditionerFactory::uninitializePrec(PreconditionerBase<double> * prec, 
                      RCP<const LinearOpSourceBase<double> > * fwdOpSrc,
                      ESupportSolveUse *supportSolveUse) const
{
   // Preconditioner * blkPrec = dynamic_cast<Preconditioner *>(prec);

   // what do I do here?
   TEUCHOS_TEST_FOR_EXCEPT_MSG(true,"\"PreconditionerFactory::uninitializePrec not implemented\"");
}

// for ParameterListAcceptor

void PreconditionerFactory::setParameterList(const RCP<Teuchos::ParameterList> & paramList)
{
   paramList_ = paramList;
}

RCP< Teuchos::ParameterList > PreconditionerFactory::getNonconstParameterList()
{
   return paramList_;
}

RCP< Teuchos::ParameterList > PreconditionerFactory::unsetParameterList()
{
   RCP<Teuchos::ParameterList> _paramList = paramList_;
   paramList_ = Teuchos::null;
   return _paramList;
}

void PreconditionerFactory::setInverseLibrary(const RCP<const InverseLibrary> & il)
{
   inverseLibrary_ = il;
}

RCP<const InverseLibrary> PreconditionerFactory::getInverseLibrary() const
{
   // lazily build the inverse library only when needed
   if(inverseLibrary_==Teuchos::null)
      return InverseLibrary::buildFromStratimikos();

   return inverseLibrary_;
}

// Static members and methods

void PreconditionerFactory::setOpRequestHandler(const RequestHandlerContainer & rhc,const LinearOp & op)
{
   ModifiableLinearOp mlo = Teuchos::rcp_const_cast<Thyra::LinearOpBase<double> >(op);

   // conditionally set the request handler
   RCP<RequestHandlerContainer> reqHandCont = Teuchos::rcp_dynamic_cast<RequestHandlerContainer>(mlo);
   if(reqHandCont!=Teuchos::null) {
      reqHandCont->setRequestHandler(rhc.getRequestHandler());
   }
   else {
      // is null
   }
   
}

CloneFactory<PreconditionerFactory> PreconditionerFactory::precFactoryBuilder_;

RCP<PreconditionerFactory> 
PreconditionerFactory::buildPreconditionerFactory(const std::string & name,
                                                       const Teuchos::ParameterList & settings,
                                                       const RCP<const InverseLibrary> & invLib)
{
   Teko_DEBUG_SCOPE("PreconditionerFactory::buildPreconditionerFactory",10);

   // initialize the defaults if necessary
   if(precFactoryBuilder_.cloneCount()==0) initializePrecFactoryBuilder();

   // request the preconditioner factory from the CloneFactory
   RCP<PreconditionerFactory> precFact = precFactoryBuilder_.build(name);

   Teko_DEBUG_MSG_BEGIN(5);
      DEBUG_STREAM << "Looked up \"" << name << "\"" << std::endl;
      DEBUG_STREAM << "Built " << precFact << std::endl;
   Teko_DEBUG_MSG_END();

   if(precFact==Teuchos::null)  
      return Teuchos::null;

   // add in the inverse library
   if(invLib!=Teuchos::null) {
      precFact->setInverseLibrary(invLib);
      precFact->setRequestHandler(invLib->getRequestHandler());
   }

   // now that inverse library has been set,
   // pass in the parameter list
   precFact->initializeFromParameterList(settings);

   return precFact;
}

void PreconditionerFactory::addPreconditionerFactory(const std::string & name,const RCP<Cloneable> & clone)
{
   // initialize the defaults if necessary
   if(precFactoryBuilder_.cloneCount()==0) initializePrecFactoryBuilder();

   // add clone to builder
   precFactoryBuilder_.addClone(name,clone); 
}

void PreconditionerFactory::initializePrecFactoryBuilder()
{
   RCP<Cloneable> clone;

   // add various preconditioners to factory
   clone = rcp(new AutoClone<LU2x2PreconditionerFactory>());
   precFactoryBuilder_.addClone("Block LU2x2",clone);

   clone = rcp(new AutoClone<JacobiPreconditionerFactory>());
   precFactoryBuilder_.addClone("Block Jacobi",clone);

   clone = rcp(new AutoClone<GaussSeidelPreconditionerFactory>());
   precFactoryBuilder_.addClone("Block Gauss-Seidel",clone);

   clone = rcp(new AutoClone<AddPreconditionerFactory>());
   precFactoryBuilder_.addClone("Block Add",clone);

   clone = rcp(new AutoClone<MultPreconditionerFactory>());
   precFactoryBuilder_.addClone("Block Multiply",clone);

   clone = rcp(new AutoClone<NS::LSCPreconditionerFactory>());
   precFactoryBuilder_.addClone("NS LSC",clone);

   clone = rcp(new AutoClone<NS::SIMPLEPreconditionerFactory>());
   precFactoryBuilder_.addClone("NS SIMPLE",clone);

   clone = rcp(new AutoClone<IterativePreconditionerFactory>());
   precFactoryBuilder_.addClone("Iterative Preconditioner",clone);

   clone = rcp(new AutoClone<DiagonalPreconditionerFactory>());
   precFactoryBuilder_.addClone("Explicit Diagonal Preconditioner",clone);

   clone = rcp(new AutoClone<DiagnosticPreconditionerFactory>());
   precFactoryBuilder_.addClone("Diagnostic Inverse",clone);

   clone = rcp(new AutoClone<DiagonallyScaledPreconditionerFactory>());
   precFactoryBuilder_.addClone("Diagonal Scaling",clone);

#ifdef Teko_ENABLE_Isorropia
   clone = rcp(new AutoClone<ProbingPreconditionerFactory>());
   precFactoryBuilder_.addClone("Probing Preconditioner",clone);
#endif

#ifdef Teko_ENABLE_ML_SMOOTHERS
   clone = rcp(new AutoClone<MLPreconditionerFactory>());
   precFactoryBuilder_.addClone("Blocked ML Preconditioner",clone);
#endif
}

void PreconditionerFactory::getPreconditionerFactoryNames(std::vector<std::string> & names)
{ 
   // initialize the defaults if necessary
   if(precFactoryBuilder_.cloneCount()==0) initializePrecFactoryBuilder();
   precFactoryBuilder_.getCloneNames(names); 
}

} // end namespace Teko