CSG::CSGRegion Class Reference

CSGRegions creates an internal representation of a CSG region, which can refer to an intersection, union, complement, or half-space. More...

#include <CSGRegion.h>

Public Types
enum	RegionType {   RegionType::EMPTY, RegionType::HALFSPACE, RegionType::COMPLEMENT, RegionType::INTERSECTION,   RegionType::UNION }
	Enum for representing region types, defined to match _region_type MooseEnum. More...
typedef std::variant< std::reference_wrapper< const CSGSurface >, RegionType, CSGSurface::Halfspace >	PostfixTokenVariant
	Type definition for a variant that represents the datatypes for entries within the list that represents the region in postfix notation. More...

Public Member Functions
	CSGRegion ()
	Default Constructor. More...
	CSGRegion (const CSGSurface &surf, const CSGSurface::Halfspace halfspace)
	Constructor for half-space of a surface. More...
	CSGRegion (const CSGRegion &region_a, const CSGRegion &region_b, const std::string &region_type)
	Constructor for union and intersection. More...
	CSGRegion (const CSGRegion &region, const std::string &region_type)
	Constructor for complement or empty region (clear the region) More...
virtual	~CSGRegion ()=default
	Destructor. More...
nlohmann::json	toInfixJSON () const
	gets the infix JSON representation of the region, which involves converting region representation from postfix to infix notation More...
std::vector< std::string >	toPostfixStringList () const
	gets the list of postfix tokens of the region in string representation More...
std::string	postfixTokenToString (const PostfixTokenVariant &token) const
	converts postfix token from PostfixTokenVariant to string representation More...
RegionType	getRegionType () const
	Get the region type. More...
const std::string	getRegionTypeString () const
	Get the region type as a string. More...
std::vector< std::reference_wrapper< const CSGSurface > >	getSurfaces () const
	Get the list of surfaces associated with the region. More...
void	updateSurfaceReferences (std::map< std::string, std::reference_wrapper< const CSGSurface >> &identical_surface_refs)
	Update surface references of region based on map of input surface references. More...
CSGRegion &	operator &= (const CSGRegion &other_region)
	Operator overload for &= which creates an intersection between the current region and the other_region. More...
CSGRegion &	operator|= (const CSGRegion &other_region)
	Operator overload for |= which creates a union of the current region with the other_region. More...
bool	operator== (const CSGRegion &other) const
	Operator overload for checking if two CSGRegion objects are equal. More...
bool	operator!= (const CSGRegion &other) const
	Operator overload for checking if two CSGRegion objects are not equal. More...

Static Public Member Functions
static char	regionSymbol (const RegionType region_type)
static char	halfspaceSymbol (const CSGSurface::Halfspace halfspace)

Protected Member Functions
const std::vector< PostfixTokenVariant > &	getPostfixTokens () const
	Get the list of postfix tokens associated with the region. More...
bool	nextRegionOpIsIdentical (const RegionType region, const std::size_t postfix_token_index) const
	Iterate through postfix tokens and check if next region operator matches the given operator. More...
bool	checkRegionEquality (const std::vector< PostfixTokenVariant > &other_tokens) const
	Loop through postfix tokens and check equality with another list of postfix tokens. More...

Protected Attributes
MooseEnum	_region_type {"EMPTY=0 HALFSPACE=1 COMPLEMENT=2 INTERSECTION=3 UNION=4"}
	An enum for type of type of operation that defines region. More...
std::vector< PostfixTokenVariant >	_postfix_tokens
	List of tokens representing the region in postfix notation. More...

Detailed Description

CSGRegions creates an internal representation of a CSG region, which can refer to an intersection, union, complement, or half-space.

Definition at line 22 of file CSGRegion.h.

Member Typedef Documentation

PostfixTokenVariant

typedef std::variant<std::reference_wrapper<const CSGSurface>, RegionType, CSGSurface::Halfspace> CSG::CSGRegion::PostfixTokenVariant

Type definition for a variant that represents the datatypes for entries within the list that represents the region in postfix notation.

This can be a surface reference, a region type, or halfspace

Definition at line 41 of file CSGRegion.h.

Member Enumeration Documentation

RegionType

enum CSG::CSGRegion::RegionType

strong

Enum for representing region types, defined to match _region_type MooseEnum.

Enumerator
EMPTY
HALFSPACE
COMPLEMENT
INTERSECTION
UNION

