21489819490

Committed 29 Jan 2026 06:21PM UTC coverage: 80.077% (-1.9%) from 81.953%

Build # 21489819490

Build Type

Pull #3757

github

Committed by

web-flow

Commit Message

Merge d08626053 into f7a734189

Pull Request Pull Request #3757: Testing point detectors

Run Details

16004 of 22621 branches covered (70.75%)

Branch coverage included in aggregate %.

94 of 518 new or added lines in 26 files covered. (18.15%)

1021 existing lines in 52 files now uncovered.

53779 of 64524 relevant lines covered (83.35%)

8016833.26 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.84

/include/openmc/cell.h

#ifndef OPENMC_CELL_H
#define OPENMC_CELL_H

#include <cstdint>
#include <functional> // for hash
#include <limits>
#include <string>
#include <unordered_map>
#include <unordered_set>

#include "hdf5.h"
#include "pugixml.hpp"

#include "openmc/bounding_box.h"
#include "openmc/constants.h"
#include "openmc/memory.h" // for unique_ptr
#include "openmc/neighbor_list.h"
#include "openmc/position.h"
#include "openmc/surface.h"
#include "openmc/universe.h"
#include "openmc/vector.h"

namespace openmc {

//==============================================================================
// Constants
//==============================================================================

enum class Fill { MATERIAL, UNIVERSE, LATTICE };

constexpr int32_t OP_LEFT_PAREN {std::numeric_limits<int32_t>::max()};
constexpr int32_t OP_RIGHT_PAREN {std::numeric_limits<int32_t>::max() - 1};
constexpr int32_t OP_COMPLEMENT {std::numeric_limits<int32_t>::max() - 2};
constexpr int32_t OP_INTERSECTION {std::numeric_limits<int32_t>::max() - 3};
constexpr int32_t OP_UNION {std::numeric_limits<int32_t>::max() - 4};

//==============================================================================
// Global variables
//==============================================================================

class Cell;
class GeometryState;
class ParentCell;
class CellInstance;
class Universe;
class UniversePartitioner;

namespace model {
extern std::unordered_map<int32_t, int32_t> cell_map;
extern vector<unique_ptr<Cell>> cells;

} // namespace model

//==============================================================================

class Region {
public:
  //----------------------------------------------------------------------------
  // Constructors
  Region() {}
  explicit Region(std::string region_spec, int32_t cell_id);

  //----------------------------------------------------------------------------
  // Methods

  //! \brief Determine if a cell contains the particle at a given location.
  //!
  //! The bounds of the cell are determined by a logical expression involving
  //! surface half-spaces. The expression used is given in infix notation
  //!
  //! The function is split into two cases, one for simple cells (those
  //! involving only the intersection of half-spaces) and one for complex cells.
  //! Both cases use short circuiting; however, in the case fo complex cells,
  //! the complexity increases with the binary operators involved.
  //! \param r The 3D Cartesian coordinate to check.
  //! \param u A direction used to "break ties" the coordinates are very
  //!   close to a surface.
  //! \param on_surface The signed index of a surface that the coordinate is
  //!   known to be on.  This index takes precedence over surface sense
  //!   calculations.
  bool contains(Position r, Direction u, int32_t on_surface) const;

  //! Find the oncoming boundary of this cell.
  std::pair<double, int32_t> distance(
    Position r, Direction u, int32_t on_surface) const;

  //! Get the BoundingBox for this cell.
  BoundingBox bounding_box(int32_t cell_id) const;

  //! Get the CSG expression as a string
  std::string str() const;

  //! Get a vector containing all the surfaces in the region expression
  vector<int32_t> surfaces() const;

  //----------------------------------------------------------------------------
  // Accessors

  //! Get Boolean of if the cell is simple or not
  bool is_simple() const { return simple_; }

private:
  //----------------------------------------------------------------------------
  // Private Methods

  //! Get a vector of the region expression in postfix notation
  vector<int32_t> generate_postfix(int32_t cell_id) const;

  //! Determine if a particle is inside the cell for a simple cell (only
  //! intersection operators)
  bool contains_simple(Position r, Direction u, int32_t on_surface) const;

