Teko_LU2x2DiagonalStrategy.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_LU2x2DiagonalStrategy.hpp"

#include "Teuchos_TimeMonitor.hpp"

namespace Teko {

using Teuchos::TimeMonitor;

Teuchos::RCP<Teuchos::Time> LU2x2DiagonalStrategy::initTimer_;
Teuchos::RCP<Teuchos::Time> LU2x2DiagonalStrategy::invSTimer_;
Teuchos::RCP<Teuchos::Time> LU2x2DiagonalStrategy::invA00Timer_;
Teuchos::RCP<Teuchos::Time> LU2x2DiagonalStrategy::opsTimer_;

void LU2x2DiagonalStrategy::buildTimers() {
  if (initTimer_ == Teuchos::null)
    initTimer_ = TimeMonitor::getNewTimer("LU2x2DiagonalStrategy::initializePrec");

  if (invSTimer_ == Teuchos::null)
    invSTimer_ = TimeMonitor::getNewTimer("LU2x2DiagonalStrategy::initializePrec invS");

  if (invA00Timer_ == Teuchos::null)
    invA00Timer_ = TimeMonitor::getNewTimer("LU2x2DiagonalStrategy::initializePrec invA00");

  if (opsTimer_ == Teuchos::null)
    opsTimer_ = TimeMonitor::getNewTimer("LU2x2DiagonalStrategy::initializePrec buildOps");
}

LU2x2DiagonalStrategy::LU2x2DiagonalStrategy() : a00InverseType_(Diagonal) { buildTimers(); }

LU2x2DiagonalStrategy::LU2x2DiagonalStrategy(const Teuchos::RCP<InverseFactory>& invFA,
                                             const Teuchos::RCP<InverseFactory>& invS)
    : invFactoryA00_(invFA), invFactoryS_(invS), a00InverseType_(Diagonal) {
  buildTimers();
}

const Teko::LinearOp LU2x2DiagonalStrategy::getHatInvA00(const Teko::BlockedLinearOp& A,
                                                         BlockPreconditionerState& state) const {
  initializeState(A, state);

  return state.getModifiableOp("invA00");
}

const Teko::LinearOp LU2x2DiagonalStrategy::getTildeInvA00(const Teko::BlockedLinearOp& A,
                                                           BlockPreconditionerState& state) const {
  initializeState(A, state);

  return state.getModifiableOp("invA00");
}

const Teko::LinearOp LU2x2DiagonalStrategy::getInvS(const Teko::BlockedLinearOp& A,
                                                    BlockPreconditionerState& state) const {
  initializeState(A, state);

  return state.getModifiableOp("invS");
}

void LU2x2DiagonalStrategy::initializeState(const Teko::BlockedLinearOp& A,
                                            BlockPreconditionerState& state) const {
  Teko_DEBUG_SCOPE("LU2x2DiagonalStrategy::initializeState", 10);

  // no work to be done
  if (state.isInitialized()) return;

  Teuchos::TimeMonitor timer(*initTimer_, true);

  // extract sub blocks
  LinearOp A00 = Teko::getBlock(0, 0, A);
  LinearOp A01 = Teko::getBlock(0, 1, A);
  LinearOp A10 = Teko::getBlock(1, 0, A);
  LinearOp A11 = Teko::getBlock(1, 1, A);

  // build the Schur complement
  ModifiableLinearOp& S = state.getModifiableOp("S");
  {
    Teko_DEBUG_SCOPE("Building S", 5);
    Teuchos::TimeMonitor timerS(*opsTimer_, true);

    LinearOp diagA00 = getInvDiagonalOp(A00, a00InverseType_);

    // build Schur-complement
    ModifiableLinearOp& triple = state.getModifiableOp("triple");
    triple                     = explicitMultiply(A10, diagA00, A01, triple);
    S                          = explicitAdd(scale(-1.0, A11), triple, S);
  }

  // build inverse S
  {
    Teko_DEBUG_SCOPE("Building inverse(S)", 5);
    Teuchos::TimeMonitor timerInvS(*invSTimer_, true);

    ModifiableLinearOp& invS = state.getModifiableOp("invS");
    if (invS == Teuchos::null)
      invS = buildInverse(*invFactoryS_, S);
    else
      rebuildInverse(*invFactoryS_, S, invS);
  }

  // build inverse A00
  {
    Teko_DEBUG_SCOPE("Building inverse(A00)", 5);
    Teuchos::TimeMonitor timerInvA00(*invA00Timer_, true);

    ModifiableLinearOp& invA00 = state.getModifiableOp("invA00");
    *getOutputStream() << "(LU2x2) invA00 pointer = " << invA00 << std::endl;
    if (invA00 == Teuchos::null)
      invA00 = buildInverse(*invFactoryA00_, A00);
    else
      rebuildInverse(*invFactoryA00_, A00, invA00);
  }

  // mark state as initialized
  state.setInitialized(true);
}

void LU2x2DiagonalStrategy::initializeFromParameterList(const Teuchos::ParameterList& pl,
                                                        const InverseLibrary& invLib) {
  Teko_DEBUG_SCOPE("LU2x2DiagonalStrategy::initializeFromParameterList", 10);

  std::string invStr = "", invA00Str = "", invSStr = "";
#if defined(Teko_ENABLE_Amesos)
  invStr = "Amesos";
#elif defined(Teko_ENABLE_Amesos2)
  invStr = "Amesos2";
#endif

  // "parse" the parameter list
  if (pl.isParameter("Inverse Type")) invStr = pl.get<std::string>("Inverse Type");
  if (pl.isParameter("Inverse A00 Type")) invA00Str = pl.get<std::string>("Inverse A00 Type");
  if (pl.isParameter("Inverse Schur Type")) invSStr = pl.get<std::string>("Inverse Schur Type");
  if (pl.isParameter("Diagonal Type")) {
    std::string massInverseStr = pl.get<std::string>("Diagonal Type");

    // build inverse types
    a00InverseType_ = getDiagonalType(massInverseStr);
  }

  // set defaults as needed
  if (invA00Str == "") invA00Str = invStr;
  if (invSStr == "") invSStr = invStr;

  Teko_DEBUG_MSG_BEGIN(5) DEBUG_STREAM << "LU2x2 Diagonal Strategy Parameters: " << std::endl;
  DEBUG_STREAM << "   inv type   = \"" << invStr << "\"" << std::endl;
  DEBUG_STREAM << "   inv A00 type = \"" << invA00Str << "\"" << std::endl;
  DEBUG_STREAM << "   inv S type = \"" << invSStr << "\"" << std::endl;
  DEBUG_STREAM << "LU2x2 Diagonal Strategy Parameter list: " << std::endl;
  pl.print(DEBUG_STREAM);
  Teko_DEBUG_MSG_END()

      // build velocity inverse factory
      invFactoryA00_ = invLib.getInverseFactory(invA00Str);

  if (invA00Str == invSStr)
    invFactoryS_ = invFactoryA00_;
  else
    invFactoryS_ = invLib.getInverseFactory(invSStr);
}
}  // end namespace Teko