Adding additional interface functions for mf10

njoy · Dec 1, 2023 · 62eeb96 · 62eeb96
1 parent 3dfa4f2
commit 62eeb96
Show file tree

Hide file tree

Showing 4 changed files with 179 additions and 0 deletions.
diff --git a/python/src/section/10.python.cpp b/python/src/section/10.python.cpp
@@ -81,6 +81,26 @@ void wrapSection_10( python::module& module, python::module& viewmodule ) {
     &Section::numberReactionProducts,
     "The number of excited states for the reaction product"
   )
+  .def(
+
+    "has_excited_state",
+    &Section::hasExcitedState,
+    python::arg( "state" ),
+    "Return whether or not the excited state is present\n\n"
+    "Arguments:\n"
+    "    self    the section\n"
+    "    state   the excited state to retrieve"
+  )
+  .def(
+
+    "reaction_product",
+    &Section::reactionProduct,
+    python::arg( "state" ),
+    "Return the reaction product for the requested excited state\n\n"
+    "Arguments:\n"
+    "    self    the section\n"
+    "    state   the excited state to retrieve"
+  )
   .def_property_readonly(
 
     "reaction_products",

diff --git a/python/test/MF10/Test_ENDFtk_MF10_Section.py b/python/test/MF10/Test_ENDFtk_MF10_Section.py
@@ -98,6 +98,69 @@ def verify_chunk( self, chunk ) :
             self.assertAlmostEqual( 0.1, product.cross_sections[0] )
             self.assertAlmostEqual( 0.48, product.cross_sections[1] )
 
+            self.assertEqual( True, chunk.has_excited_state( 0 ) )
+            product = chunk.reaction_product( 0 )
+            self.assertAlmostEqual( 5.537755e+6, product.QM )
+            self.assertAlmostEqual( 5.537755e+6, product.mass_difference_qvalue )
+            self.assertAlmostEqual( 5.537755e+6, product.QI )
+            self.assertAlmostEqual( 5.537755e+6, product.reaction_qvalue )
+            self.assertEqual( 95242, product.IZAP )
+            self.assertEqual( 95242, product.product_identifier )
+            self.assertEqual( 0, product.LFS )
+            self.assertEqual( 0, product.excited_level )
+            self.assertEqual( 2, product.NP )
+            self.assertEqual( 1, product.NR )
+            self.assertEqual( 1, len( product.interpolants ) )
+            self.assertEqual( 1, len( product.boundaries ) )
+            self.assertEqual( 3, product.interpolants[0] )
+            self.assertEqual( 2, product.boundaries[0] )
+            self.assertEqual( 2, len( product.E ) )
+            self.assertEqual( 2, len( product.energies ) )
+            self.assertEqual( 2, len( product.XS ) )
+            self.assertEqual( 2, len( product.cross_sections ) )
+            self.assertAlmostEqual( 1e-5, product.E[0] )
+            self.assertAlmostEqual( 3e+7, product.E[1] )
+            self.assertAlmostEqual( 1e-5, product.energies[0] )
+            self.assertAlmostEqual( 3e+7, product.energies[1] )
+            self.assertAlmostEqual( 0.9, product.XS[0] )
+            self.assertAlmostEqual( 0.52, product.XS[1] )
+            self.assertAlmostEqual( 0.9, product.cross_sections[0] )
+            self.assertAlmostEqual( 0.52, product.cross_sections[1] )
+
+            self.assertEqual( True, chunk.has_excited_state( 2 ) )
+            with self.assertRaises( Exception ) :
+
+                product = chunk.reaction_product( 1 )
+
+            self.assertEqual( True, chunk.has_excited_state( 2 ) )
+            product = chunk.reaction_product( 2 )
+            self.assertAlmostEqual( 5.537755e+6, product.QM )
+            self.assertAlmostEqual( 5.537755e+6, product.mass_difference_qvalue )
+            self.assertAlmostEqual( 5.489125e+6, product.QI )
+            self.assertAlmostEqual( 5.489125e+6, product.reaction_qvalue )
+            self.assertEqual( 95242, product.IZAP )
+            self.assertEqual( 95242, product.product_identifier )
+            self.assertEqual( 2, product.LFS )
+            self.assertEqual( 2, product.excited_level )
+            self.assertEqual( 2, product.NP )
+            self.assertEqual( 1, product.NR )
+            self.assertEqual( 1, len( product.interpolants ) )
+            self.assertEqual( 1, len( product.boundaries ) )
+            self.assertEqual( 3, product.interpolants[0] )
+            self.assertEqual( 2, product.boundaries[0] )
+            self.assertEqual( 2, len( product.E ) )
+            self.assertEqual( 2, len( product.energies ) )
+            self.assertEqual( 2, len( product.XS ) )
+            self.assertEqual( 2, len( product.cross_sections ) )
+            self.assertAlmostEqual( 1e-5, product.E[0] )
+            self.assertAlmostEqual( 3e+7, product.E[1] )
+            self.assertAlmostEqual( 1e-5, product.energies[0] )
+            self.assertAlmostEqual( 3e+7, product.energies[1] )
+            self.assertAlmostEqual( 0.1, product.XS[0] )
+            self.assertAlmostEqual( 0.48, product.XS[1] )
+            self.assertAlmostEqual( 0.1, product.cross_sections[0] )
+            self.assertAlmostEqual( 0.48, product.cross_sections[1] )
+
             self.assertEqual( 7, chunk.NC )
 
             # verify string

diff --git a/src/ENDFtk/section/10.hpp b/src/ENDFtk/section/10.hpp
@@ -59,6 +59,41 @@ namespace section {
      */
     int numberReactionProducts() const { return this->NS(); }
 
+    /**
+     *  @brief Return whether or not the excited state is present
+     *
+     *  @param[in] state    the excited state to retrieve
+     */
+    bool hasExcitedState( int state ) const {
+
+      return std::find_if( this->products_.begin(), this->products_.end(),
+                           [state] ( auto&& product )
+                                   { return product.excitedLevel() == state; } )
+             != this->products_.end();
+    }
+
+    /**
+     *  @brief Return the reaction product for the requested excited state
+     *
+     *  @param[in] state    the excited state to retrieve
+     */
+    const ReactionProduct& reactionProduct( int state ) const {
+
+      auto iter = std::find_if( this->products_.begin(), this->products_.end(),
+                                [state] ( auto&& product )
+                                        { return product.excitedLevel() == state; } );
+      if ( this->products_.end() == iter ) {
+
+        Log::error( "The requested excited state {} is not present in MF10",
+                    state );
+        throw std::exception();
+      }
+      else {
+
+        return *iter;
+      }
+    }
+
     /**
      *  @brief Return the reaction product data
      */

diff --git a/src/ENDFtk/section/10/test/10.test.cpp b/src/ENDFtk/section/10/test/10.test.cpp
@@ -206,6 +206,67 @@ void verifyChunk( const section::Type< 10 >& chunk ) {
   CHECK_THAT( 0.1, WithinRel( product.crossSections()[0] ) );
   CHECK_THAT( 0.48, WithinRel( product.crossSections()[1] ) );
 
+  CHECK( true == chunk.hasExcitedState( 0 ) );
+  product = chunk.reactionProduct( 0 );
+  CHECK_THAT( 5.537755e+6, WithinRel( product.QM() ) );
+  CHECK_THAT( 5.537755e+6, WithinRel( product.massDifferenceQValue() ) );
+  CHECK_THAT( 5.537755e+6, WithinRel( product.QI() ) );
+  CHECK_THAT( 5.537755e+6, WithinRel( product.reactionQValue() ) );
+  CHECK( 95242 == product.IZAP() );
+  CHECK( 95242 == product.productIdentifier() );
+  CHECK( 0 == product.LFS() );
+  CHECK( 0 == product.excitedLevel() );
+  CHECK( 2 == product.NP() );
+  CHECK( 1 == product.NR() );
+  CHECK( 1 == product.interpolants().size() );
+  CHECK( 1 == product.boundaries().size() );
+  CHECK( 3 == product.interpolants()[0] );
+  CHECK( 2 == product.boundaries()[0] );
+  CHECK( 2 == product.E().size() );
+  CHECK( 2 == product.energies().size() );
+  CHECK( 2 == product.XS().size() );
+  CHECK( 2 == product.crossSections().size() );
+  CHECK_THAT( 1e-5, WithinRel( product.E()[0] ) );
+  CHECK_THAT( 3e+7, WithinRel( product.E()[1] ) );
+  CHECK_THAT( 1e-5, WithinRel( product.energies()[0] ) );
+  CHECK_THAT( 3e+7, WithinRel( product.energies()[1] ) );
+  CHECK_THAT( 0.9, WithinRel( product.XS()[0] ) );
+  CHECK_THAT( 0.52, WithinRel( product.XS()[1] ) );
+  CHECK_THAT( 0.9, WithinRel( product.crossSections()[0] ) );
+  CHECK_THAT( 0.52, WithinRel( product.crossSections()[1] ) );
+
+  CHECK( false == chunk.hasExcitedState( 1 ) );
+  CHECK_THROWS( product = chunk.reactionProduct( 1 ) );
+
+  CHECK( true == chunk.hasExcitedState( 2 ) );
+  product = chunk.reactionProduct( 2 );
+  CHECK_THAT( 5.537755e+6, WithinRel( product.QM() ) );
+  CHECK_THAT( 5.537755e+6, WithinRel( product.massDifferenceQValue() ) );
+  CHECK_THAT( 5.489125e+6, WithinRel( product.QI() ) );
+  CHECK_THAT( 5.489125e+6, WithinRel( product.reactionQValue() ) );
+  CHECK( 95242 == product.IZAP() );
+  CHECK( 95242 == product.productIdentifier() );
+  CHECK( 2 == product.LFS() );
+  CHECK( 2 == product.excitedLevel() );
+  CHECK( 2 == product.NP() );
+  CHECK( 1 == product.NR() );
+  CHECK( 1 == product.interpolants().size() );
+  CHECK( 1 == product.boundaries().size() );
+  CHECK( 3 == product.interpolants()[0] );
+  CHECK( 2 == product.boundaries()[0] );
+  CHECK( 2 == product.E().size() );
+  CHECK( 2 == product.energies().size() );
+  CHECK( 2 == product.XS().size() );
+  CHECK( 2 == product.crossSections().size() );
+  CHECK_THAT( 1e-5, WithinRel( product.E()[0] ) );
+  CHECK_THAT( 3e+7, WithinRel( product.E()[1] ) );
+  CHECK_THAT( 1e-5, WithinRel( product.energies()[0] ) );
+  CHECK_THAT( 3e+7, WithinRel( product.energies()[1] ) );
+  CHECK_THAT( 0.1, WithinRel( product.XS()[0] ) );
+  CHECK_THAT( 0.48, WithinRel( product.XS()[1] ) );
+  CHECK_THAT( 0.1, WithinRel( product.crossSections()[0] ) );
+  CHECK_THAT( 0.48, WithinRel( product.crossSections()[1] ) );
+
   CHECK( 7 == chunk.NC() );
 }