Merge pull request #206 from njoy/fix/mf32mt151-njsx

Fix/mf32mt151 njsx

Author: whaeck

ReleaseNotes.md

@@ -8,6 +8,7 @@ In addition, the following issues were corrected:
   - A minor bug in the rectangular matrix covariance block was corrected. The values for the row and column energies are lifted out of a larger array using the std::ranges::take and std::ranges::drop function. For the column energies, we forgot to properly end the sequence. As a result, the end() iterator of the range did not point to the end of the column energies but to the end of the covariance values, which is now corrected.
   - In MF8 MT457 DiscreteSpectrum, NT=8 (which can occur for electrons, i.e. STYP=8), was explicitly disallowed by ENDFtk. This was corrected and a new constructor reflecting this usage was added as well.
   - The STA variable in MF1 MT451 was interpreted incorrectly and this has now been fixed. An additional isUnstable() function has been added to the interface.
+  - The NJSX value (the number of spin groups) is now read from the CONT record before the particle pairs in MF32 R-matrix limited uncertainties since SAMMY does not print the NJSX value on the particle pairs (the ENDF format basically has the NJSX value appear in two places and ENDFtk used the second one while SAMMY only prints out the first one). This "breaks" some interface functions (the R-matrix limited uncertainties from_string() function now requires the number of spin groups while previously it did not).
 
 A few changes were also made to remove some range-v3 code in MF1 MT451. These changes have no impact on functionality.
 

python/src/definitions.hpp

@@ -99,15 +99,15 @@ void addStandardTableDefinitions( PythonClass& component ) {
 }
 
 /**
- *  @brief Add standard component definitions
+ *  @brief Add standard component definitions (excluding reading)
  *
  *  This adds the following standard properties:
- *    NC, from_string, to_string
+ *    copy constructor, NC, to_string
  *
  *  @param[in] component   the section to which the definitions have to be added
  */
 template < typename Component, typename PythonClass >
