def test_mergeMccV2FilesRemovesTheFileWideChi(self): isoaa = isotxs.readBinary(ISOAA_PATH) self.assertAlmostEqual(1.0, sum(isoaa.isotxsMetadata["chi"]), 5) self.assertAlmostEqual(1, isoaa.isotxsMetadata["fileWideChiFlag"]) someIsotxs = xsLibraries.IsotxsLibrary() # semi-copy... someIsotxs.merge(isoaa) self.assertAlmostEqual(1.0, sum(someIsotxs.isotxsMetadata["chi"]), 5) self.assertEqual(1, someIsotxs.isotxsMetadata["fileWideChiFlag"]) # OK, now I need to delete all the nuclides, so we can merge again. for key in someIsotxs.nuclideLabels: del someIsotxs[key] someIsotxs.merge(isotxs.readBinary(ISOAA_PATH)) self.assertEqual(None, someIsotxs.isotxsMetadata["chi"])
def test_plotBlockFlux(self): try: xslib = isotxs.readBinary(ISOAA_PATH) self.r.core.lib = xslib blockList = self.r.core.getBlocks() for _, b in enumerate(blockList): b.p.mgFlux = range(33) plotting.plotBlockFlux(self.r.core, fName="flux.png", bList=blockList) self.assertTrue(os.path.exists("flux.png")) plotting.plotBlockFlux(self.r.core, fName="peak.png", bList=blockList, peak=True) self.assertTrue(os.path.exists("peak.png")) plotting.plotBlockFlux( self.r.core, fName="bList2.png", bList=blockList, bList2=blockList, ) self.assertTrue(os.path.exists("bList2.png")) # can't test adjoint at the moment, testBlock doesn't like to .getMgFlux(adjoint=True) finally: os.remove("flux.txt") # secondarily created during the call. os.remove("flux.png") # created during the call. os.remove("peak.txt") # csecondarily reated during the call. os.remove("peak.png") # created during the call. os.remove("bList2.txt") # secondarily created during the call. os.remove("bList2.png") # created during the call.
def test_mapper(self): # Switch to MC2v2 setting to make sure the isotopic/elemental expansions are compatible # with actually doing some math using the ISOAA test microscopic library _o, r = test_reactors.loadTestReactor(customSettings={"xsKernel": "MC2v2"}) applyDummyFlux(r) r.core.lib = isotxs.readBinary(ISOAA_PATH) mapper = globalFluxInterface.GlobalFluxResultMapper() mapper.r = r mapper._renormalizeNeutronFluxByBlock(100) self.assertAlmostEqual(r.core.calcTotalParam("power", generationNum=2), 100) mapper._updateDerivedParams() self.assertGreater(r.core.p.maxPD, 0.0) self.assertGreater(r.core.p.maxFlux, 0.0) mapper.updateDpaRate() block = r.core.getFirstBlock() self.assertGreater(block.p.detailedDpaRate, 0) self.assertEqual(block.p.detailedDpa, 0) # Test DoseResultsMapper. Pass in full list of blocks to apply() in order # to exercise blockList option (does not change behavior, since this is what # apply() does anyway) opts = globalFluxInterface.GlobalFluxOptions("test") dosemapper = globalFluxInterface.DoseResultsMapper(1000, opts) dosemapper.apply(r, blockList=r.core.getBlocks()) self.assertGreater(block.p.detailedDpa, 0) mapper.clearFlux() self.assertEqual(len(block.p.mgFlux), 0)
def setUp(self): self.o, self.r = test_reactors.loadTestReactor( TEST_ROOT, customSettings={"xsKernel": "MC2v2"} ) self.r.core.lib = isotxs.readBinary(ISOAA_PATH) self.r.core.p.keff = 1.0 self.converter = uniformMesh.NeutronicsUniformMeshConverter()
def testMakeTable(self): obj = loadTestBlock() obj.p.mgFlux = range(33) core = obj.getAncestorWithFlags(Flags.CORE) core.lib = isotxs.readBinary(ISOAA_PATH) table = cst.makeReactionRateTable(obj) self.assertEqual(len(table), len(obj.getNuclides()))
def setUpClass(cls): # random seed to support random mesh in unit tests below random.seed(987324987234) cls.o, cls.r = test_reactors.loadTestReactor( TEST_ROOT, customSettings={"xsKernel": "MC2v2"}) cls.r.core.lib = isotxs.readBinary(ISOAA_PATH) # make the mesh a little non-uniform a = cls.r.core[4] a[2].setHeight(a[2].getHeight() * 1.05)
def setUpClass(cls): random.seed(987324987234) # so it's always the same cls.o, cls.r = test_reactors.loadTestReactor( TEST_ROOT, customSettings={"xsKernel": "MC2v2"} ) cls.r.core.lib = isotxs.readBinary(ISOAA_PATH) # make the mesh a little non-uniform a = cls.r.core[4] a[2].setHeight(a[2].getHeight() * 1.05)
def setUpClass(cls): cls.isotxsAA = isotxs.readBinary(ISOTXS_AA) cls.gamisoAA = gamiso.readBinary(GAMISO_AA) cls.pmatrxAA = pmatrx.readBinary(PMATRX_AA) cls.xsLib = xsLibraries.IsotxsLibrary() cls.xsLibGenerationErrorStack = None try: cls.xsLib.merge(copy.deepcopy(cls.isotxsAA)) cls.xsLib.merge(copy.deepcopy(cls.gamisoAA)) cls.xsLib.merge(copy.deepcopy(cls.pmatrxAA)) except: cls.xsLibGenerationErrorStack = traceback.format_exc()
def test_makeTable(self): obj = loadTestBlock() obj.p.mgFlux = range(33) core = obj.getAncestorWithFlags(Flags.CORE) core.lib = isotxs.readBinary(ISOAA_PATH) table = crossSectionTable.makeReactionRateTable(obj) self.assertEqual(len(obj.getNuclides()), len(table)) self.assertEqual(obj.getName(), "B0001-000") self.assertEqual(table.getName(), "B0001-000") self.assertTrue(table.hasValues()) xSecTable = table.getXsecTable() self.assertEqual(len(xSecTable), 11) self.assertIn("xsecs", xSecTable[0]) self.assertIn("mcnpId", xSecTable[-1])
def test_compareDifferentComponentsOfAnXSLibrary(self): self.assertTrue(xsLibraries.compare(self.isotxsAA, self.isotxsAA)) self.assertTrue(xsLibraries.compare(self.pmatrxAA, self.pmatrxAA)) aa = isotxs.readBinary(ISOTXS_AA) del aa[aa.nuclideLabels[0]] self.assertFalse(xsLibraries.compare(aa, self.isotxsAA))
In this example, several cross sections are plotted from an existing binary cross section library file in :py:mod:`ISOTXS <armi.nuclearDataIO.isotxs>` format. """ import matplotlib.pyplot as plt from armi.physics.neutronics import energyGroups from armi.tests import ISOAA_PATH from armi.nuclearDataIO.cccc import isotxs from armi import configure configure(permissive=True) gs = energyGroups.getGroupStructure("ANL33") lib = isotxs.readBinary(ISOAA_PATH) fe56 = lib.getNuclide("FE", "AA") u235 = lib.getNuclide("U235", "AA") u238 = lib.getNuclide("U238", "AA") b10 = lib.getNuclide("B10", "AA") plt.step(gs, fe56.micros.nGamma, label=r"Fe (n, $\gamma$)") plt.step(gs, u235.micros.fission, label="U-235 (n, fission)") plt.step(gs, u238.micros.nGamma, label=r"U-238 (n, $\gamma$)") plt.step(gs, b10.micros.nalph, label=r"B-10 (n, $\alpha$)") plt.xscale("log") plt.yscale("log") plt.xlabel("Neutron Energy, eV") plt.ylabel("Cross Section, barns")
def mergeXSLibrariesInWorkingDirectory(lib, xsLibrarySuffix="", mergeGammaLibs=False): """ Merge neutron (ISOTXS) and gamma (GAMISO/PMATRX) library data into the provided library. Parameters ---------- lib : obj ISOTXS library object xsLibrarySuffix : str, optional XS library suffix used to determine which ISOTXS files are merged together, typically something like `-doppler`. If empty string, will merge everything without suffix (indicated by a `-`). mergeGammaLibs : bool, optional If True, the GAMISO and PMATRX files that correspond to the ISOTXS library will be merged. Note: if these files do not exist this will fail. """ # pylint: disable=import-outside-toplevel) ; avoid cyclic import with isotxs bringing this in for data structure from armi.nuclearDataIO.cccc import isotxs from armi.nuclearDataIO.cccc import gamiso from armi.nuclearDataIO.cccc import pmatrx from armi import nuclearDataIO xsLibFiles = getISOTXSLibrariesToMerge( xsLibrarySuffix, [iso for iso in glob.glob(_ISOTXS_EXT + "*")]) librariesToMerge = [] neutronVelocities = { } # Dictionary of neutron velocities from each ISOTXS file for xsLibFilePath in sorted(xsLibFiles): try: xsID = re.search("ISO([A-Z0-9]{2})", xsLibFilePath).group( 1) # get XS ID from the cross section library name except AttributeError: # if glob has matched something that is not actually an ISOXX file, # the .group() call will fail runLog.debug( f"Ignoring file {xsLibFilePath} in the merging of ISOXX files") continue xsFileTypes = "ISOTXS" if not mergeGammaLibs else "ISOTXS, GAMISO, and PMATRX" runLog.info("Retrieving {} data for XS ID {}{}".format( xsFileTypes, xsID, xsLibrarySuffix)) if xsLibFilePath in lib.isotxsMetadata.fileNames: runLog.extra( "Skipping merge of {} because data already exists in the library" .format(xsLibFilePath)) continue neutronLibrary = isotxs.readBinary(xsLibFilePath) neutronVelocities[xsID] = neutronLibrary.neutronVelocity librariesToMerge.append(neutronLibrary) if mergeGammaLibs: dummyNuclides = [ nuc for nuc in neutronLibrary.nuclides if isinstance(nuc._base, nuclideBases.DummyNuclideBase) ] gamisoLibraryPath = nuclearDataIO.getExpectedGAMISOFileName( suffix=xsLibrarySuffix, xsID=xsID) pmatrxLibraryPath = nuclearDataIO.getExpectedPMATRXFileName( suffix=xsLibrarySuffix, xsID=xsID) # Check if the gamiso and pmatrx data paths exist with the xs library suffix so that # these are merged in. If they don't both exist then that is OK and we can just # revert back to expecting the files just based on the XS ID. if not (os.path.exists(gamisoLibraryPath) and os.path.exists(pmatrxLibraryPath)): runLog.warning(f"One of GAMISO or PMATRX data exist for " f"XS ID {xsID} with suffix {xsLibrarySuffix}. " f"Attempting to find GAMISO/PMATRX data with " f"only XS ID {xsID} instead.") gamisoLibraryPath = nuclearDataIO.getExpectedGAMISOFileName( xsID=xsID) pmatrxLibraryPath = nuclearDataIO.getExpectedPMATRXFileName( xsID=xsID) # GAMISO data gammaLibrary = gamiso.readBinary(gamisoLibraryPath) addedDummyData = gamiso.addDummyNuclidesToLibrary( gammaLibrary, dummyNuclides) # Add DUMMY nuclide data not produced by MC2-3 if addedDummyData: gamisoDummyPath = os.path.abspath( os.path.join(os.getcwd(), gamisoLibraryPath)) gamiso.writeBinary(gammaLibrary, gamisoDummyPath) gammaLibraryDummyData = gamiso.readBinary(gamisoDummyPath) librariesToMerge.append(gammaLibraryDummyData) else: librariesToMerge.append(gammaLibrary) # PMATRX data pmatrxLibrary = pmatrx.readBinary(pmatrxLibraryPath) addedDummyData = pmatrx.addDummyNuclidesToLibrary( pmatrxLibrary, dummyNuclides) # Add DUMMY nuclide data not produced by MC2-3 if addedDummyData: pmatrxDummyPath = os.path.abspath( os.path.join(os.getcwd(), pmatrxLibraryPath)) pmatrx.writeBinary(pmatrxLibrary, pmatrxDummyPath) pmatrxLibraryDummyData = pmatrx.readBinary(pmatrxDummyPath) librariesToMerge.append(pmatrxLibraryDummyData) else: librariesToMerge.append(pmatrxLibrary) for library in librariesToMerge: lib.merge(library) return neutronVelocities
def setUpClass(cls): # load a library that is in the ARMI tree. This should # be a small library with LFPs, Actinides, structure, and coolant cls.lib = isotxs.readBinary(ISOAA_PATH)
def ISOTXS(fName="ISOTXS"): # load a library that is in the ARMI tree. This should # be a small library with LFPs, Actinides, structure, and coolant from armi.nuclearDataIO.cccc import isotxs return isotxs.readBinary(fName)