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)