PODFullSolveMultiApp.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
// StochasticTools includes
#include "PODFullSolveMultiApp.h"
#include "NonlinearSystemBase.h"
#include "Sampler.h"
#include "Executioner.h"
#include "PODSamplerSolutionTransfer.h"
#include "PODResidualTransfer.h"
 
registerMooseObject("StochasticToolsApp", PODFullSolveMultiApp);
 
InputParameters
PODFullSolveMultiApp::validParams()
{
  InputParameters params = SamplerFullSolveMultiApp::validParams();
  params.addClassDescription(
      "Creates a full-solve type sub-application for each row of a Sampler matrix. "
      "On second call, this object creates residuals for a PODReducedBasisTrainer with given basis "
      "functions.");
  params.addRequiredParam<UserObjectName>(
      "trainer_name", "Trainer object that contains the solutions for different samples.");
 
  return params;
}
 
PODFullSolveMultiApp::PODFullSolveMultiApp(const InputParameters & parameters)
  : SamplerFullSolveMultiApp(parameters),
    SurrogateModelInterface(this),
    _trainer(getSurrogateTrainer<PODReducedBasisTrainer>("trainer_name")),
    _snapshot_generation(true)
{
  if (getParam<unsigned int>("max_procs_per_app") != 1)
    paramError("max_procs_per_app", " does not support more than one processors per subapp!");
 
  if (n_processors() > _sampler.getNumberOfRows())
    mooseError(type(),
               " needs to be run with fewer processors (detected ",
               n_processors(),
               ") than samples (detected ",
               _sampler.getNumberOfRows(),
               ")!");
}
 
void
PODFullSolveMultiApp::preTransfer(Real dt, Real target_time)
{
  // Reinitialize the problem only if the snapshot generation part is done.
  if (!_snapshot_generation)
  {
    dof_id_type base_size = _trainer.getSumBaseSize();
    if (base_size < 1)
      mooseError(
          "There are no basis vectors available for residual generation."
          " This indicates that the bases have not been created yet."
          " The most common cause of this error is the wrong setting"
          " of the 'execute_on' flags in the PODFullSolveMultiApp and/or PODReducedBasisTrainer.");
 
    init(base_size,
         _sampler.getRankConfig(_mode == StochasticTools::MultiAppMode::BATCH_RESET ||
                                _mode == StochasticTools::MultiAppMode::BATCH_RESTORE));
 
    initialSetup();
  }
  SamplerFullSolveMultiApp::preTransfer(dt, target_time);
}
 
