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