Added Legendre and tabulated angular distribution components

CMakeLists.txt

@@ -200,6 +200,8 @@ pybind11_add_module( ENDFtk.python
     python/src/section/14.python.cpp
     python/src/section/14/Isotropic.python.cpp
     python/src/section/14/IsotropicDiscretePhoton.python.cpp
+    python/src/section/14/LegendreCoefficients.python.cpp
+    python/src/section/14/TabulatedDistribution.python.cpp
     python/src/file/1.python.cpp
     python/src/file/2.python.cpp
     python/src/file/3.python.cpp

cmake/unit_testing.cmake

@@ -62,6 +62,8 @@ add_subdirectory( src/ENDFtk/section/13/TotalCrossSection/test )
 add_subdirectory( src/ENDFtk/section/13/test )
 add_subdirectory( src/ENDFtk/section/14/Isotropic/test )
 add_subdirectory( src/ENDFtk/section/14/IsotropicDiscretePhoton/test )
+add_subdirectory( src/ENDFtk/section/14/LegendreCoefficients/test )
+add_subdirectory( src/ENDFtk/section/14/TabulatedDistribution/test )
 add_subdirectory( src/ENDFtk/section/2/151/BreitWignerLValue/Resonance/test )
 add_subdirectory( src/ENDFtk/section/2/151/BreitWignerLValue/test )
 add_subdirectory( src/ENDFtk/section/2/151/Isotope/test )

python/src/file/14.python.cpp

@@ -16,8 +16,8 @@ void wrapSection_14( python::module&, python::module& );
 void wrapFile_14( python::module& module, python::module& viewmodule ) {
 
   // type aliases
-  using Section = njoy::ENDFtk::section::Type< 4 >;
-  using File = njoy::ENDFtk::file::Type< 4 >;
+  using Section = njoy::ENDFtk::section::Type< 14 >;
+  using File = njoy::ENDFtk::file::Type< 14 >;
   using SectionRange = BidirectionalAnyView< Section >;
 
   // create the submodule

python/src/section/14.python.cpp

@@ -15,6 +15,8 @@ namespace mf14 {
 
   void wrapIsotropic( python::module&, python::module& );
   void wrapIsotropicDiscretePhoton( python::module&, python::module& );
+  void wrapLegendreCoefficients( python::module&, python::module& );
+  void wrapTabulatedDistribution( python::module&, python::module& );
 }
 
 void wrapSection_14( python::module& module, python::module& viewmodule ) {
@@ -24,6 +26,8 @@ void wrapSection_14( python::module& module, python::module& viewmodule ) {
   // wrap components
   mf14::wrapIsotropic( module, viewmodule );
   mf14::wrapIsotropicDiscretePhoton( module, viewmodule );
+  mf14::wrapLegendreCoefficients( module, viewmodule );
+  mf14::wrapTabulatedDistribution( module, viewmodule );
 
   // wrap views created by this section
 

python/src/section/14/LegendreCoefficients.python.cpp

@@ -0,0 +1,88 @@
+// system includes
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+// local includes
+#include "ENDFtk/section/14.hpp"
+#include "definitions.hpp"
+#include "views.hpp"
+
+// namespace aliases
+namespace python = pybind11;
+
+namespace mf14 {
+
+void wrapLegendreCoefficients( python::module& module, python::module& ) {
+
+  // type aliases
+  using Section = njoy::ENDFtk::section::Type< 14 >;
+  using Component = Section::LegendreCoefficients;
+
+  // wrap views created by this section
+
+  // create the component
+  python::class_< Component > component(
+
+    module,
+    "LegendreCoefficients",
+    "MF14 section - an angular distribution given as Legendre coefficients"
+  );
+
+  // wrap the section
+  component
+  .def(
+
+    python::init< double, std::vector< double >&& >(),
+    python::arg( "energy" ), python::arg( "coefficients" ),
+    "Initialise the component\n\n"
+    "Arguments:\n"
+    "    self            the component\n"
+    "    energy          the incident energy\n"
+    "    coefficients    the Legendre coefficients"
+  )
+  .def_property_readonly(
+
+    "E",
+    &Component::E,
+    "The incident energy for which the angular distribution is given"
+  )
+  .def_property_readonly(
+
+    "incident_energy",
+    &Component::incidentEnergy,
+    "The incident energy for which the angular distribution is given"
+  )
+  .def_property_readonly(
+
+    "NL",
+    &Component::NL,
+    "The Legendre order for the angular distribution"
+  )
+  .def_property_readonly(
+
+    "legendre_order",
+    &Component::legendreOrder,
+    "The Legendre order for the angular distribution"
+  )
+  .def_property_readonly(
+
+    "A",
+    [] ( const Component& self ) -> DoubleRange
+       { return self.A(); },
+    "The Legendre coefficients in the distribution (a0 is not present and\n"
+    "assumed to be equal to 1)"
+  )
+  .def_property_readonly(
+
+    "coefficients",
+    [] ( const Component& self ) -> DoubleRange
+       { return self.coefficients(); },
+    "The Legendre coefficients in the distribution (a0 is not present and\n"
+    "assumed to be equal to 1)"
+  );
+
+  // add standard component definitions
+  addStandardComponentDefinitions< Component >( component );
+}
+
+} // namespace mf14

python/src/section/14/TabulatedDistribution.python.cpp

@@ -0,0 +1,97 @@
+// system includes
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+// local includes
+#include "ENDFtk/section/14.hpp"
+#include "definitions.hpp"
+#include "views.hpp"
+
+// namespace aliases
+namespace python = pybind11;
+
+namespace mf14 {
+
+void wrapTabulatedDistribution( python::module& module, python::module& ) {
+
+  // type aliases
+  using Section = njoy::ENDFtk::section::Type< 14 >;
+  using Component = Section::TabulatedDistribution;
+
+  // wrap views created by this section
+
+  // create the component
+  python::class_< Component > component(
+
+    module,
+    "TabulatedDistribution",
+    "MF14 section - an angular distribution given as a tabulated function"
+  );
+
+  // wrap the section
+  component
+  .def(
+
+    python::init< double, std::vector< long >&&, std::vector< long >&&,
+                  std::vector< double >&&, std::vector< double >&& >(),
+    python::arg( "energy" ), python::arg( "boundaries" ),
+    python::arg( "interpolants" ), python::arg( "cosines" ),
+    python::arg( "probabilities" ),
+    "Initialise the component\n\n"
+    "Arguments:\n"
+    "    self             the component\n"
+    "    incident         the incident energy value\n"
+    "    boundaries       the interpolation range boundaries\n"
+    "    interpolants     the interpolation types for each range\n"
+    "    cosines          the cosine values\n"
+    "    probabilities    the probability values"
+  )
+  .def_property_readonly(
+
+    "E",
+    &Component::E,
+    "The incident energy for which the angular distribution is given"
+  )
+  .def_property_readonly(
+
+    "incident_energy",
+    &Component::incidentEnergy,
+    "The incident energy for which the angular distribution is given"
+  )
+  .def_property_readonly(
+
+    "MU",
+    [] ( const Component& self ) -> DoubleRange
+       { return self.MU(); },
+    "The cosine values"
+  )
+  .def_property_readonly(
+
+    "cosines",
+    [] ( const Component& self ) -> DoubleRange
+       { return self.cosines(); },
+    "The cosine values"
+  )
+  .def_property_readonly(
+
+    "F",
+    [] ( const Component& self ) -> DoubleRange
+       { return self.F(); },
+    "The distribution probabilities"
+  )
+  .def_property_readonly(
+
+    "probabilities",
+    [] ( const Component& self ) -> DoubleRange
+       { return self.probabilities(); },
+    "The distribution probabilities"
+  );
+
+  // add standard tab1 definitions
+  addStandardTableDefinitions< Component >( component );
+
+  // add standard component definitions
+  addStandardComponentDefinitions< Component >( component );
+}
+
+} // namespace mf14

python/test/Test_ENDFtk_MF14_LegendreCoefficients.py

@@ -0,0 +1,68 @@
+# standard imports
+import unittest
+
+# third party imports
+
+# local imports
+from ENDFtk.MF14 import LegendreCoefficients
+
+class Test_ENDFtk_MF14_LegendreCoefficients( unittest.TestCase ) :
+    """Unit test for the LegendreCoefficients class."""
+
+    chunk = ( ' 0.000000+0 1.000000-5          0          0          3          0922814  2     \n'
+              ' 7.392510-5 8.477139-9 1.17106-13                                 922814  2     \n' )
+
+    invalid = ( ' 0.000000+0 1.000000-5          0          0          2          0922814  2     \n'
+                ' 7.392510-5 8.477139-9 1.17106-13                                 922814  2     \n' )
+
+    def test_component( self ) :
+
+        def verify_chunk( self, chunk ) :
+
+            # verify content
+            self.assertAlmostEqual( 1e-5, chunk.E )
+            self.assertAlmostEqual( 1e-5, chunk.incident_energy )
+            self.assertEqual( 3, chunk.NL )
+            self.assertEqual( 3, chunk.legendre_order )
+            self.assertEqual( 3, len( chunk.A ) )
+            self.assertEqual( 3, len( chunk.coefficients ) )
+            self.assertAlmostEqual( 7.392510e-5 , chunk.A[0] )
+            self.assertAlmostEqual( 8.477139e-9, chunk.A[1] )
+            self.assertAlmostEqual( 1.17106e-13, chunk.A[2] )
+            self.assertAlmostEqual( 7.392510e-5 , chunk.coefficients[0] )
+            self.assertAlmostEqual( 8.477139e-9, chunk.coefficients[1] )
+            self.assertAlmostEqual( 1.17106e-13, chunk.coefficients[2] )
+
+            self.assertEqual( 2, chunk.NC )
+
+            # verify string
+            self.assertEqual( self.chunk, chunk.to_string( 9228, 14, 2 ) )
+
+        # the data is given explicitly
+        chunk = LegendreCoefficients( energy = 1e-5,
+                                      coefficients = [ 7.392510e-5, 8.477139e-9,
+                                                       1.17106e-13 ] )
+
+        verify_chunk( self, chunk )
+
+        # the data is read from a string
+        chunk = LegendreCoefficients.from_string( self.chunk, 9228, 14, 2 )
+
+        verify_chunk( self, chunk )
+
+        # the data is copied
+        copy = LegendreCoefficients( chunk )
+
+        verify_chunk( self, copy )
+
+    def test_failures( self ) :
+
+        print( '\n' )
+
+        with self.assertRaises( Exception ) :
+
+            chunk = LegendreCoefficients.from_string( self.invalid, 9228, 14, 2 )
+
+if __name__ == '__main__' :
+
+    unittest.main()

python/test/Test_ENDFtk_MF14_TabulatedDistribution.py

@@ -0,0 +1,88 @@
+# standard imports
+import unittest
+
+# third party imports
+
+# local imports
+from ENDFtk.MF14 import TabulatedDistribution
+
+class Test_ENDFtk_MF4_TabulatedDistribution( unittest.TestCase ) :
+    """Unit test for the TabulatedDistribution class."""
+
+    chunk = ( ' 0.000000+0 1.000000-5          0          0          1          3922814  2     \n'
+              '          3          2                                            922814  2     \n'
+              '-1.000000+0 0.000000+0 0.000000+0 1.000000+0 1.000000+0 0.000000+0922814  2     \n' )
+
+    invalid = ( ' 0.000000+0 1.000000-5          0          0          2          3922814  2     \n'
+                '          3          2                                            922814  2     \n'
+                '-1.000000+0 0.000000+0 0.000000+0 1.000000+0 1.000000+0 0.000000+0922814  2     \n' )
+
+    def test_component( self ) :
+
+        def verify_chunk( self, chunk ) :
+
+            # verify content
+            self.assertAlmostEqual( 1e-5, chunk.E )
+            self.assertAlmostEqual( 1e-5, chunk.incident_energy )
+            self.assertEqual( 3, chunk.NP )
+            self.assertEqual( 1, chunk.NR )
+            self.assertEqual( 1, len( chunk.boundaries ) )
+            self.assertEqual( 1, len( chunk.interpolants ) )
+            self.assertEqual( 3, chunk.boundaries[0] )
+            self.assertEqual( 2, chunk.interpolants[0] )
+            self.assertEqual( 3, len( chunk.cosines ) )
+            self.assertAlmostEqual( -1.0 , chunk.MU[0] )
+            self.assertAlmostEqual( 0.0, chunk.MU[1] )
+            self.assertAlmostEqual( 1.0, chunk.MU[2] )
+            self.assertAlmostEqual( -1.0 , chunk.cosines[0] )
+            self.assertAlmostEqual( 0.0, chunk.cosines[1] )
+            self.assertAlmostEqual( 1.0, chunk.cosines[2] )
+            self.assertEqual( 3, len( chunk.probabilities ) )
+            self.assertAlmostEqual( 0.0 , chunk.F[0] )
+            self.assertAlmostEqual( 1.0, chunk.F[1] )
+            self.assertAlmostEqual( 0.0, chunk.F[2] )
+            self.assertAlmostEqual( 0.0 , chunk.probabilities[0] )
+            self.assertAlmostEqual( 1.0, chunk.probabilities[1] )
+            self.assertAlmostEqual( 0.0, chunk.probabilities[2] )
+
+            self.assertEqual( 3, chunk.NC )
+
+            # verify string
+            self.assertEqual( self.chunk, chunk.to_string( 9228, 14, 2 ) )
+
+        # the data is given explicitly
+        chunk = TabulatedDistribution( energy = 1e-5,
+                                       boundaries = [ 3 ], interpolants = [ 2 ],
+                                       cosines = [ -1.0, 0.0, 1.0 ], probabilities = [ 0.0, 1.0, 0.0 ] )
+
+        verify_chunk( self, chunk )
+
+        # the data is read from a string
+        chunk = TabulatedDistribution.from_string( self.chunk, 9228, 14, 2 )
+
+        verify_chunk( self, chunk )
+
+        # the data is copied
+        copy = TabulatedDistribution( chunk )
+
+        verify_chunk( self, copy )
+
+    def test_failures( self ) :
+
+        print( '\n' )
+
+        # wrong boundaries
+        with self.assertRaises( Exception ) :
+
+            chunk = TabulatedDistribution(
+                        energy = 1e-5,
+                        boundaries = [ 4 ], interpolants = [ 2 ],
+                        cosines = [ -1.0, 0.0, 1.0 ], probabilities = [ 0.0, 1.0, 0.0 ] )
+
+        with self.assertRaises( Exception ) :
+
+            chunk = TabulatedDistribution.from_string( self.invalid, 9228, 14, 2 )
+
+if __name__ == '__main__' :
+
+    unittest.main()