import openmoc import _openmoc_intel_double from openmoc_intel_double import * import signal # Tell Python to recognize CTRL+C and stop the C++ extension module # when this is passed in from the keyboard signal.signal(signal.SIGINT, signal.SIG_DFL) set_log_level(str(openmoc.get_log_level())) set_output_directory(openmoc.get_output_directory()) set_log_filename(openmoc.get_log_filename()) Timer = openmoc.Timer
def test_log_level(self):
# Test setting log levels with the openmoc logs
openmoc.set_log_level(openmoc.DEBUG)
self.assertEqual(openmoc.get_log_level(), 0)
openmoc.set_log_level(openmoc.INFO)
self.assertEqual(openmoc.get_log_level(), 1)
openmoc.set_log_level(openmoc.NORMAL)
self.assertEqual(openmoc.get_log_level(), 3)
openmoc.set_log_level(openmoc.SEPARATOR)
self.assertEqual(openmoc.get_log_level(), 5)
openmoc.set_log_level(openmoc.HEADER)
self.assertEqual(openmoc.get_log_level(), 6)
openmoc.set_log_level(openmoc.TITLE)
self.assertEqual(openmoc.get_log_level(), 7)
openmoc.set_log_level(openmoc.WARNING)
self.assertEqual(openmoc.get_log_level(), 8)
openmoc.set_log_level(openmoc.CRITICAL)
self.assertEqual(openmoc.get_log_level(), 10)
openmoc.set_log_level(openmoc.RESULT)
self.assertEqual(openmoc.get_log_level(), 11)
openmoc.set_log_level(openmoc.UNITTEST)
self.assertEqual(openmoc.get_log_level(), 12)
openmoc.set_log_level(openmoc.ERROR)
self.assertEqual(openmoc.get_log_level(), 13)
# Setting log level with an integer
openmoc.set_log_level(3)
self.assertEqual(openmoc.get_log_level(), 3)
import signal, sys import _openmoc_intel_double # For Python 2.X.X if (sys.version_info[0] == 2): import openmoc from openmoc_intel_double import * # For Python 3.X.X else: import openmoc.openmoc as openmoc from openmoc.intel.double.openmoc_intel_double import * # Tell Python to recognize CTRL+C and stop the C++ extension module # when this is passed in from the keyboard signal.signal(signal.SIGINT, signal.SIG_DFL) set_log_level(str(openmoc.get_log_level())) set_output_directory(openmoc.get_output_directory()) set_log_filename(openmoc.get_log_filename()) Timer = openmoc.Timer
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)