-void addStandardComponentDefinitions( PythonClass& component ) {
+void addStandardComponentDefinitionsWithoutReading( PythonClass& component ) {
 
   component
   .def(
@@ -125,6 +125,35 @@ void addStandardComponentDefinitions( PythonClass& component ) {
     [] ( const Component& self ) { return self.NC(); },
     "The number of lines in this component"
   )
+  .def(
+
+    "to_string",
+    [] ( const Component& self, int mat, int mf, int mt ) -> std::string
+       { return print( self, mat, mf, mt ); },
+    python::arg( "mat" ), python::arg( "mf" ), python::arg( "mt" ),
+    "Return the string representation of the component\n\n"
+    "Arguments:\n"
+    "    self    the component\n"
+    "    mat     the MAT number to be used\n"
+    "    mf      the MF number to be used\n"
+    "    mt      the MT number to be used"
+  );
+}
+
+/**
+ *  @brief Add standard component definitions
+ *
+ *  This adds the following standard properties:
+ *    NC, from_string, to_string
+ *
+ *  @param[in] component   the section to which the definitions have to be added
+ */
+template < typename Component, typename PythonClass >
+void addStandardComponentDefinitions( PythonClass& component ) {
+
+  addStandardComponentDefinitionsWithoutReading< Component >( component );
+
+  component
   .def_static(
 
     "from_string",
@@ -140,19 +169,6 @@ void addStandardComponentDefinitions( PythonClass& component ) {
     "    mat       the MAT number of the section\n"
     "    mf        the MF number of the section\n"
     "    mt        the MT number of the section"
-  )
-  .def(
-
-    "to_string",
-    [] ( const Component& self, int mat, int mf, int mt ) -> std::string
-       { return print( self, mat, mf, mt ); },
-    python::arg( "mat" ), python::arg( "mf" ), python::arg( "mt" ),
-    "Return the string representation of the component\n\n"
-    "Arguments:\n"
-    "    self    the component\n"
-    "    mat     the MAT number to be used\n"
-    "    mf      the MF number to be used\n"
-    "    mt      the MT number to be used"
   );
 }
 

python/src/section/32/151/CompactRMatrixLimitedUncertainties.python.cpp

@@ -75,10 +75,34 @@ void wrapCompactRMatrixLimitedUncertainties( python::module& module, python::mod
     [] ( const Component& self ) -> SpinGroupRange
        { return self.spinGroups(); },
     "The spin groups"
+  )
+  .def_static(
+
+    "from_string",
+    [] ( const std::string& string, int mat, int mf, int mt, int njsx ) -> Component {
+
+      auto begin = string.begin();
+      auto end = string.end();
+      long lineNumber = 1;
+
+      return Component( begin, end, lineNumber, mat, mf, mt, njsx );
+    },
+    python::arg( "string" ), python::arg( "mat" ),
+    python::arg( "mf" ), python::arg( "mt" ),
+    python::arg( "njsx" ),
+    "Read the component from a string\n\n"
+    "An exception is raised if something goes wrong while reading the\n"
+    "component\n\n"
+    "Arguments:\n"
+    "    string    the string representing the component\n"
+    "    mat       the MAT number of the section\n"
+    "    mf        the MF number of the section\n"
+    "    mt        the MT number of the section\n"
+    "    njsx      the number of spin groups"
   );
 
   // add standard component definitions
-  addStandardComponentDefinitions< Component >( component );
+  addStandardComponentDefinitionsWithoutReading< Component >( component );
 }
 
 } // namespace mf32

python/test/MF32/MT151/Test_ENDFtk_MF32_MT151_CompactRMatrixLimitedUncertainties.py

@@ -420,7 +420,7 @@ def verify_chunk( self, chunk ) :
         verify_chunk( self, chunk )
 
         # the data is read from a string
-        chunk = CompactRMatrixLimitedUncertainties.from_string( self.chunk, 2625, 32, 151 )
+        chunk = CompactRMatrixLimitedUncertainties.from_string( self.chunk, 2625, 32, 151, 2 )
 
         verify_chunk( self, chunk )
 

src/ENDFtk/section/32/151/CompactBreitWignerUncertainties/src/ctor.hpp

@@ -72,3 +72,22 @@ CompactBreitWignerUncertainties( Iterator& it, const Iterator& end, long& lineNu
                                  int MAT, int MF, int MT ) :
    // no try ... catch: exceptions will be handled in the derived class
   CompactBreitWignerUncertainties( ListRecord( it, end, lineNumber, MAT, MF, MT ) ) {}
+
+/**
+ *  @brief Constructor (from a buffer)
+ *
+ *  @tparam Iterator        a buffer iterator
+ *
+ *  @param[in] it           the current position in the buffer
+ *  @param[in] end          the end of the buffer
+ *  @param[in] lineNumber   the current line number
+ *  @param[in] MAT          the expected MAT number
+ *  @param[in] MF           the expected MF number
+ *  @param[in] MT           the expected MT number
+ *  @param[in] unused       placeholder
+ */
+template< typename Iterator >
+CompactBreitWignerUncertainties( Iterator& it, const Iterator& end, long& lineNumber,
+                                 int MAT, int MF, int MT, int /* unused */ ) :
+   // no try ... catch: exceptions will be handled in the derived class
+  CompactBreitWignerUncertainties( it, end, lineNumber, MAT, MF, MT ) {}

src/ENDFtk/section/32/151/CompactCovarianceBase/src/ctor.hpp

@@ -84,7 +84,7 @@ CompactCovarianceBase( double spi, double ap, long l1, long n1,
   // no try ... catch: exceptions will be handled in the derived class
   CompactCovarianceBase( spi, ap, l1, n1, std::move( dap ),
                          ResonanceParameterUncertainties( it, end, lineNumber,
-                                                          MAT, MF, MT ),
+                                                          MAT, MF, MT, n1 ),
                          it, end, lineNumber, MAT, MF, MT ) {}
 
 /**

src/ENDFtk/section/32/151/CompactRMatrixLimitedUncertainties/src/ctor.hpp

@@ -29,10 +29,10 @@ template< typename Iterator >
 CompactRMatrixLimitedUncertainties(
     ParticlePairs&& pairs,
     Iterator& it, const Iterator& end, long& lineNumber,
-    int MAT, int MF, int MT ) :
+    int MAT, int MF, int MT, int NJSX ) :
   CompactRMatrixLimitedUncertainties(
     std::move( pairs ),
-    readSequence< SpinGroup >( it, end, lineNumber, MAT, MF, MT, pairs.NJSX() ) ) {}
+    readSequence< SpinGroup >( it, end, lineNumber, MAT, MF, MT, NJSX ) ) {}
 
 public:
 /**
@@ -46,14 +46,15 @@ CompactRMatrixLimitedUncertainties(
  *  @param[in] MAT          the expected MAT number
  *  @param[in] MF           the expected MF number
  *  @param[in] MT           the expected MT number
+ *  @param[in] NJSX         the number of spin groups to be read
  */
 template< typename Iterator >
 CompactRMatrixLimitedUncertainties(
     Iterator& it, const Iterator& end, long& lineNumber,
-    int MAT, int MF, int MT )
+    int MAT, int MF, int MT, int NJSX )
   try : CompactRMatrixLimitedUncertainties(
             ParticlePairs( it, end, lineNumber, MAT, MF, MT ),
-            it, end, lineNumber, MAT, MF, MT ) {}
+            it, end, lineNumber, MAT, MF, MT, NJSX ) {}
   catch ( std::exception& e ) {
 
     Log::info( "Encountered error while constructing R matrix limited "

src/ENDFtk/section/32/151/CompactRMatrixLimitedUncertainties/test/CompactRMatrixLimitedUncertainties.test.cpp

@@ -76,7 +76,7 @@ SCENARIO( "CompactRMatrixLimitedUncertainties" ) {
       long lineNumber = 1;
 
       CompactRMatrixLimitedUncertainties chunk( begin, end, lineNumber,
-                                                2625, 32, 151 );
+                                                2625, 32, 151, 2 );
 
       THEN( "an CompactRMatrixLimitedUncertainties can be constructed and members can be "
             "tested" ) {
@@ -125,7 +125,7 @@ SCENARIO( "CompactRMatrixLimitedUncertainties" ) {
       THEN( "an exception is thrown" ) {
 
         CHECK_THROWS( CompactRMatrixLimitedUncertainties( begin, end, lineNumber,
-                                                          2625, 2, 151 ) );
+                                                          2625, 2, 151, 0 ) );
       } // THEN
     } // WHEN
   } // GIVEN

