def _build_inputs(self): # Define materials water = openmc.Material(1) water.add_nuclide('H1', 2.0) water.add_nuclide('O16', 1.0) water.add_nuclide('B10', 0.0001) water.add_s_alpha_beta('c_H_in_H2O') water.set_density('g/cc', 1.0) fuel = openmc.Material(2) fuel.add_nuclide('U235', 1.0) fuel.add_nuclide('Mo99', 0.1) fuel.set_density('g/cc', 4.5) materials = openmc.Materials((water, fuel)) materials.export_to_xml() cyl = openmc.ZCylinder(surface_id=1, r=1.0, boundary_type='vacuum') top_sphere = openmc.Sphere(surface_id=2, z0=5., r=1., boundary_type='vacuum') top_plane = openmc.ZPlane(surface_id=3, z0=5.) bottom_sphere = openmc.Sphere(surface_id=4, z0=-5., r=1., boundary_type='vacuum') bottom_plane = openmc.ZPlane(surface_id=5, z0=-5.) # Define geometry inside_cyl = openmc.Cell(1, fill=fuel, region=-cyl & -top_plane & +bottom_plane) top_hemisphere = openmc.Cell(2, fill=water, region=-top_sphere & +top_plane) bottom_hemisphere = openmc.Cell(3, fill=water, region=-bottom_sphere & -top_plane) root = openmc.Universe(0, cells=(inside_cyl, top_hemisphere, bottom_hemisphere)) geometry = openmc.Geometry(root) geometry.export_to_xml() # Set up stochastic volume calculation ll, ur = root.bounding_box vol_calcs = [ openmc.VolumeCalculation(list(root.cells.values()), 100000), openmc.VolumeCalculation([water, fuel], 100000, ll, ur), openmc.VolumeCalculation([root], 100000, ll, ur) ] # Define settings settings = openmc.Settings() settings.run_mode = 'volume' settings.volume_calculations = vol_calcs settings.export_to_xml()
def test_calc_volumes(run_in_tmpdir, pin_model_attributes, mpi_intracomm): mats, geom, settings, tals, plots, _, _ = pin_model_attributes test_model = openmc.Model(geom, mats, settings, tals, plots) # With no vol calcs, it should fail with pytest.raises(ValueError): test_model.calculate_volumes(output=False) # Add a cell and mat volume calc material_vol_calc = openmc.VolumeCalculation([mats[2]], samples=1000, lower_left=(-.63, -.63, -100.), upper_right=(.63, .63, 100.)) cell_vol_calc = openmc.VolumeCalculation([geom.root_universe.cells[3]], samples=1000, lower_left=(-.63, -.63, -100.), upper_right=(.63, .63, 100.)) test_model.settings.volume_calculations = \ [material_vol_calc, cell_vol_calc] # Now lets compute the volumes and check to see if it was applied # First lets do without using the C-API # Make sure the volumes are unassigned first assert mats[2].volume is None assert geom.root_universe.cells[3].volume is None test_model.calculate_volumes(output=False, apply_volumes=True) # Now let's test that we have volumes assigned; we arent checking the # value, just that the value was changed assert mats[2].volume > 0. assert geom.root_universe.cells[3].volume > 0. # Now reset the values mats[2].volume = None geom.root_universe.cells[3].volume = None # And do again with an initialized library for file in ['volume_1.h5', 'volume_2.h5']: file = Path(file) file.unlink() test_model.init_lib(output=False, intracomm=mpi_intracomm) test_model.calculate_volumes(output=False, apply_volumes=True) assert mats[2].volume > 0. assert geom.root_universe.cells[3].volume > 0. assert openmc.lib.materials[3].volume == mats[2].volume test_model.finalize_lib()
def test_volume(uo2): """Test adding volume information from a volume calculation.""" # Create model with nested spheres model = openmc.model.Model() model.materials.append(uo2) inner = openmc.Sphere(R=1.) outer = openmc.Sphere(R=2., boundary_type='vacuum') c1 = openmc.Cell(fill=uo2, region=-inner) c2 = openmc.Cell(region=+inner & -outer) u = openmc.Universe(cells=[c1, c2]) model.geometry.root_universe = u model.settings.particles = 100 model.settings.batches = 10 model.settings.run_mode = 'fixed source' model.settings.source = openmc.Source(space=openmc.stats.Point()) ll, ur = model.geometry.bounding_box model.settings.volume_calculations for domain in (c1, uo2, u): # Run stochastic volume calculation volume_calc = openmc.VolumeCalculation( domains=[domain], samples=1000, lower_left=ll, upper_right=ur) model.settings.volume_calculations = [volume_calc] model.export_to_xml() openmc.calculate_volumes() # Load results and add volume information volume_calc.load_results('volume_1.h5') model.geometry.add_volume_information(volume_calc) # get_nuclide_densities relies on volume information nucs = set(domain.get_nuclide_densities())
def test_export_to_xml(run_in_tmpdir): s = openmc.Settings() s.run_mode = 'fixed source' s.batches = 1000 s.generations_per_batch = 10 s.inactive = 100 s.particles = 1000000 s.max_lost_particles = 5 s.rel_max_lost_particles = 1e-4 s.keff_trigger = {'type': 'std_dev', 'threshold': 0.001} s.energy_mode = 'continuous-energy' s.max_order = 5 s.source = openmc.Source(space=openmc.stats.Point()) s.output = {'summary': True, 'tallies': False, 'path': 'here'} s.verbosity = 7 s.sourcepoint = { 'batches': [50, 150, 500, 1000], 'separate': True, 'write': True, 'overwrite': True } s.statepoint = {'batches': [50, 150, 500, 1000]} s.surf_source_read = {'path': 'surface_source_1.h5'} s.surf_source_write = {'surface_ids': [2], 'max_particles': 200} s.confidence_intervals = True s.ptables = True s.seed = 17 s.survival_biasing = True s.cutoff = { 'weight': 0.25, 'weight_avg': 0.5, 'energy_neutron': 1.0e-5, 'energy_photon': 1000.0, 'energy_electron': 1.0e-5, 'energy_positron': 1.0e-5 } mesh = openmc.RegularMesh() mesh.lower_left = (-10., -10., -10.) mesh.upper_right = (10., 10., 10.) mesh.dimension = (5, 5, 5) s.entropy_mesh = mesh s.trigger_active = True s.trigger_max_batches = 10000 s.trigger_batch_interval = 50 s.no_reduce = False s.tabular_legendre = {'enable': True, 'num_points': 50} s.temperature = { 'default': 293.6, 'method': 'interpolation', 'multipole': True, 'range': (200., 1000.) } s.trace = (10, 1, 20) s.track = [1, 1, 1, 2, 1, 1] s.ufs_mesh = mesh s.resonance_scattering = { 'enable': True, 'method': 'rvs', 'energy_min': 1.0, 'energy_max': 1000.0, 'nuclides': ['U235', 'U238', 'Pu239'] } s.volume_calculations = openmc.VolumeCalculation(domains=[openmc.Cell()], samples=1000, lower_left=(-10., -10., -10.), upper_right=(10., 10., 10.)) s.create_fission_neutrons = True s.log_grid_bins = 2000 s.photon_transport = False s.electron_treatment = 'led' s.write_initial_source = True # Make sure exporting XML works s.export_to_xml() # Generate settings from XML s = openmc.Settings.from_xml() assert s.run_mode == 'fixed source' assert s.batches == 1000 assert s.generations_per_batch == 10 assert s.inactive == 100 assert s.particles == 1000000 assert s.max_lost_particles == 5 assert s.rel_max_lost_particles == 1e-4 assert s.keff_trigger == {'type': 'std_dev', 'threshold': 0.001} assert s.energy_mode == 'continuous-energy' assert s.max_order == 5 assert isinstance(s.source[0], openmc.Source) assert isinstance(s.source[0].space, openmc.stats.Point) assert s.output == {'summary': True, 'tallies': False, 'path': 'here'} assert s.verbosity == 7 assert s.sourcepoint == { 'batches': [50, 150, 500, 1000], 'separate': True, 'write': True, 'overwrite': True } assert s.statepoint == {'batches': [50, 150, 500, 1000]} assert s.surf_source_read == {'path': 'surface_source_1.h5'} assert s.surf_source_write == {'surface_ids': [2], 'max_particles': 200} assert s.confidence_intervals assert s.ptables assert s.seed == 17 assert s.survival_biasing assert s.cutoff == { 'weight': 0.25, 'weight_avg': 0.5, 'energy_neutron': 1.0e-5, 'energy_photon': 1000.0, 'energy_electron': 1.0e-5, 'energy_positron': 1.0e-5 } assert isinstance(s.entropy_mesh, openmc.RegularMesh) assert s.entropy_mesh.lower_left == [-10., -10., -10.] assert s.entropy_mesh.upper_right == [10., 10., 10.] assert s.entropy_mesh.dimension == [5, 5, 5] assert s.trigger_active assert s.trigger_max_batches == 10000 assert s.trigger_batch_interval == 50 assert not s.no_reduce assert s.tabular_legendre == {'enable': True, 'num_points': 50} assert s.temperature == { 'default': 293.6, 'method': 'interpolation', 'multipole': True, 'range': [200., 1000.] } assert s.trace == [10, 1, 20] assert s.track == [1, 1, 1, 2, 1, 1] assert isinstance(s.ufs_mesh, openmc.RegularMesh) assert s.ufs_mesh.lower_left == [-10., -10., -10.] assert s.ufs_mesh.upper_right == [10., 10., 10.] assert s.ufs_mesh.dimension == [5, 5, 5] assert s.resonance_scattering == { 'enable': True, 'method': 'rvs', 'energy_min': 1.0, 'energy_max': 1000.0, 'nuclides': ['U235', 'U238', 'Pu239'] } assert s.create_fission_neutrons assert s.log_grid_bins == 2000 assert not s.photon_transport assert s.electron_treatment == 'led' assert s.write_initial_source == True assert len(s.volume_calculations) == 1 vol = s.volume_calculations[0] assert vol.domain_type == 'cell' assert len(vol.ids) == 1 assert vol.samples == 1000 assert vol.lower_left == (-10., -10., -10.) assert vol.upper_right == (10., 10., 10.)
def _build_inputs(self): # Define materials water = openmc.Material(1) water.add_nuclide('H1', 2.0) water.add_nuclide('O16', 1.0) water.add_nuclide('B10', 0.0001) if self.is_ce: water.add_s_alpha_beta('c_H_in_H2O') water.set_density('g/cc', 1.0) fuel = openmc.Material(2) fuel.add_nuclide('U235', 1.0) fuel.add_nuclide('Mo99', 0.1) fuel.set_density('g/cc', 4.5) materials = openmc.Materials((water, fuel)) if not self.is_ce: materials.cross_sections = 'mg_lib.h5' materials.export_to_xml() cyl = openmc.ZCylinder(surface_id=1, r=1.0, boundary_type='vacuum') top_sphere = openmc.Sphere(surface_id=2, z0=5., r=1., boundary_type='vacuum') top_plane = openmc.ZPlane(surface_id=3, z0=5.) bottom_sphere = openmc.Sphere(surface_id=4, z0=-5., r=1., boundary_type='vacuum') bottom_plane = openmc.ZPlane(surface_id=5, z0=-5.) # Define geometry inside_cyl = openmc.Cell(1, fill=fuel, region=-cyl & -top_plane & +bottom_plane) top_hemisphere = openmc.Cell(2, fill=water, region=-top_sphere & +top_plane) bottom_hemisphere = openmc.Cell(3, fill=water, region=-bottom_sphere & -top_plane) root = openmc.Universe(0, cells=(inside_cyl, top_hemisphere, bottom_hemisphere)) geometry = openmc.Geometry(root) geometry.export_to_xml() # Set up stochastic volume calculation ll, ur = root.bounding_box vol_calcs = [ openmc.VolumeCalculation(list(root.cells.values()), 100000), openmc.VolumeCalculation([water, fuel], 100000, ll, ur), openmc.VolumeCalculation([root], 100000, ll, ur), openmc.VolumeCalculation(list(root.cells.values()), 100), openmc.VolumeCalculation([water, fuel], 100, ll, ur), openmc.VolumeCalculation(list(root.cells.values()), 100) ] vol_calcs[3].set_trigger(self.exp_std_dev, 'std_dev') vol_calcs[4].set_trigger(self.exp_rel_err, 'rel_err') vol_calcs[5].set_trigger(self.exp_variance, 'variance') # Define settings settings = openmc.Settings() settings.run_mode = 'volume' if not self.is_ce: settings.energy_mode = 'multi-group' settings.volume_calculations = vol_calcs settings.export_to_xml() # Create the MGXS file if necessary if not self.is_ce: groups = openmc.mgxs.EnergyGroups(group_edges=[0., 20.e6]) mg_xs_file = openmc.MGXSLibrary(groups) nu = [2.] fiss = [1.] capture = [1.] absorption_fissile = np.add(fiss, capture) absorption_other = capture scatter = np.array([[[1.]]]) total_fissile = np.add(absorption_fissile, np.sum(scatter[:, :, 0], axis=1)) total_other = np.add(absorption_other, np.sum(scatter[:, :, 0], axis=1)) chi = [1.] for iso in ['H1', 'O16', 'B10', 'Mo99', 'U235']: mat = openmc.XSdata(iso, groups) mat.order = 0 mat.atomic_weight_ratio = \ openmc.data.atomic_mass(iso) / openmc.data.NEUTRON_MASS mat.set_scatter_matrix(scatter) if iso == 'U235': mat.set_nu_fission(np.multiply(nu, fiss)) mat.set_absorption(absorption_fissile) mat.set_total(total_fissile) mat.set_chi(chi) else: mat.set_absorption(absorption_other) mat.set_total(total_other) mg_xs_file.add_xsdata(mat) mg_xs_file.export_to_hdf5('mg_lib.h5')
breeder_blanket_region = +first_wall_outer_surface & -breeder_blanket_outer_surface & +central_shield_outer_surface breeder_blanket_cell = openmc.Cell(region=breeder_blanket_region) breeder_blanket_cell.fill = breeder_material universe = openmc.Universe(cells=[ central_sol_cell, central_shield_cell, inner_vessel_cell, first_wall_cell, breeder_blanket_cell ]) geom = openmc.Geometry(universe) geom.export_to_xml() sphere = openmc.Sphere(r=10.0) cell = openmc.Cell(region=-sphere) vol_calc = openmc.VolumeCalculation(domains=[cell], samples=1000000) # cell_vol_calc = openmc.VolumeCalculation([breeder_blanket_cell], 10000) #SIMULATION SETTINGS# # Instantiate a Settings object sett = openmc.Settings() batches = 2 sett.batches = batches sett.inactive = 1 sett.particles = 50 sett.run_mode = 'fixed source' # Create a DT point source source = openmc.Source()
def _pre_run(self, root_cell): MC_input_path = self.MC_input_path pre_run_path = os.getcwd() +'/pre_run' try: shutil.rmtree(pre_run_path) except OSError: pass os.mkdir(pre_run_path) # Prepare the volume calculation #bounding_box = root_cell.bounding_box ll = self.bounding_box[0] ur = self.bounding_box[1] cell_dict = root_cell.get_all_cells() cell_list = utils.cell_dict_to_cell_list(cell_dict) cell_list.append(root_cell) # Add root_cell so that the total volume is calculated vol1 = openmc.VolumeCalculation(cell_list, 100000, lower_left = ll, upper_right = ur) settings = openmc.Settings() settings.volume_calculations = [vol1] settings.temperature = {'method':'interpolation'} settings.run_mode='volume' settings.export_to_xml(path = pre_run_path + '/settings.xml') # Copy the geometry and material file to the new dummy dir shutil.copyfile(MC_input_path + '/geometry.xml', pre_run_path + '/geometry.xml') shutil.copyfile(MC_input_path + '/materials.xml', pre_run_path + '/materials.xml') # By default, the openm_exec is set to 'openmc' # For some reasons, this does not work on the cluster (della) # On della, we need to explicitly define the absolute path to the bin we want to use # Right now a temporary path that depends on my installation is used #openmc.calculate_volumes(cwd = pre_run_path, openmc_exec='/tigress/jdtdl/openmc/py3-mpi-190324/bin/openmc') openmc.calculate_volumes(cwd = pre_run_path, openmc_exec=self.openmc_bin_path) #openmc.run() # Read and set initial nuclides dict self.set_init_nucl_dict(root_cell) # # Read each material object and add 1atm nuclides chosen by the user # if self.mode == 'no_const_lib': # self.add_zero_dens_nuclides(self.nucl_list_dict) self._set_initial_summary(pre_run_path) self._set_cross_sections_path(pre_run_path) # Read cross sections xml files, create MC_XS_nucl_list self.set_MC_XS_nucl_list() self.set_root_universe() root_cell_name = 'root cell' # need to be specified by the user at some point self._set_root_cell(root_cell_name) # Extract cells from summary, add 1 atm nuclides to their material self._change_cell_materials() # Read and distribute volumes to cells self.set_vol_to_cell(vol1, pre_run_path) # pdb.set_trace() shutil.rmtree(pre_run_path)
first_wall_cell = openmc.Cell(region=first_wall_region) first_wall_cell.fill = firstwall_material breeder_blanket_region = +first_wall_outer_surface & -breeder_blanket_outer_surface breeder_blanket_cell = openmc.Cell(region=breeder_blanket_region) breeder_blanket_cell.fill = breeder_material universe = openmc.Universe(cells=[inner_vessel_cell, first_wall_cell, breeder_blanket_cell]) geom = openmc.Geometry(universe) geom.export_to_xml() # volume calculates for materials require a bounding box lower_left = (-1000, -1000, -1000.) upper_right = (1000, 1000, 1000.) material_vol_calc = openmc.VolumeCalculation([firstwall_material, breeder_material], 100000, lower_left, upper_right) cell_vol_calc = openmc.VolumeCalculation([inner_vessel_cell, first_wall_cell, breeder_blanket_cell], 100000) settings = openmc.Settings() settings.volume_calculations = [cell_vol_calc, material_vol_calc] settings.run_mode = 'volume' settings.export_to_xml() openmc.run() cell_vol_calc_results = openmc.VolumeCalculation.from_hdf5('volume_1.h5') print('\ninner_vessel_cell volume', cell_vol_calc_results.volumes[1], 'cm3') print('first_wall_cell volume', cell_vol_calc_results.volumes[2], 'cm3') print('breeder_blanket_cell volume', cell_vol_calc_results.volumes[3], 'cm3\n')