def model_surf(request): # Select random distance and source energy x = uniform(50., 100.) E = uniform(0., 20.0e6) # Create model model = openmc.Model() mat = openmc.Material() mat.add_nuclide('Zr90', 1.0) mat.set_density('g/cm3', 1.0) model.materials.append(mat) left = openmc.XPlane(-1., boundary_type='vacuum') black_surface = openmc.XPlane(x, boundary_type='vacuum') right = openmc.XPlane(x + 1) void_cell = openmc.Cell(region=+left & -black_surface) black_cell = openmc.Cell(region=+black_surface & -right) model.geometry = openmc.Geometry([void_cell, black_cell]) model.settings = openmc.Settings() model.settings.run_mode = 'fixed source' model.settings.particles = 1000 model.settings.batches = 20 particle = request.param model.settings.source = openmc.Source( space=openmc.stats.Point((0., 0., 0.)), angle=openmc.stats.Monodirectional([1., 0., 0.]), energy=openmc.stats.Discrete([E], [1.0]), particle=particle) # Calculate time it will take neutrons to reach purely-absorbing surface t0 = time(particle, x, E) # Create tally with surface and time filters tally = openmc.Tally() tally.filters = [ openmc.SurfaceFilter([black_surface]), openmc.TimeFilter([0.0, t0 * 0.999, t0 * 1.001, 100.0]) ] tally.scores = ['current'] model.tallies.append(tally) return model
def shield(rad, bool, outer, m_batches, m_error, neutrons): #MATERIALS# min = 1 max = outer R1 = rad[0] R2 = rad[1] mats = openmc.Materials() tungsten = openmc.Material(name='Tungsten') tungsten.set_density('g/cm3', 19.0) tungsten.add_element('W', 1.0) mats.append(tungsten) water = openmc.Material(name='Water') water.set_density('g/cm3', 1.0) water.add_element('H', 2.0) water.add_element('O', 1.0) mats.append(water) eurofer = openmc.Material(name='EUROFER97') eurofer.set_density('g/cm3', 7.75) eurofer.add_element('Fe', 89.067, percent_type='wo') eurofer.add_element('C', 0.11, percent_type='wo') eurofer.add_element('Mn', 0.4, percent_type='wo') eurofer.add_element('Cr', 9.0, percent_type='wo') eurofer.add_element('Ta', 0.12, percent_type='wo') eurofer.add_element('W', 1.1, percent_type='wo') eurofer.add_element('N', 0.003, percent_type='wo') eurofer.add_element('V', 0.2, percent_type='wo') mats.append(eurofer) boron = openmc.Material(name='Boron') boron.set_density('g/cm3', 2.37) boron.add_element('B', 1.0) mats.append(boron) #GEOMETRY# sphere1 = openmc.Sphere(R=min) sphere2 = openmc.Sphere(R=R1) sphere3 = openmc.Sphere(R=R2) sphere4 = openmc.Sphere(R=max) sphere5 = openmc.Sphere(R=15) sphere6 = openmc.Sphere(R=17, boundary_type='vacuum') vac1 = -sphere1 mat1 = +sphere1 & -sphere2 mat2 = +sphere2 & -sphere3 mat3 = +sphere3 & -sphere4 vac2 = +sphere4 & -sphere5 steel = +sphere5 & -sphere6 vac3 = +sphere6 vacuum1 = openmc.Cell(region=vac1) first = openmc.Cell(region=mat1) first.fill = tungsten second = openmc.Cell(region=mat2) second.fill = water third = openmc.Cell(region=mat3) third.fill = tungsten vacuum2 = openmc.Cell(region=vac2) vessel = openmc.Cell(region=steel) vessel.fill = boron vacuum3 = openmc.Cell(region=vac3) root = openmc.Universe(cells=(vacuum1, first, second, third, vacuum2, vessel, vacuum3)) geom = openmc.Geometry(root) #SETTINGS# batch = 2 max_batches = m_batches inactive = 1 particles = neutrons source = openmc.Source() source.space = openmc.stats.Point((0, 0, 0)) source.angle = openmc.stats.Isotropic() source.energy = openmc.stats.Discrete([14e6], [1]) sett = openmc.Settings() sett.batches = batch sett.trigger_active = True sett.trigger_max_batches = m_batches sett.inactive = inactive sett.particles = particles sett.output = {'tallies': False} sett.run_mode = 'fixed source' sett.source = source #TALLIES# tallies = openmc.Tallies() filter = openmc.SurfaceFilter(sphere6) tally = openmc.Tally(name='leakage') tally.scores = ['current'] tally.filters = [filter] trigger = openmc.Trigger('rel_err', m_error / 100) tally.triggers = [trigger] tallies.append(tally) model = openmc.model.Model(geom, mats, sett, tallies) #RUN# model.run(output=bool) #PLOT# #plots = openmc.Plots() #plot = openmc.Plot() #plot.basis = 'xz' #plot.origin = (0, 0, 0) #plot.width = (200, 200) #plot.pixels = (400, 400) #plot.color_by = 'material' #plot.colors = {tungsten: 'black', water: 'blue'} #plots.append(plot) #plots.export_to_xml() for i in reversed(range(batch, max_batches + 1)): filename = 'statepoint.' + str(i).zfill(len(str(max_batches))) + '.h5' if os.path.isfile(filename): sp = openmc.StatePoint(filename) break #print('file:',filename) leakage = sp.get_tally(name='leakage') leakage_mean = leakage.mean[0][0][0] leakage_error = leakage.std_dev[0][0][0] #print(leakage_mean) #print(leakage_error) dir = '/home/emiralle/shield_git' for zippath in glob.iglob(os.path.join(dir, '*.h5')): os.remove(zippath) return leakage_mean * 100, leakage_error * 100
def make_materials_geometry_tallies(v): enrichment_fraction_list, thickness = v batches = 2 inner_radius = 500 breeder_material_name = 'Li' temperature_in_C = 500 if isinstance(enrichment_fraction_list, list): enrichment_fraction = enrichment_fraction_list[0] else: enrichment_fraction = enrichment_fraction_list 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' ] # 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(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) df = tally.get_pandas_dataframe() tally_result = df['mean'].sum() tally_std_dev = df['std. dev.'].sum() 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
def make_geometry_tallies(batches, nps, inner_radius, thickness): first_wall_inner_surface = openmc.Sphere(r=inner_radius) first_wall_outer_surface = openmc.Sphere(r=inner_radius + thickness, boundary_type='vacuum') first_wall = +first_wall_inner_surface & -first_wall_outer_surface first_wall = openmc.Cell(region=first_wall) first_wall.fill = eurofer inner_vac_cell = -first_wall_inner_surface inner_vac_cell = openmc.Cell(region=inner_vac_cell) universe = openmc.Universe(cells=[first_wall, inner_vac_cell]) geom = openmc.Geometry(universe) geom.export_to_xml('geometry') vox_plot = openmc.Plot() vox_plot.type = 'voxel' vox_plot.width = (15, 15, 15) vox_plot.pixels = (200, 200, 200) vox_plot.filename = 'plot_3d' vox_plot.color_by = 'material' vox_plot.colors = {eurofer: 'blue'} plots = openmc.Plots([vox_plot]) plots.export_to_xml() openmc.plot_geometry() os.system('openmc-voxel-to-vtk plot_3d.h5 -o plot_3d.vti') os.system('paraview plot_3d.vti') sett = openmc.Settings() sett.batches = batches sett.inactive = 0 sett.particles = nps 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.Discrete([14.08e6], [1]) #source.energy = openmc.stats.Muir(e0=14080000.0, m_rat=5.0, kt=20000.0) sett.source = source sett.export_to_xml('settings.xml') #tallies particle_filter = openmc.ParticleFilter([1]) surface_filter_front = openmc.SurfaceFilter(first_wall_inner_surface) surface_filter_rear = openmc.SurfaceFilter(first_wall_outer_surface) bins = openmc.mgxs.GROUP_STRUCTURES['VITAMIN-J-175'] #think will need to change this energy_filter = openmc.EnergyFilter(bins) tallies = openmc.Tallies() tally = openmc.Tally(name='incident_neutron_current') tally.filters = [surface_filter_front, particle_filter] tally.scores = ['current'] tallies.append(tally) tally = openmc.Tally(name='leakage_neutron_current') tally.filters = [surface_filter_rear, particle_filter] tally.scores = ['current'] tallies.append(tally) tally = openmc.Tally(name='incident_neutron_spectrum') tally.filters = [surface_filter_rear, particle_filter, energy_filter] tally.scores = ['flux'] tallies.append(tally) tally = openmc.Tally(name='leakage_neutron_spectrum') tally.filters = [surface_filter_front, particle_filter, energy_filter] tally.scores = ['flux'] tallies.append(tally) model = openmc.model.Model(geom, mats, sett, tallies) model.run() sp = openmc.StatePoint('statepoint.' + str(batches) + '.h5') #we want to retrieve our tallies, but we now want to save them in a .json file #therefore, we setup the json file to recieve the tally data #for now, we will simply get the json file to get the neutron current #first, we specify the 'general' parameters about the setup that we want the .json file to recieve json_output = {'inner_radius': inner_radius, 'thickness': thickness} #i.e. these are the general parameters about the setup that we want the json file to recieve #however, we also want the json file to retrieve the data from the tallies #first, we want to retrieve the neutron current at the inner and outer surfaces tallies_to_retrieve = [ 'incident_neutron_current', 'leakage_neutron_current' ] for tally_name in tallies_to_retrieve: tally = sp.get_tally(name=tally_name) df = tally.get_pandas_dataframe() #defining something that stands for dataframe, need to investigate this #its basically something that we use to obtain the mean value and the std deviation value of the tally tally_result = df['mean'].sum() tally_std_dev = df['std. dev.'].sum() json_output[tally_name] = { 'value': tally_result, 'std_dev': tally_std_dev } #next we wnat to retrieve the neutron spectra data at the inner and outer surfaces of the shell spectra_tallies_to_retrieve = [ 'incident_neutron_spectrum', 'leakage_neutron_spectrum' ] 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 ] #print(spectra_tally_result) return json_output
def make_materials_geometry_tallies(v): enrichment_fraction, thickness = v inner_radius = 500 breeder_material_name = 'Li' temperature_in_C = 500 print('simulating enrichment,', enrichment_fraction, 'thickness ', thickness) # MATERIALS from library of materials in neutronics_material_maker package breeder_material = Material( material_name=breeder_material_name, enrichment_fraction=enrichment_fraction, temperature_in_C=temperature_in_C).neutronics_material eurofer = Material(material_name='eurofer').neutronics_material 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 = 0 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 = [ '(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(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 } tally = sp.get_tally(name='TBR') df = tally.get_pandas_dataframe() json_output['TBR'] = df['mean'].sum() json_output['TBR_std_dev'] = df['std. dev.'].sum() return json_output
sett.inactive = 0 # the default is 10, which would be wasted computing for us sett.particles = 600 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 sett.photon_transport = True # This line is required to switch on photons tracking # setup the filters for the tallies photon_particle_filter = openmc.ParticleFilter( ['photon']) # This line adds a particle filter for photons surface_filter = openmc.SurfaceFilter( vessel_rear_surface) # detects particles across a surface cell_filter = openmc.CellFilter( blanket_cell) # detects particles across a cell / volume energy_bins = openmc.mgxs.GROUP_STRUCTURES['CCFE-709'] energy_filter = openmc.EnergyFilter(energy_bins) spectra_tally = openmc.Tally(name='energy_spectra') spectra_tally.scores = ['flux'] spectra_tally.filters = [cell_filter, photon_particle_filter, energy_filter] tallies = openmc.Tallies() tallies.append(spectra_tally) # combine all the required parts to make a model model = openmc.model.Model(geom, mats, sett, tallies) # Run OpenMC! results_filename = model.run()
def _build_inputs(self): # Instantiate some Materials and register the appropriate Nuclides uo2 = openmc.Material(name='UO2 fuel at 2.4% wt enrichment') uo2.set_density('g/cc', 10.0) uo2.add_nuclide('U238', 1.0) uo2.add_nuclide('U235', 0.02) uo2.add_nuclide('O16', 2.0) borated_water = openmc.Material(name='Borated water') borated_water.set_density('g/cm3', 1) borated_water.add_nuclide('B10', 10e-5) borated_water.add_nuclide('H1', 2.0) borated_water.add_nuclide('O16', 1.0) # Instantiate a Materials collection and export to XML materials_file = openmc.Materials([uo2, borated_water]) materials_file.export_to_xml() # Instantiate ZCylinder surfaces fuel_or = openmc.ZCylinder(surface_id=1, x0=0, y0=0, r=1, name='Fuel OR') left = openmc.XPlane(surface_id=2, x0=-2, name='left') right = openmc.XPlane(surface_id=3, x0=2, name='right') bottom = openmc.YPlane(y0=-2, name='bottom') top = openmc.YPlane(y0=2, name='top') left.boundary_type = 'vacuum' right.boundary_type = 'reflective' top.boundary_type = 'reflective' bottom.boundary_type = 'reflective' # Instantiate Cells fuel = openmc.Cell(name='fuel') water = openmc.Cell(name='water') # Use surface half-spaces to define regions fuel.region = -fuel_or water.region = +fuel_or & -right & +bottom & -top # Register Materials with Cells fuel.fill = uo2 water.fill = borated_water # Instantiate pin cell Universe pin_cell = openmc.Universe(name='pin cell') pin_cell.add_cells([fuel, water]) # Instantiate root Cell and Universe root_cell = openmc.Cell(name='root cell') root_cell.region = +left & -right & +bottom & -top root_cell.fill = pin_cell root_univ = openmc.Universe(universe_id=0, name='root universe') root_univ.add_cell(root_cell) # Instantiate a Geometry, register the root Universe geometry = openmc.Geometry(root_univ) geometry.export_to_xml() # Instantiate a Settings object, set all runtime parameters settings_file = openmc.Settings() settings_file.batches = 10 settings_file.inactive = 0 settings_file.particles = 1000 #settings_file.output = {'tallies': True} # Create an initial uniform spatial source distribution bounds = [-0.62992, -0.62992, -1, 0.62992, 0.62992, 1] 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() # Tallies file tallies_file = openmc.Tallies() # Create partial current tallies from fuel to water # Filters two_groups = [0., 4e6, 20e6] energy_filter = openmc.EnergyFilter(two_groups) polar_filter = openmc.PolarFilter([0, np.pi / 4, np.pi]) azimuthal_filter = openmc.AzimuthalFilter([0, np.pi / 4, np.pi]) surface_filter = openmc.SurfaceFilter([1]) cell_from_filter = openmc.CellFromFilter(fuel) cell_filter = openmc.CellFilter(water) # Use Cell to cell filters for partial current cell_to_cell_tally = openmc.Tally(name=str('fuel_to_water_1')) cell_to_cell_tally.filters = [cell_from_filter, cell_filter, \ energy_filter, polar_filter, azimuthal_filter] cell_to_cell_tally.scores = ['current'] tallies_file.append(cell_to_cell_tally) # Use a Cell from + surface filters for partial current cell_to_cell_tally = openmc.Tally(name=str('fuel_to_water_2')) cell_to_cell_tally.filters = [cell_from_filter, surface_filter, \ energy_filter, polar_filter, azimuthal_filter] cell_to_cell_tally.scores = ['current'] tallies_file.append(cell_to_cell_tally) # Create partial current tallies from water to fuel # Filters cell_from_filter = openmc.CellFromFilter(water) cell_filter = openmc.CellFilter(fuel) # Cell to cell filters for partial current cell_to_cell_tally = openmc.Tally(name=str('water_to_fuel_1')) cell_to_cell_tally.filters = [cell_from_filter, cell_filter, \ energy_filter, polar_filter, azimuthal_filter] cell_to_cell_tally.scores = ['current'] tallies_file.append(cell_to_cell_tally) # Cell from + surface filters for partial current cell_to_cell_tally = openmc.Tally(name=str('water_to_fuel_2')) cell_to_cell_tally.filters = [cell_from_filter, surface_filter, \ energy_filter, polar_filter, azimuthal_filter] cell_to_cell_tally.scores = ['current'] tallies_file.append(cell_to_cell_tally) # Create a net current tally on inner surface using a surface filter surface_filter = openmc.SurfaceFilter([1]) surf_tally1 = openmc.Tally(name='net_cylinder') surf_tally1.filters = [surface_filter, energy_filter, polar_filter, \ azimuthal_filter] surf_tally1.scores = ['current'] tallies_file.append(surf_tally1) # Create a net current tally on left surface using a surface filter # This surface has a vacuum boundary condition, so leakage is tallied surface_filter = openmc.SurfaceFilter([2]) surf_tally2 = openmc.Tally(name='leakage_left') surf_tally2.filters = [surface_filter, energy_filter, polar_filter, \ azimuthal_filter] surf_tally2.scores = ['current'] tallies_file.append(surf_tally2) # Create a net current tally on right surface using a surface filter # This surface has a reflective boundary condition, so the net current # should be zero. surface_filter = openmc.SurfaceFilter([3]) surf_tally3 = openmc.Tally(name='net_right') surf_tally3.filters = [surface_filter, energy_filter] surf_tally3.scores = ['current'] tallies_file.append(surf_tally3) surface_filter = openmc.SurfaceFilter([3]) surf_tally3 = openmc.Tally(name='net_right') surf_tally3.filters = [surface_filter, energy_filter] surf_tally3.scores = ['current'] tallies_file.append(surf_tally3) tallies_file.export_to_xml()
def make_geometry_tallies(batches, nps, 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_materials(enrichment_fraction, breeder_material_name, temperature_in_C) eurofer = make_eurofer() copper = make_copper() mats = openmc.Materials([breeder_material, eurofer, copper]) mats.export_to_xml('materials.xml') #GEOMETRY# central_sol_surface = openmc.ZCylinder(R=100) central_shield_outer_surface = openmc.ZCylinder(R=110) first_wall_inner_surface = openmc.Sphere(R=inner_radius) first_wall_outer_surface = openmc.Sphere(R=inner_radius + 10) breeder_blanket_outer_surface = openmc.Sphere(R=inner_radius + 10.0 + thickness) vessel_outer_surface = openmc.Sphere(R=inner_radius + 10.0 + thickness + 10.0, boundary_type='vacuum') central_sol_region = -central_sol_surface & -breeder_blanket_outer_surface central_sol_cell = openmc.Cell(region=central_sol_region) central_sol_cell.fill = copper central_shield_region = +central_sol_surface & -central_shield_outer_surface & -breeder_blanket_outer_surface central_shield_cell = openmc.Cell(region=central_shield_region) central_shield_cell.fill = eurofer inner_void_region = -first_wall_inner_surface & +central_shield_outer_surface inner_void_cell = openmc.Cell(region=inner_void_region) inner_void_cell.name = 'inner_void' first_wall_region = -first_wall_outer_surface & +first_wall_inner_surface & +central_shield_outer_surface first_wall_cell = openmc.Cell(region=first_wall_region) first_wall_cell.fill = eurofer breeder_blanket_region = +first_wall_outer_surface & -breeder_blanket_outer_surface & +central_shield_outer_surface breeder_blanket_cell = openmc.Cell(region=breeder_blanket_region) breeder_blanket_cell.fill = breeder_material vessel_region = +breeder_blanket_outer_surface & -vessel_outer_surface vessel_cell = openmc.Cell(region=vessel_region) vessel_cell.name = 'vessel' vessel_cell.fill = eurofer universe = openmc.Universe(cells=[ central_sol_cell, central_shield_cell, inner_void_cell, first_wall_cell, breeder_blanket_cell, vessel_cell ]) #plt.show(universe.plot(width=(1500,1500),basis='xz')) geom = openmc.Geometry(universe) # geom.export_to_xml('geometry.xml') #SIMULATION SETTINGS# sett = openmc.Settings() sett.batches = batches sett.inactive = 1 sett.particles = nps sett.run_mode = 'fixed source' source = openmc.Source() source.space = openmc.stats.Point((150, 0, 0)) source.angle = openmc.stats.Isotropic() #source.energy = openmc.stats.Discrete([14.08e6], [1]) 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 sett.export_to_xml('settings.xml') #tally filters particle_filter = openmc.ParticleFilter([1]) #1 is neutron, 2 is photon cell_filter_breeder = openmc.CellFilter(breeder_blanket_cell) cell_filter_vessel = openmc.CellFilter(vessel_cell) surface_filter_front = openmc.SurfaceFilter(first_wall_inner_surface) surface_filter_rear = openmc.SurfaceFilter(breeder_blanket_outer_surface) energy_bins = openmc.mgxs.GROUP_STRUCTURES['VITAMIN-J-175'] energy_filter = openmc.EnergyFilter(energy_bins) #TALLIES# tallies = openmc.Tallies() 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, particle_filter] tally.scores = ['current'] tallies.append(tally) tally = openmc.Tally(name='vessel_leakage') tally.filters = [surface_filter_rear, particle_filter] tally.scores = ['current'] tallies.append(tally) tally = openmc.Tally(name='rear_neutron_spectra') tally.filters = [surface_filter_rear, particle_filter, energy_filter] tally.scores = ['flux'] tallies.append(tally) tally = openmc.Tally(name='front_neutron_spectra') tally.filters = [surface_filter_front, particle_filter, energy_filter] tally.scores = ['flux'] 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() #RETRIEVING TALLY RESULTS 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) tally_result = tally.sum[0][0][ 0] / batches #for some reason the tally sum is a nested list tally_std_dev = tally.std_dev[0][0][ 0] / batches #for some reason the tally std_dev is a nested list json_output[tally_name] = { 'value': tally_result, 'std_dev': tally_std_dev } spectra_tallies_to_retrieve = [ 'front_neutron_spectra', 'breeder_blanket_spectra', 'vacuum_vessel_spectra', 'rear_neutron_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
def get_neutron_spectrum_from_plasma(plasma_temperature=14080000.0): # MATERIALS (there are none in this model) mats = openmc.Materials([]) # GEOMETRY # surfaces inner_surface = openmc.Sphere(r=100) outer_surface = openmc.Sphere(r=101, boundary_type='vacuum') # cells inner_cell = openmc.Cell(region=-inner_surface) # this is filled with a void / vauum by default outer_cell = openmc.Cell(region=+inner_surface & -outer_surface) # this is filled with a void / vauum by default universe = openmc.Universe(cells=[inner_cell, outer_cell]) geom = openmc.Geometry(universe) # SIMULATION SETTINGS # Instantiate a Settings object sett = openmc.Settings() sett.batches = 20 sett.inactive = 0 # the default is 10, which would be wasted computing for us sett.particles = 500000 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.Muir(kt=plasma_temperature) sett.source = source # setup the filters for the tallies neutron_particle_filter = openmc.ParticleFilter(['neutron']) surface_filter = openmc.SurfaceFilter( inner_surface) # detects particles across a surface energy_filter = openmc.EnergyFilter(energy_bins) spectra_tally = openmc.Tally(name='energy_spectra') spectra_tally.scores = ['current'] spectra_tally.filters = [ surface_filter, neutron_particle_filter, energy_filter ] tallies = openmc.Tallies() tallies.append(spectra_tally) # combine all the required parts to make a model model = openmc.model.Model(geom, mats, sett, tallies) # Run OpenMC! results_filename = model.run() # open the results file results = openmc.StatePoint(results_filename) #extracts the tally values from the simulation results surface_tally = results.get_tally(name='energy_spectra') surface_tally = surface_tally.get_pandas_dataframe() surface_tally_values = surface_tally['mean'] return surface_tally_values
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')
def _build_openmc(self): """Generate the OpenMC input XML """ # Directory from which openmc is run os.makedirs('openmc', exist_ok=True) # 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]) materials.export_to_xml(os.path.join('openmc', '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(os.path.join('openmc', '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() settings.source = source settings.particles = self.particles settings.run_mode = 'fixed source' settings.batches = 1 settings.photon_transport = True settings.electron_treatment = self.electron_treatment settings.cutoff = {'energy_photon': 1000.} settings.export_to_xml(os.path.join('openmc', 'settings.xml')) # Define filters surface_filter = openmc.SurfaceFilter(cyl) particle_filter = openmc.ParticleFilter('photon') energy_bins = np.logspace(3, np.log10(2 * self.energy), 500) energy_filter = openmc.EnergyFilter(energy_bins) # Create tallies and export to XML tally = openmc.Tally(name='photon current') tally.filters = [surface_filter, energy_filter, particle_filter] tally.scores = ['current'] tallies = openmc.Tallies([tally]) tallies.export_to_xml(os.path.join('openmc', 'tallies.xml'))
def _build_inputs(self): mat = openmc.Material() mat.set_density('g/cm3', 2.6989) mat.add_nuclide('Al27', 1.0) materials = openmc.Materials([mat]) materials.export_to_xml() cyl = openmc.XCylinder(r=1.0, boundary_type='vacuum') x_plane_left = openmc.XPlane(-1.0, 'vacuum') x_plane_center = openmc.XPlane(1.0) x_plane_right = openmc.XPlane(1.0e9, 'vacuum') inner_cyl_left = openmc.Cell() inner_cyl_right = openmc.Cell() outer_cyl = openmc.Cell() inner_cyl_left.region = -cyl & +x_plane_left & -x_plane_center inner_cyl_right.region = -cyl & +x_plane_center & -x_plane_right outer_cyl.region = ~(-cyl & +x_plane_left & -x_plane_right) inner_cyl_right.fill = mat geometry = openmc.Geometry( [inner_cyl_left, inner_cyl_right, outer_cyl]) geometry.export_to_xml() source = openmc.Source() source.space = openmc.stats.Point((0, 0, 0)) source.angle = openmc.stats.Monodirectional() source.energy = openmc.stats.Discrete([14.0e6], [1.0]) source.particle = 'neutron' settings = openmc.Settings() settings.particles = 10000 settings.run_mode = 'fixed source' settings.batches = 1 settings.photon_transport = True settings.electron_treatment = 'ttb' settings.cutoff = {'energy_photon': 1000.0} settings.source = source settings.export_to_xml() surface_filter = openmc.SurfaceFilter(cyl) particle_filter = openmc.ParticleFilter('photon') current_tally = openmc.Tally() current_tally.filters = [surface_filter, particle_filter] current_tally.scores = ['current'] tally_tracklength = openmc.Tally() tally_tracklength.filters = [particle_filter] tally_tracklength.scores = ['total', 'heating'] tally_tracklength.nuclides = ['Al27', 'total'] tally_tracklength.estimator = 'tracklength' tally_collision = openmc.Tally() tally_collision.filters = [particle_filter] tally_collision.scores = ['total', 'heating'] tally_collision.nuclides = ['Al27', 'total'] tally_collision.estimator = 'collision' tally_analog = openmc.Tally() tally_analog.filters = [particle_filter] tally_analog.scores = ['total', 'heating'] tally_analog.nuclides = ['Al27', 'total'] tally_analog.estimator = 'analog' tallies = openmc.Tallies( [current_tally, tally_tracklength, tally_collision, tally_analog]) tallies.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()
def model(): model = openmc.model.Model() mat = openmc.Material() mat.set_density('g/cm3', 2.6989) mat.add_nuclide('Al27', 1.0) model.materials.append(mat) cyl = openmc.XCylinder(r=1.0, boundary_type='vacuum') x_plane_left = openmc.XPlane(-1.0, boundary_type='vacuum') x_plane_center = openmc.XPlane(1.0) x_plane_right = openmc.XPlane(1.0e9, boundary_type='vacuum') inner_cyl_left = openmc.Cell() inner_cyl_right = openmc.Cell() outer_cyl = openmc.Cell() inner_cyl_left.region = -cyl & +x_plane_left & -x_plane_center inner_cyl_right.region = -cyl & +x_plane_center & -x_plane_right outer_cyl.region = ~(-cyl & +x_plane_left & -x_plane_right) inner_cyl_right.fill = mat model.geometry = openmc.Geometry( [inner_cyl_left, inner_cyl_right, outer_cyl]) source = openmc.Source() source.space = openmc.stats.Point((0, 0, 0)) source.angle = openmc.stats.Monodirectional() source.energy = openmc.stats.Discrete([14.0e6], [1.0]) source.particle = 'neutron' model.settings.particles = 10000 model.settings.run_mode = 'fixed source' model.settings.batches = 1 model.settings.photon_transport = True model.settings.electron_treatment = 'ttb' model.settings.cutoff = {'energy_photon': 1000.0} model.settings.source = source surface_filter = openmc.SurfaceFilter(cyl) particle_filter = openmc.ParticleFilter( ['neutron', 'photon', 'electron', 'positron']) current_tally = openmc.Tally() current_tally.filters = [surface_filter, particle_filter] current_tally.scores = ['current'] tally_tracklength = openmc.Tally() tally_tracklength.filters = [particle_filter] tally_tracklength.scores = ['total', '(n,gamma)' ] # heating doesn't work with tracklength tally_tracklength.nuclides = ['Al27', 'total'] tally_tracklength.estimator = 'tracklength' tally_collision = openmc.Tally() tally_collision.filters = [particle_filter] tally_collision.scores = ['total', 'heating', '(n,gamma)'] tally_collision.nuclides = ['Al27', 'total'] tally_collision.estimator = 'collision' tally_analog = openmc.Tally() tally_analog.filters = [particle_filter] tally_analog.scores = ['total', 'heating', '(n,gamma)'] tally_analog.nuclides = ['Al27', 'total'] tally_analog.estimator = 'analog' model.tallies.extend( [current_tally, tally_tracklength, tally_collision, tally_analog]) return model