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             : #include "CoupledInjectionProductionPhysics.h"
      11             : 
      12             : registerPhysicsBaseTasks("PorousFlowApp", CoupledInjectionProductionPhysics);
      13             : registerMooseAction("PorousFlowApp", CoupledInjectionProductionPhysics, "add_dirac_kernel");
      14             : registerMooseAction("PorousFlowApp", CoupledInjectionProductionPhysics, "add_postprocessor");
      15             : registerMooseAction("PorousFlowApp", CoupledInjectionProductionPhysics, "add_transfer");
      16             : 
      17             : InputParameters
      18           9 : CoupledInjectionProductionPhysics::validParams()
      19             : {
      20           9 :   InputParameters params = PhysicsBase::validParams();
      21             : 
      22          18 :   params.addRequiredParam<std::vector<Point>>("injection_points", "List of injection points [m]");
      23          18 :   params.addRequiredParam<std::vector<Point>>("production_points", "List of production points [m]");
      24          18 :   params.addParam<MultiAppName>("multi_app", "MultiApp to transfer to and from");
      25             : 
      26           9 :   params.addClassDescription(
      27             :       "Adds objects to perform hydrodynamic coupling at injection and production points.");
      28             : 
      29           9 :   return params;
      30           0 : }
      31             : 
      32           9 : CoupledInjectionProductionPhysics::CoupledInjectionProductionPhysics(
      33           9 :     const InputParameters & parameters)
      34             :   : PhysicsBase(parameters),
      35           9 :     _injection_points(getParam<std::vector<Point>>("injection_points")),
      36          27 :     _production_points(getParam<std::vector<Point>>("production_points"))
      37             : {
      38           9 :   _points = _injection_points;
      39           9 :   _points.insert(_points.end(), _production_points.begin(), _production_points.end());
      40             : 
      41          18 :   for (const auto i : index_range(_injection_points))
      42          18 :     _labels.push_back("inj" + std::to_string(i + 1));
      43          18 :   for (const auto i : index_range(_production_points))
      44          18 :     _labels.push_back("pro" + std::to_string(i + 1));
      45           9 : }
      46             : 
      47             : void
      48           9 : CoupledInjectionProductionPhysics::addDiracKernels()
      49             : {
      50          27 :   for (const auto i : index_range(_points))
      51             :   {
      52          72 :     addPPSourceDiracKernel(_points[i], "porepressure", "mass_rate_" + _labels[i]);
      53          72 :     addPPSourceDiracKernel(_points[i], "temperature", "energy_rate_" + _labels[i]);
      54             :   }
      55           9 : }
      56             : 
      57             : void
      58           9 : CoupledInjectionProductionPhysics::addPostprocessors()
      59             : {
      60          27 :   for (const auto i : index_range(_points))
      61             :   {
      62          72 :     addPointValuePostprocessor("porepressure", _points[i], "p_" + _labels[i]);
      63          72 :     addPointValuePostprocessor("temperature", _points[i], "T_" + _labels[i]);
      64          54 :     addReceiverPostprocessor("mass_rate_" + _labels[i]);
      65          54 :     addReceiverPostprocessor("energy_rate_" + _labels[i]);
      66             :   }
      67           9 : }
      68             : 
      69             : void
      70           9 : CoupledInjectionProductionPhysics::addTransfers()
      71             : {
      72          18 :   if (isParamValid("multi_app"))
      73          27 :     for (const auto i : index_range(_points))
      74             :     {
      75          54 :       addPostprocessorTransfer("p_" + _labels[i], false);
      76          54 :       addPostprocessorTransfer("T_" + _labels[i], false);
      77          54 :       addPostprocessorTransfer("mass_rate_" + _labels[i], true);
      78          54 :       addPostprocessorTransfer("energy_rate_" + _labels[i], true);
      79             :     }
      80           9 : }
      81             : 
      82             : void
      83          36 : CoupledInjectionProductionPhysics::addPPSourceDiracKernel(const Point & point,
      84             :                                                           const NonlinearVariableName & var,
      85             :                                                           const PostprocessorName & pp_name)
      86             : {
      87          36 :   const std::string class_name = "PorousFlowPointSourceFromPostprocessor";
      88          36 :   auto params = _factory.getValidParams(class_name);
      89          36 :   params.set<NonlinearVariableName>("variable") = var;
      90          36 :   params.set<Point>("point") = point;
      91          36 :   params.set<PostprocessorName>("mass_flux") = pp_name;
      92          36 :   getProblem().addDiracKernel(class_name, "dirac_" + pp_name, params);
      93          72 : }
      94             : 
      95             : void
      96          36 : CoupledInjectionProductionPhysics::addReceiverPostprocessor(const PostprocessorName & pp_name)
      97             : {
      98          36 :   const std::string class_name = "Receiver";
      99          36 :   auto params = _factory.getValidParams(class_name);
     100          36 :   getProblem().addPostprocessor(class_name, pp_name, params);
     101          72 : }
     102             : 
     103             : void
     104          36 : CoupledInjectionProductionPhysics::addPointValuePostprocessor(const VariableName & var,
     105             :                                                               const Point & point,
     106             :                                                               const PostprocessorName & pp_name)
     107             : {
     108          36 :   const std::string class_name = "PointValue";
     109          36 :   auto params = _factory.getValidParams(class_name);
     110          36 :   params.set<VariableName>("variable") = var;
     111          36 :   params.set<Point>("point") = point;
     112         144 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     113          36 :   getProblem().addPostprocessor(class_name, pp_name, params);
     114         108 : }
     115             : 
     116             : void
     117          72 : CoupledInjectionProductionPhysics::addPostprocessorTransfer(const PostprocessorName & pp_name,
     118             :                                                             bool from_multi_app)
     119             : {
     120          72 :   const std::string class_name = "MultiAppPostprocessorTransfer";
     121          72 :   auto params = _factory.getValidParams(class_name);
     122          72 :   if (from_multi_app)
     123         108 :     params.set<MultiAppName>("from_multi_app") = getParam<MultiAppName>("multi_app");
     124             :   else
     125         108 :     params.set<MultiAppName>("to_multi_app") = getParam<MultiAppName>("multi_app");
     126          72 :   params.set<PostprocessorName>("from_postprocessor") = pp_name;
     127          72 :   params.set<PostprocessorName>("to_postprocessor") = pp_name;
     128         144 :   params.set<MooseEnum>("reduction_type") = "average";
     129         288 :   params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_TIMESTEP_END};
     130          72 :   getProblem().addTransfer(class_name, pp_name + "_transfer", params);
     131         216 : }