SCMSolutionTransfer.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
 
#include "SCMSolutionTransfer.h"
#include "MultiApp.h"
#include "FEProblemBase.h"
#include "DisplacedProblem.h"
#include "SubChannelMesh.h"
 
namespace
{
bool
isDeprecatedPinTransferType(const InputParameters & parameters)
{
  const auto & type = parameters.getObjectType();
  return type == "SCMPinSolutionTransfer" || type == "PinSolutionTransfer";
}
}
 
registerMooseObject("SubChannelApp", SCMSolutionTransfer);
registerMooseObjectRenamed("SubChannelApp",
                           SolutionTransfer,
                           "06/30/2027 24:00",
                           SCMSolutionTransfer);
registerMooseObjectRenamed("SubChannelApp",
                           SCMPinSolutionTransfer,
                           "06/30/2027 24:00",
                           SCMSolutionTransfer);
registerMooseObjectRenamed("SubChannelApp",
                           PinSolutionTransfer,
                           "06/30/2027 24:00",
                           SCMSolutionTransfer);
 
InputParameters
SCMSolutionTransfer::validParams()
{
  InputParameters params = MultiAppTransfer::validParams();
  params.addRequiredParam<std::vector<AuxVariableName>>("variable",
                                                        "The auxiliary variables to transfer.");
  MooseEnum transfer_type("subchannel pin", "subchannel");
  params.addParam<MooseEnum>("transfer_type",
                             transfer_type,
                             "Whether to transfer subchannel-centered or pin-centered fields.");
  params.addClassDescription(
      "Transfers subchannel or pin solutions from a SubChannel mesh onto a visualization mesh.");
  return params;
}
 
SCMSolutionTransfer::SCMSolutionTransfer(const InputParameters & parameters)
  : MultiAppTransfer(parameters),
    _var_names(getParam<std::vector<AuxVariableName>>("variable")),
    _pin_transfer(
        getParam<MooseEnum>("transfer_type") == "pin" ||
        (!parameters.isParamSetByUser("transfer_type") && isDeprecatedPinTransferType(parameters)))
{
  if (_directions.contains(Transfer::FROM_MULTIAPP))
    paramError("from_multiapp", "This transfer works only into multi-app.");
}
 
