def make_load(name, outer, assemblies, number, hpitch, lenz, load_dict = {}):
"""Parametres:
----------
name : str
- load called
outer : openmc.Universe
- outer universe
assemblies : dictionary
- loaded type of assembly
load_dict : dictionary
- a pairs 'name of lattice3d' : a 'list of spiral numbers'
Return:
----------
openmc.Lattice
"""
lattice = openmc.HexLattice(lattice_id=1001, name=name)
lattice.center = (0, 0, 0)
lattice.orientation = "x"
lattice.pitch = (hpitch, lenz)
lattice.outer = outer
univs = []
univs.append(init_openmc_spiral(outer, number))
lattice.universes = univs
for k,v in load_dict.items():
#
for g in v:
zz = get_hex_num_by_spiral(g, number)
i = zz[0]
j = zz[1]
lattice.universes[0][i][j] = assemblies[k]
return lattice
def hlat3(pincell1, pincell2, uo2, water, zr):
"""3D Hexagonal lattice for testing."""
# Create another universe for top layer
hydrogen = openmc.Material()
hydrogen.add_element('H', 1.0)
hydrogen.set_density('g/cm3', 0.09)
h_cell = openmc.Cell(fill=hydrogen)
u3 = openmc.Universe(cells=[h_cell])
all_zr = openmc.Cell(fill=zr)
pitch = 1.2
u1, u2 = pincell1, pincell2
lattice = openmc.HexLattice()
lattice.center = (0., 0., 0.)
lattice.pitch = (pitch, 10.0)
lattice.outer = openmc.Universe(cells=[all_zr])
lattice.universes = [[[u2, u1, u1, u1, u1, u1, u1, u1, u1, u1, u1, u1],
[u2, u1, u1, u1, u1, u1], [u2]],
[[u1, u1, u1, u1, u1, u1, u3, u1, u1, u1, u1, u1],
[u1, u1, u1, u3, u1, u1], [u3]]]
# Add extra attributes for comparison purpose
lattice.cells = [
u1.fuel, u1.moderator, u2.fuel, u2.moderator, h_cell, all_zr
]
lattice.mats = [uo2, water, zr, hydrogen]
lattice.univs = [u1, u2, u3, lattice.outer]
return lattice
def get_lattice(self):
upin = self.pincell.build()
ugtb = self.gtube.build()
hlat = openmc.HexLattice()
hlat.pitch = [self.pitch] * 2
unis = [[upin] * 78, [upin] * 72, [upin] * 66, [upin] * 60,
[upin] * 54, [upin] * 48, [upin] * 42, [upin] * 36,
[upin] * 30, [upin] * 24, [upin] * 18, [upin] * 12, [upin] * 6,
[ugtb]]
hlat.center = (0, -self.pitch * (len(unis) - 1), 0)
# Center row
unis[0][39] = ugtb
unis[4][27] = ugtb
unis[8][15] = ugtb
unis[9][0] = ugtb
unis[4][0] = ugtb
unis[0][0] = ugtb
# Next row
unis[0][35] = ugtb
unis[4][23] = ugtb
unis[9][4] = ugtb
unis[8][11] = ugtb
unis[4][4] = ugtb
# Another row
unis[0][31] = ugtb
unis[4][19] = ugtb
unis[5][13] = ugtb
# Corner
unis[0][26] = ugtb
hlat.universes = [unis]
hlat.outer = upin
print(hlat.show_indices(hlat.num_rings))
return hlat
def mixed_lattice_model(uo2, water):
cyl = openmc.ZCylinder(r=0.4)
c1 = openmc.Cell(fill=uo2, region=-cyl)
c1.temperature = 600.0
c2 = openmc.Cell(fill=water, region=+cyl)
pin = openmc.Universe(cells=[c1, c2])
empty = openmc.Cell()
empty_univ = openmc.Universe(cells=[empty])
hex_lattice = openmc.HexLattice()
hex_lattice.center = (0.0, 0.0)
hex_lattice.pitch = (1.2, 10.0)
outer_ring = [pin]*6
inner_ring = [empty_univ]
axial_level = [outer_ring, inner_ring]
hex_lattice.universes = [axial_level]*3
hex_lattice.outer = empty_univ
cell_hex = openmc.Cell(fill=hex_lattice)
u = openmc.Universe(cells=[cell_hex])
rotated_cell_hex = openmc.Cell(fill=u)
rotated_cell_hex.rotation = (0., 0., 30.)
ur = openmc.Universe(cells=[rotated_cell_hex])
d = 6.0
rect_lattice = openmc.RectLattice()
rect_lattice.lower_left = (-d, -d)
rect_lattice.pitch = (d, d)
rect_lattice.outer = empty_univ
rect_lattice.universes = [
[ur, empty_univ],
[empty_univ, u]
]
xmin = openmc.XPlane(-d, boundary_type='periodic')
xmax = openmc.XPlane(d, boundary_type='periodic')
xmin.periodic_surface = xmax
ymin = openmc.YPlane(-d, boundary_type='periodic')
ymax = openmc.YPlane(d, boundary_type='periodic')
main_cell = openmc.Cell(fill=rect_lattice,
region=+xmin & -xmax & +ymin & -ymax)
# Create geometry and use unique material in each fuel cell
geometry = openmc.Geometry([main_cell])
geometry.determine_paths()
c1.fill = [water.clone() for i in range(c1.num_instances)]
return openmc.model.Model(geometry)
def hlat2(pincell1, pincell2, uo2, water, zr):
"""2D Hexagonal lattice for testing."""
all_zr = openmc.Cell(fill=zr)
pitch = 1.2
u1, u2 = pincell1, pincell2
lattice = openmc.HexLattice()
lattice.center = (0., 0.)
lattice.pitch = (pitch, )
lattice.outer = openmc.Universe(cells=[all_zr])
lattice.universes = [[u2, u1, u1, u1, u1, u1, u1, u1, u1, u1, u1, u1],
[u2, u1, u1, u1, u1, u1], [u2]]
# Add extra attributes for comparison purpose
lattice.cells = [u1.fuel, u1.moderator, u2.fuel, u2.moderator, all_zr]
lattice.mats = [uo2, water, zr]
lattice.univs = [u1, u2, lattice.outer]
return lattice
def _build_inputs(self):
materials = openmc.Materials()
fuel_mat = openmc.Material()
fuel_mat.add_nuclide('U235', 4.9817E-03, 'ao')
materials.append(fuel_mat)
matrix = openmc.Material()
matrix.set_density('atom/b-cm', 1.7742E-02)
matrix.add_element('C', 1.0, 'ao')
matrix.add_s_alpha_beta('c_Graphite')
materials.append(matrix)
lead = openmc.Material(name="Lead")
lead.set_density('g/cm3', 10.32)
lead.add_nuclide('Pb204', 0.014, 'ao')
lead.add_nuclide('Pb206', 0.241, 'ao')
lead.add_nuclide('Pb207', 0.221, 'ao')
lead.add_nuclide('Pb208', 0.524, 'ao')
materials.append(lead)
coolant = openmc.Material()
coolant.set_density('atom/b-cm', 5.4464E-04)
coolant.add_nuclide('He4', 1.0, 'ao')
materials.append(coolant)
zirc = openmc.Material(name="Zirc4")
zirc.add_nuclide('Zr90', 2.217E-02, 'ao')
zirc.add_nuclide('Zr91', 4.781E-03, 'ao')
zirc.add_nuclide('Zr92', 7.228E-03, 'ao')
zirc.add_nuclide('Zr94', 7.169E-03, 'ao')
zirc.add_nuclide('Zr96', 1.131E-03, 'ao')
materials.append(zirc)
materials.export_to_xml()
### Geometry ###
pin_rad = 0.7 # cm
assembly_pitch = 1.4 # cm
cool_rad = 0.293 # cm
zirc_clad_thickness = 0.057 # cm
zirc_ir = cool_rad # cm
zirc_or = cool_rad + zirc_clad_thickness # cm
lead_thickness = 0.002 # cm
lead_ir = zirc_or # cm
lead_or = zirc_or + lead_thickness # cm
cyl = openmc.ZCylinder(x0=0., y0=0., r=pin_rad)
fuel_btm = openmc.ZPlane(z0=0.0, boundary_type='reflective')
fuel_top = openmc.ZPlane(z0=10.0, boundary_type='reflective')
region = -cyl & +fuel_btm & -fuel_top
container = openmc.Cell(region=region)
container.fill = fuel_mat
fuel_outside = openmc.Cell()
fuel_outside.region = +cyl
fuel_outside.fill = matrix
fuel_ch_univ = openmc.Universe(cells=[container, fuel_outside])
# Coolant Channel
cool_outer = openmc.ZCylinder(x0=0.0, y0=0.0, r=cool_rad)
zirc_outer = openmc.ZCylinder(x0=0.0, y0=0.0, r=zirc_or)
lead_outer = openmc.ZCylinder(x0=0.0, y0=0.0, r=lead_or)
coolant_ch = openmc.Cell(name="coolant")
coolant_ch.region = -cool_outer & +fuel_btm & -fuel_top
coolant_ch.fill = coolant
zirc_shell = openmc.Cell(name="zirconium_shell")
zirc_shell.region = +cool_outer & -zirc_outer & +fuel_btm & -fuel_top
zirc_shell.fill = zirc
lead_shell = openmc.Cell(name="lead_shell")
lead_shell.region = +zirc_outer & -lead_outer & +fuel_btm & -fuel_top
lead_shell.fill = lead
coolant_matrix = openmc.Cell(name="matrix coolant surround")
coolant_matrix.region = +lead_outer & +fuel_btm & -fuel_top
coolant_matrix.fill = matrix
coolant_channel = [coolant_ch, zirc_shell, lead_shell, coolant_matrix]
coolant_univ = openmc.Universe(name="coolant universe")
coolant_univ.add_cells(coolant_channel)
half_width = assembly_pitch # cm
edge_length = (2. / sqrt(3.0)) * half_width
inf_mat = openmc.Cell()
inf_mat.fill = matrix
inf_mat_univ = openmc.Universe(cells=[
inf_mat,
])
# a hex surface for the core to go inside of
hexprism = openmc.model.hexagonal_prism(edge_length=edge_length,
origin=(0.0, 0.0),
boundary_type='reflective',
orientation='x')
pincell_only_lattice = openmc.HexLattice(name="regular fuel assembly")
pincell_only_lattice.center = (0., 0.)
pincell_only_lattice.pitch = (assembly_pitch, )
pincell_only_lattice.outer = inf_mat_univ
# setup hex rings
ring0 = [fuel_ch_univ]
ring1 = [coolant_univ] * 6
pincell_only_lattice.universes = [ring1, ring0]
pincell_only_cell = openmc.Cell(name="container cell")
pincell_only_cell.region = hexprism & +fuel_btm & -fuel_top
pincell_only_cell.fill = pincell_only_lattice
root_univ = openmc.Universe(name="root universe",
cells=[
pincell_only_cell,
])
geom = openmc.Geometry(root_univ)
geom.export_to_xml()
### Settings ###
settings = openmc.Settings()
settings.run_mode = 'eigenvalue'
source = openmc.Source()
corner_dist = sqrt(2) * pin_rad
ll = [-corner_dist, -corner_dist, 0.0]
ur = [corner_dist, corner_dist, 10.0]
source.space = openmc.stats.Box(ll, ur)
source.strength = 1.0
settings.source = source
settings.output = {'summary': False}
settings.batches = 5
settings.inactive = 2
settings.particles = 1000
settings.seed = 22
settings.export_to_xml()
def from_hdf5(group, universes):
"""Create lattice from HDF5 group
Parameters
----------
group : h5py.Group
Group in HDF5 file
universes : dict
Dictionary mapping universe IDs to instances of
:class:`openmc.Universe`.
Returns
-------
openmc.Lattice
Instance of lattice subclass
"""
lattice_id = int(group.name.split('/')[-1].lstrip('lattice '))
name = group['name'].value.decode() if 'name' in group else ''
lattice_type = group['type'].value.decode()
if lattice_type == 'rectangular':
dimension = group['dimension'][...]
lower_left = group['lower_left'][...]
pitch = group['pitch'][...]
outer = group['outer'].value
universe_ids = group['universes'][...]
# Create the Lattice
lattice = openmc.RectLattice(lattice_id, name)
lattice.lower_left = lower_left
lattice.pitch = pitch
# If the Universe specified outer the Lattice is not void
if outer >= 0:
lattice.outer = universes[outer]
# Build array of Universe pointers for the Lattice
uarray = np.empty(universe_ids.shape, dtype=openmc.Universe)
for z in range(universe_ids.shape[0]):
for y in range(universe_ids.shape[1]):
for x in range(universe_ids.shape[2]):
uarray[z, y, x] = universes[universe_ids[z, y, x]]
# Use 2D NumPy array to store lattice universes for 2D lattices
if len(dimension) == 2:
uarray = np.squeeze(uarray)
uarray = np.atleast_2d(uarray)
# Set the universes for the lattice
lattice.universes = uarray
elif lattice_type == 'hexagonal':
n_rings = group['n_rings'].value
n_axial = group['n_axial'].value
center = group['center'][...]
pitch = group['pitch'][...]
outer = group['outer'].value
universe_ids = group['universes'][...]
# Create the Lattice
lattice = openmc.HexLattice(lattice_id, name)
lattice.center = center
lattice.pitch = pitch
# If the Universe specified outer the Lattice is not void
if outer >= 0:
lattice.outer = universes[outer]
# Build array of Universe pointers for the Lattice. Note that
# we need to convert between the HDF5's square array of
# (x, alpha, z) to the Python API's format of a ragged nested
# list of (z, ring, theta).
uarray = []
for z in range(n_axial):
# Add a list for this axial level.
uarray.append([])
x = n_rings - 1
a = 2 * n_rings - 2
for r in range(n_rings - 1, 0, -1):
# Add a list for this ring.
uarray[-1].append([])
# Climb down the top-right.
for i in range(r):
uarray[-1][-1].append(universe_ids[z, a, x])
x += 1
a -= 1
# Climb down the right.
for i in range(r):
uarray[-1][-1].append(universe_ids[z, a, x])
a -= 1
# Climb down the bottom-right.
for i in range(r):
uarray[-1][-1].append(universe_ids[z, a, x])
x -= 1
# Climb up the bottom-left.
for i in range(r):
uarray[-1][-1].append(universe_ids[z, a, x])
x -= 1
a += 1
# Climb up the left.
for i in range(r):
uarray[-1][-1].append(universe_ids[z, a, x])
a += 1
# Climb up the top-left.
for i in range(r):
uarray[-1][-1].append(universe_ids[z, a, x])
x += 1
# Move down to the next ring.
a -= 1
# Convert the ids into Universe objects.
uarray[-1][-1] = [
universes[u_id] for u_id in uarray[-1][-1]
]
# Handle the degenerate center ring separately.
u_id = universe_ids[z, a, x]
uarray[-1].append([universes[u_id]])
# Add the universes to the lattice.
if len(pitch) == 2:
# Lattice is 3D
lattice.universes = uarray
else:
# Lattice is 2D; extract the only axial level
lattice.universes = uarray[0]
return lattice
c3003 = openmc.Cell(fill=fuel, region=+zc301 & -zc300 & -zp200)
c3004 = openmc.Cell(fill=steel, region=+zc300 & -zp200)
c3005 = openmc.Cell(fill=fuel, region=+zc301 & +zp200 & -zp201)
c3006 = openmc.Cell(region=+zp201)
u3 = openmc.Universe(
universe_id=3,
cells=[c3000, c3001, c3001, c3002, c3003, c3004, c3005, c3006])
c4000 = openmc.Cell(region=+zp201)
c4001 = openmc.Cell(fill=fuel, region=+zp200 & -zp201) #fuel
c4002 = openmc.Cell(fill=steel, region=-zp200) #steel
u4 = openmc.Universe(cells=[c4000, c4001, c4002])
##建立六边形栅格
lattice = openmc.HexLattice(lattice_id=5)
lattice.center = (0, 0) #六边形以原点为中心
lattice.pitch = [10.6] #间隔10.6cm
outer_ring = [
u1, u2, u2, u2, u2
] * 6 #[u1,u2,u2,u2,u2, u1,u2,u2,u2,u2, u1,u2,u2,u2,u2, u1,u2,u2,u2,u2, u1,u2,u2,u2,u2, u1,u2,u2,u2,u2]
m5_ring = [
u2
] * 24 #[u2,u2,u2,u2, u2,u2,u2,u2, u2,u2,u2,u2, u2,u2,u2,u2, u2,u2,u2,u2, u2,u2,u2,u2]
m4_ring = [u3, u2, u2
] * 6 #[u3,u2,u2, u3,u2,u2, u3,u2,u2, u3,u2,u2, u3,u2,u2, u3,u2,u2]
m3_ring = [u2] * 12 #[u2,u2, u2,u2, u2,u2, u2,u2, u2,u2, u2,u2]
m2_ring = [u2] * 6 #[u2,u2,u2,u2,u2,u2]
inner_ring = [u3]
lattice.universes = [
outer_ring, m5_ring, m4_ring, m3_ring, m2_ring, inner_ring
def _build_inputs(self):
materials = openmc.Materials()
fuel_mat = openmc.Material(material_id=1, name="UO2")
fuel_mat.set_density('sum')
fuel_mat.add_nuclide('U235', 0.87370e-03)
fuel_mat.add_nuclide('U238', 1.87440e-02)
fuel_mat.add_nuclide('O16', 3.92350e-02)
materials.append(fuel_mat)
coolant = openmc.Material(material_id=2, name="borated H2O")
coolant.set_density('sum')
coolant.add_nuclide('H1', 0.06694)
coolant.add_nuclide('O16', 0.03347)
coolant.add_nuclide('B10', 6.6262e-6)
coolant.add_nuclide('B11', 2.6839e-5)
materials.append(coolant)
absorber = openmc.Material(material_id=3, name="pellet B4C")
absorber.set_density('sum')
absorber.add_nuclide('C0', 0.01966)
absorber.add_nuclide('B11', 4.7344e-6)
absorber.add_nuclide('B10', 1.9177e-5)
materials.append(absorber)
zirc = openmc.Material(material_id=4, name="Zirc4")
zirc.set_density('sum')
zirc.add_element('Zr', 4.23e-2)
materials.append(zirc)
materials.export_to_xml()
# Geometry #
pin_rad = 0.7 # cm
assembly_pitch = 1.235 # cm
hexagonal_pitch = 23.6 # cm
length = 10.0 # cm
# Fuel pin surfaces
cylfuelin = openmc.ZCylinder(surface_id=1, r=0.386)
cylfuelout = openmc.ZCylinder(surface_id=2, r=0.4582)
# Fuel cells
infcell = openmc.Cell(cell_id=1)
infcell.region = -cylfuelin
infcell.fill = fuel_mat
clfcell = openmc.Cell(cell_id=2)
clfcell.region = -cylfuelout & +cylfuelin
clfcell.fill = zirc
outfcell = openmc.Cell(cell_id=3)
outfcell.region = +cylfuelout
outfcell.fill = coolant
# Fuel universe
fuel_ch_univ = openmc.Universe(universe_id=1,
name="Fuel channel",
cells=[infcell, clfcell, outfcell])
# Central tube surfaces
cyltubein = openmc.ZCylinder(surface_id=3, r=0.45)
cyltubeout = openmc.ZCylinder(surface_id=4, r=0.5177)
# Central tube cells
inctcell = openmc.Cell(cell_id=4)
inctcell.region = -cyltubein
inctcell.fill = coolant
clctcell = openmc.Cell(cell_id=5)
clctcell.region = -cyltubeout & +cyltubein
clctcell.fill = zirc
outctcell = openmc.Cell(cell_id=6)
outctcell.region = +cyltubeout
outctcell.fill = coolant
# Central tubel universe
tube_ch_univ = openmc.Universe(universe_id=2,
name="Central tube channel",
cells=[inctcell, clctcell, outctcell])
# Absorber tube surfaces
cylabsin = openmc.ZCylinder(surface_id=5, r=0.35)
cylabsout = openmc.ZCylinder(surface_id=6, r=0.41)
cylabsclin = openmc.ZCylinder(surface_id=7, r=0.545)
cylabsclout = openmc.ZCylinder(surface_id=8, r=0.6323)
# Absorber tube cells
inabscell = openmc.Cell(cell_id=7)
inabscell.region = -cylabsin
inabscell.fill = absorber
clabscell = openmc.Cell(cell_id=8)
clabscell.region = -cylabsout & +cylabsin
clabscell.fill = zirc
interabscell = openmc.Cell(cell_id=9)
interabscell.region = -cylabsclin & +cylabsout
interabscell.fill = coolant
clatcell = openmc.Cell(cell_id=10)
clatcell.region = -cylabsclout & +cylabsclin
clatcell.fill = zirc
outabscell = openmc.Cell(cell_id=11)
outabscell.region = +cylabsclout
outabscell.fill = coolant
# Absorber tube universe
abs_ch_univ = openmc.Universe(
universe_id=3,
name="Central tube channel",
cells=[inabscell, clabscell, interabscell, clatcell, outabscell])
# Assembly surfaces
edge_length = (1. / np.sqrt(3.0)) * hexagonal_pitch
fuel_bottom = openmc.ZPlane(surface_id=9,
z0=0.0,
boundary_type='reflective')
fuel_top = openmc.ZPlane(surface_id=10,
z0=length,
boundary_type='reflective')
# a hex surface for the core to go inside of
hexprism = openmc.model.hexagonal_prism(edge_length=edge_length,
origin=(0.0, 0.0),
boundary_type='reflective',
orientation='x')
region = hexprism & +fuel_bottom & -fuel_top
inf_mat = openmc.Cell(cell_id=12)
inf_mat.fill = coolant
inf_mat_univ = openmc.Universe(universe_id=4, cells=[inf_mat])
# Fill lattice by channels
nring = 11
universes = []
for ring in range(nring - 1, -1, -1):
arr = []
arr.append(fuel_ch_univ)
for cell in range(ring * 6 - 1):
arr.append(fuel_ch_univ)
universes.append(arr)
universes[-1] = [tube_ch_univ]
channels = [(7, 2), (7, 5), (7, 8), (7, 11), (7, 14), (7, 17), (5, 0),
(4, 3), (5, 5), (4, 9), (5, 10), (4, 15), (5, 15), (4, 21),
(5, 20), (4, 27), (5, 25), (4, 33)]
for i, j in channels:
universes[i][j] = abs_ch_univ
lattice = openmc.HexLattice(name="regular fuel assembly")
lattice.orientation = "x"
lattice.center = (0., 0., length / 2.0)
lattice.pitch = (assembly_pitch, length / 2.0)
lattice.universes = 2 * [universes]
lattice.outer = inf_mat_univ
assembly_cell = openmc.Cell(cell_id=13, name="container assembly cell")
assembly_cell.region = region
assembly_cell.fill = lattice
root_univ = openmc.Universe(universe_id=5,
name="root universe",
cells=[assembly_cell])
geom = openmc.Geometry(root_univ)
geom.export_to_xml()
# Settings #
settings = openmc.Settings()
settings.run_mode = 'eigenvalue'
source = openmc.Source()
ll = [-edge_length, -edge_length, 0.0]
ur = [edge_length, edge_length, 10.0]
source.space = openmc.stats.Box(ll, ur)
source.strength = 1.0
settings.source = source
settings.batches = 10
settings.inactive = 5
settings.particles = 1000
settings.seed = 22
settings.export_to_xml()
breedgap.fill = He
breedgap.region = gap_region
breedclad = openmc.Cell(14, 'breedclad')
breedclad.fill = stainless
breedclad.region = clad_region
#assembly
#assemebly cell
f = openmc.Universe(name='Fuel Pin', cells=[fuel, gap, clad, gas, coolant])
all_coolant = openmc.Universe(cells=[coolant2])
s = openmc.Universe(cells=[steel])
c = openmc.Universe(name='control rod', cells=[control, controlvoid])
#lattice
assembly = openmc.HexLattice()
assembly.center = (0, 0)
assembly.pitch = [1.36]
assembly.outer = all_coolant
assembly.universes = [[f] * 48, [f] * 42, [f] * 36, [f] * 30, [f] * 24,
[f] * 18, [s] * 12, [c] * 6, [c]]
# Create boundary planes to surround the geometry
asseouter_sphere = openmc.Sphere(R=300, boundary_type='vacuum')
asseouter_surface = openmc.ZCylinder(R=100, boundary_type='vacuum')
min_z = openmc.ZPlane(z0=-1.4, boundary_type='vacuum')
max_z = openmc.ZPlane(z0=+208.6, boundary_type='vacuum')
max_z2 = openmc.ZPlane(z0=+165.4, boundary_type='vacuum')
min_z2 = openmc.ZPlane(z0=-0.5, boundary_type='vacuum')
# cell for assembly
def rotated_lattice_model():
model = openmc.model.Model()
# Create some materials
fuel1 = openmc.Material()
fuel1.set_density('g/cm3', 10.0)
fuel1.add_nuclide('U235', 1.0)
fuel2 = openmc.Material()
fuel2.set_density('g/cm3', 10.0)
fuel2.add_nuclide('U238', 1.0)
water = openmc.Material()
water.set_density('g/cm3', 1.0)
water.add_nuclide('H1', 2.0)
water.add_nuclide('O16', 1.0)
water.add_s_alpha_beta('c_H_in_H2O')
model.materials.extend([fuel1, fuel2, water])
# Create universes for lattices
r_pin = openmc.ZCylinder(r=0.25)
fuel_cell = openmc.Cell(fill=fuel1, region=-r_pin)
water_cell = openmc.Cell(fill=water, region=+r_pin)
pin_universe = openmc.Universe(cells=(fuel_cell, water_cell))
r_big_pin = openmc.ZCylinder(r=0.5)
fuel2_cell = openmc.Cell(fill=fuel2, region=-r_big_pin)
water2_cell = openmc.Cell(fill=water, region=+r_big_pin)
big_pin_universe = openmc.Universe(cells=(fuel2_cell, water2_cell))
all_water_cell = openmc.Cell(fill=water)
outer_universe = openmc.Universe(30, cells=(all_water_cell,))
# Create hexagonal lattice
pitch = 1.25
hexlat = openmc.HexLattice()
hexlat.center = (0., 0.)
hexlat.pitch = [pitch]
hexlat.outer = outer_universe
outer_ring = [big_pin_universe] + [pin_universe]*11
middle_ring = [big_pin_universe] + [pin_universe]*5
inner_ring = [big_pin_universe]
hexlat.universes = [outer_ring, middle_ring, inner_ring]
# Create rectangular lattice
rectlat = openmc.RectLattice()
rectlat.center = (0., 0.)
rectlat.pitch = (pitch, pitch)
rectlat.lower_left = (-2*pitch, -2*pitch)
rectlat.outer = outer_universe
rectlat.universes = np.full((4, 4), pin_universe)
rectlat.universes[0] = big_pin_universe
# Create cell filled with translated/rotated rectangular lattice on left
left_cyl = openmc.ZCylinder(x0=-4.0, r=4.0)
left_cell = openmc.Cell(fill=rectlat, region=-left_cyl)
left_cell.translation = (-4.0, 0.0, 0.0)
left_cell.rotation = (0.0, 0.0, 45.0)
# Create cell filled with translated/rotated hexagonal lattice on right
right_cyl = openmc.ZCylinder(x0=4.0, r=4.0)
right_cell = openmc.Cell(fill=hexlat, region=-right_cyl)
right_cell.translation = (4.0, 0.0, 0.0)
right_cell.rotation = (0.0, 0.0, 30.0)
# Finish up with the geometry
outer_cyl = openmc.ZCylinder(r=8.0, boundary_type='vacuum')
main_cell = openmc.Cell(fill=water, region=-outer_cyl & +left_cyl & +right_cyl)
model.geometry = openmc.Geometry([main_cell, left_cell, right_cell])
model.settings.batches = 5
model.settings.inactive = 0
model.settings.particles = 1000
model.settings.source = openmc.Source(space=openmc.stats.Point())
model.settings.export_to_xml()
return model
def _read_lattices(self):
self.n_lattices = self._f['geometry/n_lattices'].value
# Initialize lattices for each Lattice
# Keys - Lattice keys
# Values - Lattice objects
self.lattices = {}
for key in self._f['geometry/lattices'].keys():
if key == 'n_lattices':
continue
lattice_id = int(key.lstrip('lattice '))
index = self._f['geometry/lattices'][key]['index'].value
name = self._f['geometry/lattices'][key]['name'].value.decode()
lattice_type = self._f['geometry/lattices'][key][
'type'].value.decode()
if 'offsets' in self._f['geometry/lattices'][key]:
offsets = self._f['geometry/lattices'][key]['offsets'][...]
else:
offsets = None
if lattice_type == 'rectangular':
dimension = self._f['geometry/lattices'][key]['dimension'][...]
lower_left = \
self._f['geometry/lattices'][key]['lower_left'][...]
pitch = self._f['geometry/lattices'][key]['pitch'][...]
outer = self._f['geometry/lattices'][key]['outer'].value
universe_ids = \
self._f['geometry/lattices'][key]['universes'][...]
universe_ids = np.swapaxes(universe_ids, 0, 1)
universe_ids = np.swapaxes(universe_ids, 1, 2)
# Create the Lattice
lattice = openmc.RectLattice(lattice_id=lattice_id, name=name)
lattice.dimension = tuple(dimension)
lattice.lower_left = lower_left
lattice.pitch = pitch
# If the Universe specified outer the Lattice is not void (-22)
if outer != -22:
lattice.outer = self.universes[outer]
# Build array of Universe pointers for the Lattice
universes = \
np.ndarray(tuple(universe_ids.shape), dtype=openmc.Universe)
for x in range(universe_ids.shape[0]):
for y in range(universe_ids.shape[1]):
for z in range(universe_ids.shape[2]):
universes[x, y, z] = \
self.get_universe_by_id(universe_ids[x, y, z])
# Transpose, reverse y-dimension for appropriate ordering
shape = universes.shape
universes = np.transpose(universes, (1, 0, 2))
universes.shape = shape
universes = universes[:, ::-1, :]
lattice.universes = universes
if offsets is not None:
offsets = np.swapaxes(offsets, 0, 1)
offsets = np.swapaxes(offsets, 1, 2)
lattice.offsets = offsets
# Add the Lattice to the global dictionary of all Lattices
self.lattices[index] = lattice
if lattice_type == 'hexagonal':
n_rings = self._f['geometry/lattices'][key]['n_rings'][0]
n_axial = self._f['geometry/lattices'][key]['n_axial'][0]
center = self._f['geometry/lattices'][key]['center'][...]
pitch = self._f['geometry/lattices'][key]['pitch'][...]
outer = self._f['geometry/lattices'][key]['outer'][0]
universe_ids = self._f['geometry/lattices'][key]['universes'][
...]
# Create the Lattice
lattice = openmc.HexLattice(lattice_id=lattice_id, name=name)
lattice.num_rings = n_rings
lattice.num_axial = n_axial
lattice.center = center
lattice.pitch = pitch
# If the Universe specified outer the Lattice is not void (-22)
if outer != -22:
lattice.outer = self.universes[outer]
# Build array of Universe pointers for the Lattice. Note that
# we need to convert between the HDF5's square array of
# (x, alpha, z) to the Python API's format of a ragged nested
# list of (z, ring, theta).
universes = []
for z in range(lattice.num_axial):
# Add a list for this axial level.
universes.append([])
x = lattice.num_rings - 1
a = 2 * lattice.num_rings - 2
for r in range(lattice.num_rings - 1, 0, -1):
# Add a list for this ring.
universes[-1].append([])
# Climb down the top-right.
for i in range(r):
universes[-1][-1].append(universe_ids[z, a, x])
x += 1
a -= 1
# Climb down the right.
for i in range(r):
universes[-1][-1].append(universe_ids[z, a, x])
a -= 1
# Climb down the bottom-right.
for i in range(r):
universes[-1][-1].append(universe_ids[z, a, x])
x -= 1
# Climb up the bottom-left.
for i in range(r):
universes[-1][-1].append(universe_ids[z, a, x])
x -= 1
a += 1
# Climb up the left.
for i in range(r):
universes[-1][-1].append(universe_ids[z, a, x])
a += 1
# Climb up the top-left.
for i in range(r):
universes[-1][-1].append(universe_ids[z, a, x])
x += 1
# Move down to the next ring.
a -= 1
# Convert the ids into Universe objects.
universes[-1][-1] = [
self.get_universe_by_id(u_id)
for u_id in universes[-1][-1]
]
# Handle the degenerate center ring separately.
u_id = universe_ids[z, a, x]
universes[-1].append([self.get_universe_by_id(u_id)])
# Add the universes to the lattice.
if len(pitch) == 2:
# Lattice is 3D
lattice.universes = universes
else:
# Lattice is 2D; extract the only axial level
lattice.universes = universes[0]
if offsets is not None:
lattice.offsets = offsets
# Add the Lattice to the global dictionary of all Lattices
self.lattices[index] = lattice
sodium.add_element('Na', 2.2272e-02)
materials = openmc.Materials([fuel, ht9, sodium])
materials.export_to_xml()
################################################################################
# GEOMETRY
fuel_outer = openmc.ZCylinder(r=fuel_radius)
clad_outer = openmc.ZCylinder(r=clad_outer_radius)
pin_universe = openmc.model.pin([fuel_outer, clad_outer], [fuel, ht9, sodium])
na_cell = openmc.Cell(fill=sodium)
na_universe = openmc.Universe(cells=(na_cell, ))
lattice = openmc.HexLattice()
lattice.center = (0., 0.)
lattice.pitch = (pin_pitch, )
lattice.orientation = 'x'
lattice.universes = [[pin_universe]]
lattice.universes = [[pin_universe for _ in range(max(1, 6 * ring_index))]
for ring_index in reversed(range(10))]
lattice.outer = na_universe
outer_hex = openmc.model.hexagonal_prism(subassembly_pitch / sqrt(3.),
orientation='x',
boundary_type='periodic')
duct_outer_hex = openmc.model.hexagonal_prism(subassembly_duct_outer /
sqrt(3.),
orientation='x')
duct_inner_hex = openmc.model.hexagonal_prism(subassembly_duct_inner /