adding more functionality

Author: magnoxemo

include/Depletion.h

@@ -0,0 +1,13 @@
+#ifndef ASTARA_DEPLETION_H
+#define ASTARA_DEPLETION_H
+
+namespace astara{
+    class DepletionSolver{
+    public:
+        DepletionSolver();
+        ~DepletionSolver();
+    protected:
+        // isotope list
+    };
+}
+#endif //ASTARA_DEPLETION_H

include/Parser.h include/Function.hinclude/Parser.h renamed to include/Function.h

@@ -0,0 +1,16 @@
+#ifndef ASTARA_MATH_H
+#define ASTARA_MATH_H
+
+// main math functions and solvers for the framework
+namespace astara{
+
+    template <typename T>
+    T predictor_corrector_integrator(T (*differential_func)(), T time_step);
+
+    template <typename T>
+    T predictor_integrator(T (*differential_func)(), T time_step);
+}
+
+#endif //ASTARA_MATH_H
+
+

include/Math.h

@@ -11,7 +11,10 @@ class Function;
 class Reactor {
 
 public:
-  Reactor(unsigned int n_groups, std::vector<double> delayed_neutron_constants);
+  Reactor(unsigned int n_groups,
+          std::vector<double> neutron_group_const,
+          std::vector<double> delayed_neutron_constants,
+          double neutron_generation_time);
   ~Reactor();
 
   /* initial condition setters*/
@@ -67,14 +70,26 @@ class Reactor {
   std::unique_ptr<Function> _moderator_temperature_co_efficient;
   std::unique_ptr<Function> _boron_temperature_co_efficient;
 
+  //neutron generation time
+  const double _neutron_generation_time;
+
+  //variables
+  /* There is an initial reactivity which can be calculated from the startup
+   * condition. Like how much boron in it, fuel moderator temperature, initial xenon presence
+   * fuel inventory presence etc */
+  double _reactivity = 0;
+
   // temperatures
   double _fuel_temperature;
   double _moderator_temperature;
 
   // delayed neutron fractions
   const unsigned int _number_of_neutron_groups;
-  const std::vector<double> _delayed_neutron_constants;
-  const double _sum_delayed_neutron_constants;
+  const std::vector<double> _neutron_group_const;
+  const std::vector<double> _decay_constants;
+  const double _total_decay_constant;
+  const double _total_group_const;
+
 };
 } // namespace astara
 

include/Reactor.h

@@ -1,4 +1,4 @@
-#include "Parser.h"
+#include "Function.h"
 
 astara::Function::Function(const std::string &expr,
                            const std::vector<std::string> &variable_names)

src/Parser.cpp src/Function.cppsrc/Parser.cpp renamed to src/Function.cpp

@@ -1,22 +1,30 @@
 #include <iostream>
 #include <numeric>
 
-#include "Parser.h"
+#include "Function.h"
 #include "Reactor.h"
 
 astara::Reactor::Reactor(unsigned int n_groups,
-                         std::vector<double> delayed_neutron_constants)
+                         std::vector<double> neutron_group_const,
+                         std::vector<double> delayed_neutron_constants,
+                         double neutron_generation_time)
     : _number_of_neutron_groups(n_groups),
-      _delayed_neutron_constants(delayed_neutron_constants),
-      _sum_delayed_neutron_constants(
-          std::accumulate(_delayed_neutron_constants.begin(),
-                          _delayed_neutron_constants.end(), 0.0)) {
-
-  if (_number_of_neutron_groups != _delayed_neutron_constants.size())
+      _neutron_group_const(neutron_group_const),
+      _decay_constants(delayed_neutron_constants),
+      _total_decay_constant(std::accumulate(_decay_constants.begin(),
+                                            _decay_constants.end(), 0.0)),
+      _total_group_const(std::accumulate(_neutron_group_const.begin(),
+                                         _neutron_group_const.end(), 0)),
+      _neutron_generation_time(neutron_generation_time) {
+
+  if (_number_of_neutron_groups != _decay_constants.size() and
+      _number_of_neutron_groups != _neutron_group_const.size())
     throw std::runtime_error("Number of neutron group must be equal to the "
-                             "number of delayed consts");
+                             "number of delayed and group consts");
 }
 
