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