Definition at line 26 of file CSGRegion.h.

  {
    EMPTY,
    HALFSPACE,
    COMPLEMENT,
    INTERSECTION,
    UNION
  };

Constructor & Destructor Documentation

CSGRegion() [1/4]

CSG::CSGRegion::CSGRegion

(

)

Default Constructor.

Definition at line 90 of file CSGRegion.C.

Referenced by operator|=().

{
  _region_type = "EMPTY";
  _postfix_tokens.clear();
}

CSGRegion() [2/4]

CSG::CSGRegion::CSGRegion	(	const CSGSurface &	surf,
		const CSGSurface::Halfspace	halfspace
	)

Constructor for half-space of a surface.

Parameters

surf	referance to surface used to define the half-space
halfspace	half-space to apply to surface (POSITIVE or NEGATIVE)

Definition at line 97 of file CSGRegion.C.

{
  _region_type = "HALFSPACE";

  // (halfspace surf) in postfix is represented as (surf halfspace)
  _postfix_tokens.push_back(surf);
  _postfix_tokens.push_back(halfspace);
}

CSGRegion() [3/4]

CSG::CSGRegion::CSGRegion	(	const CSGRegion &	region_a,
		const CSGRegion &	region_b,
		const std::string &	region_type
	)

Constructor for union and intersection.

Parameters

region_a	reference to first region to union or intersect
region_b	reference to second region to union or intersect
region_type	type of region operation (UNION or INTERSECTION)

Definition at line 107 of file CSGRegion.C.

{
  _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());
}

CSGRegion() [4/4]

CSG::CSGRegion::CSGRegion	(	const CSGRegion &	region,
		const std::string &	region_type
	)

Constructor for complement or empty region (clear the region)

Parameters

region	reference to region to apply complement
region_type	type of region to apply (COMPLEMENT or EMPTY)

Definition at line 130 of file CSGRegion.C.

{
  _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();
}

~CSGRegion()

virtual CSG::CSGRegion::~CSGRegion ( )

virtualdefault

Destructor.

Member Function Documentation

checkRegionEquality()

bool CSG::CSGRegion::checkRegionEquality ( const std::vector< PostfixTokenVariant > &  other_tokens ) const

protected

Loop through postfix tokens and check equality with another list of postfix tokens.

Parameters

other_tokens

list of postfix tokens to compare to

Returns

true if postfix token lists are equal, false otherwise

Definition at line 54 of file CSGRegion.C.

Referenced by operator==().

{
  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;
}

getPostfixTokens()

const std::vector<PostfixTokenVariant>& CSG::CSGRegion::getPostfixTokens ( ) const

inlineprotected

Get the list of postfix tokens associated with the region.

Returns

list of tokens that define the region in postfix notation

Definition at line 160 of file CSGRegion.h.

Referenced by checkRegionEquality(), CSGRegion(), and operator==().

{ return _postfix_tokens; }

getRegionType()

RegionType CSG::CSGRegion::getRegionType ( ) const

inline

Get the region type.

Returns

region type enum

Definition at line 117 of file CSGRegion.h.

Referenced by CSGRegion(), CSGUtils::getInnerRegion(), and operator==().

{ return _region_type.getEnum<RegionType>(); }

getRegionTypeString()

const std::string CSG::CSGRegion::getRegionTypeString ( ) const

inline

Get the region type as a string.

Returns

region type string

Definition at line 124 of file CSGRegion.h.

Referenced by CSGRegion().

{ return _region_type; }

getSurfaces()

std::vector< std::reference_wrapper< const CSGSurface > > CSG::CSGRegion::getSurfaces

(

)

const

Get the list of surfaces associated with the region.

Returns

list of references to surfaces that define the region

Definition at line 266 of file CSGRegion.C.

Referenced by CSG::CSGBase::addTransformation(), and CSG::CSGBase::checkRegionSurfaces().

{
  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;
}

halfspaceSymbol()

char CSG::CSGRegion::halfspaceSymbol ( const CSGSurface::Halfspace  halfspace )

static

Returns

The symbol associated with the given halfspace

Definition at line 37 of file CSGRegion.C.

Referenced by postfixTokenToString(), and toInfixJSON().

{
  mooseAssert(halfspace == CSGSurface::Halfspace::POSITIVE ||
                  halfspace == CSGSurface::Halfspace::NEGATIVE,
              "Unexpected halfspace");

  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)];
}

nextRegionOpIsIdentical()

