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

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

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

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

  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