LCOV - code coverage report
Current view: top level - src/transfers - MultiAppTransfer.C (source / functions) Hit Total Coverage
Test: idaholab/moose framework: 909fe5 Lines: 312 343 91.0 %
Date: 2025-08-29 20:01:24 Functions: 26 27 96.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : // MOOSE includes
      11             : #include "MultiAppTransfer.h"
      12             : #include "Transfer.h"
      13             : #include "MooseTypes.h"
      14             : #include "FEProblem.h"
      15             : #include "DisplacedProblem.h"
      16             : #include "MultiApp.h"
      17             : #include "MooseMesh.h"
      18             : #include "UserObject.h"
      19             : 
      20             : #include "libmesh/parallel_algebra.h"
      21             : #include "libmesh/mesh_tools.h"
      22             : 
      23             : InputParameters
      24      333275 : MultiAppTransfer::validParams()
      25             : {
      26      333275 :   InputParameters params = Transfer::validParams();
      27     1999650 :   params.addDeprecatedParam<MultiAppName>("multi_app",
      28             :                                           "The name of the MultiApp to transfer data with",
      29             :                                           "Use to_multiapp & from_multiapp parameters now");
      30     1333100 :   params.addParam<MultiAppName>("from_multi_app", "The name of the MultiApp to receive data from");
      31     1333100 :   params.addParam<MultiAppName>("to_multi_app", "The name of the MultiApp to transfer the data to");
      32             : 
      33             :   // MultiAppTransfers by default will execute with their associated MultiApp. These flags will be
      34             :   // added by FEProblemBase when the transfer is added.
      35      333275 :   ExecFlagEnum & exec_enum = params.set<ExecFlagEnum>("execute_on", true);
      36      333275 :   exec_enum.addAvailableFlags(EXEC_SAME_AS_MULTIAPP);
      37             :   // Add the POST_ADAPTIVITY execution flag.
      38             : #ifdef LIBMESH_ENABLE_AMR
      39      333275 :   exec_enum.addAvailableFlags(EXEC_POST_ADAPTIVITY);
      40             : #endif
      41      333275 :   exec_enum = EXEC_SAME_AS_MULTIAPP;
      42      999825 :   params.setDocString("execute_on", exec_enum.getDocString());
      43             : 
      44      999825 :   params.addParam<bool>(
      45             :       "check_multiapp_execute_on",
      46      666550 :       true,
      47             :       "When false the check between the multiapp and transfer execute on flags is not performed.");
      48      999825 :   params.addParam<bool>("displaced_source_mesh",
      49      666550 :                         false,
      50             :                         "Whether or not to use the displaced mesh for the source mesh.");
      51      666550 :   params.addParam<bool>("displaced_target_mesh",
      52      666550 :                         false,
      53             :                         "Whether or not to use the displaced mesh for the target mesh.");
      54      333275 :   addSkipCoordCollapsingParam(params);
      55      333275 :   return params;
      56           0 : }
      57             : 
      58             : void
      59       59588 : MultiAppTransfer::addBBoxFactorParam(InputParameters & params)
      60             : {
      61      238352 :   params.addRangeCheckedParam<Real>(
      62             :       "bbox_factor",
      63      119176 :       1 + TOLERANCE,
      64             :       "bbox_factor>0",
      65             :       "Multiply bounding box width (in all directions) by the prescribed factor. Values less than "
      66             :       "1 will shrink the bounding box; values greater than 1 will enlarge the bounding box. It is "
      67             :       "generally not advised to ever shrink the bounding box. On the other hand it may be helpful "
      68             :       "to enlarge the bounding box. Larger bounding boxes will lead to more accurate determination "
      69             :       "of the closest node/element with the tradeoff of more communication.");
      70       59588 : }
      71             : 
      72             : void
      73      333275 : MultiAppTransfer::addSkipCoordCollapsingParam(InputParameters & params)
      74             : {
      75      999825 :   params.addParam<bool>(
      76             :       "skip_coordinate_collapsing",
      77      666550 :       true,
      78             :       "Whether to skip coordinate collapsing (translation and rotation are still performed, only "
      79             :       "XYZ, RZ etc collapsing is skipped) when performing mapping and inverse "
      80             :       "mapping coordinate transformation operations. This parameter should only "
      81             :       "be set by users who really know what they're doing.");
      82      999825 :   params.addParamNamesToGroup("skip_coordinate_collapsing", "Advanced");
      83      333275 : }
      84             : 
      85             : void
      86       77597 : MultiAppTransfer::addUserObjectExecutionCheckParam(InputParameters & params)
      87             : {
      88      155194 :   params.addParam<bool>("warn_source_object_execution_schedule",
      89      155194 :                         true,
      90             :                         "Emit a warning when the transfer execution schedule is detected to lag "
      91             :                         "information from the user object. Note that the check cannot detect all "
      92             :                         "potential wrong combinations of user-object/transfer execution schedules");
      93       77597 : }
      94             : 
      95       12524 : MultiAppTransfer::MultiAppTransfer(const InputParameters & parameters)
      96             :   : Transfer(parameters),
      97       25048 :     _skip_coordinate_collapsing(getParam<bool>("skip_coordinate_collapsing")),
      98       25048 :     _displaced_source_mesh(getParam<bool>("displaced_source_mesh")),
      99       25048 :     _displaced_target_mesh(getParam<bool>("displaced_target_mesh")),
     100       66974 :     _bbox_factor(isParamValid("bbox_factor") ? getParam<Real>("bbox_factor") : 1)
     101             : {
     102             :   // Get the multiapps from their names
     103       37572 :   if (!isParamValid("multi_app"))
     104             :   {
     105       37404 :     if (isParamValid("from_multi_app"))
     106             :     {
     107       14256 :       _from_multi_app = _fe_problem.getMultiApp(getParam<MultiAppName>("from_multi_app"));
     108        7128 :       _multi_app = _from_multi_app;
     109             :     }
     110       37404 :     if (isParamValid("to_multi_app"))
     111             :     {
     112       13064 :       _to_multi_app = _fe_problem.getMultiApp(getParam<MultiAppName>("to_multi_app"));
     113        6532 :       _multi_app = _to_multi_app;
     114             :     }
     115       80136 :     if (!isParamValid("direction") && !isParamValid("from_multi_app") &&
     116       28476 :         !isParamValid("to_multi_app"))
     117           4 :       mooseError("from_multi_app and/or to_multi_app must be specified");
     118             :   }
     119             :   else
     120             :   {
     121             :     // Check deprecated direction parameter
     122         112 :     for (const auto & dir : _directions)
     123             :     {
     124          56 :       if (dir == FROM_MULTIAPP)
     125             :       {
     126         112 :         _from_multi_app = _fe_problem.getMultiApp(getParam<MultiAppName>("multi_app"));
     127          56 :         _multi_app = _from_multi_app;
     128             :       }
     129           0 :       else if (dir == TO_MULTIAPP)
     130             :       {
     131           0 :         _to_multi_app = _fe_problem.getMultiApp(getParam<MultiAppName>("multi_app"));
     132           0 :         _multi_app = _to_multi_app;
     133             :       }
     134             :       else
     135           0 :         paramError("direction",
     136             :                    "BETWEN_MULTIAPP transfers should be specified using to/from_multi_app");
     137             :     }
     138             :   }
     139             : 
     140       37560 :   if (getParam<bool>("check_multiapp_execute_on"))
     141       12390 :     checkMultiAppExecuteOn();
     142             : 
     143             :   // Fill direction attributes, for backward compatibility but also convenience
     144       37560 :   if (!isParamValid("direction"))
     145             :   {
     146       12460 :     if (_from_multi_app && (!_to_multi_app || _from_multi_app == _to_multi_app))
     147       17796 :       _directions.setAdditionalValue("from_multiapp");
     148       12460 :     if (_to_multi_app && (!_from_multi_app || _from_multi_app == _to_multi_app))
     149       16008 :       _directions.setAdditionalValue("to_multiapp");
     150       12460 :     if (_from_multi_app && _to_multi_app && _from_multi_app != _to_multi_app)
     151        3588 :       _directions.setAdditionalValue("between_multiapp");
     152             : 
     153             :     // So it's available in the next constructors
     154       12460 :     _direction = _directions[0];
     155       12460 :     _current_direction = _directions[0];
     156             :   }
     157             : 
     158             :   // Handle deprecated parameters
     159       25040 :   if (parameters.isParamSetByUser("direction"))
     160             :   {
     161         180 :     if (!isParamValid("multi_app"))
     162           8 :       paramError("direction",
     163             :                  "The deprecated 'direction' parameter is meant to be used in conjunction with the "
     164             :                  "'multi_app' parameter");
     165         280 :     if (isParamValid("to_multi_app") || isParamValid("from_multi_app"))
     166           8 :       paramError("direction",
     167             :                  "The deprecated 'direction' parameter is not meant to be used in conjunction with "
     168             :                  "the 'from_multi_app' or 'to_multi_app' parameters");
     169             :   }
     170       12512 : }
     171             : 
     172             : void
     173       12390 : MultiAppTransfer::checkMultiAppExecuteOn()
     174             : {
     175       12390 :   if (_from_multi_app && !_to_multi_app)
     176        5919 :     if (getExecuteOnEnum() != _from_multi_app->getExecuteOnEnum())
     177         261 :       mooseDoOnce(
     178             :           mooseWarning("MultiAppTransfer execute_on flags do not match associated from_multi_app "
     179             :                        "execute_on flags"));
     180             : 
     181       12390 :   if (_to_multi_app && !_from_multi_app)
     182        5267 :     if (getExecuteOnEnum() != _to_multi_app->getExecuteOnEnum())
     183         254 :       mooseDoOnce(
     184             :           mooseWarning("MultiAppTransfer execute_on flags do not match associated to_multi_app "
     185             :                        "execute_on flags"));
     186             : 
     187             :   // In the case of siblings transfer, the check will be looser
     188       12390 :   if (_from_multi_app && _to_multi_app)
     189        1215 :     if (getExecuteOnEnum() != _from_multi_app->getExecuteOnEnum() &&
     190          15 :         getExecuteOnEnum() != _to_multi_app->getExecuteOnEnum())
     191           7 :       mooseDoOnce(
     192             :           mooseWarning("MultiAppTransfer execute_on flags do not match associated to_multi_app "
     193             :                        "and from_multi_app execute_on flags"));
     194       12390 : }
     195             : 
     196             : void
     197        9981 : MultiAppTransfer::variableIntegrityCheck(const AuxVariableName & var_name,
     198             :                                          bool is_from_multiapp) const
     199             : {
     200        9981 :   bool variable_found = false;
     201        9981 :   bool has_an_app = false;
     202             : 
     203             :   // Check the from_multi_app for the variable
     204        9981 :   if (is_from_multiapp && _from_multi_app)
     205       13380 :     for (unsigned int i = 0; i < _from_multi_app->numGlobalApps(); i++)
     206        8734 :       if (_from_multi_app->hasLocalApp(i))
     207             :       {
     208        7345 :         has_an_app = true;
     209        7345 :         if (_from_multi_app->appProblemBase(i).hasVariable(var_name))
     210        7341 :           variable_found = true;
     211             :       }
     212             : 
     213             :   // Check the to_multi_app for the variable
     214        9981 :   if (!is_from_multiapp && _to_multi_app)
     215       15418 :     for (unsigned int i = 0; i < _to_multi_app->numGlobalApps(); i++)
     216       10083 :       if (_to_multi_app->hasLocalApp(i))
     217             :       {
     218        8510 :         has_an_app = true;
     219        8510 :         if (_to_multi_app->appProblemBase(i).hasVariable(var_name))
     220        8510 :           variable_found = true;
     221             :       }
     222             : 
     223        9981 :   if (!variable_found && has_an_app)
     224           4 :     mooseError("Cannot find variable ", var_name, " for ", name(), " Transfer");
     225        9977 : }
     226             : 
     227             : void
     228       12184 : MultiAppTransfer::initialSetup()
     229             : {
     230             :   // Check for siblings transfer support
     231       12184 :   if (_to_multi_app && _from_multi_app)
     232        1196 :     checkSiblingsTransferSupported();
     233             : 
     234       12184 :   getAppInfo();
     235             : 
     236       12176 :   if (_from_multi_app)
     237        6972 :     _from_multi_app->addAssociatedTransfer(*this);
     238       12176 :   if (_to_multi_app)
     239        6400 :     _to_multi_app->addAssociatedTransfer(*this);
     240       12176 : }
     241             : 
     242             : void
     243       69514 : MultiAppTransfer::getAppInfo()
     244             : {
     245             :   // I would like to do all of this in initialSetup, but it will fail with
     246             :   // multiapps that reset.  A reset deletes and rebuilds the FEProblems so all
     247             :   // of the pointers will be broken.
     248             : 
     249             :   // Clear the vectors since we've probably built them up from a previous call
     250       69514 :   _from_problems.clear();
     251       69514 :   _to_problems.clear();
     252       69514 :   _from_es.clear();
     253       69514 :   _to_es.clear();
     254       69514 :   _from_meshes.clear();
     255       69514 :   _to_meshes.clear();
     256       69514 :   _to_positions.clear();
     257       69514 :   _from_positions.clear();
     258       69514 :   _to_transforms.clear();
     259       69514 :   _from_transforms.clear();
     260             :   // Clear this map since we build it from scratch every time we transfer
     261             :   // Otherwise, this will cause two issues: 1) increasing memory usage
     262             :   // for a simulation that requires many transfers, 2) producing wrong results
     263             :   // when we do collective communication on this vector.
     264       69514 :   _to_local2global_map.clear();
     265       69514 :   _from_local2global_map.clear();
     266             : 
     267             :   // Build the vectors for to problems, from problems, and subapps positions.
     268       69514 :   if (_current_direction == FROM_MULTIAPP)
     269             :   {
     270       34861 :     _to_problems.push_back(&_from_multi_app->problemBase());
     271       34861 :     _to_positions.push_back(Point(0., 0., 0.));
     272       34861 :     getFromMultiAppInfo();
     273             :   }
     274       34653 :   else if (_current_direction == TO_MULTIAPP)
     275             :   {
     276       32459 :     _from_problems.push_back(&_to_multi_app->problemBase());
     277       32459 :     _from_positions.push_back(Point(0., 0., 0.));
     278       32459 :     getToMultiAppInfo();
     279             :   }
     280        2194 :   else if (_current_direction == BETWEEN_MULTIAPP)
     281             :   {
     282             :     mooseAssert(&_from_multi_app->problemBase().coordTransform() ==
     283             :                     &_to_multi_app->problemBase().coordTransform(),
     284             :                 "I believe these should be the same. If not, then it will be difficult to define a "
     285             :                 "canonical reference frame.");
     286        2194 :     getToMultiAppInfo();
     287        2194 :     getFromMultiAppInfo();
     288             :   }
     289             : 
     290             :   // Build the from and to equation systems and mesh vectors.
     291      146365 :   for (unsigned int i = 0; i < _to_problems.size(); i++)
     292             :   {
     293             :     // TODO: Do I actually want es or displaced es?
     294       76851 :     _to_es.push_back(&_to_problems[i]->es());
     295       76851 :     if (_displaced_target_mesh && _to_problems[i]->getDisplacedProblem())
     296         574 :       _to_meshes.push_back(&_to_problems[i]->getDisplacedProblem()->mesh());
     297             :     else
     298       76277 :       _to_meshes.push_back(&_to_problems[i]->mesh());
     299             :   }
     300             : 
     301      146335 :   for (unsigned int i = 0; i < _from_problems.size(); i++)
     302             :   {
     303       76821 :     _from_es.push_back(&_from_problems[i]->es());
     304       76821 :     if (_displaced_source_mesh && _from_problems[i]->getDisplacedProblem())
     305         950 :       _from_meshes.push_back(&_from_problems[i]->getDisplacedProblem()->mesh());
     306             :     else
     307       75871 :       _from_meshes.push_back(&_from_problems[i]->mesh());
     308             :   }
     309             : 
     310       69514 :   MooseAppCoordTransform::MinimalData from_app_transform_construction_data{};
     311       69514 :   if (_communicator.rank() == 0)
     312             :     from_app_transform_construction_data =
     313       52260 :         _current_direction == TO_MULTIAPP
     314      104520 :             ? _to_multi_app->problemBase().coordTransform().minimalDataDescription()
     315       52260 :             : _from_multi_app->appProblemBase(0).coordTransform().minimalDataDescription();
     316       69514 :   _communicator.broadcast(from_app_transform_construction_data);
     317             :   _from_moose_app_transform =
     318       69514 :       std::make_unique<MooseAppCoordTransform>(from_app_transform_construction_data);
     319             : 
     320       69514 :   MooseAppCoordTransform::MinimalData to_app_transform_construction_data{};
     321       69514 :   if (_communicator.rank() == 0)
     322             :     to_app_transform_construction_data =
     323       52260 :         _current_direction == FROM_MULTIAPP
     324      104520 :             ? _from_multi_app->problemBase().coordTransform().minimalDataDescription()
     325       52260 :             : _to_multi_app->appProblemBase(0).coordTransform().minimalDataDescription();
     326       69514 :   _communicator.broadcast(to_app_transform_construction_data);
     327             :   _to_moose_app_transform =
     328       69514 :       std::make_unique<MooseAppCoordTransform>(to_app_transform_construction_data);
     329             : 
     330             :   /*
     331             :    * skip_coordinate_collapsing: whether to set the transform to skip coordinate collapsing
     332             :    *                             (from XYZ to RZ for example)
     333             :    * transforms: vector of transforms to add the new transforms to
     334             :    * moose_app_transform: base for the new transform
     335             :    * is_parent_app_transform: whether working on the transform for the parent app (this app, the
     336             :    *                          one creating the transfer) or for child apps
     337             :    * multiapp: pointer to the multiapp to obtain the position of the child apps
     338             :    */
     339      139028 :   auto create_multiapp_transforms = [this](auto & transforms,
     340             :                                            const auto & moose_app_transform,
     341             :                                            const bool is_parent_app_transform,
     342             :                                            const MultiApp * const multiapp = nullptr)
     343             :   {
     344             :     mooseAssert(is_parent_app_transform || multiapp,
     345             :                 "Coordinate transform must be created either for child app or parent app");
     346      139028 :     if (is_parent_app_transform)
     347             :     {
     348       67320 :       transforms.push_back(std::make_unique<MultiAppCoordTransform>(moose_app_transform));
     349       67320 :       transforms.back()->skipCoordinateCollapsing(_skip_coordinate_collapsing);
     350             :       // zero translation
     351             :     }
     352             :     else
     353             :     {
     354             :       mooseAssert(transforms.size() == 0, "transforms should not be initialized at this point");
     355      166035 :       for (const auto i : make_range(multiapp->numGlobalApps()))
     356             :       {
     357       94327 :         transforms.push_back(std::make_unique<MultiAppCoordTransform>(moose_app_transform));
     358       94327 :         auto & transform = transforms[i];
     359       94327 :         transform->skipCoordinateCollapsing(_skip_coordinate_collapsing);
     360       94327 :         if (multiapp->usingPositions())
     361       94327 :           transform->setTranslationVector(multiapp->position(i));
     362             :       }
     363             :     }
     364      139028 :   };
     365             : 
     366       69514 :   if (_current_direction == TO_MULTIAPP)
     367             :   {
     368       32459 :     create_multiapp_transforms(
     369       32459 :         _to_transforms, *_to_moose_app_transform, false, _to_multi_app.get());
     370       32459 :     create_multiapp_transforms(_from_transforms, *_from_moose_app_transform, true);
     371             :   }
     372       69514 :   if (_current_direction == FROM_MULTIAPP)
     373             :   {
     374       34861 :     create_multiapp_transforms(_to_transforms, *_to_moose_app_transform, true);
     375       34861 :     create_multiapp_transforms(
     376       34861 :         _from_transforms, *_from_moose_app_transform, false, _from_multi_app.get());
     377             :   }
     378       69514 :   if (_current_direction == BETWEEN_MULTIAPP)
     379             :   {
     380        2194 :     create_multiapp_transforms(
     381        2194 :         _to_transforms, *_to_moose_app_transform, false, _to_multi_app.get());
     382        2194 :     create_multiapp_transforms(
     383        2194 :         _from_transforms, *_from_moose_app_transform, false, _from_multi_app.get());
     384             :   }
     385             : 
     386      139020 :   auto check_transform_compatibility = [this](const MultiAppCoordTransform & transform)
     387             :   {
     388      139020 :     if (transform.hasNonTranslationTransformation() && !usesMooseAppCoordTransform())
     389           8 :       mooseWarning("Transfer '",
     390           8 :                    name(),
     391             :                    "' of type '",
     392           8 :                    type(),
     393             :                    "' has non-translation transformations but it does not implement coordinate "
     394             :                    "transformations using the 'MooseAppCoordTransform' class. Your data transfers "
     395             :                    "will not be performed in the expected transformed frame");
     396      208526 :   };
     397             : 
     398             :   // set the destination coordinate systems for each transform for the purposes of determining
     399             :   // coordinate collapsing. For example if TO is XYZ and FROM is RZ, then TO will have its XYZ
     400             :   // coordinates collapsed into RZ and FROM will have a no-op for coordinate collapsing
     401             : 
     402      150666 :   for (const auto i : index_range(_from_transforms))
     403             :   {
     404       81160 :     auto & from_transform = _from_transforms[i];
     405       81160 :     from_transform->setDestinationCoordTransform(*_to_moose_app_transform);
     406       81160 :     if (i == 0)
     407       69514 :       check_transform_compatibility(*from_transform);
     408             :   }
     409      149589 :   for (const auto i : index_range(_to_transforms))
     410             :   {
     411       80083 :     auto & to_transform = _to_transforms[i];
     412       80083 :     to_transform->setDestinationCoordTransform(*_from_moose_app_transform);
     413       80083 :     if (i == 0)
     414       69506 :       check_transform_compatibility(*to_transform);
     415             :   }
     416       69506 : }
     417             : 
     418             : namespace
     419             : {
     420             : void
     421       71708 : fillInfo(MultiApp & multi_app,
     422             :          std::vector<unsigned int> & map,
     423             :          std::vector<FEProblemBase *> & problems,
     424             :          std::vector<Point> & positions)
     425             : {
     426      166035 :   for (unsigned int i_app = 0; i_app < multi_app.numGlobalApps(); i_app++)
     427             :   {
     428       94327 :     if (!multi_app.hasLocalApp(i_app))
     429        7975 :       continue;
     430             : 
     431       86352 :     auto & subapp_problem = multi_app.appProblemBase(i_app);
     432             : 
     433       86352 :     map.push_back(i_app);
     434       86352 :     problems.push_back(&subapp_problem);
     435       86352 :     if (multi_app.usingPositions())
     436       86352 :       positions.push_back(multi_app.position(i_app));
     437             :   }
     438       71708 : }
     439             : }
     440             : 
     441             : void
     442       34653 : MultiAppTransfer::getToMultiAppInfo()
     443             : {
     444       34653 :   if (!_to_multi_app)
     445           0 :     mooseError("There is no to_multiapp to get info from");
     446             : 
     447       34653 :   fillInfo(*_to_multi_app, _to_local2global_map, _to_problems, _to_positions);
     448       34653 : }
     449             : 
     450             : void
     451       37055 : MultiAppTransfer::getFromMultiAppInfo()
     452             : {
     453       37055 :   if (!_from_multi_app)
     454           0 :     mooseError("There is no from_multiapp to get info from");
     455             : 
     456       37055 :   fillInfo(*_from_multi_app, _from_local2global_map, _from_problems, _from_positions);
     457       37055 : }
     458             : 
     459             : void
     460       62234 : MultiAppTransfer::transformBoundingBox(BoundingBox & box, const MultiAppCoordTransform & transform)
     461             : {
     462       62234 :   MultiApp::transformBoundingBox(box, transform);
     463       62234 : }
     464             : 
     465             : void
     466       59413 : MultiAppTransfer::extendBoundingBoxes(const Real factor, std::vector<BoundingBox> & bboxes) const
     467             : {
     468       59413 :   const auto extension_factor = factor - 1;
     469             : 
     470             :   // Extend (or contract if the extension factor is negative) bounding boxes along all the
     471             :   // directions by the same length. Greater than zero values of this member may be necessary because
     472             :   // the nearest bounding box does not necessarily give you the closest node/element. It will depend
     473             :   // on the partition and geometry. A node/element will more likely find its nearest source
     474             :   // element/node by extending bounding boxes. If each of the bounding boxes covers the entire
     475             :   // domain, a node/element will be able to find its nearest source element/node for sure, but at
     476             :   // the same time, more communication will be involved and can be expensive.
     477      151995 :   for (auto & box : bboxes)
     478             :   {
     479             :     // libmesh set an invalid bounding box using this code
     480             :     // for (unsigned int i=0; i<LIBMESH_DIM; i++)
     481             :     // {
     482             :     //   this->first(i)  =  std::numeric_limits<Real>::max();
     483             :     //   this->second(i) = -std::numeric_limits<Real>::max();
     484             :     // }
     485             :     // If it is an invalid box, we should skip it
     486       92582 :     if (box.first(0) == std::numeric_limits<Real>::max())
     487           0 :       continue;
     488             : 
     489       92582 :     auto width = box.second - box.first;
     490       92582 :     box.second += width * extension_factor;
     491       92582 :     box.first -= width * extension_factor;
     492             :   }
     493       59413 : }
     494             : 
     495             : std::vector<BoundingBox>
     496        2608 : MultiAppTransfer::getFromBoundingBoxes()
     497             : {
     498        2608 :   std::vector<std::pair<Point, Point>> bb_points(_from_meshes.size());
     499        5766 :   for (unsigned int i = 0; i < _from_meshes.size(); i++)
     500             :   {
     501             :     // Get a bounding box around the mesh elements that are local to the current
     502             :     // processor.
     503        3158 :     BoundingBox bbox = MeshTools::create_local_bounding_box(*_from_meshes[i]);
     504             : 
     505             :     // Translate the bounding box to the from domain's position. We may have rotations so we must
     506             :     // be careful in constructing the new min and max (first and second)
     507        3158 :     const auto from_global_num = getGlobalSourceAppIndex(i);
     508        3158 :     transformBoundingBox(bbox, *_from_transforms[from_global_num]);
     509             : 
     510             :     // Cast the bounding box into a pair of points (so it can be put through
     511             :     // MPI communication).
     512        3158 :     bb_points[i] = static_cast<std::pair<Point, Point>>(bbox);
     513             :   }
     514             : 
     515             :   // Serialize the bounding box points.
     516        2608 :   _communicator.allgather(bb_points);
     517             : 
     518             :   // Recast the points back into bounding boxes and return.
     519        2608 :   std::vector<BoundingBox> bboxes(bb_points.size());
     520        7198 :   for (unsigned int i = 0; i < bb_points.size(); i++)
     521        4590 :     bboxes[i] = static_cast<BoundingBox>(bb_points[i]);
     522             : 
     523             :   // possibly extend bounding boxes
     524        2608 :   extendBoundingBoxes(_bbox_factor, bboxes);
     525             : 
     526        5216 :   return bboxes;
     527        2608 : }
     528             : 
     529             : std::vector<BoundingBox>
     530          97 : MultiAppTransfer::getFromBoundingBoxes(BoundaryID boundary_id)
     531             : {
     532          97 :   std::vector<std::pair<Point, Point>> bb_points(_from_meshes.size());
     533          97 :   const Real min_r = std::numeric_limits<Real>::lowest();
     534          97 :   const Real max_r = std::numeric_limits<Real>::max();
     535             : 
     536         210 :   for (unsigned int i = 0; i < _from_meshes.size(); i++)
     537             :   {
     538             : 
     539         113 :     Point min(max_r, max_r, max_r);
     540         113 :     Point max(min_r, min_r, min_r);
     541         113 :     bool at_least_one = false;
     542             : 
     543             :     // TODO: Factor this into mesh_tools after adding new boundary bounding box routine.
     544         113 :     const ConstBndNodeRange & bnd_nodes = *_from_meshes[i]->getBoundaryNodeRange();
     545        6555 :     for (const auto & bnode : bnd_nodes)
     546             :     {
     547        8052 :       if (bnode->_bnd_id == boundary_id &&
     548        1610 :           bnode->_node->processor_id() == _from_meshes[i]->processor_id())
     549             :       {
     550        1566 :         at_least_one = true;
     551        1566 :         const auto & node = *bnode->_node;
     552        6264 :         for (const auto i : make_range(Moose::dim))
     553             :         {
     554        4698 :           min(i) = std::min(min(i), node(i));
     555        4698 :           max(i) = std::max(max(i), node(i));
     556             :         }
     557             :       }
     558             :     }
     559             : 
     560         113 :     BoundingBox bbox(min, max);
     561         113 :     if (!at_least_one)
     562           9 :       bbox.min() = max; // If we didn't hit any nodes, this will be _the_ minimum bbox
     563             :     else
     564             :     {
     565             :       // Translate the bounding box to the from domain's position. We may have rotations so we must
     566             :       // be careful in constructing the new min and max (first and second)
     567         104 :       const auto from_global_num = getGlobalSourceAppIndex(i);
     568         104 :       transformBoundingBox(bbox, *_from_transforms[from_global_num]);
     569             :     }
     570             : 
     571             :     // Cast the bounding box into a pair of points (so it can be put through
     572             :     // MPI communication).
     573         113 :     bb_points[i] = static_cast<std::pair<Point, Point>>(bbox);
     574             :   }
     575             : 
     576             :   // Serialize the bounding box points.
     577          97 :   _communicator.allgather(bb_points);
     578             : 
     579             :   // Recast the points back into bounding boxes and return.
     580          97 :   std::vector<BoundingBox> bboxes(bb_points.size());
     581         252 :   for (unsigned int i = 0; i < bb_points.size(); i++)
     582         155 :     bboxes[i] = static_cast<BoundingBox>(bb_points[i]);
     583             : 
     584             :   // possibly extend bounding boxes
     585          97 :   extendBoundingBoxes(_bbox_factor, bboxes);
     586             : 
     587         194 :   return bboxes;
     588          97 : }
     589             : 
     590             : std::vector<unsigned int>
     591       59413 : MultiAppTransfer::getFromsPerProc()
     592             : {
     593       59413 :   std::vector<unsigned int> froms_per_proc;
     594       59413 :   if (_to_multi_app)
     595       29375 :     froms_per_proc.resize(n_processors(), 1);
     596       59413 :   if (_from_multi_app)
     597             :   {
     598       31036 :     froms_per_proc.resize(n_processors());
     599       31036 :     _communicator.allgather(_from_multi_app->numLocalApps(), froms_per_proc);
     600             :   }
     601       59413 :   return froms_per_proc;
     602           0 : }
     603             : 
     604             : NumericVector<Real> &
     605        1598 : MultiAppTransfer::getTransferVector(unsigned int i_local, std::string var_name)
     606             : {
     607             :   mooseAssert(_to_multi_app, "getTransferVector only works for transfers to multiapps");
     608             : 
     609        1598 :   return _to_multi_app->appTransferVector(_to_local2global_map[i_local], var_name);
     610             : }
     611             : 
     612             : void
     613        4536 : MultiAppTransfer::checkVariable(const FEProblemBase & fe_problem,
     614             :                                 const VariableName & var_name,
     615             :                                 const std::string & param_name) const
     616             : {
     617        4536 :   if (!fe_problem.hasVariable(var_name))
     618             :   {
     619           4 :     if (param_name.empty())
     620           4 :       mooseError("The variable '", var_name, "' does not exist.");
     621             :     else
     622           0 :       paramError(param_name, "The variable '", var_name, "' does not exist.");
     623             :   }
     624        4532 : }
     625             : 
     626             : Point
     627         394 : MultiAppTransfer::getPointInTargetAppFrame(const Point & p,
     628             :                                            unsigned int local_i_to,
     629             :                                            const std::string & phase) const
     630             : {
     631         394 :   const auto & to_transform = _to_transforms[getGlobalTargetAppIndex(local_i_to)];
     632         394 :   if (to_transform->hasCoordinateSystemTypeChange())
     633             :   {
     634           0 :     if (!_skip_coordinate_collapsing)
     635           0 :       mooseInfo(phase + " cannot use the point in the target app frame due to the "
     636             :                         "non-uniqueness of the coordinate collapsing reverse mapping."
     637             :                         " Coordinate collapse is ignored for this operation");
     638           0 :     to_transform->skipCoordinateCollapsing(true);
     639           0 :     const auto target_point = to_transform->mapBack(p);
     640           0 :     to_transform->skipCoordinateCollapsing(false);
     641           0 :     return target_point;
     642             :   }
     643             :   else
     644         394 :     return to_transform->mapBack(p);
     645             : }
     646             : 
     647             : unsigned int
     648     5570231 : MultiAppTransfer::getGlobalSourceAppIndex(unsigned int i_from) const
     649             : {
     650             :   mooseAssert(_current_direction == TO_MULTIAPP || i_from < _from_local2global_map.size(),
     651             :               "Out of bounds local from-app index");
     652     5570231 :   return _current_direction == TO_MULTIAPP ? 0 : _from_local2global_map[i_from];
     653             : }
     654             : 
     655             : unsigned int
     656      466298 : MultiAppTransfer::getGlobalTargetAppIndex(unsigned int i_to) const
     657             : {
     658             :   mooseAssert(_current_direction == FROM_MULTIAPP || i_to < _to_local2global_map.size(),
     659             :               "Out of bounds local to-app index");
     660      466298 :   return _current_direction == FROM_MULTIAPP ? 0 : _to_local2global_map[i_to];
     661             : }
     662             : 
     663             : unsigned int
     664           0 : MultiAppTransfer::getLocalSourceAppIndex(unsigned int i_from) const
     665             : {
     666           0 :   return _current_direction == TO_MULTIAPP
     667           0 :              ? 0
     668           0 :              : _from_local2global_map[i_from] - _from_local2global_map[0];
     669             : }
     670             : 
     671             : void
     672       28350 : MultiAppTransfer::checkParentAppUserObjectExecuteOn(const std::string & object_name) const
     673             : {
     674             :   // Source app is not the parent, most execution schedules are fine since the transfer occurs after
     675             :   // the app has run NOTE: not true for siblings transfer
     676       28350 :   if (hasFromMultiApp())
     677           0 :     return;
     678             :   // Get user object from parent. We don't know the type
     679       28350 :   const auto & uo = _fe_problem.getUserObject<UserObject>(object_name);
     680             :   // If we are executing on transfers, every additional schedule is not a problem
     681       28350 :   if (uo.getExecuteOnEnum().contains(EXEC_TRANSFER))
     682       26538 :     return;
     683             :   // If we are transferring on the same schedule as we are executing, we are lagging. Is it on
     684             :   // purpose? We don't know, so we will give a warning unless silenced.
     685             :   // The derived-classes offer the parameter to silence this warning
     686             :   // Note: UOs execute before transfers on INITIAL so it's not a problem at this time
     687        1824 :   if (uo.getExecuteOnEnum().contains(_fe_problem.getCurrentExecuteOnFlag()) &&
     688          12 :       _fe_problem.getCurrentExecuteOnFlag() != EXEC_INITIAL)
     689           0 :     if (!isParamValid("warn_source_object_execution_schedule") ||
     690           0 :         getParam<bool>("warn_source_object_execution_schedule"))
     691           0 :       uo.paramWarning("execute_on",
     692           0 :                       "This UserObject-derived class is being executed on '" +
     693           0 :                           Moose::stringify(_fe_problem.getCurrentExecuteOnFlag()) +
     694           0 :                           "' and also providing values for the '" + name() +
     695             :                           "' transfer, on that same execution schedule. Because user objects are "
     696             :                           "executed after transfers are, this means the values provided by this "
     697             :                           "user object are lagged. If you are ok with this, then set the "
     698             :                           "'warn_source_object_execution_schedule' parameter to false in this "
     699           0 :                           "Transfer. If not, then execute '" +
     700           0 :                           uo.name() +
     701             :                           "' on TRANSFER by adding it to the 'execute_on' vector parameter.");
     702             : }
     703             : 
     704             : void
     705       28442 : MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(const std::string & object_name) const
     706             : {
     707             :   // parent app is the source app, EXEC_TRANSFER is fine
     708       28442 :   if (!hasFromMultiApp())
     709           0 :     return;
     710             :   // Get the app and problem
     711       28442 :   const auto & app = getFromMultiApp();
     712       28442 :   if (!app->hasApp())
     713           0 :     return;
     714       28442 :   const auto & problem = app->appProblemBase(app->firstLocalApp());
     715             :   // Use the warehouse to find the object
     716       28442 :   std::vector<SetupInterface *> objects_with_exec_on;
     717       28442 :   problem.theWarehouse()
     718       56884 :       .query()
     719       28442 :       .template condition<AttribName>(object_name)
     720       28442 :       .template condition<AttribExecOns>(EXEC_TRANSFER)
     721       28442 :       .queryInto(objects_with_exec_on);
     722       28442 :   if (objects_with_exec_on.size())
     723           4 :     mooseError("Object '" + object_name +
     724             :                "' should not be executed on EXEC_TRANSFER, because this transfer has "
     725             :                "indicated it does not support it.\nExecuting this object on TIMESTEP_END should be "
     726             :                "sufficient to get updated values.");
     727       28438 : }

Generated by: LCOV version 1.14