Teko_DiagnosticPreconditionerFactory.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

// Teko includes
#include "Teko_DiagnosticPreconditionerFactory.hpp"

#include "Teko_PreconditionerInverseFactory.hpp"
#include "Teko_DiagnosticLinearOp.hpp"

#include "Teuchos_TimeMonitor.hpp"

namespace Teko {

DiagnosticPreconditionerFactory::DiagnosticPreconditionerFactory()
    : outputStream_(Teko::getOutputStream()),
      invFactory_(Teuchos::null),
      diagString_("<label me!>"),
      printResidual_(false) {}

DiagnosticPreconditionerFactory::DiagnosticPreconditionerFactory(
    const Teuchos::RCP<Teko::InverseFactory>& invFactory, const std::string& label,
    const Teuchos::RCP<std::ostream>& os, bool printResidual)
    : outputStream_(Teko::getOutputStream()),
      invFactory_(invFactory),
      precFactory_(Teuchos::null),
      diagString_(label),
      printResidual_(printResidual) {
  initTimers(diagString_);

  if (os != Teuchos::null) outputStream_ = os;
}

DiagnosticPreconditionerFactory::DiagnosticPreconditionerFactory(
    const Teuchos::RCP<Teko::InverseFactory>& invFactory,
    const Teuchos::RCP<Teko::InverseFactory>& precFactory, const std::string& label,
    const Teuchos::RCP<std::ostream>& os, bool printResidual)
    : outputStream_(Teko::getOutputStream()),
      invFactory_(invFactory),
      precFactory_(precFactory),
      diagString_(label),
      printResidual_(printResidual) {
  initTimers(diagString_);

  if (os != Teuchos::null) outputStream_ = os;
}

double DiagnosticPreconditionerFactory::totalInitialBuildTime() const {
  return buildTimer_->totalElapsedTime() + precBuildTimer_->totalElapsedTime();
}

double DiagnosticPreconditionerFactory::totalRebuildTime() const {
  return rebuildTimer_->totalElapsedTime() + precRebuildTimer_->totalElapsedTime();
}

DiagnosticPreconditionerFactory::~DiagnosticPreconditionerFactory() {
  // check timers for null
  if (buildTimer_ == Teuchos::null || rebuildTimer_ == Teuchos::null) {
    // (*outputStream_) << "DiagnosticPreconditionerFactory \"" << diagString_ << "\": "
    //                  << "Timers not initialized" << std::endl;

    return;
  }

  double initBuildTime = totalInitialBuildTime();
  int initBuilds       = numInitialBuilds();

  double initRebuildTime = totalRebuildTime();
  int initRebuilds       = numRebuilds();

  (*outputStream_) << "DiagnosticPreconditionerFactory \"" << diagString_ << "\":\n";

  // print build string
  (*outputStream_) << "   build elapsed = " << initBuildTime << ", "
                   << "num builds = " << initBuilds << ", ";
  if (initBuilds > 0)
    (*outputStream_) << "timer/app = " << initBuildTime / double(initBuilds) << "\n";
  else
    (*outputStream_) << "timer/app = "
                     << "none"
                     << "\n";

  // print rebuild string
  (*outputStream_) << "   rebuild elapsed = " << initRebuildTime << ", "
                   << "num rebuilds = " << initRebuilds << ", ";
  if (initRebuilds > 0)
    (*outputStream_) << "timer/app = " << initRebuildTime / double(initRebuilds) << "\n";
  else
    (*outputStream_) << "timer/app = "
                     << "none"
                     << "\n";

  // print total string
  (*outputStream_) << "   total elapsed = " << initRebuildTime + initBuildTime << ", "
                   << "num rebuilds = " << initRebuilds + initBuilds << ", ";
  if (initBuilds + initRebuilds > 0)
    (*outputStream_) << "timer/app = "
                     << (initRebuildTime + initBuildTime) / double(initRebuilds + initBuilds)
                     << std::endl;
  else
    (*outputStream_) << "timer/app = "
                     << "none" << std::endl;
}

LinearOp DiagnosticPreconditionerFactory::buildPreconditionerOperator(
    LinearOp& lo, PreconditionerState& state) const {
  using Teuchos::RCP;
  using Teuchos::rcp_dynamic_cast;

  TEUCHOS_TEST_FOR_EXCEPTION(
      invFactory_ == Teuchos::null, std::runtime_error,
      "ERROR: Teko::DiagnosticPreconditionerFactory::buildPreconditionerOperator requires that an "
          << "inverse factory has been set. Currently it is null!");

  TEUCHOS_TEST_FOR_EXCEPTION(
      buildTimer_ == Teuchos::null || rebuildTimer_ == Teuchos::null, std::runtime_error,
      "ERROR: Teko::DiagnosticPreconditionerFactory::buildPreconditionerOperator requires that "
          << "the timers be initialized. Currently they are null! (label = \"" << diagString_
          << "\")");

  // build user specified preconditioner
  ModifiableLinearOp& diagOp_ptr      = state.getModifiableOp("diagnosticOp");
  ModifiableLinearOp& diagOp_prec_ptr = state.getModifiableOp("prec_diagnosticOp");

  if (precFactory_ != Teuchos::null) {
    if (diagOp_prec_ptr == Teuchos::null) {
      {
        // start timer on construction, end on destruction
        Teuchos::TimeMonitor monitor(*precBuildTimer_, false);

        diagOp_prec_ptr = precFactory_->buildInverse(lo);
      }

      state.addModifiableOp("prec_diagnosticOp", diagOp_prec_ptr);
    } else {
      Teuchos::TimeMonitor monitor(*precRebuildTimer_, false);
      Teko::rebuildInverse(*precFactory_, lo, diagOp_prec_ptr);
    }
  }

  if (diagOp_ptr == Teuchos::null) {
    ModifiableLinearOp invOp;
    {
      // start timer on construction, end on destruction
      Teuchos::TimeMonitor monitor(*buildTimer_, false);

      if (diagOp_prec_ptr.is_null())
        invOp = Teko::buildInverse(*invFactory_, lo);
      else
        invOp = Teko::buildInverse(*invFactory_, lo, diagOp_prec_ptr);
    }

    // only printing residual requires use of forward operator
    if (printResidual_)
      diagOp_ptr = createDiagnosticLinearOp(outputStream_, lo, invOp, diagString_);
    else
      diagOp_ptr = createDiagnosticLinearOp(outputStream_, invOp, diagString_);
  } else {
    RCP<DiagnosticLinearOp> diagOp = rcp_dynamic_cast<DiagnosticLinearOp>(diagOp_ptr);

    // only printing residual requires use of forward operator
    if (printResidual_) diagOp->setForwardOp(lo);

    ModifiableLinearOp invOp = diagOp->getModifiableOp();
    {
      // start timer on construction, end on destruction
      Teuchos::TimeMonitor monitor(*rebuildTimer_, false);

      if (diagOp_prec_ptr.is_null())
        Teko::rebuildInverse(*invFactory_, lo, invOp);
      else
        Teko::rebuildInverse(*invFactory_, lo, diagOp_prec_ptr, invOp);
    }
  }

  return diagOp_ptr.getConst();
}

void DiagnosticPreconditionerFactory::initializeFromParameterList(
    const Teuchos::ParameterList& settings) {
  TEUCHOS_TEST_FOR_EXCEPTION(
      not settings.isParameter("Inverse Factory"), std::runtime_error,
      "Parameter \"Inverse Factory\" is required by a Teko::DiagnosticPreconditionerFactory");
  TEUCHOS_TEST_FOR_EXCEPTION(
      not settings.isParameter("Descriptive Label"), std::runtime_error,
      "Parameter \"Descriptive Label\" is required by a Teko::DiagnosticPreconditionerFactory");

  // grab library and preconditioner name
  std::string invName  = settings.get<std::string>("Inverse Factory");
  std::string precName = "";
  if (settings.isParameter("Preconditioner Factory"))
    precName = settings.get<std::string>("Preconditioner Factory");
  diagString_ = settings.get<std::string>("Descriptive Label");

  // build preconditioner factory
  Teuchos::RCP<const InverseLibrary> il = getInverseLibrary();
  invFactory_                           = il->getInverseFactory(invName);
  if (precName != "") precFactory_ = il->getInverseFactory(precName);
  TEUCHOS_TEST_FOR_EXCEPTION(invFactory_ == Teuchos::null, std::runtime_error,
                             "ERROR: \"Inverse Factory\" = " << invName << " could not be found");

  if (settings.isParameter("Print Residual")) printResidual_ = settings.get<bool>("Print Residual");

  // build timers to use
  initTimers(diagString_);
}

Teuchos::RCP<Teuchos::ParameterList> DiagnosticPreconditionerFactory::getRequestedParameters()
    const {
  TEUCHOS_TEST_FOR_EXCEPTION(
      invFactory_ == Teuchos::null, std::runtime_error,
      "ERROR: Teko::DiagnosticPreconditionerFactory::getRequestedParameters requires that a "
          << "preconditioner factory has been set. Currently it is null!");

  return invFactory_->getRequestedParameters();
}

bool DiagnosticPreconditionerFactory::updateRequestedParameters(const Teuchos::ParameterList& pl) {
  TEUCHOS_TEST_FOR_EXCEPTION(
      invFactory_ == Teuchos::null, std::runtime_error,
      "ERROR: Teko::DiagnosticPreconditionerFactory::updateRequestedParameters requires that a "
          << "preconditioner factory has been set. Currently it is null!");

  bool success = true;
  success &= invFactory_->updateRequestedParameters(pl);
  if (precFactory_) success &= precFactory_->updateRequestedParameters(pl);

  return success;
}

void DiagnosticPreconditionerFactory::initTimers(const std::string& str) {
  buildTimer_       = Teuchos::rcp(new Teuchos::Time(str + " buildTimer"));
  rebuildTimer_     = Teuchos::rcp(new Teuchos::Time(str + " rebuildTimer"));
  precBuildTimer_   = Teuchos::rcp(new Teuchos::Time(str + " precBuildTimer"));
  precRebuildTimer_ = Teuchos::rcp(new Teuchos::Time(str + " precRebuildTimer"));
}

}  // end namespace Teko