  //! Determine if a particle is inside the cell for a complex cell.
  //!
  //! Uses the comobination of half-spaces and binary operators to determine
  //! if short circuiting can be used. Short cicuiting uses the relative and
  //! absolute depth of parentheses in the expression.
  bool contains_complex(Position r, Direction u, int32_t on_surface) const;

  //! BoundingBox if the paritcle is in a simple cell.
  BoundingBox bounding_box_simple() const;

  //! BoundingBox if the particle is in a complex cell.
  BoundingBox bounding_box_complex(vector<int32_t> postfix) const;

  //! Enforce precedence between intersections and unions
  void enforce_precedence();

  //! Add parenthesis to enforce precedence
  void add_parentheses(int64_t start);

  //! Remove complement operators from the expression
  void remove_complement_ops();

  //! Remove complement operators by using DeMorgan's laws
  void apply_demorgan(
    vector<int32_t>::iterator start, vector<int32_t>::iterator stop);

  //----------------------------------------------------------------------------
  // Private Data

  //! Definition of spatial region as Boolean expression of half-spaces
  // TODO: Should this be a vector of some other type
  vector<int32_t> expression_;
  bool simple_; //!< Does the region contain only intersections?
};

//==============================================================================

class Cell {
public:
  //----------------------------------------------------------------------------
  // Constructors, destructors, factory functions

  explicit Cell(pugi::xml_node cell_node);
  Cell() {};
  virtual ~Cell() = default;

  //----------------------------------------------------------------------------
  // Methods

  //! \brief Determine if a cell contains the particle at a given location.
  //!
  //! The bounds of the cell are detemined by a logical expression involving
  //! surface half-spaces. At initialization, the expression was converted
  //! to RPN notation.
  //!
  //! The function is split into two cases, one for simple cells (those
  //! involving only the intersection of half-spaces) and one for complex cells.
  //! Simple cells can be evaluated with short circuit evaluation, i.e., as soon
  //! as we know that one half-space is not satisfied, we can exit. This
  //! provides a performance benefit for the common case. In
  //! contains_complex, we evaluate the RPN expression using a stack, similar to
  //! how a RPN calculator would work.
  //! \param r The 3D Cartesian coordinate to check.
  //! \param u A direction used to "break ties" the coordinates are very
  //!   close to a surface.
  //! \param on_surface The signed index of a surface that the coordinate is
  //!   known to be on.  This index takes precedence over surface sense
  //!   calculations.
  virtual bool contains(Position r, Direction u, int32_t on_surface) const = 0;

  //! Find the oncoming boundary of this cell.
  virtual std::pair<double, int32_t> distance(
    Position r, Direction u, int32_t on_surface, GeometryState* p) const = 0;

  //! Write all information needed to reconstruct the cell to an HDF5 group.
  //! \param group_id An HDF5 group id.
  void to_hdf5(hid_t group_id) const;

  virtual void to_hdf5_inner(hid_t group_id) const = 0;

  //! Export physical properties to HDF5
  //! \param[in] group  HDF5 group to read from
  void export_properties_hdf5(hid_t group) const;

  //! Import physical properties from HDF5
  //! \param[in] group  HDF5 group to write to
  void import_properties_hdf5(hid_t group);

  //! Get the BoundingBox for this cell.
  virtual BoundingBox bounding_box() const = 0;

  //! Get a vector of surfaces in the cell
  virtual vector<int32_t> surfaces() const { return vector<int32_t>(); }

  //! Check if the cell region expression is simple
  virtual bool is_simple() const { return true; }

  //----------------------------------------------------------------------------
  // Accessors

  //! Get the temperature of a cell instance
  //! \param[in] instance Instance index. If -1 is given, the temperature for
  //!   the first instance is returned.
  //! \return Temperature in [K]
  double temperature(int32_t instance = -1) const;

  //! Get the density multiplier of a cell instance
  //! \param[in] instance Instance index. If -1 is given, the density multiplier
  //! for the first instance is returned.
  //! \return Density multiplier
  double density_mult(int32_t instance = -1) const;

  //! Get the density of a cell instance in g/cm3
  //! \param[in] instance Instance index. If -1 is given, the density
  //! for the first instance is returned.
  //! \return Density in [g/cm3]
  double density(int32_t instance = -1) const;