src/ENDFtk/section/32/151/CompactReichMooreUncertainties/src/ctor.hpp

@@ -74,3 +74,22 @@ CompactReichMooreUncertainties( Iterator& it, const Iterator& end, long& lineNum
                    int MAT, int MF, int MT ) :
    // no try ... catch: exceptions will be handled in the derived class
   CompactReichMooreUncertainties( ListRecord( it, end, lineNumber, MAT, MF, MT ) ) {}
+
+/**
+ *  @brief Constructor (from a buffer)
+ *
+ *  @tparam Iterator        a buffer iterator
+ *
+ *  @param[in] it           the current position in the buffer
+ *  @param[in] end          the end of the buffer
+ *  @param[in] lineNumber   the current line number
+ *  @param[in] MAT          the expected MAT number
+ *  @param[in] MF           the expected MF number
+ *  @param[in] MT           the expected MT number
+ *  @param[in] unused       placeholder
+ */
+template< typename Iterator >
+CompactReichMooreUncertainties( Iterator& it, const Iterator& end, long& lineNumber,
+                   int MAT, int MF, int MT, int /* unused */ ) :
+   // no try ... catch: exceptions will be handled in the derived class
+  CompactReichMooreUncertainties( it, end, lineNumber, MAT, MF, MT ) {}