void
SCMSolutionTransfer::initialSetup()
{
  MultiAppTransfer::initialSetup();
  for (std::size_t var_index = 0; var_index < _var_names.size(); ++var_index)
  {
    if (_to_problems.empty())
      continue;
 
    MooseVariableFieldBase & from_var = _subproblem.getVariable(
        0, _var_names[var_index], Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
    const auto & fe_type = from_var.feType();
 
    if (fe_type.family != LAGRANGE || fe_type.order != FIRST)
      paramError("variable",
                 "This transfer requires a first order Lagrange variable for the source variable");
 
    MooseVariableFieldBase & to_var = _to_problems[0]->getVariable(
        0, _var_names[var_index], Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
    const auto & fe_type_target = to_var.feType();
 
    if (fe_type_target.family != LAGRANGE || fe_type_target.order != FIRST)
      paramError("variable",
                 "This transfer requires a first order Lagrange variable for the source variable");
  }
}
 
void
SCMSolutionTransfer::execute()
{
  TIME_SECTION(
      "MultiAppDetailedSolutionBaseTransfer::execute()", 5, "Transferring subchannel solutions");
  getAppInfo();
 
  switch (_current_direction)
  {
    case TO_MULTIAPP:
    case BETWEEN_MULTIAPP:
      transferToMultiApps();
      break;
 
    default:
      break;
  }
}
 
void
SCMSolutionTransfer::transferToMultiApps()
{
  mooseAssert(_from_meshes.size() == 1, "Only one source mesh can be active in this transfer.");
  auto * from_mesh = dynamic_cast<SubChannelMesh *>(_from_meshes[0]);
  if (from_mesh == nullptr)
    mooseError("This transfer works only with SubChannelMesh classes.");
  if (_pin_transfer && !from_mesh->pinMeshExist())
    mooseError(
        "This transfer was configured for pin variables, but the source mesh has no pin mesh.");
 
  for (unsigned int i = 0; i < getToMultiApp()->numGlobalApps(); i++)
    if (getToMultiApp()->hasLocalApp(i))
      transferVarsToApp(i);
}
 
void
SCMSolutionTransfer::transferVarsToApp(unsigned int app_idx)
{
  transferNodalVars(app_idx);
}
 
void
SCMSolutionTransfer::transferNodalVars(unsigned int app_idx)
{
  Moose::ScopedCommSwapper swapper(getToMultiApp()->comm());
 
  FEProblemBase & to_problem = getToMultiApp()->appProblemBase(app_idx);
  MooseMesh * mesh = NULL;
  if (_displaced_target_mesh && to_problem.getDisplacedProblem())
    mesh = &to_problem.getDisplacedProblem()->mesh();
  else
    mesh = &to_problem.mesh();
 
  const SubChannelMesh & from_mesh = dynamic_cast<SubChannelMesh &>(*_from_meshes[0]);
  FEProblemBase & from_problem = *_from_problems[0];
  validateVariableLocations(from_mesh, to_problem);
 
  for (auto & node : mesh->getMesh().local_node_ptr_range())
  {
    if (processor_id() != 0)
      continue;
    Node * from_node = getFromNode(from_mesh, *node);
 
    for (auto & var_name : _var_names)
    {
      System * to_sys = find_sys(to_problem.es(), var_name);
      unsigned int to_sys_num = to_sys->number();
      unsigned int to_var_num = to_sys->variable_number(var_name);
 
      if (node->n_dofs(to_sys_num, to_var_num) > 0)
      {
        System * from_sys = find_sys(from_problem.es(), var_name);
        unsigned int from_sys_num = from_sys->number();
        unsigned int from_var_num = from_sys->variable_number(var_name);
 
        // Return to parent app MPI communicator to get solution dof
        swapper.forceSwap();
        NumericVector<Real> * from_solution = from_sys->solution.get();
        dof_id_type from_dof = from_node->dof_number(from_sys_num, from_var_num, 0);
        Real from_value = (*from_solution)(from_dof);
        swapper.forceSwap();
 
        NumericVector<Real> & to_solution = getToMultiApp()->appTransferVector(app_idx, var_name);
        dof_id_type to_dof = node->dof_number(to_sys_num, to_var_num, 0);
        to_solution.set(to_dof, from_value);
      }
    }
  }
 
  for (auto & var_name : _var_names)
  {
    getToMultiApp()->appTransferVector(app_idx, var_name).close();
    find_sys(to_problem.es(), var_name)->update();
  }
}
 
void
SCMSolutionTransfer::validateVariableLocations(const SubChannelMesh & from_mesh,
                                               FEProblemBase & to_problem)
{
  if (processor_id() != 0)
    return;
 
  Node * from_node = _pin_transfer ? from_mesh.getPinNode(0, 0) : from_mesh.getChannelNode(0, 0);
  mooseAssert(from_node, "The representative source node must be non-null.");
 
  FEProblemBase & from_problem = *_from_problems[0];
  const auto transfer_type = _pin_transfer ? "pin" : "subchannel";
  const auto other_transfer_type = _pin_transfer ? "subchannel" : "pin";
  const auto expected_block = _pin_transfer ? "fuel_pins" : "subchannel";
  const auto source_block_id = from_mesh.getSubdomainID(expected_block);
  const auto target_block_id = to_problem.mesh().getSubdomainID(expected_block);
 
  for (const auto & var_name : _var_names)
  {
    MooseVariableFieldBase & from_var = from_problem.getVariable(
        0, var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
    MooseVariableFieldBase & to_var = to_problem.getVariable(
        0, var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
    System * from_sys = find_sys(from_problem.es(), var_name);
    const auto from_sys_num = from_sys->number();
    const auto from_var_num = from_sys->variable_number(var_name);
 
    if (!from_var.activeOnSubdomain(source_block_id) ||
        !to_var.activeOnSubdomain(target_block_id) ||
        from_node->n_dofs(from_sys_num, from_var_num) == 0)
      paramError("variable",
                 "The variable '",
                 var_name,
                 "' does not have DOFs on ",
                 transfer_type,
                 " nodes. Use a separate SCMSolutionTransfer with transfer_type = '",
                 other_transfer_type,
                 "' for variables centered on ",
                 other_transfer_type,
                 " nodes.");
  }
}
 
Node *
SCMSolutionTransfer::getFromNode(const SubChannelMesh & from_mesh, const Point & src_node)
{
  unsigned int sch_idx =
      _pin_transfer ? from_mesh.pinIndex(src_node) : from_mesh.channelIndex(src_node);
  unsigned iz = from_mesh.getZIndex(src_node);
  return _pin_transfer ? from_mesh.getPinNode(sch_idx, iz) : from_mesh.getChannelNode(sch_idx, iz);
}