  //! Set the temperature of a cell instance
  //! \param[in] T Temperature in [K]
  //! \param[in] instance Instance index. If -1 is given, the temperature for
  //!   all instances is set.
  //! \param[in] set_contained If this cell is not filled with a material,
  //!   collect all contained cells with material fills and set their
  //!   temperatures.
  void set_temperature(
    double T, int32_t instance = -1, bool set_contained = false);

  //! Set the density of a cell instance
  //! \param[in] density Density [g/cm3]
  //! \param[in] instance Instance index. If -1 is given, the density
  //!   for all instances is set.
  //! \param[in] set_contained If this cell is not filled with a material,
  //!   collect all contained cells with material fills and set their
  //!   densities.
  void set_density(
    double density, int32_t instance = -1, bool set_contained = false);

  int32_t n_instances() const;

  //! Set the rotation matrix of a cell instance
  //! \param[in] rot The rotation matrix of length 3 or 9
  void set_rotation(const vector<double>& rot);

  //! Get the name of a cell
  //! \return Cell name
  const std::string& name() const { return name_; };

  //! Set the temperature of a cell instance
  //! \param[in] name Cell name
  void set_name(const std::string& name) { name_ = name; };

  //! Get all cell instances contained by this cell
  //! \param[in] instance Instance of the cell for which to get contained cells
  //! (default instance is zero)
  //! \param[in] hint positional hint for determining the parent cells
  //! \return Map with cell indexes as keys and
  //! instances as values
  std::unordered_map<int32_t, vector<int32_t>> get_contained_cells(
    int32_t instance = 0, Position* hint = nullptr) const;

  //! Determine the material index corresponding to a specific cell instance,
  //! taking into account presence of distribcell material
  //! \param[in] instance of the cell
  //! \return material index
  int32_t material(int32_t instance) const
  {
    // If distributed materials are used, then each instance has its own
    // material definition. If distributed materials are not used, then
    // all instances used the same material stored at material_[0]. The
    // presence of distributed materials is inferred from the size of
    // the material_ vector being greater than one.
    if (material_.size() > 1) {
      return material_[instance];
    } else {
      return material_[0];
    }
  }

  //! Determine the temperature index corresponding to a specific cell instance,
  //! taking into account presence of distribcell temperature
  //! \param[in] instance of the cell
  //! \return temperature index
  double sqrtkT(int32_t instance) const
  {
    // If distributed materials are used, then each instance has its own
    // temperature definition. If distributed materials are not used, then
    // all instances used the same temperature stored at sqrtkT_[0]. The
    // presence of distributed materials is inferred from the size of
    // the sqrtkT_ vector being greater than one.
    if (sqrtkT_.size() > 1) {
      return sqrtkT_[instance];
    } else {
      return sqrtkT_[0];
    }
  }

protected:
  //! Determine the path to this cell instance in the geometry hierarchy
  //! \param[in] instance of the cell to find parent cells for
  //! \param[in] r position used to do a fast search for parent cells
  //! \return parent cells
  vector<ParentCell> find_parent_cells(
    int32_t instance, const Position& r) const;

  //! Determine the path to this cell instance in the geometry hierarchy
  //! \param[in] instance of the cell to find parent cells for
  //! \param[in] p particle used to do a fast search for parent cells
  //! \return parent cells
  vector<ParentCell> find_parent_cells(
    int32_t instance, GeometryState& p) const;

  //! Determine the path to this cell instance in the geometry hierarchy
  //! \param[in] instance of the cell to find parent cells for
  //! \return parent cells
  vector<ParentCell> exhaustive_find_parent_cells(int32_t instance) const;

  //! Inner function for retrieving contained cells
  void get_contained_cells_inner(
    std::unordered_map<int32_t, vector<int32_t>>& contained_cells,
    vector<ParentCell>& parent_cells) const;

public:
  //----------------------------------------------------------------------------
  // Data members

  int32_t id_;       //!< Unique ID
  std::string name_; //!< User-defined name
  Fill type_;        //!< Material, universe, or lattice
  int32_t universe_; //!< Universe # this cell is in
  int32_t fill_;     //!< Universe # filling this cell

  //! \brief Index corresponding to this cell in distribcell arrays
  int distribcell_index_ {C_NONE};

