def simulate(self): """this runs a simple tbr simulation using openmc and returns the tritium breeding ratio""" breeder_material = openmc.Material(1, "PbLi") # Pb84.2Li15.8 breeder_material.add_element('Pb', 84.2, percent_type='ao') breeder_material.add_element('Li', 15.8, percent_type='ao', enrichment=50.0, enrichment_target='Li6', enrichment_type='ao') # 50% enriched breeder_material.set_density('atom/b-cm', 3.2720171e-2) # around 11 g/cm3 mats = openmc.Materials([breeder_material]) # GEOMETRY # surfaces vessel_inner = openmc.Sphere(r=500) breeder_blanket_outer_surface = openmc.Sphere(r=600, boundary_type='vacuum') # cells inner_vessel_region = -vessel_inner inner_vessel_cell = openmc.Cell(region=inner_vessel_region) breeder_blanket_region = -breeder_blanket_outer_surface breeder_blanket_cell = openmc.Cell(region=breeder_blanket_region) breeder_blanket_cell.fill = breeder_material # universe universe = openmc.Universe( cells=[inner_vessel_cell, breeder_blanket_cell]) geom = openmc.Geometry(universe) # SIMULATION SETTINGS # Instantiate a Settings object sett = openmc.Settings() sett.batches = 2 sett.inactive = 0 sett.particles = 100 sett.run_mode = 'fixed source' # Create a DT point source source = openmc.Source() source.space = openmc.stats.Point((0, 0, 0)) source.angle = openmc.stats.Isotropic() source.energy = openmc.stats.Discrete([14e6], [1]) sett.source = source tallies = openmc.Tallies() # added a cell tally for tritium production cell_filter = openmc.CellFilter(breeder_blanket_cell) tbr_tally = openmc.Tally(name='TBR') tbr_tally.filters = [cell_filter] tbr_tally.scores = [ '(n,Xt)' ] # MT 205 is the (n,Xt) reaction where X is a wildcard, if MT 105 or (n,t) then some tritium production will be missed, for example (n,nt) which happens in Li7 would be missed tallies.append(tbr_tally) # Run OpenMC! model = openmc.model.Model(geom, mats, sett, tallies) sp_filename = model.run() # open the results file sp = openmc.StatePoint(sp_filename) # access the tally using pandas dataframes tbr_tally = sp.get_tally(name='TBR') df = tbr_tally.get_pandas_dataframe() tbr_tally_result = df['mean'].sum() return tbr_tally_result
def make_materials_geometry_tallies(batches, enrichment_fraction, inner_radius, thickness, breeder_material_name, temperature_in_C): print('simulating ', batches, enrichment_fraction, inner_radius, thickness, breeder_material_name) #MATERIALS# breeder_material = make_breeder_material(enrichment_fraction, breeder_material_name, temperature_in_C) eurofer = make_eurofer() mats = openmc.Materials([breeder_material, eurofer]) #GEOMETRY# breeder_blanket_inner_surface = openmc.Sphere(R=inner_radius) breeder_blanket_outer_surface = openmc.Sphere(R=inner_radius + thickness) vessel_inner_surface = openmc.Sphere(R=inner_radius + thickness + 10) vessel_outer_surface = openmc.Sphere(R=inner_radius + thickness + 20, boundary_type='vacuum') breeder_blanket_region = -breeder_blanket_outer_surface & +breeder_blanket_inner_surface breeder_blanket_cell = openmc.Cell(region=breeder_blanket_region) breeder_blanket_cell.fill = breeder_material breeder_blanket_cell.name = 'breeder_blanket' inner_void_region = -breeder_blanket_inner_surface inner_void_cell = openmc.Cell(region=inner_void_region) inner_void_cell.name = 'inner_void' vessel_region = +vessel_inner_surface & -vessel_outer_surface vessel_cell = openmc.Cell(region=vessel_region) vessel_cell.name = 'vessel' vessel_cell.fill = eurofer blanket_vessel_gap_region = -vessel_inner_surface & +breeder_blanket_outer_surface blanket_vessel_gap_cell = openmc.Cell(region=blanket_vessel_gap_region) blanket_vessel_gap_cell.name = 'blanket_vessel_gap' universe = openmc.Universe(cells=[ inner_void_cell, breeder_blanket_cell, blanket_vessel_gap_cell, vessel_cell ]) geom = openmc.Geometry(universe) #SIMULATION SETTINGS# sett = openmc.Settings() # batches = 3 # this is parsed as an argument sett.batches = batches sett.inactive = 10 sett.particles = 500 sett.run_mode = 'fixed source' source = openmc.Source() source.space = openmc.stats.Point((0, 0, 0)) source.angle = openmc.stats.Isotropic() source.energy = openmc.stats.Muir( e0=14080000.0, m_rat=5.0, kt=20000.0 ) #neutron energy = 14.08MeV, AMU for D + T = 5, temperature is 20KeV sett.source = source #TALLIES# tallies = openmc.Tallies() # define filters cell_filter_breeder = openmc.CellFilter(breeder_blanket_cell) cell_filter_vessel = openmc.CellFilter(vessel_cell) particle_filter = openmc.ParticleFilter([1]) #1 is neutron, 2 is photon surface_filter_rear_blanket = openmc.SurfaceFilter( breeder_blanket_outer_surface) surface_filter_rear_vessel = openmc.SurfaceFilter(vessel_outer_surface) energy_bins = openmc.mgxs.GROUP_STRUCTURES['VITAMIN-J-175'] energy_filter = openmc.EnergyFilter(energy_bins) tally = openmc.Tally(name='TBR') tally.filters = [cell_filter_breeder, particle_filter] tally.scores = ['205'] tallies.append(tally) tally = openmc.Tally(name='blanket_leakage') tally.filters = [surface_filter_rear_blanket, particle_filter] tally.scores = ['current'] tallies.append(tally) tally = openmc.Tally(name='vessel_leakage') tally.filters = [surface_filter_rear_vessel, particle_filter] tally.scores = ['current'] tallies.append(tally) tally = openmc.Tally(name='breeder_blanket_spectra') tally.filters = [cell_filter_breeder, particle_filter, energy_filter] tally.scores = ['flux'] tallies.append(tally) tally = openmc.Tally(name='vacuum_vessel_spectra') tally.filters = [cell_filter_vessel, particle_filter, energy_filter] tally.scores = ['flux'] tallies.append(tally) tally = openmc.Tally(name='DPA') tally.filters = [cell_filter_vessel, particle_filter] tally.scores = ['444'] tallies.append(tally) #RUN OPENMC # model = openmc.model.Model(geom, mats, sett, tallies) model.run() sp = openmc.StatePoint('statepoint.' + str(batches) + '.h5') json_output = { 'enrichment_fraction': enrichment_fraction, 'inner_radius': inner_radius, 'thickness': thickness, 'breeder_material_name': breeder_material_name, 'temperature_in_C': temperature_in_C } tallies_to_retrieve = ['TBR', 'DPA', 'blanket_leakage', 'vessel_leakage'] for tally_name in tallies_to_retrieve: tally = sp.get_tally(name=tally_name) # for some reason the tally sum is a nested list tally_result = tally.sum[0][0][0] / batches # for some reason the tally std_dev is a nested list tally_std_dev = tally.std_dev[0][0][0] / batches json_output[tally_name] = { 'value': tally_result, 'std_dev': tally_std_dev } spectra_tallies_to_retrieve = [ 'breeder_blanket_spectra', 'vacuum_vessel_spectra' ] for spectra_name in spectra_tallies_to_retrieve: spectra_tally = sp.get_tally(name=spectra_name) spectra_tally_result = [entry[0][0] for entry in spectra_tally.mean] spectra_tally_std_dev = [ entry[0][0] for entry in spectra_tally.std_dev ] json_output[spectra_name] = { 'value': spectra_tally_result, 'std_dev': spectra_tally_std_dev, 'energy_groups': list(energy_bins) } return json_output
sett = openmc.Settings() batches = 2 sett.batches = batches sett.inactive = 0 sett.particles = 7000 sett.run_mode = 'fixed source' # Create a DT point source source = openmc.Source() source.space = openmc.stats.Point((150, 0, 0)) source.angle = openmc.stats.Isotropic() source.energy = openmc.stats.Discrete([14e6], [1]) sett.source = source # setup the tallies tallies = openmc.Tallies() neutron_particle_filter = openmc.ParticleFilter(['neutron']) cell_filter = openmc.CellFilter(breeder_blanket_cell) cell_filter_fw = openmc.CellFilter(first_wall_cell) energy_bins = openmc.mgxs.GROUP_STRUCTURES['VITAMIN-J-175'] energy_filter = openmc.EnergyFilter(energy_bins) spectra_tally = openmc.Tally(3, name='breeder_blanket_spectra') spectra_tally.filters = [cell_filter, neutron_particle_filter, energy_filter] spectra_tally.scores = ['flux'] tallies.append(spectra_tally) spectra_tally = openmc.Tally(4, name='first_wall_spectra') spectra_tally.filters = [ cell_filter_fw, neutron_particle_filter, energy_filter
# Exporting to OpenMC plots.xml File ############################################################################### plot_1 = openmc.Plot(plot_id=1) plot_1.filename = 'plot_1' plot_1.origin = [0.0, 0.0, 0.0] plot_1.width = [64.26, 64.26] plot_1.pixels = [500, 500] plot_1.color_by = 'material' plot_1.basis = 'xy' plot_2 = openmc.Plot(plot_id=2) plot_2.filename = 'plot_2' plot_2.origin = [0.0, 21.42, 0.0] plot_2.width = [64.26, 64.26] plot_2.pixels = [500, 500] plot_2.color_by = 'material' plot_2.basis = 'xz' # Instantiate a PlotsFile, add Plot, and export to XML plot_file = openmc.Plots([plot_1, plot_2]) plot_file.export_to_xml() ############################################################################### # Exporting to OpenMC tallies.xml File ############################################################################### # Instantiate a Tallies collection and export to XML tallies_file = openmc.Tallies(tallies.values()) tallies_file.export_to_xml()
def _make_openmc_input(self): """Generate the OpenMC input XML """ # Define material mat = openmc.Material() for nuclide, fraction in self.nuclides: mat.add_nuclide(nuclide, fraction) mat.set_density('g/cm3', self.density) materials = openmc.Materials([mat]) if self.xsdir is not None: xs_path = (self.openmc_dir / 'cross_sections.xml').resolve() materials.cross_sections = str(xs_path) materials.export_to_xml(self.openmc_dir / 'materials.xml') # Instantiate surfaces cyl = openmc.XCylinder(boundary_type='vacuum', r=1.e-6) px1 = openmc.XPlane(boundary_type='vacuum', x0=-1.) px2 = openmc.XPlane(boundary_type='transmission', x0=1.) px3 = openmc.XPlane(boundary_type='vacuum', x0=1.e9) # Instantiate cells inner_cyl_left = openmc.Cell() inner_cyl_right = openmc.Cell() outer_cyl = openmc.Cell() # Set cells regions and materials inner_cyl_left.region = -cyl & +px1 & -px2 inner_cyl_right.region = -cyl & +px2 & -px3 outer_cyl.region = ~(-cyl & +px1 & -px3) inner_cyl_right.fill = mat # Create root universe and export to XML geometry = openmc.Geometry( [inner_cyl_left, inner_cyl_right, outer_cyl]) geometry.export_to_xml(self.openmc_dir / 'geometry.xml') # Define source source = openmc.Source() source.space = openmc.stats.Point((0, 0, 0)) source.angle = openmc.stats.Monodirectional() source.energy = openmc.stats.Discrete([self.energy], [1.]) source.particle = 'neutron' # Settings settings = openmc.Settings() if self._temperature is not None: settings.temperature = {'default': self._temperature} settings.source = source settings.particles = self.particles // self._batches settings.run_mode = 'fixed source' settings.batches = self._batches settings.photon_transport = True settings.electron_treatment = self.electron_treatment settings.cutoff = {'energy_photon': self._cutoff_energy} settings.export_to_xml(self.openmc_dir / 'settings.xml') # Define filters surface_filter = openmc.SurfaceFilter(cyl) particle_filter = openmc.ParticleFilter('photon') energy_bins = np.logspace(np.log10(self._cutoff_energy), np.log10(self.max_energy), self._bins + 1) energy_filter = openmc.EnergyFilter(energy_bins) # Create tallies and export to XML tally = openmc.Tally(name='tally') tally.filters = [surface_filter, energy_filter, particle_filter] tally.scores = ['current'] tallies = openmc.Tallies([tally]) tallies.export_to_xml(self.openmc_dir / 'tallies.xml')
mats = openmc.Materials([iron]) mats.export_to_xml() # Create a 5 cm x 5 cm box filled with iron box = openmc.model.rectangular_prism(10.0, 10.0, boundary_type='vacuum') cell = openmc.Cell(fill=iron, region=box) geometry = openmc.Geometry([cell]) geometry.export_to_xml() # Tell OpenMC we're going to use our custom source settings = openmc.Settings() settings.run_mode = 'fixed source' settings.batches = 10 settings.particles = 1000 source = openmc.Source() source.library = 'build/libsource.so' settings.source = source settings.export_to_xml() # Finally, define a mesh tally so that we can see the resulting flux mesh = openmc.RegularMesh() mesh.lower_left = (-5.0, -5.0) mesh.upper_right = (5.0, 5.0) mesh.dimension = (50, 50) tally = openmc.Tally() tally.filters = [openmc.MeshFilter(mesh)] tally.scores = ['flux'] tallies = openmc.Tallies([tally]) tallies.export_to_xml()
############################################################################### # Exporting to OpenMC tallies.xml file ############################################################################### # Instantiate some tally Filters cell_filter = openmc.CellFilter(cell2) energy_filter = openmc.EnergyFilter([0., 20.e6]) energyout_filter = openmc.EnergyoutFilter([0., 20.e6]) # 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 # Instantiate the third Tally third_tally = openmc.Tally(tally_id=3, name='third tally') third_tally.filters = [cell_filter, energy_filter, energyout_filter] third_tally.scores = ['scatter', 'nu-scatter', 'nu-fission'] # Instantiate a Tallies collection and export to XML tallies_file = openmc.Tallies((first_tally, second_tally, third_tally)) tallies_file.export_to_xml()
g.root_universe = root g.export_to_xml() # data/control section settings = openmc.Settings() settings.run_mode = 'fixed source' settings.batches = 50 # even for fixed source problems you need batches settings.particles = 10000 source = openmc.Source() source.particle = 'neutron' source.space = openmc.stats.Point(xyz=(0., 0., 0.)) # default is the origin source.angle = openmc.stats.Isotropic() source.energy = openmc.stats.Discrete([1.0e6], [1.0]) settings.source = source settings.export_to_xml() t = openmc.Tally(name='sphere') s_filter = openmc.SurfaceFilter(sphere.id) t.filters = [s_filter] t.scores = ['flux'] tallies = openmc.Tallies([t]) tallies.export_to_xml() openmc.run()
settings.source = [src] model.settings = settings detector_cells = detectors_tallies(h_cell) print(detector_cells) tallies_list = [] tally = openmc.Tally(name='flux') tally.filters = [openmc.CellFilter(detector_cells)] tally.scores = ['flux'] tallies_list.append(tally) model.tallies = openmc.Tallies(tallies_list) model.export_to_xml() ph = horizontal_section() pv = vertical_section() plots = openmc.Plots([ph, pv]) plots.export_to_xml() openmc.plot_geometry() openmc.run()
def tallies_generation(root): """ Creates tallies.xml file Parameters ---------- root: openmc.Universe with all the relevant cells for the geometry. Returns ------- This function generates the tallies.xml file. """ tallies_file = openmc.Tallies() # phase1a-b energy_filter_b = openmc.EnergyFilter([1e-6, 20.0e6]) mesh_b = openmc.RegularMesh(mesh_id=16) mesh_b.dimension = [1, 1] L = 27.02 mesh_b.lower_left = [-L, -L] mesh_b.upper_right = [L, L] mesh_filter_b = openmc.MeshFilter(mesh_b) tally_b = openmc.Tally(name='mesh tally b') tally_b.filters = [mesh_filter_b, energy_filter_b] tally_b.scores = ['delayed-nu-fission', 'nu-fission'] tallies_file.append(tally_b) # phase1a-c mesh_no = 0 for t in range(6): mesh_no += 1 for x in range(2): x_trans = t * T['A1']['P']['x'] y_trans = t * T['A1']['P']['y'] if x == 1: mesh_no += 1 x_trans += T['A1']['F']['x'] y_trans += T['A1']['F']['y'] mesh_c = openmc.RegularMesh(mesh_id=mesh_no) mesh_c.dimension = [1, 5] mesh_c.lower_left = [ V['A1']['F']['L']['x'] + x_trans, V['A1']['F']['B']['y'] + y_trans ] mesh_c.upper_right = [ V['A1']['F']['R']['x'] + x_trans, V['A1']['F']['T']['y'] + y_trans ] mesh_filter_c = openmc.MeshFilter(mesh_c) tally_c = openmc.Tally(name='mesh tally c' + str(mesh_no)) tally_c.filters = [mesh_filter_c] tally_c.scores = ['fission'] tallies_file.append(tally_c) # phase 1a-d energy_filter_d = openmc.EnergyFilter([1e-5, 3, 1.0e5, 20.0e6]) mesh_d = openmc.RegularMesh(mesh_id=13) mesh_d.dimension = [1, 1] L = 27.02 mesh_d.lower_left = [-L, -L] mesh_d.upper_right = [L, L] mesh_filter_d = openmc.MeshFilter(mesh_d) tally_d = openmc.Tally(name='mesh tally d') tally_d.filters = [mesh_filter_d, energy_filter_d] tally_d.scores = ['flux', 'nu-fission', 'fission'] tallies_file.append(tally_d) # phase 1a-e energy_filter_e = openmc.EnergyFilter([1e-5, 3, 0.1e6, 20.0e6]) mesh_e = openmc.RegularMesh(mesh_id=14) mesh_e.dimension = [100, 100] L = 27.02 mesh_e.lower_left = [-L, -L] mesh_e.upper_right = [L, L] mesh_filter_e = openmc.MeshFilter(mesh_e) tally_e = openmc.Tally(name='mesh tally e') tally_e.filters = [mesh_filter_e, energy_filter_e] tally_e.scores = ['flux', 'nu-fission', 'fission'] tallies_file.append(tally_e) # phase 1a-f energy_filter_f = openmc.EnergyFilter(engs) mesh_f = openmc.RegularMesh(mesh_id=15) mesh_f.dimension = [1, 1] L = 27.02 mesh_f.lower_left = [-L, -L] mesh_f.upper_right = [L, L] mesh_filter_f = openmc.MeshFilter(mesh_f) tally_f = openmc.Tally(name='mesh tally f') tally_f.filters = [mesh_filter_f, energy_filter_f] tally_f.scores = ['flux', 'nu-fission', 'fission'] tallies_file.append(tally_f) tallies_file.export_to_xml() return
plot_file.export_to_xml() ############################################################################### # Create OpenMC MGXS Library ############################################################################### # Instantiate a 1-group EnergyGroups object groups = openmc.mgxs.EnergyGroups() groups.group_edges = [0., 20e6] # Initialize an MGXS Library for OpenMOC mgxs_lib = openmc.mgxs.Library(openmc_geometry, by_nuclide=False) mgxs_lib.energy_groups = groups mgxs_lib.mgxs_types = ['total', 'nu-fission', 'nu-scatter matrix', 'chi'] mgxs_lib.domain_type = 'cell' mgxs_lib.correction = None mgxs_lib.domains = openmc_geometry.get_all_material_cells().values() mgxs_lib.build_library() # Create a "tallies.xml" file for the MGXS Library tallies_file = openmc.Tallies() mgxs_lib.add_to_tallies_file(tallies_file, merge=True) tallies_file.export_to_xml() ############################################################################### # Run OpenMC Simulation ############################################################################### # Run OpenMC openmc.run()