CSGLattice.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 "CSGUniverse.h"
#include "CSGTransformationHelper.h"
#include "JsonIO.h"
#include <variant>
#include <optional>
 
#ifdef MOOSE_UNIT_TEST
#include "gtest/gtest.h"
#endif
 
namespace CSG
{
 
typedef std::variant<std::reference_wrapper<const CSGUniverse>, std::string> OuterVariant;
 
class CSGLattice : public CSGTransformationHelper
{
public:
  CSGLattice(const std::string & name, const std::optional<OuterVariant> & outer = std::nullopt);
 
  virtual ~CSGLattice() = default;
 
  // Pure virtual clone method that derived classes must implement
  virtual std::unique_ptr<CSGLattice> clone() const = 0;
 
  const std::string & getName() const { return _name; }
 
  const std::string getType() const
  {
    return MooseUtils::prettyCppType(libMesh::demangle(typeid(*this).name()));
  }
 
  const std::string getOuterType() const { return _outer_type; }
 
  const CSGUniverse & getOuterUniverse() const;
 
  const std::string & getOuterMaterial() const;
 
  std::vector<std::vector<std::reference_wrapper<const CSGUniverse>>> getUniverses() const
  {
    return _universe_map;
  }
 
  const std::vector<std::vector<std::string>> getUniverseNameMap() const;
 
  bool hasUniverse(const std::string & name) const;
 
  virtual std::unordered_map<std::string, AttributeVariant>
  getAttributes() const = 0; // pure virtual function
 
  virtual bool isValidIndex(const std::pair<int, int> index) const = 0; // Pure virtual function
 
  const CSGUniverse & getUniverseAtIndex(const std::pair<int, int> index);
 
  const std::vector<std::pair<unsigned int, unsigned int>>
  getUniverseIndices(const std::string & univ_name) const;
 
  virtual bool
  isValidUniverseMap(std::vector<std::vector<std::reference_wrapper<const CSGUniverse>>> universes)
      const = 0; // pure virtual function
 
  void resetOuter();
 
  const std::vector<std::reference_wrapper<const CSGUniverse>> getUniqueUniverses() const;
 
  bool operator==(const CSGLattice & other) const;
 
  bool operator!=(const CSGLattice & other) const;
 
protected:
  // set the name of the lattices - intentionally not public because
  // name needs to be managed at the CSGLatticeList level
  void setName(const std::string & name) { _name = name; }
 
  virtual void
  setUniverses(std::vector<std::vector<std::reference_wrapper<const CSGUniverse>>> universes) = 0;
 
  void setUniverseAtIndex(const CSGUniverse & universe, const std::pair<int, int> index);
 
  virtual bool compareAttributes(const CSGLattice & other) const = 0; // pure virtual
 
  void updateOuter(const std::string & outer_name);
 
  void updateOuter(const CSGUniverse & outer_universe);
 
  std::string _name;
 
  std::vector<std::vector<std::reference_wrapper<const CSGUniverse>>> _universe_map;
 
  mutable std::string _outer_type;
 
  mutable std::string _outer_material;
 
  const CSGUniverse * _outer_universe;
 
  // CSGLatticeList needs to be friend to access setName()
  friend class CSGLatticeList;
  // CSGBase needed for access updateAttributes()
  friend class CSGBase;
 
#ifdef MOOSE_UNIT_TEST
  FRIEND_TEST(CSGLatticeTest, testSetName);
  FRIEND_TEST(CSGLatticeTest, testUpdateOuter);
  FRIEND_TEST(CSGBaseTest, testAddLattice);
  FRIEND_TEST(CSGLatticeTest, testCartLatticeEquality);
#endif
};
}