  //! \brief Material(s) within this cell.
  //!
  //! May be multiple materials for distribcell.
  vector<int32_t> material_;

  //! \brief Temperature(s) within this cell.
  //!
  //! The stored values are actually sqrt(k_Boltzmann * T) for each temperature
  //! T. The units are sqrt(eV).
  vector<double> sqrtkT_;

  //! \brief Unitless density multiplier(s) within this cell.
  vector<double> density_mult_;

  //! \brief Neighboring cells in the same universe.
  NeighborList neighbors_;

  Position translation_ {0, 0, 0}; //!< Translation vector for filled universe

  //! \brief Rotational tranfsormation of the filled universe.
  //
  //! The vector is empty if there is no rotation. Otherwise, the first 9 values
  //! give the rotation matrix in row-major order. When the user specifies
  //! rotation angles about the x-, y- and z- axes in degrees, these values are
  //! also present at the end of the vector, making it of length 12.
  vector<double> rotation_;

  vector<int32_t> offset_; //!< Distribcell offset table

  // Right now, either CSG or DAGMC cells are used.
  virtual GeometryType geom_type() const = 0;
};

struct CellInstanceItem {
  int32_t index {-1};    //! Index into global cells array
  int lattice_indx {-1}; //! Flat index value of the lattice cell
};

//==============================================================================

class CSGCell : public Cell {
public:
  //----------------------------------------------------------------------------
  // Constructors
  CSGCell() = default;
  explicit CSGCell(pugi::xml_node cell_node);

  //----------------------------------------------------------------------------
  // Methods
  vector<int32_t> surfaces() const override { return region_.surfaces(); }

  std::pair<double, int32_t> distance(Position r, Direction u,
    int32_t on_surface, GeometryState* p) const override
  {
    return region_.distance(r, u, on_surface);
  }

  bool contains(Position r, Direction u, int32_t on_surface) const override
  {
    return region_.contains(r, u, on_surface);
  }

  BoundingBox bounding_box() const override
  {
    return region_.bounding_box(id_);
  }

  void to_hdf5_inner(hid_t group_id) const override;

  bool is_simple() const override { return region_.is_simple(); }

  virtual GeometryType geom_type() const override { return GeometryType::CSG; }

protected:
  //! Returns the beginning position of a parenthesis block (immediately before
  //! two surface tokens) in the RPN given a starting position at the end of
  //! that block (immediately after two surface tokens)
  //! \param start Starting position of the search
  //! \param rpn The rpn being searched
  static vector<int32_t>::iterator find_left_parenthesis(
    vector<int32_t>::iterator start, const vector<int32_t>& rpn);

private:
  Region region_;
};

//==============================================================================
//! Define an instance of a particular cell
//==============================================================================

//!  Stores information used to identify a unique cell in the model
struct CellInstance {
  //! Check for equality
  bool operator==(const CellInstance& other) const
  {
    return index_cell == other.index_cell && instance == other.instance;
  }

  int64_t index_cell;
  int64_t instance;
};

//! Structure necessary for inserting CellInstance into hashed STL data
//! structures
struct CellInstanceHash {
  std::size_t operator()(const CellInstance& k) const
  {
    return 4096 * k.index_cell + k.instance;
  }
};

//==============================================================================
// Non-member functions
//==============================================================================

void read_cells(pugi::xml_node node);

//!  Add cells to universes
void populate_universes();

} // namespace openmc
#endif // OPENMC_CELL_H

