Teko_ProbingPreconditionerFactory.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_ProbingPreconditionerFactory.hpp"
 
#ifdef Teko_ENABLE_Isorropia
 
#include "Teko_EpetraOperatorWrapper.hpp"
 
#include "Thyra_get_Epetra_Operator.hpp"
#include "Thyra_EpetraLinearOp.hpp"
#include "Epetra_CrsMatrix.h"
 
using Teuchos::rcp;
using Teuchos::RCP;
using Teuchos::rcp_dynamic_cast;
using Teuchos::rcpFromRef;
 
namespace Teko {
 
/*****************************************************/
 
ProbingPreconditionerFactory::ProbingPreconditionerFactory() {
  prober = rcp(new Isorropia::Epetra::Prober);
}
 
LinearOp ProbingPreconditionerFactory::buildPreconditionerOperator(
    LinearOp& lo, PreconditionerState& state) const {
  // make an epetra operator to be probed
  RCP<Epetra_Operator> epetraLo = rcp(new Teko::Epetra::EpetraOperatorWrapper(lo));
 
  // build color scheme
  prober->color();
 
  // probe operator: take me to your leader
  RCP<Epetra_CrsMatrix> retOp = prober->probe(*epetraLo);
  Teko::LinearOp probedOp     = Thyra::epetraLinearOp(retOp);
 
  return Teko::buildInverse(*invFactory_, probedOp);
}
 
void ProbingPreconditionerFactory::initializeFromParameterList(const Teuchos::ParameterList& pl) {
  RCP<const InverseLibrary> invLib = getInverseLibrary();
 
  const std::string inverse_type           = "Inverse Type";
  const std::string probing_graph_operator = "Probing Graph Operator";
  const std::string probing_graph          = "Probing Graph";
  const std::string user_graph             = "User Will Set Probing Graph";
 
  // get string specifying default inverse
  std::string invStr = "Amesos";
  if (pl.isParameter(inverse_type)) invStr = pl.get<std::string>(inverse_type);
 
  if (pl.isParameter(probing_graph_operator))
    setGraphOperator(pl.get<Teko::LinearOp>(probing_graph_operator));
  else if (pl.isParameter(probing_graph))
    setGraph(pl.get<RCP<const Epetra_CrsGraph> >(probing_graph));
  else if (pl.isParameter(user_graph) && pl.get<bool>("User Will Set Probing Graph")) {
    // noop
  } else {
    Teuchos::RCP<Teko::RequestHandler> rh = getRequestHandler();
    rh->preRequest<RCP<const Epetra_CrsGraph> >(Teko::RequestMesg("Probing Graph"));
    setGraph(rh->request<RCP<const Epetra_CrsGraph> >(Teko::RequestMesg("Probing Graph")));
  }
 
  setInverseFactory(invLib->getInverseFactory(invStr));
}
 
void ProbingPreconditionerFactory::setGraphOperator(const Teko::LinearOp& graphOp) {
  RCP<const Epetra_CrsMatrix> crsMatrix =
      rcp_dynamic_cast<const Epetra_CrsMatrix>(Thyra::get_Epetra_Operator(*graphOp));
  setGraph(Teuchos::rcpFromRef(crsMatrix->Graph()));
}
 
void ProbingPreconditionerFactory::setGraph(const Teuchos::RCP<const Epetra_CrsGraph>& graph) {
  prober->setGraph(graph);
}
 
void ProbingPreconditionerFactory::setProberList(const Teuchos::ParameterList& list) {
  prober->setList(list);
}
 
}  // end namespace Teko
 
#endif