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 "SubdomainBoundingBoxGenerator.h"
      11             : #include "Conversion.h"
      12             : #include "CastUniquePointer.h"
      13             : #include "MooseUtils.h"
      14             : #include "MooseMeshUtils.h"
      15             : 
      16             : #include "libmesh/elem.h"
      17             : 
      18             : registerMooseObject("MooseApp", SubdomainBoundingBoxGenerator);
      19             : 
      20             : InputParameters
      21       26413 : SubdomainBoundingBoxGenerator::validParams()
      22             : {
      23       26413 :   MooseEnum location("INSIDE OUTSIDE", "INSIDE");
      24             : 
      25       26413 :   InputParameters params = MeshGenerator::validParams();
      26             : 
      27       26413 :   params.addRequiredParam<MeshGeneratorName>("input", "The mesh we want to modify");
      28       26413 :   params.addClassDescription("Changes the subdomain ID of elements either (XOR) inside or outside "
      29             :                              "the specified box to the specified ID.");
      30       26413 :   params.addRequiredParam<RealVectorValue>(
      31             :       "bottom_left", "The bottom left point (in x,y,z with spaces in-between).");
      32       26413 :   params.addRequiredParam<RealVectorValue>(
      33             :       "top_right", "The bottom left point (in x,y,z with spaces in-between).");
      34       26413 :   params.addRequiredParam<subdomain_id_type>(
      35             :       "block_id", "Subdomain id to set for inside/outside the bounding box");
      36       26413 :   params.addParam<SubdomainName>(
      37             :       "block_name", "Subdomain name to set for inside/outside the bounding box (optional)");
      38       26413 :   params.addParam<MooseEnum>(
      39             :       "location", location, "Control of where the subdomain id is to be set");
      40       26413 :   params.addParam<std::vector<SubdomainName>>(
      41             :       "restricted_subdomains",
      42             :       "Only reset subdomain ID for given subdomains within the bounding box");
      43             : 
      44       26413 :   params.addParam<std::string>("integer_name",
      45             :                                "Element integer to be assigned (default to subdomain ID)");
      46       52826 :   return params;
      47       26413 : }
      48             : 
      49        6070 : SubdomainBoundingBoxGenerator::SubdomainBoundingBoxGenerator(const InputParameters & parameters)
      50             :   : MeshGenerator(parameters),
      51        6070 :     _input(getMesh("input")),
      52        6070 :     _location(parameters.get<MooseEnum>("location")),
      53        6070 :     _block_id(parameters.get<subdomain_id_type>("block_id")),
      54        6070 :     _has_restriction(isParamValid("restricted_subdomains")),
      55        6070 :     _bounding_box(MooseUtils::buildBoundingBox(parameters.get<RealVectorValue>("bottom_left"),
      56       12140 :                                                parameters.get<RealVectorValue>("top_right")))
      57             : {
      58        6070 : }
      59             : 
      60             : std::unique_ptr<MeshBase>
      61        5773 : SubdomainBoundingBoxGenerator::generate()
      62             : {
      63        5773 :   std::unique_ptr<MeshBase> mesh = std::move(_input);
      64             : 
      65        5773 :   std::set<SubdomainID> restricted_ids;
      66        5773 :   if (_has_restriction)
      67             :   {
      68          13 :     auto names = getParam<std::vector<SubdomainName>>("restricted_subdomains");
      69          22 :     for (auto & name : names)
      70             :     {
      71             :       // check that the subdomain exists in the mesh
      72          13 :       if (!MooseMeshUtils::hasSubdomainName(*mesh, name))
      73           4 :         paramError("restricted_subdomains", "The block '", name, "' was not found in the mesh");
      74             : 
      75           9 :       restricted_ids.insert(MooseMeshUtils::getSubdomainID(name, *mesh));
      76             :     }
      77           9 :   }
      78             : 
      79        5769 :   if (isParamValid("integer_name"))
      80             :   {
      81         700 :     std::string integer_name = getParam<std::string>("integer_name");
      82             : 
      83         700 :     if (!mesh->has_elem_integer(integer_name))
      84           0 :       mooseError("Mesh does not have an element integer names as ", integer_name);
      85             : 
      86         700 :     unsigned int id = mesh->get_elem_integer_index(integer_name);
      87             : 
      88             :     // Loop over the elements
      89      123420 :     for (const auto & elem : mesh->active_element_ptr_range())
      90             :     {
      91       61360 :       if (_has_restriction && restricted_ids.count(elem->subdomain_id()) == 0)
      92           0 :         continue;
      93             : 
      94       61360 :       bool contains = _bounding_box.contains_point(elem->vertex_average());
      95       61360 :       if ((contains && _location == "INSIDE") || (!contains && _location == "OUTSIDE"))
      96       22195 :         elem->set_extra_integer(id, _block_id);
      97         700 :     }
      98         700 :   }
      99             :   else
     100             :   {
     101             :     // Loop over the elements
     102     1013937 :     for (const auto & elem : mesh->element_ptr_range())
     103             :     {
     104      504434 :       if (_has_restriction && restricted_ids.count(elem->subdomain_id()) == 0)
     105         576 :         continue;
     106             : 
     107      503858 :       bool contains = _bounding_box.contains_point(elem->vertex_average());
     108      503858 :       if ((contains && _location == "INSIDE") || (!contains && _location == "OUTSIDE"))
     109      187886 :         elem->subdomain_id() = _block_id;
     110        5069 :     }
     111             : 
     112             :     // Assign block name, if provided
     113        5069 :     if (isParamValid("block_name"))
     114         258 :       mesh->subdomain_name(_block_id) = getParam<SubdomainName>("block_name");
     115             :   }
     116             : 
     117        5769 :   mesh->set_isnt_prepared();
     118       11538 :   return dynamic_pointer_cast<MeshBase>(mesh);
     119        5769 : }