Updating Cell class

examples/main.cpp

@@ -2,7 +2,8 @@
 #include <vector>
 #include <omp.h>
 #include <Eigen/Dense>
-#include "demeter/model/material.hpp"
+
+#include "demeter/model.hpp"
 
 int main() {
   using namespace Demeter;
@@ -17,8 +18,10 @@ int main() {
   ArrayXd chi{{1., 0.}};
 
   Material uo2(sigma_t, sigma_s, sigma_a, sigma_f, nu_sigma_f, chi, "UO2");
-
   std::cout << uo2 << std::endl;
 
+  Cell uo2_cell(1.0, &uo2, "UO2");
+  std::cout << uo2_cell << std::endl;
+
   return 0;
 }

src/demeter/common/define.hpp

@@ -5,6 +5,6 @@
 
 #include <Eigen/Core>
 
-
 using Eigen::ArrayXd;
-using Eigen::ArrayXXd;
+using Eigen::ArrayXXd;
+using Eigen::Index;

src/demeter/model/cell.cpp

@@ -1,5 +1,15 @@
 #include "cell.hpp"
 
 namespace Demeter {
-void Cell::check() const { assert(materials_.size() == radii_.size() + 1); }
+void Cell::check() const {
+  assert(side_ > 0.0);
+  assert(materials_.size() == radii_.size() + 1);
+}
+
+std::string Cell::print() const {
+  std::ostringstream ss;
+  ss << "Cell " << name_ << " has " << radii_.size() << " rings and "
+     << materials_.size() << " materials";
+  return ss.str();
+}
 }  // namespace Demeter

src/demeter/model/cell.hpp

@@ -13,29 +13,34 @@ namespace Demeter {
 
 class Cell {
  public:
-  Cell(double side, std::vector<std::shared_ptr<Material>>& materials,
-       std::string_view name = "")
-      : side(side), materials_(materials), name_(name) {}
+  Cell(double side, Material* material, std::string_view name = "")
+      : side_(side), name_(name) {
+    materials_.push_back(material);
+  }
 
   Cell(double side, std::vector<double>& radii,
-       std::vector<std::shared_ptr<Material>>& materials,
-       std::string_view name = "")
-      : side(side), radii_(radii), materials_(materials), name_(name) {
+       std::vector<Material*>& materials, std::string_view name = "")
+      : side_(side), radii_(radii), materials_(materials), name_(name) {
     check();
   }
 
+  std::string print() const;
+  friend std::ostream& operator<<(std::ostream& os, const Cell& c) {
+    return os << c.print();
+  }
+
  private:
   void check() const;
 
  private:
-  double side;  // we assume that every cell is a square
+  double side_;  // we assume that every cell is a square
 
   std::vector<double> radii_;
   // size_t num_rings_;
 
   // size_t num_sectors_; //TODO
 
-  std::vector<std::shared_ptr<Material>> materials_;
+  std::vector<Material*> materials_;
 
   /* A name for the Cell */
   std::string name_;

src/demeter/model/material.bind.cpp

@@ -1,7 +1,7 @@
 #include "demeter/model/material.hpp"
 
 #pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
+#pragma GCC diagnostic ignored "-Weverything"
 #include <nanobind/nanobind.h>
 #include <nanobind/eigen/dense.h>
 #include <nanobind/stl/string_view.h>

src/demeter/model/material.cpp

@@ -113,14 +113,12 @@ void Material::check() const {  // TODO use fmt and a logger
     throw std::runtime_error(print());
   }
 
-  auto cast = [&](long int x) { return static_cast<decltype(num_groups_)>(x); };
-
   auto dims = {sigma_t_.size(), sigma_s_.rows(), sigma_s_.cols(),
                sigma_a_.size(), sigma_f_.size(), nu_sigma_f_.size(),
                chi_.size()};
 
-  for (auto d : dims) {
-    if (cast(d) != num_groups_) {
+  for (const auto d : dims) {
+    if (d != num_groups_) {
       std::string msg =
           print() + ", but cross-sections have different sizes " +
           "sigma_t.size()=" + std::to_string(sigma_t_.size()) +

src/demeter/model/material.hpp

@@ -53,14 +53,14 @@ class Material {
   const auto& SigmaF() const { return sigma_f_; }
   const auto& NuSigmaF() const { return nu_sigma_f_; }
   const auto& Chi() const { return chi_; }
-  auto SigmaT(size_t group) const { return sigma_t_(check(group)); }
-  auto SigmaS(size_t from, size_t to) const {
+  auto SigmaT(Index group) const { return sigma_t_(check(group)); }
+  auto SigmaS(Index from, Index to) const {
     return sigma_s_(check(from), check(to));
   };
-  auto SigmaA(size_t group) const { return sigma_a_(check(group)); }
-  auto SigmaF(size_t group) const { return sigma_f_(check(group)); };
-  auto NuSigmaF(size_t group) const { return nu_sigma_f_(check(group)); };
-  auto Chi(size_t group) const { return chi_(check(group)); };
+  auto SigmaA(Index group) const { return sigma_a_(check(group)); }
+  auto SigmaF(Index group) const { return sigma_f_(check(group)); };
+  auto NuSigmaF(Index group) const { return nu_sigma_f_(check(group)); };
+  auto Chi(Index group) const { return chi_(check(group)); };
   bool fissile() const { return fissile_; }
 
   friend void swap(Material& a, Material& b) {
@@ -78,8 +78,8 @@ class Material {
 
  private:
   void check() const;
-  size_t check(size_t group) const {
-    assert(group < num_groups_);
+  Index check(Index group) const {
+    assert((group > 0) and (group < num_groups_));
     return group;
   }
 
@@ -103,7 +103,7 @@ class Material {
   ArrayXd chi_;
 
   /* The number of energy groups */
-  size_t num_groups_;
+  Index num_groups_;
 
   /* The Material is fissile if it contains a non-zero fission xs */
   bool fissile_;