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 class	RegionType {   EMPTY , HALFSPACE , COMPLEMENT , INTERSECTION ,   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.

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

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

Protected Member Functions
const std::vector< PostfixTokenVariant > &	getPostfixTokens () const
	Get the list of postfix tokens associated with the region.
void	replaceWithSubRegion (const CSGSurface &old_surf, const CSGRegion &sub_region)
	Replace all occurrences of old_surf in this region's postfix token stream with the tokens of sub_region.
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.
bool	checkRegionEquality (const std::vector< PostfixTokenVariant > &other_tokens) const
	Loop through postfix tokens and check equality with another list of postfix tokens.

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.
std::vector< PostfixTokenVariant >	_postfix_tokens
	List of tokens representing the region in postfix notation.

Friends
class	CSGBase

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 class 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 113 of file CSGRegion.C.

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

Referenced by operator&=(), and operator|=().

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 120 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 130 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 153 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.

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

Referenced by operator==().

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 166 of file CSGRegion.h.

{ return _postfix_tokens; }

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

getRegionType()

RegionType CSG::CSGRegion::getRegionType ( ) const

inline

Get the region type.

Returns

region type enum

Definition at line 123 of file CSGRegion.h.

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

Referenced by CSGRegion(), CSGRegion(), CSG::CSGNPolygonUnit::expandUnit(), CSG::CSGSurfaceEngUnit::getExpandedRegion(), CSGUtils::getInnerRegion(), operator==(), and CSG::CSGBase::replaceSurfaceRefsWithRegion().

getRegionTypeString()

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

inline

Get the region type as a string.

Returns

region type string

Definition at line 130 of file CSGRegion.h.

{ return _region_type; }

Referenced by CSGRegion(), and CSGRegion().

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 289 of file CSGRegion.C.

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

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

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.

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

Referenced by postfixTokenToString(), and toInfixJSON().

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 265 of file CSGRegion.C.

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

Referenced by toInfixJSON().

operator!=()

bool CSG::CSGRegion::operator!=

(

const CSGRegion &

other

)

const

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

Definition at line 360 of file CSGRegion.C.

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

operator&=()

CSGRegion & CSG::CSGRegion::operator&=

(

const CSGRegion &

other_region

)

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

Definition at line 300 of file CSGRegion.C.

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

operator==()

bool CSG::CSGRegion::operator==

(

const CSGRegion &

other

)

const

Operator overload for checking if two CSGRegion objects are equal.

Definition at line 353 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 308 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 247 of file CSGRegion.C.

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

Referenced by checkRegionEquality(), and toPostfixStringList().

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.

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

Referenced by postfixTokenToString(), and toInfixJSON().

regionTypeName()

std::string CSG::CSGRegion::regionTypeName ( const RegionType  region_type )

static

Returns

The string associated with the given region type

Definition at line 91 of file CSGRegion.C.

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

Referenced by replaceWithSubRegion().

replaceWithSubRegion()

void CSG::CSGRegion::replaceWithSubRegion ( const CSGSurface &  old_surf, const CSGRegion &  sub_region  )

protected

Replace all occurrences of old_surf in this region's postfix token stream with the tokens of sub_region.

Each [old_surf_ref][Halfspace] pair in _postfix_tokens is replaced by sub_region's tokens (for NEGATIVE halfspace) or sub_region's tokens followed by a COMPLEMENT token (for POSITIVE halfspace). The flat _surfaces list is rebuilt from the updated token stream.

Called exclusively by CSGBase::replaceSurfaceRefsWithRegion().

Parameters

old_surf	surface to replace
sub_region	region to substitute (represents the old surface's "negative" interior)

Definition at line 366 of file CSGRegion.C.

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

Referenced by CSG::CSGBase::replaceSurfaceRefsWithRegion().

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 170 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 237 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 275 of file CSGRegion.C.

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

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

Friends And Related Symbol Documentation

CSGBase

friend class CSGBase

friend

Definition at line 204 of file CSGRegion.h.

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 210 of file CSGRegion.h.

Referenced by CSGRegion(), CSGRegion(), CSGRegion(), CSGRegion(), getPostfixTokens(), getSurfaces(), nextRegionOpIsIdentical(), replaceWithSubRegion(), 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 207 of file CSGRegion.h.

{"EMPTY=0 HALFSPACE=1 COMPLEMENT=2 INTERSECTION=3 UNION=4"};

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

---

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

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