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 "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>>
    CSGObjectVariant;

class CSGBase
{
public:
  CSGBase();

  CSGBase(const CSGBase & other_base);

  ~CSGBase();

  std::unique_ptr<CSGBase> clone() const { return std::make_unique<CSGBase>(*this); }

  const CSGSurface & addSurface(std::unique_ptr<CSGSurface> surf)
  {
    return _surface_list.addSurface(std::move(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)
  {
    _surface_list.renameSurface(surface, 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)
  {
    _cell_list.renameCell(cell, 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)
  {
    _universe_list.renameUniverse(_universe_list.getRoot(), name);
  }

  void renameUniverse(const CSGUniverse & universe, const std::string & name)
  {
    _universe_list.renameUniverse(universe, 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); }

  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 applyTranslation(const CSGObjectVariant & csg_object,
                        const std::tuple<Real, Real, Real> & distances)
  {
    addTransformation(csg_object, TransformationType::TRANSLATION, distances);
  }

  void applyRotation(const CSGObjectVariant & csg_object,
                     const std::tuple<Real, Real, Real> & angles)
  {
    addTransformation(csg_object, TransformationType::ROTATION, angles);
  }

  void
  applyAxisRotation(const CSGObjectVariant & csg_object, RotationAxisType axis, const Real angle);

  void applyScaling(const CSGObjectVariant & csg_object,
                    const std::tuple<Real, Real, Real> & values)
  {
    addTransformation(csg_object, TransformationType::SCALE, values);
  }

private:
  CSGSurface & getSurface(const std::string & name) { return _surface_list.getSurface(name); }

  void checkUniverseLinking() const;

  void getLinkedUniverses(const CSGUniverse & univ,
                          std::vector<std::string> & linked_universe_names,
                          std::vector<std::string> & linked_cell_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);

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

  // check that surfaces used in this region are a part of this CSGBase instance
  void checkRegionSurfaces(const CSGRegion & region) const;

  // check that surface being accessed is a part of this CSGBase instance
  bool checkSurfaceInBase(const CSGSurface & surface) const;

  // check that cell being accessed is a part of this CSGBase instance
  bool checkCellInBase(const CSGCell & cell) const;

  // check that universe being accessed is a part of this CSGBase instance
  bool checkUniverseInBase(const CSGUniverse & universe) const;

  // check that lattice being accessed is a part of this CSGBase instance
  bool checkLatticeInBase(const CSGLattice & lattice) const;

  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;

#ifdef MOOSE_UNIT_TEST
  FRIEND_TEST(CSGBaseTest, testCheckRegionSurfaces);
  FRIEND_TEST(CSGBaseTest, testAddGetSurface);
  FRIEND_TEST(CSGBaseTest, testUniverseLinking);
#endif
};
} // namespace CSG