CSGRegion.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 "CSGRegion.h"
 
namespace CSG
{
 
char
CSGRegion::regionSymbol(const RegionType region_type)
{
  mooseAssert(region_type == RegionType::COMPLEMENT || region_type == RegionType::UNION ||
                  region_type == RegionType::INTERSECTION,
              "Unexpected region type");
 
  static constexpr std::array<char, 5> symbols = {
      '\0', // CSGRegion::RegionType::EMPTY (unused)
      '\0', // CSGRegion::RegionType::HALFSPACE (unused)
      '~',  // CSGRegion::RegionType::COMPLEMENT
      '&',  // CSGRegion::RegionType::INTERSECTION
      '|'   // CSGRegion::RegionType::UNION
  };
  static_assert(symbols[static_cast<std::size_t>(RegionType::COMPLEMENT)] == '~');
  static_assert(symbols[static_cast<std::size_t>(RegionType::INTERSECTION)] == '&');
  static_assert(symbols[static_cast<std::size_t>(RegionType::UNION)] == '|');
 
  return symbols[static_cast<std::size_t>(region_type)];
}
 
char
CSGRegion::halfspaceSymbol(const CSGSurface::Halfspace halfspace)
{
  mooseAssert(halfspace == CSGSurface::Halfspace::POSITIVE ||
                  halfspace == CSGSurface::Halfspace::NEGATIVE,
              "Unexpected halfspace");
 
  static constexpr std::array<char, 2> symbols = {
      '+', // CSGSurface::Halfspace::POSITIVE
      '-'  // CSGSurface::Halfspace::NEGATIVE
  };
  static_assert(symbols[static_cast<std::size_t>(CSGSurface::Halfspace::POSITIVE)] == '+');
  static_assert(symbols[static_cast<std::size_t>(CSGSurface::Halfspace::NEGATIVE)] == '-');
 
  return symbols[static_cast<std::size_t>(halfspace)];
}
 
bool
CSGRegion::checkRegionEquality(const std::vector<PostfixTokenVariant> & other_tokens) const
{
  const auto & tokens = getPostfixTokens();
  if (tokens.size() != other_tokens.size())
    return false;
 
  // Loop through all tokens and check equality
  for (const auto i : index_range(tokens))
  {
    const auto & token = tokens[i];
    const auto & other_token = other_tokens[i];
    if (std::holds_alternative<std::reference_wrapper<const CSGSurface>>(token))
    {
      // For surface references, compare references themselves for equality
      if (!std::holds_alternative<std::reference_wrapper<const CSGSurface>>(other_token))
        return false;
      const auto & surf_ref = std::get<std::reference_wrapper<const CSGSurface>>(token);
      const auto & other_surf_ref = std::get<std::reference_wrapper<const CSGSurface>>(other_token);
      if (surf_ref.get() != other_surf_ref.get())
        return false;
    }
    else
    {
      // For region types and halfspaces, compare based on string representations
      mooseAssert(std::holds_alternative<RegionType>(token) ||
                      std::holds_alternative<CSGSurface::Halfspace>(token),
                  "Unexpected token type");
      if (std::holds_alternative<std::reference_wrapper<const CSGSurface>>(other_token))
        return false;
      if (postfixTokenToString(token) != postfixTokenToString(other_token))
        return false;
    }
  }
  return true;
}
 
std::string
CSGRegion::regionTypeName(const RegionType region_type)
{
  mooseAssert(region_type == RegionType::COMPLEMENT || region_type == RegionType::INTERSECTION ||
                  region_type == RegionType::UNION,
              "Unexpected region type");
 
  static constexpr std::array<const char *, 5> names = {
      nullptr,        // RegionType::EMPTY (not used as a postfix operator)
      nullptr,        // RegionType::HALFSPACE (not used as a postfix operator)
      "COMPLEMENT",   // RegionType::COMPLEMENT
      "INTERSECTION", // RegionType::INTERSECTION
      "UNION"         // RegionType::UNION
  };
  static_assert(names[static_cast<std::size_t>(RegionType::COMPLEMENT)] ==
                std::string_view("COMPLEMENT"));
  static_assert(names[static_cast<std::size_t>(RegionType::INTERSECTION)] ==
                std::string_view("INTERSECTION"));
  static_assert(names[static_cast<std::size_t>(RegionType::UNION)] == std::string_view("UNION"));
 
  return names[static_cast<std::size_t>(region_type)];
}
 
CSGRegion::CSGRegion()
{
  _region_type = "EMPTY";
  _postfix_tokens.clear();
}
 
// halfspace constructor
CSGRegion::CSGRegion(const CSGSurface & surf, const CSGSurface::Halfspace halfspace)
{
  _region_type = "HALFSPACE";
 
  // (halfspace surf) in postfix is represented as (surf halfspace)
  _postfix_tokens.push_back(surf);
  _postfix_tokens.push_back(halfspace);
}
 
// intersection and union constructor
CSGRegion::CSGRegion(const CSGRegion & region_a,
                     const CSGRegion & region_b,
                     const std::string & region_type)
{
  _region_type = region_type;
  if (getRegionType() != RegionType::INTERSECTION && getRegionType() != RegionType::UNION)
    mooseError("Region type " + getRegionTypeString() + " is not supported for two regions.");
  if (region_a.getRegionType() == RegionType::EMPTY ||
      region_b.getRegionType() == RegionType::EMPTY)
    mooseError("Region operation " + getRegionTypeString() +
               " cannot be performed on an empty region.");
 
  // (region_a region_type region_b) in postfix is represented as (region_a region_b region_type)
  _postfix_tokens.insert(_postfix_tokens.end(),
                         region_a.getPostfixTokens().begin(),
                         region_a.getPostfixTokens().end());
  _postfix_tokens.insert(_postfix_tokens.end(),
                         region_b.getPostfixTokens().begin(),
                         region_b.getPostfixTokens().end());
  _postfix_tokens.push_back(getRegionType());
}
 
// complement or explicitly empty constructor
CSGRegion::CSGRegion(const CSGRegion & region, const std::string & region_type)
{
  _region_type = region_type;
  if (getRegionType() != RegionType::COMPLEMENT && getRegionType() != RegionType::EMPTY)
    mooseError("Region type " + getRegionTypeString() + " is not supported for a single region.");
 
  if (getRegionType() == RegionType::COMPLEMENT)
  {
    // (complement region) in postfix is represented as (region complement)
    _postfix_tokens = region.getPostfixTokens();
    _postfix_tokens.push_back(getRegionType());
  }
  else if (getRegionType() == RegionType::EMPTY)
    _postfix_tokens.clear();
}
 
nlohmann::json
CSGRegion::toInfixJSON() const
{
  // Return an empty JSON object if no postfix tokens are defined
  if (_postfix_tokens.empty())
    return nlohmann::json::parse("[]");
 
  // Build the region string using a stack, iterating through each token within _postfix_tokens
  std::stack<std::string> postfix_stack;
  for (auto i : index_range(_postfix_tokens))
  {
    const auto & token = _postfix_tokens[i];
    // Surface: Push name to stack
    if (const auto surface_ref_ptr = std::get_if<std::reference_wrapper<const CSGSurface>>(&token))
      postfix_stack.push(surface_ref_ptr->get().getName());
    // Halfspaces and region operators
    else
    {
      std::string region_string;
      // Halfspace: Pop from the stack, update region string, push back
      if (const auto halfspace_ptr = std::get_if<CSGSurface::Halfspace>(&token))
      {
        std::string symbol = std::string(1, halfspaceSymbol(*halfspace_ptr));
        region_string = "\"" + symbol + postfix_stack.top() + "\"";
        postfix_stack.pop();
      }
      // Region operator: Pop 1 or 2 values, update region string, push back
      else
      {
        const auto region = std::get<RegionType>(token);
        const std::string symbol{regionSymbol(region)};
        if (region == RegionType::COMPLEMENT)
        {
          region_string = postfix_stack.top();
          postfix_stack.pop();
          if (region_string[0] == '[')
            region_string = "\"" + symbol + "\", " + region_string;
          else
            region_string = "\"" + symbol + "\", [" + region_string + "]";
        }
        else
        {
          auto region_string_b = postfix_stack.top();
          postfix_stack.pop();
          auto region_string_a = postfix_stack.top();
          postfix_stack.pop();
          region_string = region_string_a + ", \"" + symbol + "\", " + region_string_b;
          // Skip putting parentheses around the region string if the next region operator in the
          // postfix token list is identical
          if (!nextRegionOpIsIdentical(region, i + 1))
            region_string = "[" + region_string + "]";
        }
      }
      postfix_stack.push(region_string);
    }
  }
 
  // Top of stack should now have region string we desire. Now, we
  // parse the string into a JSON object
  std::string region_string = postfix_stack.top();
  // Wrap region string in square brackets so that it is always treated as a
  // list in the output JSON object
  if (region_string[0] != '[')
    region_string = "[" + region_string + "]";
  return nlohmann::json::parse(region_string);
}
 
std::vector<std::string>
CSGRegion::toPostfixStringList() const
{
  std::vector<std::string> postfix_string_list;
  postfix_string_list.reserve(_postfix_tokens.size());
  for (const auto & token : _postfix_tokens)
    postfix_string_list.push_back(postfixTokenToString(token));
  return postfix_string_list;
}
 
std::string
CSGRegion::postfixTokenToString(const PostfixTokenVariant & token) const
{
  // Lambda function to return all variant types as strings
  return std::visit(
      [](auto && arg) -> std::string
      {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, std::reference_wrapper<const CSGSurface>>)
          return arg.get().getName();
        else if constexpr (std::is_same_v<T, RegionType>)
          return std::string{regionSymbol(arg)};
        else // if constexpr (std::is_same_v<T, CSGSurface::Halfspace>)
          return std::string{halfspaceSymbol(arg)};
      },
      token);
}
 
