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)