CSGRegion.h

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
 
#pragma once
 
#include "CSGSurface.h"
#include "MooseEnum.h"
 
namespace CSG
{
 
class CSGRegion
{
public:
  enum class RegionType
  {
    EMPTY,
    HALFSPACE,
    COMPLEMENT,
    INTERSECTION,
    UNION
  };
 
  typedef std::variant<std::reference_wrapper<const CSGSurface>, RegionType, CSGSurface::Halfspace>
      PostfixTokenVariant;
 
  static char regionSymbol(const RegionType region_type);
 
  static char halfspaceSymbol(const CSGSurface::Halfspace halfspace);
 
  static std::string regionTypeName(const RegionType region_type);
 
  CSGRegion();
 
  CSGRegion(const CSGSurface & surf, const CSGSurface::Halfspace halfspace);
 
  CSGRegion(const CSGRegion & region_a,
            const CSGRegion & region_b,
            const std::string & region_type);
 
  CSGRegion(const CSGRegion & region, const std::string & region_type);
 
  virtual ~CSGRegion() = default;
 
  nlohmann::json toInfixJSON() const;
 
  std::vector<std::string> toPostfixStringList() const;
 
  std::string postfixTokenToString(const PostfixTokenVariant & token) const;
 
  RegionType getRegionType() const { return _region_type.getEnum<RegionType>(); }
 
  const std::string getRegionTypeString() const { return _region_type; }
 
  std::vector<std::reference_wrapper<const CSGSurface>> getSurfaces() const;
 
  void updateSurfaceReferences(
      std::map<std::string, std::reference_wrapper<const CSGSurface>> & identical_surface_refs);
 
  CSGRegion & operator&=(const CSGRegion & other_region);
 
  CSGRegion & operator|=(const CSGRegion & other_region);
 
  bool operator==(const CSGRegion & other) const;
 
  bool operator!=(const CSGRegion & other) const;
 
protected:
  const std::vector<PostfixTokenVariant> & getPostfixTokens() const { return _postfix_tokens; }
 
  void replaceWithSubRegion(const CSGSurface & old_surf, const CSGRegion & sub_region);
 
  bool nextRegionOpIsIdentical(const RegionType region,
                               const std::size_t postfix_token_index) const;
 
  bool checkRegionEquality(const std::vector<PostfixTokenVariant> & other_tokens) const;
 
  // Only CSGBase should be calling replaceWithSubRegion()
  friend class CSGBase;
 
  MooseEnum _region_type{"EMPTY=0 HALFSPACE=1 COMPLEMENT=2 INTERSECTION=3 UNION=4"};
 
  std::vector<PostfixTokenVariant> _postfix_tokens;
};
 
 
const CSGRegion operator+(const CSGSurface & surf);
 
const CSGRegion operator-(const CSGSurface & surf);
 
const CSGRegion operator&(const CSGRegion & region_a, const CSGRegion & region_b);
 
const CSGRegion operator|(const CSGRegion & region_a, const CSGRegion & region_b);
 
const CSGRegion operator~(const CSGRegion & region);
 
} // namespace CSG