Convert scattering routines to C++

include/openmc/endf.h

@@ -22,6 +22,17 @@ Interpolation int2interp(int i);
 //! \return Whether corresponding reaction is a fission reaction
 bool is_fission(int MT);
 
+//! Determine if a given MT number is that of a disappearance reaction, i.e., a
+//! reaction with no neutron in the exit channel
+//! \param[in] MT ENDF MT value
+//! \return Whether corresponding reaction is a disappearance reaction
+bool is_disappearance(int MT);
+
+//! Determine if a given MT number is that of an inelastic scattering reaction
+//! \param[in] MT ENDF MT value
+//! \return Whether corresponding reaction is an inelastic scattering reaction
+bool is_inelastic_scatter(int MT);
+
 //==============================================================================
 //! Abstract one-dimensional function
 //==============================================================================

include/openmc/material.h

@@ -43,5 +43,11 @@ public:
   explicit Material(pugi::xml_node material_node);
 };
 
+//==============================================================================
+// Fortran compatibility
+//==============================================================================
+
+extern "C" bool material_isotropic(int i_material, int i_nuc_mat);
+
 } // namespace openmc
 #endif // OPENMC_MATERIAL_H

include/openmc/nuclide.h

@@ -17,19 +17,35 @@
 
 namespace openmc {
 
+//==============================================================================
+// Constants
+//==============================================================================
+
+constexpr double CACHE_INVALID {-1.0};
+
 //===============================================================================
 // Data for a nuclide
 //===============================================================================
 
 class Nuclide {
 public:
+  // Types, aliases
   using EmissionMode = ReactionProduct::EmissionMode;
+  struct EnergyGrid {
+    std::vector<int> grid_index;
+    std::vector<double> energy;
+  };
 
   // Constructors
   Nuclide(hid_t group, const double* temperature, int n);
 
   // Methods
-  double nu(double E, EmissionMode mode, int group=0);
+  double nu(double E, EmissionMode mode, int group=0) const;
+  void calculate_elastic_xs(int i_nuclide) const;
+
+  //! Determines the microscopic 0K elastic cross section at a trial relative
+  //! energy used in resonance scattering
+  double elastic_xs_0K(double E) const;
 
   // Data members
   std::string name_; //! Name of nuclide, e.g. "U235"
@@ -38,6 +54,7 @@ public:
   int metastable_; //! Metastable state
   double awr_; //! Atomic weight ratio
   std::vector<double> kTs_; //! temperatures in eV (k*T)
+  std::vector<EnergyGrid> grid_; //! Energy grid at each temperature
 
   bool fissionable_ {false}; //! Whether nuclide is fissionable
   bool has_partial_fission_ {false}; //! has partial fission reactions?
@@ -45,7 +62,14 @@ public:
   int n_precursor_ {0}; //! Number of delayed neutron precursors
   std::unique_ptr<Function1D> total_nu_; //! Total neutron yield
 
+  // Resonance scattering information
+  bool resonant_ {false};
+  std::vector<double> energy_0K_;
+  std::vector<double> elastic_0K_;
+  std::vector<double> xs_cdf_;
+
   std::vector<std::unique_ptr<Reaction>> reactions_; //! Reactions
+  std::vector<int> index_inelastic_scatter_;
 
 private:
   void create_derived();

include/openmc/physics.h

@@ -2,6 +2,7 @@
 #define OPENMC_PHYSICS_H
 
 #include "openmc/bank.h"
+#include "openmc/nuclide.h"
 #include "openmc/particle.h"
 #include "openmc/position.h"
 #include "openmc/reaction.h"
@@ -51,22 +52,33 @@ void sample_photon_product(int i_nuclide, double E, int* i_rx, int* i_product);
 
 void absorption(Particle* p, int i_nuclide);
 
-extern "C" void scatter(Particle*, int i_nuclide, int i_nuc_mat);
+void scatter(Particle*, int i_nuclide, int i_nuc_mat);
 
-// void elastic_scatter(int i_nuclide, const Reaction& rx, double kT, double* E,
-//   Direction* u, double* mu_lab, double* wgt);
+//! Treats the elastic scattering of a neutron with a target.
+void elastic_scatter(int i_nuclide, const Reaction* rx, double kT, double* E,
+  double* uvw, double* mu_lab, double* wgt);
 
-// void sab_scatter(int i_nuclide, int i_sab, double* E, Direction* u, double* mu);
+extern "C" void sab_scatter(int i_nuclide, int i_sab, double* E,
+  double* uvw, double* mu);
 
-// void sample_target_velocity(int i_nuclide, Direction* v_target, double E, Direction u,
-//   Direction v_neut, double* wgt, double xs_eff, double kT);
+//! samples the target velocity. The constant cross section free gas model is
+//! the default method. Methods for correctly accounting for the energy
+//! dependence of cross sections in treating resonance elastic scattering such
+//! as the DBRC, WCM, and a new, accelerated scheme are also implemented here.
+Direction sample_target_velocity(const Nuclide* nuc, double E, Direction u,
+   Direction v_neut, double xs_eff, double kT, double* wgt);
 
-// void sample_cxs_target_velocity(int i_nuclide, Direction* v_target, double E, Direction u,
-//   double kT);
+//! samples a target velocity based on the free gas scattering formulation, used
+//! by most Monte Carlo codes, in which cross section is assumed to be constant
+//! in energy. Excellent documentation for this method can be found in
+//! FRA-TM-123.
+Direction sample_cxs_target_velocity(double awr, double E, Direction u, double kT);
 
 void sample_fission_neutron(int i_nuclide, const Reaction* rx, double E_in, Bank* site);
 
-// void inelastic_scatter(int i_nuclide, const Reaction& rx, Particle* p);
+//! handles all reactions with a single secondary neutron (other than fission),
+//! i.e. level scattering, (n,np), (n,na), etc.
+void inelastic_scatter(const Nuclide* nuc, const Reaction* rx, Particle* p);
 
 void sample_secondary_photons(Particle* p, int i_nuclide);
 

include/openmc/position.h

@@ -25,6 +25,8 @@ struct Position {
   Position& operator-=(double);
   Position& operator*=(Position);
   Position& operator*=(double);
+  Position& operator/=(Position);
+  Position& operator/=(double);
 
   const double& operator[](int i) const {
     switch (i) {
@@ -76,6 +78,10 @@ inline Position operator*(Position a, Position b) { return a *= b; }
 inline Position operator*(Position a, double b)   { return a *= b; }
 inline Position operator*(double a, Position b)   { return b *= a; }
 
+inline Position operator/(Position a, Position b) { return a /= b; }
+inline Position operator/(Position a, double b)   { return a /= b; }
+inline Position operator/(double a, Position b)   { return b /= a; }
+
 inline bool operator==(Position a, Position b)
 {return a.x == b.x && a.y == b.y && a.z == b.z;}