def _build_inputs(self): # Instantiate a tally mesh mesh = openmc.Mesh(mesh_id=1) mesh.type = 'regular' mesh.dimension = [17, 17, 1] mesh.lower_left = [0.0, 0.0, 0.0] mesh.upper_right = [21.42, 21.42, 100.0] # Instantiate some tally filters energy_filter = openmc.Filter(type='energy', bins=[0.0, 20.0]) energyout_filter = openmc.Filter(type='energyout', bins=[0.0, 20.0]) mesh_filter = openmc.Filter() mesh_filter.mesh = mesh mat_filter = openmc.Filter(type='material', bins=[1, 2, 3]) tally1 = openmc.Tally(tally_id=1) tally1.filters = [mesh_filter] tally1.scores = [ 'total', 'absorption', 'flux', 'fission', 'nu-fission' ] tally2 = openmc.Tally(tally_id=2) tally2.filters = [mat_filter, energy_filter, energyout_filter] tally2.scores = ['scatter', 'nu-scatter'] self._input_set.tallies = openmc.Tallies([tally1, tally2]) super(MGTalliesTestHarness, self)._build_inputs()
def _build_inputs(self): # The summary.h5 file needs to be created to read in the tallies self._input_set.settings.output = {'summary': True} # Initialize the nuclides u235 = openmc.Nuclide('U-235') u238 = openmc.Nuclide('U-238') pu239 = openmc.Nuclide('Pu-239') # Initialize the filters energy_filter = openmc.Filter(type='energy', bins=[0.0, 0.253e-6, 1.0e-3, 1.0, 20.0]) distrib_filter = openmc.Filter(type='distribcell', bins=[60]) # Initialized the tallies tally = openmc.Tally(name='distribcell tally') tally.filters = [energy_filter, distrib_filter] tally.scores = ['nu-fission', 'total'] tally.nuclides = [u235, u238, pu239] tallies_file = openmc.Tallies([tally]) # Export tallies to file self._input_set.tallies = tallies_file super(TallyAggregationTestHarness, self)._build_inputs()
def _build_inputs(self): filt1 = openmc.Filter(type='mu', bins=(-1.0, -0.5, 0.0, 0.5, 1.0)) tally1 = openmc.Tally(tally_id=1) tally1.add_filter(filt1) tally1.add_score('scatter') tally1.add_score('nu-scatter') filt2 = openmc.Filter(type='mu', bins=(5, )) tally2 = openmc.Tally(tally_id=2) tally2.add_filter(filt2) tally2.add_score('scatter') tally2.add_score('nu-scatter') mesh = openmc.Mesh(mesh_id=1) mesh.lower_left = [-182.07, -182.07] mesh.upper_right = [182.07, 182.07] mesh.dimension = [2, 2] filt_mesh = openmc.Filter(type='mesh', bins=(1, )) tally3 = openmc.Tally(tally_id=3) tally3.add_filter(filt2) tally3.add_filter(filt_mesh) tally3.add_score('scatter') tally3.add_score('nu-scatter') self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(tally1) self._input_set.tallies.add_tally(tally2) self._input_set.tallies.add_tally(tally3) self._input_set.tallies.add_mesh(mesh) super(FilterMuTestHarness, self)._build_inputs()
def _build_inputs(self): filt1 = openmc.Filter(type='energy', bins=(0.0, 0.253e-6, 1.0e-3, 1.0, 20.0)) filt2 = openmc.Filter(type='energyout', bins=(0.0, 0.253e-6, 1.0e-3, 1.0, 20.0)) tally = openmc.Tally(tally_id=1) tally.add_filter(filt1) tally.add_filter(filt2) tally.add_score('scatter') tally.add_score('nu-fission') self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(tally) super(FilterGroupTransferTestHarness, self)._build_inputs()
def _build_inputs(self): filt = openmc.Filter(type='universe', bins=(1, 2, 3, 4)) tally = openmc.Tally(tally_id=1) tally.add_filter(filt) tally.add_score('total') self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(tally) super(FilterUniverseTestHarness, self)._build_inputs()
def generate_tally_xml(self, settings): import copy """ Generates tally.xml. Using information from self.depletion_chain as well as the nuclides currently in the problem, this function automatically generates a tally.xml for the simulation. """ chain = self.chain # ---------------------------------------------------------------------- # Create tallies for depleting regions tally_ind = 1 cell_filter_dep = openmc.Filter(type='cell', bins=self.burn_list) tallies_file = openmc.Tallies() nuc_superset = set() for cell in self.burn_list: for key in self.number_density[cell]: # Check if in participating nuclides if key in self.participating_nuclides: nuc_superset.add(key) # For each reaction in the chain, for each nuclide, and for each # cell, make a tally tally_dep = openmc.Tally(tally_id=tally_ind) for key in nuc_superset: if key in chain.nuclide_dict: tally_dep.add_nuclide(key) tally_dep.add_filter(cell_filter_dep) if (settings.fet_order == None): for reaction in chain.react_to_ind: tally_dep.add_score(reaction) tallies_file.add_tally(tally_dep) else: # Add the geomtric norm to tally if we are doing FETs # TODO we need geometry constants in another PYTHON file for easy use tally_dep.add_geom_norm(0.4096) tally_dep.estimator = 'collision' # The current implementation does not allow multiple score pins for FETs # Therefore, we need a unique tally for each reaction fet_tallies = [] for reaction in chain.react_to_ind: fet_tallies.append(copy.deepcopy(tally_dep)) fet_score_name = 'micro-' + reaction + '-z' + str(settings.fet_order) fet_tallies[-1].id = tally_ind fet_tallies[-1].add_score(fet_score_name) tally_ind += 1 [tallies_file.add_tally(t) for t in fet_tallies] tallies_file.export_to_xml()
def _build_inputs(self): filt = openmc.Filter(type='cellborn', bins=(10, 21, 22, 23)) tally = openmc.Tally(tally_id=1) tally.add_filter(filt) tally.add_score('total') self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(tally) super(FilterCellbornTestHarness, self)._build_inputs()
def _build_inputs(self): filt = openmc.Filter(type='delayedgroup', bins=(1, 2, 3, 4, 5, 6)) tally = openmc.Tally(tally_id=1) tally.add_filter(filt) tally.add_score('delayed-nu-fission') self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(tally) super(FilterDelayedgroupTestHarness, self)._build_inputs()
def _build_inputs(self): # The summary.h5 file needs to be created to read in the tallies self._input_set.settings.output = {'summary': True} # Initialize the tallies file tallies_file = openmc.Tallies() # Initialize the nuclides u235 = openmc.Nuclide('U-235') u238 = openmc.Nuclide('U-238') pu239 = openmc.Nuclide('Pu-239') # Initialize Mesh mesh = openmc.Mesh(mesh_id=1) mesh.type = 'regular' mesh.dimension = [2, 2, 2] mesh.lower_left = [-160.0, -160.0, -183.0] mesh.upper_right = [160.0, 160.0, 183.0] # Initialize the filters energy_filter = openmc.Filter(type='energy', bins=(0.0, 0.253e-6, 1.0e-3, 1.0, 20.0)) material_filter = openmc.Filter(type='material', bins=(1, 3)) distrib_filter = openmc.Filter(type='distribcell', bins=(60)) mesh_filter = openmc.Filter(type='mesh') mesh_filter.mesh = mesh # Initialized the tallies tally = openmc.Tally(name='tally 1') tally.filters = [material_filter, energy_filter, distrib_filter] tally.scores = ['nu-fission', 'total'] tally.nuclides = [u235, pu239] tallies_file.append(tally) tally = openmc.Tally(name='tally 2') tally.filters = [energy_filter, mesh_filter] tally.scores = ['total', 'fission'] tally.nuclides = [u238, u235] tallies_file.append(tally) # Export tallies to file self._input_set.tallies = tallies_file super(TallyArithmeticTestHarness, self)._build_inputs()
def _build_inputs(self): filt = openmc.Filter(type='energyout', bins=(0.0, 0.253e-6, 1.0e-3, 1.0, 20.0)) tally = openmc.Tally(tally_id=1) tally.add_filter(filt) tally.add_score('scatter') self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(tally) super(FilterEnergyoutTestHarness, self)._build_inputs()
def _build_inputs(self): filt = openmc.Filter(type='cell', bins=(21, 27)) tallies = [openmc.Tally(tally_id=i) for i in range(1, 3)] [t.add_filter(filt) for t in tallies] [t.add_score('events') for t in tallies] tallies[0].estimator = 'tracklength' tallies[1].estimator = 'analog' self._input_set.tallies = openmc.TalliesFile() [self._input_set.tallies.add_tally(t) for t in tallies] super(ScoreEventsTestHarness, self)._build_inputs()
def _build_inputs(self): filt = openmc.Filter(type='cell', bins=(21, 22, 23, 27)) tallies = [openmc.Tally(tally_id=i) for i in range(1, 4)] [t.add_filter(filt) for t in tallies] [t.add_score('kappa-fission') for t in tallies] tallies[0].estimator = 'tracklength' tallies[1].estimator = 'analog' tallies[2].estimator = 'collision' self._input_set.tallies = openmc.TalliesFile() [self._input_set.tallies.add_tally(t) for t in tallies] super(ScoreKappaFissionTestHarness, self)._build_inputs()
def _build_inputs(self): filt = openmc.Filter(type='cell', bins=(21, 22, 23)) t = openmc.Tally(tally_id=1) t.add_filter(filt) t.add_score('scatter') t.add_score('scatter-1') t.add_score('scatter-2') t.add_score('scatter-3') t.add_score('scatter-4') self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(t) super(ScoreScatterNTestHarness, self)._build_inputs()
def _build_inputs(self): filt = openmc.Filter(type='cell', bins=(21, 22, 23, 27, 28, 29)) tallies = [openmc.Tally(tally_id=i) for i in range(1, 5)] [t.add_filter(filt) for t in tallies] tallies[0].add_score('flux') [t.add_score('flux-y5') for t in tallies[1:]] tallies[1].estimator = 'tracklength' tallies[2].estimator = 'analog' tallies[3].estimator = 'collision' self._input_set.tallies = openmc.TalliesFile() [self._input_set.tallies.add_tally(t) for t in tallies] super(ScoreFluxYnTestHarness, self)._build_inputs()
def _build_inputs(self): filt1 = openmc.Filter(type='polar', bins=(0.0, 0.6283, 1.2566, 1.8850, 2.5132, 3.1416)) tally1 = openmc.Tally(tally_id=1) tally1.add_filter(filt1) tally1.add_score('flux') tally1.estimator = 'tracklength' tally2 = openmc.Tally(tally_id=2) tally2.add_filter(filt1) tally2.add_score('flux') tally2.estimator = 'analog' filt3 = openmc.Filter(type='polar', bins=(5, )) tally3 = openmc.Tally(tally_id=3) tally3.add_filter(filt3) tally3.add_score('flux') tally3.estimator = 'tracklength' mesh = openmc.Mesh(mesh_id=1) mesh.lower_left = [-182.07, -182.07] mesh.upper_right = [182.07, 182.07] mesh.dimension = [2, 2] filt_mesh = openmc.Filter(type='mesh', bins=(1, )) tally4 = openmc.Tally(tally_id=4) tally4.add_filter(filt3) tally4.add_filter(filt_mesh) tally4.add_score('flux') tally4.estimator = 'tracklength' self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(tally1) self._input_set.tallies.add_tally(tally2) self._input_set.tallies.add_tally(tally3) self._input_set.tallies.add_tally(tally4) self._input_set.tallies.add_mesh(mesh) super(FilterPolarTestHarness, self)._build_inputs()
def _build_inputs(self): filt = openmc.Filter(type='cell', bins=(21, )) t1 = openmc.Tally(tally_id=1) t1.add_filter(filt) t1.add_score('scatter-0') t1.estimator = 'analog' t2 = openmc.Tally(tally_id=2) t2.add_filter(filt) t2.add_score('scatter-y4') self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(t1) self._input_set.tallies.add_tally(t2) super(ScoreScatterYNTestHarness, self)._build_inputs()
def _build_inputs(self): filt = openmc.Filter(type='cell', bins=(10, 21, 22, 23)) t = openmc.Tally(tally_id=1) t.add_filter(filt) t.add_score('nu-scatter') self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(t) self._input_set.build_default_materials_and_geometry() self._input_set.build_default_settings() self._input_set.settings.inactive = 0 self._input_set.export()
def _build_inputs(self): filt = openmc.Filter(type='cell', bins=(10, 21, 22, 23)) tallies = [openmc.Tally(tally_id=i) for i in range(1, 5)] [t.add_filter(filt) for t in tallies] tallies[0].add_score('total') [t.add_score('total-y4') for t in tallies[1:]] [t.add_nuclide('U-235') for t in tallies[1:]] [t.add_nuclide('total') for t in tallies[1:]] tallies[1].estimator = 'tracklength' tallies[2].estimator = 'analog' tallies[3].estimator = 'collision' self._input_set.tallies = openmc.TalliesFile() [self._input_set.tallies.add_tally(t) for t in tallies] super(ScoreTotalYNTestHarness, self)._build_inputs()
def _build_inputs(self): filt = openmc.Filter(type='cell', bins=(21, )) t1 = openmc.Tally(tally_id=1) t1.add_filter(filt) t1.add_score('nu-scatter-0') t2 = openmc.Tally(tally_id=2) t2.add_filter(filt) t2.add_score('nu-scatter-y3') self._input_set.tallies = openmc.TalliesFile() self._input_set.tallies.add_tally(t1) self._input_set.tallies.add_tally(t2) self._input_set.build_default_materials_and_geometry() self._input_set.build_default_settings() self._input_set.settings.inactive = 0 self._input_set.export()
plot_xy.filename = 'plot_xy' plot_xy.origin = [0, 0, 0] plot_xy.width = [6, 6] plot_xy.pixels = [400, 400] plot_xy.color = 'mat' plot_yz = openmc.Plot(plot_id=2) plot_yz.filename = 'plot_yz' plot_yz.basis = 'yz' plot_yz.origin = [0, 0, 0] plot_yz.width = [8, 8] plot_yz.pixels = [400, 400] plot_yz.color = 'mat' # Instantiate a Plots collection, add plots, and export to XML plot_file = openmc.Plots((plot_xy, plot_yz)) plot_file.export_to_xml() ############################################################################### # Exporting to OpenMC tallies.xml File ############################################################################### # Instantiate a distribcell Tally tally = openmc.Tally(tally_id=1) tally.filters = [openmc.Filter(type='distribcell', bins=[cell2.id])] tally.scores = ['total'] # Instantiate a Tallies collection and export to XML tallies_file = openmc.Tallies([tally]) tallies_file.export_to_xml()
# Instantiate a PlotsFile, add Plot, and export to XML plot_file = openmc.PlotsFile() plot_file.add_plot(plot) plot_file.export_to_xml() ############################################################################### # Exporting to OpenMC tallies.xml File ############################################################################### # Instantiate a tally mesh mesh = openmc.Mesh(mesh_id=1) mesh.type = 'regular' mesh.dimension = [4, 4] mesh.lower_left = [-2, -2] mesh.width = [1, 1] # Instantiate tally Filter mesh_filter = openmc.Filter() mesh_filter.mesh = mesh # Instantiate the Tally tally = openmc.Tally(tally_id=1) tally.add_filter(mesh_filter) tally.add_score('total') # Instantiate a TalliesFile, register Tally/Mesh, and export to XML tallies_file = openmc.TalliesFile() tallies_file.add_mesh(mesh) tallies_file.add_tally(tally) tallies_file.export_to_xml()
plots = openmc.Plots([plot]) plots.export_to_xml() ############################################################################### # Create Mesh Tallies for Verification ############################################################################### # Instantiate a tally Mesh mesh = openmc.Mesh(name='assembly mesh') mesh.type = 'regular' mesh.dimension = assembly.dimension mesh.lower_left = assembly.lower_left mesh.width = assembly.pitch # Instantiate mesh Filter mesh_filter = openmc.Filter() mesh_filter.mesh = mesh # Fission rate mesh Tally mesh_fiss = openmc.Tally(name='mesh fission') mesh_fiss.filters = [mesh_filter] mesh_fiss.scores = ['fission'] mesh_fiss.nuclides = ['U-235', 'U-238'] # Fine energy flux Tally flux = openmc.Tally(name='flux') energies = np.logspace(np.log10(1E-8), np.log10(8.), 1000) flux.filters = [openmc.Filter(type='energy', bins=energies)] flux.scores = ['flux'] # U-238 capture and fission distribcell Tally
settings_file.source = openmc.source.Source(space=uniform_dist) settings_file.export_to_xml() ############################################################################### # Exporting to OpenMC tallies.xml file ############################################################################### # Instantiate a tally mesh mesh = openmc.Mesh(mesh_id=1) mesh.type = 'regular' mesh.dimension = [100, 100, 1] mesh.lower_left = [-0.63, -0.63, -1.e50] mesh.upper_right = [0.63, 0.63, 1.e50] # Instantiate some tally Filters energy_filter = openmc.Filter(type='energy', bins=[1E-11, 0.0635E-6, 10.0E-6, 1.0E-4, 1.0E-3, 0.5, 1.0, 20.0]) mesh_filter = openmc.Filter() mesh_filter.mesh = mesh # Instantiate the Tally tally = openmc.Tally(tally_id=1, name='tally 1') tally.filters = [energy_filter, mesh_filter] tally.scores = ['flux', 'fission', 'nu-fission'] # Instantiate a Tallies collection, register all Tallies, and export to XML tallies_file = openmc.Tallies([tally]) tallies_file.export_to_xml()
settings_file.entropy_dimension = [10, 10, 1] settings_file.export_to_xml() ############################################################################### # Exporting to OpenMC tallies.xml File ############################################################################### # Instantiate a tally mesh mesh = openmc.Mesh(mesh_id=1) mesh.type = 'rectangular' mesh.dimension = [100, 100, 1] mesh.lower_left = [-0.62992, -0.62992, -1.e50] mesh.upper_right = [0.62992, 0.62992, 1.e50] # Instantiate some tally Filters energy_filter = openmc.Filter(type='energy', bins=[0., 4.e-6, 20.]) mesh_filter = openmc.Filter() mesh_filter.mesh = mesh # Instantiate the Tally tally = openmc.Tally(tally_id=1, name='tally 1') tally.add_filter(energy_filter) tally.add_filter(mesh_filter) tally.add_score('flux') tally.add_score('fission') tally.add_score('nu-fission') # Instantiate a TalliesFile, register all Tallies, and export to XML tallies_file = openmc.TalliesFile() tallies_file.add_mesh(mesh) tallies_file.add_tally(tally)
settings_file.inactive = inactive settings_file.particles = particles # Create an initial uniform spatial source distribution over fissionable zones bounds = [-4., -4., -4., 4., 4., 4.] uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:], only_fissionable=True) settings_file.source = openmc.source.Source(space=uniform_dist) settings_file.export_to_xml() ############################################################################### # Exporting to OpenMC tallies.xml file ############################################################################### # Instantiate some tally Filters cell_filter = openmc.Filter(type='cell', bins=100) energy_filter = openmc.Filter(type='energy', bins=[0., 20.]) energyout_filter = openmc.Filter(type='energyout', bins=[0., 20.]) # Instantiate the first Tally first_tally = openmc.Tally(tally_id=1, name='first tally') first_tally.filters = [cell_filter] scores = [ 'total', 'scatter', 'nu-scatter', 'absorption', 'fission', 'nu-fission' ] first_tally.scores = scores # Instantiate the second Tally second_tally = openmc.Tally(tally_id=2, name='second tally') second_tally.filters = [cell_filter, energy_filter] second_tally.scores = scores
def _read_tallies(self): # Initialize dictionaries for the Tallies # Keys - Tally IDs # Values - Tally objects self.tallies = {} # Read the number of tallies if 'tallies' not in self._f: self.n_tallies = 0 return self.n_tallies = self._f['tallies/n_tallies'].value # OpenMC Tally keys all_keys = self._f['tallies/'].keys() tally_keys = [key for key in all_keys if 'tally' in key] base = 'tallies/tally ' # Iterate over all Tallies for tally_key in tally_keys: tally_id = int(tally_key.strip('tally ')) subbase = '{0}{1}'.format(base, tally_id) # Read Tally name metadata tally_name = self._f['{0}/name'.format(subbase)].value.decode() # Create Tally object and assign basic properties tally = openmc.Tally(tally_id, tally_name) # Read scattering moment order strings (e.g., P3, Y1,2, etc.) moments = self._f['{0}/moment_orders'.format(subbase)].value # Read score metadata scores = self._f['{0}/score_bins'.format(subbase)].value for j, score in enumerate(scores): score = score.decode() # If this is a moment, use generic moment order pattern = r'-n$|-pn$|-yn$' score = re.sub(pattern, '-' + moments[j].decode(), score) tally.scores.append(score) # Read filter metadata num_filters = self._f['{0}/n_filters'.format(subbase)].value # Initialize all Filters for j in range(1, num_filters + 1): subsubbase = '{0}/filter {1}'.format(subbase, j) # Read filter type (e.g., "cell", "energy", etc.) filter_type = self._f['{0}/type'.format( subsubbase)].value.decode() # Read the filter bins num_bins = self._f['{0}/n_bins'.format(subsubbase)].value bins = self._f['{0}/bins'.format(subsubbase)][...] # Create Filter object new_filter = openmc.Filter(filter_type, bins) new_filter.num_bins = num_bins # Read in distribcell paths if filter_type == 'distribcell': paths = self._f['{0}/paths'.format(subsubbase)][...] paths = [str(path.decode()) for path in paths] new_filter.distribcell_paths = paths # Add Filter to the Tally tally.filters.append(new_filter) # Add Tally to the global dictionary of all Tallies self.tallies[tally_id] = tally
def _build_inputs(self): """Build an axis-asymmetric lattice of fuel assemblies""" # Build full core geometry from underlying input set self._input_set.build_default_materials_and_geometry() # Extract universes encapsulating fuel and water assemblies geometry = self._input_set.geometry water = geometry.get_universes_by_name('water assembly (hot)')[0] fuel = geometry.get_universes_by_name('fuel assembly (hot)')[0] # Construct a 3x3 lattice of fuel assemblies core_lat = openmc.RectLattice(name='3x3 Core Lattice', lattice_id=202) core_lat.lower_left = (-32.13, -32.13) core_lat.pitch = (21.42, 21.42) core_lat.universes = [[fuel, water, water], [fuel, fuel, fuel], [water, water, water]] # Create bounding surfaces min_x = openmc.XPlane(x0=-32.13, boundary_type='reflective') max_x = openmc.XPlane(x0=+32.13, boundary_type='reflective') min_y = openmc.YPlane(y0=-32.13, boundary_type='reflective') max_y = openmc.YPlane(y0=+32.13, boundary_type='reflective') min_z = openmc.ZPlane(z0=0, boundary_type='reflective') max_z = openmc.ZPlane(z0=+32.13, boundary_type='reflective') # Define root universe root_univ = openmc.Universe(universe_id=0, name='root universe') root_cell = openmc.Cell(cell_id=1) root_cell.region = +min_x & -max_x & +min_y & -max_y & +min_z & -max_z root_cell.fill = core_lat root_univ.add_cell(root_cell) # Over-ride geometry in the input set with this 3x3 lattice self._input_set.geometry.root_universe = root_univ # Initialize a "distribcell" filter for the fuel pin cell distrib_filter = openmc.Filter(type='distribcell', bins=[27]) # Initialize the tallies tally = openmc.Tally(name='distribcell tally', tally_id=27) tally.filters.append(distrib_filter) tally.scores.append('nu-fission') # Initialize the tallies file tallies_file = openmc.Tallies([tally]) # Assign the tallies file to the input set self._input_set.tallies = tallies_file # Build default settings self._input_set.build_default_settings() # Specify summary output and correct source sampling box source = openmc.Source( space=openmc.stats.Box([-32, -32, 0], [32, 32, 32])) source.space.only_fissionable = True self._input_set.settings.source = source self._input_set.settings.output = {'summary': True} # Write input XML files self._input_set.export()
def _build_inputs(self): # The summary.h5 file needs to be created to read in the tallies self._input_set.settings.output = {'summary': True} # Initialize the tallies file tallies_file = openmc.Tallies() # Define nuclides and scores to add to both tallies self.nuclides = ['U-235', 'U-238'] self.scores = ['fission', 'nu-fission'] # Define filters for energy and spatial domain low_energy = openmc.Filter(type='energy', bins=[0., 0.625e-6]) high_energy = openmc.Filter(type='energy', bins=[0.625e-6, 20.]) merged_energies = low_energy.merge(high_energy) cell_21 = openmc.Filter(type='cell', bins=[21]) cell_27 = openmc.Filter(type='cell', bins=[27]) distribcell_filter = openmc.Filter(type='distribcell', bins=[21]) mesh = openmc.Mesh(name='mesh') mesh.type = 'regular' mesh.dimension = [2, 2] mesh.lower_left = [-50., -50.] mesh.upper_right = [+50., +50.] mesh_filter = openmc.Filter(type='mesh', bins=[mesh.id]) mesh_filter.mesh = mesh self.cell_filters = [cell_21, cell_27] self.energy_filters = [low_energy, high_energy] # Initialize cell tallies with filters, nuclides and scores tallies = [] for energy_filter in self.energy_filters: for cell_filter in self.cell_filters: for nuclide in self.nuclides: for score in self.scores: tally = openmc.Tally() tally.estimator = 'tracklength' tally.add_score(score) tally.add_nuclide(nuclide) tally.add_filter(cell_filter) tally.add_filter(energy_filter) tallies.append(tally) # Merge all cell tallies together while len(tallies) != 1: halfway = int(len(tallies) / 2) zip_split = zip(tallies[:halfway], tallies[halfway:]) tallies = list(map(lambda xy: xy[0].merge(xy[1]), zip_split)) # Specify a name for the tally tallies[0].name = 'cell tally' # Initialize a distribcell tally distribcell_tally = openmc.Tally(name='distribcell tally') distribcell_tally.estimator = 'tracklength' distribcell_tally.add_filter(distribcell_filter) distribcell_tally.add_filter(merged_energies) for score in self.scores: distribcell_tally.add_score(score) for nuclide in self.nuclides: distribcell_tally.add_nuclide(nuclide) mesh_tally = openmc.Tally(name='mesh tally') mesh_tally.estimator = 'tracklength' mesh_tally.filters = [mesh_filter, merged_energies] mesh_tally.scores = self.scores mesh_tally.nuclides = self.nuclides # Add tallies to a Tallies object tallies_file = openmc.Tallies( (tallies[0], distribcell_tally, mesh_tally)) # Export tallies to file self._input_set.tallies = tallies_file super(TallySliceMergeTestHarness, self)._build_inputs()
plot_xy.pixels = [400, 400] plot_xy.color = 'mat' plot_yz = openmc.Plot(plot_id=2) plot_yz.filename = 'plot_yz' plot_yz.basis = 'yz' plot_yz.origin = [0, 0, 0] plot_yz.width = [8, 8] plot_yz.pixels = [400, 400] plot_yz.color = 'mat' # Instantiate a PlotsFile, add Plot, and export to XML plot_file = openmc.PlotsFile() plot_file.add_plot(plot_xy) plot_file.add_plot(plot_yz) plot_file.export_to_xml() ############################################################################### # Exporting to OpenMC tallies.xml File ############################################################################### # Instantiate a distribcell Tally tally = openmc.Tally(tally_id=1) tally.add_filter(openmc.Filter(type='distribcell', bins=[cell2.id])) tally.add_score('total') # Instantiate a TalliesFile, register Tally/Mesh, and export to XML tallies_file = openmc.TalliesFile() tallies_file.add_tally(tally) tallies_file.export_to_xml()
def _read_tallies(self): # Initialize dictionaries for the Tallies # Keys - Tally IDs # Values - Tally objects self.tallies = {} # Read the number of tallies if 'tallies' not in self._f: self.n_tallies = 0 return self.n_tallies = self._f['tallies/n_tallies'].value # OpenMC Tally keys all_keys = self._f['tallies/'].keys() tally_keys = [key for key in all_keys if 'tally' in key] base = 'tallies/tally ' # Iterate over all Tallies for tally_key in tally_keys: tally_id = int(tally_key.strip('tally ')) subbase = '{0}{1}'.format(base, tally_id) # Read Tally name metadata tally_name = self._f['{0}/name'.format(subbase)].value.decode() # Create Tally object and assign basic properties tally = openmc.Tally(tally_id, tally_name) # Read score metadata scores = self._f['{0}/score_bins'.format(subbase)].value for score in scores: tally.add_score(score.decode()) num_score_bins = self._f['{0}/n_score_bins'.format(subbase)][...] tally.num_score_bins = num_score_bins # Read filter metadata num_filters = self._f['{0}/n_filters'.format(subbase)].value # Initialize all Filters for j in range(1, num_filters + 1): subsubbase = '{0}/filter {1}'.format(subbase, j) # Read filter type (e.g., "cell", "energy", etc.) filter_type = self._f['{0}/type'.format( subsubbase)].value.decode() # Read the filter bins num_bins = self._f['{0}/n_bins'.format(subsubbase)].value bins = self._f['{0}/bins'.format(subsubbase)][...] # Create Filter object filter = openmc.Filter(filter_type, bins) filter.num_bins = num_bins # Add Filter to the Tally tally.add_filter(filter) # Add Tally to the global dictionary of all Tallies self.tallies[tally_id] = tally