CSGBase.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 "CSGSurfaceList.h"
#include "CSGRegion.h"
#include "CSGCellList.h"
#include "CSGUniverseList.h"
#include "CSGLatticeList.h"
#include "CSGTransformationHelper.h"
#include "CSGEngUnitList.h"
#include "nlohmann/json.h"
 
#ifdef MOOSE_UNIT_TEST
#include "gtest/gtest.h"
#endif
 
namespace CSG
{
 
enum class RotationAxisType
{
  X = 0, // X axis
  Y = 1, // Y axis
  Z = 2  // Z axis
};
 
typedef std::variant<std::reference_wrapper<const CSGSurface>,
                     std::reference_wrapper<const CSGCell>,
                     std::reference_wrapper<const CSGUniverse>,
                     std::reference_wrapper<const CSGRegion>,
                     std::reference_wrapper<const CSGLattice>,
                     std::reference_wrapper<const CSGEngUnit>>
    CSGObjectVariant;
 
class CSGBase
{
public:
  CSGBase();
 
  CSGBase(const CSGBase & other_base);
 
  ~CSGBase();
 
  std::unique_ptr<CSGBase> clone() const;
 
  const CSGSurface & addSurface(std::unique_ptr<CSGSurface> surf);
 
  void deleteSurface(const CSGSurface & surface);
 
  std::vector<std::reference_wrapper<const CSGSurface>> getAllSurfaces() const
  {
    return _surface_list.getAllSurfaces();
  }
 
  const CSGSurface & getSurfaceByName(const std::string & name) const
  {
    return _surface_list.getSurface(name);
  }
 
  bool hasSurface(const std::string & name) const { return _surface_list.hasSurface(name); }
 
  void renameSurface(const CSGSurface & surface, const std::string & name);
 
  const CSGCell & createCell(const std::string & name,
                             const std::string & mat_name,
                             const CSGRegion & region,
                             const CSGUniverse * add_to_univ = nullptr);
 
  const CSGCell & createCell(const std::string & name,
                             const CSGRegion & region,
                             const CSGUniverse * add_to_univ = nullptr);
 
  const CSGCell & createCell(const std::string & name,
                             const CSGUniverse & fill_univ,
                             const CSGRegion & region,
                             const CSGUniverse * add_to_univ = nullptr);
 
  const CSGCell & createCell(const std::string & name,
                             const CSGLattice & fill_lattice,
                             const CSGRegion & region,
                             const CSGUniverse * add_to_univ = nullptr);
 
  void deleteCell(const CSGCell & cell);
 
  std::vector<std::reference_wrapper<const CSGCell>> getAllCells() const
  {
    return _cell_list.getAllCells();
  }
 
  const CSGCell & getCellByName(const std::string & name) const { return _cell_list.getCell(name); }
 
  bool hasCell(const std::string & name) const { return _cell_list.hasCell(name); }
 
  void renameCell(const CSGCell & cell, const std::string & name);
 
  void updateCellRegion(const CSGCell & cell, const CSGRegion & region);
 
  void resetCellFill(const CSGCell & cell);
 
  void updateCellFill(const CSGCell & cell, const std::string & mat_name);
 
  void updateCellFill(const CSGCell & cell, const CSGUniverse * univ);
 
  void updateCellFill(const CSGCell & cell, const CSGLattice * lattice);
 
  const CSGUniverse & getRootUniverse() const { return _universe_list.getRoot(); }
 
  void renameRootUniverse(const std::string & name)
  {
    renameUniverse(_universe_list.getRoot(), name);
  }
 
  void renameUniverse(const CSGUniverse & universe, const std::string & name);
 
  const CSGUniverse & createUniverse(const std::string & name)
  {
    return _universe_list.addUniverse(name);
  }
 
  const CSGUniverse & createUniverse(const std::string & name,
                                     std::vector<std::reference_wrapper<const CSGCell>> & cells);
 
  void deleteUniverse(const CSGUniverse & univ);
 
  void addCellToUniverse(const CSGUniverse & universe, const CSGCell & cell);
 
  void addCellsToUniverse(const CSGUniverse & universe,
                          std::vector<std::reference_wrapper<const CSGCell>> & cells);
 
  void removeCellFromUniverse(const CSGUniverse & universe, const CSGCell & cell);
 
  void removeCellsFromUniverse(const CSGUniverse & universe,
                               std::vector<std::reference_wrapper<const CSGCell>> & cells);
 
  std::vector<std::reference_wrapper<const CSGUniverse>> getAllUniverses() const
  {
    return _universe_list.getAllUniverses();
  }
 
  const CSGUniverse & getUniverseByName(const std::string & name)
  {
    return _universe_list.getUniverse(name);
  }
 
  bool hasUniverse(const std::string & name) const { return _universe_list.hasUniverse(name); }
 
