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 "nlohmann/json.h"

#ifdef MOOSE_UNIT_TEST
#include "gtest/gtest.h"
#endif

namespace CSG
{

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

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

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

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

  void renameCell(const CSGCell & cell, const std::string & name)
  {
    _cell_list.renameCell(cell, name);
  }

  void updateCellRegion(const CSGCell & cell, const CSGRegion & region);

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

  void joinOtherBase(std::unique_ptr<CSGBase> base);

  void joinOtherBase(std::unique_ptr<CSGBase> base, std::string & new_root_name_join);

  void joinOtherBase(std::unique_ptr<CSGBase> base,
                     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;

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

  void joinSurfaceList(CSGSurfaceList & surf_list);

  void joinCellList(CSGCellList & cell_list);

  void joinUniverseList(CSGUniverseList & univ_list);

  void joinUniverseList(CSGUniverseList & univ_list, const std::string & new_root_name_incoming);

  void joinUniverseList(CSGUniverseList & univ_list,
                        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 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;

  const CSGCell & addCellToList(const CSGCell & cell);

  const CSGUniverse & addUniverseToList(const CSGUniverse & univ);

  CSGSurfaceList _surface_list;

  CSGCellList _cell_list;

  CSGUniverseList _universe_list;

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