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 "BoundaryElementConversionGenerator.h"
      11             : #include "MooseMeshElementConversionUtils.h"
      12             : #include "CastUniquePointer.h"
      13             : #include "MooseMeshUtils.h"
      14             : 
      15             : #include "libmesh/mesh_serializer.h"
      16             : 
      17             : registerMooseObject("MooseApp", BoundaryElementConversionGenerator);
      18             : 
      19             : InputParameters
      20       14433 : BoundaryElementConversionGenerator::validParams()
      21             : {
      22       14433 :   InputParameters params = MeshGenerator::validParams();
      23             : 
      24       57732 :   params.addParam<MeshGeneratorName>(
      25             :       "input",
      26             :       "mesh generator creating the mesh on which to create the boundary transition layer on.");
      27       57732 :   params.addRequiredParam<std::vector<BoundaryName>>(
      28             :       "boundary_names", "Boundaries that need to be converted to form a transition layer.");
      29       43299 :   params.addParam<unsigned int>(
      30             :       "conversion_element_layer_number",
      31       28866 :       1,
      32             :       "The number of layers of elements to be converted. The farthest layer of the elements from "
      33             :       "the given boundary are converted to elements compatible with the remainder of the mesh, "
      34             :       "while the other layers of elements are converted into TET4.");
      35       57732 :   params.addParam<SubdomainName>("converted_tet_element_subdomain_name_suffix",
      36             :                                  "to_tet",
      37             :                                  "The suffix to be added to the original subdomain name for the "
      38             :                                  "subdomains containing the elements converted to TET4.");
      39       57732 :   params.addParam<SubdomainName>(
      40             :       "converted_pyramid_element_subdomain_name_suffix",
      41             :       "to_pyramid",
      42             :       "The suffix to be added to the original subdomain name for the subdomains containing the "
      43             :       "elements converted to PYRAMID5.");
      44       43299 :   params.addParam<bool>("external_boundaries_checking",
      45       28866 :                         false,
      46             :                         "Whether to check if provided boundaries are external.");
      47             : 
      48       14433 :   params.addClassDescription("Convert the elements involved in a set of external boundaries to "
      49             :                              "ensure that the boundary set only contains TRI3 elements");
      50             : 
      51       14433 :   return params;
      52           0 : }
      53             : 
      54          83 : BoundaryElementConversionGenerator::BoundaryElementConversionGenerator(
      55          83 :     const InputParameters & parameters)
      56             :   : MeshGenerator(parameters),
      57          83 :     _input(getMesh("input")),
      58         166 :     _boundary_names(getParam<std::vector<BoundaryName>>("boundary_names")),
      59         166 :     _conversion_element_layer_number(getParam<unsigned int>("conversion_element_layer_number")),
      60         249 :     _external_boundaries_checking(getParam<bool>("external_boundaries_checking"))
      61             : {
      62          83 : }
      63             : 
      64             : std::unique_ptr<MeshBase>
      65          83 : BoundaryElementConversionGenerator::generate()
      66             : {
      67          83 :   UnstructuredMesh & mesh = dynamic_cast<UnstructuredMesh &>(*_input);
      68             : 
      69          83 :   libMesh::MeshSerializer serial_mesh(mesh);
      70             : 
      71             :   // collect the subdomain ids of the original mesh
      72          83 :   std::set<subdomain_id_type> original_subdomain_ids;
      73        2025 :   for (auto elem_it = mesh.active_elements_begin(); elem_it != mesh.active_elements_end();
      74             :        elem_it++)
      75             :   {
      76        1942 :     original_subdomain_ids.emplace((*elem_it)->subdomain_id());
      77          83 :   }
      78             :   try
      79             :   {
      80          83 :     MooseMeshElementConversionUtils::transitionLayerGenerator(
      81          83 :         mesh, _boundary_names, _conversion_element_layer_number, _external_boundaries_checking);
      82             :   }
      83          20 :   catch (const MooseException & e)
      84             :   {
      85          40 :     if (((std::string)e.what()).compare("subdomain id overflow") == 0)
      86           8 :       paramError("input",
      87             :                  "Some subdomain ids of the input mesh are too large and cause overflow when "
      88             :                  "assigning new subdomain ids during element conversion. Please consider lowering "
      89             :                  "the subdomain ids using RenameBlockGenerator.");
      90          32 :     else if (((std::string)e.what()).compare(13, 8, "boundary") == 0)
      91          24 :       paramError("boundary_names", e.what());
      92             :     else
      93           8 :       paramError("input", e.what());
      94           0 :   }
      95             :   try
      96             :   {
      97         252 :     MooseMeshElementConversionUtils::assignConvertedElementsSubdomainNameSuffix(
      98             :         mesh,
      99             :         original_subdomain_ids,
     100          63 :         *original_subdomain_ids.rbegin() + 1,
     101             :         getParam<SubdomainName>("converted_tet_element_subdomain_name_suffix"),
     102             :         getParam<SubdomainName>("converted_pyramid_element_subdomain_name_suffix"));
     103             :   }
     104           0 :   catch (const std::exception & e)
     105             :   {
     106           0 :     if (((std::string)e.what()).compare(26, 4, "TET4") == 0)
     107           0 :       paramError("converted_tet_element_subdomain_name_suffix", e.what());
     108             :     else // if (((std::string)e.what()).compare(26, 7, "PYRAMID5") == 0)
     109           0 :       paramError("converted_pyramid_element_subdomain_name_suffix", e.what());
     110           0 :   }
     111             : 
     112             :   // MeshSerializer's destructor calls delete_remote_elements()
     113          63 :   if (!mesh.is_replicated())
     114           0 :     mesh.prepare_for_use();
     115             :   else
     116          63 :     mesh.set_isnt_prepared();
     117             : 
     118         126 :   return std::move(_input);
     119          63 : }