  template <typename LatticeType = CSGLattice>
  const LatticeType & addLattice(std::unique_ptr<LatticeType> lattice)
  {
    static_assert(std::is_base_of_v<CSGLattice, LatticeType>, "Is not a CSGLattice");
    // make sure all universes are a part of this base instance
    auto universes = lattice->getUniverses();
    for (auto univ_list : universes)
      for (const CSGUniverse & univ : univ_list)
        if (!checkUniverseInBase(univ))
          mooseError("Cannot add lattice " + lattice->getName() + " of type " + lattice->getType() +
                     ". Universe " + univ.getName() + " is not in the CSGBase instance.");
 
    if (lattice->getOuterType() == "UNIVERSE")
    {
      const CSGUniverse & outer_univ = lattice->getOuterUniverse();
      if (!checkUniverseInBase(outer_univ))
        mooseError("Cannot add lattice " + lattice->getName() + " of type " + lattice->getType() +
                   ". Outer universe " + outer_univ.getName() + " is not in the CSGBase instance.");
    }
    auto & lat_ref = _lattice_list.addLattice(std::move(lattice));
    return dynamic_cast<LatticeType &>(lat_ref);
  }
 
  void deleteLattice(const CSGLattice & lattice);
 
  void setUniverseAtLatticeIndex(const CSGLattice & lattice,
                                 const CSGUniverse & universe,
                                 std::pair<int, int> index);
 
  void setLatticeUniverses(
      const CSGLattice & lattice,
      std::vector<std::vector<std::reference_wrapper<const CSGUniverse>>> & universes);
 
  void renameLattice(const CSGLattice & lattice, const std::string & name)
  {
    _lattice_list.renameLattice(lattice, name);
  }
 
  void setLatticeOuter(const CSGLattice & lattice, const std::string & outer_name);
 
  void setLatticeOuter(const CSGLattice & lattice, const CSGUniverse & outer_univ);
 
  void resetLatticeOuter(const CSGLattice & lattice);
 
  std::vector<std::reference_wrapper<const CSGLattice>> getAllLattices() const
  {
    return _lattice_list.getAllLattices();
  }
 
  template <typename LatticeType = CSGLattice>
  const LatticeType & getLatticeByName(const std::string & name)
  {
    const CSGLattice & lattice = _lattice_list.getLattice(name);
    const LatticeType * typed_lattice = dynamic_cast<const LatticeType *>(&lattice);
    if (!typed_lattice)
      mooseError("Cannot get lattice " + name + ". Lattice is not of specified type " +
                 MooseUtils::prettyCppType<LatticeType>());
    return *typed_lattice;
  }
 
  bool hasLattice(const std::string & name) const { return _lattice_list.hasLattice(name); }
 
  template <typename T>
  const T & addEngUnit(std::unique_ptr<T> unit, const CSGUniverse * add_to_univ = nullptr)
  {
    static_assert(std::is_base_of_v<CSGEngUnit, T>, "T must derive from CSGEngUnit");
    static_assert(std::is_base_of_v<CSGSurface, T> || std::is_base_of_v<CSGCell, T> ||
                      std::is_base_of_v<CSGUniverse, T>,
                  "T must also derive from CSGSurface, CSGCell, or CSGUniverse");
    // create raw pointer so we can transfer ownership to the proper type list without destroying
    // it, and also can store the pointer in the CSGEngUnitList (non-owning list)
    T * raw = unit.get();
 
    // must check if an engineering unit of the same name (regardless of type) exists already before
    // adding it to any list so that we don't add to a type-list before knowing if it is actually
    // allowable as a unit. The addX checks below will check that the name doesn't conflict with a
    // real type unit too.
    if (_eng_unit_list.hasEngUnit(raw->getName()))
      mooseError(
          "An engineering unit with name '", raw->getName(), "' already exists in geometry.");
 
    // Transfer ownership to the appropriate type list
    if constexpr (std::is_base_of_v<CSGSurface, T>)
      _surface_list.addSurface(std::move(unit));
    else if constexpr (std::is_base_of_v<CSGCell, T>)
    {
      // must add a cell unit to the appropriate universe
      auto & cell = _cell_list.addCell(std::move(unit));
      if (add_to_univ)
        addCellToUniverse(*add_to_univ, cell);
      else
        addCellToUniverse(getRootUniverse(), cell);
    }
    else if constexpr (std::is_base_of_v<CSGUniverse, T>)
      _universe_list.addUniverse(std::move(unit));
 
    // Register non-owning pointer in the CSGEngUnitList if no name conflicts identified above.
    _eng_unit_list.addEngUnit(cast_ref<CSGEngUnit &>(*raw));
    return *raw;
  }
 
  void deleteEngUnit(const CSGEngUnit & unit);
 
