Teko_PreconditionerFactory.cpp

// @HEADER
// *****************************************************************************
//      Teko: A package for block and physics based preconditioning
//
// Copyright 2010 NTESS and the Teko contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @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_HierarchicalGaussSeidelPreconditionerFactory.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_AdaptivePreconditionerFactory.hpp"
#include "Teko_ProbingPreconditionerFactory.hpp"
#include "Teko_IdentityPreconditionerFactory.hpp"
#include "NS/Teko_LSCPreconditionerFactory.hpp"
#include "NS/Teko_SIMPLEPreconditionerFactory.hpp"
#include "NS/Teko_TimingsSIMPLEPreconditionerFactory.hpp"
 
#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<HierarchicalGaussSeidelPreconditionerFactory>());
  precFactoryBuilder_.addClone("Hierarchical 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<NS::TimingsSIMPLEPreconditionerFactory>());
  precFactoryBuilder_.addClone("NS SIMPLE-Timed", 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);
 
  clone = rcp(new AutoClone<IdentityPreconditionerFactory>());
  precFactoryBuilder_.addClone("Identity", clone);
 
  clone = rcp(new AutoClone<AdaptivePreconditionerFactory>());
  precFactoryBuilder_.addClone("Adaptive", clone);
 
  clone = rcp(new AutoClone<ProbingPreconditionerFactory>());
  precFactoryBuilder_.addClone("Probing Preconditioner", clone);
}
 
void PreconditionerFactory::getPreconditionerFactoryNames(std::vector<std::string> &names) {
  // initialize the defaults if necessary
  if (precFactoryBuilder_.cloneCount() == 0) initializePrecFactoryBuilder();
  precFactoryBuilder_.getCloneNames(names);
}
 
}  // end namespace Teko