+astara::Reactor::Reactor::~Reactor() = default;
+
 void astara::Reactor::setHeatTransferCoefficient(
     Function *heat_transfer_co_eff_function) {
   if (heat_transfer_co_eff_function != nullptr)
@@ -49,4 +57,4 @@ void astara::Reactor::setModeratorTemperatureCoEfficientFunction(
     throw std::runtime_error("moderator_temp_feed_back_func is null_ptr");
 }
 
-astara::Reactor::Reactor::~Reactor() = default;
+void astara::Reactor::dRhoDt() {}

src/Reactor.cpp

@@ -1,7 +1,7 @@
 #include "cmath"
 #include <gtest/gtest.h>
 
-#include "Parser.h"
+#include "Function.h"
 
 TEST(AstaraParser, ConstantExpression) {
   astara::Function f("2 + 3 * 4", {});

unit_tests/parser_tests.cpp unit_tests/function_tests.cppunit_tests/parser_tests.cpp renamed to unit_tests/function_tests.cpp

@@ -2,98 +2,22 @@
 #include <stdexcept>
 #include <vector>
 
-#include "Parser.h"
+#include "Function.h"
 #include "Reactor.h"
 
 using namespace astara;
 
-
 TEST(ReactorConstructorTest, ThrowsWhenGroupCountDoesNotMatchConstants) {
-  EXPECT_THROW(Reactor reactor(3, {0.1, 0.2}), std::runtime_error);
-}
-
-TEST(ReactorConstructorTest, DoesNotThrowWhenGroupCountMatchesConstants) {
-  EXPECT_NO_THROW(Reactor reactor(2, {0.1, 0.2}));
-}
-
-// ------------------------
-// Heat transfer coefficient setter
-// ------------------------
-TEST(ReactorFunctionSetterTest, HeatTransferCoefficientThrowsOnNullptr) {
-  Reactor reactor(1, {0.1});
-  EXPECT_THROW(reactor.setHeatTransferCoefficient(nullptr), std::runtime_error);
-}
-
-TEST(ReactorFunctionSetterTest, HeatTransferCoefficientAcceptsValidFunction) {
-  Reactor reactor(1, {0.1});
-  EXPECT_NO_THROW(
-      reactor.setHeatTransferCoefficient(new Function("2.0 * x", {"x"})));
-}
-
-// ------------------------
-// Fuel specific heat setter
-// ------------------------
-TEST(ReactorFunctionSetterTest, FuelSpecificHeatThrowsOnNullptr) {
-  Reactor reactor(1, {0.1});
-  EXPECT_THROW(reactor.setFuelSpecificHeatFunction(nullptr),
-               std::runtime_error);
-}
-
-TEST(ReactorFunctionSetterTest, FuelSpecificHeatAcceptsValidFunction) {
-  Reactor reactor(1, {0.1});
-  EXPECT_NO_THROW(
-      reactor.setFuelSpecificHeatFunction(new Function("1000 + T", {"T"})));
-}
-
-// ------------------------
-// Fuel temperature coefficient setter
-// ------------------------
-TEST(ReactorFunctionSetterTest, FuelTemperatureCoefficientThrowsOnNullptr) {
-  Reactor reactor(1, {0.1});
-  EXPECT_THROW(reactor.setFuelTemperatureCoEfficientFunction(nullptr),
-               std::runtime_error);
-}
-
-TEST(ReactorFunctionSetterTest,
-     FuelTemperatureCoefficientAcceptsValidFunction) {
-  Reactor reactor(1, {0.1});
-  EXPECT_NO_THROW(reactor.setFuelTemperatureCoEfficientFunction(
-      new Function("-0.01 * T", {"T"})));
-}
-
-// ------------------------
-// Moderator temperature coefficient setter
-// ------------------------
-TEST(ReactorFunctionSetterTest,
-     ModeratorTemperatureCoefficientThrowsOnNullptr) {
-  Reactor reactor(1, {0.1});
-  EXPECT_THROW(reactor.setModeratorTemperatureCoEfficientFunction(nullptr),
+  EXPECT_THROW(Reactor reactor(3, {0.1, 0.2}, {0.1, 0.2}, 1e-9),
                std::runtime_error);
 }
 
-TEST(ReactorFunctionSetterTest,
-     ModeratorTemperatureCoefficientAcceptsValidFunction) {
-  Reactor reactor(1, {0.1});
-  EXPECT_NO_THROW(reactor.setModeratorTemperatureCoEfficientFunction(
-      new Function("-0.002 * T", {"T"})));
-}
-
-// ------------------------
-// Replacement semantics
-// ------------------------
-TEST(ReactorFunctionSetterTest, ReplacingHeatTransferCoefficientDoesNotThrow) {
-  Reactor reactor(1, {0.1});
-  EXPECT_NO_THROW({
-    reactor.setHeatTransferCoefficient(new Function("x", {"x"}));
-    reactor.setHeatTransferCoefficient(new Function("2 * x", {"x"}));
-  });
+TEST(ReactorConstructorTest, DoesNotThrowWhenGroupCountMatchesConstants) {
+  EXPECT_NO_THROW(Reactor reactor(2, {0.1, 0.2}, {0.1, 0.2}, 1e-9));
 }
 
-// ------------------------
-// Multiple setters together
-// ------------------------
 TEST(ReactorFunctionSetterTest, SettingAllFunctionsDoesNotThrow) {
-  Reactor reactor(1, {0.1});
+  Reactor reactor(2, {0.1, 0.2}, {0.1, 0.2}, 1e-9);
   EXPECT_NO_THROW({
     reactor.setHeatTransferCoefficient(new Function("x", {"x"}));
     reactor.setFuelSpecificHeatFunction(new Function("1000 + T", {"T"}));