def _create_trackgenerator(self):
"""Dump and load the geometry then instantiate a TrackGenerator."""
# Geometry should be dumped before FSRs are initialized
# Dump the geometry
self.input_set.geometry.dumpToFile("geometry_file.geo")
# Get rid of the geometry
self.input_set.geometry = None
# Reload the geometry
self.input_set.geometry = openmoc.Geometry()
self.input_set.geometry.loadFromFile("geometry_file.geo")
# Instantiate a TrackGenerator
geometry = self.input_set.geometry
geometry.initializeFlatSourceRegions()
self.track_generator = \
openmoc.TrackGenerator(geometry, self.num_azim,
self.spacing)
###############################################################################
openmoc.log.py_printf('NORMAL', 'Importing cubic geometry...')
left.setBoundaryType(openmoc.VACUUM)
right.setBoundaryType(openmoc.VACUUM)
top.setBoundaryType(openmoc.REFLECTIVE)
bottom.setBoundaryType(openmoc.REFLECTIVE)
###############################################################################
######################## Creating the TrackGenerator ######################
###############################################################################
openmoc.log.py_printf('NORMAL', 'Initializing the track generator...')
track_generator = openmoc.TrackGenerator(geometry, opts.num_azim,
opts.azim_spacing)
track_generator.setNumThreads(opts.num_omp_threads)
track_generator.generateTracks()
###############################################################################
########################### Running a Simulation ##########################
###############################################################################
solver = openmoc.CPUSolver(track_generator)
solver.setNumThreads(opts.num_omp_threads)
solver.setConvergenceThreshold(opts.tolerance)
solver.computeEigenvalue(opts.max_iters)
solver.printTimerReport()
###############################################################################
############################ Generating Plots ############################
# Build a coarse group Library from the fine (70-)group Library
coarse_groups = group_structures['CASMO']['{}-group'.format(num_groups)]
condense_lib = mgxs_lib.get_condensed_library(coarse_groups)
# Create an OpenMOC Geometry from the OpenMC Geometry
openmoc_geometry = get_openmoc_geometry(condense_lib.geometry)
openmoc.materialize.load_openmc_mgxs_lib(condense_lib, openmoc_geometry)
# Discretize the geometry
cells = openmoc_geometry.getAllMaterialCells()
for cell_id, cell in cells.items():
cell.setNumSectors(8)
# Generate tracks
track_generator = openmoc.TrackGenerator(openmoc_geometry, 128, 0.01)
track_generator.setNumThreads(opts.num_omp_threads)
track_generator.generateTracks()
# Instantiate a Solver
solver = openmoc.CPUSolver(track_generator)
solver.setNumThreads(opts.num_omp_threads)
solver.setConvergenceThreshold(1E-7)
# Run OpenMOC
solver.computeEigenvalue(opts.max_iters)
keffs[0, j] = solver.getKeff()
###############################################################################
# Eigenvalue Calculation w/ SPH Factors
###############################################################################
mgxs_lib = openmc.mgxs.Library.load_from_file(directory=directory)
openmoc_geometry = \
openmc.openmoc_compatible.get_openmoc_geometry(mgxs_lib.geometry)
coarse_groups = group_structures['CASMO']['{}-group'.format(num_groups)]
mgxs_lib = mgxs_lib.get_condensed_library(coarse_groups)
openmoc_materials = \
openmoc.materialize.load_openmc_mgxs_lib(mgxs_lib, openmoc_geometry)
# Discretize the geometry in angular sectors
cells = openmoc_geometry.getAllMaterialCells()
for cell_id, cell in cells.items():
cell.setNumSectors(8)
# Initialize an OpenMOC TrackGenerator and Solver
track_generator = openmoc.TrackGenerator(openmoc_geometry, 512, 0.001)
track_generator.setNumThreads(opts.num_omp_threads)
track_generator.generateTracks(store=False)
# Initialize an OpenMOC Solver
solver = openmoc.CPUSolver(track_generator)
solver.setConvergenceThreshold(1E-7)
solver.setNumThreads(opts.num_omp_threads)
# Run an eigenvalue calulation with the MGXS from OpenMC
solver.computeEigenvalue(opts.max_iters)
solver.printTimerReport()
###############################################################################
# Extracting Scalar Fluxes
###############################################################################
geometry = openmoc.Geometry()
geometry.setRootUniverse(universes['Root'])
geometry.setCmfd(cmfd)
geometry.initializeFlatSourceRegions()
###############################################################################
######################## Creating the TrackGenerator ######################
###############################################################################
log.py_printf('NORMAL', 'Initializing the track generator...')
quad = openmoc.EqualAnglePolarQuad()
quad.setNumPolarAngles(num_polar)
track_generator = openmoc.TrackGenerator(geometry, num_azim, azim_spacing)
track_generator.setQuadrature(quad)
track_generator.setNumThreads(num_threads)
track_generator.generateTracks()
###############################################################################
########################### Running a Simulation ##########################
###############################################################################
solver = openmoc.CPUSolver(track_generator)
solver.setConvergenceThreshold(tolerance)
solver.setNumThreads(num_threads)
solver.computeEigenvalue(max_iters)
solver.printTimerReport()
###############################################################################
def _create_trackgenerator(self):
"""Instantiate a TrackGenerator."""
geometry = self.input_set.geometry
geometry.initializeFlatSourceRegions()
self.track_generator = \
openmoc.TrackGenerator(geometry, self.num_azim, self.spacing)
def _create_trackgenerator(self):
"""Instantiate a TrackGenerator."""
geometry = self.input_set.geometry
self.track_generator = \
openmoc.TrackGenerator(geometry, self.num_azim, self.spacing)
def compute_sph_factors(mgxs_lib,
max_sph_iters=30,
sph_tol=1E-5,
fix_src_tol=1E-5,
num_azim=4,
azim_spacing=0.1,
zcoord=0.0,
num_threads=1,
throttle_output=True,
geometry=None,
track_generator=None,
solver=None,
sph_domains=None):
"""Compute SPH factors for an OpenMC multi-group cross section library.
This routine coputes SuPerHomogenisation (SPH) factors for an OpenMC MGXS
library. The SPH scheme is outlined by Alain Hebert in the following paper:
Hebert, A., "A Consistent Technique for the Pin-by-Pin
Homogenization of a Pressurized Water Reactor Assembly."
Nuclear Science and Engineering, 113 (3), pp. 227-233, 1993.
The SPH factors are needed to preserve reaction rates in heterogeneous
geometries. The energy condensation process leads to a bias between
ultrafine and coarse energy group calculations. This bias is a result of the
use of scalar flux-weighting to compute MGXS without properly accounting for
angular-dependence of the flux.
Parameters
----------
mgxs_lib : openmc.mgxs.Library
An OpenMC multi-group cross section library
max_sph_iters : Integral
The maximum number of SPH iterations (default is 30)
sph_tol : Real
The tolerance on the SPH factor convergence (default is 1E-5)
fix_src_tol : Real
The tolerance on the MOC fixed source calculations (default is 1E-5)
num_azim : Integral
The number of azimuthal angles (default is 4)
azim_spacing : Real
The track spacing (default is 0.1 centimeters)
zcoord : Real
The coordinate on the z-axis (default is 0.)
num_threads : Real
The number of OpenMP threads (default is 1)
throttle_output : bool
Whether to suppress output from fixed source calculations (default is True)
geometry : openmoc.Geometry
An optional openmoc geometry to compute SPH factors on
track_generator : openmoc.TrackGenerator
An optional track generator to avoid initializing it in this routine
solver : openmoc.Solver
An optional openmoc solver to compute SPH factors with
sph_domains : list of int
A list of domain (cell or material, based on mgxs_lib domain type) ids,
in which SPH factors should be computed. Default is only fissonable FSRs
Returns
-------
fsrs_to_sph : numpy.ndarray of Real
A NumPy array of SPH factors indexed by FSR and energy group
sph_mgxs_lib : openmc.mgxs.Library
An OpenMC MGXS library with the SPH factors applied to each MGXS
sph_to_fsrs_indices : numpy.ndarray of Integral
A NumPy array of all FSRs to which SPH factors were applied
"""
import openmc.mgxs
cv.check_type('mgxs_lib', mgxs_lib, openmc.mgxs.Library)
# For Python 2.X.X
if sys.version_info[0] == 2:
from openmc.openmoc_compatible import get_openmoc_geometry
from process import get_scalar_fluxes
# For Python 3.X.X
else:
from openmc.openmoc_compatible import get_openmoc_geometry
from openmoc.process import get_scalar_fluxes
py_printf('NORMAL', 'Computing SPH factors...')
if not geometry:
# Create an OpenMOC Geometry from the OpenMC Geometry
geometry = get_openmoc_geometry(mgxs_lib.geometry)
# Load the MGXS library data into the OpenMOC geometry
load_openmc_mgxs_lib(mgxs_lib, geometry)
if not track_generator:
# Initialize an OpenMOC TrackGenerator
track_generator = openmoc.TrackGenerator(geometry, num_azim,
azim_spacing)
track_generator.setZCoord(zcoord)
track_generator.generateTracks()
track_generator.initializeVolumes()
else:
track_generator.initializeVolumes()
py_printf(
'WARNING', 'Using provided track generator, ignoring '
'arguments for track generation settings')
if not solver:
# Initialize an OpenMOC Solver
solver = openmoc.CPUSolver(track_generator)
solver.setConvergenceThreshold(fix_src_tol)
solver.setNumThreads(num_threads)
else:
py_printf(
'WARNING', 'Using provided solver, ignoring arguments for '
'solver settings')
# Get all OpenMOC domains
if mgxs_lib.domain_type == 'material':
openmoc_domains = geometry.getAllMaterials()
elif mgxs_lib.domain_type == 'cell':
openmoc_domains = geometry.getAllMaterialCells()
else:
py_printf(
'ERROR', 'SPH factors cannot be applied for an OpenMC MGXS '
'library of domain type %s', mgxs_lib.domain_type)
if not sph_domains:
sph_domains = []
# If unspecified, apply sph factors in fissionable regions
for openmoc_domain in openmoc_domains.values():
if openmoc_domain.isFissionable():
sph_domains.append(openmoc_domain.getId())
openmc_fluxes = _load_openmc_src(mgxs_lib, solver)
# Initialize SPH factors
num_groups = geometry.getNumEnergyGroups()
num_fsrs = geometry.getNumFSRs()
# Map FSRs to domains (and vice versa) to compute domain-averaged fluxes
fsrs_to_domains = np.zeros(num_fsrs)
domains_to_fsrs = collections.defaultdict(list)
sph_to_fsr_indices = []
for fsr in range(num_fsrs):
cell = geometry.findCellContainingFSR(fsr)
if mgxs_lib.domain_type == 'material':
domain = cell.getFillMaterial()
else:
domain = cell
fsrs_to_domains[fsr] = domain.getId()
domains_to_fsrs[domain.getId()].append(fsr)
if domain.getId() in sph_domains:
sph_to_fsr_indices.append(fsr)
# Build a list of indices into the SPH array for fissionable domains
sph_to_domain_indices = []
for i, openmc_domain in enumerate(mgxs_lib.domains):
if openmc_domain.id in openmoc_domains:
openmoc_domain = openmoc_domains[openmc_domain.id]
if openmoc_domain.getId() in sph_domains:
sph_to_domain_indices.append(i)
py_printf('NORMAL', 'Computing SPH factors for %d "%s" domains',
len(sph_to_domain_indices), mgxs_lib.domain_type)
# Initialize array of domain-averaged fluxes and SPH factors
num_domains = len(mgxs_lib.domains)
openmoc_fluxes = np.zeros((num_domains, num_groups))
sph = np.ones((num_domains, num_groups))
# Store starting verbosity log level
log_level = openmoc.get_log_level()
# SPH iteration loop
for i in range(max_sph_iters):
# Run fixed source calculation with suppressed output
if throttle_output:
openmoc.set_log_level('WARNING')
# Disable flux resets between SPH iterations for speed
if i == 1:
solver.setRestartStatus(True)
# Fixed source calculation
solver.computeFlux()
# Restore log output level
if throttle_output:
openmoc.set_log_level('NORMAL')
# Extract the FSR scalar fluxes
fsr_fluxes = get_scalar_fluxes(solver)
# Compute the domain-averaged flux in each energy group
for j, openmc_domain in enumerate(mgxs_lib.domains):
domain_fluxes = fsr_fluxes[fsrs_to_domains == openmc_domain.id, :]
openmoc_fluxes[j, :] = np.mean(domain_fluxes, axis=0)
# Compute SPH factors
old_sph = np.copy(sph)
sph = openmc_fluxes / openmoc_fluxes
sph = np.nan_to_num(sph)
sph[sph == 0.0] = 1.0
# Compute SPH factor residuals
res = np.abs((sph - old_sph) / old_sph)
res = np.nan_to_num(res)
# Extract residuals for fissionable domains only
res = res[sph_to_domain_indices, :]
# Report maximum SPH factor residual
py_printf('NORMAL', 'SPH Iteration %d:\tres = %1.3e', i, res.max())
# Create a new MGXS library with cross sections updated by SPH factors
sph_mgxs_lib = _apply_sph_factors(mgxs_lib, geometry, sph, sph_domains)
# Load the new MGXS library data into the OpenMOC geometry
load_openmc_mgxs_lib(sph_mgxs_lib, geometry)
# Check max SPH factor residual for this domain for convergence
if res.max() < sph_tol and i > 0:
break
# Warn user if SPH factors did not converge
else:
py_printf('WARNING', 'SPH factors did not converge')
# Collect SPH factors for each FSR, energy group
fsrs_to_sph = np.ones((num_fsrs, num_groups), dtype=np.float)
for i, openmc_domain in enumerate(mgxs_lib.domains):
if openmc_domain.id in openmoc_domains:
openmoc_domain = openmoc_domains[openmc_domain.id]
if openmoc_domain.getId() in sph_domains:
fsr_ids = domains_to_fsrs[openmc_domain.id]
fsrs_to_sph[fsr_ids, :] = sph[i, :]
return fsrs_to_sph, sph_mgxs_lib, np.array(sph_to_fsr_indices)