bool CSG::CSGRegion::nextRegionOpIsIdentical ( const RegionType  region, const std::size_t  postfix_token_index  ) const

protected

Iterate through postfix tokens and check if next region operator matches the given operator.

Parameters

region	the region type
postfix_token_index	index in _postfix_tokens to start region operator comparisons

Returns

true if next region operator in _postfix_tokens matches region_op_string, false otherwise

Definition at line 242 of file CSGRegion.C.

Referenced by toInfixJSON().

{
  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;
}

operator &=()

CSGRegion& CSG::CSGRegion::operator&=

(

const CSGRegion &

other_region

)

Operator overload for &= which creates an intersection between the current region and the other_region.

operator!=()

bool CSG::CSGRegion::operator!=

(

const CSGRegion &

other

)

const

Operator overload for checking if two CSGRegion objects are not equal.

Definition at line 337 of file CSGRegion.C.

{
  return !(*this == other);
}

operator==()

bool CSG::CSGRegion::operator==

(

const CSGRegion &

other

)

const

Operator overload for checking if two CSGRegion objects are equal.

Definition at line 330 of file CSGRegion.C.

{
  const bool region_type_eq = this->getRegionType() == other.getRegionType();
  return (region_type_eq && checkRegionEquality(other.getPostfixTokens()));
}

operator|=()

CSGRegion & CSG::CSGRegion::operator|=

(

const CSGRegion &

other_region

)

Operator overload for |= which creates a union of the current region with the other_region.

Definition at line 285 of file CSGRegion.C.

{
  if (this != &other_region)
    *this = CSGRegion(*this, other_region, "UNION");
  return *this;
}

postfixTokenToString()

std::string CSG::CSGRegion::postfixTokenToString

(

const PostfixTokenVariant &

token

)

const

converts postfix token from PostfixTokenVariant to string representation

Parameters

token

postfix token of type PostfixTokenVariant

Returns

string representation of postfix token

Definition at line 224 of file CSGRegion.C.

Referenced by checkRegionEquality(), and toPostfixStringList().

{
  // 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);
}

regionSymbol()

char CSG::CSGRegion::regionSymbol ( const RegionType  region_type )

static

Returns

The symbol associated with the given region type

Definition at line 16 of file CSGRegion.C.

Referenced by postfixTokenToString(), and toInfixJSON().

{
  mooseAssert(region_type == RegionType::COMPLEMENT || region_type == RegionType::UNION ||
                  region_type == RegionType::INTERSECTION,
              "Unexpected region type");

  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)];
}

toInfixJSON()

nlohmann::json CSG::CSGRegion::toInfixJSON

(

)

const

gets the infix JSON representation of the region, which involves converting region representation from postfix to infix notation

Returns

infix JSON representation of the region

Definition at line 147 of file CSGRegion.C.

{
  // 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);
}

toPostfixStringList()

std::vector< std::string > CSG::CSGRegion::toPostfixStringList

(

)

const

gets the list of postfix tokens of the region in string representation

Returns

list of postfix tokens that represent the region

Definition at line 214 of file CSGRegion.C.

{
  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;
}

updateSurfaceReferences()

void CSG::CSGRegion::updateSurfaceReferences

(

std::map< std::string, std::reference_wrapper< const CSGSurface >> &

identical_surface_refs

)

Update surface references of region based on map of input surface references.

Parameters

identical_surface_refs

map of surface name to surface references that region should be defined with

Definition at line 252 of file CSGRegion.C.

Referenced by CSG::CSGCell::updateCellRegionSurfaces().

{
  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);
    }
}

Member Data Documentation

_postfix_tokens

std::vector<PostfixTokenVariant> CSG::CSGRegion::_postfix_tokens

protected

List of tokens representing the region in postfix notation.

Definition at line 186 of file CSGRegion.h.

Referenced by CSGRegion(), getPostfixTokens(), getSurfaces(), nextRegionOpIsIdentical(), toInfixJSON(), toPostfixStringList(), and updateSurfaceReferences().

_region_type

MooseEnum CSG::CSGRegion::_region_type {"EMPTY=0 HALFSPACE=1 COMPLEMENT=2 INTERSECTION=3 UNION=4"}

protected

An enum for type of type of operation that defines region.

Definition at line 183 of file CSGRegion.h.

Referenced by CSGRegion(), getRegionType(), and getRegionTypeString().

---

The documentation for this class was generated from the following files:

• include/csg/CSGRegion.h
• src/csg/CSGRegion.C