bool
CSGRegion::nextRegionOpIsIdentical(const RegionType region,
                                   const std::size_t postfix_token_index) const
{
  for (const auto i : make_range(postfix_token_index, _postfix_tokens.size()))
    if (const auto region_ptr = std::get_if<RegionType>(&_postfix_tokens[i]))
      return region == *region_ptr;
  return false;
}
 
void
CSGRegion::updateSurfaceReferences(
    std::map<std::string, std::reference_wrapper<const CSGSurface>> & identical_surface_refs)
{
  for (auto & token : _postfix_tokens)
    if (std::holds_alternative<std::reference_wrapper<const CSGSurface>>(token))
    {
      const auto & surf_ref = std::get<std::reference_wrapper<const CSGSurface>>(token);
      const auto & surf_name = surf_ref.get().getName();
      if (identical_surface_refs.find(surf_name) != identical_surface_refs.end())
        token = identical_surface_refs.at(surf_name);
    }
}
 
std::vector<std::reference_wrapper<const CSGSurface>>
CSGRegion::getSurfaces() const
{
  std::vector<std::reference_wrapper<const CSGSurface>> surface_references;
  for (auto & token : _postfix_tokens)
    if (std::holds_alternative<std::reference_wrapper<const CSGSurface>>(token))
      surface_references.push_back(std::get<std::reference_wrapper<const CSGSurface>>(token));
 
  return surface_references;
}
 
