Beispiel #1
0
 def test_getB1Exp(self):
     """ Get Expected vales from B1 dictionary"""
     d = {}
     # Comparison
     for kk in self.univ.b1Exp:
         d[kk] = self.univ.get(kk, False)
     compareDictOfArrays(self.b1Exp, d, 'Error in b1 values at {key}')
Beispiel #2
0
 def test_getInfExp(self):
     """ Get Expected vales from Inf dictionary"""
     d = {}
     # Comparison
     for kk in self.univ.infExp:
         d[kk] = self.univ.get(kk, False)
     compareDictOfArrays(self.infExp, d,
                         'Error in infinite values at {key}')
Beispiel #3
0
 def test_getInfUnc(self):
     """ Get Expected vales and associated uncertainties from Inf dictionary
     """
     d = {}
     # Comparison
     for kk in self.univ.infUnc:
         d[kk] = self.univ.get(kk, True)[1]
     compareDictOfArrays(self.infUnc, d,
                         'Error in infinite uncertainties at {key}')
Beispiel #4
0
 def test_getB1Unc(self):
     """ Get Expected vales and associated uncertainties from B1 dictionary
     """
     d = {}
     # Comparison
     for kk in self.univ.b1Exp:
         d[kk] = self.univ.get(kk, True)[1]
     compareDictOfArrays(self.b1Unc, d,
                         'Error in b1 uncertainties at {key}')
Beispiel #5
0
 def test_detectorGrids(self):
     """Verify that all grids are loaded."""
     baseMsg = "Key: {key}"
     for detName, gridDict in self.EXPECTED_GRIDS.items():
         msg = baseMsg + "  Reading: " + self.__class__.__name__
         actualGrids = self.detectors[detName].grids
         compareDictOfArrays(gridDict,
                             actualGrids,
                             testCase=self,
                             fmtMsg=msg)
Beispiel #6
0
 def test_getBothInf(self):
     """
     Verify that the value and the uncertainty are returned if the
     flag is passed.
     """
     expected, uncertainties = {}, {}
     for key in self.infExp.keys():
         value, unc = self.univ.get(key, True)
         expected[key] = value
         uncertainties[key] = unc
     compareDictOfArrays(self.infExp, expected, 'infinite values')
     compareDictOfArrays(self.infUnc, uncertainties,
                         'infinite uncertainties')
    def test_integratedSensitivities(self):
        """Verify the energy integrated sensitivities are correct."""
        expected = {
                'fis2flx': array([[  # noqa: E126
                       [[-3.65771000e-01, 5.50000000e-02],
                        [-1.08269000e-03, 1.00000000e+00],
                        [0.00000000e+00, 0.00000000e+00],
                        [5.08970000e-03, 6.80000000e-01],
                        [-7.13637000e-02, 1.10000000e-01],
                        [-2.98151000e-01, 6.50000000e-02],
                        [-2.63575000e-04, 1.00000000e+00]],

                       [[-9.12298000e-03, 1.00000000e+00],
                        [3.16180000e-02, 1.00000000e+00],
                        [0.00000000e+00, 0.00000000e+00],
                        [4.73019000e-02, 4.00000000e-01],
                        [-9.90513000e-02, 8.80000000e-02],
                        [1.05040000e-02, 6.80000000e-01],
                        [5.04490000e-04, 1.00000000e+00]]]]),
                'keff': array([[
                       [[3.21018000e-01, 7.40000000e-02],
                        [-5.58871000e-03, 1.00000000e+00],
                        [0.00000000e+00, 0.00000000e+00],
                        [-5.16380000e-03, 7.60000000e-01],
                        [-1.14412000e-01, 5.70000000e-02],
                        [4.46246000e-01, 4.20000000e-02],
                        [-6.34103000e-05, 1.00000000e+00]],

                       [[-1.34445000e-01, 3.40000000e-01],
                        [-8.64658000e-03, 1.00000000e+00],
                        [0.00000000e+00, 0.00000000e+00],
                        [-2.26180000e-02, 7.00000000e-01],
                        [-1.52945000e-01, 7.30000000e-02],
                        [4.75881000e-02, 1.10000000e-01],
                        [2.17649000e-03, 5.30000000e-01]]]])
        }
        compareDictOfArrays(expected, self.reader.energyIntegratedSens,
                            'energy integrated sensitivities')
    def test_expectedSensitivities(self):
        """Verify the sensitivity arrays are loaded correctly."""
        expected = {
            'fis2flx': array([[[
                [[-2.61375000e-01, 7.10000000e-02],  # noqa: E126
                  [-1.04396000e-01, 1.30000000e-01]],

                 [[8.14309000e-04, 1.00000000e+00],
                  [-1.89700000e-03, 1.00000000e+00]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [0.00000000e+00, 0.00000000e+00]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [5.08970000e-03, 6.80000000e-01]],

                 [[-3.80915000e-02, 1.50000000e-01],
                  [-3.32722000e-02, 1.50000000e-01]],

                 [[-2.24098000e-01, 7.40000000e-02],
                  [-7.40533000e-02, 1.50000000e-01]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [-2.63575000e-04, 1.00000000e+00]]],


                [[[-1.82609000e-02, 8.50000000e-01],
                  [9.13794000e-03, 1.00000000e+00]],

                 [[1.05618000e-02, 1.00000000e+00],
                  [2.10562000e-02, 1.00000000e+00]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [0.00000000e+00, 0.00000000e+00]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [4.73019000e-02, 4.00000000e-01]],

                 [[-2.88227000e-02, 1.30000000e-01],
                  [-7.02287000e-02, 1.10000000e-01]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [1.05040000e-02, 6.80000000e-01]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [5.04490000e-04, 1.00000000e+00]]]]]),
            'keff': array([[[
                 [[2.33920000e-01, 8.00000000e-02],
                  [8.70984000e-02, 2.10000000e-01]],

                 [[-5.39529000e-03, 7.90000000e-01],
                  [-1.93425000e-04, 1.00000000e+00]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [0.00000000e+00, 0.00000000e+00]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [-5.16380000e-03, 7.60000000e-01]],

                 [[-6.34126000e-02, 8.10000000e-02],
                  [-5.09998000e-02, 9.00000000e-02]],

                 [[3.02727000e-01, 6.00000000e-02],
                  [1.43519000e-01, 8.30000000e-02]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [-6.34103000e-05, 1.00000000e+00]]],


                [[[-2.55744000e-02, 4.90000000e-01],
                  [-1.08870000e-01, 4.00000000e-01]],

                 [[7.10802000e-03, 1.00000000e+00],
                  [-1.57546000e-02, 1.00000000e+00]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [0.00000000e+00, 0.00000000e+00]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [-2.26180000e-02, 7.00000000e-01]],

                 [[-3.26824000e-02, 1.20000000e-01],
                  [-1.20262000e-01, 8.30000000e-02]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [4.75881000e-02, 1.10000000e-01]],

                 [[0.00000000e+00, 0.00000000e+00],
                  [2.17649000e-03, 5.30000000e-01]]]]])
        }
        compareDictOfArrays(expected, self.reader.sensitivities,
                            'Error in sensitivities at {key}', testCase=self)