  template <typename EngUnitType = CSGEngUnit>
  const EngUnitType & getEngUnitByName(const std::string & name) const
  {
    const CSGEngUnit & unit = _eng_unit_list.getEngUnit(name);
    const EngUnitType * typed_unit = dynamic_cast<const EngUnitType *>(&unit);
    if (!typed_unit)
      mooseError("Cannot get engineering unit " + name +
                 ". Engineering unit is not of specified type " +
                 MooseUtils::prettyCppType<EngUnitType>());
    return *typed_unit;
  }
 
  bool hasEngUnit(const std::string & name) const { return _eng_unit_list.hasEngUnit(name); }
 
  void renameEngUnit(const CSGEngUnit & unit, const std::string & name);
 
  std::vector<std::reference_wrapper<const CSGEngUnit>> getAllEngUnits() const
  {
    return _eng_unit_list.getAllEngUnits();
  }
 
  std::vector<std::reference_wrapper<const CSGSurfaceEngUnit>> getAllSurfaceEngUnits() const
  {
    return _eng_unit_list.getAllSurfaceEngUnits();
  }
 
  std::vector<std::reference_wrapper<const CSGCellEngUnit>> getAllCellEngUnits() const
  {
    return _eng_unit_list.getAllCellEngUnits();
  }
 
  std::vector<std::reference_wrapper<const CSGUniverseEngUnit>> getAllUniverseEngUnits() const
  {
    return _eng_unit_list.getAllUniverseEngUnits();
  }
 
  CSGRegion expandEngUnit(const CSGSurfaceEngUnit & unit);
 
  const CSGCell & expandEngUnit(const CSGCellEngUnit & unit);
 
  const CSGUniverse & expandEngUnit(const CSGUniverseEngUnit & unit);
 
  void expandAllEngUnits();
 
  bool areCSGObjectsLinked() const;
 
  void joinOtherBase(std::unique_ptr<CSGBase> base, const bool ignore_identical_components);
 
  void joinOtherBase(std::unique_ptr<CSGBase> base,
                     const bool ignore_identical_components,
                     const std::string & new_root_name_join);
 
  void joinOtherBase(std::unique_ptr<CSGBase> base,
                     const bool ignore_identical_components,
                     const std::string & new_root_name_base,
                     const std::string & new_root_name_join);
 
  nlohmann::json generateOutput() const;
 
  bool operator==(const CSGBase & other) const;
 
  bool operator!=(const CSGBase & other) const;
 
  void addTransformation(const CSGObjectVariant & csg_object,
                         TransformationType type,
                         const std::tuple<Real, Real, Real> & values);
 
  void addTransformation(const CSGEngUnit & unit,
                         TransformationType type,
                         const std::tuple<Real, Real, Real> & values)
  {
    addTransformation(CSGObjectVariant{std::cref(unit)}, type, values);
  }
 
  void applyTranslation(const CSGObjectVariant & csg_object,
                        const std::tuple<Real, Real, Real> & distances)
  {
    addTransformation(csg_object, TransformationType::TRANSLATION, distances);
  }
 
  void applyTranslation(const CSGEngUnit & unit, const std::tuple<Real, Real, Real> & distances)
  {
    addTransformation(unit, TransformationType::TRANSLATION, distances);
  }
 
  void applyRotation(const CSGObjectVariant & csg_object,
                     const std::tuple<Real, Real, Real> & angles)
  {
    addTransformation(csg_object, TransformationType::ROTATION, angles);
  }
 
  void applyRotation(const CSGEngUnit & unit, const std::tuple<Real, Real, Real> & angles)
  {
    addTransformation(unit, TransformationType::ROTATION, angles);
  }
 
  void
  applyAxisRotation(const CSGObjectVariant & csg_object, RotationAxisType axis, const Real angle);
 
  void applyAxisRotation(const CSGEngUnit & unit, RotationAxisType axis, const Real angle)
  {
    applyAxisRotation(CSGObjectVariant{std::cref(unit)}, axis, angle);
  }
 
  void applyScaling(const CSGObjectVariant & csg_object,
                    const std::tuple<Real, Real, Real> & values)
  {
    addTransformation(csg_object, TransformationType::SCALE, values);
  }
 
  void applyScaling(const CSGEngUnit & unit, const std::tuple<Real, Real, Real> & values)
  {
    addTransformation(unit, TransformationType::SCALE, values);
  }
 
private:
  CSGSurface & getSurface(const std::string & name) { return _surface_list.getSurface(name); }
 
  void expandAllEngUnitsCycle(std::set<std::set<std::string>> & all_type_sets);
 
  void checkUniverseLinking() const;
 
  void getLinkedCSGObjects(const CSGUniverse & univ,
                           std::set<std::string> & linked_universe_names,
                           std::set<std::string> & linked_cell_names,
                           std::set<std::string> & linked_surface_names) const;
 
