time consistent seed approach

Author: yardasol

include/openmc/random_ray/flat_source_domain.h

@@ -76,22 +76,17 @@ class FlatSourceDomain {
 
   //----------------------------------------------------------------------------
   // Methods for kinetic simulations
-  virtual void update_single_neutron_source_td(SourceRegionHandle& srh);
   void compute_single_neutron_source_time_derivative(SourceRegionHandle& srh);
   void compute_single_scalar_flux_time_derivative_2(SourceRegionHandle& srh);
-  virtual void update_all_neutron_sources_td();
 
   void compute_single_delayed_fission_source(SourceRegionHandle& srh);
   void compute_single_precursors(SourceRegionHandle& srh);
   void compute_all_precursors();
 
-  void serialize_final_td_fluxes(vector<double>& flux_td);
-  void serialize_final_td_sources(vector<double>& source_td);
   void serialize_final_precursors(vector<double>& precursors);
   void serialize_final_delayed_fission_source(
     vector<double>& delayed_fission_source);
 
-  void flux_td_swap();
   void precursors_swap();
   void accumulate_iteration_quantities();
   void normalize_final_quantities();
@@ -124,6 +119,9 @@ class FlatSourceDomain {
   //----------------------------------------------------------------------------
   // Public Data members
   double k_eff_ {1.0};              // Eigenvalue
+  double
+    fission_rate_; // The system's fission rate (per cm^3), in eigenvalue mode
+
   bool mapped_all_tallies_ {false}; // If all source regions have been visited
 
   int64_t n_external_source_regions_ {0}; // Total number of source regions with
@@ -200,13 +198,6 @@ class FlatSourceDomain {
   vector<double> chi_p_;
   vector<double> inverse_vbar_;
 
-  // Time-dependent cross section arrays for use with material density
-  // timeseries
-  vector<double> sigma_t_td_;
-  vector<double> nu_sigma_f_td_;
-  vector<double> sigma_f_td_;
-  vector<double> sigma_s_td_;
-
 protected:
   //----------------------------------------------------------------------------
   // Methods
@@ -229,9 +220,6 @@ class FlatSourceDomain {
     simulation_volume_; // Total physical volume of the simulation domain, as
                         // defined by the 3D box of the random ray source
 
-  double
-    fission_rate_; // The system's fission rate (per cm^3), in eigenvalue mode
-
   // Volumes for each tally and bin/score combination. This intermediate data
   // structure is used when tallying quantities that must be normalized by
   // volume (i.e., flux). The vector is index by tally index, while the inner 2D

include/openmc/random_ray/random_ray.h

@@ -74,8 +74,7 @@ class RandomRay : public Particle {
 
   //---------------------------------------------------------------------------
   // Public data members for kinetic simulations
-  vector<float> angular_flux_td_;
-  vector<float> angular_flux_td_prime_;
+  vector<float> angular_flux_prime_;
 
 private:
   //----------------------------------------------------------------------------
@@ -94,8 +93,7 @@ class RandomRay : public Particle {
 
   //---------------------------------------------------------------------------
   // Private data members for kinetic simulations
-  vector<double> delta_psi_td_;
-  vector<double> delta_psi_td_prime_;
+  vector<double> delta_psi_prime_;
 
 }; // class RandomRay
 

include/openmc/random_ray/random_ray_simulation.h

@@ -52,6 +52,12 @@ class RandomRaySimulation {
   // Number of delay groups
   int ndgroups_;
 
+  //----------------------------------------------------------------------------
+  // Data Members for kinetic simulations
+
+  vector<double> static_k_eff_;
+  vector<double> static_fission_rate_;
+
 }; // class RandomRaySimulation
 
 //============================================================================

include/openmc/random_ray/source_region.h

@@ -196,14 +196,6 @@ class SourceRegionHandle {
   //---------------------------------------------------------------------------
   // Public Data Members for kinetic simulations
 
-  // Energy group-wise 1D time-dependent arrays
-  double* scalar_flux_td_old_;
-  double* scalar_flux_td_new_;
-  double* scalar_flux_td_final_;
-
-  double* source_td_;
-  double* source_td_final_;
-
   // Energy group-wise 1D time-derivative arrays
   double* source_time_derivative_;
   double* scalar_flux_time_derivative_2_;
@@ -351,30 +343,6 @@ class SourceRegionHandle {
 
   //---------------------------------------------------------------------------
   // Public Accessors for kinetic simulations
-  double& scalar_flux_td_old(int g) { return scalar_flux_td_old_[g]; }
-  const double scalar_flux_td_old(int g) const
-  {
-    return scalar_flux_td_old_[g];
-  }
-
-  double& scalar_flux_td_new(int g) { return scalar_flux_td_new_[g]; }
-  const double scalar_flux_td_new(int g) const
-  {
-    return scalar_flux_td_new_[g];
-  }
-
-  double& scalar_flux_td_final(int g) { return scalar_flux_td_final_[g]; }
-  const double scalar_flux_td_final(int g) const
-  {
-    return scalar_flux_td_final_[g];
-  }
-
-  double& source_td(int g) { return source_td_[g]; }
-  const double source_td(int g) const { return source_td_[g]; }
-
-  double& source_td_final(int g) { return source_td_final_[g]; }
-  const double source_td_final(int g) const { return source_td_final_[g]; }
-
   double& source_time_derivative(int g) { return source_time_derivative_[g]; }
   const double source_time_derivative(int g) const
   {
@@ -531,23 +499,8 @@ class SourceRegion {
   // Public Data Members for kinetic simulations
 
   // Energy group-wise 1D time-dependent arrrays
-  vector<double> source_final_;       //!< The total source accumulated over all
-                                      //!< active iterations (used for SDP)
-  vector<double> scalar_flux_td_old_; //!< The time-dependent scalar flux from
-                                      //!< the previous iteration
-  vector<double> scalar_flux_td_new_; //!< The time-dependent scalar flux from
-                                      //!< the current iteration
-  vector<double>
-    scalar_flux_td_final_; //!< The time-dependent scalar flux accumulated over
-                           //!< all active iterations (used as the initial
-                           //!< condition for the next timestep)
-
-  vector<double>
-    source_td_; //!< The total time-dependent source term (prompt
-                //!< prompt fission + scattering + delayed emission)
-  vector<double>
-    source_td_final_; //!< The total time-dependent source accumulated over all
-                      //!< active iterations (used for SDP)
+  vector<double> source_final_; //!< The total source accumulated over all
+                                //!< active iterations (used for SDP)
 
   // Energy group-wise 1D derivative arrays
   vector<double> source_time_derivative_;        //!< The time derivative of the
@@ -851,71 +804,6 @@ class SourceRegionContainer {
 
   //---------------------------------------
   // For kinetic simulations
-
-  double& scalar_flux_td_old(int64_t sr, int g)
-  {
-    return scalar_flux_td_old_[index(sr, g)];
-  }
-  const double& scalar_flux_td_old(int64_t sr, int g) const
-  {
-    return scalar_flux_td_old_[index(sr, g)];
-  }
-  double& scalar_flux_td_old(int64_t se) { return scalar_flux_td_old_[se]; }
-  const double& scalar_flux_td_old(int64_t se) const
-  {
-    return scalar_flux_td_old_[se];
-  }
-
-  double& scalar_flux_td_new(int64_t sr, int g)
-  {
-    return scalar_flux_td_new_[index(sr, g)];
-  }
-  const double& scalar_flux_td_new(int64_t sr, int g) const
-  {
-    return scalar_flux_td_new_[index(sr, g)];
-  }
-  double& scalar_flux_td_new(int64_t se) { return scalar_flux_td_new_[se]; }
-  const double& scalar_flux_td_new(int64_t se) const
-  {
-    return scalar_flux_td_new_[se];
-  }
-
-  double& scalar_flux_td_final(int64_t sr, int g)
-  {
-    return scalar_flux_td_final_[index(sr, g)];
-  }
-  const double& scalar_flux_td_final(int64_t sr, int g) const
-  {
-    return scalar_flux_td_final_[index(sr, g)];
-  }
-  double& scalar_flux_td_final(int64_t se) { return scalar_flux_td_final_[se]; }
-  const double& scalar_flux_td_final(int64_t se) const
-  {
-    return scalar_flux_td_final_[se];
-  }
-
-  double& source_td(int64_t sr, int g) { return source_td_[index(sr, g)]; }
-  const double& source_td(int64_t sr, int g) const
-  {
-    return source_td_[index(sr, g)];
-  }
-  double& source_td(int64_t se) { return source_td_[se]; }
-  const double& source_td(int64_t se) const { return source_td_[se]; }
-
-  double& source_td_final(int64_t sr, int g)
-  {
-    return source_td_final_[index(sr, g)];
-  }
-  const double& source_td_final(int64_t sr, int g) const
-  {
-    return source_td_final_[index(sr, g)];
-  }
-  double& source_td_final(int64_t se) { return source_td_final_[se]; }
-  const double& source_td_final(int64_t se) const
-  {
-    return source_td_final_[se];
-  }
-
   double& source_time_derivative(int64_t sr, int g)
   {
     return source_time_derivative_[index(sr, g)];
@@ -1137,7 +1025,6 @@ class SourceRegionContainer {
   int& ndgroups() { return ndgroups_; }
   const int ndgroups() const { return ndgroups_; }
 
-  void flux_td_swap();
   void precursors_swap();
   void time_step_reset();
 
@@ -1197,14 +1084,6 @@ class SourceRegionContainer {
   //---------------------------------------------------------------------------
   // Private Data Members for kinetic simulations
 
-  // SoA energy group-wise 2D time-dependent arrays flattened to 1D
-  vector<double> scalar_flux_td_old_;
-  vector<double> scalar_flux_td_new_;
-  vector<double> scalar_flux_td_final_;
-
-  vector<double> source_td_;
-  vector<double> source_td_final_;
-
   // SoA energy group-wise 2D derivative arrays flattened to 1D
   vector<double> source_time_derivative_;
   vector<double> scalar_flux_time_derivative_2_;

include/openmc/simulation.h

@@ -56,6 +56,8 @@ extern bool
                              // condition for a kinetic simulation
 extern int current_timestep; // !< current time step in kinetic simulation
 extern double current_time;  // !< current time in kinetic simulation
+extern bool k_eff_correction; // !< flag to indicate if the simulation is meant
+                              // to correct batchwise k_effs
 
 } // namespace simulation
 

include/openmc/timer.h

@@ -33,8 +33,7 @@ extern Timer time_event_collision;
 extern Timer time_event_death;
 extern Timer time_update_src;
 
-extern Timer time_update_bd_vectors_td;
-extern Timer time_update_src_td;
+extern Timer time_update_bd_vectors;
 extern Timer time_compute_precursors;
 
 } // namespace simulation