F_cell_new.translation = (x_trans, y_trans, 0)
all_F_univ.add_cell(F_cell_new)
all_F_regions |= F_region_new
P_areas.region &= ~F_region_new
D_areas.region &= ~F_region_new
H_cell.region &= ~F_region_new
F_areas = openmc.Cell(
fill=all_F_univ,
region=all_F_regions & -
top_surface & +
bot_surface)
# Spacer
all_S_univ = openmc.Universe()
S_small_spacer_surf = openmc.ZCylinder(
r=S_small_r,
x0=-D_to_center_width - S_A1_D_gap,
y0=-D_to_center - P_small_gap) # initialize
all_S_regions = -S_small_spacer_surf & + \
plane(V['A1']['P']['T']['m'], V['A1']['P']['T']['x'], V['A1']['P']['T']['y'])
# outer loop is for 3 types of spacers, small top, big middle, small bottom
rad = [S_small_r, S_large_r, S_small_r]
start = [0, 1, 5]
end = [1, 6, 6]
C = ['C', 'C', 'Cb']
for y in range(3):
for area in range(3):
area_str = 'A{}'.format(area + 1)
S_cylinder = openmc.ZCylinder(r=rad[y],
x0=V[area_str]['S'][C[y]]['x0'],
y0=V[area_str]['S'][C[y]]['y0'])
zirc4.add_nuclide('Hf178', 6.03806E-07)
zirc4.add_nuclide('Hf179', 3.01460E-07)
zirc4.add_nuclide('Hf180', 7.76449E-07)
water_600 = openmc.Material(name='Borated water at 600 K with 1300 ppm')
water_600.add_nuclide('O16', 2.20729E-02)
water_600.add_nuclide('H1', 4.41459E-02)
water_600.add_nuclide('B10', 9.52537E-06)
water_600.add_nuclide('B11', 3.83408E-05)
water_600.add_s_alpha_beta('c_H_in_H2O')
###############################################################################
# Geometry
# Instantiate zCylinder surfaces
fuel_or = openmc.ZCylinder(r=0.4096, name='Fuel OR')
clad_ir = openmc.ZCylinder(r=0.4180, name='Clad IR')
clad_or = openmc.ZCylinder(r=0.4750, name='Clad OR')
gt_ir = openmc.ZCylinder(r=0.5610, name='Guide Tube IR')
gt_or = openmc.ZCylinder(r=0.6020, name='Guide Tube OR')
assembly_left = openmc.XPlane(x0=-10.75, boundary_type='reflective')
assembly_right = openmc.XPlane(x0=10.75, boundary_type='reflective')
assembly_back = openmc.YPlane(y0=-10.75, boundary_type='reflective')
assembly_front = openmc.YPlane(y0=10.75, boundary_type='reflective')
assembly_bottom = openmc.ZPlane(z0=-200.0, boundary_type='reflective')
assembly_top = openmc.ZPlane(z0=200.0, boundary_type='reflective')
lattice_left = openmc.XPlane(x0=-10.71)
lattice_right = openmc.XPlane(x0=10.71)
lattice_back = openmc.YPlane(y0=-10.71)
def simulate(n_particles, seed, e_min=1E-03, plot=False, verbose=False):
# set random number seed
np.random.seed(seed)
particle_generator = ParticleGenerator()
# materials
uo2 = openmc.Material(name='UO2 fuel at 2.4% wt enrichment')
uo2.set_density('g/cm3', 5.29769)
uo2.add_element('U', 1., enrichment=2.4)
uo2.add_element('O', 2.)
zircaloy = openmc.Material(name='Zircaloy 4')
zircaloy.set_density('g/cm3', 6.55)
zircaloy.add_element('Sn', 0.014, 'wo')
zircaloy.add_element('Fe', 0.00165, 'wo')
zircaloy.add_element('Cr', 0.001, 'wo')
zircaloy.add_element('Zr', 0.98335, 'wo')
borated_water = openmc.Material(name='Borated water')
borated_water.set_density('g/cm3', 0.740582)
borated_water.add_element('B', 4.0e-5)
borated_water.add_element('H', 5.0e-2)
borated_water.add_element('O', 2.4e-2)
# simple pincell geometry
fuel_cyl = openmc.ZCylinder(r=1.5)
clad_cyl = openmc.ZCylinder(r=1.7)
boundary = openmc.ZCylinder(r=2.0)
fuel_cell = openmc.Cell(region=-fuel_cyl, fill=uo2)
clad_cell = openmc.Cell(region=+fuel_cyl & -clad_cyl, fill=zircaloy)
water_cell = openmc.Cell(region=+clad_cyl & -boundary, fill=borated_water)
geom = openmc.Geometry([fuel_cell, clad_cell, water_cell])
print("Computing material cross-sections...")
xs_dict = {}
for material in geom.get_all_materials().values():
e_grid, xs = calculate_cexs(material, 'material', ('total', ))
xs_dict[material] = CEXS(e_grid, xs[0])
print("Computing majorant cross-section...")
e_grid, majorants = majorants_from_geometry(geom)
if plot:
plot_majorant(e_grid, majorants)
majorant = Majorant.from_others(e_grid, majorants)
print("Running particles...")
# transport loop
for _ in atpbar(range(n_particles)):
p = particle_generator()
while p.e > e_min:
maj_xs = majorant.calculate_xs(p.e)
p.advance(maj_xs)
p.locate(geom)
if not p.cell:
print('Particle left geometry')
break
p.calculate_xs(xs_dict)
if p.xs > maj_xs:
raise RuntimeError("Total XS value {} b is greater than the "
"majorant value ({} b).".format(
p.xs, maj_xs))
if rand() < p.xs / maj_xs:
p.scatter()
if verbose:
print(p)
def _read_surfaces(self):
self.n_surfaces = self._f['geometry/n_surfaces'].value
# Initialize dictionary for each Surface
# Keys - Surface keys
# Values - Surfacee objects
self.surfaces = {}
for key in self._f['geometry/surfaces'].keys():
if key == 'n_surfaces':
continue
surface_id = int(key.lstrip('surface '))
index = self._f['geometry/surfaces'][key]['index'].value
name = self._f['geometry/surfaces'][key]['name'].value.decode()
surf_type = self._f['geometry/surfaces'][key]['type'].value.decode(
)
bc = self._f['geometry/surfaces'][key][
'boundary_condition'].value.decode()
coeffs = self._f['geometry/surfaces'][key]['coefficients'][...]
# Create the Surface based on its type
if surf_type == 'x-plane':
x0 = coeffs[0]
surface = openmc.XPlane(surface_id, bc, x0, name)
elif surf_type == 'y-plane':
y0 = coeffs[0]
surface = openmc.YPlane(surface_id, bc, y0, name)
elif surf_type == 'z-plane':
z0 = coeffs[0]
surface = openmc.ZPlane(surface_id, bc, z0, name)
elif surf_type == 'plane':
A = coeffs[0]
B = coeffs[1]
C = coeffs[2]
D = coeffs[3]
surface = openmc.Plane(surface_id, bc, A, B, C, D, name)
elif surf_type == 'x-cylinder':
y0 = coeffs[0]
z0 = coeffs[1]
R = coeffs[2]
surface = openmc.XCylinder(surface_id, bc, y0, z0, R, name)
elif surf_type == 'y-cylinder':
x0 = coeffs[0]
z0 = coeffs[1]
R = coeffs[2]
surface = openmc.YCylinder(surface_id, bc, x0, z0, R, name)
elif surf_type == 'z-cylinder':
x0 = coeffs[0]
y0 = coeffs[1]
R = coeffs[2]
surface = openmc.ZCylinder(surface_id, bc, x0, y0, R, name)
elif surf_type == 'sphere':
x0 = coeffs[0]
y0 = coeffs[1]
z0 = coeffs[2]
R = coeffs[3]
surface = openmc.Sphere(surface_id, bc, x0, y0, z0, R, name)
elif surf_type in ['x-cone', 'y-cone', 'z-cone']:
x0 = coeffs[0]
y0 = coeffs[1]
z0 = coeffs[2]
R2 = coeffs[3]
if surf_type == 'x-cone':
surface = openmc.XCone(surface_id, bc, x0, y0, z0, R2,
name)
if surf_type == 'y-cone':
surface = openmc.YCone(surface_id, bc, x0, y0, z0, R2,
name)
if surf_type == 'z-cone':
surface = openmc.ZCone(surface_id, bc, x0, y0, z0, R2,
name)
elif surf_type == 'quadric':
a, b, c, d, e, f, g, h, j, k = coeffs
surface = openmc.Quadric(surface_id, bc, a, b, c, d, e, f, g,
h, j, k, name)
# Add Surface to global dictionary of all Surfaces
self.surfaces[index] = surface
borated_water = openmc.Material(name='Borated Water')
borated_water.set_density('g/cm3', 0.740582)
borated_water.add_nuclide('B10', 8.0042e-6)
borated_water.add_nuclide('B11', 3.2218e-5)
borated_water.add_nuclide('H1', 4.9457e-2)
borated_water.add_nuclide('O16', 2.4672e-2)
borated_water.add_s_alpha_beta('HH2O')
# Instantiate a MaterialsFile, register all Materials, and export to XML
materials_file = openmc.Materials([uo2, helium, zircaloy, borated_water])
materials_file.default_xs = '71c'
################### Exporting to OpenMC geometry.xml File ###################
# Instantiate ZCylinder surfaces
fuel_or = openmc.ZCylinder(x0=0, y0=0, R=0.39218, name='Fuel OR')
clad_ir = openmc.ZCylinder(x0=0, y0=0, R=0.40005, name='Clad IR')
clad_or = openmc.ZCylinder(x0=0, y0=0, R=0.45720, name='Clad OR')
min_x = openmc.XPlane(x0=-0.62992, name='min x')
max_x = openmc.XPlane(x0=+0.62992, name='max x')
min_y = openmc.YPlane(y0=-0.62992, name='min y')
max_y = openmc.YPlane(y0=+0.62992, name='max y')
min_z = openmc.ZPlane(z0=-0.62992, name='min z')
max_z = openmc.ZPlane(z0=+0.62992, name='max z')
min_x.boundary_type = 'reflective'
max_x.boundary_type = 'reflective'
min_y.boundary_type = 'reflective'
max_y.boundary_type = 'reflective'
min_z.boundary_type = 'reflective'
max_z.boundary_type = 'reflective'
# Instantiate a MaterialsFile, register all Materials, and export to XML materials_file = openmc.MaterialsFile() materials_file.default_xs = '71c' materials_file.add_materials([moderator, fuel]) materials_file.export_to_xml() ############################################################################### # Exporting to OpenMC geometry.xml File ############################################################################### # Instantiate Surfaces left = openmc.XPlane(surface_id=1, x0=-2, name='left') right = openmc.XPlane(surface_id=2, x0=2, name='right') bottom = openmc.YPlane(surface_id=3, y0=-2, name='bottom') top = openmc.YPlane(surface_id=4, y0=2, name='top') fuel1 = openmc.ZCylinder(surface_id=5, x0=0, y0=0, R=0.4) fuel2 = openmc.ZCylinder(surface_id=6, x0=0, y0=0, R=0.3) fuel3 = openmc.ZCylinder(surface_id=7, x0=0, y0=0, R=0.2) left.boundary_type = 'vacuum' right.boundary_type = 'vacuum' top.boundary_type = 'vacuum' bottom.boundary_type = 'vacuum' # Instantiate Cells cell1 = openmc.Cell(cell_id=1, name='Cell 1') cell2 = openmc.Cell(cell_id=101, name='cell 2') cell3 = openmc.Cell(cell_id=102, name='cell 3') cell4 = openmc.Cell(cell_id=201, name='cell 4') cell5 = openmc.Cell(cell_id=202, name='cell 5') cell6 = openmc.Cell(cell_id=301, name='cell 6')
def initial(self, opt, Mesh): #, nthreads):
#####################################
# Create OpenMC geometry
#####################################
FuelOR = opt.FuelOR * 100 #[cm]
CladIR = opt.CladIR * 100 #[cm]
CladOR = opt.CladOR * 100 #[cm]
# ExtraCladOR = opt.ExtraCladOR*100 #[cm]
Pitch = opt.PinPitch * 100 #[cm]
# Construct uniform initial source distribution over fissionable zones
lower_left = [-Pitch / 2, -Pitch / 2, 0]
upper_right = [+Pitch / 2, +Pitch / 2, +365.76]
uniform_dist = openmc.stats.Box(lower_left,
upper_right,
only_fissionable=True)
# Settings file
self.settings_file = openmc.Settings()
self.settings_file.batches = 1100
self.settings_file.inactive = 100
self.settings_file.particles = 20000
self.settings_file.generations_per_batch = 5
self.settings_file.output = {'tallies': False}
self.settings_file.temperature = {'multipole': True, 'tolerance': 3000}
self.settings_file.source = openmc.source.Source(space=uniform_dist)
self.settings_file.seed = np.random.randint(1, 100) # for correlation
self.settings_file.export_to_xml() #Removed for correlation
# Materials file
uo2 = openmc.Material(material_id=1,
name='UO2 fuel at 2.4% wt enrichment')
uo2.temperature = 900. #opt.Tin
uo2.set_density('g/cm3', 10.29769)
uo2.add_element('U', 1., enrichment=2.4)
uo2.add_element('O', 2.)
# helium = openmc.Material(material_id=2, name='Helium for gap')
# helium.temperature = opt.Tin
# helium.set_density('g/cm3', 0.001598)
# helium.add_element('He', 2.4044e-4)
zircaloy = openmc.Material(material_id=3, name='Zircaloy 4')
zircaloy.temperature = opt.Tin
zircaloy.set_density('g/cm3', 6.55)
zircaloy.add_element('Sn', 0.014, 'wo')
zircaloy.add_element('Fe', 0.00165, 'wo')
zircaloy.add_element('Cr', 0.001, 'wo')
zircaloy.add_element('Zr', 0.98335, 'wo')
# borated_water = openmc.Material()
# borated_water.temperature = opt.Tin
# borated_water.set_density('g/cm3', 0.7406)
# borated_water.add_element('B', 4.0e-5)
# borated_water.add_element('H', 5.0e-2)
# borated_water.add_element('O', 2.4e-2)
# borated_water.add_s_alpha_beta('c_H_in_H2O')
borated_water = openmc.model.borated_water(boron_ppm=432.473,
temperature=opt.Tin,
pressure=15)
self.materials_file = openmc.Materials([uo2, zircaloy,
borated_water]) #helium
self.materials_file.export_to_xml() #Removed for correlation
# Geometry file
fuel_or = openmc.ZCylinder(x0=0, y0=0, R=FuelOR)
# clad_ir = openmc.ZCylinder(x0=0, y0=0, R=CladIR)
clad_or = openmc.ZCylinder(x0=0, y0=0, R=CladOR)
# extra_clad_or = openmc.ZCylinder(x0=0, y0=0, R=ExtraCladOR)
left = openmc.XPlane(x0=-Pitch / 2)
right = openmc.XPlane(x0=Pitch / 2)
back = openmc.YPlane(y0=-Pitch / 2)
front = openmc.YPlane(y0=Pitch / 2)
top = openmc.ZPlane(z0=396.24)
bottom = openmc.ZPlane(z0=-30.48)
z_list = []
for i in range(0, len(Mesh)):
z_list.append(openmc.ZPlane(z0=Mesh[i]))
left.boundary_type = 'reflective'
right.boundary_type = 'reflective'
front.boundary_type = 'reflective'
back.boundary_type = 'reflective'
top.boundary_type = 'vacuum'
bottom.boundary_type = 'vacuum'
# z_list[-1].boundary_type = 'vacuum'
# z_list[0].boundary_type = 'vacuum'
self.reflectTOP = openmc.Cell()
self.reflectBOT = openmc.Cell()
self.fuel_list = []
# self.gap_list = []
self.clad_list = []
# self.extra_clad_list = []
self.water_list = []
for i in range(0, len(Mesh) - 1):
self.fuel_list.append(openmc.Cell())
# self.gap_list.append(openmc.Cell())
self.clad_list.append(openmc.Cell())
# self.extra_clad_list.append(openmc.Cell())
self.water_list.append(openmc.Cell())
self.reflectTOP.region = +left & -right & +back & -front & +z_list[
-1] & -top
self.reflectBOT.region = +left & -right & +back & -front & +bottom & -z_list[
0]
self.reflectTOP.fill = borated_water
self.reflectBOT.fill = borated_water
j = 0
for fuels in self.fuel_list:
fuels.region = -fuel_or & +z_list[j] & -z_list[j + 1]
fuels.fill = uo2
j = j + 1
# j = 0
# for gaps in self.gap_list:
# gaps.region = +fuel_or & -clad_ir & +z_list[j] & -z_list[j+1]
# gaps.fill = helium
# j = j+1
j = 0
for clads in self.clad_list:
clads.region = +fuel_or & -clad_or & +z_list[j] & -z_list[
j + 1] #clad_ir instead of fuel_or
clads.fill = zircaloy
j = j + 1
# j = 0
# for extra_clads in self.extra_clad_list:
# extra_clads.region = +clad_or & -extra_clad_or & +left & -right & +back & -front & +z_list[j] & -z_list[j+1]
# grid_flag = 0
# for i in range(0,len(opt.GridBot_z)):
# if z_list[j].z0 == opt.GridBot_z[i]:
# extra_clads.fill = zircaloy
# grid_flag = 1
# if grid_flag == 1:
# extra_clads.fill = zircaloy
# else:
# extra_clads.fill = borated_water
# extra_clads.fill = borated_water
# j = j+1
j = 0
for waters in self.water_list:
waters.region = +clad_or & +left & -right & +back & -front & +z_list[
j] & -z_list[j + 1]
waters.fill = borated_water
j = j + 1
self.root = openmc.Universe(universe_id=0, name='root universe')
self.root.add_cells(self.fuel_list)
# self.root.add_cells(self.gap_list)
self.root.add_cells(self.clad_list)
# self.root.add_cells(self.extra_clad_list)
self.root.add_cells(self.water_list)
self.root.add_cells([self.reflectTOP, self.reflectBOT])
self.geometry_file = openmc.Geometry(self.root)
self.geometry_file.export_to_xml() #Removed for correlation
# Tallies
# power distribution: fission q recoverable (Sterling's note: starts 0, might be data pb)
# openmc accounts for incoming neutron energy and isotope
cell_filter = openmc.CellFilter(self.fuel_list)
t = openmc.Tally(tally_id=1)
t.filters.append(cell_filter)
t.scores = ['fission-q-recoverable']
tallies = openmc.Tallies([t])
tallies.export_to_xml() #Removed for correlation
# Plots
plot = openmc.Plot()
plot.width = [Pitch + 45, Pitch + 45]
plot.origin = [0., 0., -20]
plot.color_by = 'material'
plot.filename = 'fuel-pin'
plot.pixels = [1000, 1000]
plot.basis = 'yz'
# openmc.plot_inline(plot)
# Move Files to PinGeo folder #Removed for correlation
shutil.move('settings.xml', 'PinGeo/settings.xml')
shutil.move('materials.xml', 'PinGeo/materials.xml')
shutil.move('geometry.xml', 'PinGeo/geometry.xml')
shutil.move('tallies.xml', 'PinGeo/tallies.xml')
# shutil.move('plots.xml', 'PinGeo/plots.xml')
openmc.run(
cwd='PinGeo') #, threads=nthreads, mpi_args=['mpiexec','-n','2'])
sp = openmc.StatePoint('PinGeo/statepoint.' +
str(self.settings_file.batches) + '.h5')
tally = sp.get_tally(scores=['fission-q-recoverable'])
self.Tally = np.ndarray.flatten(tally.sum)
Pfactor = 66945.4 / sum(np.ndarray.flatten(tally.sum))
# print("Pfactor: ", Pfactor)
self.Tally = np.ndarray.flatten(tally.sum) * Pfactor
self.Var = np.divide(np.ndarray.flatten(tally.std_dev),
np.ndarray.flatten(tally.mean))
def define_Geo_Mat_Set(cells_num_dic,parameters_dic,settings_dic,temp_phy_mat,controlRod_deep,empty_reflector_height):
# Check file
if os.path.exists('geometry.xml'):
os.remove('geometry.xml')
if os.path.exists('materials.xml'):
os.remove('materials.xml')
if os.path.exists('settings.xml'):
os.remove('settings.xml')
if os.path.exists('tallies.xml'):
os.remove('tallies.xml')
# defualt temperature: 1073.5K
if settings_dic['temperature_update']== True:
temp_defualt = temp_phy_mat.min()
else:
temp_defualt = 1073.5
# Structural Material HAYNES230
structure_HAY = openmc.Material(name='HAYNES230')
structure_HAY.set_density('g/cm3',8.97)
structure_HAY.add_element('Ni',0.57,'wo')
structure_HAY.add_element('Cr',0.22,'wo')
structure_HAY.add_element('W',0.14,'wo')
structure_HAY.add_element('Mo',0.02,'wo')
structure_HAY.add_element('Fe',0.01875,'wo')
structure_HAY.add_element('Co',0.03125,'wo')
# Structural Material SS316
structure_SS = openmc.Material(name='SS316')
structure_SS.set_density('g/cm3',7.99)
structure_SS.add_element('Ni',0.12,'wo')
structure_SS.add_element('Cr',0.17,'wo')
structure_SS.add_element('Mo',0.025,'wo')
structure_SS.add_element('Mn',0.02,'wo')
structure_SS.add_element('Fe',0.665,'wo')
#Control Rod Material B4C
ControlRod_B4C = openmc.Material(name='B4C')
ControlRod_B4C.set_density('g/cm3',2.52)
ControlRod_B4C.add_nuclide('B10',4,'ao')
ControlRod_B4C.add_element('C',1,'ao')
#Reflector Material BeO
Reflector_BeO = openmc.Material(name='BeO')
Reflector_BeO.set_density('g/cm3',3.025)
Reflector_BeO.add_element('Be',1,'ao')
Reflector_BeO.add_element('O',1,'ao')
#Coolant Na
Coolant_Na = openmc.Material(name='Na')
Coolant_Na.set_density('g/cm3',0.76)
Coolant_Na.add_element('Na',1,'ao')
# Instantiate a Materials collection
materials_file = openmc.Materials([structure_HAY, structure_SS, ControlRod_B4C, Reflector_BeO, Coolant_Na])
# Number of cells
n_r = cells_num_dic['n_r']
n_r_outer = cells_num_dic['n_r_outer']
n_h = cells_num_dic['n_h']
# Effect of Temperature on density of fuel
fuel_list = []
density_mat = calUMoDensity(temp_phy_mat)
# Fuel U-10Mo
for j in range(n_h):
for i in range(n_r):
fuel_name = str((j+1)*10000+(i + 1)*100)
fuel = openmc.Material(name='U-10Mo '+ fuel_name)
fuel.set_density('g/cm3',density_mat[j,i])
fuel.add_element('Mo',0.1,'wo')
# fuel.add_nuclide('U235',0.1773,'wo') # for LEU (19.7%)
# fuel.add_nuclide('U238',0.7227,'wo')
fuel.add_nuclide('U235',0.837,'wo') # for HEU (93.0%)
fuel.add_nuclide('U238',0.063,'wo')
fuel_list.append(fuel)
materials_file.append(fuel)
for i in range(n_r_outer):
fuel_name = str((j+1)*10000+(i + n_r + 1)*100)
fuel = openmc.Material(name='U-10Mo '+ fuel_name)
fuel.set_density('g/cm3',density_mat[j,i+n_r])
fuel.add_element('Mo',0.1,'wo')
# fuel.add_nuclide('U235',0.1773,'wo') # for LEU (19.7%)
# fuel.add_nuclide('U238',0.7227,'wo')
fuel.add_nuclide('U235',0.837,'wo') # for HEU (93.0%)
fuel.add_nuclide('U238',0.063,'wo')
fuel_list.append(fuel)
materials_file.append(fuel)
# Export to "materials.xml"
materials_file.export_to_xml()
num_heat_pipe = 8
# Parameters of reactor
# Unit:cm
fuel_r = parameters_dic['fuel_r']
fuel_h = parameters_dic['fuel_h']
controlRod_r = parameters_dic['controlRod_r']
controlRod_h_max = parameters_dic['controlRod_h_max']
controlRod_l = parameters_dic['controlRod_l']
reflector_r = parameters_dic['reflector_r']
reflector_h = parameters_dic['reflector_h']
heat_pipe_R = parameters_dic['heat_pipe_R']
heat_pipe_r = parameters_dic['heat_pipe_r']
top_distance = parameters_dic['top_distance']
bottom_distance = parameters_dic['bottom_distance']
# Create cylinders for the fuel control rod and reflector
fuel_OD = openmc.ZCylinder(x0=0.0, y0=0.0, r=fuel_r)
controlRod_OD = openmc.ZCylinder(x0=0.0, y0=0.0, r=controlRod_r)
reflector_OD = openmc.ZCylinder(x0=0.0, y0=0.0, r=reflector_r, boundary_type='vacuum')
# Create planes for fuel control rod and reflector
reflector_TOP = openmc.ZPlane(z0 = (top_distance+fuel_h/2),boundary_type='vacuum')
reflector_BOTTOM = openmc.ZPlane(z0 = -(bottom_distance+fuel_h/2),boundary_type='vacuum')
reflector_empty_TOP = openmc.ZPlane(z0 = -(bottom_distance+fuel_h/2-empty_reflector_height))
fuel_TOP = openmc.ZPlane(z0 = fuel_h/2)
fuel_BOTTOM = openmc.ZPlane(z0 = -fuel_h/2)
controlRodSpace_TOP = openmc.ZPlane(z0 = (controlRod_h_max-bottom_distance-fuel_h/2))
# Create cylinders for heat pipes
heat_pipe_OD = openmc.ZCylinder(x0=fuel_r, y0=0, r=heat_pipe_R)
n_ang = num_heat_pipe
ang_mesh = np.pi/n_ang
r_mesh = np.linspace(controlRod_r,(fuel_r-heat_pipe_R),n_r+1)
r_outer_mesh = np.linspace(fuel_r-heat_pipe_R,fuel_r,n_r_outer+1)
h_mesh = np.linspace(-fuel_h/2,fuel_h/2,n_h+1)
line_1 = openmc.Plane(a=np.tan(-ang_mesh),b=-1.0,c=0.0,d=0.0,boundary_type='reflective')
line_2 = openmc.Plane(a=np.tan(ang_mesh),b=-1.0,c=0.0,d=0.0,boundary_type='reflective')
# Create volume vector and matrix
volume_vec = np.zeros(n_r+n_r_outer)
d_h = fuel_h/n_h
for i in range(n_r+n_r_outer):
if i >= n_r:
d = heat_pipe_R*(i-n_r)/n_r_outer
x_i = np.sqrt(2*heat_pipe_R*d-d*d)
d = heat_pipe_R*(i-n_r+1)/n_r_outer
x_i1 = np.sqrt(2*heat_pipe_R*d-d*d)
s = (x_i+x_i1)*heat_pipe_R/n_r_outer
volume_vec[i] = d_h*np.pi*(r_outer_mesh[i+1-n_r]*r_outer_mesh[i+1-n_r]-r_outer_mesh[i-n_r]*r_outer_mesh[i-n_r])/8-s
else:
volume_vec[i] = d_h*np.pi*(r_mesh[i+1]*r_mesh[i+1]-r_mesh[i]*r_mesh[i])/8
volume_mat = np.zeros((n_h,(n_r+n_r_outer)))
for i in range(n_h):
volume_mat[i,:] = volume_vec
# Create heat_pipe universe
heat_pipe_Inner = openmc.ZCylinder(r=heat_pipe_r)
coolant_cell = openmc.Cell(fill=Coolant_Na, region=(-heat_pipe_Inner & -reflector_TOP & +reflector_BOTTOM))
pipe_cell = openmc.Cell(fill=structure_HAY, region=(+heat_pipe_Inner & -reflector_TOP & +reflector_BOTTOM))
heat_pipe_universe = openmc.Universe(cells=(coolant_cell, pipe_cell))
# Create a Universe to encapsulate a fuel pin
pin_cell_universe = openmc.Universe(name='U-10Mo Pin')
# Create fine-fuel-cell (num of cells: n_r + n_r_outer)
fuel_cell_list = []
fuel_cell_ID_list = []
k = 0
for j in range(n_h):
cir_top = openmc.ZPlane(z0 = h_mesh[j+1])
cir_bottom = openmc.ZPlane(z0 = h_mesh[j])
for i in range(n_r):
cir_in = openmc.ZCylinder(r=r_mesh[i])
cir_out = openmc.ZCylinder(r=r_mesh[i+1])
fuel_cell = openmc.Cell()
fuel_cell.fill = fuel_list[k]
k = k+1
fuel_cell.region = +cir_in & -cir_out & +cir_bottom &-cir_top
fuel_cell.temperature = temp_phy_mat[j,i]
fuel_cell.id = (j+1)*10000+(i + 1)*100
fuel_cell_ID_list.append((j+1)*10000+(i + 1)*100)
fuel_cell_list.append(fuel_cell)
pin_cell_universe.add_cell(fuel_cell)
for i in range(n_r_outer):
cir_in = openmc.ZCylinder(r=r_outer_mesh[i])
cir_out = openmc.ZCylinder(r=r_outer_mesh[i+1])
fuel_cell = openmc.Cell()
fuel_cell.fill = fuel_list[k]
k = k+1
fuel_cell.region = +cir_in & -cir_out & +heat_pipe_OD & +cir_bottom &-cir_top
fuel_cell.temperature = temp_phy_mat[j,i+n_r]
fuel_cell.id = (j+1)*10000+(n_r + i + 1)*100
fuel_cell_ID_list.append((j+1)*10000+(n_r + i + 1)*100)
fuel_cell_list.append(fuel_cell)
pin_cell_universe.add_cell(fuel_cell)
# Create control rod Cell
controlRod_TOP = openmc.ZPlane(z0 = (controlRod_deep-fuel_h/2-bottom_distance))
controlRod_TOP.name = 'controlRod_TOP'
if controlRod_deep < controlRod_h_max:
controlRod_empty_cell = openmc.Cell(name='Control Rod Empty')
controlRod_empty_cell.region = -controlRod_OD & +controlRod_TOP & -controlRodSpace_TOP
pin_cell_universe.add_cell(controlRod_empty_cell)
if controlRod_deep > 0:
controlRod_cell = openmc.Cell(name='Control Rod')
controlRod_cell.fill = ControlRod_B4C
controlRod_cell.region = -controlRod_OD & +reflector_BOTTOM & -controlRod_TOP
controlRod_cell.tempearture = temp_defualt
pin_cell_universe.add_cell(controlRod_cell)
# Create heat pipe Cell
heat_pipe_cell = openmc.Cell(name='Heat Pipe')
heat_pipe_cell.fill = heat_pipe_universe
heat_pipe_cell.region = -heat_pipe_OD & +reflector_BOTTOM & -reflector_TOP
heat_pipe_cell.temperature = temp_defualt
heat_pipe_cell.translation = (fuel_r,0,0)
pin_cell_universe.add_cell(heat_pipe_cell)
# To be edited
# Create reflector Cell
if empty_reflector_height >0:
reflector_radial_empty_cell = openmc.Cell(name='Radial Reflector Empty')
reflector_radial_empty_cell.region = +fuel_OD & +heat_pipe_OD & +reflector_BOTTOM & -reflector_empty_TOP
pin_cell_universe.add_cell(reflector_radial_empty_cell)
reflector_radial_cell = openmc.Cell(name='Radial Reflector')
reflector_radial_cell.fill = Reflector_BeO
reflector_radial_cell.region = +fuel_OD & +heat_pipe_OD & +reflector_empty_TOP & -reflector_TOP
reflector_radial_cell.temperature = temp_defualt
pin_cell_universe.add_cell(reflector_radial_cell)
else:
reflector_radial_cell = openmc.Cell(name='Radial Reflector')
reflector_radial_cell.fill = Reflector_BeO
reflector_radial_cell.region = +fuel_OD & +heat_pipe_OD & +reflector_BOTTOM & -reflector_TOP
reflector_radial_cell.temperature = temp_defualt
pin_cell_universe.add_cell(reflector_radial_cell)
reflector_bottom_cell = openmc.Cell(name='Bottom Reflector')
reflector_bottom_cell.fill = Reflector_BeO
reflector_bottom_cell.region = +controlRod_OD & +heat_pipe_OD & -fuel_OD & -fuel_BOTTOM & +reflector_BOTTOM
reflector_bottom_cell.temperature = temp_defualt
pin_cell_universe.add_cell(reflector_bottom_cell)
reflector_top_cell = openmc.Cell(name='Top Reflector')
reflector_top_cell.fill = Reflector_BeO
reflector_top_cell.region = +heat_pipe_OD & -fuel_OD & +controlRodSpace_TOP & -reflector_TOP
reflector_top_cell.region = reflector_top_cell.region | (+controlRod_OD & +heat_pipe_OD & -fuel_OD & +fuel_TOP & -controlRodSpace_TOP)
reflector_top_cell.temperature = temp_defualt
pin_cell_universe.add_cell(reflector_top_cell)
# Create root Cell
root_cell = openmc.Cell(name='root cell')
root_cell.fill = pin_cell_universe
# Add boundary planes
root_cell.region = -reflector_OD & +line_2 & -line_1 & +reflector_BOTTOM & -reflector_TOP
# Create root Universe
root_universe = openmc.Universe(universe_id=0, name='root universe')
root_universe.add_cell(root_cell)
# Create Geometry and set root Universe
geometry = openmc.Geometry(root_universe)
# Export to "geometry.xml"
geometry.export_to_xml()
# Instantiate a Settings object
settings_file = openmc.Settings()
settings_file.batches = settings_dic['batches']
settings_file.inactive = settings_dic['inactive']
settings_file.particles = settings_dic['particles']
settings_file.temperature['multipole']= True
settings_file.temperature['method']= 'interpolation'
settings_file.source = openmc.Source(space=openmc.stats.Point((15,0,0)))
# Export to "settings.xml"
settings_file.export_to_xml()
# Instantiate an empty Tallies object
tallies_file = openmc.Tallies()
for i in range(len(fuel_cell_ID_list)):
tally = openmc.Tally(name='cell tally '+str(fuel_cell_ID_list[i]))
tally.filters = [openmc.DistribcellFilter(fuel_cell_ID_list[i])]
tally.scores = ['heating','flux']
tallies_file.append(tally)
# Export to "tallies.xml"
tallies_file.export_to_xml()
return volume_mat,fuel_cell_ID_list
waba.add_nuclide('B11', 1.21192E-02)
waba.add_element('C', 3.77001E-03)
waba.add_nuclide('O16', 5.85563E-02)
waba.add_nuclide('Al27', 3.90223E-02)
materials_file = openmc.Materials([
fuel_21, fuel_31, fuel_36, fuel_46, helium, water_565, water_600, pyrex,
zirc4, gad, ifba, ss304, agincd, b4c, waba
])
materials_file.export_to_xml()
###############################################################################
# Create geometry
###############################################################################
# Instantiate zCylinder surfaces
fuel_or = openmc.ZCylinder(surface_id=1, x0=0, y0=0, r=0.4096, name='Fuel OR')
clad_ir = openmc.ZCylinder(surface_id=2, x0=0, y0=0, r=0.4180, name='Clad IR')
clad_or = openmc.ZCylinder(surface_id=3, x0=0, y0=0, r=0.4750, name='Clad OR')
gt_ir = openmc.ZCylinder(surface_id=4,
x0=0,
y0=0,
r=0.5610,
name='Guide Tube IR')
gt_or = openmc.ZCylinder(surface_id=5,
x0=0,
y0=0,
r=0.6020,
name='Guide Tube OR')
it_ir = openmc.ZCylinder(surface_id=6,
x0=0,
y0=0,
def _add_rcca_pincells(self):
""" Adds BEAVRS RCCA pincells """
# RCCA rod radial surfaces
self.s_rcca_clad_IR = openmc.ZCylinder(name='RCCA rod clad IR', R=c.rcca_clad_IR)
self.s_rcca_clad_OR = openmc.ZCylinder(name='RCCA rod clad OR', R=c.rcca_clad_OR)
self.s_rcca_b4c_OR = openmc.ZCylinder(name='RCCA rod B4C OR', R=c.rcca_b4c_OR)
self.s_rcca_aic_OR = openmc.ZCylinder(name='RCCA rod AIC OR', R=c.rcca_aic_OR)
self.s_rcca_spacer_OR = openmc.ZCylinder(name='RCCA rod spacer OR', R=c.rcca_spacer_OR)
self.s_rcca_spring_OR = openmc.ZCylinder(name='RCCA rod plenum spring OR', R=c.rcca_spring_OR)
# RCCA rod axial surfaces
self.s_rcca_rod_bot = {}
self.s_rcca_lowerFitting_top = {}
self.s_rcca_aic_top = {}
self.s_rcca_b4c_top = {}
self.s_rcca_spacer_top = {}
self.s_rcca_plenum_top = {}
for b in c.rcca_banks:
d = c.rcca_bank_steps_withdrawn[b]*c.rcca_StepWidth
self.s_rcca_rod_bot[b] = openmc.ZPlane(name='Bottom of RCCA rod bank {0}'.format(b), z0=c.rcca_Rod_bot + d)
self.s_rcca_lowerFitting_top[b] = openmc.ZPlane(name='Top of RCCA rod lower fitting bank {0}'.format(b), z0=c.rcca_LowerFitting_top + d)
self.s_rcca_aic_top[b] = openmc.ZPlane(name='Top of RCCA rod AIC bank {0}'.format(b), z0=c.rcca_AIC_top + d)
self.s_rcca_b4c_top[b] = openmc.ZPlane(name='Top of RCCA rod B4C bank {0}'.format(b), z0=c.rcca_B4C_top + d)
self.s_rcca_spacer_top[b] = openmc.ZPlane(name='Top of RCCA rod spacer bank {0}'.format(b), z0=c.rcca_Spacer_top + d)
self.s_rcca_plenum_top[b] = openmc.ZPlane(name='Top of RCCA rod plenum bank {0}'.format(b), z0=c.rcca_Plenum_top + d)
# RCCA pincell universes
self.u_rcca_plenum = InfinitePinCell(name='RCCA plenum')
self.u_rcca_plenum.add_ring(self.mats['Inconel 718'], self.s_rcca_spring_OR)
self.u_rcca_plenum.add_ring(self.mats['Air'], self.s_rcca_clad_IR)
self.u_rcca_plenum.add_last_ring(self.mats['Zircaloy 4'])
self.u_rcca_plenum.finalize()
self.u_rcca_aic = InfinitePinCell(name='RCCA AIC')
self.u_rcca_aic.add_ring(self.mats['Ag-In-Cd'], self.s_rcca_aic_OR)
self.u_rcca_aic.add_ring(self.mats['Air'], self.s_rcca_clad_IR)
self.u_rcca_aic.add_last_ring( self.mats['Zircaloy 4'])
self.u_rcca_aic.finalize()
self.u_rcca_b4c = InfinitePinCell(name='RCCA B4C')
self.u_rcca_b4c.add_ring(self.mats['B4C'], self.s_rcca_b4c_OR)
self.u_rcca_b4c.add_ring(self.mats['Air'], self.s_rcca_clad_IR)
self.u_rcca_b4c.add_last_ring(self.mats['Zircaloy 4'])
self.u_rcca_b4c.finalize()
self.u_rcca_spacer = InfinitePinCell(name='RCCA Spacer')
self.u_rcca_spacer.add_ring(self.mats['SS304'], self.s_rcca_spacer_OR)
self.u_rcca_spacer.add_ring(self.mats['Air'], self.s_rcca_clad_IR)
self.u_rcca_spacer.add_last_ring(self.mats['Zircaloy 4'])
self.u_rcca_spacer.finalize()
# RCCA rod axial stack
self.u_rcca = {}
for b in c.rcca_banks:
self.u_rcca[b] = AxialPinCell(name='RCCA bank {0}'.format(b))
self.u_rcca[b].add_axial_section(self.s_struct_supportPlate_bot, self.mats['Borated Water'])
self.u_rcca[b].add_axial_section(self.s_struct_lowerNozzle_top, self.mats['Water SPN'])
self.u_rcca[b].add_axial_section(self.s_rcca_rod_bot[b], self.mats['Borated Water'])
self.u_rcca[b].add_axial_section(self.s_rcca_lowerFitting_top[b], self.mats['SS304'])
self.u_rcca[b].add_axial_section(self.s_rcca_aic_top[b], self.u_rcca_aic)
self.u_rcca[b].add_axial_section(self.s_rcca_b4c_top[b], self.u_rcca_b4c)
self.u_rcca[b].add_axial_section(self.s_rcca_spacer_top[b], self.u_rcca_spacer)
self.u_rcca[b].add_axial_section(self.s_rcca_plenum_top[b], self.u_rcca_plenum)
self.u_rcca[b].add_last_axial_section(self.mats['SS304'])
self.u_rcca[b] = self.u_rcca[b].add_wrapper(self.u_gt, self.s_rcca_clad_OR)
self.u_rcca[b].finalize()
def build_inputs(n_mesh_bins, energy_bins, n_azim_bins, **kwargs):
"""Build OpenMC input XML files for a pincell with detailed flux tallying"""
if n_azim_bins % 8 != 0:
raise ValueError("The number of azimuthal bins "
"must be divisible by eight")
pitch = 0.62992 * 2
####################
# Define materials
####################
uo2 = openmc.Material(material_id=9201,
name='UO2 fuel at 2.4% wt enrichment')
uo2.set_density('g/cm3', 10.29769)
uo2.add_nuclide('U-234', 4.4842e-06)
uo2.add_nuclide('U-235', 5.5814e-04)
uo2.add_nuclide('U-238', 2.2407e-02)
uo2.add_nuclide('O-16', 4.5828e-02)
uo2.add_nuclide('O-17', 1.7457e-05 + 9.4176e-05)
borated_water = openmc.Material(material_id=101,
name='Borated water at 975 ppm')
borated_water.set_density('g/cm3', 0.740582)
borated_water.add_nuclide('B-10', 8.0042e-6)
borated_water.add_nuclide('B-11', 3.2218e-5)
borated_water.add_nuclide('H-1', 4.9457e-2)
borated_water.add_nuclide('H-2', 7.4196e-6)
borated_water.add_nuclide('O-16', 2.4672e-2)
borated_water.add_nuclide('O-17', 9.3982e-06 + 5.0701e-05)
borated_water.add_s_alpha_beta('HH2O', '71t')
helium = openmc.Material(material_id=201, name='Helium for gap')
helium.set_density('g/cm3', 0.001598)
helium.add_nuclide('He-4', 2.4044e-4)
zircaloy = openmc.Material(material_id=4001, name='Zircaloy 4')
zircaloy.set_density('g/cm3', 6.55)
zircaloy.add_nuclide('O-16', 3.0743e-04)
zircaloy.add_nuclide('O-17', 1.1711e-07 + 6.3176e-07)
zircaloy.add_nuclide('Cr-50', 3.2962e-06)
zircaloy.add_nuclide('Cr-52', 6.3564e-05)
zircaloy.add_nuclide('Cr-53', 7.2076e-06)
zircaloy.add_nuclide('Cr-54', 1.7941e-06)
zircaloy.add_nuclide('Fe-54', 8.6699e-06)
zircaloy.add_nuclide('Fe-56', 1.3610e-04)
zircaloy.add_nuclide('Fe-57', 3.1431e-06)
zircaloy.add_nuclide('Fe-58', 4.1829e-07)
zircaloy.add_nuclide('Zr-90', 2.1827e-02)
zircaloy.add_nuclide('Zr-91', 4.7600e-03)
zircaloy.add_nuclide('Zr-92', 7.2758e-03)
zircaloy.add_nuclide('Zr-94', 7.3734e-03)
zircaloy.add_nuclide('Zr-96', 1.1879e-03)
zircaloy.add_nuclide('Sn-112', 4.6735e-06)
zircaloy.add_nuclide('Sn-114', 3.1799e-06)
zircaloy.add_nuclide('Sn-115', 1.6381e-06)
zircaloy.add_nuclide('Sn-116', 7.0055e-05)
zircaloy.add_nuclide('Sn-117', 3.7003e-05)
zircaloy.add_nuclide('Sn-118', 1.1669e-04)
zircaloy.add_nuclide('Sn-119', 4.1387e-05)
zircaloy.add_nuclide('Sn-120', 1.5697e-04)
zircaloy.add_nuclide('Sn-122', 2.2308e-05)
zircaloy.add_nuclide('Sn-124', 2.7897e-05)
materials_file = openmc.MaterialsFile()
materials_file.default_xs = '71c'
materials_file.add_materials([uo2, helium, zircaloy, borated_water])
materials_file.export_to_xml()
####################
# Define geometry
####################
# Surfaces.
fuel_or = openmc.ZCylinder(R=0.39218, name='Fuel OR')
clad_ir = openmc.ZCylinder(R=0.40005, name='Clad IR')
clad_or = openmc.ZCylinder(R=0.45720, name='Clad OR')
bottom = openmc.YPlane(y0=0.0, name='bottom')
right = openmc.XPlane(x0=pitch / 2.0, name='right')
top = openmc.Plane(A=1, B=-1, name='top') # 45 degree angle
lower = openmc.ZPlane(z0=-10, name='lower')
upper = openmc.ZPlane(z0=10, name='upper')
for s in (bottom, right, top, lower, upper):
s.boundary_type = 'reflective'
# Cells.
fuel_cell = openmc.Cell()
gap_cell = openmc.Cell()
clad_cell = openmc.Cell()
water_cell = openmc.Cell()
# Cell regions.
fuel_cell.region = -fuel_or
gap_cell.region = +fuel_or & -clad_ir
clad_cell.region = +clad_ir & -clad_or
water_cell.region = +clad_or & -right
for c in (fuel_cell, gap_cell, clad_cell, water_cell):
c.region = c.region & +bottom & +top & +lower & -upper
# Cell fills.
fuel_cell.fill = uo2
gap_cell.fill = helium
clad_cell.fill = zircaloy
water_cell.fill = borated_water
# Universe, geometry, and XML.
root = openmc.Universe(universe_id=0, name='Root universe')
root.add_cells([fuel_cell, gap_cell, clad_cell, water_cell])
geometry = openmc.Geometry()
geometry.root_universe = root
geometry_file = openmc.GeometryFile()
geometry_file.geometry = geometry
geometry_file.export_to_xml()
####################
# Define settings
####################
settings_file = openmc.SettingsFile()
settings_file.batches = kwargs.setdefault('batches', 25)
settings_file.inactive = kwargs.setdefault('inactive', 5)
settings_file.particles = kwargs.setdefault('particles', 1000)
settings_file.source = openmc.source.Source(
openmc.stats.Point((0.2, 0.1, 0.0)))
settings_file.export_to_xml()
####################
# Define tallies
####################
mesh = openmc.Mesh(mesh_id=1)
delta = pitch / 2.0 / (n_mesh_bins + 1)
mesh.dimension = [n_mesh_bins, n_mesh_bins, 1]
mesh.lower_left = [-delta / 2.0, -delta / 2.0, -1.e50]
mesh.upper_right = [
pitch / 2.0 + delta / 2.0, pitch / 2.0 + delta / 2.0, 1.e50
]
energy_filter = openmc.Filter(type='energy', bins=energy_bins)
mesh_filter = openmc.Filter()
mesh_filter.mesh = mesh
azim_filter = openmc.Filter(type='azimuthal', bins=n_azim_bins)
tally = openmc.Tally(tally_id=1)
tally.add_filter(energy_filter)
tally.add_filter(mesh_filter)
tally.add_filter(azim_filter)
tally.add_score('flux')
tallies_file = openmc.TalliesFile()
tallies_file.add_mesh(mesh)
tallies_file.add_tally(tally)
tallies_file.export_to_xml()
####################
# Define plots
####################
plotfile = openmc.PlotsFile()
plot = openmc.Plot()
plot.filename = 'matplot'
plot.origin = (pitch / 4.0, pitch / 4.0, 0)
plot.width = (0.5 * pitch, 0.5 * pitch)
plot.pixels = (400, 400)
plot.color = 'mat'
plot.col_spec = {
101: (100, 200, 200),
201: (220, 220, 220),
4001: (150, 150, 150),
9201: (255, 50, 50)
}
plotfile.add_plot(plot)
plot = openmc.Plot()
plot.filename = 'cellplot'
plot.origin = (pitch / 4.0, pitch / 4.0, 0)
plot.width = (0.5 * pitch, 0.5 * pitch)
plot.pixels = (400, 400)
plot.color = 'cell'
plotfile.add_plot(plot)
plotfile.export_to_xml()
eurofer = openmc.Material(name='EUROFER97')
eurofer.set_density('g/cm3', 7.75)
eurofer.add_element('Fe', 89.067, percent_type='wo')
eurofer.add_element('C', 0.11, percent_type='wo')
eurofer.add_element('Mn', 0.4, percent_type='wo')
eurofer.add_element('Cr', 9.0, percent_type='wo')
eurofer.add_element('Ta', 0.12, percent_type='wo')
eurofer.add_element('W', 1.1, percent_type='wo')
eurofer.add_element('N', 0.003, percent_type='wo')
eurofer.add_element('V', 0.2, percent_type='wo')
mats.append(eurofer)
# GEOMETRY
central_sol_surface = openmc.ZCylinder(r=100, boundary_type='vacuum')
vessel_inner = openmc.Sphere(r=500, boundary_type='vacuum')
first_wall_outer_surface = openmc.Sphere(r=510)
breeder_blanket_outer_surface = openmc.Sphere(r=610)
central_sol_region = -central_sol_surface & -breeder_blanket_outer_surface
central_sol_cell = openmc.Cell(region=central_sol_region)
central_sol_cell.fill = copper
first_wall_region = -first_wall_outer_surface & +vessel_inner & +central_sol_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_sol_surface
breeder_blanket_cell = openmc.Cell(region=breeder_blanket_region)
breeder_blanket_cell.fill = eurofer
def segment_pin(n_rings, n_wedges, r_fuel, r_gap, r_clad):
""" Calculates a segmented pin.
Separates a pin with n_rings and n_wedges. All cells have equal volume.
Pin is centered at origin.
"""
# Calculate all the volumes of interest
v_fuel = math.pi * r_fuel**2
v_gap = math.pi * r_gap**2 - v_fuel
v_clad = math.pi * r_clad**2 - v_fuel - v_gap
v_ring = v_fuel / n_rings
v_segment = v_ring / n_wedges
# Compute ring radiuses
r_rings = np.zeros(n_rings)
for i in range(n_rings):
r_rings[i] = math.sqrt(1.0/(math.pi) * v_ring * (i+1))
# Compute thetas
theta = np.linspace(0, 2*math.pi, n_wedges + 1)
# Compute surfaces
fuel_rings = [openmc.ZCylinder(x0=0, y0=0, R=r_rings[i])
for i in range(n_rings)]
fuel_wedges = [openmc.Plane(A=math.cos(theta[i]), B=math.sin(theta[i]))
for i in range(n_wedges)]
gap_ring = openmc.ZCylinder(x0=0, y0=0, R=r_gap)
clad_ring = openmc.ZCylinder(x0=0, y0=0, R=r_clad)
# Create cells
fuel_cells = []
if n_wedges == 1:
for i in range(n_rings):
cell = openmc.Cell(name='fuel')
if i == 0:
cell.region = -fuel_rings[0]
else:
cell.region = +fuel_rings[i-1] & -fuel_rings[i]
fuel_cells.append(cell)
else:
for i in range(n_rings):
for j in range(n_wedges):
cell = openmc.Cell(name='fuel')
if i == 0:
if j != n_wedges-1:
cell.region = (-fuel_rings[0]
& +fuel_wedges[j]
& -fuel_wedges[j+1])
else:
cell.region = (-fuel_rings[0]
& +fuel_wedges[j]
& -fuel_wedges[0])
else:
if j != n_wedges-1:
cell.region = (+fuel_rings[i-1]
& -fuel_rings[i]
& +fuel_wedges[j]
& -fuel_wedges[j+1])
else:
cell.region = (+fuel_rings[i-1]
& -fuel_rings[i]
& +fuel_wedges[j]
& -fuel_wedges[0])
fuel_cells.append(cell)
# Gap ring
gap_cell = openmc.Cell(name='gap')
gap_cell.region = +fuel_rings[-1] & -gap_ring
fuel_cells.append(gap_cell)
# Clad ring
clad_cell = openmc.Cell(name='clad')
clad_cell.region = +gap_ring & -clad_ring
fuel_cells.append(clad_cell)
# Moderator
mod_cell = openmc.Cell(name='cool')
mod_cell.region = +clad_ring
fuel_cells.append(mod_cell)
# Form universe
fuel_u = openmc.Universe()
fuel_u.add_cells(fuel_cells)
return fuel_u, v_segment, v_gap, v_clad
overall model is built by an `assembly` function. This script also demonstrates
the use of the `Model` class, which provides some extra convenience over using
`Geometry`, `Materials`, and `Settings` classes directly. Finally, the script
takes two command-line flags that indicate whether to build and/or run the
model.
"""
import argparse
from math import log10
import numpy as np
import openmc
# Define surfaces
fuel_or = openmc.ZCylinder(r=0.39218, name='Fuel OR')
clad_or = openmc.ZCylinder(r=0.45720, name='Clad OR')
# Define materials
fuel = openmc.Material(name='Fuel')
fuel.set_density('g/cm3', 10.29769)
fuel.add_nuclide('U234', 4.4843e-6)
fuel.add_nuclide('U235', 5.5815e-4)
fuel.add_nuclide('U238', 2.2408e-2)
fuel.add_nuclide('O16', 4.5829e-2)
clad = openmc.Material(name='Cladding')
clad.set_density('g/cm3', 6.55)
clad.add_nuclide('Zr90', 2.1827e-2)
clad.add_nuclide('Zr91', 4.7600e-3)
clad.add_nuclide('Zr92', 7.2758e-3)
fuel = openmc.Material(material_id=40, name='fuel')
fuel.set_density('g/cc', 4.5)
fuel.add_nuclide('U235', 1.)
# Instantiate a Materials collection and export to XML
materials_file = openmc.Materials([moderator, fuel])
materials_file.export_to_xml()
###############################################################################
# Exporting to OpenMC geometry.xml file
###############################################################################
# Instantiate ZCylinder surfaces
surf1 = openmc.ZCylinder(surface_id=1, x0=0, y0=0, R=7, name='surf 1')
surf2 = openmc.ZCylinder(surface_id=2, x0=0, y0=0, R=9, name='surf 2')
surf3 = openmc.ZCylinder(surface_id=3, x0=0, y0=0, R=11, name='surf 3')
surf3.boundary_type = 'vacuum'
# Instantiate Cells
cell1 = openmc.Cell(cell_id=1, name='cell 1')
cell2 = openmc.Cell(cell_id=100, name='cell 2')
cell3 = openmc.Cell(cell_id=101, name='cell 3')
cell4 = openmc.Cell(cell_id=2, name='cell 4')
# Use surface half-spaces to define regions
cell1.region = -surf2
cell2.region = -surf1
cell3.region = +surf1
cell4.region = +surf2 & -surf3
bot_fa.add_nuclide("Zr-91", 0.0824858164, 'wo')
bot_fa.add_nuclide("Zr-92", 0.1274914944, 'wo')
bot_fa.add_nuclide("Zr-94", 0.1319920622, 'wo')
bot_fa.add_nuclide("Zr-96", 0.0216912612, 'wo')
bot_fa.add_s_alpha_beta('HH2O', '71t')
# Define the materials file.
materials = openmc.Materials()
materials.default_xs = '71c'
materials += [fuel, clad, cold_water, hot_water, rpv_steel,
lower_rad_ref, upper_rad_ref, bot_plate,
bot_nozzle, top_nozzle, top_fa, bot_fa]
materials.export_to_xml()
# Define surfaces.
s1 = openmc.ZCylinder(R=0.41, surface_id=1)
s2 = openmc.ZCylinder(R=0.475, surface_id=2)
s3 = openmc.ZCylinder(R=0.56, surface_id=3)
s4 = openmc.ZCylinder(R=0.62, surface_id=4)
s5 = openmc.ZCylinder(R=187.6, surface_id=5)
s6 = openmc.ZCylinder(R=209.0, surface_id=6)
s7 = openmc.ZCylinder(R=229.0, surface_id=7)
s8 = openmc.ZCylinder(R=249.0, surface_id=8)
s8.boundary_type = 'vacuum'
s31 = openmc.ZPlane(z0=-229.0, surface_id=31)
s31.boundary_type = 'vacuum'
s32 = openmc.ZPlane(z0=-199.0, surface_id=32)
s33 = openmc.ZPlane(z0=-193.0, surface_id=33)
s34 = openmc.ZPlane(z0=-183.0, surface_id=34)
s35 = openmc.ZPlane(z0=0.0, surface_id=35)
# Exporting to OpenMC geometry.xml file ############################################################################### # Instantiate ZCylinder surfaces factor = 1.0 factor_p = 1.0 entropy_mesh_value = 0.39218 # 0.39218 fuel_r = 0.39218*factor # 0.39218 clad_ir = 0.40005*factor # 0.40005 clar_or = 0.45720*factor # 0.45720 void_r = 0.5772*factor # 0.57720 plane_value = 0.62992*factor_p # 0.62992 fuel_or = openmc.ZCylinder(surface_id=1, x0=0, y0=0, r=fuel_r, name='Fuel OR') clad_ir = openmc.ZCylinder(surface_id=2, x0=0, y0=0, r=clad_ir, name='Clad IR') clad_or = openmc.ZCylinder(surface_id=3, x0=0, y0=0, r=clar_or, name='Clad OR') void_r= openmc.ZCylinder(surface_id=4, x0=0, y0=0, r=void_r, name='Clad OR') left = openmc.XPlane(surface_id=5, x0=-plane_value, name='left') right = openmc.XPlane(surface_id=6, x0=plane_value, name='right') bottom = openmc.YPlane(surface_id=7, y0=-plane_value, name='bottom') top = openmc.YPlane(surface_id=8, y0=plane_value, name='top') left.boundary_type = 'reflective' right.boundary_type = 'reflective' top.boundary_type = 'reflective' bottom.boundary_type = 'reflective' # Instantiate Cells
eurofer.add_element('Fe', 89.067, percent_type='wo')
eurofer.add_element('C', 0.11, percent_type='wo')
eurofer.add_element('Mn', 0.4, percent_type='wo')
eurofer.add_element('Cr', 9.0, percent_type='wo')
eurofer.add_element('Ta', 0.12, percent_type='wo')
eurofer.add_element('W', 1.1, percent_type='wo')
eurofer.add_element('N', 0.003, percent_type='wo')
eurofer.add_element('V', 0.2, percent_type='wo')
mats = openmc.Materials([breeder_material, eurofer, copper])
# GEOMETRY
# surfaces
central_sol_surface = openmc.ZCylinder(r=100)
central_shield_outer_surface = openmc.ZCylinder(r=110)
vessel_inner_surface = openmc.Sphere(r=500)
first_wall_outer_surface = openmc.Sphere(r=510)
breeder_blanket_outer_surface = openmc.Sphere(r=610, boundary_type='vacuum')
# cells
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_vessel_region = -vessel_inner_surface & +central_shield_outer_surface
water = openmc.Material(material_id=2, name='Water')
water.set_density('macro', 1.0)
water.add_macroscopic(h2o_data)
# Instantiate a Materials collection and export to XML
materials_file = openmc.Materials([uo2, water])
materials_file.default_xs = '300K'
materials_file.export_to_xml()
###############################################################################
# Exporting to OpenMC geometry.xml file
###############################################################################
# Instantiate ZCylinder surfaces
fuel_or = openmc.ZCylinder(surface_id=1, x0=0, y0=0, R=0.54, name='Fuel OR')
left = openmc.XPlane(surface_id=4, x0=-0.63, name='left')
right = openmc.XPlane(surface_id=5, x0=0.63, name='right')
bottom = openmc.YPlane(surface_id=6, y0=-0.63, name='bottom')
top = openmc.YPlane(surface_id=7, y0=0.63, name='top')
left.boundary_type = 'reflective'
right.boundary_type = 'reflective'
top.boundary_type = 'reflective'
bottom.boundary_type = 'reflective'
# Instantiate Cells
fuel = openmc.Cell(cell_id=1, name='cell 1')
moderator = openmc.Cell(cell_id=2, name='cell 2')
# Use surface half-spaces to define regions
acrylic=openmc.Material(5,'acrylic')
acrylic.add_nuclide('H1',5.6642e-2)
acrylic.add_nuclide('O16',1.4273e-2)
acrylic.add_nuclide('C0',3.5648e-2)
acrylic.add_s_alpha_beta('c_H_in_CH2')
acrylic.set_density('g/cm3',1.185)
mats=openmc.Materials([fuel,water,clad6061,rubber,acrylic])
mats.cross_sections='/home/tang/nndc_hdf5/cross_sections.xml'
mats.export_to_xml()
#fuel cylinder
zc1=openmc.ZCylinder(x0=0,y0=0,R=0.6325)
zc2=openmc.ZCylinder(x0=0,y0=0,R=0.6415)
xp3=openmc.XPlane(x0= -1.27)
xp4=openmc.XPlane(x0=1.27)
yp5=openmc.YPlane(y0=-1.27)
yp6=openmc.YPlane(y0=1.27)
zp7=openmc.ZPlane(z0= 0.0)
zp8=openmc.ZPlane(z0=92.075)
zp9=openmc.ZPlane(z0= 94.2975) #top 0f clad
xp10=openmc.XPlane(x0=22.86 )
xp11=openmc.XPlane(x0= 0.)
zc12=openmc.ZCylinder(x0=0,y0=0,R=0.7075)#clad outer surface
xp13=openmc.XPlane(x0=7.62)
ss_plate = openmc.Material(7, 'ss_plate')
ss_plate.add_element('Cr', 1.7046e-2)
ss_plate.add_nuclide('Mn55', 1.3734e-3)
ss_plate.add_element('Cu', 2.0291e-4)
ss_plate.add_element('Fe', 5.8353e-2)
ss_plate.add_element('Ni', 9.0238e-3)
ss_plate.add_element('Mo', 1.2942e-4)
ss_plate.set_density('g/cm3', 7.93)
mats = openmc.Materials(
[fuel, water, clad6061, clad5052, acrylic, clad1100, ss_plate])
mats.cross_sections = '/home/tang/nndc_hdf5/cross_sections.xml'
mats.export_to_xml()
#fuel cylinder
zc1 = openmc.ZCylinder(x0=0, y0=0, R=0.5588)
zc2 = openmc.ZCylinder(x0=0, y0=0, R=0.635)
zp7 = openmc.ZPlane(z0=0.0)
zp8 = openmc.ZPlane(z0=91.44)
zp9 = openmc.ZPlane(z0=91.92) #top 0f clad
xp10 = openmc.XPlane(x0=40.64)
xp11 = openmc.XPlane(x0=0.0)
xp15 = openmc.XPlane(x0=48.28)
xp14 = openmc.XPlane(x0=88.92)
xp17 = openmc.XPlane(x0=96.56)
xp16 = openmc.XPlane(x0=137.2)
yp20 = openmc.YPlane(y0=32.512)
yp19 = openmc.YPlane(y0=0.0)
for name, frac in (zirc.get_nuclide_atom_densities().values()):
homogenized.add_nuclide(name, frac * area_clad / area_homog)
for name, frac in (water.get_nuclide_atom_densities().values()):
homogenized.add_nuclide(name, frac * area_channel / area_homog)
# In[8]:
materials = openmc.Materials([uo2, homogenized])
# ## Surfaces
# In[9]:
rfo = openmc.ZCylinder(R=radius_fuel)
xy_box = openmc.model.get_rectangular_prism(pitch,
pitch,
boundary_type='reflective')
z0 = openmc.ZPlane(z0=-10, boundary_type='reflective')
z1 = openmc.ZPlane(z0=10, boundary_type='reflective')
# ## Cells, etc.
# In[10]:
fuel = openmc.Cell(name='fuel', fill=uo2)
fuel.region = -rfo & +z0 & -z1
mod = openmc.Cell(name='moderator', fill=homogenized)
mod.region = +rfo & xy_box & +z0 & -z1
root = openmc.Universe(cells=(fuel, mod))
def _build_inputs(self):
# Instantiate some Materials and register the appropriate Nuclides
uo2 = openmc.Material(name='UO2 fuel at 2.4% wt enrichment')
uo2.set_density('g/cc', 10.0)
uo2.add_nuclide('U238', 1.0)
uo2.add_nuclide('U235', 0.02)
uo2.add_nuclide('O16', 2.0)
borated_water = openmc.Material(name='Borated water')
borated_water.set_density('g/cm3', 1)
borated_water.add_nuclide('B10', 10e-5)
borated_water.add_nuclide('H1', 2.0)
borated_water.add_nuclide('O16', 1.0)
# Instantiate a Materials collection and export to XML
materials_file = openmc.Materials([uo2, borated_water])
materials_file.export_to_xml()
# Instantiate ZCylinder surfaces
fuel_or = openmc.ZCylinder(surface_id=1, x0=0, y0=0, R=1, \
name='Fuel OR')
left = openmc.XPlane(surface_id=2, x0=-2, name='left')
right = openmc.XPlane(surface_id=3, x0=2, name='right')
bottom = openmc.YPlane(y0=-2, name='bottom')
top = openmc.YPlane(y0=2, name='top')
left.boundary_type = 'vacuum'
right.boundary_type = 'reflective'
top.boundary_type = 'reflective'
bottom.boundary_type = 'reflective'
# Instantiate Cells
fuel = openmc.Cell(name='fuel')
water = openmc.Cell(name='water')
# Use surface half-spaces to define regions
fuel.region = -fuel_or
water.region = +fuel_or & -right & +bottom & -top
# Register Materials with Cells
fuel.fill = uo2
water.fill = borated_water
# Instantiate pin cell Universe
pin_cell = openmc.Universe(name='pin cell')
pin_cell.add_cells([fuel, water])
# Instantiate root Cell and Universe
root_cell = openmc.Cell(name='root cell')
root_cell.region = +left & -right & +bottom & -top
root_cell.fill = pin_cell
root_univ = openmc.Universe(universe_id=0, name='root universe')
root_univ.add_cell(root_cell)
# Instantiate a Geometry, register the root Universe
geometry = openmc.Geometry(root_univ)
geometry.export_to_xml()
# Instantiate a Settings object, set all runtime parameters
settings_file = openmc.Settings()
settings_file.batches = 10
settings_file.inactive = 0
settings_file.particles = 1000
#settings_file.output = {'tallies': True}
# Create an initial uniform spatial source distribution
bounds = [-0.62992, -0.62992, -1, 0.62992, 0.62992, 1]
uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:],\
only_fissionable=True)
settings_file.source = openmc.source.Source(space=uniform_dist)
settings_file.export_to_xml()
# Tallies file
tallies_file = openmc.Tallies()
# Create partial current tallies from fuel to water
# Filters
two_groups = [0., 4e6, 20e6]
energy_filter = openmc.EnergyFilter(two_groups)
polar_filter = openmc.PolarFilter([0, np.pi / 4, np.pi])
azimuthal_filter = openmc.AzimuthalFilter([0, np.pi / 4, np.pi])
surface_filter = openmc.SurfaceFilter([1])
cell_from_filter = openmc.CellFromFilter(fuel)
cell_filter = openmc.CellFilter(water)
# Use Cell to cell filters for partial current
cell_to_cell_tally = openmc.Tally(name=str('fuel_to_water_1'))
cell_to_cell_tally.filters = [cell_from_filter, cell_filter, \
energy_filter, polar_filter, azimuthal_filter]
cell_to_cell_tally.scores = ['current']
tallies_file.append(cell_to_cell_tally)
# Use a Cell from + surface filters for partial current
cell_to_cell_tally = openmc.Tally(name=str('fuel_to_water_2'))
cell_to_cell_tally.filters = [cell_from_filter, surface_filter, \
energy_filter, polar_filter, azimuthal_filter]
cell_to_cell_tally.scores = ['current']
tallies_file.append(cell_to_cell_tally)
# Create partial current tallies from water to fuel
# Filters
cell_from_filter = openmc.CellFromFilter(water)
cell_filter = openmc.CellFilter(fuel)
# Cell to cell filters for partial current
cell_to_cell_tally = openmc.Tally(name=str('water_to_fuel_1'))
cell_to_cell_tally.filters = [cell_from_filter, cell_filter, \
energy_filter, polar_filter, azimuthal_filter]
cell_to_cell_tally.scores = ['current']
tallies_file.append(cell_to_cell_tally)
# Cell from + surface filters for partial current
cell_to_cell_tally = openmc.Tally(name=str('water_to_fuel_2'))
cell_to_cell_tally.filters = [cell_from_filter, surface_filter, \
energy_filter, polar_filter, azimuthal_filter]
cell_to_cell_tally.scores = ['current']
tallies_file.append(cell_to_cell_tally)
# Create a net current tally on inner surface using a surface filter
surface_filter = openmc.SurfaceFilter([1])
surf_tally1 = openmc.Tally(name='net_cylinder')
surf_tally1.filters = [surface_filter, energy_filter, polar_filter, \
azimuthal_filter]
surf_tally1.scores = ['current']
tallies_file.append(surf_tally1)
# Create a net current tally on left surface using a surface filter
# This surface has a vacuum boundary condition, so leakage is tallied
surface_filter = openmc.SurfaceFilter([2])
surf_tally2 = openmc.Tally(name='leakage_left')
surf_tally2.filters = [surface_filter, energy_filter, polar_filter, \
azimuthal_filter]
surf_tally2.scores = ['current']
tallies_file.append(surf_tally2)
# Create a net current tally on right surface using a surface filter
# This surface has a reflective boundary condition, but the zero
# net current is not picked up because particles are only tallied once
surface_filter = openmc.SurfaceFilter([3])
surf_tally3 = openmc.Tally(name='net_right')
surf_tally3.filters = [surface_filter, energy_filter]
surf_tally3.scores = ['current']
tallies_file.append(surf_tally3)
surface_filter = openmc.SurfaceFilter([3])
surf_tally3 = openmc.Tally(name='net_right')
surf_tally3.filters = [surface_filter, energy_filter]
surf_tally3.scores = ['current']
tallies_file.append(surf_tally3)
tallies_file.export_to_xml()
fuel.add_nuclide('U236', 6.4776E-08)
fuel.add_nuclide('U238', 5.7769E-04)
fuel.set_density('atom/b-cm', 9.89471078E-02)
fuel.add_s_alpha_beta('c_H_in_H2O')
mats = openmc.Materials([clad, air, fuel])
mats.cross_sections = '/home/tang/nndc_hdf5/cross_sections.xml'
mats.export_to_xml()
zp1 = openmc.ZPlane(z0=0.0)
zp2 = openmc.ZPlane(z0=83.55)
zp3 = openmc.ZPlane(z0=150.0)
zp4 = openmc.ZPlane(z0=152.5, boundary_type='vacuum')
zp5 = openmc.ZPlane(z0=-2.0, boundary_type='vacuum')
zc10 = openmc.ZCylinder(x0=0, y0=0, R=29.5)
zc20 = openmc.ZCylinder(x0=0, y0=0, R=29.8, boundary_type='vacuum')
cell1 = openmc.Cell()
region1 = +zp1 & -zp2 & -zc10
cell1.region = region1
cell1.fill = fuel
cell2 = openmc.Cell()
region2 = +zp2 & -zp3 & -zc10
cell2.region = region2
cell2.fill = air
cell3 = openmc.Cell()
cell3.region = -zp1 | +zp3 | +zc10
cell3.fill = clad
pyrex.set_density('g/cm3', 2.26)
mf = openmc.Materials((uo2, zirconium, water, pyrex))
mf.export_to_xml()
# color stuff
colors = {}
colors[water] = (100, 200, 200)
colors[zirconium] = (150, 150, 150)
colors[pyrex] = (100, 255, 100)
colors[uo2] = (255, 50, 50)
#fuel pin
pitch = 1.26
fuel_or = openmc.ZCylinder(R=0.39)
clad_ir = openmc.ZCylinder(R=0.40)
clad_or = openmc.ZCylinder(R=0.46)
fuel = openmc.Cell(1, 'fuel')
fuel.fill = uo2
fuel.region = -fuel_or
gap = openmc.Cell(2, 'air gap')
gap.fill = 'void'
gap.region = +fuel_or & -clad_ir
clad = openmc.Cell(3, 'clad')
clad.fill = zirconium
clad.region = +clad_ir & -clad_or
# Instantiate a Materials collection and export to XML materials_file = openmc.Materials([moderator, fuel, iron]) materials_file.default_xs = '71c' materials_file.export_to_xml() ############################################################################### # Exporting to OpenMC geometry.xml file ############################################################################### # Instantiate Surfaces left = openmc.XPlane(surface_id=1, x0=-3, name='left') right = openmc.XPlane(surface_id=2, x0=3, name='right') bottom = openmc.YPlane(surface_id=3, y0=-4, name='bottom') top = openmc.YPlane(surface_id=4, y0=4, name='top') fuel_surf = openmc.ZCylinder(surface_id=5, x0=0, y0=0, R=0.4) left.boundary_type = 'vacuum' right.boundary_type = 'vacuum' top.boundary_type = 'vacuum' bottom.boundary_type = 'vacuum' # Instantiate Cells cell1 = openmc.Cell(cell_id=1, name='Cell 1') cell2 = openmc.Cell(cell_id=101, name='cell 2') cell3 = openmc.Cell(cell_id=102, name='cell 3') cell4 = openmc.Cell(cell_id=500, name='cell 4') cell5 = openmc.Cell(cell_id=600, name='cell 5') cell6 = openmc.Cell(cell_id=601, name='cell 6') # Use surface half-spaces to define regions
def _build_inputs(self):
####################
# Materials
####################
moderator = openmc.Material(material_id=1)
moderator.set_density('g/cc', 1.0)
moderator.add_nuclide('H1', 2.0)
moderator.add_nuclide('O16', 1.0)
dense_fuel = openmc.Material(material_id=2)
dense_fuel.set_density('g/cc', 4.5)
dense_fuel.add_nuclide('U235', 1.0)
light_fuel = openmc.Material(material_id=3)
light_fuel.set_density('g/cc', 2.0)
light_fuel.add_nuclide('U235', 1.0)
mats_file = openmc.Materials([moderator, dense_fuel, light_fuel])
mats_file.export_to_xml()
####################
# Geometry
####################
c1 = openmc.Cell(cell_id=1, fill=moderator)
mod_univ = openmc.Universe(universe_id=1, cells=[c1])
r0 = openmc.ZCylinder(r=0.3)
c11 = openmc.Cell(cell_id=11, region=-r0)
c11.fill = [dense_fuel, None, light_fuel, dense_fuel]
c12 = openmc.Cell(cell_id=12, region=+r0, fill=moderator)
fuel_univ = openmc.Universe(universe_id=11, cells=[c11, c12])
lat = openmc.RectLattice(lattice_id=101)
lat.lower_left = [-2.0, -2.0]
lat.pitch = [2.0, 2.0]
lat.universes = [[fuel_univ]*2]*2
lat.outer = mod_univ
x0 = openmc.XPlane(x0=-3.0)
x1 = openmc.XPlane(x0=3.0)
y0 = openmc.YPlane(y0=-3.0)
y1 = openmc.YPlane(y0=3.0)
for s in [x0, x1, y0, y1]:
s.boundary_type = 'reflective'
c101 = openmc.Cell(cell_id=101, fill=lat)
c101.region = +x0 & -x1 & +y0 & -y1
root_univ = openmc.Universe(universe_id=0, cells=[c101])
geometry = openmc.Geometry(root_univ)
geometry.export_to_xml()
####################
# Settings
####################
sets_file = openmc.Settings()
sets_file.batches = 5
sets_file.inactive = 0
sets_file.particles = 1000
sets_file.source = openmc.Source(space=openmc.stats.Box(
[-1, -1, -1], [1, 1, 1]))
sets_file.export_to_xml()
####################
# Plots
####################
plot1 = openmc.Plot(plot_id=1)
plot1.basis = 'xy'
plot1.color_by = 'cell'
plot1.filename = 'cellplot'
plot1.origin = (0, 0, 0)
plot1.width = (7, 7)
plot1.pixels = (400, 400)
plot2 = openmc.Plot(plot_id=2)
plot2.basis = 'xy'
plot2.color_by = 'material'
plot2.filename = 'matplot'
plot2.origin = (0, 0, 0)
plot2.width = (7, 7)
plot2.pixels = (400, 400)
plots = openmc.Plots([plot1, plot2])
plots.export_to_xml()
def hexfunction(pitch, pack_frac):
settings = openmc.Settings()
# Set high tolerance to allow use of lower temperature xs
settings.temperature['tolerance'] = 1000
settings.temperature['method'] = 'nearest'
settings.temperature['multipole'] = True
settings.cutoff = {'energy': 1e-8} #energy cutoff in eV
#############################
### MATERIALS ###
#############################
mat_list = []
enrichment = 20.0
uo2 = openmc.Material(1, "uo2")
uo2.add_element('U', 1.0, enrichment=enrichment)
uo2.add_element('O', 2.0)
uo2.set_density('g/cm3', 10.97)
uo2.temperature = 900 #kelvin
mat_list.append(uo2)
graphite = openmc.Material(2, "graphite")
graphite.set_density('g/cm3', 1.1995)
graphite.add_element('C', 1.0)
graphite.add_s_alpha_beta('c_Graphite')
graphite.temperature = 900 #kelvin
mat_list.append(graphite)
# sodium = openmc.Material(3, "sodium")
sodium = openmc.Material()
sodium.set_density('g/cm3', 0.8017) # 900 K
sodium.add_element('Na', 1.0)
# sodium.add_s_alpha_beta('c_Graphite')
sodium.temperature = 900 #kelvin
mat_list.append(sodium)
# naoh = openmc.Material(6, "naoh")
naoh = openmc.Material()
naoh.set_density('g/cm3', 1.5) # 900 K
naoh.add_element('Na', 1.0)
naoh.add_element('O', 1.0)
naoh.add_element('H', 1.0)
# sodium.add_s_alpha_beta('c_Graphite')
naoh.temperature = 900 #kelvin
mat_list.append(naoh)
# TRISO Materials
fuel = openmc.Material(name='Fuel')
fuel.set_density('g/cm3', 10.5)
# fuel.add_nuclide('U235', 4.6716e-02)
fuel.add_nuclide('U235', 0.0667372)
# fuel.add_nuclide('U238', 2.8697e-01)
fuel.add_nuclide('U238', 0.2669488)
fuel.add_nuclide('O16', 5.0000e-01)
fuel.add_element('C', 1.6667e-01)
mat_list.append(fuel)
buff = openmc.Material(name='Buffer')
buff.set_density('g/cm3', 1.0)
buff.add_element('C', 1.0)
buff.add_s_alpha_beta('c_Graphite')
mat_list.append(buff)
PyC1 = openmc.Material(name='PyC1')
PyC1.set_density('g/cm3', 1.9)
PyC1.add_element('C', 1.0)
PyC1.add_s_alpha_beta('c_Graphite')
mat_list.append(PyC1)
PyC2 = openmc.Material(name='PyC2')
PyC2.set_density('g/cm3', 1.87)
PyC2.add_element('C', 1.0)
PyC2.add_s_alpha_beta('c_Graphite')
mat_list.append(PyC2)
SiC = openmc.Material(name='SiC')
SiC.set_density('g/cm3', 3.2)
SiC.add_element('C', 0.5)
SiC.add_element('Si', 0.5)
mat_list.append(SiC)
fuel_temp = 900
homogeneous_fuel = build_fuel_material(fuel_temp, pack_frac)
mat_list.append(homogeneous_fuel)
mats = openmc.Materials(mat_list)
mats.export_to_xml()
#############################
### GEOMETRY ###
#############################
pitch = 17.4
fuel_bottom = -pitch / 2
fuel_top = pitch / 2
coolant_r = 4
# fuel_r = (pitch/2 - coolant_r)/2
fuel_r = (pitch / (3**(1 / 2)) - coolant_r) / 2
hex_universe = openmc.Universe()
top = openmc.ZPlane(z0=fuel_top, boundary_type='reflective')
bottom = openmc.ZPlane(z0=fuel_bottom, boundary_type='reflective')
surf_fuel = openmc.ZCylinder(r=fuel_r)
# Make TRISOS to be filled in fuel cylinders by chopping up
# fuel cylinder into segments
n_cyls = 40
fuel_segment_heights = np.linspace(fuel_bottom, fuel_top, n_cyls)
segment_height = fuel_segment_heights[1] - fuel_segment_heights[0]
fuel_planes = [bottom]
fuel_cells = []
for i, height in enumerate(fuel_segment_heights[1:-1]):
this_plane = openmc.ZPlane(z0=height)
fuel_planes.append(this_plane)
this_cell = openmc.Cell()
this_cell.region = +fuel_planes[i] & -fuel_planes[i + 1] & -surf_fuel
fuel_cells.append(copy.deepcopy(this_cell))
# last cell
fuel_planes.append(top)
this_cell = openmc.Cell()
this_cell.region = +fuel_planes[-2] & -fuel_planes[-1] & -surf_fuel
fuel_cells.append(copy.deepcopy(this_cell))
# Make fuel cylinder
fuel_cyl_top = openmc.ZPlane(z0=segment_height / 2)
fuel_cyl_bottom = openmc.ZPlane(z0=-segment_height / 2)
fuel_triso_region = -surf_fuel & +fuel_cyl_bottom & -fuel_cyl_top
outer_radius = 425. * 1e-4
# openmc.model.triso._Cylinder.from_region(fuel_region, outer_radius)
spheres = [openmc.Sphere(r=r * 1e-4) for r in [215., 315., 350., 385.]]
cells = [
openmc.Cell(fill=fuel, region=-spheres[0]),
openmc.Cell(fill=buff, region=+spheres[0] & -spheres[1]),
openmc.Cell(fill=PyC1, region=+spheres[1] & -spheres[2]),
openmc.Cell(fill=SiC, region=+spheres[2] & -spheres[3]),
openmc.Cell(fill=PyC2, region=+spheres[3])
]
triso_univ = openmc.Universe(cells=cells)
outer_radius = 425. * 1e-4
centers = openmc.model.pack_spheres(radius=outer_radius,
region=fuel_triso_region,
pf=pack_frac)
trisos = [openmc.model.TRISO(outer_radius, triso_univ, c) for c in centers]
outside_trisos = openmc.Intersection(~t.region for t in trisos)
# background_region = outside_trisos & +fuel_cyl_bottom & \
# -fuel_cyl_top & -surf_fuel
background_region = outside_trisos
background_cell = openmc.Cell(fill=graphite, region=background_region)
fuel_triso_univ = openmc.Universe()
fuel_triso_univ.add_cell(background_cell)
for idx, triso in enumerate(trisos):
fuel_triso_univ.add_cell(triso)
# Fill in fuel cells with triso cells and translate to location
for i, cell in enumerate(fuel_cells):
cell_height = segment_height * (i + 1 / 2) + fuel_bottom
cell.translation = [0, 0, cell_height]
cell.fill = fuel_triso_univ
fuel_cell_univ = openmc.Universe(cells=fuel_cells)
# For testing solid fuel
# test_region = +bottom & -top & -surf_fuel
# fuel_cell = openmc.Cell(region=test_region, fill=fuel)
# fuel_cell_univ = openmc.Universe(cells=[fuel_cell])
coolant_cyl = openmc.ZCylinder(r=coolant_r)
coolant_region = -coolant_cyl
coolant_cell = openmc.Cell()
coolant_cell.fill = naoh
coolant_cell.region = coolant_region
hex_universe.add_cell(coolant_cell)
hex_prism = openmc.get_hexagonal_prism(edge_length=pitch / (3**1 / 2),
boundary_type='reflective')
graphite_region = hex_prism & +coolant_cyl & -top & +bottom
graphite_cell = openmc.Cell()
graphite_cell.fill = graphite
graphite_cell.region = graphite_region
hex_universe.add_cell(graphite_cell)
fuel_cells = []
root3 = 3**(1 / 2)
half_to_vertex = pitch / root3 / 2
half_to_edge = pitch / 4
# fuel_id = 100
offset_angle = 30
n_pins = 6
for i in range(n_pins):
theta = (offset_angle + i / n_pins * 360) * pi / 180
r = coolant_r + fuel_r + 0.01
x = r * np.cos(theta)
y = r * np.sin(theta)
fuel_cyl_bound = openmc.ZCylinder(x0=x, y0=y, r=fuel_r)
graphite_cell.region &= +fuel_cyl_bound
fuel_cell = openmc.Cell()
fuel_cell.fill = copy.deepcopy(fuel_cell_univ)
fuel_cell.translation = [x, y, 0]
fuel_cell.region = -fuel_cyl_bound & -top & +bottom
# fuel_cell.id = fuel_id
# fuel_id += 1
fuel_cells.append(fuel_cell)
hex_universe.add_cell(fuel_cell)
geom = openmc.Geometry(hex_universe)
# geom = openmc.Geometry(fuel_cell_univ)
geom.export_to_xml()
#####################################
### SOURCE/BATCHES ###
#####################################
point = openmc.stats.Point((0, 0, 0))
src = openmc.Source(space=point)
settings.source = src
settings.batches = 50
settings.inactive = 10
settings.particles = 200
settings.export_to_xml()
#############################
### TALLIES ###
#############################
# Instantiate an empty Tallies object
tallies_file = openmc.Tallies()
# K-Eigenvalue (infinity) tallies
fiss_rate = openmc.Tally(name='fiss. rate')
fiss_rate.scores = ['nu-fission']
tallies_file.append(fiss_rate)
abs_rate = openmc.Tally(name='abs. rate')
abs_rate.scores = ['absorption']
tallies_file.append(abs_rate)
# Resonance Escape Probability tallies
therm_abs_rate = openmc.Tally(name='therm. abs. rate')
therm_abs_rate.scores = ['absorption']
therm_abs_rate.filters = [openmc.EnergyFilter([0., 0.625])]
tallies_file.append(therm_abs_rate)
# Thermal Flux Utilization tallies
# fuel_therm_abs_rate = openmc.Tally(name='fuel therm. abs. rate')
# fuel_therm_abs_rate.scores = ['absorption']
# fuel_therm_abs_rate.filters = [openmc.EnergyFilter([0., 0.625]),
# openmc.CellFilter([fuel_cell])]
# tallies_file.append(fuel_therm_abs_rate)
# Fast Fission Factor tallies
therm_fiss_rate = openmc.Tally(name='therm. fiss. rate')
therm_fiss_rate.scores = ['nu-fission']
therm_fiss_rate.filters = [openmc.EnergyFilter([0., 0.625])]
tallies_file.append(therm_fiss_rate)
tallies_file.export_to_xml()
#############################
### PLOTTING ###
#############################
zs = np.linspace(0, 1, 2)
plots = []
for z in zs:
p = openmc.Plot()
p.filename = 'pinplot' + str(z)
p.width = (1.4 * pitch, 1.4 * pitch)
p.pixels = (2000, 2000)
p.color_by = 'material'
p.origin = [0, 0, z]
# p.color_by = 'cell'
# p.colors = {homogeneous_fuel: 'yellow', naoh: 'grey', graphite: 'black'}
p.colors = {fuel: 'yellow', naoh: 'grey', graphite: 'black'}
plots.append(copy.deepcopy(p))
plots = openmc.Plots(plots)
plots.export_to_xml()
# openmc.plot_geometry(output = False)
openmc.plot_geometry()
# pngstring = 'pinplot{}.png'.format(str(pitch))
# subprocess.call(['convert','pinplot.ppm',pngstring])
# subprocess.call(['mv',pngstring,'figures/'+pngstring])
#############################
### EXECUTION ###
#############################
# openmc.run(output=False)
openmc.run()
sp = openmc.StatePoint('statepoint.{}.h5'.format(settings.batches))
# Collect all the tallies
fiss_rate = sp.get_tally(name='fiss. rate')
fiss_rate_df = fiss_rate.get_pandas_dataframe()
abs_rate = sp.get_tally(name='abs. rate')
abs_rate_df = abs_rate.get_pandas_dataframe()
therm_abs_rate = sp.get_tally(name='therm. abs. rate')
therm_abs_rate_df = therm_abs_rate.get_pandas_dataframe()
fuel_therm_abs_rate = sp.get_tally(name='fuel therm. abs. rate')
fuel_therm_abs_rate_df = fuel_therm_abs_rate.get_pandas_dataframe()
therm_fiss_rate = sp.get_tally(name='therm. fiss. rate')
therm_fiss_rate_df = therm_fiss_rate.get_pandas_dataframe()
# Compute k-infinity
kinf = fiss_rate / abs_rate
kinf_df = kinf.get_pandas_dataframe()
# Compute resonance escape probability
res_esc = (therm_abs_rate) / (abs_rate)
res_esc_df = res_esc.get_pandas_dataframe()
# Compute fast fission factor
fast_fiss = fiss_rate / therm_fiss_rate
fast_fiss_df = fast_fiss.get_pandas_dataframe()
# Compute thermal flux utilization
therm_util = fuel_therm_abs_rate / therm_abs_rate
therm_util_df = therm_util.get_pandas_dataframe()
# Compute neutrons produced per absorption
eta = therm_fiss_rate / fuel_therm_abs_rate
eta_df = eta.get_pandas_dataframe()
columns = [
'pitch', 'enrichment', 'kinf mean', 'kinf sd', 'res_esc mean',
'res_esc sd', 'fast_fiss mean', 'fast_fiss sd', 'therm_util mean',
'therm_util sd', 'eta mean', 'eta sd'
]
data = [[
pitch, enrichment, kinf_df['mean'][0], kinf_df['std. dev.'][0],
res_esc_df['mean'][0], res_esc_df['std. dev.'][0],
fast_fiss_df['mean'][0], fast_fiss_df['std. dev.'][0],
therm_util_df['mean'][0], therm_util_df['std. dev.'][0],
eta_df['mean'][0], eta_df['std. dev.'][0]
]]
all_tallies = pd.DataFrame(data, columns=columns)
return all_tallies
## Universes and in-line plotting
universe = openmc.Universe()
universe.add_cell(cell)
# universe.plot(width=(2.0, 2.0))
# universe.plot(width=(2.0, 2.0), basis='xz')
# universe.plot(width=(2.0, 2.0), basis='xz', colors={cell: 'fuchsia'})
## Pin cell geometry
# Modifications
z_top = openmc.ZPlane(z0=0.5, boundary_type='reflective')
z_bot = openmc.ZPlane(z0=-0.5, boundary_type='reflective')
fuel_or = openmc.ZCylinder(R=0.39)
clad_ir = openmc.ZCylinder(R=0.40)
clad_or = openmc.ZCylinder(R=0.46)
fuel_region = -fuel_or & +z_bot & -z_top
gap_region = +fuel_or & -clad_ir & +z_bot & -z_top
clad_region = +clad_ir & -clad_or & +z_bot & -z_top
fuel = openmc.Cell(1, 'fuel')
fuel.fill = uo2
fuel.region = fuel_region
gap = openmc.Cell(2, 'air gap')
gap.region = gap_region
clad = openmc.Cell(3, 'clad')
borated_water.add_nuclide(o16, 2.4672e-2)
borated_water.add_nuclide(o17, 6.0099e-5)
borated_water.add_s_alpha_beta('HH2O', '71t')
# Instantiate a MaterialsFile, register all Materials, and export to XML
materials_file = openmc.MaterialsFile()
materials_file.default_xs = '71c'
materials_file.add_materials([uo2, helium, zircaloy, borated_water])
materials_file.export_to_xml()
###############################################################################
# Exporting to OpenMC geometry.xml File
###############################################################################
# Instantiate ZCylinder surfaces
fuel_or = openmc.ZCylinder(surface_id=1, x0=0, y0=0, R=0.39218, name='Fuel OR')
clad_ir = openmc.ZCylinder(surface_id=2, x0=0, y0=0, R=0.40005, name='Clad IR')
clad_or = openmc.ZCylinder(surface_id=3, x0=0, y0=0, R=0.45720, name='Clad OR')
left = openmc.XPlane(surface_id=4, x0=-0.62992, name='left')
right = openmc.XPlane(surface_id=5, x0=0.62992, name='right')
bottom = openmc.YPlane(surface_id=6, y0=-0.62992, name='bottom')
top = openmc.YPlane(surface_id=7, y0=0.62992, name='top')
left.boundary_type = 'reflective'
right.boundary_type = 'reflective'
top.boundary_type = 'reflective'
bottom.boundary_type = 'reflective'
# Instantiate Cells
fuel = openmc.Cell(cell_id=1, name='cell 1')
gap = openmc.Cell(cell_id=2, name='cell 2')
