ParsedSubdomainGeneratorBase.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#include "ParsedSubdomainGeneratorBase.h"
#include "Conversion.h"
#include "MooseMeshUtils.h"
#include "CastUniquePointer.h"

#include "libmesh/fparser_ad.hh"
#include "libmesh/elem.h"

InputParameters
ParsedSubdomainGeneratorBase::validParams()
{
  InputParameters params = MeshGenerator::validParams();
  params += FunctionParserUtils<false>::validParams();

  params.addRequiredParam<MeshGeneratorName>("input", "The mesh we want to modify");
  params.addRequiredParam<std::string>(
      "expression", "Parsed expression to determine the subdomain id of each involved element");
  params.addParam<std::vector<SubdomainName>>(
      "excluded_subdomains",
      "A set of subdomain names that will be immune to change if set. This cannot be used together "
      "with included_subdomains.");
  params.addDeprecatedParam<std::vector<subdomain_id_type>>(
      "excluded_subdomain_ids",
      "A set of subdomain ids that will not changed even if "
      "they are inside/outside the combinatorial geometry",
      "excluded_subdomain_ids is deprecated, use excluded_subdomains (ids or names accepted)");
  params.addParam<std::vector<SubdomainName>>(
      "included_subdomains",
      "A set of subdomain names that will only be subjected to change if set. This cannot be used "
      "together with excluded_subdomains.");
  params.addParam<std::vector<std::string>>(
      "constant_names", {}, "Vector of constants used in the parsed function");
  params.addParam<std::vector<std::string>>(
      "constant_expressions",
      {},
      "Vector of values for the constants in constant_names (can be an FParser expression)");
  params.addParam<std::vector<ExtraElementIDName>>(
      "extra_element_id_names", {}, "Extra element integers used in the parsed expression");
  params.addClassDescription("A base class for mesh generators that Use a parsed expression to "
                             "assign new subdomain id(s).");

  return params;
}

ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(const InputParameters & parameters)
  : MeshGenerator(parameters),
    FunctionParserUtils<false>(parameters),
    _input(getMesh("input")),
    _function(parameters.get<std::string>("expression")),
    _excluded_ids(isParamValid("excluded_subdomain_ids")
                      ? parameters.get<std::vector<subdomain_id_type>>("excluded_subdomain_ids")
                      : std::vector<subdomain_id_type>()),
    _eeid_names(getParam<std::vector<ExtraElementIDName>>("extra_element_id_names"))
{
  if ((isParamValid("excluded_subdomains") || isParamValid("excluded_subdomain_ids")) &&
      (isParamValid("included_subdomains")))
    paramError("excluded_subdomains",
               "You cannot use both excluded_subdomains and included_subdomains at the same time.");

  functionInitialize(_function);
}

std::unique_ptr<MeshBase>
ParsedSubdomainGeneratorBase::generate()
{
  std::unique_ptr<MeshBase> mesh = std::move(_input);

  // Make sure subdomain caches are up to date
  if (!mesh->preparation().has_cached_elem_data)
    mesh->cache_elem_data();

  // the extra element ids would not have existed at construction so we only do this now
  for (const auto & eeid_name : _eeid_names)
    _eeid_indices.push_back(mesh->get_elem_integer_index(eeid_name));

  if (isParamValid("excluded_subdomains"))
  {
    auto excluded_subdomains = parameters().get<std::vector<SubdomainName>>("excluded_subdomains");

    // check that the subdomains exist in the mesh
    for (const auto & name : excluded_subdomains)
      if (!MooseMeshUtils::hasSubdomainName(*mesh, name))
        paramError("excluded_subdomains", "The block '", name, "' was not found in the mesh");

    _excluded_ids = MooseMeshUtils::getSubdomainIDs(*mesh, excluded_subdomains);
  }
  else if (isParamValid("included_subdomains"))
  {
    auto included_subdomains = parameters().get<std::vector<SubdomainName>>("included_subdomains");

    // check that the subdomains exist in the mesh
    for (const auto & name : included_subdomains)
      if (!MooseMeshUtils::hasSubdomainName(*mesh, name))
        paramError("included_subdomains", "The block '", name, "' was not found in the mesh");

    auto included_ids = MooseMeshUtils::getSubdomainIDs(*mesh, included_subdomains);

    // collect all subdomain ids in the mesh
    std::set<subdomain_id_type> mesh_sids;
    mesh->subdomain_ids(mesh_sids);

    // set excluded ids to all mesh sids that are not in included ids
    for (const auto & sid : mesh_sids)
      if (std::find(included_ids.begin(), included_ids.end(), sid) == included_ids.end())
        _excluded_ids.push_back(sid);
  }

  // Loop over the elements
  for (const auto & elem : mesh->active_element_ptr_range())
    assignElemSubdomainID(elem);

  // Assign block name, if applicable
  setBlockName(mesh);

  mesh->unset_is_prepared();
  return dynamic_pointer_cast<MeshBase>(mesh);
}

void
ParsedSubdomainGeneratorBase::functionInitialize(const std::string & function_expression)
{
  // add the extra element integers
  std::string symbol_str = "x,y,z";
  for (const auto & eeid_name : _eeid_names)
    symbol_str += "," + eeid_name;

  // Create parsed function
  _func_F = std::make_shared<SymFunction>();
  parsedFunctionSetup(_func_F,
                      function_expression,
                      symbol_str,
                      getParam<std::vector<std::string>>("constant_names"),
                      getParam<std::vector<std::string>>("constant_expressions"),
                      comm());

  _func_params.resize(3 + _eeid_names.size());
}