def inf_medium_model(cutoff_energy, source_energy): """Infinite medium problem with a monoenergetic photon source""" model = openmc.Model() m = openmc.Material() m.add_nuclide('Zr90', 1.0) m.set_density('g/cm3', 1.0) sph = openmc.Sphere(r=100.0, boundary_type='reflective') cell = openmc.Cell(fill=m, region=-sph) model.geometry = openmc.Geometry([cell]) model.settings.run_mode = 'fixed source' model.settings.source = openmc.Source( particle='photon', energy=openmc.stats.Discrete([source_energy], [1.0]), ) model.settings.particles = 100 model.settings.batches = 10 model.settings.cutoff = {'energy_photon': cutoff_energy} tally_flux = openmc.Tally(name='flux') tally_flux.filters = [ openmc.EnergyFilter([0.0, cutoff_energy, source_energy]), openmc.ParticleFilter(['photon']) ] tally_flux.scores = ['flux'] tally_heating = openmc.Tally(name='heating') tally_heating.scores = ['heating'] model.tallies = openmc.Tallies([tally_flux, tally_heating]) return model
def _make_openmc_input(self): """Generate the OpenMC input XML """ # Define material mat = openmc.Material() for element, fraction in self.elements: mat.add_element(element, 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') # Set up geometry x1 = openmc.XPlane(x0=-1.e9, boundary_type='reflective') x2 = openmc.XPlane(x0=+1.e9, boundary_type='reflective') y1 = openmc.YPlane(y0=-1.e9, boundary_type='reflective') y2 = openmc.YPlane(y0=+1.e9, boundary_type='reflective') z1 = openmc.ZPlane(z0=-1.e9, boundary_type='reflective') z2 = openmc.ZPlane(z0=+1.e9, boundary_type='reflective') cell = openmc.Cell(fill=materials) cell.region = +x1 & -x2 & +y1 & -y2 & +z1 & -z2 geometry = openmc.Geometry([cell]) 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.Isotropic() source.energy = openmc.stats.Discrete([self.energy], [1.]) source.particle = 'photon' # Settings settings = openmc.Settings() 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 tallies energy_bins = np.logspace(np.log10(self._cutoff_energy), np.log10(1.0001*self.energy), self._bins+1) energy_filter = openmc.EnergyFilter(energy_bins) particle_filter = openmc.ParticleFilter('photon') tally = openmc.Tally(name='tally') tally.filters = [energy_filter, particle_filter] tally.scores = ['flux'] 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 element, fraction in self.elements: mat.add_element(element, fraction) mat.set_density('g/cm3', self.density) materials = openmc.Materials([mat]) materials.export_to_xml(os.path.join('openmc', 'materials.xml')) # Set up geometry sphere = openmc.Sphere(boundary_type='reflective', R=1.e9) cell = openmc.Cell() cell.fill = mat cell.region = -sphere geometry = openmc.Geometry([cell]) 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.Isotropic() source.energy = openmc.stats.Discrete([self.energy], [1.]) source.particle = 'photon' # 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 tallies cell_filter = openmc.CellFilter(cell) energy_bins = np.logspace(3, np.log10(self.energy), 500) energy_filter = openmc.EnergyFilter(energy_bins) particle_filter = openmc.ParticleFilter('photon') tally = openmc.Tally(name='photon flux') tally.filters = [cell_filter, energy_filter, particle_filter] tally.scores = ['flux'] 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', 0.998207) mat.add_element('H', 0.111894) mat.add_element('O', 0.888106) materials = openmc.Materials([mat]) materials.export_to_xml() sphere = openmc.Sphere(r=1.0e9, boundary_type='reflective') inside_sphere = openmc.Cell() inside_sphere.region = -sphere inside_sphere.fill = mat geometry = openmc.Geometry([inside_sphere]) geometry.export_to_xml() source = openmc.Source() source.space = openmc.stats.Point((0, 0, 0)) source.angle = openmc.stats.Isotropic() source.energy = openmc.stats.Discrete([10.0e6], [1.0]) source.particle = 'photon' settings = openmc.Settings() settings.particles = 10000 settings.batches = 1 settings.photon_transport = True settings.electron_treatment = 'ttb' settings.cutoff = {'energy_photon': 1000.0} settings.run_mode = 'fixed source' settings.source = source settings.export_to_xml() particle_filter = openmc.ParticleFilter('photon') tally = openmc.Tally() tally.filters = [particle_filter] tally.scores = ['flux', '(n,gamma)'] tallies = openmc.Tallies([tally]) tallies.export_to_xml()
def model(): model = openmc.model.Model() mat = openmc.Material() mat.set_density('g/cm3', 10.0) mat.add_nuclide('U235', 1.0) model.materials.append(mat) sph = openmc.Sphere(r=100.0, boundary_type='reflective') cell = openmc.Cell(fill=mat, region=-sph) model.geometry = openmc.Geometry([cell]) model.settings.particles = 1000 model.settings.batches = 5 model.settings.inactive = 2 model.settings.photon_transport = True model.settings.source = openmc.Source(space=openmc.stats.Point((0, 0, 0))) particle_filter = openmc.ParticleFilter(['neutron', 'photon']) tally_tracklength = openmc.Tally() tally_tracklength.filters = [particle_filter] tally_tracklength.scores = ['fission', 'heating-local'] tally_tracklength.nuclides = ['U235', 'total'] tally_tracklength.estimator = 'tracklength' tally_collision = openmc.Tally() tally_collision.filters = [particle_filter] tally_collision.scores = ['fission', 'heating', 'heating-local'] tally_collision.nuclides = ['U235', 'total'] tally_collision.estimator = 'collision' tally_analog = openmc.Tally() tally_analog.filters = [particle_filter] tally_analog.scores = ['fission', 'heating', 'heating-local'] tally_analog.nuclides = ['U235', 'total'] tally_analog.estimator = 'analog' model.tallies.extend([tally_tracklength, tally_collision, tally_analog]) return model
def find_tbr_from_graded_blanket( number_of_layers, layer_thickness_fractions, layer_li6_enrichments, layer_breeder_fractions, layer_multiplier_fractions, blanket_structural_material, blanket_multiplier_material, blanket_breeder_material, firstwall_coolant, blanket_structural_fraction, inner_radius, thickness, firstwall_thickness): batches = 10 thickness_fraction_scaler = thickness / sum(layer_thickness_fractions) print('thickness_fraction_scaler', thickness_fraction_scaler) if firstwall_coolant == 'no firstwall': breeder_blanket_inner_surface = openmc.Sphere(r=inner_radius) inner_void_region = -breeder_blanket_inner_surface inner_void_cell = openmc.Cell(region=inner_void_region) inner_void_cell.name = 'inner_void' surfaces = [breeder_blanket_inner_surface] additional_thickness = 0 all_layers_materials = [] all_cells = [inner_void_cell] for i, (layer_thickness, layer_enrichment, layer_breeder_fraction, layer_multiplier_fraction) in enumerate( zip(layer_thickness_fractions, layer_li6_enrichments, layer_breeder_fractions, layer_multiplier_fractions)): print(i, layer_thickness, layer_enrichment, layer_breeder_fraction) layer_material = MultiMaterial( material_name='layer_' + str(i) + '_material', materials=[ Material(blanket_breeder_material, enrichment_fraction=layer_enrichment), Material(blanket_multiplier_material), Material(blanket_structural_material) ], fracs=[ layer_breeder_fraction, layer_multiplier_fraction, blanket_structural_fraction ]).neutronics_material all_layers_materials.append(layer_material) additional_thickness = additional_thickness + ( layer_thickness * thickness_fraction_scaler) print('additional_thickness', additional_thickness) if i == number_of_layers - 1: layer_outer_surface = openmc.Sphere(r=inner_radius + additional_thickness, boundary_type='vacuum') else: layer_outer_surface = openmc.Sphere(r=inner_radius + additional_thickness) layer_inner_surface = surfaces[-1] layer_region = -layer_outer_surface & +layer_inner_surface layer_cell = openmc.Cell(region=layer_region) layer_cell.fill = layer_material layer_cell.name = 'layer_' + str(i) + '_cell' surfaces.append(layer_outer_surface) all_cells.append(layer_cell) else: #firstwall is present firstwall_material = MultiMaterial( material_name='firstwall_material', materials=[ Material('tungsten'), Material(firstwall_coolant), Material(blanket_structural_material) ], fracs=[0.055262, 0.253962, 0.690776] #based on HCPB paper with 2mm W firstwall ).neutronics_material breeder_blanket_inner_surface = openmc.Sphere(r=inner_radius + firstwall_thickness) firstwall_outer_surface = openmc.Sphere(r=inner_radius) surfaces = [firstwall_outer_surface, breeder_blanket_inner_surface] inner_void_region = -firstwall_outer_surface inner_void_cell = openmc.Cell(region=inner_void_region) inner_void_cell.name = 'inner_void' firstwall_region = +firstwall_outer_surface & -breeder_blanket_inner_surface firstwall_cell = openmc.Cell(region=firstwall_region) firstwall_cell.fill = firstwall_material firstwall_cell.name = 'firstwall' additional_thickness = 0 all_layers_materials = [firstwall_material] all_cells = [inner_void_cell, firstwall_cell] for i, (layer_thickness, layer_enrichment, layer_breeder_fraction, layer_multiplier_fraction) in enumerate( zip(layer_thickness_fractions, layer_li6_enrichments, layer_breeder_fractions, layer_multiplier_fractions)): print(i, layer_thickness, layer_enrichment, layer_breeder_fraction) layer_material = MultiMaterial( 'layer_' + str(i) + '_material', materials=[ Material(blanket_breeder_material, enrichment_fraction=layer_enrichment), Material(blanket_multiplier_material), Material(blanket_structural_material) ], volume_fractions=[ layer_breeder_fraction, layer_multiplier_fraction, blanket_structural_fraction ]) all_layers_materials.append(layer_material) additional_thickness = additional_thickness + ( layer_thickness * thickness_fraction_scaler) print('additional_thickness', additional_thickness) if i == number_of_layers - 1: layer_outer_surface = openmc.Sphere(r=inner_radius + firstwall_thickness + additional_thickness, boundary_type='vacuum') else: layer_outer_surface = openmc.Sphere(r=inner_radius + firstwall_thickness + additional_thickness) layer_inner_surface = surfaces[-1] layer_region = -layer_outer_surface & +layer_inner_surface layer_cell = openmc.Cell(region=layer_region) layer_cell.fill = layer_material layer_cell.name = 'layer_' + str(i) + '_cell' surfaces.append(layer_outer_surface) all_cells.append(layer_cell) universe = openmc.Universe(cells=all_cells) geom = openmc.Geometry(universe) mats = openmc.Materials(all_layers_materials) 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) particle_filter = openmc.ParticleFilter(['neutron' ]) #1 is neutron, 2 is photon tally = openmc.Tally(name='TBR') tally.filters = [particle_filter] tally.scores = ['(n,Xt)'] #could be (n,Xt) tallies.append(tally) model = openmc.model.Model(geom, mats, sett, tallies) model.export_to_xml() # model.run() openmc.lib.run() sp = openmc.StatePoint('statepoint.' + str(batches) + '.h5') tally = sp.get_tally(name='TBR') df = tally.get_pandas_dataframe() return df['mean'].sum()
fuel_material.volume = volume[fuel_material] #+ volume[fuel_hot]; print("Volume:", volume[fuel_material]) ############################################################################### tallies_file = openmc.Tallies() # XY-MESH #Creating mesh and mesh filter mesh_xy = openmc.RegularMesh(mesh_id=1) mesh_xy.dimension = [200,200,1] mesh_xy.lower_left = [-100,-100,-1.e50] mesh_xy.upper_right = [100,100,1.e50] mesh_filter_xy = openmc.MeshFilter(mesh_xy) particle_filter = openmc.ParticleFilter(['neutron','photon'], filter_id=2) #Creating mesh tally tally_xy = openmc.Tally(name='flux_xy',tally_id=1) tally_xy.filters = [mesh_filter_xy,particle_filter] tally_xy.scores = ['flux','fission','nu-fission'] tallies_file.append(tally_xy) # XZ-MESH #Creating mesh and mesh filter mesh_xz = openmc.RegularMesh(mesh_id=2) mesh_xz.dimension = [200,1,200] mesh_xz.lower_left = [-100,-1.e50,-100] mesh_xz.upper_right = [100,1.e50,100]
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 _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'))
sett.inactive = 0 sett.particles = 5000 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 sett.photon_transport = True # This line is required to switch on photons tracking # setup the tallies tallies = openmc.Tallies() photon_particle_filter = openmc.ParticleFilter(['photon']) # This line adds a particle filter for photons neutron_particle_filter = openmc.ParticleFilter(['neutron']) cell_filter = openmc.CellFilter(breeder_blanket_cell) energy_bins = openmc.mgxs.GROUP_STRUCTURES['VITAMIN-J-175'] energy_filter = openmc.EnergyFilter(energy_bins) spectra_tally = openmc.Tally(name='breeder_blanket_neutron_spectra') spectra_tally.filters = [cell_filter, neutron_particle_filter, energy_filter] spectra_tally.scores = ['flux'] tallies.append(spectra_tally) spectra_tally = openmc.Tally(name='breeder_blanket_photon_spectra') spectra_tally.filters = [cell_filter, photon_particle_filter, energy_filter] spectra_tally.scores = ['flux'] tallies.append(spectra_tally)
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 create_neutronics_model(self, method: str = None): """Uses OpenMC python API to make a neutronics model, including tallies (cell_tallies and mesh_tally_2d), simulation settings (batches, particles per batch). Arguments: method: (str): The method to use when making the imprinted and merged geometry. Options are "ppp", "trelis", "pymoab". Defaults to None. """ self.create_materials() self.create_neutronics_geometry(method=method) # this is the underlying geometry container that is filled with the # faceteted DGAMC CAD model self.universe = openmc.Universe() geom = openmc.Geometry(self.universe) # settings for the number of neutrons to simulate settings = openmc.Settings() settings.batches = self.simulation_batches settings.inactive = 0 settings.particles = self.simulation_particles_per_batch settings.run_mode = "fixed source" settings.dagmc = True settings.photon_transport = True settings.source = self.source settings.max_lost_particles = self.max_lost_particles # details about what neutrons interactions to keep track of (tally) self.tallies = openmc.Tallies() if self.mesh_tally_3d is not None: mesh_xyz = openmc.RegularMesh(mesh_id=1, name='3d_mesh') mesh_xyz.dimension = self.mesh_3D_resolution mesh_xyz.lower_left = [ -self.geometry.largest_dimension, -self.geometry.largest_dimension, -self.geometry.largest_dimension ] mesh_xyz.upper_right = [ self.geometry.largest_dimension, self.geometry.largest_dimension, self.geometry.largest_dimension ] for standard_tally in self.mesh_tally_3d: if standard_tally == 'tritium_production': score = '(n,Xt)' # where X is a wild card prefix = 'tritium_production' else: score = standard_tally prefix = standard_tally mesh_filter = openmc.MeshFilter(mesh_xyz) tally = openmc.Tally(name=prefix + '_on_3D_mesh') tally.filters = [mesh_filter] tally.scores = [score] self.tallies.append(tally) if self.mesh_tally_2d is not None: # Create mesh which will be used for tally mesh_xz = openmc.RegularMesh(mesh_id=2, name='2d_mesh_xz') mesh_xz.dimension = [ self.mesh_2D_resolution[1], 1, self.mesh_2D_resolution[0] ] mesh_xz.lower_left = [ -self.geometry.largest_dimension, -1, -self.geometry.largest_dimension ] mesh_xz.upper_right = [ self.geometry.largest_dimension, 1, self.geometry.largest_dimension ] mesh_xy = openmc.RegularMesh(mesh_id=3, name='2d_mesh_xy') mesh_xy.dimension = [ self.mesh_2D_resolution[1], self.mesh_2D_resolution[0], 1 ] mesh_xy.lower_left = [ -self.geometry.largest_dimension, -self.geometry.largest_dimension, -1 ] mesh_xy.upper_right = [ self.geometry.largest_dimension, self.geometry.largest_dimension, 1 ] mesh_yz = openmc.RegularMesh(mesh_id=4, name='2d_mesh_yz') mesh_yz.dimension = [ 1, self.mesh_2D_resolution[1], self.mesh_2D_resolution[0] ] mesh_yz.lower_left = [ -1, -self.geometry.largest_dimension, -self.geometry.largest_dimension ] mesh_yz.upper_right = [ 1, self.geometry.largest_dimension, self.geometry.largest_dimension ] for standard_tally in self.mesh_tally_2d: if standard_tally == 'tritium_production': score = '(n,Xt)' # where X is a wild card prefix = 'tritium_production' else: score = standard_tally prefix = standard_tally for mesh_filter, plane in zip( [mesh_xz, mesh_xy, mesh_yz], ['xz', 'xy', 'yz']): mesh_filter = openmc.MeshFilter(mesh_filter) tally = openmc.Tally(name=prefix + '_on_2D_mesh_' + plane) tally.filters = [mesh_filter] tally.scores = [score] self.tallies.append(tally) if self.cell_tallies is not None: for standard_tally in self.cell_tallies: if standard_tally == 'TBR': score = '(n,Xt)' # where X is a wild card sufix = 'TBR' tally = openmc.Tally(name='TBR') tally.scores = [score] self.tallies.append(tally) self._add_tally_for_every_material(sufix, score) elif standard_tally == 'spectra': neutron_particle_filter = openmc.ParticleFilter([ 'neutron']) photon_particle_filter = openmc.ParticleFilter(['photon']) energy_bins = openmc.mgxs.GROUP_STRUCTURES['CCFE-709'] energy_filter = openmc.EnergyFilter(energy_bins) self._add_tally_for_every_material( 'neutron_spectra', 'flux', [neutron_particle_filter, energy_filter] ) self._add_tally_for_every_material( 'photon_spectra', 'flux', [photon_particle_filter, energy_filter] ) else: score = standard_tally sufix = standard_tally self._add_tally_for_every_material(sufix, score) # make the model from gemonetry, materials, settings and tallies self.model = openmc.model.Model( geom, self.mats, settings, self.tallies)
def simulate_model( enrichment, thickness, breeder_material_name="Li4SiO4", temperature_in_C=500, batches=10, nps=1000, inner_radius=500, ): # MATERIALS from library of materials in neutronics_material_maker package breeder_material = Material( material_name=breeder_material_name, enrichment=enrichment, temperature_in_C=temperature_in_C, ).neutronics_material eurofer = Material(material_name="eurofer").neutronics_material copper = Material(material_name="copper").neutronics_material 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, ]) geom = openmc.Geometry(universe) # SIMULATION SETTINGS# 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((150, 0, 0)) source.angle = openmc.stats.Isotropic() source.energy = openmc.stats.Discrete([14.08e6], [1]) sett.source = source # sett.export_to_xml("settings.xml") # tally filters particle_filter = openmc.ParticleFilter("neutron") cell_filter_breeder = openmc.CellFilter(breeder_blanket_cell) # TALLIES# tallies = openmc.Tallies() tally = openmc.Tally(name="TBR") tally.filters = [cell_filter_breeder, particle_filter] tally.scores = ["(n,Xt)"] tallies.append(tally) # RUN OPENMC # model = openmc.model.Model(geom, mats, sett, tallies) model.run(output=False) # RETRIEVING TALLY RESULTS sp = openmc.StatePoint("statepoint." + str(batches) + ".h5") json_output = { "batches": batches, "nps": nps, "enrichment": enrichment, "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
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 _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()
sett.inactive = 1 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]) # source.file = 'source_7000_particles.h5' # not working for some reason sett.source = source #setup the tallies tallies = openmc.Tallies() particle_filter = openmc.ParticleFilter([1]) #1 is neutron, 2 is photon 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,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,particle_filter,energy_filter] spectra_tally.scores = ['flux'] tallies.append(spectra_tally)
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 find_tbr_model_sphere_with_firstwall(blanket_thickness, blanket_material, firstwall_material, firstwall_thickness, number_of_batches, particles_per_batch): inner_radius = 1000 #10m thickness = blanket_thickness # batches = number_of_batches mats = openmc.Materials([blanket_material, firstwall_material]) breeder_blanket_inner_surface = openmc.Sphere(r=inner_radius + firstwall_thickness) firstwall_outer_surface = openmc.Sphere(r=inner_radius) inner_void_region = -firstwall_outer_surface inner_void_cell = openmc.Cell(region=inner_void_region) inner_void_cell.name = 'inner_void' firstwall_region = +firstwall_outer_surface & -breeder_blanket_inner_surface firstwall_cell = openmc.Cell(region=firstwall_region) firstwall_cell.fill = firstwall_material firstwall_cell.name = 'firstwall' breeder_blanket_outer_surface = openmc.Sphere( r=inner_radius + firstwall_thickness + thickness, 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 = blanket_material breeder_blanket_cell.name = 'breeder_blanket' universe = openmc.Universe( cells=[inner_void_cell, firstwall_cell, breeder_blanket_cell]) geom = openmc.Geometry(universe) #SIMULATION SETTINGS# sett = openmc.Settings() # batches = 10 # this is parsed as an argument sett.batches = number_of_batches sett.inactive = 0 sett.particles = particles_per_batch sett.run_mode = 'fixed source' # sett.verbosity = 1 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 # source.energy = openmc.stats.Discrete([14e6], [1]) sett.source = source #TALLIES# tallies = openmc.Tallies() # define filters cell_filter_breeder = openmc.CellFilter(breeder_blanket_cell) particle_filter = openmc.ParticleFilter(['neutron' ]) #1 is neutron, 2 is photon 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) model = openmc.model.Model(geom, mats, sett, tallies) model.export_to_xml() model.run() # openmc.lib.run() sp = openmc.StatePoint('statepoint.' + str(number_of_batches) + '.h5') tally = sp.get_tally(name='TBR') df = tally.get_pandas_dataframe() # print(df) tally_result = df['mean'].sum() tally_std_dev = df['std. dev.'].sum() results = {'tbr': tally_result, 'tbr_error': tally_std_dev} return results
def sphere_with_firstwall_model( material_for_structure, blanket_breeder_material, blanket_coolant_material, firstwall_coolant_material, blanket_breeder_li6_enrichment, # this is a percentage coolant_pressure, # this is in Pa blanket_coolant_temperature_in_C, firstwall_coolant_temperature_in_C, blanket_breeder_fraction, blanket_coolant_fraction, blanket_structural_fraction, blanket_breeder_temperature_in_C = None, #needed for liquid breeders like lithium lead firstwall_thickness = 2.7, # this is in cm blanket_thickness = 200, # this is in cm inner_radius = 1000, firstwall_armour_fraction = 0.106305, # equivilent to 3mm and based on https://doi.org/10.1016/j.fusengdes.2017.02.008 firstwall_coolant_fraction= 0.333507, # based on https://doi.org/10.1016/j.fusengdes.2017.02.008 firstwall_structural_fraction = 0.560188, # based on https://doi.org/10.1016/j.fusengdes.2017.02.008 blanket_multipler_material = None, #used for combined breeder multiplier options blanket_multiplier_fraction = None, #used for combined breeder multiplier options blanket_breeder_material_packing_fraction = None, #used for combined breeder multiplier options blanket_multiplier_packing_fraction = None, #used for combined breeder multiplier options blanket_multiplier_material = None #used for combined breeder multiplier options ): breeder_percent_in_breeder_plus_multiplier_ratio = 100 * (blanket_breeder_fraction / (blanket_breeder_fraction + blanket_multiplier_fraction)) inputs = locals() """ This function builds materials for the homogenised blanket material, homogenised firstwall material The creates a simple sphere geometry with a simple point source and TBR tally on the blanket The function also carries out the simulation and writes the results to a JSON file """ # creates homogensied blanket material using a single breeder / multiplier material (e.g lithium lead) if blanket_breeder_material == 'Pb842Li158': blanket_material = MultiMaterial(material_tag = 'blanket_material', materials = [ Material(material_name = material_for_structure), Material(material_name = blanket_coolant_material, temperature_in_C = blanket_coolant_temperature_in_C, pressure_in_Pa = coolant_pressure), Material(material_name = blanket_breeder_material, enrichment = blanket_breeder_li6_enrichment, temperature_in_C = blanket_breeder_temperature_in_C), ], fracs = [blanket_structural_fraction, blanket_coolant_fraction, blanket_breeder_fraction], percent_type='vo' ).openmc_material # creates homogensied blanket material using a combined breeder multiplier material (e.g lithium ceramic with be multiplier) else: blanket_material = MultiMaterial( material_tag = 'blanket_material', materials = [ Material(material_name = material_for_structure), Material(material_name = blanket_coolant_material, temperature_in_C = blanket_coolant_temperature_in_C, pressure_in_Pa = coolant_pressure), Material(material_name = blanket_breeder_material, enrichment = blanket_breeder_li6_enrichment, packing_fraction = blanket_breeder_material_packing_fraction), Material(material_name = blanket_multipler_material, packing_fraction = blanket_multiplier_packing_fraction), ], fracs = [blanket_structural_fraction, blanket_coolant_fraction, blanket_breeder_fraction, blanket_multiplier_fraction], percent_type='vo' ).openmc_material # creates homogensied firstwall material with eurofer, tungsten and a coolant firstwall_material = MultiMaterial(material_tag = 'firstwall_material', materials = [ Material(material_name = 'tungsten'), Material(material_name = firstwall_coolant_material, temperature_in_C = firstwall_coolant_temperature_in_C, pressure_in_Pa = coolant_pressure), Material(material_name = 'eurofer')], fracs = [firstwall_armour_fraction, firstwall_coolant_fraction, firstwall_structural_fraction] ).openmc_material mats = openmc.Materials([blanket_material, firstwall_material]) # creates surfaces breeder_blanket_inner_surface = openmc.Sphere(r=inner_radius+firstwall_thickness) firstwall_outer_surface = openmc.Sphere(r=inner_radius) inner_void_region = -firstwall_outer_surface inner_void_cell = openmc.Cell(region=inner_void_region) inner_void_cell.name = 'inner_void' firstwall_region = +firstwall_outer_surface & -breeder_blanket_inner_surface firstwall_cell = openmc.Cell(name='firstwall', region=firstwall_region) firstwall_cell.fill = firstwall_material breeder_blanket_outer_surface = openmc.Sphere(r=inner_radius+firstwall_thickness+blanket_thickness, boundary_type='vacuum') breeder_blanket_region = -breeder_blanket_outer_surface & +breeder_blanket_inner_surface breeder_blanket_cell = openmc.Cell(name = 'breeder_blanket', region=breeder_blanket_region) breeder_blanket_cell.fill = blanket_material universe = openmc.Universe(cells=[inner_void_cell, firstwall_cell, breeder_blanket_cell]) geom = openmc.Geometry(universe) # assigns simulation settings sett = openmc.Settings() sett.batches = 200 # this is minimum number of batches that will be run sett.trigger_active = True sett.trigger_max_batches = 1500 # this is maximum number of batches that will be run sett.particles = 300 sett.verbosity = 1 sett.run_mode = 'fixed source' # sets a 14MeV (distributuion) point 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 # this is the tally set up tallies = openmc.Tallies() # define filters cell_filter_breeder = openmc.CellFilter(breeder_blanket_cell) particle_filter = openmc.ParticleFilter(['neutron']) # creates the TBR tally using the filters and sets a completion trigger tally = openmc.Tally(name='TBR') tally.filters = [cell_filter_breeder, particle_filter] tally.scores = ['(n,Xt)'] # 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 tally.triggers = [openmc.Trigger(trigger_type='rel_err', threshold=0.0001)] # This stops the simulation if the threshold is meet tallies.append(tally) # collects all the model parts and runs the model model = openmc.model.Model(geom, mats, sett, tallies) sp_filename = model.run(output=False) # opens the output file and retrieves the tally results sp = openmc.StatePoint(sp_filename) tally = sp.get_tally(name='TBR') df = tally.get_pandas_dataframe() tally_result = df['mean'].sum() tally_std_dev = df['std. dev.'].sum() # combines the tally results with the input data inputs.update({'tbr': tally_result}) inputs.update({'tbr_error': tally_std_dev}) return inputs
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
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
model.settings.source = openmc.source.Source(space=uniform_dist) entropy_mesh = openmc.RegularMesh() entropy_mesh.lower_left = [-10.71, -10.71] entropy_mesh.upper_right = [10.71, 10.71] entropy_mesh.dimension = [10, 10] model.settings.entropy_mesh = entropy_mesh ############################################################################### # Analysis # Get heating in a neutron-only calculation tally = openmc.Tally(name='heating') tally.filters = [ openmc.MaterialFilter([fuel_31, helium, zirc4, ss304, agincd, water_600]), openmc.ParticleFilter(['neutron', 'photon', 'electron', 'positron']) ] tally.scores = ['fission', 'heating-local'] total_tally = openmc.Tally(name='total') total_tally.scores = ['fission', 'heating-local', 'heating'] model.tallies = openmc.Tallies([tally, total_tally]) sp_path = model.run() with openmc.StatePoint(sp_path) as sp: t = sp.get_tally(name='heating') df_neutron = t.get_pandas_dataframe() # Get heating in a coupled neutron-photon calculation model.settings.photon_transport = True
def model(): model = openmc.Model() # materials (M4 steel alloy) m4 = openmc.Material() m4.set_density('g/cc', 2.3) m4.add_nuclide('H1', 0.168018676) m4.add_nuclide("H2", 1.93244e-05) m4.add_nuclide("O16", 0.561814465) m4.add_nuclide("O17", 0.00021401) m4.add_nuclide("Na23", 0.021365) m4.add_nuclide("Al27", 0.021343) m4.add_nuclide("Si28", 0.187439342) m4.add_nuclide("Si29", 0.009517714) m4.add_nuclide("Si30", 0.006273944) m4.add_nuclide("Ca40", 0.018026179) m4.add_nuclide("Ca42", 0.00012031) m4.add_nuclide("Ca43", 2.51033e-05) m4.add_nuclide("Ca44", 0.000387892) m4.add_nuclide("Ca46", 7.438e-07) m4.add_nuclide("Ca48", 3.47727e-05) m4.add_nuclide("Fe54", 0.000248179) m4.add_nuclide("Fe56", 0.003895875) m4.add_nuclide("Fe57", 8.99727e-05) m4.add_nuclide("Fe58", 1.19737e-05) s0 = openmc.Sphere(r=240) s1 = openmc.Sphere(r=250, boundary_type='vacuum') c0 = openmc.Cell(fill=m4, region=-s0) c1 = openmc.Cell(region=+s0 & -s1) model.geometry = openmc.Geometry([c0, c1]) # settings settings = model.settings settings.run_mode = 'fixed source' settings.particles = 200 settings.batches = 2 settings.max_splits = 200 settings.photon_transport = True space = Point((0.001, 0.001, 0.001)) energy = Discrete([14E6], [1.0]) settings.source = openmc.Source(space=space, energy=energy) # tally mesh = openmc.RegularMesh() mesh.lower_left = (-240, -240, -240) mesh.upper_right = (240, 240, 240) mesh.dimension = (5, 10, 15) mesh_filter = openmc.MeshFilter(mesh) e_bnds = [0.0, 0.5, 2E7] energy_filter = openmc.EnergyFilter(e_bnds) particle_filter = openmc.ParticleFilter(['neutron', 'photon']) tally = openmc.Tally() tally.filters = [mesh_filter, energy_filter, particle_filter] tally.scores = ['flux'] model.tallies.append(tally) # weight windows # load pre-generated weight windows # (created using the same tally as above) ww_n_lower_bnds = np.loadtxt('ww_n.txt') ww_p_lower_bnds = np.loadtxt('ww_p.txt') # create a mesh matching the one used # to generate the weight windows ww_mesh = openmc.RegularMesh() ww_mesh.lower_left = (-240, -240, -240) ww_mesh.upper_right = (240, 240, 240) ww_mesh.dimension = (5, 6, 7) ww_n = openmc.WeightWindows(ww_mesh, ww_n_lower_bnds, None, 10.0, e_bnds, max_lower_bound_ratio=1.5) ww_p = openmc.WeightWindows(ww_mesh, ww_p_lower_bnds, None, 10.0, e_bnds, max_lower_bound_ratio=1.5) model.settings.weight_windows = [ww_n, ww_p] return model
sett.batches = 2 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 ] spectra_tally.scores = ['flux']
def simulate_model(enrichment, blanket_thickness=200, firstwall_thickness=5, breeder_material_name="Li4SiO4", temperature_in_C=500, threshold=0.0005, inner_radius=500): # MATERIALS from library of materials in neutronics_material_maker package breeder_material = Material( material_name=breeder_material_name, enrichment=enrichment, temperature_in_C=temperature_in_C, ).neutronics_material SS316 = Material(material_name="SS316").neutronics_material copper = Material(material_name="copper").neutronics_material mats = openmc.Materials([breeder_material, SS316, copper]) mats.export_to_xml("materials.xml") # GEOMETRY# first_wall_inner_surface = openmc.Sphere(r=inner_radius) first_wall_outer_surface = openmc.Sphere(r=inner_radius + firstwall_thickness) breeder_blanket_outer_surface = openmc.Sphere( r=inner_radius + firstwall_thickness + blanket_thickness) vessel_outer_surface = openmc.Sphere(r=inner_radius + firstwall_thickness + blanket_thickness + 10., boundary_type="vacuum") inner_void_region = -first_wall_inner_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) first_wall_cell = openmc.Cell(region=first_wall_region) first_wall_cell.fill = SS316 breeder_blanket_region = (+first_wall_outer_surface & -breeder_blanket_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 = SS316 universe = openmc.Universe(cells=[ inner_void_cell, first_wall_cell, breeder_blanket_cell, vessel_cell ]) geom = openmc.Geometry(universe) # SIMULATION SETTINGS# sett = openmc.Settings() sett.batches = 2 # this is minimum number of batches that will be run sett.trigger_active = True sett.trigger_max_batches = 2000 # this is maximum number of batches that will be run sett.inactive = 0 sett.particles = 1000 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]) sett.source = source # sett.export_to_xml("settings.xml") # tally filters particle_filter = openmc.ParticleFilter("neutron") cell_filter_breeder = openmc.CellFilter(breeder_blanket_cell) # TALLIES# tallies = openmc.Tallies() tally = openmc.Tally(name="TBR") tally.filters = [cell_filter_breeder, particle_filter] tally.scores = ["(n,Xt)"] tally.triggers = [ openmc.Trigger(trigger_type='rel_err', threshold=threshold) ] # This stops the simulation if the threshold is meet tallies.append(tally) # RUN OPENMC # model = openmc.model.Model(geom, mats, sett, tallies) sp_filename = model.run(output=False) # RETRIEVING TALLY RESULTS sp = openmc.StatePoint(sp_filename) json_output = { "enrichment": enrichment, "inner_radius": inner_radius, "firstwall_thickness": firstwall_thickness, "blanket_thickness": blanket_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() os.system('rm *.h5') return json_output
def model(): openmc.reset_auto_ids() model = openmc.Model() # materials (M4 steel alloy) m4 = openmc.Material() m4.set_density('g/cc', 2.3) m4.add_nuclide('H1', 0.168018676) m4.add_nuclide("H2", 1.93244e-05) m4.add_nuclide("O16", 0.561814465) m4.add_nuclide("O17", 0.00021401) m4.add_nuclide("Na23", 0.021365) m4.add_nuclide("Al27", 0.021343) m4.add_nuclide("Si28", 0.187439342) m4.add_nuclide("Si29", 0.009517714) m4.add_nuclide("Si30", 0.006273944) m4.add_nuclide("Ca40", 0.018026179) m4.add_nuclide("Ca42", 0.00012031) m4.add_nuclide("Ca43", 2.51033e-05) m4.add_nuclide("Ca44", 0.000387892) m4.add_nuclide("Ca46", 7.438e-07) m4.add_nuclide("Ca48", 3.47727e-05) m4.add_nuclide("Fe54", 0.000248179) m4.add_nuclide("Fe56", 0.003895875) m4.add_nuclide("Fe57", 8.99727e-05) m4.add_nuclide("Fe58", 1.19737e-05) s0 = openmc.Sphere(r=240) s1 = openmc.Sphere(r=250, boundary_type='vacuum') c0 = openmc.Cell(fill=m4, region=-s0) c1 = openmc.Cell(region=+s0 & -s1) model.geometry = openmc.Geometry([c0, c1]) # settings settings = model.settings settings.run_mode = 'fixed source' settings.particles = 500 settings.batches = 2 settings.max_splits = 100 settings.photon_transport = True space = Point((0.001, 0.001, 0.001)) energy = Discrete([14E6], [1.0]) settings.source = openmc.Source(space=space, energy=energy) # tally mesh = openmc.RegularMesh() mesh.lower_left = (-240, -240, -240) mesh.upper_right = (240, 240, 240) mesh.dimension = (3, 5, 7) mesh_filter = openmc.MeshFilter(mesh) e_bnds = [0.0, 0.5, 2E7] energy_filter = openmc.EnergyFilter(e_bnds) particle_filter = openmc.ParticleFilter(['neutron', 'photon']) tally = openmc.Tally() tally.filters = [mesh_filter, energy_filter, particle_filter] tally.scores = ['flux'] model.tallies.append(tally) return model