  const CSGSurfaceList & getSurfaceList() const { return _surface_list; }
 
  CSGSurfaceList & getSurfaceList() { return _surface_list; }
 
  const CSGCellList & getCellList() const { return _cell_list; }
 
  CSGCellList & getCellList() { return _cell_list; }
 
  const CSGUniverseList & getUniverseList() const { return _universe_list; }
 
  CSGUniverseList & getUniverseList() { return _universe_list; }
 
  const CSGLatticeList & getLatticeList() const { return _lattice_list; }
 
  CSGLatticeList & getLatticeList() { return _lattice_list; }
 
  void updateIncomingCSGReferences(CSGBase & incoming_base);
 
  void replaceSurfaceRefsByName(
      std::map<std::string, std::reference_wrapper<const CSGSurface>> & identical_surface_refs,
      CSGBase & base);
 
  void replaceCellRefsByName(
      std::map<std::string, std::reference_wrapper<const CSGCell>> & identical_cell_refs,
      CSGBase & base);
 
  void replaceUniverseRefsByName(
      std::map<std::string, std::reference_wrapper<const CSGUniverse>> & identical_universe_refs,
      CSGBase & base);
 
  void replaceLatticeRefsByName(
      std::map<std::string, std::reference_wrapper<const CSGLattice>> & identical_lattice_refs,
      CSGBase & base);
 
  const CSGEngUnitList & getEngUnitList() const { return _eng_unit_list; }
 
  void joinSurfaceList(CSGSurfaceList & surf_list, const bool ignore_identical_surfaces);
 
  void joinCellList(CSGCellList & cell_list, const bool ignore_identical_cells);
 
  void joinLatticeList(CSGLatticeList & lattice_list, const bool ignore_identical_lattices);
 
  void joinUniverseList(CSGUniverseList & univ_list, const bool ignore_identical_universes);
 
  void joinUniverseList(CSGUniverseList & univ_list,
                        const bool ignore_identical_universes,
                        const std::string & new_root_name_incoming);
 
  void joinUniverseList(CSGUniverseList & univ_list,
                        const bool ignore_identical_universes,
                        const std::string & new_root_name_base,
                        const std::string & new_root_name_incoming);
 
  void rebuildEngUnitList();
 
  void replaceUniverseRefs(const CSGUniverse & old_univ, const CSGUniverse & new_univ);
 
  void replaceCellRefs(const CSGCell & old_cell, const CSGCell & new_cell);
 
  void replaceSurfaceRefsWithRegion(const CSGSurface & old_surf, const CSGRegion & sub_region);
 
  void checkRegionSurfaces(const CSGRegion & region) const;
 
  bool checkSurfaceInBase(const CSGSurface & surface) const;
 
  bool checkCellInBase(const CSGCell & cell) const;
 
  bool checkEngUnitInBase(const CSGEngUnit & unit) const;
 
  bool checkUniverseInBase(const CSGUniverse & universe) const;
 
  bool checkLatticeInBase(const CSGLattice & lattice) const;
 
  void prepareSurfaceDeletion(const CSGSurface & surface) const;
 
  void prepareCellDeletion(const CSGCell & cell);
 
  void prepareUniverseDeletion(const CSGUniverse & universe) const;
 
  const CSGSurfaceEngUnit * surfaceToEngUnit(const CSGSurface & surf) const
  {
    return dynamic_cast<const CSGSurfaceEngUnit *>(&surf);
  }
 
  const CSGCellEngUnit * cellToEngUnit(const CSGCell & cell) const
  {
    return dynamic_cast<const CSGCellEngUnit *>(&cell);
  }
 
  const CSGUniverseEngUnit * universeToEngUnit(const CSGUniverse & univ) const
  {
    return dynamic_cast<const CSGUniverseEngUnit *>(&univ);
  }
 
  const CSGCell & addCellToList(const CSGCell & cell);
 
  const CSGUniverse & addUniverseToList(const CSGUniverse & univ);
 
  const CSGLattice & addLatticeToList(const CSGLattice & lattice);
 
  CSGSurfaceList _surface_list;
 
  CSGCellList _cell_list;
 
  CSGUniverseList _universe_list;
 
  CSGLatticeList _lattice_list;
 
  CSGEngUnitList _eng_unit_list;
 
#ifdef MOOSE_UNIT_TEST
  FRIEND_TEST(CSGBaseTest, testCheckRegionSurfaces);
  FRIEND_TEST(CSGBaseTest, testAddGetSurface);
  FRIEND_TEST(CSGBaseTest, testUniverseLinking);
  FRIEND_TEST(CSGBaseTest, testEngUnitLinking);
  FRIEND_TEST(CSGBaseTest, testCellEngUnitAddErrors);
  FRIEND_TEST(CSGBaseTest, testUnivEngUnitAddErrors);
#endif
};
} // namespace CSG