CSGRegion &
CSGRegion::operator&=(const CSGRegion & other_region)
{
  if (this != &other_region)
    *this = CSGRegion(*this, other_region, "INTERSECTION");
  return *this;
}
 
CSGRegion &
CSGRegion::operator|=(const CSGRegion & other_region)
{
  if (this != &other_region)
    *this = CSGRegion(*this, other_region, "UNION");
  return *this;
}
 
// Operators for region construction
 
// positive halfspace
const CSGRegion
operator+(const CSGSurface & surf)
{
  return CSGRegion(surf, CSGSurface::Halfspace::POSITIVE);
}
 
// negative halfspace
const CSGRegion
operator-(const CSGSurface & surf)
{
  return CSGRegion(surf, CSGSurface::Halfspace::NEGATIVE);
}
 
// intersection
const CSGRegion
operator&(const CSGRegion & region_a, const CSGRegion & region_b)
{
  return CSGRegion(region_a, region_b, "INTERSECTION");
}
 
// union
const CSGRegion
operator|(const CSGRegion & region_a, const CSGRegion & region_b)
{
  return CSGRegion(region_a, region_b, "UNION");
}
 
// complement
const CSGRegion
operator~(const CSGRegion & region)
{
  return CSGRegion(region, "COMPLEMENT");
}
 
bool
CSGRegion::operator==(const CSGRegion & other) const
{
  const bool region_type_eq = this->getRegionType() == other.getRegionType();
  return (region_type_eq && checkRegionEquality(other.getPostfixTokens()));
}
 
bool
CSGRegion::operator!=(const CSGRegion & other) const
{
  return !(*this == other);
}
 
void
CSGRegion::replaceWithSubRegion(const CSGSurface & old_surf, const CSGRegion & sub_region)
{
  // Rebuild _postfix_tokens, substituting each [old_surf_ref][Halfspace] pair with the
  // tokens of sub_region (and a trailing COMPLEMENT for the positive / outside halfspace).
  // This will also update the _surfaces list to remove the old_surf (if present) and append the
  // surfaces from the sub-region if they are used to replace the old_surf here.
  std::vector<PostfixTokenVariant> new_tokens;
 
  for (std::size_t i = 0; i < _postfix_tokens.size(); ++i)
  {
    const auto * ref_ptr =
        std::get_if<std::reference_wrapper<const CSGSurface>>(&_postfix_tokens[i]);
 
    if (ref_ptr && &ref_ptr->get() == &old_surf)
    {
      // encountered the old_surf to be replaced, so replace with the sub_region tokens
 
      // The next token must be the Halfspace that was applied to this surface
      mooseAssert(i + 1 < _postfix_tokens.size() &&
                      std::holds_alternative<CSGSurface::Halfspace>(_postfix_tokens[i + 1]),
                  "Expected a Halfspace token after surface reference in postfix stream");
      const auto & hs = std::get<CSGSurface::Halfspace>(_postfix_tokens[++i]);
 
      // Insert the sub-region's token stream in place of the surface + halfspace pair
      new_tokens.insert(
          new_tokens.end(), sub_region._postfix_tokens.begin(), sub_region._postfix_tokens.end());
 
      // Positive halfspace means "outside" so use complement of sub-region
      if (hs == CSGSurface::Halfspace::POSITIVE)
        new_tokens.push_back(RegionType::COMPLEMENT);
    }
    else
      new_tokens.push_back(_postfix_tokens[i]);
  }
  _postfix_tokens = new_tokens;
 
  // Update _region_type from the last token in the new stream
  if (_postfix_tokens.empty())
    _region_type = "EMPTY";
  else if (const auto * rt = std::get_if<RegionType>(&_postfix_tokens.back()))
    _region_type = regionTypeName(*rt);
  else
  {
    mooseAssert(std::holds_alternative<CSGSurface::Halfspace>(_postfix_tokens.back()),
                "Expected halfspace as last token");
    _region_type = "HALFSPACE";
  }
}
 
} // namespace CSG