def _create_geometry(self):
"""Instantiate materials and a pin cell Geometry."""
self.input_set.create_materials()
zcylinder = openmoc.ZCylinder(x=0.0, y=0.0, radius=1.0, name='pin')
xmin = openmoc.XPlane(x=-2.0, name='xmin')
xmax = openmoc.XPlane(x=+2.0, name='xmax')
ymin = openmoc.YPlane(y=-2.0, name='ymin')
ymax = openmoc.YPlane(y=+2.0, name='ymax')
xmin.setBoundaryType(openmoc.VACUUM)
xmax.setBoundaryType(openmoc.VACUUM)
ymin.setBoundaryType(openmoc.VACUUM)
ymax.setBoundaryType(openmoc.VACUUM)
fuel = openmoc.Cell(name='fuel')
fuel.setFill(self.input_set.materials['UO2'])
fuel.addSurface(halfspace=-1, surface=zcylinder)
moderator = openmoc.Cell(name='moderator')
moderator.setFill(self.input_set.materials['Water'])
moderator.addSurface(halfspace=+1, surface=zcylinder)
moderator.addSurface(halfspace=+1, surface=xmin)
moderator.addSurface(halfspace=-1, surface=xmax)
moderator.addSurface(halfspace=+1, surface=ymin)
moderator.addSurface(halfspace=-1, surface=ymax)
root_universe = openmoc.Universe(name='root universe')
root_universe.addCell(fuel)
root_universe.addCell(moderator)
self.input_set.geometry = openmoc.Geometry()
self.input_set.geometry.setRootUniverse(root_universe)
def _create_geometry(self):
"""Inspired from SimpleLattice"""
self.materials = \
openmoc.materialize.load_from_hdf5(filename='c5g7-mgxs.h5',
directory='../../sample-input/')
xmin = openmoc.XPlane(x=-2.0, name='xmin')
xmax = openmoc.XPlane(x=+2.0, name='xmax')
ymin = openmoc.YPlane(y=-2.0, name='ymin')
ymax = openmoc.YPlane(y=+2.0, name='ymax')
boundaries = [xmin, xmax, ymin, ymax]
if (self.dimensions == 3):
zmin = openmoc.ZPlane(z=-5.0, name='zmin')
zmax = openmoc.ZPlane(z=+5.0, name='zmax')
boundaries = [xmin, xmax, ymin, ymax, zmin, zmax]
large_zcylinder = openmoc.ZCylinder(x=0.0, y=0.0,
radius=0.4, name='large pin')
medium_zcylinder = openmoc.ZCylinder(x=0.0, y=0.0,
radius=0.3, name='medium pin')
small_zcylinder = openmoc.ZCylinder(x=0.0, y=0.0,
radius=0.2, name='small pin')
xplane = openmoc.XPlane(x=0, name='mid-cell')
yplane = openmoc.YPlane(y=0, name='mid-cell')
for boundary in boundaries: boundary.setBoundaryType(openmoc.REFLECTIVE)
if (self.dimensions == 3):
boundaries[-1].setBoundaryType(openmoc.VACUUM)
large_fuel = openmoc.Cell(name='large pin fuel')
large_fuel.setNumRings(3)
large_fuel.setNumSectors(8)
large_fuel.setFill(self.materials['UO2'])
large_fuel.addSurface(halfspace=-1, surface=large_zcylinder)
large_moderator = openmoc.Cell(name='large pin moderator')
large_moderator.setNumSectors(8)
large_moderator.setFill(self.materials['Water'])
large_moderator.addSurface(halfspace=+1, surface=large_zcylinder)
medium_fuel = openmoc.Cell(name='medium pin fuel')
medium_fuel.setNumRings(3)
medium_fuel.setNumSectors(8)
medium_fuel.setFill(self.materials['UO2'])
medium_fuel.addSurface(halfspace=-1, surface=medium_zcylinder)
medium_moderator = openmoc.Cell(name='medium pin moderator')
medium_moderator.setNumSectors(8)
medium_moderator.setFill(self.materials['Water'])
medium_moderator.addSurface(halfspace=+1, surface=medium_zcylinder)
small_fuel = openmoc.Cell(name='small pin fuel')
small_fuel.setNumRings(3) # test may fail if fsrs are initialized
small_fuel.setNumSectors(8)
small_fuel.setFill(self.materials['UO2'])
small_fuel.addSurface(halfspace=-1, surface=small_zcylinder)
small_clad_q1 = openmoc.Cell(name='small pin cladding quarter')
small_clad_q1.setFill(self.materials['Clad'])
small_clad_q1.addSurface(halfspace=+1, surface=small_zcylinder)
small_clad_q1.addSurface(halfspace=-1, surface=medium_zcylinder)
small_clad_q1.addSurface(halfspace=+1, surface=xplane)
small_clad_q1.addSurface(halfspace=-1, surface=yplane)
small_moderator = openmoc.Cell(name='small pin moderator')
small_moderator.setNumSectors(8)
small_moderator.setFill(self.materials['Water'])
small_moderator.addSurface(halfspace=+1, surface=medium_zcylinder)
lattice_cell = openmoc.Cell(name='lattice cell')
root_cell = openmoc.Cell(name='root cell')
root_cell.addSurface(halfspace=+1, surface=boundaries[0])
root_cell.addSurface(halfspace=-1, surface=boundaries[1])
root_cell.addSurface(halfspace=+1, surface=boundaries[2])
root_cell.addSurface(halfspace=-1, surface=boundaries[3])
if (self.dimensions == 3):
root_cell.addSurface(halfspace=+1, surface=boundaries[4])
root_cell.addSurface(halfspace=-1, surface=boundaries[5])
pin1 = openmoc.Universe(name='large pin cell')
pin2 = openmoc.Universe(name='medium pin cell')
pin3 = openmoc.Universe(name='small pin cell')
assembly = openmoc.Universe(name='2x2 lattice')
root_universe = openmoc.Universe(name='root universe')
pin1.addCell(large_fuel)
pin1.addCell(large_moderator)
pin2.addCell(medium_fuel)
pin2.addCell(medium_moderator)
pin3.addCell(small_fuel)
pin3.addCell(small_clad_q1)
pin3.addCell(small_moderator)
assembly.addCell(lattice_cell)
root_universe.addCell(root_cell)
# 2x2 assembly
lattice = openmoc.Lattice(name='2x2 lattice')
lattice.setWidth(width_x=1.0, width_y=1.0)
lattice.setUniverses([[[pin1, pin2], [pin1, pin3]]])
lattice_cell.setFill(lattice)
# Rotate a lattice to test rotation of a fill cell
assembly_c = openmoc.Cell(name='rotated cell containing a lattice')
assembly_c.setFill(assembly)
assembly_c.setRotation((0,0,90), 'degrees')
assembly_r = openmoc.Universe(name='rotated lattice')
assembly_r.addCell(assembly_c)
# Translate a lattice to test translation of a fill cell
assembly_c = openmoc.Cell(name='rotated cell containing a lattice')
assembly_c.setFill(assembly)
assembly_c.setTranslation((0.05,0,0))
assembly_t = openmoc.Universe(name='translated lattice')
assembly_t.addCell(assembly_c)
# Rotate a lattice to test rotation of a fill cell
assembly_c = openmoc.Cell(name='translated cell containing a lattice')
assembly_c.setFill(assembly)
assembly_c.setRotation((0,0,-90), 'degrees')
assembly_c.setTranslation((-0.05,0,0))
assembly_rt = openmoc.Universe(name='translate and rotated lattice')
assembly_rt.addCell(assembly_c)
# 2x2 core
core = openmoc.Lattice(name='2x2 core')
core.setWidth(width_x=2.0, width_y=2.0)
core.setUniverses([[[assembly, assembly_rt], [assembly_t, assembly_r]]])
root_cell.setFill(core)
self.geometry = openmoc.Geometry()
self.geometry.setRootUniverse(root_universe)
###############################################################################
# Creating Surfaces
###############################################################################
openmoc.log.py_printf('NORMAL', 'Creating surfaces...')
left = openmoc.XPlane(x=-34.0, name='left')
right = openmoc.XPlane(x=34.0, name='right')
top = openmoc.YPlane(y=-34.0, name='top')
bottom = openmoc.YPlane(y=34.0, name='bottom')
boundaries = [left, right, top, bottom]
for boundary in boundaries: boundary.setBoundaryType(openmoc.REFLECTIVE)
zcylinders = list()
radii = [0.15, 0.2, 0.25, 0.3, 0.35, 0.4]
for r in radii: zcylinders.append(openmoc.ZCylinder(x=0.0, y=0.0, radius=r))
###############################################################################
# Creating Cells
###############################################################################
openmoc.log.py_printf('NORMAL', 'Creating cells...')
# Create a list of 12 Cell instances
cells = [openmoc.Cell() for i in range(12)]
# Append 3 CellFills for the assemblies and full core
assembly1 = openmoc.Cell(name='assembly 1')
assembly2 = openmoc.Cell(name='assembly 2')
root_cell = openmoc.Cell(name='full core')
def create_geometry(self):
"""Instantiate a 17x17 pin cell lattice Geometry."""
# Create ZCylinder for the fuel and moderator
fuel_radius = openmoc.ZCylinder(x=0.0, y=0.0, radius=0.54)
# Create planes to bound the entire geometry
xmin = openmoc.XPlane(x=-10.71, name='xmin')
xmax = openmoc.XPlane(x=+10.71, name='xmax')
ymin = openmoc.YPlane(y=-10.71, name='ymin')
ymax = openmoc.YPlane(y=+10.71, name='xmax')
xmin.setBoundaryType(openmoc.REFLECTIVE)
xmax.setBoundaryType(openmoc.REFLECTIVE)
ymin.setBoundaryType(openmoc.REFLECTIVE)
ymax.setBoundaryType(openmoc.REFLECTIVE)
# 4.3% MOX pin cell
mox43_cell = openmoc.Cell()
mox43_cell.setFill(self.materials['MOX-4.3%'])
mox43_cell.setNumRings(3)
mox43_cell.setNumSectors(8)
mox43_cell.addSurface(-1, fuel_radius)
mox43 = openmoc.Universe(name='MOX-4.3%')
mox43.addCell(mox43_cell)
# 7% MOX pin cell
mox7_cell = openmoc.Cell()
mox7_cell.setFill(self.materials['MOX-7%'])
mox7_cell.setNumRings(3)
mox7_cell.setNumSectors(8)
mox7_cell.addSurface(-1, fuel_radius)
mox7 = openmoc.Universe(name='MOX-7%')
mox7.addCell(mox7_cell)
# 8.7% MOX pin cell
mox87_cell = openmoc.Cell()
mox87_cell.setFill(self.materials['MOX-8.7%'])
mox87_cell.setNumRings(3)
mox87_cell.setNumSectors(8)
mox87_cell.addSurface(-1, fuel_radius)
mox87 = openmoc.Universe(name='MOX-8.7%')
mox87.addCell(mox87_cell)
# Fission chamber pin cell
fission_chamber_cell = openmoc.Cell()
fission_chamber_cell.setFill(self.materials['Fission Chamber'])
fission_chamber_cell.setNumRings(3)
fission_chamber_cell.setNumSectors(8)
fission_chamber_cell.addSurface(-1, fuel_radius)
fission_chamber = openmoc.Universe(name='Fission Chamber')
fission_chamber.addCell(fission_chamber_cell)
# Guide tube pin cell
guide_tube_cell = openmoc.Cell()
guide_tube_cell.setFill(self.materials['Guide Tube'])
guide_tube_cell.setNumRings(3)
guide_tube_cell.setNumSectors(8)
guide_tube_cell.addSurface(-1, fuel_radius)
guide_tube = openmoc.Universe(name='Guide Tube')
guide_tube.addCell(guide_tube_cell)
# Moderator cell
moderator = openmoc.Cell()
moderator.setFill(self.materials['Water'])
moderator.addSurface(+1, fuel_radius)
moderator.setNumRings(3)
moderator.setNumSectors(8)
# Add moderator to each pin cell
pins = [mox43, mox7, mox87, fission_chamber, guide_tube]
for pin in pins:
pin.addCell(moderator)
# CellFills for the assembly
assembly1_cell = openmoc.Cell(name='Assembly 1')
assembly1 = openmoc.Universe(name='Assembly 1')
assembly1.addCell(assembly1_cell)
# A mixed enrichment PWR MOX fuel assembly
assembly = openmoc.Lattice(name='MOX Assembly')
assembly.setWidth(width_x=1.26, width_y=1.26)
# Create a template to map to pin cell types
template = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1],
[1, 2, 2, 2, 2, 4, 2, 2, 4, 2, 2, 4, 2, 2, 2, 2, 1],
[1, 2, 2, 4, 2, 3, 3, 3, 3, 3, 3, 3, 2, 4, 2, 2, 1],
[1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 1],
[1, 2, 4, 3, 3, 4, 3, 3, 4, 3, 3, 4, 3, 3, 4, 2, 1],
[1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 1],
[1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 1],
[1, 2, 4, 3, 3, 4, 3, 3, 5, 3, 3, 4, 3, 3, 4, 2, 1],
[1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 1],
[1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 1],
[1, 2, 4, 3, 3, 4, 3, 3, 4, 3, 3, 4, 3, 3, 4, 2, 1],
[1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 1],
[1, 2, 2, 4, 2, 3, 3, 3, 3, 3, 3, 3, 2, 4, 2, 2, 1],
[1, 2, 2, 2, 2, 4, 2, 2, 4, 2, 2, 4, 2, 2, 2, 2, 1],
[1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
universes = {1 : mox43, 2 : mox7, 3 : mox87,
4 : guide_tube, 5 : fission_chamber}
for i in range(17):
for j in range(17):
template[i][j] = universes[template[i][j]]
assembly.setUniverses([template])
# Root Cell/Universe
root_cell = openmoc.Cell(name='Full Geometry')
root_cell.setFill(assembly)
root_cell.addSurface(+1, xmin)
root_cell.addSurface(-1, xmax)
root_cell.addSurface(+1, ymin)
root_cell.addSurface(-1, ymax)
root_universe = openmoc.Universe(name='Root Universe')
root_universe.addCell(root_cell)
self.geometry = openmoc.Geometry()
self.geometry.setRootUniverse(root_universe)
super(PwrAssemblyInput, self).create_geometry()
def _run_openmoc(self):
"""Instantiate a complex region Geometry."""
root_universe = openmoc.Universe(name='root universe')
root_cell = openmoc.Cell(name='root cell')
root_universe.addCell(root_cell)
u1 = openmoc.Universe(name='universe 1')
u2 = openmoc.Universe(name='universe 2 in c2')
root_cell.setFill(u1)
# Z-bounds at root level
p1 = openmoc.ZPlane(z=-2.0, name='zmin')
p1.setBoundaryType(openmoc.REFLECTIVE)
p2 = openmoc.ZPlane(z=+2.0, name='zmax')
p2.setBoundaryType(openmoc.INTERFACE)
root_cell.addSurface(halfspace=+1, surface=p1)
root_cell.addSurface(halfspace=-1, surface=p2)
# Cells in the root cell
c1 = openmoc.Cell(name='intersection cell')
c2 = openmoc.Cell(name='union cell')
c2a = openmoc.Cell(name='union cell 2')
c3 = openmoc.Cell(name='unbound cell')
u1.addCell(c1)
u1.addCell(c2)
u1.addCell(c3)
# Setting the parent cell helps to find boundaries (in Z here)
c3.setParent(root_cell)
# Cell c2a in c2, to further test arborescence
c2.setFill(u2)
u2.addCell(c2a)
c2.setParent(root_cell)
c2a.setParent(c2) # to test transitivity
# Bounds for cell 1 : intersection region cell
p11 = openmoc.XPlane(x=-2.0, name='xmin')
p11.setBoundaryType(openmoc.REFLECTIVE)
p12 = openmoc.YPlane(y=-2.0, name='ymin')
p12.setBoundaryType(openmoc.VACUUM)
p13 = openmoc.ZCylinder(x=0, y=0, radius=2.5, name='cylinder')
p13.setBoundaryType(openmoc.INTERFACE)
# addSurface assumes an intersection, which is what we want here
c1.addSurface(halfspace=+1, surface=p11)
c1.addSurface(halfspace=+1, surface=p12)
c1.addSurface(halfspace=-1, surface=p13)
# Bounds for cell 2 : union region cell
p22 = openmoc.ZCylinder(x=4, y=4, radius=2.5, name='cylinder')
p22.setBoundaryType(openmoc.INTERFACE)
p23 = openmoc.ZCylinder(x=-2, y=-8, radius=3, name='cylinder')
p23.setBoundaryType(openmoc.VACUUM)
# To have a union, we need to use addLogicalNode and addSurfaceInRegion
c2.addLogicalNode(1)
c2.addSurfaceInRegion(halfspace=-1, surface=p22)
c2.addSurfaceInRegion(halfspace=-1, surface=p23)
# Plane limits area even more
c2a.addLogicalNode(1)
c2a.addSurfaceInRegion(halfspace=+1, surface=p11)
# Add a material to a cell to know the number of groups
c1.setFill(self.materials['UO2'])
self.geometry = openmoc.Geometry()
self.geometry.setRootUniverse(root_universe)
# Dump geometry
self.geometry.dumpToFile("geometry_file.geo")
# Get rid of the geometry
self.geometry = None
# Reload the geometry
self.geometry = openmoc.Geometry()
self.geometry.loadFromFile("geometry_file.geo")
# Dump geometry again
self.geometry.dumpToFile("geometry_file_second.geo")
def get_openmoc_surface(openmc_surface):
"""Return an OpenMOC surface corresponding to an OpenMC surface.
Parameters
----------
openmc_surface : openmc.Surface
OpenMC surface
Returns
-------
openmoc_surface : openmoc.Surface
Equivalent OpenMOC surface
"""
cv.check_type('openmc_surface', openmc_surface, openmc.Surface)
surface_id = openmc_surface.id
# If this Material was already created, use it
if surface_id in OPENMOC_SURFACES:
return OPENMOC_SURFACES[surface_id]
# Create an OpenMOC Surface to represent this OpenMC Surface
name = openmc_surface.name
# Determine the type of boundary conditions applied to the Surface
if openmc_surface.boundary_type == 'vacuum':
boundary = openmoc.VACUUM
elif openmc_surface.boundary_type == 'reflective':
boundary = openmoc.REFLECTIVE
elif openmc_surface.boundary_type == 'periodic':
boundary = openmoc.PERIODIC
else:
boundary = openmoc.BOUNDARY_NONE
if openmc_surface.type == 'plane':
A = openmc_surface.a
B = openmc_surface.b
C = openmc_surface.c
D = openmc_surface.d
# OpenMOC uses the opposite sign on D
openmoc_surface = openmoc.Plane(A, B, C, -D, surface_id, name)
elif openmc_surface.type == 'x-plane':
x0 = openmc_surface.x0
openmoc_surface = openmoc.XPlane(x0, surface_id, name)
elif openmc_surface.type == 'y-plane':
y0 = openmc_surface.y0
openmoc_surface = openmoc.YPlane(y0, surface_id, name)
elif openmc_surface.type == 'z-plane':
z0 = openmc_surface.z0
openmoc_surface = openmoc.ZPlane(z0, surface_id, name)
elif openmc_surface.type == 'z-cylinder':
x0 = openmc_surface.x0
y0 = openmc_surface.y0
R = openmc_surface.r
openmoc_surface = openmoc.ZCylinder(x0, y0, R, surface_id, name)
else:
msg = 'Unable to create an OpenMOC Surface from an OpenMC ' \
'Surface of type "{}" since it is not a compatible ' \
'Surface type in OpenMOC'.format(type(openmc_surface))
raise ValueError(msg)
# Set the boundary condition for this Surface
openmoc_surface.setBoundaryType(boundary)
# Add the OpenMC Surface to the global collection of all OpenMC Surfaces
OPENMC_SURFACES[surface_id] = openmc_surface
# Add the OpenMOC Surface to the global collection of all OpenMOC Surfaces
OPENMOC_SURFACES[surface_id] = openmoc_surface
return openmoc_surface
def create_geometry(self):
"""Instantiate a 4x4 non-uniform simple lattice Geometry."""
fuel_rings = 1
moderator_rings = 1
num_sectors = 8
openmoc.set_line_length(120)
r_fuel = 0.54
r_clad = 0.57
r_large = 0.60
pin_pitch = 1.26
gap_size = 0.05
surfaces = {}
surfaces['Pin Cell ZCylinder'] = openmoc.ZCylinder(
x=0, y=0, radius=r_fuel, name='Pin Cell ZCylinder')
surfaces['Clad Cell ZCylinder'] = openmoc.ZCylinder(
x=0, y=0, radius=r_clad, name='Clad Cell ZCylinder')
surfaces['large'] = openmoc.ZCylinder(x=0,
y=0,
radius=r_large,
name='large')
surfaces['z-inf'] = openmoc.ZPlane(z=-1.0E10)
surfaces['z+inf'] = openmoc.ZPlane(z=1.0E10)
cells = {}
cells['fuel'] = openmoc.Cell()
cells['clad'] = openmoc.Cell()
cells['mod'] = openmoc.Cell()
cells['uniform gap'] = openmoc.Cell()
cells['large_fuel'] = openmoc.Cell()
cells['large_mod'] = openmoc.Cell()
cells['fuel'].addSurface(halfspace=-1,
surface=surfaces['Pin Cell ZCylinder'])
cells['fuel'].addSurface(halfspace=+1, surface=surfaces['z-inf'])
cells['fuel'].addSurface(halfspace=-1, surface=surfaces['z+inf'])
cells['fuel'].setFill(self.materials['UO2'])
cells['fuel'].setNumSectors(num_sectors)
cells['fuel'].setNumRings(fuel_rings)
cells['clad'].addSurface(halfspace=+1,
surface=surfaces['Pin Cell ZCylinder'])
cells['clad'].addSurface(halfspace=-1,
surface=surfaces['Clad Cell ZCylinder'])
cells['clad'].addSurface(halfspace=+1, surface=surfaces['z-inf'])
cells['clad'].addSurface(halfspace=-1, surface=surfaces['z+inf'])
cells['clad'].setFill(self.materials['Clad'])
cells['clad'].setNumSectors(num_sectors)
cells['mod'].addSurface(halfspace=+1,
surface=surfaces['Clad Cell ZCylinder'])
cells['mod'].addSurface(halfspace=+1, surface=surfaces['z-inf'])
cells['mod'].addSurface(halfspace=-1, surface=surfaces['z+inf'])
cells['mod'].setFill(self.materials['Water'])
cells['mod'].setNumSectors(num_sectors)
cells['mod'].setNumRings(moderator_rings)
cells['uniform gap'].addSurface(halfspace=+1,
surface=surfaces['z-inf'])
cells['uniform gap'].addSurface(halfspace=-1,
surface=surfaces['z+inf'])
cells['uniform gap'].setFill(self.materials['Clad'])
cells['large_fuel'].addSurface(halfspace=-1, surface=surfaces['large'])
cells['large_fuel'].addSurface(halfspace=+1, surface=surfaces['z-inf'])
cells['large_fuel'].addSurface(halfspace=-1, surface=surfaces['z+inf'])
cells['large_fuel'].setFill(self.materials['UO2'])
cells['large_fuel'].setNumSectors(num_sectors)
cells['large_mod'].addSurface(halfspace=+1, surface=surfaces['large'])
cells['large_mod'].addSurface(halfspace=+1, surface=surfaces['z-inf'])
cells['large_mod'].addSurface(halfspace=-1, surface=surfaces['z+inf'])
cells['large_mod'].setFill(self.materials['Water'])
cells['large_mod'].setNumSectors(num_sectors)
universes = {}
universes['pin'] = openmoc.Universe()
universes['pin'].addCell(cells['fuel'])
universes['pin'].addCell(cells['clad'])
universes['pin'].addCell(cells['mod'])
universes['uniform gap'] = openmoc.Universe()
universes['uniform gap'].addCell(cells['uniform gap'])
universes['large_pin'] = openmoc.Universe()
universes['large_pin'].addCell(cells['large_fuel'])
universes['large_pin'].addCell(cells['large_mod'])
lower_left = [0., 0., 0.]
width = ([gap_size, pin_pitch, pin_pitch,
gap_size], [gap_size, pin_pitch, pin_pitch,
gap_size], [1.0, 1.5])
lattice = openmoc.Lattice(name='lattice with gap')
lattice.setWidths(width[0], width[1], width[2])
lattice.setOffset(lower_left[0] + sum(width[0]) / 2.,
lower_left[1] + sum(width[1]) / 2.,
lower_left[2] + sum(width[2]) / 2.)
f = universes['pin']
g = universes['uniform gap']
l = universes['large_pin']
lattice.setUniverses([[[g, g, g, g], [g, f, f, g], [g, f, f, g],
[g, g, g, g]],
[[g, g, g, g], [g, f, f, g], [g, f, f, g],
[g, g, g, g]]])
surfaces['Global x-'] = openmoc.XPlane(x=lower_left[0])
surfaces['Global x+'] = openmoc.XPlane(x=lower_left[0] + sum(width[0]))
surfaces['Global y-'] = openmoc.YPlane(y=lower_left[1])
surfaces['Global y+'] = openmoc.YPlane(y=lower_left[1] + sum(width[1]))
surfaces['Global z-'] = openmoc.ZPlane(z=lower_left[2])
surfaces['Global z+'] = openmoc.ZPlane(z=lower_left[2] + sum(width[2]))
surfaces['Global x-'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Global x+'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Global y-'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Global y+'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Global z-'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Global z+'].setBoundaryType(openmoc.REFLECTIVE)
root_cell = openmoc.Cell()
root_cell.setFill(lattice)
root_cell.addSurface(halfspace=+1, surface=surfaces['Global x-'])
root_cell.addSurface(halfspace=-1, surface=surfaces['Global x+'])
root_cell.addSurface(halfspace=+1, surface=surfaces['Global y-'])
root_cell.addSurface(halfspace=-1, surface=surfaces['Global y+'])
root_cell.addSurface(halfspace=+1, surface=surfaces['Global z-'])
root_cell.addSurface(halfspace=-1, surface=surfaces['Global z+'])
root_universe = openmoc.Universe()
root_universe.addCell(root_cell)
self.geometry = openmoc.Geometry()
self.geometry.setRootUniverse(root_universe)
super(NonUniformLatticeInput, self).create_geometry()
def get_openmoc_surface(opencg_surface):
if not isinstance(opencg_surface, opencg.Surface):
msg = 'Unable to create an OpenMoC Surface from {0} which ' \
'is not an OpenCG Surface'.format(opencg_surface)
raise ValueError(msg)
global OPENMOC_SURFACES
surface_id = opencg_surface._id
# If this Surface was already created, use it
if surface_id in OPENMOC_SURFACES:
return OPENMOC_SURFACES[surface_id]
# Create an OpenMOC Surface to represent this OpenCG Surface
name = opencg_surface._name
# Correct for OpenMOC's syntax for Surfaces dividing Cells
boundary = opencg_surface._boundary_type
if boundary == 'vacuum':
boundary = openmoc.VACUUM
elif boundary == 'reflective':
boundary = openmoc.REFLECTIVE
elif boundary == 'interface':
boundary = openmoc.BOUNDARY_NONE
if opencg_surface._type == 'plane':
A = opencg_surface._coeffs['A']
B = opencg_surface._coeffs['B']
D = opencg_surface._coeffs['D']
openmoc_surface = openmoc.Plane(A, B, D, surface_id, name)
elif opencg_surface._type == 'x-plane':
x0 = opencg_surface._coeffs['x0']
openmoc_surface = openmoc.XPlane(x0, int(surface_id), name)
elif opencg_surface._type == 'y-plane':
y0 = opencg_surface._coeffs['y0']
openmoc_surface = openmoc.YPlane(y0, surface_id, name)
elif opencg_surface._type == 'z-plane':
z0 = opencg_surface._coeffs['z0']
openmoc_surface = openmoc.ZPlane(z0, surface_id, name)
elif opencg_surface._type == 'z-cylinder':
x0 = opencg_surface._coeffs['x0']
y0 = opencg_surface._coeffs['y0']
R = opencg_surface._coeffs['R']
openmoc_surface = openmoc.ZCylinder(x0, y0, R, surface_id, name)
else:
msg = 'Unable to create an OpenMOC Surface from an OpenCG ' \
'Surface of type {0} since it is not a compatible ' \
'Surface type in OpenMOC'.format(opencg_surface._type)
raise ValueError(msg)
# Set the boundary condition for this Surface
openmoc_surface.setBoundaryType(boundary)
# Add the OpenMOC Surface to the global collection of all OpenMOC Surfaces
OPENMOC_SURFACES[surface_id] = openmoc_surface
# Add the OpenCG Surface to the global collection of all OpenCG Surfaces
OPENCG_SURFACES[surface_id] = opencg_surface
# FIXME
openmoc_surface.thisown = 0
return openmoc_surface
def _run_openmoc(self):
"""Instantiate a complex region Geometry."""
# ----------------
# / \
# --------------- c2 (p22,p23) - u2 - c2a (p11)
# / /
# u_r <- c_r (p1,p2) - u1 - c1 (p11,p12,p13)
# \ \
# ------------- c3
root_universe = openmoc.Universe(name='root universe')
root_cell = openmoc.Cell(name='root cell')
u1 = openmoc.Universe(name='universe 1')
u2 = openmoc.Universe(name='universe 2 in c2')
root_cell.setFill(u1)
# Z-bounds at root level
p1 = openmoc.ZPlane(z=-2.0, name='zmin')
p1.setBoundaryType(openmoc.REFLECTIVE)
p2 = openmoc.ZPlane(z=+2.0, name='zmax')
p2.setBoundaryType(openmoc.INTERFACE)
root_cell.addSurface(halfspace=+1, surface=p1)
root_cell.addSurface(halfspace=-1, surface=p2)
# Cells in the root cell
c1 = openmoc.Cell(name='intersection cell')
c2 = openmoc.Cell(name='union cell')
c2a = openmoc.Cell(name='union cell 2')
c3 = openmoc.Cell(name='unbound cell')
u1.addCell(c1)
u1.addCell(c2)
u1.addCell(c3)
# Setting the parent cell helps to find boundaries (in Z here)
c3.setParent(root_cell)
# Cell c2a in c2, to further test arborescence
c2.setFill(u2)
u2.addCell(c2a)
c2.setParent(root_cell)
c2a.setParent(c2) # to test transitivity
# Bounds for cell 1 : intersection region cell
p11 = openmoc.XPlane(x=-2.0, name='xmin')
p11.setBoundaryType(openmoc.REFLECTIVE)
p12 = openmoc.YPlane(y=-2.0, name='ymin')
p12.setBoundaryType(openmoc.VACUUM)
p13 = openmoc.ZCylinder(x=0, y=0, radius=2.5, name='cylinder')
p13.setBoundaryType(openmoc.INTERFACE)
# addSurface assumes an intersection, which is what we want here
c1.addSurface(halfspace=+1, surface=p11)
c1.addSurface(halfspace=+1, surface=p12)
c1.addSurface(halfspace=-1, surface=p13)
# Bounds for cell 2 : union region cell
p22 = openmoc.ZCylinder(x=4, y=4, radius=2.5, name='cylinder')
p22.setBoundaryType(openmoc.INTERFACE)
p23 = openmoc.ZCylinder(x=-2, y=-8, radius=3, name='cylinder')
p23.setBoundaryType(openmoc.VACUUM)
# To have a union, we need to use addLogicalNode and addSurfaceInRegion
c2.addLogicalNode(1)
c2.addSurfaceInRegion(halfspace=-1, surface=p22)
c2.addSurfaceInRegion(halfspace=-1, surface=p23)
# Plane limits area even more
c2a.addLogicalNode(1)
c2a.addSurfaceInRegion(halfspace=+1, surface=p11)
openmoc.set_log_level('NORMAL')
for cell in [root_cell, c1, c2, c2a, c3]:
py_printf('NORMAL', 'Cell: %s', cell.getName())
py_printf('NORMAL', 'MinX: %f', cell.getMinX())
py_printf('NORMAL', 'MinXBoundaryType: %s',
cell.getMinXBoundaryType())
py_printf('NORMAL', 'MinY: %f', cell.getMinY())
py_printf('NORMAL', 'MinYBoundaryType: %s',
cell.getMinYBoundaryType())
py_printf('NORMAL', 'MinZ: %f', cell.getMinZ())
py_printf('NORMAL', 'MinZBoundaryType: %s',
cell.getMinZBoundaryType())
py_printf('NORMAL', 'MaxX: %f', cell.getMaxX())
py_printf('NORMAL', 'MaxXBoundaryType: %s',
cell.getMaxXBoundaryType())
py_printf('NORMAL', 'MaxY: %f', cell.getMaxY())
py_printf('NORMAL', 'MaxYBoundaryType: %s',
cell.getMaxYBoundaryType())
py_printf('NORMAL', 'MaxZ: %f', cell.getMaxZ())
py_printf('NORMAL', 'MaxZBoundaryType: %s',
cell.getMaxZBoundaryType())
py_printf('NORMAL', '')
###############################################################################
openmoc.log.py_printf('NORMAL', 'Importing materials data from HDF5...')
materials = openmoc.materialize.load_from_hdf5('c5g7-mgxs.h5', '../')
###############################################################################
# Creating Surfaces
###############################################################################
openmoc.log.py_printf('NORMAL', 'Creating surfaces...')
boundary = openmoc.RectangularPrism(4., 4.)
boundary.setBoundaryType(openmoc.PERIODIC)
zcylinder = openmoc.ZCylinder(x=0.0, y=0.0, radius=0.3, name='fuel pin')
###############################################################################
# Creating Grid Spacer
###############################################################################
outer_box = openmoc.RectangularPrism(1.00, 1.00)
inner_box = openmoc.RectangularPrism(0.96, 0.96)
inner_complement = openmoc.Complement()
inner_complement.addNode(inner_box)
grid_spacer_region = openmoc.Intersection()
grid_spacer_region.addNode(outer_box)
grid_spacer_region.addNode(inner_complement)
###############################################################################
fuel.setSigmaS(numpy.array([0.38259177]))
fuel.setChi(numpy.array([1.0]))
moderator.setSigmaT(numpy.array([0.841545641]))
moderator.setSigmaF(numpy.array([0.0]))
moderator.setNuSigmaF(numpy.array([0.0]))
moderator.setSigmaS(numpy.array([0.837794542]))
moderator.setChi(numpy.array([1.0]))
###############################################################################
# Creating Surfaces
###############################################################################
openmoc.log.py_printf('NORMAL', 'Creating surfaces...')
zcylinder = openmoc.ZCylinder(x=0.0, y=0.0, radius=0.4)
left = openmoc.XPlane(x=-0.635)
right = openmoc.XPlane(x=0.635)
top = openmoc.YPlane(y=0.635)
bottom = openmoc.YPlane(y=-0.635)
left.setBoundaryType(openmoc.REFLECTIVE)
right.setBoundaryType(openmoc.REFLECTIVE)
top.setBoundaryType(openmoc.REFLECTIVE)
bottom.setBoundaryType(openmoc.REFLECTIVE)
###############################################################################
# Creating Cells
###############################################################################
openmoc.log.py_printf('NORMAL', 'Creating cells...')
gap = 0.5
surfaces = {}
# Instantiate surfaces
surfaces['Root x-min'] = openmoc.XPlane(x=-32.13, name='Root x-min')
surfaces['Root x-max'] = openmoc.XPlane(x=32.13, name='Root x-max')
surfaces['Root y-min'] = openmoc.YPlane(y=-32.13, name='Root y-min')
surfaces['Root y-max'] = openmoc.YPlane(y=32.13, name='Root y-max')
surfaces['Root Small z-min'] = openmoc.ZPlane(z=-32.13,
name='Root Small z-min')
surfaces['Root Small z-max'] = openmoc.ZPlane(z=32.13, name='Root Small z-max')
surfaces['Root Big z-min'] = openmoc.ZPlane(z=-107.1, name='Root Big z-min')
surfaces['Root Big z-max'] = openmoc.ZPlane(z=107.1, name='Root Big z-max')
surfaces['Fuel Cylinder'] = openmoc.ZCylinder(x=0.0,
y=0.0,
radius=0.54,
name='Fuel Cylinder')
surfaces['Gap Root x-min'] = openmoc.XPlane(x=-32.13 - 3 * gap,
name='Gap Root x-min')
surfaces['Gap Root x-max'] = openmoc.XPlane(x=32.13 + 3 * gap,
name='Gap Root x-max')
surfaces['Gap Root y-min'] = openmoc.YPlane(y=-32.13 - 3 * gap,
name='Gap Root y-min')
surfaces['Gap Root y-max'] = openmoc.YPlane(y=32.13 + 3 * gap,
name='Gap Root y-max')
surfaces['Root x-min'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Root x-max'].setBoundaryType(openmoc.VACUUM)
surfaces['Root y-min'].setBoundaryType(openmoc.VACUUM)
surfaces['Root y-max'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Root Small z-min'].setBoundaryType(openmoc.REFLECTIVE)
def create_lattice(self):
large_zcylinder = openmoc.ZCylinder(
x=0.0, y=0.0, radius=0.4, name='large pin')
medium_zcylinder = openmoc.ZCylinder(
x=0.0, y=0.0, radius=0.3, name='medium pin')
small_zcylinder = openmoc.ZCylinder(
x=0.0, y=0.0, radius=0.2, name='small pin')
x0_plane = openmoc.XPlane(x=0)
y0_plane = openmoc.YPlane(y=0)
large_fuel = openmoc.Cell(name='large pin fuel')
large_fuel.setFill(self.materials['UO2'])
large_fuel.addSurface(halfspace=-1, surface=large_zcylinder)
large_moderator = openmoc.Cell(name='large pin moderator')
large_moderator.setFill(self.materials['Water'])
large_moderator.addSurface(halfspace=+1, surface=large_zcylinder)
fuel_quads = [None]*4
mod_quads = [None]*4
for i in range(4):
qname = " (quadrant {})".format(i + 1)
fcell = openmoc.Cell(name='large fuel' + qname)
fcell.setFill(self.materials['UO2'])
fcell.addSurface(halfspace=-1, surface=large_zcylinder)
mcell = openmoc.Cell(name='large mod' + qname)
mcell.setFill(self.materials['Water'])
mcell.addSurface(halfspace=+1, surface=large_zcylinder)
# Add the appropriate quadrants
xspace = 1 if i in (0, 3) else -1
yspace = 1 if i in (0, 1) else -1
fcell.addSurface(halfspace=xspace, surface=x0_plane)
fcell.addSurface(halfspace=yspace, surface=y0_plane)
mcell.addSurface(halfspace=xspace, surface=x0_plane)
mcell.addSurface(halfspace=yspace, surface=y0_plane)
fuel_quads[i] = fcell
mod_quads[i] = mcell
medium_fuel = openmoc.Cell(name='medium pin fuel')
medium_fuel.setFill(self.materials['UO2'])
medium_fuel.addSurface(halfspace=-1, surface=medium_zcylinder)
medium_moderator = openmoc.Cell(name='medium pin moderator')
medium_moderator.setFill(self.materials['Water'])
medium_moderator.addSurface(halfspace=+1, surface=medium_zcylinder)
small_fuel = openmoc.Cell(name='small pin fuel')
small_fuel.setFill(self.materials['UO2'])
small_fuel.addSurface(halfspace=-1, surface=small_zcylinder)
small_moderator = openmoc.Cell(name='small pin moderator')
small_moderator.setFill(self.materials['Water'])
small_moderator.addSurface(halfspace=+1, surface=small_zcylinder)
pin1 = openmoc.Universe(name='large pin cell')
pin2 = openmoc.Universe(name='medium pin cell')
pin3 = openmoc.Universe(name='small pin cell')
pin4 = openmoc.Universe(name='large pin cell (quadrants)')
pin1.addCell(large_fuel)
pin1.addCell(large_moderator)
pin2.addCell(medium_fuel)
pin2.addCell(medium_moderator)
pin3.addCell(small_fuel)
pin3.addCell(small_moderator)
for c in fuel_quads + mod_quads:
pin4.addCell(c)
###################
# SUBDIVIDE PINS #
###################
lleft = [-0.5]*2
uright = [0.5]*2
DIV = (2, 2)
div1 = openmoc.Subdivider(DIV, lleft, uright)
pin1_div = div1.get_subdivided_universe(pin1)
div4 = openmoc.Subdivider(DIV, lleft, uright)
pin4_div = div4.get_subdivided_universe(pin4)
# 2x2 assembly
lattice = openmoc.Lattice(name='2x2 lattice')
lattice.setWidth(width_x=1.0, width_y=1.0)
lattice.setUniverses([[[pin4_div, pin3],
[pin1, pin1_div]]])
return lattice
def create_geometry(self):
"""Instantiate 4x4 non-uniform and axially extended lattice problem."""
fuel_rings = 1
moderator_rings = 1
num_sectors = 8
openmoc.set_line_length(120)
r_fuel = 0.54
r_clad = 0.57
r_large = 0.60
pin_pitch = 1.26
gap_size = 0.05
surfaces = {}
surfaces['Pin Cell ZCylinder'] = openmoc.ZCylinder(
x=0, y=0, radius=r_fuel, name='Pin Cell ZCylinder')
surfaces['Clad Cell ZCylinder'] = openmoc.ZCylinder(
x=0, y=0, radius=r_clad, name='Clad Cell ZCylinder')
surfaces['large'] = openmoc.ZCylinder(x=0,
y=0,
radius=r_large,
name='large')
surfaces['z-inf'] = openmoc.ZPlane(z=-1.0E10)
surfaces['z+inf'] = openmoc.ZPlane(z=1.0E10)
cells = {}
cells['fuel'] = openmoc.Cell()
cells['clad'] = openmoc.Cell()
cells['mod'] = openmoc.Cell()
cells['uniform gap'] = openmoc.Cell()
cells['large_fuel'] = openmoc.Cell()
cells['large_mod'] = openmoc.Cell()
cells['fuel'].addSurface(halfspace=-1,
surface=surfaces['Pin Cell ZCylinder'])
cells['fuel'].addSurface(halfspace=+1, surface=surfaces['z-inf'])
cells['fuel'].addSurface(halfspace=-1, surface=surfaces['z+inf'])
cells['fuel'].setFill(self.materials['UO2'])
cells['fuel'].setNumSectors(num_sectors)
cells['fuel'].setNumRings(fuel_rings)
cells['clad'].addSurface(halfspace=+1,
surface=surfaces['Pin Cell ZCylinder'])
cells['clad'].addSurface(halfspace=-1,
surface=surfaces['Clad Cell ZCylinder'])
cells['clad'].addSurface(halfspace=+1, surface=surfaces['z-inf'])
cells['clad'].addSurface(halfspace=-1, surface=surfaces['z+inf'])
cells['clad'].setFill(self.materials['Clad'])
cells['clad'].setNumSectors(num_sectors)
cells['mod'].addSurface(halfspace=+1,
surface=surfaces['Clad Cell ZCylinder'])
cells['mod'].addSurface(halfspace=+1, surface=surfaces['z-inf'])
cells['mod'].addSurface(halfspace=-1, surface=surfaces['z+inf'])
cells['mod'].setFill(self.materials['Water'])
cells['mod'].setNumSectors(num_sectors)
cells['mod'].setNumRings(moderator_rings)
cells['uniform gap'].addSurface(halfspace=+1,
surface=surfaces['z-inf'])
cells['uniform gap'].addSurface(halfspace=-1,
surface=surfaces['z+inf'])
cells['uniform gap'].setFill(self.materials['Clad'])
cells['large_fuel'].addSurface(halfspace=-1, surface=surfaces['large'])
cells['large_fuel'].addSurface(halfspace=+1, surface=surfaces['z-inf'])
cells['large_fuel'].addSurface(halfspace=-1, surface=surfaces['z+inf'])
cells['large_fuel'].setFill(self.materials['UO2'])
cells['large_fuel'].setNumSectors(num_sectors)
cells['large_mod'].addSurface(halfspace=+1, surface=surfaces['large'])
cells['large_mod'].addSurface(halfspace=+1, surface=surfaces['z-inf'])
cells['large_mod'].addSurface(halfspace=-1, surface=surfaces['z+inf'])
cells['large_mod'].setFill(self.materials['Water'])
cells['large_mod'].setNumSectors(num_sectors)
universes = {}
universes['pin'] = openmoc.Universe()
universes['pin'].addCell(cells['fuel'])
universes['pin'].addCell(cells['clad'])
universes['pin'].addCell(cells['mod'])
universes['uniform gap'] = openmoc.Universe()
universes['uniform gap'].addCell(cells['uniform gap'])
universes['large_pin'] = openmoc.Universe()
universes['large_pin'].addCell(cells['large_fuel'])
universes['large_pin'].addCell(cells['large_mod'])
lower_left = [0., 0., 0.]
# set the XYZ widths of non-uniform lattice
width = ([gap_size, pin_pitch, pin_pitch,
gap_size], [gap_size, pin_pitch, pin_pitch,
gap_size], [1.0] * 20)
lattice = openmoc.Lattice(name='lattice with gap')
lattice.setWidths(width[0], width[1], width[2])
lattice.setOffset(lower_left[0] + sum(width[0]) / 2.,
lower_left[1] + sum(width[1]) / 2.,
lower_left[2] + sum(width[2]) / 2.)
f = universes['pin']
g = universes['uniform gap']
l = universes['large_pin']
a = numpy.array([[g, g, g, g], [g, f, f, g], [g, f, f, g],
[g, g, g, g]])
fill_universes = numpy.tile(a, (20, 1, 1))
# make the geometry axially heterogeneous
fill_universes[2][1][1] = g
fill_universes = fill_universes.tolist()
lattice.setUniverses(fill_universes)
surfaces['Global x-'] = openmoc.XPlane(x=lower_left[0])
surfaces['Global x+'] = openmoc.XPlane(x=lower_left[0] + sum(width[0]))
surfaces['Global y-'] = openmoc.YPlane(y=lower_left[1])
surfaces['Global y+'] = openmoc.YPlane(y=lower_left[1] + sum(width[1]))
surfaces['Global z-'] = openmoc.ZPlane(z=lower_left[2])
surfaces['Global z+'] = openmoc.ZPlane(z=lower_left[2] + sum(width[2]))
surfaces['Global x-'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Global x+'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Global y-'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Global y+'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Global z-'].setBoundaryType(openmoc.REFLECTIVE)
surfaces['Global z+'].setBoundaryType(openmoc.REFLECTIVE)
root_cell = openmoc.Cell()
root_cell.setFill(lattice)
root_cell.addSurface(halfspace=+1, surface=surfaces['Global x-'])
root_cell.addSurface(halfspace=-1, surface=surfaces['Global x+'])
root_cell.addSurface(halfspace=+1, surface=surfaces['Global y-'])
root_cell.addSurface(halfspace=-1, surface=surfaces['Global y+'])
root_cell.addSurface(halfspace=+1, surface=surfaces['Global z-'])
root_cell.addSurface(halfspace=-1, surface=surfaces['Global z+'])
root_universe = openmoc.Universe()
root_universe.addCell(root_cell)
self.geometry = openmoc.Geometry()
self.geometry.setRootUniverse(root_universe)
super(AxialExtendedInput, self).create_geometry()
def get_openmoc_surface(opencg_surface):
"""Return an OpenMOC surface corresponding to an OpenCG surface.
Parameters
----------
opencg_surface : opencg.Surface
OpenCG surface
Returns
-------
openmoc_surface : openmoc.Surface
Equivalent OpenMOC surface
"""
cv.check_type('opencg_surface', opencg_surface, opencg.Surface)
global OPENMOC_SURFACES
surface_id = opencg_surface.id
# If this Surface was already created, use it
if surface_id in OPENMOC_SURFACES:
return OPENMOC_SURFACES[surface_id]
# Create an OpenMOC Surface to represent this OpenCG Surface
name = str(opencg_surface.name)
# Correct for OpenMOC's syntax for Surfaces dividing Cells
boundary = opencg_surface.boundary_type
if boundary == 'vacuum':
boundary = openmoc.VACUUM
elif boundary == 'reflective':
boundary = openmoc.REFLECTIVE
elif boundary == 'interface':
boundary = openmoc.BOUNDARY_NONE
if opencg_surface.type == 'plane':
A = opencg_surface.a
B = opencg_surface.b
C = opencg_surface.c
D = opencg_surface.d
openmoc_surface = openmoc.Plane(A, B, C, D, surface_id, name)
elif opencg_surface.type == 'x-plane':
x0 = opencg_surface.x0
openmoc_surface = openmoc.XPlane(x0, int(surface_id), name)
elif opencg_surface.type == 'y-plane':
y0 = opencg_surface.y0
openmoc_surface = openmoc.YPlane(y0, surface_id, name)
elif opencg_surface.type == 'z-plane':
z0 = opencg_surface.z0
openmoc_surface = openmoc.ZPlane(z0, surface_id, name)
elif opencg_surface.type == 'z-cylinder':
x0 = opencg_surface.x0
y0 = opencg_surface.y0
R = opencg_surface.r
openmoc_surface = openmoc.ZCylinder(x0, y0, R, surface_id, name)
else:
msg = 'Unable to create an OpenMOC Surface from an OpenCG ' \
'Surface of type {0} since it is not a compatible ' \
'Surface type in OpenMOC'.format(opencg_surface.type)
raise ValueError(msg)
# Set the boundary condition for this Surface
openmoc_surface.setBoundaryType(boundary)
# Add the OpenMOC Surface to the global collection of all OpenMOC Surfaces
OPENMOC_SURFACES[surface_id] = openmoc_surface
# Add the OpenCG Surface to the global collection of all OpenCG Surfaces
OPENCG_SURFACES[surface_id] = opencg_surface
return openmoc_surface
xmin = openmoc.XPlane(x=-32.13, name='xmin')
xmax = openmoc.XPlane(x=32.13, name='xmax')
ymin = openmoc.YPlane(y=-32.13, name='ymin')
ymax = openmoc.YPlane(y=32.13, name='ymax')
zmin = openmoc.ZPlane(z=-32.13, name='zmin')
zmax = openmoc.ZPlane(z=32.13, name='zmax')
xmin.setBoundaryType(openmoc.REFLECTIVE)
xmax.setBoundaryType(openmoc.VACUUM)
ymin.setBoundaryType(openmoc.VACUUM)
ymax.setBoundaryType(openmoc.REFLECTIVE)
# Create ZCylinders for the fuel as well as to discretize the moderator into
# rings
fuel_radius = openmoc.ZCylinder(x=0.0, y=0.0, radius=0.54)
moderator_inner_radius = openmoc.ZCylinder(x=0.0, y=0.0, radius=0.58)
moderator_outer_radius = openmoc.ZCylinder(x=0.0, y=0.0, radius=0.62)
###############################################################################
###################### Creating Cells and Universes #######################
###############################################################################
openmoc.log.py_printf('NORMAL', 'Creating cells...')
# Moderator rings
moderator_ring1 = openmoc.Cell()
moderator_ring2 = openmoc.Cell()
moderator_ring3 = openmoc.Cell()
moderator_ring1.setNumSectors(8)
moderator_ring2.setNumSectors(8)
###############################################################################
# Creating Materials
###############################################################################
openmoc.log.py_printf('NORMAL', 'Importing materials data from HDF5...')
materials = openmoc.materialize.load_from_hdf5('c5g7-mgxs.h5', '../')
###############################################################################
# Creating Surfaces
###############################################################################
openmoc.log.py_printf('NORMAL', 'Creating surfaces...')
zcylinder = openmoc.ZCylinder(x=0.0, y=0.0, radius=1.0, name='pin')
left = openmoc.XPlane(x=-2.0, name='left')
right = openmoc.XPlane(x=2.0, name='right')
top = openmoc.YPlane(y=2.0, name='top')
bottom = openmoc.YPlane(y=-2.0, name='bottom')
left.setBoundaryType(openmoc.REFLECTIVE)
right.setBoundaryType(openmoc.REFLECTIVE)
top.setBoundaryType(openmoc.REFLECTIVE)
bottom.setBoundaryType(openmoc.REFLECTIVE)
###############################################################################
# Creating Cells
###############################################################################
openmoc.log.py_printf('NORMAL', 'Creating cells...')
def create_geometry(self):
"""Instantiate a 4x4 pin cell lattice Geometry."""
xmin = openmoc.XPlane(x=-2.0, name='xmin')
xmax = openmoc.XPlane(x=+2.0, name='xmax')
ymax = openmoc.YPlane(y=+2.0, name='ymin')
ymin = openmoc.YPlane(y=-2.0, name='ymax')
boundaries = [xmin, xmax, ymin, ymax]
large_zcylinder = openmoc.ZCylinder(x=0.0, y=0.0,
radius=0.4, name='large pin')
medium_zcylinder = openmoc.ZCylinder(x=0.0, y=0.0,
radius=0.3, name='medium pin')
small_zcylinder = openmoc.ZCylinder(x=0.0, y=0.0,
radius=0.2, name='small pin')
for boundary in boundaries: boundary.setBoundaryType(openmoc.REFLECTIVE)
large_fuel = openmoc.Cell(name='large pin fuel')
large_fuel.setNumRings(3)
large_fuel.setNumSectors(8)
large_fuel.setFill(self.materials['UO2'])
large_fuel.addSurface(halfspace=-1, surface=large_zcylinder)
large_moderator = openmoc.Cell(name='large pin moderator')
large_moderator.setNumSectors(8)
large_moderator.setFill(self.materials['Water'])
large_moderator.addSurface(halfspace=+1, surface=large_zcylinder)
medium_fuel = openmoc.Cell(name='medium pin fuel')
medium_fuel.setNumRings(3)
medium_fuel.setNumSectors(8)
medium_fuel.setFill(self.materials['UO2'])
medium_fuel.addSurface(halfspace=-1, surface=medium_zcylinder)
medium_moderator = openmoc.Cell(name='medium pin moderator')
medium_moderator.setNumSectors(8)
medium_moderator.setFill(self.materials['Water'])
medium_moderator.addSurface(halfspace=+1, surface=medium_zcylinder)
small_fuel = openmoc.Cell(name='small pin fuel')
small_fuel.setNumRings(3)
small_fuel.setNumSectors(8)
small_fuel.setFill(self.materials['UO2'])
small_fuel.addSurface(halfspace=-1, surface=small_zcylinder)
small_moderator = openmoc.Cell(name='small pin moderator')
small_moderator.setNumSectors(8)
small_moderator.setFill(self.materials['Water'])
small_moderator.addSurface(halfspace=+1, surface=small_zcylinder)
lattice_cell = openmoc.Cell(name='lattice cell')
root_cell = openmoc.Cell(name='root cell')
root_cell.addSurface(halfspace=+1, surface=boundaries[0])
root_cell.addSurface(halfspace=-1, surface=boundaries[1])
root_cell.addSurface(halfspace=+1, surface=boundaries[2])
root_cell.addSurface(halfspace=-1, surface=boundaries[3])
pin1 = openmoc.Universe(name='large pin cell')
pin2 = openmoc.Universe(name='medium pin cell')
pin3 = openmoc.Universe(name='small pin cell')
assembly = openmoc.Universe(name='2x2 lattice')
root_universe = openmoc.Universe(name='root universe')
pin1.addCell(large_fuel)
pin1.addCell(large_moderator)
pin2.addCell(medium_fuel)
pin2.addCell(medium_moderator)
pin3.addCell(small_fuel)
pin3.addCell(small_moderator)
assembly.addCell(lattice_cell)
root_universe.addCell(root_cell)
# 2x2 assembly
lattice = openmoc.Lattice(name='2x2 lattice')
lattice.setWidth(width_x=1.0, width_y=1.0)
lattice.setUniverses([[[pin1, pin2], [pin1, pin3]]])
lattice_cell.setFill(lattice)
# 2x2 core
core = openmoc.Lattice(name='2x2 core')
core.setWidth(width_x=2.0, width_y=2.0)
core.setUniverses([[[assembly, assembly], [assembly, assembly]]])
root_cell.setFill(core)
self.geometry = openmoc.Geometry()
self.geometry.setRootUniverse(root_universe)
super(SimpleLatticeInput, self).create_geometry()
materials = openmoc.materialize.load_from_hdf5('c5g7-mgxs.h5', '../')
###############################################################################
# Creating Surfaces
###############################################################################
openmoc.log.py_printf('NORMAL', 'Creating surfaces...')
left = openmoc.XPlane(x=-2.0, name='left')
right = openmoc.XPlane(x=2.0, name='right')
top = openmoc.YPlane(y=-2.0, name='top')
bottom = openmoc.YPlane(y=2.0, name='bottom')
boundaries = [left, right, top, bottom]
large_zcylinder = openmoc.ZCylinder(x=0.0, y=0.0, radius=0.4, name='large pin')
medium_zcylinder = openmoc.ZCylinder(x=0.0,
y=0.0,
radius=0.3,
name='medium pin')
small_zcylinder = openmoc.ZCylinder(x=0.0, y=0.0, radius=0.2, name='small pin')
for boundary in boundaries:
boundary.setBoundaryType(openmoc.REFLECTIVE)
###############################################################################
# Creating Cells
###############################################################################
openmoc.log.py_printf('NORMAL', 'Creating cells...')
max_iters = 50
# ## Initialize Materials
# In[3]:
materials = load_from_hdf5(filename='c5g7-mgxs-ensemble-uo2.h5',
directory='..')
print(materials.keys())
# ## Create Bounding Surfaces
# In[4]:
# Create ZCylinder for the fuel
fuel_radius = openmoc.ZCylinder(x=0.0, y=0.0, radius=0.54)
# ## Create Fuel Pins
# In[6]:
# Create ensemble of fuel pins
# 4.0% UOX pin cell base case
Nmat = 100 # number of UO2 pin materials in the ensemble
uox40_array = []
gd_array = []
for n in range(Nmat):
uo2_name = 'UO2-' + str(n)
uox40_cell = openmoc.Cell()
uox40_cell.setFill(materials[uo2_name])
