def mixed_lattice_model(uo2, water): cyl = openmc.ZCylinder(r=0.4) c1 = openmc.Cell(fill=uo2, region=-cyl) c1.temperature = 600.0 c2 = openmc.Cell(fill=water, region=+cyl) pin = openmc.Universe(cells=[c1, c2]) empty = openmc.Cell() empty_univ = openmc.Universe(cells=[empty]) hex_lattice = openmc.HexLattice() hex_lattice.center = (0.0, 0.0) hex_lattice.pitch = (1.2, 10.0) outer_ring = [pin]*6 inner_ring = [empty_univ] axial_level = [outer_ring, inner_ring] hex_lattice.universes = [axial_level]*3 hex_lattice.outer = empty_univ cell_hex = openmc.Cell(fill=hex_lattice) u = openmc.Universe(cells=[cell_hex]) rotated_cell_hex = openmc.Cell(fill=u) rotated_cell_hex.rotation = (0., 0., 30.) ur = openmc.Universe(cells=[rotated_cell_hex]) d = 6.0 rect_lattice = openmc.RectLattice() rect_lattice.lower_left = (-d, -d) rect_lattice.pitch = (d, d) rect_lattice.outer = empty_univ rect_lattice.universes = [ [ur, empty_univ], [empty_univ, u] ] xmin = openmc.XPlane(-d, boundary_type='periodic') xmax = openmc.XPlane(d, boundary_type='periodic') xmin.periodic_surface = xmax ymin = openmc.YPlane(-d, boundary_type='periodic') ymax = openmc.YPlane(d, boundary_type='periodic') main_cell = openmc.Cell(fill=rect_lattice, region=+xmin & -xmax & +ymin & -ymax) # Create geometry and use unique material in each fuel cell geometry = openmc.Geometry([main_cell]) geometry.determine_paths() c1.fill = [water.clone() for i in range(c1.num_instances)] return openmc.model.Model(geometry)
def test_get_by_name(): m1 = openmc.Material(name='zircaloy') m1.add_element('Zr', 1.0) m2 = openmc.Material(name='Zirconium') m2.add_element('Zr', 1.0) c1 = openmc.Cell(fill=m1, name='cell1') u1 = openmc.Universe(name='Zircaloy universe', cells=[c1]) cyl = openmc.ZCylinder() c2 = openmc.Cell(fill=u1, region=-cyl, name='cell2') c3 = openmc.Cell(fill=m2, region=+cyl, name='Cell3') root = openmc.Universe(name='root Universe', cells=[c2, c3]) geom = openmc.Geometry(root) mats = set(geom.get_materials_by_name('zirc')) assert not mats ^ {m1, m2} mats = set(geom.get_materials_by_name('zirc', True)) assert not mats ^ {m1} mats = set(geom.get_materials_by_name('zirconium', False, True)) assert not mats ^ {m2} mats = geom.get_materials_by_name('zirconium', True, True) assert not mats cells = set(geom.get_cells_by_name('cell')) assert not cells ^ {c1, c2, c3} cells = set(geom.get_cells_by_name('cell', True)) assert not cells ^ {c1, c2} cells = set(geom.get_cells_by_name('cell3', False, True)) assert not cells ^ {c3} cells = geom.get_cells_by_name('cell3', True, True) assert not cells cells = set(geom.get_cells_by_fill_name('Zircaloy')) assert not cells ^ {c1, c2} cells = set(geom.get_cells_by_fill_name('Zircaloy', True)) assert not cells ^ {c2} cells = set(geom.get_cells_by_fill_name('Zircaloy', False, True)) assert not cells ^ {c1} cells = geom.get_cells_by_fill_name('Zircaloy', True, True) assert not cells univs = set(geom.get_universes_by_name('universe')) assert not univs ^ {u1, root} univs = set(geom.get_universes_by_name('universe', True)) assert not univs ^ {u1} univs = set(geom.get_universes_by_name('universe', True, True)) assert not univs
def _make_outer_mg_universe(outmat): cell = openmc.Cell(cell_id=100000) univ = openmc.Universe(universe_id=100000) cell.fill = outmat univ.add_cell(cell) outsurface = openmc.ZCylinder(R=175.25, name='Reactor preasure vessel out', boundary_type = 'vacuum') return univ, outsurface
def materials(tmpdir_factory): """Use C API to construct realistic materials for testing tallies""" tmpdir = tmpdir_factory.mktemp("lib") orig = tmpdir.chdir() # Create proxy problem to please openmc mfuel = openmc.Material(name="test_fuel") mfuel.volume = 1.0 for nuclide in ["U235", "U238", "Xe135", "Pu239"]: mfuel.add_nuclide(nuclide, 1.0) openmc.Materials([mfuel]).export_to_xml() # Geometry box = openmc.rectangular_prism(1.0, 1.0, boundary_type="reflective") cell = openmc.Cell(fill=mfuel, region=box) root = openmc.Universe(cells=[cell]) openmc.Geometry(root).export_to_xml() # settings settings = openmc.Settings() settings.particles = 100 settings.inactive = 0 settings.batches = 10 settings.verbosity = 1 settings.export_to_xml() try: with lib.run_in_memory(): yield [lib.Material(), lib.Material()] finally: # Convert to strings as os.remove in py 3.5 doesn't support Paths for file_path in ("settings.xml", "geometry.xml", "materials.xml", "summary.h5"): os.remove(str(tmpdir / file_path)) orig.chdir() os.rmdir(str(tmpdir))
def test_transfer_volumes(run_in_tmpdir): """Unit test of volume transfer in restart calculations.""" op = dummy_operator.DummyOperator() op.output_dir = "test_transfer_volumes" # Perform simulation using the predictor algorithm dt = [0.75] power = 1.0 PredictorIntegrator(op, dt, power).integrate() # Load the files res = openmc.deplete.ResultsList.from_hdf5(op.output_dir / "depletion_results.h5") # Create a dictionary of volumes to transfer res[0].volume['1'] = 1.5 res[0].volume['2'] = 2.5 # Create dummy geometry mat1 = openmc.Material(material_id=1) mat1.depletable = True mat2 = openmc.Material(material_id=2) cell = openmc.Cell() cell.fill = [mat1, mat2] root = openmc.Universe() root.add_cell(cell) geometry = openmc.Geometry(root) # Transfer volumes res[0].transfer_volumes(openmc.Model(geometry)) assert mat1.volume == 1.5 assert mat2.volume is None
def _add_dummy_universe(self): """ Adds all-water universe for empty lattice positions""" self.u_waterPin = openmc.Universe(name='Dummy Water Universe') self.c_water = openmc.Cell(name='Water', fill=self.mats['Borated Water']) self.u_waterPin.add_cells([self.c_water])
def buildTriangUni(modSetting,pitch,diameter,boron,modT,fuelT,DyFrac,enrich): uo2=getU(fuelT,DyFrac,enrich) mod=getMod(modSetting,boron,modT) #loads the moderator mats = openmc.Materials([uo2, mod]) mats.export_to_xml() ####################build the surfaces################################ fuel_or1 = openmc.ZCylinder(R=diameter/2) box = openmc.get_hexagonal_prism(edge_length=pitch/math.sqrt(3.0),boundary_type='reflective') #################Build the Cells ####################################### fuel_region = -fuel_or1 #beautiful abuse of operator overloading mod_region = box & +fuel_or1 # c # c Fuel # c # c throwback to MCNP fuel = openmc.Cell(1, 'fuel') fuel.fill = uo2 fuel.region = fuel_region # # Moderator # moderator = openmc.Cell(4, 'moderator') moderator.fill = mod moderator.region = mod_region #I am groot! groot = openmc.Universe(cells=(fuel, moderator)) geom = openmc.Geometry(groot) geom.export_to_xml() cell_filter = openmc.CellFilter([fuel, moderator]) # tallies buildTallies(cell_filter) return (fuel,moderator)
def uo2_trigger_model(): """Set up a simple UO2 model with k-eff trigger""" model = openmc.model.Model() m = openmc.Material(name='UO2') m.add_nuclide('U235', 1.0) m.add_nuclide('O16', 2.0) m.set_density('g/cm3', 10.0) model.materials.append(m) cyl = openmc.ZCylinder(r=1.0, boundary_type='vacuum') c = openmc.Cell(fill=m, region=-cyl) model.geometry.root_universe = openmc.Universe(cells=[c]) model.settings.batches = 10 model.settings.inactive = 5 model.settings.particles = 100 model.settings.source = openmc.Source(space=openmc.stats.Box( [-0.5, -0.5, -1], [0.5, 0.5, 1], only_fissionable=True)) model.settings.verbosity = 1 model.settings.keff_trigger = {'type': 'std_dev', 'threshold': 0.001} model.settings.trigger_active = True model.settings.trigger_max_batches = 10 model.settings.trigger_batch_interval = 1 # Write XML files in tmpdir with cdtemp(): model.export_to_xml() yield
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 build_default_materials_and_geometry(self): # Define materials needed for 1D/1G slab problem uo2_data = openmc.Macroscopic('uo2_iso', '71c') uo2 = openmc.Material(name='UO2', material_id=1) uo2.set_density('macro', 1.0) uo2.add_macroscopic(uo2_data) clad_data = openmc.Macroscopic('clad_ang_mu', '71c') clad = openmc.Material(name='Clad', material_id=2) clad.set_density('macro', 1.0) clad.add_macroscopic(clad_data) water_data = openmc.Macroscopic('lwtr_iso_mu', '71c') water = openmc.Material(name='LWTR', material_id=3) water.set_density('macro', 1.0) water.add_macroscopic(water_data) # Define the materials file. self.materials.default_xs = '71c' self.materials += (uo2, clad, water) # Define surfaces. # Assembly/Problem Boundary left = openmc.XPlane(x0=0.0, surface_id=200, boundary_type='reflective') right = openmc.XPlane(x0=10.0, surface_id=201, boundary_type='reflective') bottom = openmc.YPlane(y0=0.0, surface_id=300, boundary_type='reflective') top = openmc.YPlane(y0=10.0, surface_id=301, boundary_type='reflective') down = openmc.ZPlane(z0=0.0, surface_id=0, boundary_type='reflective') fuel_clad_intfc = openmc.ZPlane(z0=2.0, surface_id=1) clad_lwtr_intfc = openmc.ZPlane(z0=2.4, surface_id=2) up = openmc.ZPlane(z0=5.0, surface_id=3, boundary_type='reflective') # Define cells c1 = openmc.Cell(cell_id=1) c1.region = +left & -right & +bottom & -top & +down & -fuel_clad_intfc c1.fill = uo2 c2 = openmc.Cell(cell_id=2) c2.region = +left & -right & +bottom & -top & +fuel_clad_intfc & -clad_lwtr_intfc c2.fill = clad c3 = openmc.Cell(cell_id=3) c3.region = +left & -right & +bottom & -top & +clad_lwtr_intfc & -up c3.fill = water # Define root universe. root = openmc.Universe(universe_id=0, name='root universe') root.add_cells((c1, c2, c3)) # Assign root universe to geometry self.geometry.root_universe = root
def _read_universes(self): self.n_universes = self._f['geometry/n_universes'].value # Initialize dictionary for each Universe # Keys - Universe keys # Values - Universe objects self.universes = {} for key in self._f['geometry/universes'].keys(): if key == 'n_universes': continue universe_id = int(key.lstrip('universe ')) index = self._f['geometry/universes'][key]['index'].value cells = self._f['geometry/universes'][key]['cells'][...] # Create this Universe universe = openmc.Universe(universe_id=universe_id) # Add each Cell to the Universe for cell_id in cells: cell = self.cells[cell_id] universe.add_cell(cell) # Add the Universe to the global list of Universes self.universes[index] = universe
def build(self): # All cylinders fcyl = openmc.ZCylinder(R=self.rfuel, name="Fuel Cylinder") gcyl = openmc.ZCylinder(R=self.rgap, name="Gap Cylinder") ccyl = openmc.ZCylinder(R=self.rclad, name="Clad Cylinder") # Innermost ring: plain fuel fring = openmc.Cell() fring.region = -fcyl fring.fill = self.fuel_mat # Next ring: gap gring = openmc.Cell() gring.region = +fcyl & -gcyl gring.fill = self.gap_mat # probably void # Next ring: clad cring = openmc.Cell() cring.region = +gcyl & -ccyl cring.fill = self.clad_mat # Outside: moderator moderator = openmc.Cell() moderator.region = +ccyl moderator.fill = self.mod_mat # Finalize pincell_universe = openmc.Universe(name="Pincell") pincell_universe.add_cells((fring, gring, cring, moderator)) return pincell_universe
def test_fixed_source(): mat = openmc.Material() mat.add_nuclide('O16', 1.0) mat.add_nuclide('U238', 0.0001) mat.set_density('g/cc', 7.5) surf = openmc.Sphere(r=10.0, boundary_type='vacuum') cell = openmc.Cell(fill=mat, region=-surf) model = openmc.model.Model() model.geometry.root_universe = openmc.Universe(cells=[cell]) model.materials.append(mat) model.settings.run_mode = 'fixed source' model.settings.batches = 10 model.settings.particles = 100 model.settings.temperature = {'default': 294} model.settings.source = openmc.Source(space=openmc.stats.Point(), strength=10.0) tally = openmc.Tally() tally.scores = ['flux'] model.tallies.append(tally) harness = FixedSourceTestHarness('statepoint.10.h5', model) harness.main()
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_get_all_cells(): cells = [openmc.Cell() for i in range(5)] cells2 = [openmc.Cell() for i in range(3)] cells[0].fill = openmc.Universe(cells=cells2) geom = openmc.Geometry(cells) all_cells = set(geom.get_all_cells().values()) assert not all_cells ^ set(cells + cells2)
def build_default_materials_and_geometry(self): # Define materials. fuel = openmc.Material(name='Fuel') fuel.set_density('g/cm3', 10.29769) fuel.add_nuclide("U234", 4.4843e-6) fuel.add_nuclide("U235", 5.5815e-4) fuel.add_nuclide("U238", 2.2408e-2) fuel.add_nuclide("O16", 4.5829e-2) clad = openmc.Material(name='Cladding') clad.set_density('g/cm3', 6.55) clad.add_nuclide("Zr90", 2.1827e-2) clad.add_nuclide("Zr91", 4.7600e-3) clad.add_nuclide("Zr92", 7.2758e-3) clad.add_nuclide("Zr94", 7.3734e-3) clad.add_nuclide("Zr96", 1.1879e-3) hot_water = openmc.Material(name='Hot borated water') hot_water.set_density('g/cm3', 0.740582) hot_water.add_nuclide("H1", 4.9457e-2) hot_water.add_nuclide("O16", 2.4672e-2) hot_water.add_nuclide("B10", 8.0042e-6) hot_water.add_nuclide("B11", 3.2218e-5) hot_water.add_s_alpha_beta('c_H_in_H2O') # Define the materials file. self.materials += (fuel, clad, hot_water) # Instantiate ZCylinder surfaces fuel_or = openmc.ZCylinder(x0=0, y0=0, R=0.39218, name='Fuel OR') clad_or = openmc.ZCylinder(x0=0, y0=0, R=0.45720, name='Clad OR') left = openmc.XPlane(x0=-0.63, name='left', boundary_type='reflective') right = openmc.XPlane(x0=0.63, name='right', boundary_type='reflective') bottom = openmc.YPlane(y0=-0.63, name='bottom', boundary_type='reflective') top = openmc.YPlane(y0=0.63, name='top', boundary_type='reflective') # Instantiate Cells fuel_pin = openmc.Cell(name='cell 1', fill=fuel) cladding = openmc.Cell(name='cell 3', fill=clad) water = openmc.Cell(name='cell 2', fill=hot_water) # Use surface half-spaces to define regions fuel_pin.region = -fuel_or cladding.region = +fuel_or & -clad_or water.region = +clad_or & +left & -right & +bottom & -top # Instantiate Universe root = openmc.Universe(universe_id=0, name='root universe') # Register Cells with Universe root.add_cells([fuel_pin, cladding, water]) # Instantiate a Geometry, register the root Universe, and export to XML self.geometry.root_universe = root
def test_pins_of_universes(pin_mats, good_radii): """Build a pin with a Universe in one ring""" u1 = openmc.Universe(cells=[openmc.Cell(fill=pin_mats[1])]) new_items = pin_mats[:1] + (u1, ) + pin_mats[2:] new_pin = pin([openmc.ZCylinder(r=r) for r in good_radii], new_items, subdivisions={0: 2}, divide_vols=True) assert len(new_pin.cells) == len(pin_mats) + 1
def pincell1(uo2, water): cyl = openmc.ZCylinder(r=0.35) fuel = openmc.Cell(fill=uo2, region=-cyl) moderator = openmc.Cell(fill=water, region=+cyl) univ = openmc.Universe(cells=[fuel, moderator]) univ.fuel = fuel univ.moderator = moderator return univ
def from_hdf5(cls, filename): """Load stochastic volume calculation results from HDF5 file. Parameters ---------- filename : str Path to volume.h5 file Returns ------- openmc.VolumeCalculation Results of the stochastic volume calculation """ with h5py.File(filename, 'r') as f: cv.check_filetype_version(f, "volume", _VERSION_VOLUME) domain_type = f.attrs['domain_type'].decode() samples = f.attrs['samples'] lower_left = f.attrs['lower_left'] upper_right = f.attrs['upper_right'] volumes = {} atoms = {} ids = [] for obj_name in f: if obj_name.startswith('domain_'): domain_id = int(obj_name[7:]) ids.append(domain_id) group = f[obj_name] volume = tuple(group['volume'].value) nucnames = group['nuclides'].value atoms_ = group['atoms'].value atom_dict = OrderedDict() for name_i, atoms_i in zip(nucnames, atoms_): atom_dict[name_i.decode()] = tuple(atoms_i) volumes[domain_id] = volume atoms[domain_id] = atom_dict # Instantiate some throw-away domains that are used by the constructor # to assign IDs with warnings.catch_warnings(): warnings.simplefilter('ignore', openmc.IDWarning) if domain_type == 'cell': domains = [openmc.Cell(uid) for uid in ids] elif domain_type == 'material': domains = [openmc.Material(uid) for uid in ids] elif domain_type == 'universe': domains = [openmc.Universe(uid) for uid in ids] # Instantiate the class and assign results vol = cls(domains, samples, lower_left, upper_right) vol.volumes = volumes vol.atoms = atoms return vol
def _build_inputs(self): # Instantiate some Macroscopic Data uo2_data = openmc.Macroscopic('UO2') # Instantiate some Materials and register the appropriate objects mat = openmc.Material(material_id=1, name='UO2 fuel') mat.set_density('macro', 1.0) mat.add_macroscopic(uo2_data) # Instantiate a Materials collection and export to XML materials_file = openmc.Materials([mat]) materials_file.cross_sections = "./mgxs.h5" materials_file.export_to_xml() # Instantiate ZCylinder surfaces left = openmc.XPlane(surface_id=4, x0=-5., name='left') right = openmc.XPlane(surface_id=5, x0=5., name='right') bottom = openmc.YPlane(surface_id=6, y0=-5., name='bottom') top = openmc.YPlane(surface_id=7, y0=5., name='top') left.boundary_type = 'reflective' right.boundary_type = 'vacuum' top.boundary_type = 'reflective' bottom.boundary_type = 'reflective' # Instantiate Cells fuel = openmc.Cell(cell_id=1, name='cell 1') # Use surface half-spaces to define regions fuel.region = +left & -right & +bottom & -top # Register Materials with Cells fuel.fill = mat # Instantiate Universe root = openmc.Universe(universe_id=0, name='root universe') # Register Cells with Universe root.add_cells([fuel]) # Instantiate a Geometry, register the root Universe, and export to XML geometry = openmc.Geometry(root) geometry.export_to_xml() settings_file = openmc.Settings() settings_file.energy_mode = "multi-group" settings_file.batches = batches settings_file.inactive = inactive settings_file.particles = particles # Create an initial uniform spatial source distribution bounds = [-5, -5, -5, 5, 5, 5] uniform_dist = openmc.stats.Box(bounds[:3], bounds[3:]) settings_file.source = openmc.source.Source(space=uniform_dist) settings_file.export_to_xml()
def _make_outer_universe(): mat = openmc.Material(material_id=100000) mat.set_density('g/cm3',0.88) mat.add_nuclide("Na23", 1.0) cell = openmc.Cell(cell_id=100000) univ = openmc.Universe(universe_id=100000) cell.fill = mat univ.add_cell(cell) outsurface = openmc.ZCylinder(R=175.25, name='Reactor preasure vessel out', boundary_type = 'vacuum') return univ, outsurface
def guide_tube_pin(): """Returns a control rod guide tube universe.""" gt_inner_cell = openmc.Cell(fill=hot_water, region=-fuel_or) gt_clad_cell = openmc.Cell(fill=clad, region=+fuel_or & -clad_or) gt_outer_cell = openmc.Cell(fill=hot_water, region=+clad_or) univ = openmc.Universe(name='Guide Tube') univ.add_cells([gt_inner_cell, gt_clad_cell, gt_outer_cell]) return univ
def fuel_pin(): """Returns a fuel pin universe.""" fuel_cell = openmc.Cell(fill=fuel, region=-fuel_or) clad_cell = openmc.Cell(fill=clad, region=+fuel_or & -clad_or) hot_water_cell = openmc.Cell(fill=hot_water, region=+clad_or) univ = openmc.Universe(name='Fuel Pin') univ.add_cells([fuel_cell, clad_cell, hot_water_cell]) return univ
def test_rotation(): u = openmc.Universe() c = openmc.Cell(fill=u) c.rotation = (180.0, 0.0, 0.0) assert np.allclose(c.rotation_matrix, [[1., 0., 0.], [0., -1., 0.], [0., 0., -1.]]) c.rotation = (0.0, 90.0, 0.0) assert np.allclose(c.rotation_matrix, [[0., 0., -1.], [0., 1., 0.], [1., 0., 0.]])
def _build_inputs(self): # Define materials water = openmc.Material(1) water.add_nuclide('H1', 2.0) water.add_nuclide('O16', 1.0) 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.set_density('g/cc', 4.5) materials = openmc.Materials((water, fuel)) materials.default_temperature = '294K' materials.export_to_xml() # Define the geometry. Note that this geometry is somewhat non-sensical # (it essentially defines a circle of half-cylinders), but it is # designed so that periodic and reflective BCs will give different # answers. theta1 = (-1 / 6 + 1 / 2) * np.pi theta2 = (1 / 6 - 1 / 2) * np.pi plane1 = openmc.Plane(a=np.cos(theta1), b=np.sin(theta1), boundary_type='periodic') plane2 = openmc.Plane(a=np.cos(theta2), b=np.sin(theta2), boundary_type='periodic') x_max = openmc.XPlane(x0=5., boundary_type='reflective') z_cyl = openmc.ZCylinder(x0=3 * np.cos(np.pi / 6), y0=3 * np.sin(np.pi / 6), r=2.0) outside_cyl = openmc.Cell(1, fill=water, region=(+plane1 & +plane2 & -x_max & +z_cyl)) inside_cyl = openmc.Cell(2, fill=fuel, region=(+plane1 & +plane2 & -z_cyl)) root_universe = openmc.Universe(0, cells=(outside_cyl, inside_cyl)) geometry = openmc.Geometry() geometry.root_universe = root_universe geometry.export_to_xml() # Define settings settings = openmc.Settings() settings.particles = 1000 settings.batches = 4 settings.inactive = 0 settings.source = openmc.Source( space=openmc.stats.Box((0, 0, 0), (5, 5, 0))) settings.export_to_xml()
def test_from_geometry(): width = 25. s = openmc.Sphere(r=width / 2, boundary_type='vacuum') c = openmc.Cell(region=-s) univ = openmc.Universe(cells=[c]) geom = openmc.Geometry(univ) for basis in ('xy', 'yz', 'xz'): plot = openmc.Plot.from_geometry(geom, basis) assert plot.origin == pytest.approx((0., 0., 0.)) assert plot.width == pytest.approx((width, width))
def __init__(self, root=None): self._root_universe = None self._offsets = {} if root is not None: if isinstance(root, openmc.Universe): self.root_universe = root else: univ = openmc.Universe() for cell in root: univ.add_cell(cell) self._root_universe = univ
def model(request): openmc.reset_auto_ids() marker = request.node.get_closest_marker("surf_source_op") surf_source_op = marker.args[0] openmc_model = openmc.model.Model() # Materials # None # Geometry # Concentric void spheres # - Innermost sphere to bank surface sources # - Second shell to tally cell flux # - Outermost sphere as vacuum boundary sph_1 = openmc.Sphere(r=1.0) # Surface to bank/write sources. sph_2 = openmc.Sphere(r=2.0) sph_3 = openmc.Sphere(r=2.5) sph_4 = openmc.Sphere(r=4.0, boundary_type='vacuum') cell_1 = openmc.Cell(region=-sph_1) cell_2 = openmc.Cell(region=+sph_1 & -sph_2) cell_3 = openmc.Cell(region=+sph_2 & -sph_3) # Cell to tally flux. cell_4 = openmc.Cell(region=+sph_3 & -sph_4) root = openmc.Universe(cells=[cell_1, cell_2, cell_3, cell_4]) openmc_model.geometry = openmc.Geometry(root) # Settings openmc_model.settings.run_mode = 'fixed source' openmc_model.settings.particles = 1000 openmc_model.settings.batches = 10 openmc_model.settings.seed = 1 if surf_source_op == 'write': point = openmc.stats.Point((0, 0, 0)) pt_src = openmc.Source(space=point) openmc_model.settings.source = pt_src openmc_model.settings.surf_source_write = { 'surface_ids': [1], 'max_particles': 1000 } elif surf_source_op == 'read': openmc_model.settings.surf_source_read = { 'path': 'surface_source_true.h5' } # Tallies tal = openmc.Tally() cell_filter = openmc.CellFilter(cell_3) tal.filters = [cell_filter] tal.scores = ['flux'] openmc_model.tallies.append(tal) return openmc_model
def test_create_xml(cell_with_lattice): cells = [openmc.Cell() for i in range(5)] u = openmc.Universe(cells=cells) geom = ET.Element('geom') u.create_xml_subelement(geom) cell_elems = geom.findall('cell') assert len(cell_elems) == len(cells) assert all(c.get('universe') == str(u.id) for c in cell_elems) assert not (set(c.get('id') for c in cell_elems) ^ set(str(c.id) for c in cells))
def test_clone(): c1 = openmc.Cell() c2 = openmc.Cell() root = openmc.Universe(cells=[c1, c2]) geom = openmc.Geometry(root) clone = geom.clone() root_clone = clone.root_universe assert root.id != root_clone.id assert not (set(root.cells) & set(root_clone.cells))