bool
PODFullSolveMultiApp::solveStep(Real dt, Real target_time, bool auto_advance)
{
 
  bool last_solve_converged = true;
 
  // If snapshot generation phase, solve the subapplications in a regular manner.
  // Otherwise, compute the residuals only.
  if (_snapshot_generation)
  {
    last_solve_converged = SamplerFullSolveMultiApp::solveStep(dt, target_time, auto_advance);
    _snapshot_generation = false;
  }
  else
  {
    if (_mode == StochasticTools::MultiAppMode::BATCH_RESET ||
        _mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
      computeResidualBatch(target_time);
    else
      computeResidual();
  }
 
  return last_solve_converged;
}
 
void
PODFullSolveMultiApp::computeResidual()
{
  // Doing the regular computation but instead of solving the subapplication,
  // the residuals for different tags are evaluated.
  if (!_has_an_app)
    return;
 
  Moose::ScopedCommSwapper swapper(_my_comm);
 
  int rank;
  int ierr;
  ierr = MPI_Comm_rank(_communicator.get(), &rank);
  mooseCheckMPIErr(ierr);
 
  // Getting the necessary tag names.
  const std::vector<std::string> & trainer_tags = _trainer.getTagNames();
 
  // Looping over the subapplications and computing residuals.
  for (unsigned int i = 0; i < _my_num_apps; i++)
  {
    // Getting the local problem
    FEProblemBase & problem = _apps[i]->getExecutioner()->feProblem();
 
    // Extracting the TagIDs based on tag names from the current subapp.
    std::set<TagID> tags_to_compute;
    for (auto & tag_name : trainer_tags)
      tags_to_compute.insert(problem.getVectorTagID(tag_name));
 
    problem.setCurrentNonlinearSystem(0);
    problem.computeResidualTags(tags_to_compute);
  }
}
 
void
PODFullSolveMultiApp::computeResidualBatch(Real target_time)
{
  // Getting the overall base size from the trainer.
  dof_id_type base_size = _trainer.getSumBaseSize();
 
  // Distributing the residual evaluation among processes.
  dof_id_type local_base_begin;
  dof_id_type local_base_end;
  dof_id_type n_local_bases;
  MooseUtils::linearPartitionItems(
      base_size, n_processors(), processor_id(), n_local_bases, local_base_begin, local_base_end);
 
  // List of active relevant Transfer objects
  std::vector<std::shared_ptr<PODSamplerSolutionTransfer>> to_transfers =
      getActiveSolutionTransfers(MultiAppTransfer::TO_MULTIAPP);
  std::vector<std::shared_ptr<PODResidualTransfer>> from_transfers =
      getActiveResidualTransfers(MultiAppTransfer::FROM_MULTIAPP);
 
  // Initialize to/from transfers
  for (auto transfer : to_transfers)
    transfer->initializeToMultiapp();
 
  for (auto transfer : from_transfers)
    transfer->initializeFromMultiapp();
 
  if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
    backup();
 
  // Perform batch MultiApp solves
  _local_batch_app_index = 0;
  for (dof_id_type i = local_base_begin; i < local_base_end; ++i)
  {
    for (auto & transfer : to_transfers)
    {
      transfer->setGlobalMultiAppIndex(i);
      transfer->executeToMultiapp();
    }
 
    computeResidual();
 
    for (auto & transfer : from_transfers)
    {
      transfer->setGlobalMultiAppIndex(i);
      transfer->executeFromMultiapp();
    }
 
    if (i < _sampler.getLocalRowEnd() - 1)
    {
      if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
        restore();
      else
      {
        // The app is being reset for the next loop, thus the batch index must be indexed as such
        _local_batch_app_index++;
        resetApp(_local_batch_app_index + i, target_time);
        initialSetup();
      }
    }
  }
 
  // Finalize to/from transfers
  for (auto transfer : to_transfers)
    transfer->finalizeToMultiapp();
  for (auto transfer : from_transfers)
    transfer->finalizeFromMultiapp();
}
 
std::vector<std::shared_ptr<PODSamplerSolutionTransfer>>
PODFullSolveMultiApp::getActiveSolutionTransfers(Transfer::DIRECTION direction)
{
  std::vector<std::shared_ptr<PODSamplerSolutionTransfer>> output;
  const ExecuteMooseObjectWarehouse<Transfer> & warehouse =
      _fe_problem.getMultiAppTransferWarehouse(direction);
  for (std::shared_ptr<Transfer> transfer : warehouse.getActiveObjects())
  {
    auto ptr = std::dynamic_pointer_cast<PODSamplerSolutionTransfer>(transfer);
    if (ptr)
      output.push_back(ptr);
  }
  return output;
}
 
std::vector<std::shared_ptr<PODResidualTransfer>>
PODFullSolveMultiApp::getActiveResidualTransfers(Transfer::DIRECTION direction)
{
  std::vector<std::shared_ptr<PODResidualTransfer>> output;
  const ExecuteMooseObjectWarehouse<Transfer> & warehouse =
      _fe_problem.getMultiAppTransferWarehouse(direction);
  for (std::shared_ptr<Transfer> transfer : warehouse.getActiveObjects())
  {
    auto ptr = std::dynamic_pointer_cast<PODResidualTransfer>(transfer);
    if (ptr)
      output.push_back(ptr);
  }
  return output;
}