1	#ifndef OPENMC_CELL_H
2	#define OPENMC_CELL_H
3
4	#include <cstdint>
5	#include <functional> // for hash
6	#include <limits>
7	#include <string>
8	#include <unordered_map>
9	#include <unordered_set>
10
11	#include "hdf5.h"
12	#include "pugixml.hpp"
13
14	#include "openmc/bounding_box.h"
15	#include "openmc/constants.h"
16	#include "openmc/memory.h" // for unique_ptr
17	#include "openmc/neighbor_list.h"
18	#include "openmc/position.h"
19	#include "openmc/surface.h"
20	#include "openmc/universe.h"
21	#include "openmc/vector.h"
22
23	namespace openmc {
24
25	//==============================================================================
26	// Constants
27	//==============================================================================
28
29	enum class Fill { MATERIAL, UNIVERSE, LATTICE };
30
31	constexpr int32_t OP_LEFT_PAREN {std::numeric_limits<int32_t>::max()};
32	constexpr int32_t OP_RIGHT_PAREN {std::numeric_limits<int32_t>::max() - 1};
33	constexpr int32_t OP_COMPLEMENT {std::numeric_limits<int32_t>::max() - 2};
34	constexpr int32_t OP_INTERSECTION {std::numeric_limits<int32_t>::max() - 3};
35	constexpr int32_t OP_UNION {std::numeric_limits<int32_t>::max() - 4};
36
37	//==============================================================================
38	// Global variables
39	//==============================================================================
40
41	class Cell;
42	class GeometryState;
43	class ParentCell;
44	class CellInstance;
45	class Universe;
46	class UniversePartitioner;
47
48	namespace model {
49	extern std::unordered_map<int32_t, int32_t> cell_map;
50	extern vector<unique_ptr<Cell>> cells;
51
52	} // namespace model
53
54	//==============================================================================
55
56	class Region {
57	public:
58	//----------------------------------------------------------------------------
59	// Constructors
60	Region() {}	2,037✔
61	explicit Region(std::string region_spec, int32_t cell_id);
62
63	//----------------------------------------------------------------------------
64	// Methods
65
66	//! \brief Determine if a cell contains the particle at a given location.
67	//!
68	//! The bounds of the cell are determined by a logical expression involving
69	//! surface half-spaces. The expression used is given in infix notation
70	//!
71	//! The function is split into two cases, one for simple cells (those
72	//! involving only the intersection of half-spaces) and one for complex cells.
73	//! Both cases use short circuiting; however, in the case fo complex cells,
74	//! the complexity increases with the binary operators involved.
75	//! \param r The 3D Cartesian coordinate to check.
76	//! \param u A direction used to "break ties" the coordinates are very
77	//! close to a surface.
78	//! \param on_surface The signed index of a surface that the coordinate is
79	//! known to be on. This index takes precedence over surface sense
80	//! calculations.
81	bool contains(Position r, Direction u, int32_t on_surface) const;
82
83	//! Find the oncoming boundary of this cell.
84	std::pair<double, int32_t> distance(
85	Position r, Direction u, int32_t on_surface) const;
86
87	//! Get the BoundingBox for this cell.
88	BoundingBox bounding_box(int32_t cell_id) const;
89
90	//! Get the CSG expression as a string
91	std::string str() const;
92
93	//! Get a vector containing all the surfaces in the region expression
94	vector<int32_t> surfaces() const;
95
96	//----------------------------------------------------------------------------
97	// Accessors
98
99	//! Get Boolean of if the cell is simple or not
100	bool is_simple() const { return simple_; }	484,745,899✔
101
102	private:
103	//----------------------------------------------------------------------------
104	// Private Methods
105
106	//! Get a vector of the region expression in postfix notation
107	vector<int32_t> generate_postfix(int32_t cell_id) const;
108
109	//! Determine if a particle is inside the cell for a simple cell (only
110	//! intersection operators)
111	bool contains_simple(Position r, Direction u, int32_t on_surface) const;
112
113	//! Determine if a particle is inside the cell for a complex cell.
114	//!
115	//! Uses the comobination of half-spaces and binary operators to determine
116	//! if short circuiting can be used. Short cicuiting uses the relative and
117	//! absolute depth of parentheses in the expression.
118	bool contains_complex(Position r, Direction u, int32_t on_surface) const;
119
120	//! BoundingBox if the paritcle is in a simple cell.
121	BoundingBox bounding_box_simple() const;
122
123	//! BoundingBox if the particle is in a complex cell.
124	BoundingBox bounding_box_complex(vector<int32_t> postfix) const;
125
126	//! Enforce precedence between intersections and unions
127	void enforce_precedence();
128
129	//! Add parenthesis to enforce precedence
130	void add_parentheses(int64_t start);
131
132	//! Remove complement operators from the expression
133	void remove_complement_ops();
134
135	//! Remove complement operators by using DeMorgan's laws
136	void apply_demorgan(
137	vector<int32_t>::iterator start, vector<int32_t>::iterator stop);
138
139	//----------------------------------------------------------------------------
140	// Private Data
141
142	//! Definition of spatial region as Boolean expression of half-spaces
143	// TODO: Should this be a vector of some other type
144	vector<int32_t> expression_;
145	bool simple_; //!< Does the region contain only intersections?
146	};
147
148	//==============================================================================
149
150	class Cell {
151	public:
152	//----------------------------------------------------------------------------
153	// Constructors, destructors, factory functions
154
155	explicit Cell(pugi::xml_node cell_node);
156	Cell() {};	2,037✔
157	virtual ~Cell() = default;	2,037✔
158
159	//----------------------------------------------------------------------------
160	// Methods
161
162	//! \brief Determine if a cell contains the particle at a given location.
163	//!
164	//! The bounds of the cell are detemined by a logical expression involving
165	//! surface half-spaces. At initialization, the expression was converted
166	//! to RPN notation.
167	//!
168	//! The function is split into two cases, one for simple cells (those
169	//! involving only the intersection of half-spaces) and one for complex cells.
170	//! Simple cells can be evaluated with short circuit evaluation, i.e., as soon
171	//! as we know that one half-space is not satisfied, we can exit. This
172	//! provides a performance benefit for the common case. In
173	//! contains_complex, we evaluate the RPN expression using a stack, similar to
174	//! how a RPN calculator would work.
175	//! \param r The 3D Cartesian coordinate to check.
176	//! \param u A direction used to "break ties" the coordinates are very
177	//! close to a surface.
178	//! \param on_surface The signed index of a surface that the coordinate is
179	//! known to be on. This index takes precedence over surface sense
180	//! calculations.
181	virtual bool contains(Position r, Direction u, int32_t on_surface) const = 0;
182
183	//! Find the oncoming boundary of this cell.
184	virtual std::pair<double, int32_t> distance(
185	Position r, Direction u, int32_t on_surface, GeometryState* p) const = 0;
186
187	//! Write all information needed to reconstruct the cell to an HDF5 group.
188	//! \param group_id An HDF5 group id.
189	void to_hdf5(hid_t group_id) const;
190
191	virtual void to_hdf5_inner(hid_t group_id) const = 0;
192
193	//! Export physical properties to HDF5
194	//! \param[in] group HDF5 group to read from
195	void export_properties_hdf5(hid_t group) const;
196
197	//! Import physical properties from HDF5
198	//! \param[in] group HDF5 group to write to
199	void import_properties_hdf5(hid_t group);
200
201	//! Get the BoundingBox for this cell.
202	virtual BoundingBox bounding_box() const = 0;
203
204	//! Get a vector of surfaces in the cell
205	virtual vector<int32_t> surfaces() const { return vector<int32_t>(); }	×
206
207	//! Check if the cell region expression is simple
UNCOV 208	virtual bool is_simple() const { return true; }	×
209
210	//----------------------------------------------------------------------------
211	// Accessors
212
213	//! Get the temperature of a cell instance
214	//! \param[in] instance Instance index. If -1 is given, the temperature for
215	//! the first instance is returned.
216	//! \return Temperature in [K]
217	double temperature(int32_t instance = -1) const;
218
219	//! Get the density multiplier of a cell instance
220	//! \param[in] instance Instance index. If -1 is given, the density multiplier
221	//! for the first instance is returned.
222	//! \return Density multiplier
223	double density_mult(int32_t instance = -1) const;
224
225	//! Get the density of a cell instance in g/cm3
226	//! \param[in] instance Instance index. If -1 is given, the density
227	//! for the first instance is returned.
228	//! \return Density in [g/cm3]
229	double density(int32_t instance = -1) const;
230
231	//! Set the temperature of a cell instance
232	//! \param[in] T Temperature in [K]
233	//! \param[in] instance Instance index. If -1 is given, the temperature for
234	//! all instances is set.
235	//! \param[in] set_contained If this cell is not filled with a material,
236	//! collect all contained cells with material fills and set their
237	//! temperatures.
238	void set_temperature(
239	double T, int32_t instance = -1, bool set_contained = false);
240
241	//! Set the density of a cell instance
242	//! \param[in] density Density [g/cm3]
243	//! \param[in] instance Instance index. If -1 is given, the density
244	//! for all instances is set.
245	//! \param[in] set_contained If this cell is not filled with a material,
246	//! collect all contained cells with material fills and set their
247	//! densities.
248	void set_density(
249	double density, int32_t instance = -1, bool set_contained = false);
250
251	int32_t n_instances() const;
252
253	//! Set the rotation matrix of a cell instance
254	//! \param[in] rot The rotation matrix of length 3 or 9
255	void set_rotation(const vector<double>& rot);
256
257	//! Get the name of a cell
258	//! \return Cell name
259	const std::string& name() const { return name_; };	26✔
260
261	//! Set the temperature of a cell instance
262	//! \param[in] name Cell name
263	void set_name(const std::string& name) { name_ = name; };	1✔
264
265	//! Get all cell instances contained by this cell
266	//! \param[in] instance Instance of the cell for which to get contained cells
267	//! (default instance is zero)
268	//! \param[in] hint positional hint for determining the parent cells
269	//! \return Map with cell indexes as keys and
270	//! instances as values
271	std::unordered_map<int32_t, vector<int32_t>> get_contained_cells(
272	int32_t instance = 0, Position* hint = nullptr) const;
273
274	//! Determine the material index corresponding to a specific cell instance,
275	//! taking into account presence of distribcell material
276	//! \param[in] instance of the cell
277	//! \return material index
278	int32_t material(int32_t instance) const	229,670,183✔
279	{
280	// If distributed materials are used, then each instance has its own
281	// material definition. If distributed materials are not used, then
282	// all instances used the same material stored at material_[0]. The
283	// presence of distributed materials is inferred from the size of
284	// the material_ vector being greater than one.
285	if (material_.size() > 1) {	229,670,183✔
286	return material_[instance];	1,050,770✔
287	} else {
288	return material_[0];	228,619,413✔
289	}
290	}
291
292	//! Determine the temperature index corresponding to a specific cell instance,
293	//! taking into account presence of distribcell temperature
294	//! \param[in] instance of the cell
295	//! \return temperature index
296	double sqrtkT(int32_t instance) const	229,442,414✔
297	{
298	// If distributed materials are used, then each instance has its own
299	// temperature definition. If distributed materials are not used, then
300	// all instances used the same temperature stored at sqrtkT_[0]. The
301	// presence of distributed materials is inferred from the size of
302	// the sqrtkT_ vector being greater than one.
303	if (sqrtkT_.size() > 1) {	229,442,414✔
304	return sqrtkT_[instance];	1,086,437✔
305	} else {
306	return sqrtkT_[0];	228,355,977✔
307	}
308	}
309
310	protected:
311	//! Determine the path to this cell instance in the geometry hierarchy
312	//! \param[in] instance of the cell to find parent cells for
313	//! \param[in] r position used to do a fast search for parent cells
314	//! \return parent cells
315	vector<ParentCell> find_parent_cells(
316	int32_t instance, const Position& r) const;
317
318	//! Determine the path to this cell instance in the geometry hierarchy
319	//! \param[in] instance of the cell to find parent cells for
320	//! \param[in] p particle used to do a fast search for parent cells
321	//! \return parent cells
322	vector<ParentCell> find_parent_cells(
323	int32_t instance, GeometryState& p) const;
324
325	//! Determine the path to this cell instance in the geometry hierarchy
326	//! \param[in] instance of the cell to find parent cells for
327	//! \return parent cells
328	vector<ParentCell> exhaustive_find_parent_cells(int32_t instance) const;
329
330	//! Inner function for retrieving contained cells
331	void get_contained_cells_inner(
332	std::unordered_map<int32_t, vector<int32_t>>& contained_cells,
333	vector<ParentCell>& parent_cells) const;
334
335	public:
336	//----------------------------------------------------------------------------
337	// Data members
338
339	int32_t id_; //!< Unique ID
340	std::string name_; //!< User-defined name
341	Fill type_; //!< Material, universe, or lattice
342	int32_t universe_; //!< Universe # this cell is in
343	int32_t fill_; //!< Universe # filling this cell
344
345	//! \brief Index corresponding to this cell in distribcell arrays
346	int distribcell_index_ {C_NONE};
347
348	//! \brief Material(s) within this cell.
349	//!
350	//! May be multiple materials for distribcell.
351	vector<int32_t> material_;
352
353	//! \brief Temperature(s) within this cell.
354	//!
355	//! The stored values are actually sqrt(k_Boltzmann * T) for each temperature
356	//! T. The units are sqrt(eV).
357	vector<double> sqrtkT_;
358
359	//! \brief Unitless density multiplier(s) within this cell.
360	vector<double> density_mult_;
361
362	//! \brief Neighboring cells in the same universe.
363	NeighborList neighbors_;
364
365	Position translation_ {0, 0, 0}; //!< Translation vector for filled universe
366
367	//! \brief Rotational tranfsormation of the filled universe.
368	//
369	//! The vector is empty if there is no rotation. Otherwise, the first 9 values
370	//! give the rotation matrix in row-major order. When the user specifies
371	//! rotation angles about the x-, y- and z- axes in degrees, these values are
372	//! also present at the end of the vector, making it of length 12.
373	vector<double> rotation_;
374
375	vector<int32_t> offset_; //!< Distribcell offset table
376
377	// Right now, either CSG or DAGMC cells are used.
378	virtual GeometryType geom_type() const = 0;
379	};
380
381	struct CellInstanceItem {
382	int32_t index {-1}; //! Index into global cells array
383	int lattice_indx {-1}; //! Flat index value of the lattice cell
384	};
385
386	//==============================================================================
387
388	class CSGCell : public Cell {
389	public:
390	//----------------------------------------------------------------------------
391	// Constructors
392	CSGCell() = default;	2✔
393	explicit CSGCell(pugi::xml_node cell_node);
394
395	//----------------------------------------------------------------------------
396	// Methods
397	vector<int32_t> surfaces() const override { return region_.surfaces(); }	364✔
398
399	std::pair<double, int32_t> distance(Position r, Direction u,	653,473,723✔
400	int32_t on_surface, GeometryState* p) const override
401	{
402	return region_.distance(r, u, on_surface);	653,473,723✔
403	}
404
405	bool contains(Position r, Direction u, int32_t on_surface) const override	357,083,588✔
406	{
407	return region_.contains(r, u, on_surface);	357,083,588✔
408	}
409
410	BoundingBox bounding_box() const override	8✔
411	{
412	return region_.bounding_box(id_);	8✔
413	}
414
415	void to_hdf5_inner(hid_t group_id) const override;
416
417	bool is_simple() const override { return region_.is_simple(); }	484,745,899✔
418
419	virtual GeometryType geom_type() const override { return GeometryType::CSG; }	×
420
421	protected:
422	//! Returns the beginning position of a parenthesis block (immediately before
423	//! two surface tokens) in the RPN given a starting position at the end of
424	//! that block (immediately after two surface tokens)
425	//! \param start Starting position of the search
426	//! \param rpn The rpn being searched
427	static vector<int32_t>::iterator find_left_parenthesis(
428	vector<int32_t>::iterator start, const vector<int32_t>& rpn);
429
430	private:
431	Region region_;
432	};
433
434	//==============================================================================
435	//! Define an instance of a particular cell
436	//==============================================================================
437
438	//! Stores information used to identify a unique cell in the model
439	struct CellInstance {
440	//! Check for equality
441	bool operator==(const CellInstance& other) const	363,204✔
442	{
443	return index_cell == other.index_cell && instance == other.instance;	363,204!
444	}
445
446	int64_t index_cell;
447	int64_t instance;
448	};
449
450	//! Structure necessary for inserting CellInstance into hashed STL data
451	//! structures
452	struct CellInstanceHash {
453	std::size_t operator()(const CellInstance& k) const	363,244✔
454	{
455	return 4096 * k.index_cell + k.instance;	363,244✔
456	}
457	};
458
459	//==============================================================================
460	// Non-member functions
461	//==============================================================================
462
463	void read_cells(pugi::xml_node node);
464
465	//! Add cells to universes
466	void populate_universes();
467
468	} // namespace openmc
469	#endif // OPENMC_CELL_H

openmc-dev / openmc / 21489819490

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous