diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e4a95aa..bebf61d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -15,10 +15,11 @@ jobs: with: auto-update-conda: true environment-file: environment.yml - activate-environment: libra-run-env + activate-environment: BABY_1l_LiPb - # example how to run a notebook - # - name: Run tritium model - # shell: bash -l {0} - # working-directory: analysis/tritium - # run: jupyter-nbconvert --to notebook tritium_model.ipynb --execute + - name: Run neutronics model + shell: bash -l {0} + working-directory: analysis/neutron + run: | + python openmc_model_PbLi.py + jupyter-nbconvert --to notebook postprocessing.ipynb --execute diff --git a/README.md b/README.md index 211ecd7..6e46a24 100644 --- a/README.md +++ b/README.md @@ -24,13 +24,13 @@ conda env create -f environment.yml ## Todo list: - [ ] [Link to Zenodo](https://zenodo.org/) -- [ ] Change environment name in [`environment.yml`](environment.yml) -- [ ] Change environment name in [CI workflows](.github/workflows) +- [x] Change environment name in [`environment.yml`](environment.yml) +- [x] Change environment name in [CI workflows](.github/workflows) - [ ] Modify [binder](https://mybinder.org/) badge by inserting the repo name - [ ] Add general run data to [`data/general.json`](data/general.json) - [ ] Add LSC data to [`data/tritium_detection`](data/tritium_detection) - [ ] Add neutron detection data to [`data/neutron_detection`](data/neutron_detection) -- [ ] Add OpenMC model to [`analysis/neutron`](analysis/neutron) +- [x] Add OpenMC model to [`analysis/neutron`](analysis/neutron) - [ ] Add Tritium model to [`analysis/tritium`](analysis/tritium) - [ ] Add the right version tags to [`environment.yml`](environment.yml) - [ ] Add and update information in the README diff --git a/analysis/neutron/.gitignore b/analysis/neutron/.gitignore new file mode 100644 index 0000000..45db49c --- /dev/null +++ b/analysis/neutron/.gitignore @@ -0,0 +1,2 @@ +*.h5 +*.xml \ No newline at end of file diff --git a/analysis/neutron/cross_sections/.gitignore b/analysis/neutron/cross_sections/.gitignore new file mode 100644 index 0000000..45db49c --- /dev/null +++ b/analysis/neutron/cross_sections/.gitignore @@ -0,0 +1,2 @@ +*.h5 +*.xml \ No newline at end of file diff --git a/analysis/neutron/helpers.py b/analysis/neutron/helpers.py new file mode 100644 index 0000000..b8844a0 --- /dev/null +++ b/analysis/neutron/helpers.py @@ -0,0 +1,59 @@ +import math +import openmc + + +def get_exp_cllif_density(temp, LiCl_frac=0.695): + """Calculates density of ClLiF [g/cc] from temperature in Celsius + and molar concentration of LiCl. Valid for 660 C - 1000 C. + Source: + G. J. Janz, R. P. T. Tomkins, C. B. Allen; + Molten Salts: Volume 4, Part 4 + Mixed Halide Melts Electrical Conductance, Density, Viscosity, and Surface Tension Data. + J. Phys. Chem. Ref. Data 1 January 1979; 8 (1): 125–302. + https://doi.org/10.1063/1.555590 + """ + temp = temp + 273.15 # Convert temperature from Celsius to Kelvin + C = LiCl_frac * 100 # Convert molar concentration to molar percent + + a = 2.25621 + b = -8.20475e-3 + c = -4.09235e-4 + d = 6.37250e-5 + e = -2.52846e-7 + f = 8.73570e-9 + g = -5.11184e-10 + + rho = a + b * C + c * temp + d * C**2 + e * C**3 + f * temp * C**2 + g * C * temp**2 + + return rho + + +def calculate_cylinder_volume(radius, height): + volume = math.pi * radius**2 * height + return volume + + +def translate_surface( + surface: ( + openmc.XPlane | openmc.YPlane | openmc.ZPlane | openmc.Plane | openmc.Sphere + ), + dx: float, + dy: float, + dz: float, +) -> openmc.Surface: + """Translate an OpenMC surface by dx, dy, dz.""" + if isinstance(surface, openmc.XPlane): + surface.x0 += dx + elif isinstance(surface, openmc.YPlane): + surface.y0 += dy + elif isinstance(surface, openmc.ZPlane): + surface.z0 += dz + elif isinstance(surface, openmc.Plane): + surface.d += surface.a * dx + surface.b * dy + surface.c * dz + elif isinstance(surface, openmc.Sphere): + surface.x0 += dx + surface.y0 += dy + surface.z0 += dz + else: + raise TypeError(f"Unsupported surface type: {type(surface)}") + return surface diff --git a/analysis/neutron/openmc_model_PbLi.py b/analysis/neutron/openmc_model_PbLi.py new file mode 100644 index 0000000..37b1d80 --- /dev/null +++ b/analysis/neutron/openmc_model_PbLi.py @@ -0,0 +1,577 @@ +import openmc +import vault +from libra_toolbox.neutronics.neutron_source import A325_generator_diamond +import helpers +import math + +############################################################################ +# Functions + + +def calculate_breeder_depth(R, r, g, V): + """Calculates the height (H) of a cylindrical volume (radius R & volume V) with an + inserted inner cylinder (of radius r & gap from larger cylinder floor of g). + + Args: + R (float): Major radius of breeder volume cylinder (cm) + r (float): Radius of inner cylinder inserted into breeder volume (cm) + g (float): Gap between floor of breeder volume cylinder and inserted inner cylinder (cm) + V (float): Volume of breeder material(cm3) + + Returns: + (float): Depth of breeder material volume. + """ + v1 = math.pi * R**2 * g # Volume of cylinder beneath heater + v2 = V - v1 # Volume of annulus around heater + + h1 = g # Height below heater + h2 = v2 / (math.pi * (R**2 - r**2)) # Height of annulus around heater + + H = h1 + h2 # Total height for given volume + return H + + +def baby_geometry(x_c: float, y_c: float, z_c: float): + """Returns the geometry for the BABY experiment. + + Args: + x_c: x-coordinate of the center of the BABY experiment (cm) + y_c: y-coordinate of the center of the BABY experiment (cm) + z_c: z-coordinate of the center of the BABY experiment (cm) + + Returns: + the sphere, cllif cell, and cells + """ + + ####### Dimensions (all in cm) ###### + + ## Vertical dimensions + epoxy_thickness = 2.54 # 1 inch + alumina_compressed_thickness = 2.54 # 1 inch + ov_base_thickness = 0.786 + alumina_thickness = 0.635 + he_thickness = 0.6 + iv_base_thickness = 0.3 + heater_gap = 0.878 + iv_height = 10.8903 + iv_cap = 1.422 + furnace_thickness = 15.24 + ov_height = 21.093 + ov_cap = 2.392 + table_height = 28.00 + lead_height = 4.00 + lead_width = 8.00 + lead_length = 16.00 + + heater_length = 25.40 + heater_z = ( + epoxy_thickness + + alumina_compressed_thickness + + ov_base_thickness + + alumina_thickness + + he_thickness + + iv_base_thickness + + heater_gap + + z_c + ) + + ## Radial dimensions + heater_radius = 0.439 + PbLi_radius = 7.00 + iv_external_radius = 7.3 + he_radius = 9.144 + furnace_radius = 14.224 + ov_internal_radius = 15.593 + ov_external_radius = 15.812 + + ## Calculated dimensions + PbLi_volume = 1000 # 1L = 1000 cm3 + + PbLi_thickness = calculate_breeder_depth( + PbLi_radius, heater_radius, heater_gap, PbLi_volume + ) + cover_he_thickness = ( + iv_height - PbLi_thickness + ) # Gap between surface of PbLi and top boundary of inner vessel. + + ## Source dimensions + source_h = 50.00 + source_x = x_c - 13.50 + source_z = z_c - 5.635 + source_external_r = 5.00 + source_internal_r = 4.75 + + ########## Surfaces ########## + z_plane_1 = openmc.ZPlane(0.0 + z_c) + z_plane_2 = openmc.ZPlane(epoxy_thickness + z_c) + z_plane_3 = openmc.ZPlane(epoxy_thickness + alumina_compressed_thickness + z_c) + z_plane_4 = openmc.ZPlane( + epoxy_thickness + alumina_compressed_thickness + ov_base_thickness + z_c + ) + z_plane_5 = openmc.ZPlane( + epoxy_thickness + + alumina_compressed_thickness + + ov_base_thickness + + alumina_thickness + + z_c + ) + z_plane_6 = openmc.ZPlane( + epoxy_thickness + + alumina_compressed_thickness + + ov_base_thickness + + alumina_thickness + + he_thickness + + z_c + ) + z_plane_7 = openmc.ZPlane( + epoxy_thickness + + alumina_compressed_thickness + + ov_base_thickness + + alumina_thickness + + he_thickness + + iv_base_thickness + + z_c + ) + z_plane_8 = openmc.ZPlane( + epoxy_thickness + + alumina_compressed_thickness + + ov_base_thickness + + alumina_thickness + + he_thickness + + iv_base_thickness + + PbLi_thickness + + z_c + ) + z_plane_9 = openmc.ZPlane( + epoxy_thickness + + alumina_compressed_thickness + + ov_base_thickness + + alumina_thickness + + he_thickness + + iv_base_thickness + + PbLi_thickness + + cover_he_thickness + + z_c + ) + z_plane_10 = openmc.ZPlane( + epoxy_thickness + + alumina_compressed_thickness + + ov_base_thickness + + alumina_thickness + + he_thickness + + iv_base_thickness + + PbLi_thickness + + cover_he_thickness + + iv_cap + + z_c + ) + z_plane_11 = openmc.ZPlane( + epoxy_thickness + + alumina_compressed_thickness + + ov_base_thickness + + alumina_thickness + + furnace_thickness + + z_c + ) + z_plane_12 = openmc.ZPlane( + epoxy_thickness + + alumina_compressed_thickness + + ov_base_thickness + + ov_height + + z_c + ) + z_plane_13 = openmc.ZPlane( + epoxy_thickness + + alumina_compressed_thickness + + ov_base_thickness + + ov_height + + ov_cap + + z_c + ) + z_plane_14 = openmc.ZPlane(z_c - table_height) + z_plane_15 = openmc.ZPlane(z_c - table_height - epoxy_thickness) + + ########## Cylinder ########## + z_cyl_1 = openmc.ZCylinder(x0=x_c, y0=y_c, r=PbLi_radius) + z_cyl_2 = openmc.ZCylinder(x0=x_c, y0=y_c, r=iv_external_radius) + z_cyl_3 = openmc.ZCylinder(x0=x_c, y0=y_c, r=he_radius) + z_cyl_4 = openmc.ZCylinder(x0=x_c, y0=y_c, r=furnace_radius) + z_cyl_5 = openmc.ZCylinder(x0=x_c, y0=y_c, r=ov_internal_radius) + z_cyl_6 = openmc.ZCylinder(x0=x_c, y0=y_c, r=ov_external_radius) + + right_cyl = openmc.model.RightCircularCylinder( + (x_c, y_c, heater_z), heater_length, heater_radius, axis="z" + ) + ext_cyl_source = openmc.model.RightCircularCylinder( + (source_x, y_c, source_z), source_h, source_external_r, axis="x" + ) + source_region = openmc.model.RightCircularCylinder( + (source_x + 0.25, y_c, source_z), source_h - 0.50, source_internal_r, axis="x" + ) + + ########## Sphere ########## + sphere = openmc.Sphere(x0=x_c, y0=y_c, z0=z_c, r=50.00) # before r=50.00 + + ########## Lead bricks positioned under the source ########## + positions = [ + (x_c - 13.50, y_c, z_c - table_height), + (x_c - 4.50, y_c, z_c - table_height), + (x_c + 36.50, y_c, z_c - table_height), + (x_c + 27.50, y_c, z_c - table_height), + ] + + lead_blocks = [] + for position in positions: + lead_block_region = openmc.model.RectangularParallelepiped( + position[0] - lead_width / 2, + position[0] + lead_width / 2, + position[1] - lead_length / 2, + position[1] + lead_length / 2, + position[2], + position[2] + lead_height, + ) + lead_blocks.append(lead_block_region) + + ########## Regions ########## + source_wall_region = -ext_cyl_source & +source_region + source_region = -source_region + epoxy_region = +z_plane_1 & -z_plane_2 & -sphere + alumina_compressed_region = +z_plane_2 & -z_plane_3 & -sphere + bottom_vessel = +z_plane_3 & -z_plane_4 & -z_cyl_6 + top_vessel = +z_plane_12 & -z_plane_13 & -z_cyl_6 & +right_cyl + cylinder_vessel = +z_plane_4 & -z_plane_12 & +z_cyl_5 & -z_cyl_6 + vessel_region = bottom_vessel | cylinder_vessel | top_vessel + alumina_region = +z_plane_4 & -z_plane_5 & -z_cyl_5 + bottom_cap = +z_plane_6 & -z_plane_7 & -z_cyl_2 & +right_cyl + cylinder_cap = +z_plane_7 & -z_plane_9 & +z_cyl_1 & -z_cyl_2 & +right_cyl + top_cap = +z_plane_9 & -z_plane_10 & -z_cyl_2 & +right_cyl + cap_region = bottom_cap | cylinder_cap | top_cap + PbLi_region = +z_plane_7 & -z_plane_8 & -z_cyl_1 & +right_cyl + gap_region = +z_plane_8 & -z_plane_9 & -z_cyl_1 & +right_cyl + furnace_region = +z_plane_5 & -z_plane_11 & +z_cyl_3 & -z_cyl_4 + heater_region = -right_cyl + table_under_source_region = +z_plane_15 & -z_plane_14 & -sphere + lead_block_1_region = -lead_blocks[0] + lead_block_2_region = -lead_blocks[1] + lead_block_3_region = -lead_blocks[2] + lead_block_4_region = -lead_blocks[3] + he_region = ( + +z_plane_5 + & -z_plane_12 + & -z_cyl_5 + & ~source_region + & ~epoxy_region + & ~alumina_compressed_region + & ~alumina_region + & ~PbLi_region + & ~gap_region + & ~furnace_region + & ~vessel_region + & ~cap_region + & ~heater_region + & ~table_under_source_region + & ~lead_block_1_region + & ~lead_block_2_region + & ~lead_block_3_region + & ~lead_block_4_region + ) + sphere_region = ( + -sphere + & ~source_wall_region + & ~source_region + & ~epoxy_region + & ~alumina_compressed_region + & ~alumina_region + & ~PbLi_region + & ~gap_region + & ~furnace_region + & ~he_region + & ~vessel_region + & ~cap_region + & ~heater_region + & ~table_under_source_region + & ~lead_block_1_region + & ~lead_block_2_region + & ~lead_block_3_region + & ~lead_block_4_region + ) + + # cells + source_wall_cell_1 = openmc.Cell(region=source_wall_region) + source_wall_cell_1.fill = SS304 + source_region = openmc.Cell(region=source_region) + source_region.fill = None + epoxy_cell = openmc.Cell(region=epoxy_region) + epoxy_cell.fill = epoxy + alumina_compressed_cell = openmc.Cell(region=alumina_compressed_region) + alumina_compressed_cell.fill = alumina + vessel_cell = openmc.Cell(region=vessel_region) + vessel_cell.fill = SS316L + alumina_cell = openmc.Cell(region=alumina_region) + alumina_cell.fill = alumina + PbLi_cell = openmc.Cell(region=PbLi_region) + PbLi_cell.fill = lithium_lead # cllif_nat or lithium_lead + gap_cell = openmc.Cell(region=gap_region) + gap_cell.fill = he + cap_cell = openmc.Cell(region=cap_region) + cap_cell.fill = SS316L + furnace_cell = openmc.Cell(region=furnace_region) + furnace_cell.fill = furnace + heater_cell = openmc.Cell(region=heater_region) + heater_cell.fill = heater_mat + table_cell = openmc.Cell(region=table_under_source_region) + table_cell.fill = epoxy + sphere_cell = openmc.Cell(region=sphere_region) + sphere_cell.fill = air + he_cell = openmc.Cell(region=he_region) + he_cell.fill = he + lead_block_1_cell = openmc.Cell(region=lead_block_1_region) + lead_block_1_cell.fill = lead + lead_block_2_cell = openmc.Cell(region=lead_block_2_region) + lead_block_2_cell.fill = lead + lead_block_3_cell = openmc.Cell(region=lead_block_3_region) + lead_block_3_cell.fill = lead + lead_block_4_cell = openmc.Cell(region=lead_block_4_region) + lead_block_4_cell.fill = lead + + cells = [ + source_wall_cell_1, + source_region, + epoxy_cell, + alumina_compressed_cell, + vessel_cell, + alumina_cell, + cap_cell, + PbLi_cell, + gap_cell, + furnace_cell, + heater_cell, + he_cell, + sphere_cell, + table_cell, + lead_block_1_cell, + lead_block_2_cell, + lead_block_3_cell, + lead_block_4_cell, + ] + + return sphere, PbLi_cell, cells + + +def baby_model(): + """Returns an openmc model of the BABY experiment. + + Returns: + the openmc model + """ + + materials = [ + SS316L, + lithium_lead, + SS304, + heater_mat, + furnace, + alumina, + lead, + air, + epoxy, + he, + ] + + # BABY coordinates + x_c = 587 # cm + y_c = 60 # cm + z_c = 100 # cm + sphere, PbLi_cell, cells = baby_geometry(x_c, y_c, z_c) + + ############################################################################ + # Define Settings + + settings = openmc.Settings() + + src = A325_generator_diamond((x_c, y_c, z_c - 5.635), (1, 0, 0)) + settings.source = src + settings.batches = 100 + settings.inactive = 0 + settings.run_mode = "fixed source" + settings.particles = int(1e4) + settings.output = {"tallies": False} + settings.photon_transport = False + + ############################################################################ + overall_exclusion_region = -sphere + + ############################################################################ + # Specify Tallies + tallies = openmc.Tallies() + + tbr_tally = openmc.Tally(name="TBR") + tbr_tally.scores = ["(n,Xt)"] + tbr_tally.filters = [openmc.CellFilter(PbLi_cell)] + tallies.append(tbr_tally) + + model = vault.build_vault_model( + settings=settings, + tallies=tallies, + added_cells=cells, + added_materials=materials, + overall_exclusion_region=overall_exclusion_region, + ) + + return model + + +############################################################################ +# Define Materials +# Source: PNNL Materials Compendium April 2021 +# PNNL-15870, Rev. 2 + +# 316L Stainless Steel +# Data from https://www.thyssenkrupp-materials.co.uk/stainless-steel-316l-14404.html +SS316L = openmc.Material(name="316L Steel") +SS316L.add_element("C", 0.0003, "wo") +SS316L.add_element("Si", 0.01, "wo") +SS316L.add_element("Mn", 0.02, "wo") +SS316L.add_element("P", 0.00045, "wo") +SS316L.add_element("S", 0.000151, "wo") +SS316L.add_element("Cr", 0.175, "wo") +SS316L.add_element("Ni", 0.115, "wo") +SS316L.add_element("N", 0.001, "wo") +SS316L.add_element("Mo", 0.00225, "wo") +SS316L.add_element("Fe", 0.655599, "wo") + +# Lithium-Lead +# Composition from certificate of analysis provided with Lithium-Lead from Camex +lithium_lead = openmc.Material(name="Lithium Lead") +lithium_lead.add_element("Pb", 0.993479, "wo") +lithium_lead.add_element("Li", 0.0064, "wo") +lithium_lead.add_element("Tl", 0.00002, "wo") +lithium_lead.add_element("Zn", 0.000002, "wo") +lithium_lead.add_element("Sn", 0.000002, "wo") +lithium_lead.add_element("Sb", 0.000002, "wo") +lithium_lead.add_element("Ni", 0.000001, "wo") +lithium_lead.add_element("Cu", 0.000002, "wo") +lithium_lead.add_element("Cd", 0.000002, "wo") +lithium_lead.add_element("Bi", 0.00008, "wo") +lithium_lead.add_element("As", 0.000002, "wo") +lithium_lead.add_element("Ag", 0.000008, "wo") +lithium_lead.set_density("g/cm3", 9.10411395) # Density at 600C + +# Stainless Steel 304 from PNNL Materials Compendium (PNNL-15870 Rev2) +SS304 = openmc.Material(name="Stainless Steel 304") +# SS304.temperature = 700 + 273 +SS304.add_element("C", 0.000800, "wo") +SS304.add_element("Mn", 0.020000, "wo") +SS304.add_element("P", 0.000450, "wo") +SS304.add_element("S", 0.000300, "wo") +SS304.add_element("Si", 0.010000, "wo") +SS304.add_element("Cr", 0.190000, "wo") +SS304.add_element("Ni", 0.095000, "wo") +SS304.add_element("Fe", 0.683450, "wo") +SS304.set_density("g/cm3", 8.00) + +# Central heater material +# Data from where??? +heater_mat = openmc.Material(name="heater") +heater_mat.add_element("C", 0.000990, "wo") +heater_mat.add_element("Al", 0.003960, "wo") +heater_mat.add_element("Si", 0.004950, "wo") +heater_mat.add_element("P", 0.000148, "wo") +heater_mat.add_element("S", 0.000148, "wo") +heater_mat.add_element("Ti", 0.003960, "wo") +heater_mat.add_element("Cr", 0.215000, "wo") +heater_mat.add_element("Mn", 0.004950, "wo") +heater_mat.add_element("Fe", 0.049495, "wo") +heater_mat.add_element("Co", 0.009899, "wo") +heater_mat.add_element("Ni", 0.580000, "wo") +heater_mat.add_element("Nb", 0.036500, "wo") +heater_mat.add_element("Mo", 0.090000, "wo") +heater_mat.set_density("g/cm3", 2.44) + +# Using Microtherm with 1 a% Al2O3, 27 a% ZrO2, and 72 a% SiO2 +# https://www.foundryservice.com/product/microporous-silica-insulating-boards-mintherm-microtherm-1925of-grades/ +furnace = openmc.Material(name="Furnace") +# Estimate average temperature of furnace insulation to be around 300 C +# furnace.temperature = 273 + 300 +furnace.add_element("Al", 0.004, "ao") +furnace.add_element("O", 0.666, "ao") +furnace.add_element("Si", 0.240, "ao") +furnace.add_element("Zr", 0.090, "ao") +furnace.set_density("g/cm3", 0.30) + +# alumina insulation +# data from https://precision-ceramics.com/materials/alumina/ +alumina = openmc.Material(name="Alumina insulation") +alumina.add_element("O", 0.6, "ao") +alumina.add_element("Al", 0.4, "ao") +alumina.set_density("g/cm3", 3.98) + +# air +air = openmc.Material(name="Air") +air.add_element("C", 0.00012399, "wo") +air.add_element("N", 0.75527, "wo") +air.add_element("O", 0.23178, "wo") +air.add_element("Ar", 0.012827, "wo") +air.set_density("g/cm3", 0.0012) + +# epoxy +# Data from where?? +epoxy = openmc.Material(name="Epoxy") +epoxy.add_element("C", 0.70, "wo") +epoxy.add_element("H", 0.08, "wo") +epoxy.add_element("O", 0.15, "wo") +epoxy.add_element("N", 0.07, "wo") +epoxy.set_density("g/cm3", 1.2) + +# helium @5psig +pressure = 34473.8 # Pa ~ 5 psig +temperature = 300 # K +R_he = 2077 # J/(kg*K) +density = pressure / (R_he * temperature) / 1000 # in g/cm^3 +he = openmc.Material(name="Helium") +he.add_element("He", 1.0, "ao") +he.set_density("g/cm3", density) + +# lead +# data from https://wwwrcamnl.wr.usgs.gov/isoig/period/pb_iig.html +lead = openmc.Material() +lead.set_density("g/cm3", 11.34) +lead.add_nuclide("Pb204", 0.014, "ao") +lead.add_nuclide("Pb206", 0.241, "ao") +lead.add_nuclide("Pb207", 0.221, "ao") +lead.add_nuclide("Pb208", 0.524, "ao") + + +if __name__ == "__main__": + model = baby_model() + model.run() + sp = openmc.StatePoint(f"statepoint.{model.settings.batches}.h5") + tbr_tally = sp.get_tally(name="TBR").get_pandas_dataframe() + + print(f"TBR: {tbr_tally['mean'].iloc[0] :.6e}\n") + print(f"TBR std. dev.: {tbr_tally['std. dev.'].iloc[0] :.6e}\n") + + processed_data = { + "modelled_TBR": { + "mean": tbr_tally["mean"].iloc[0], + "std_dev": tbr_tally["std. dev."].iloc[0], + } + } + + import json + + processed_data_file = "../../data/processed_data.json" + + try: + with open(processed_data_file, "r") as f: + existing_data = json.load(f) + except FileNotFoundError: + print(f"Processed data file not found, creating it in {processed_data_file}") + existing_data = {} + + existing_data.update(processed_data) + + with open(processed_data_file, "w") as f: + json.dump(existing_data, f, indent=4) + + print(f"Processed data stored in {processed_data_file}") diff --git a/analysis/neutron/postprocessing.ipynb b/analysis/neutron/postprocessing.ipynb new file mode 100644 index 0000000..cdb71e1 --- /dev/null +++ b/analysis/neutron/postprocessing.ipynb @@ -0,0 +1,433 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# LIBRA and the Lithium-Lead Liquid Immersion Blanket\n", + "## 1L BABY" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import openmc\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import LogNorm, ListedColormap\n", + "from openmc_model_PbLi import baby_model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Geometry" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/rossmac/anaconda3/envs/BABY_1L_PbLi/lib/python3.12/site-packages/openmc/source.py:656: FutureWarning: This class is deprecated in favor of 'IndependentSource'\n", + " warnings.warn(\"This class is deprecated in favor of 'IndependentSource'\", FutureWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "isotopes ['Ag107', 'Ag109', 'Al27', 'Ar36', 'Ar38', 'Ar40', 'As75', 'B10', 'B11', 'Be9', 'Bi209', 'C12', 'C13', 'Ca40', 'Ca42', 'Ca43', 'Ca44', 'Ca46', 'Ca48', 'Cd106', 'Cd108', 'Cd110', 'Cd111', 'Cd112', 'Cd113', 'Cd114', 'Cd116', 'Co59', 'Cr50', 'Cr52', 'Cr53', 'Cr54', 'Cu63', 'Cu65', 'F19', 'Fe54', 'Fe56', 'Fe57', 'Fe58', 'H1', 'H2', 'He3', 'He4', 'K39', 'K40', 'K41', 'Li6', 'Li7', 'Mg24', 'Mg25', 'Mg26', 'Mn55', 'Mo100', 'Mo92', 'Mo94', 'Mo95', 'Mo96', 'Mo97', 'Mo98', 'N14', 'N15', 'Na23', 'Nb93', 'Ni58', 'Ni60', 'Ni61', 'Ni62', 'Ni64', 'O16', 'O17', 'O18', 'P31', 'Pb204', 'Pb206', 'Pb207', 'Pb208', 'S32', 'S33', 'S34', 'S36', 'Sb121', 'Sb123', 'Si28', 'Si29', 'Si30', 'Sn112', 'Sn114', 'Sn115', 'Sn116', 'Sn117', 'Sn118', 'Sn119', 'Sn120', 'Sn122', 'Sn124', 'Ti46', 'Ti47', 'Ti48', 'Ti49', 'Ti50', 'Tl203', 'Tl205', 'W182', 'W183', 'W184', 'W186', 'Zn64', 'Zn66', 'Zn67', 'Zn68', 'Zn70', 'Zr90', 'Zr91', 'Zr92', 'Zr94', 'Zr96']\n", + "Searching libraries with the following priority {'ENDFB-8.0-NNDC': 1}\n", + "Isotopes found matching library requirements 556\n", + "Isotopes found matching particle requirements 1789\n", + "Isotopes found matching isotope requirements 458\n", + "Isotopes found matching all requirements 116\n", + " library remote_file \\\n", + "1233 ENDFB-8.0-NNDC H1.h5 \n", + "1234 ENDFB-8.0-NNDC H2.h5 \n", + "1236 ENDFB-8.0-NNDC He3.h5 \n", + "1237 ENDFB-8.0-NNDC He4.h5 \n", + "1238 ENDFB-8.0-NNDC Li6.h5 \n", + "... ... ... \n", + "1689 ENDFB-8.0-NNDC Pb204.h5 \n", + "1691 ENDFB-8.0-NNDC Pb206.h5 \n", + "1692 ENDFB-8.0-NNDC Pb207.h5 \n", + "1693 ENDFB-8.0-NNDC Pb208.h5 \n", + "1694 ENDFB-8.0-NNDC Bi209.h5 \n", + "\n", + " url \\\n", + "1233 https://github.com/openmc-data-storage/ENDF-B-... \n", + "1234 https://github.com/openmc-data-storage/ENDF-B-... \n", + "1236 https://github.com/openmc-data-storage/ENDF-B-... \n", + "1237 https://github.com/openmc-data-storage/ENDF-B-... \n", + "1238 https://github.com/openmc-data-storage/ENDF-B-... \n", + "... ... \n", + "1689 https://github.com/openmc-data-storage/ENDF-B-... \n", + "1691 https://github.com/openmc-data-storage/ENDF-B-... \n", + "1692 https://github.com/openmc-data-storage/ENDF-B-... \n", + "1693 https://github.com/openmc-data-storage/ENDF-B-... \n", + "1694 https://github.com/openmc-data-storage/ENDF-B-... \n", + "\n", + " local_file particle isotope element priority \n", + "1233 ENDFB-8.0-NNDC_H1.h5 neutron H1 H 1 \n", + "1234 ENDFB-8.0-NNDC_H2.h5 neutron H2 H 1 \n", + "1236 ENDFB-8.0-NNDC_He3.h5 neutron He3 He 1 \n", + "1237 ENDFB-8.0-NNDC_He4.h5 neutron He4 He 1 \n", + "1238 ENDFB-8.0-NNDC_Li6.h5 neutron Li6 Li 1 \n", + "... ... ... ... ... ... \n", + "1689 ENDFB-8.0-NNDC_Pb204.h5 neutron Pb204 Pb 1 \n", + "1691 ENDFB-8.0-NNDC_Pb206.h5 neutron Pb206 Pb 1 \n", + "1692 ENDFB-8.0-NNDC_Pb207.h5 neutron Pb207 Pb 1 \n", + "1693 ENDFB-8.0-NNDC_Pb208.h5 neutron Pb208 Pb 1 \n", + "1694 ENDFB-8.0-NNDC_Bi209.h5 neutron Bi209 Bi 1 \n", + "\n", + "[116 rows x 8 columns]\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_H1.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_H2.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_He3.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_He4.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Li6.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Li7.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Be9.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_B10.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_B11.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_C12.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_C13.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_N14.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_N15.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_O16.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_O17.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_O18.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_F19.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Na23.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mg24.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mg25.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mg26.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Al27.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Si28.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Si29.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Si30.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_P31.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_S32.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_S33.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_S34.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_S36.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ar36.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ar38.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ar40.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_K39.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_K40.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_K41.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ca40.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ca42.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ca43.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ca44.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ca46.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ca48.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ti46.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ti47.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ti48.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ti49.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ti50.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cr50.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cr52.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cr53.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cr54.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mn55.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Fe54.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Fe56.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Fe57.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Fe58.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Co59.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ni58.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ni60.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ni61.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ni62.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ni64.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cu63.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cu65.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Zn64.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Zn66.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Zn67.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Zn68.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Zn70.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_As75.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Zr90.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Zr91.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Zr92.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Zr94.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Zr96.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Nb93.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mo92.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mo94.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mo95.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mo96.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mo97.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mo98.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Mo100.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ag107.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Ag109.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cd106.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cd108.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cd110.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cd111.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cd112.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cd113.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cd114.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Cd116.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sn112.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sn114.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sn115.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sn116.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sn117.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sn118.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sn119.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sn120.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sn122.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sn124.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sb121.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Sb123.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_W182.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_W183.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_W184.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_W186.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Tl203.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Tl205.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Pb204.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Pb206.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Pb207.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Pb208.h5, already downloaded\n", + "Skipping cross_sections/ENDFB-8.0-NNDC_Bi209.h5, already downloaded\n", + "written cross sections xml file to /home/rossmac/Repositories/Ross-BABY-LiPb/analysis/neutron/cross_sections/cross_sections.xml\n", + "setting OPENMC_CROSS_SECTIONS to /home/rossmac/Repositories/Ross-BABY-LiPb/analysis/neutron/cross_sections/cross_sections.xml\n" + ] + } + ], + "source": [ + "model = baby_model()\n", + "geometry = model.geometry" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Vault Geometry" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualization\n", + "\n", + "from vault import Air\n", + "from openmc_model_PbLi import air\n", + "\n", + "x_c = 587\n", + "y_c = 60\n", + "z_c = 100\n", + "ax = geometry.plot(\n", + " width=(2500, 1500),\n", + " origin=(x_c, y_c, z_c + 10),\n", + " pixels=(1000, 1000),\n", + " basis=\"xy\",\n", + " color_by=\"material\",\n", + " colors={Air: \"white\", air: \"white\"},\n", + ")\n", + "ax.tick_params(axis=\"both\", labelsize=20)\n", + "ax.set_xlabel(ax.get_xlabel(), fontsize=20)\n", + "ax.set_ylabel(ax.get_ylabel(), fontsize=20)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### BABY 1L Geometry XZ View" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = geometry.plot(\n", + " width=(85, 85),\n", + " origin=(x_c, y_c, z_c + 10),\n", + " pixels=(1000, 1000),\n", + " basis=\"xz\",\n", + " color_by=\"material\",\n", + " colors={Air: \"white\", air: \"white\"},\n", + ")\n", + "ax.tick_params(axis=\"both\", labelsize=20)\n", + "ax.set_xlabel(ax.get_xlabel(), fontsize=20)\n", + "ax.set_ylabel(ax.get_ylabel(), fontsize=20)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### BABY 1L Geometry YZ View" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = geometry.plot(\n", + " width=(85, 85),\n", + " origin=(x_c, y_c, z_c + 10),\n", + " pixels=(1000, 1000),\n", + " basis=\"yz\",\n", + " color_by=\"material\",\n", + " colors={Air: \"white\", air: \"white\"},\n", + ")\n", + "ax.tick_params(axis=\"both\", labelsize=20)\n", + "ax.set_xlabel(ax.get_xlabel(), fontsize=20)\n", + "ax.set_ylabel(ax.get_ylabel(), fontsize=20)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### BABY 1L Geometry XY View" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = geometry.plot(\n", + " width=(85, 85),\n", + " origin=(x_c, y_c, z_c + 10),\n", + " pixels=(1000, 1000),\n", + " basis=\"xy\",\n", + " color_by=\"material\",\n", + " colors={Air: \"white\", air: \"white\"},\n", + ")\n", + "ax.tick_params(axis=\"both\", labelsize=20)\n", + "ax.set_xlabel(ax.get_xlabel(), fontsize=20)\n", + "ax.set_ylabel(ax.get_ylabel(), fontsize=20)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Result" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TBR: 1.028456e-03\n", + "\n", + "TBR std. dev.: 2.928848e-05\n", + "\n" + ] + } + ], + "source": [ + "sp = openmc.StatePoint(\"statepoint.100.h5\")\n", + "tbr_withvault = sp.get_tally(name=\"TBR\").get_pandas_dataframe()\n", + "print(f\"TBR: {tbr_withvault['mean'].iloc[0] :.6e}\\n\")\n", + "print(f\"TBR std. dev.: {tbr_withvault['std. dev.'].iloc[0] :.6e}\\n\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "BABY_1L_PbLi", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/analysis/neutron/vault.py b/analysis/neutron/vault.py new file mode 100644 index 0000000..6ca9ecc --- /dev/null +++ b/analysis/neutron/vault.py @@ -0,0 +1,805 @@ +import openmc +import openmc.model +import numpy as np +from helpers import translate_surface + +# needed to download cross sections on the fly +import openmc_data_downloader as odd + + +def build_vault_model( + settings=openmc.Settings(), + tallies=openmc.Tallies(), + added_cells=[], + added_materials=[], + overall_exclusion_region=None, +) -> openmc.model.Model: + + materials = openmc.Materials( + [ + Aluminum, + Material_2, + Air, + Concrete, + IronConcrete, + Material_6, + Material_7, + Material_8, + Material_10, + Lead, + BPE, + Polyethylene, + HDPE, + Material_22, + Material_23, + Material_30, + Material_40, + Soil, + Brick, + RicoRad, + Steel, + SS304, + Firebrick, + Flibe_nat, + Copper, + Be, + ] + ) + + # Add materials from imported model + materials += added_materials + + materials.download_cross_section_data( + libraries=["ENDFB-8.0-NNDC"], + set_OPENMC_CROSS_SECTIONS=True, + particles=["neutron"], + destination="cross_sections", + ) + # + # Definition of the spherical void/blackhole boundary + Surface_95 = openmc.Sphere(x0=0.0, y0=0.0, z0=0.0, r=2500.0, boundary_type="vacuum") + + # 24 + Surface_24 = openmc.model.RectangularParallelepiped( + 1023.62 - 1104.9, 2247.9 - 1104.9, 0.0 - 99.38, 749.62 - 99.38, 0.0, 424.18 + ) + + # with an angle of 2.8 degrees. The positive vector points towards the + # lower-right (Southeast) corner of the geometry + Surface_49 = openmc.Plane(a=0.99881, b=-0.04885, c=0.0, d=2144.83) + + # + # Outer surface definition of the foundation underneath all basement labs + Surface_94 = openmc.model.RectangularParallelepiped( + 0.0 - 1104.9, 2247.9 - 1104.9, 0.0 - 99.38, 1998.37 - 99.38, -81.28, 0.0 + ) + + # Define Soil cell 3 meters wide + East_outer_plane = Surface_49.clone() + East_outer_plane = East_outer_plane.translate([500 * np.cos(np.deg2rad(2.8)), 0, 0]) + + # + # The cuboid defining the outermost boundary of the Vault door in Room III + Surface_13 = openmc.model.RectangularParallelepiped( + 1105.41 - 1104.9, + 1166.3700000000001 - 1104.9, + 368.0 - 99.38, + 611.84 - 99.38, + 0.0, + 223.52, + ) + + # The plane used to create the 30 degree north-most cut on the Vault door. + # The positive vector points towards the lower-left + Surface_14 = openmc.Plane(a=0.5, b=0.86603, c=0.0, d=1084.9) + + # The plane used to create the 30 degree south-most cut on the Vault door + # the positive vector points towards the upper-left + Surface_15 = openmc.Plane(a=0.5, b=-0.86603, c=0.0, d=238.93) + + # The main Vault shield door in Room III + Vault_door_reg = -Surface_13 & -Surface_14 & -Surface_15 + + # + # North B-HDPE shield in entrance to Vault in Room III + Surface_17 = openmc.model.RectangularParallelepiped( + 1066.8 - 1104.9, + 1104.8999999999999 - 1104.9, + 565.78 - 99.38, + 598.8 - 99.38, + 10.16, + 213.35999999999999, + ) + + # The northern Ricorad extra Vault door shielding in Room III + Vault_door_shield_n_pillar_reg = -Surface_17 + + # + # South B-HDPE shield in entrance to Vault in Room III + Surface_18 = openmc.model.RectangularParallelepiped( + 1066.8 - 1104.9, + 1104.8999999999999 - 1104.9, + 380.71 - 99.38, + 413.72999999999996 - 99.38, + 10.16, + 213.35999999999999, + ) + + # The southern Ricorad extra Vault door shielding in Room III + Vault_door_shield_s_pillar_reg = -Surface_18 + + # + # Surface definition for west iron-brick pile around DANTE selection magnet + Surface_10 = openmc.model.RectangularParallelepiped( + 1741.65 - 1104.9, 1808.49 - 1104.9, 512.12 - 99.38, 637.85 - 99.38, 10.16, 152.4 + ) + + # The western DANTE beamline (Fe or Pb fill?) concrete block shield + DANTE_vault_w_shield_reg = -Surface_10 + + # + # Surface definition for east iron-brick pile around DANTE selection magnet + Surface_9 = openmc.model.RectangularParallelepiped( + 1935.48 - 1104.9, + 1983.74 - 1104.9, + 512.12 - 99.38, + 637.85 - 99.38, + 10.16, + 135.89000000000001, + ) + + # The eastern DANTE beamline (Fe or Pb fill?) concrete block shield + DANTE_vault_e_shield_reg = -Surface_9 + + # + # 11 + Surface_11 = openmc.model.RightCircularCylinder( + (1858.01 - 1104.9, 637.86 - 99.38, 111.76), 111.76, 15.24, axis="y" + ) + + # + # 2 + Surface_22 = openmc.model.RectangularParallelepiped( + 1699.2 - 1104.9, 2119.2 - 1104.9, 637.85 - 99.38, 668.33 - 99.38, 10.16, 363.22 + ) + + # with an angle of 2.8 degrees. The positive vector points towards the + # lower-right (Southeast) corner of the geometry + Surface_48 = openmc.Plane(a=0.99881, b=-0.04885, c=0.0, d=2063.64) + + # The CMU wall partially covering the north shield wall in Room III + Vault_north_wall_ext_reg = -Surface_22 & -Surface_48 & +Surface_11 + + # The foundation underneath all basement lab rooms + Region_21 = -Surface_94 & -Surface_49 + + # + # 36 + Surface_36 = openmc.model.RectangularParallelepiped( + 1104.9 - 1104.9, 2254.9 - 1104.9, 0.0 - 99.38, 99.38 - 99.38, 0.0, 363.22 + ) + + # The south Vault shield wall in Room III + South_vault_wall_reg = -Surface_36 & -Surface_49 + + # + # 16 + Surface_16 = openmc.model.RectangularParallelepiped( + 2050.0 - 1104.9, 2200.0 - 1104.9, 99.38 - 99.38, 668.34 - 99.38, 0.0, 363.22 + ) + + # The east Vault shield wall in Room III with Room II entrance cutout + East_vault_wall_reg = -Surface_16 & +Surface_48 & -Surface_49 + + # + # 38 + Surface_38 = openmc.model.RectangularParallelepiped( + 1000.0 - 1104.9, + 1150.0 - 1104.9, + 380.71 - 99.38, + 598.8 - 99.38, + 10.16, + 213.35999999999999, + ) + + # + # 39 + Surface_39 = openmc.model.RectangularParallelepiped( + 1023.62 - 1104.9, 1104.9 - 1104.9, 0.0 - 99.38, 749.62 - 99.38, 0.0, 363.22 + ) + + # The west Vault shield wall in Room III with Vault entrance cutout + West_vault_wall_reg = -Surface_39 & +Surface_38 + + # + # 37 + Surface_37 = openmc.model.RectangularParallelepiped( + 1023.62 - 1104.9, 2253.62 - 1104.9, 0.0 - 99.38, 749.62 - 99.38, 363.22, 424.18 + ) + + # The top (roof) Vault shield wall in Room III + Vault_ceiling_reg = -Surface_37 & -Surface_49 + + # + # 12 + Surface_12 = openmc.model.RectangularParallelepiped( + 1169.67 - 1104.9, 2169.67 - 1104.9, 99.38 - 99.38, 668.34 - 99.38, 0.0, 10.16 + ) + + # The bottom Vault floor in Room III + Vault_floor_reg = -Surface_12 & -Surface_48 + + # 23 + Surface_23 = openmc.model.RectangularParallelepiped( + 1104.9 - 1104.9, 2254.9 - 1104.9, 668.34 - 99.38, 749.62 - 99.38, 0.0, 363.22 + ) + + # + # The cyclotron beamline cutout in the north Vault shield wall + Surface_102 = openmc.model.RightCircularCylinder( + (1422.0 - 1104.9, 668.34 - 99.38, 50.0), 81.28, 5.0, axis="y" + ) + + # The north Vault shield wall in Room III with beamline cutouts + North_vault_wall_reg = -Surface_23 & -Surface_49 & +Surface_11 & +Surface_102 + + # + # 82 + Surface_82 = openmc.model.RectangularParallelepiped( + 1135.9 - 1104.9, + 1147.3300000000002 - 1104.9, + 138.75 - 99.38, + 628.97 - 99.38, + 276.86, + 279.40000000000003, + ) + + # + # 83 + Surface_83 = openmc.model.RectangularParallelepiped( + 1135.9 - 1104.9, + 1147.3300000000002 - 1104.9, + 138.75 - 99.38, + 628.97 - 99.38, + 297.18, + 299.72, + ) + + # + # 84 + Surface_84 = openmc.model.RectangularParallelepiped( + 1140.35 - 1104.9, + 1142.8899999999999 - 1104.9, + 138.75 - 99.38, + 628.97 - 99.38, + 276.86, + 299.72, + ) + + # The I-beam support the main Vault shield door in Room III + I_beam_reg = -Surface_82 | -Surface_83 | -Surface_84 + + # + # Inner surface defining the top/bottom DANTE selection magnets + Surface_28 = openmc.model.RightCircularCylinder( + (1858.01 - 1104.9, 597.22 - 99.38, 99.7), 75.0, 20.95, axis="z" + ) + + # + # Outer surface defining the bottom DANTE selection magnet + Surface_30 = openmc.model.RightCircularCylinder( + (1858.01 - 1104.9, 597.22 - 99.38, 99.7), 8.0, 32.0, axis="z" + ) + + # The bottom DANTE beamline selection magnet in Room III + DANTE_vault_bot_magnet_reg = -Surface_30 & +Surface_28 + + # + # Outer surface defining the top DANTE selection magnet + Surface_35 = openmc.model.RightCircularCylinder( + (1858.01 - 1104.9, 597.22 - 99.38, 115.83), 8.0, 32.0, axis="z" + ) + + # The top DANTE beamline selection magnet in Room III + DANTE_vault_top_magnet_reg = -Surface_35 & +Surface_28 + + # + # Surface definition for selection magnet cutout of surface #27 + Surface_21 = openmc.model.RectangularParallelepiped( + 1825.87 - 1104.9, + 1890.1399999999999 - 1104.9, + 571.9 - 99.38, + 621.9 - 99.38, + 99.7, + 123.83, + ) + + # + # Surface definition of square box that contains DANTE selection magnets + Surface_27 = openmc.model.RectangularParallelepiped( + 1816.1 - 1104.9, + 1899.9199999999998 - 1104.9, + 576.9 - 99.38, + 617.54 - 99.38, + 89.54, + 133.99, + ) + + # + # Selection magnet SE support leg + Surface_29 = openmc.model.RectangularParallelepiped( + 1892.3 - 1104.9, + 1899.9199999999998 - 1104.9, + 576.9 - 99.38, + 584.52 - 99.38, + 10.16, + 88.89999999999999, + ) + + # + # Selection magnet NE support leg + Surface_31 = openmc.model.RectangularParallelepiped( + 1892.3 - 1104.9, + 1899.9199999999998 - 1104.9, + 609.92 - 99.38, + 617.54 - 99.38, + 10.16, + 88.89999999999999, + ) + + # + # Selection magnet SW support leg + Surface_33 = openmc.model.RectangularParallelepiped( + 1816.1 - 1104.9, + 1823.7199999999998 - 1104.9, + 576.9 - 99.38, + 584.52 - 99.38, + 10.16, + 88.89999999999999, + ) + + # + # Thin selection magnet table top plate + Surface_34 = openmc.model.RectangularParallelepiped( + 1816.1 - 1104.9, + 1899.9199999999998 - 1104.9, + 576.9 - 99.38, + 617.54 - 99.38, + 88.9, + 89.54, + ) + + # The DANTE beamline selection magnet stand in Room III + DANTE_vault_mag_stand_reg = ( + (-Surface_27 & +Surface_21) + | -Surface_29 + | -Surface_31 + | -Surface_33 + | -Surface_34 + ) + + Region_28 = ( + -Surface_24 + & -Surface_49 + & ~North_vault_wall_reg + & ~Vault_north_wall_ext_reg + & ~South_vault_wall_reg + & ~West_vault_wall_reg + & ~East_vault_wall_reg + & ~Vault_ceiling_reg + & ~Vault_floor_reg + & ~Vault_door_reg + & ~Vault_door_shield_n_pillar_reg + & ~Vault_door_shield_s_pillar_reg + & ~I_beam_reg + & ~DANTE_vault_w_shield_reg + & ~DANTE_vault_e_shield_reg + & ~DANTE_vault_bot_magnet_reg + & ~DANTE_vault_top_magnet_reg + & ~DANTE_vault_mag_stand_reg + ) + if overall_exclusion_region: + Region_28 = Region_28 & ~overall_exclusion_region + + translation_vector = [-1104.9, -99.38, 0.0] + + for surface in [Surface_49, East_outer_plane, Surface_14, Surface_15, Surface_48]: + translate_surface(surface, *translation_vector) + + Vault_air_cell = openmc.Cell(fill=Air, region=Region_28) + DANTE_vault_mag_stand_cell = openmc.Cell( + fill=Aluminum, region=DANTE_vault_mag_stand_reg + ) + DANTE_vault_top_magnet_cell = openmc.Cell( + fill=Material_2, region=DANTE_vault_top_magnet_reg + ) + DANTE_vault_bot_magnet_cell = openmc.Cell( + fill=Material_2, region=DANTE_vault_bot_magnet_reg + ) + I_beam_cell = openmc.Cell(fill=Material_6, region=I_beam_reg) + North_vault_wall_cell = openmc.Cell(fill=Concrete, region=North_vault_wall_reg) + Vault_floor_cell = openmc.Cell(fill=Concrete, region=Vault_floor_reg) + Vault_ceiling_cell = openmc.Cell(fill=Concrete, region=Vault_ceiling_reg) + West_vault_wall_cell = openmc.Cell(fill=Concrete, region=West_vault_wall_reg) + East_vault_wall_cell = openmc.Cell(fill=Concrete, region=East_vault_wall_reg) + South_vault_wall_cell = openmc.Cell(fill=Concrete, region=South_vault_wall_reg) + foundation = openmc.Cell(fill=Concrete, region=Region_21) + Vault_north_wall_ext_cell = openmc.Cell( + fill=Concrete, region=Vault_north_wall_ext_reg + ) + DANTE_vault_e_shield_cell = openmc.Cell( + fill=IronConcrete, region=DANTE_vault_e_shield_reg + ) + DANTE_vault_w_shield_cell = openmc.Cell( + fill=IronConcrete, region=DANTE_vault_w_shield_reg + ) + Vault_door_shield_s_pillar_cell = openmc.Cell( + fill=RicoRad, region=Vault_door_shield_s_pillar_reg + ) + Vault_door_shield_n_pillar_cell = openmc.Cell( + fill=RicoRad, region=Vault_door_shield_n_pillar_reg + ) + Vault_door_cell = openmc.Cell(fill=Concrete, region=Vault_door_reg) + + # Explicit declaration of the outer void + Region_1000 = ( + -Surface_95 + & ~Vault_door_reg + & ~Vault_door_shield_n_pillar_reg + & ~Vault_door_shield_s_pillar_reg + & ~DANTE_vault_w_shield_reg + & ~DANTE_vault_e_shield_reg + & ~Vault_north_wall_ext_reg + & ~Region_21 + & ~South_vault_wall_reg + & ~East_vault_wall_reg + & ~West_vault_wall_reg + & ~Vault_ceiling_reg + & ~Vault_floor_reg + & ~North_vault_wall_reg + & ~I_beam_reg + & ~DANTE_vault_bot_magnet_reg + & ~DANTE_vault_top_magnet_reg + & ~DANTE_vault_mag_stand_reg + & ~Region_28 + ) + + if overall_exclusion_region: + Region_1000 = Region_1000 & ~overall_exclusion_region + + Cell_1000 = openmc.Cell(fill=Air, region=Region_1000) + + Cells = [ + Cell_1000, + Vault_door_cell, + Vault_door_shield_n_pillar_cell, + Vault_door_shield_s_pillar_cell, + DANTE_vault_w_shield_cell, + DANTE_vault_e_shield_cell, + Vault_north_wall_ext_cell, + foundation, + South_vault_wall_cell, + East_vault_wall_cell, + West_vault_wall_cell, + Vault_ceiling_cell, + Vault_floor_cell, + North_vault_wall_cell, + I_beam_cell, + DANTE_vault_bot_magnet_cell, + DANTE_vault_top_magnet_cell, + DANTE_vault_mag_stand_cell, + Vault_air_cell, + ] + + Cells += added_cells + + Universe_1 = openmc.Universe(cells=Cells) + geometry = openmc.Geometry(Universe_1) + geometry.remove_redundant_surfaces() + + vault_model = openmc.model.Model( + geometry=geometry, materials=materials, settings=settings, tallies=tallies + ) + + return vault_model + + +# +# **** Natural elements **** +# +# Aluminum : 2.6989 g/cm3 +Aluminum = openmc.Material() +Aluminum.set_density("g/cm3", 2.6989) +Aluminum.add_nuclide("Al27", 1.0, "ao") + +# Copper : 8.96 g/cm3 +Material_2 = openmc.Material() +Material_2.set_density("g/cm3", 8.96) +Material_2.add_nuclide("Cu63", 0.6917, "ao") +Material_2.add_nuclide("Cu65", 0.3083, "ao") + +# Name: Air +# Density : 0.001205 g/cm3 +# Reference: None +# Describes: All atmospheric, non-object chambers +Air = openmc.Material(name="Air") +Air.set_density("g/cm3", 0.001205) +Air.add_element("C", 0.00015, "ao") +Air.add_nuclide("N14", 0.784431, "ao") +Air.add_nuclide("O16", 0.210748, "ao") +Air.add_nuclide("Ar40", 0.004671, "ao") + +# Name: Portland concrete +# Density: 2.3 g/cm3 +# Reference: PNNL Report 15870 (Rev. 1) +# Describes: facility foundation, floors, walls +Concrete = openmc.Material() +Concrete.set_density("g/cm3", 2.3) +Concrete.add_nuclide("H1", 0.168759, "ao") +Concrete.add_element("C", 0.001416, "ao") +Concrete.add_nuclide("O16", 0.562524, "ao") +Concrete.add_nuclide("Na23", 0.011838, "ao") +Concrete.add_element("Mg", 0.0014, "ao") +Concrete.add_nuclide("Al27", 0.021354, "ao") +Concrete.add_element("Si", 0.204115, "ao") +Concrete.add_element("K", 0.005656, "ao") +Concrete.add_element("Ca", 0.018674, "ao") +Concrete.add_element("Fe", 0.004264, "ao") + +# Name: Portland iron concrete +# Density: 3.8 g/cm3 as roughly measured using scale and assuming rectangular prism +# Reference: PNNL Report 15870 (Rev. 1) +# Describes: Potential new walls, shielding doors +IronConcrete = openmc.Material() +IronConcrete.set_density("g/cm3", 3.8) +IronConcrete.add_nuclide("H1", 0.135585, "ao") +IronConcrete.add_nuclide("O16", 0.150644, "ao") +IronConcrete.add_element("Mg", 0.002215, "ao") +IronConcrete.add_nuclide("Al27", 0.005065, "ao") +IronConcrete.add_element("Si", 0.013418, "ao") +IronConcrete.add_element("S", 0.000646, "ao") +IronConcrete.add_element("Ca", 0.040919, "ao") +IronConcrete.add_nuclide("Mn55", 0.002638, "ao") +IronConcrete.add_element("Fe", 0.648869, "ao") + +# Name: Stainless steel 304 +# Density: 8.0 g/cm3 +# Reference: PNNL Report 15870 (Rev. 1) +# Describes: vacuum pipes, flanges, general steel objects +Material_6 = openmc.Material() +Material_6.set_density("g/cm3", 8.0) +Material_6.add_element("C", 0.00183, "ao") +Material_6.add_element("Si", 0.009781, "ao") +Material_6.add_nuclide("P31", 0.000408, "ao") +Material_6.add_element("S", 0.000257, "ao") +Material_6.add_element("Cr", 0.200762, "ao") +Material_6.add_nuclide("Mn55", 0.010001, "ao") +Material_6.add_element("Fe", 0.690375, "ao") +Material_6.add_element("Ni", 0.086587, "ao") + +# Name: Wood (Southern Pine) +# Density: 0.64 g/cm3 +# Reference: PNNL Report 15870 (Rev. 1) +# Describes: doors +Material_7 = openmc.Material() +Material_7.set_density("g/cm3", 0.64) +Material_7.add_nuclide("H1", 0.462423, "ao") +Material_7.add_element("C", 0.323389, "ao") +Material_7.add_nuclide("N14", 0.002773, "ao") +Material_7.add_nuclide("O16", 0.208779, "ao") +Material_7.add_element("Mg", 0.000639, "ao") +Material_7.add_element("S", 0.001211, "ao") +Material_7.add_element("K", 0.000397, "ao") +Material_7.add_element("Ca", 0.000388, "ao") + +# Name: Gypsum (wallboard) +# Density: 2.32 g/cm3 +# Reference: PNNL Report 15870 (Rev. 1) +# Describes: drywall walls (GWB) +Material_8 = openmc.Material() +Material_8.set_density("g/cm3", 2.32) +Material_8.add_nuclide("H1", 0.333321, "ao") +Material_8.add_nuclide("O16", 0.500014, "ao") +Material_8.add_element("S", 0.083324, "ao") +Material_8.add_element("Ca", 0.083341, "ao") + +# **** Gamma shielding materials **** +# +# Tungsten : 19.3 g/cm3 +Material_10 = openmc.Material() +Material_10.set_density("g/cm3", 19.3) +Material_10.add_nuclide("W182", 0.265, "ao") +Material_10.add_nuclide("W183", 0.1431, "ao") +Material_10.add_nuclide("W184", 0.3064, "ao") +Material_10.add_nuclide("W186", 0.2855, "ao") + +# +# Lead : 11.34 g/cm3 +Lead = openmc.Material() +Lead.set_density("g/cm3", 11.34) +Lead.add_nuclide("Pb204", 0.014, "ao") +Lead.add_nuclide("Pb206", 0.241, "ao") +Lead.add_nuclide("Pb207", 0.221, "ao") +Lead.add_nuclide("Pb208", 0.524, "ao") + +# Name: Borated Polyethylene (5% B in via B4C additive) +# Density: 0.95 g/cm3 +# Reference: PNNL Report 15870 (Rev. 1) but revised to make it 5 wt.% B +# Describes: General purpose neutron shielding +BPE = openmc.Material() +BPE.set_density("g/cm3", 0.95) +BPE.add_nuclide("H1", 0.1345, "wo") +BPE.add_element("B", 0.0500, "wo") +BPE.add_element("C", 0.8155, "wo") + +# Name: Non-borated polyethylene +# Density: 0.93 g/cm3 +# Reference: PNNL Report 15870 (Rev. 1) +# Describes: General purpose neutron shielding +Polyethylene = openmc.Material() +Polyethylene.set_density("g/cm3", 0.93) +Polyethylene.add_nuclide("H1", 0.666662, "ao") +Polyethylene.add_element("C", 0.333338, "ao") + +# High Density Polyethylene +# Reference: PNNL Report 15870 (Rev. 1) +HDPE = openmc.Material(name="HDPE") +HDPE.set_density("g/cm3", 0.95) +HDPE.add_element("H", 0.143724, "wo") +HDPE.add_element("C", 0.856276, "wo") + +# Name: Zirconium dihydride +# Density: 5.6 g/cm3 +# Reference: JNM 386-388 (2009) 119-121 +# Describes: General purpose neutron shielding +Material_22 = openmc.Material() +Material_22.set_density("g/cm3", 5.6) +Material_22.add_nuclide("H1", 0.0216, "wo") +Material_22.add_element("Zr", 0.9784, "wo") + +# Name: Zirconium borohydride +# Density: 1.18 g/cm3 +# Reference: JNM 386-388 (2009) 119-121 +# Describes: General purpose neutron shielding +Material_23 = openmc.Material() +Material_23.set_density("g/cm3", 1.18) +Material_23.add_nuclide("H1", 0.1073, "wo") +Material_23.add_nuclide("B10", 0.0571, "wo") +Material_23.add_nuclide("B11", 0.23, "wo") +Material_23.add_element("Zr", 0.6056, "wo") + +# Density: 1.848 g/cm3 +# Reference: None +# Describes: Highest intenstiy neutron production target +# Notes: Uses ENDF-derived proton nuclear data libray +Material_30 = openmc.Material() +Material_30.set_density("g/cm3", 1.848) +Material_30.add_nuclide("Be9", 1.0, "ao") + +# Name: Concrete (Regular) +# Density: 2.3 g/cm3 +# Reference: Provided by Matthey Carey, MIT EHS/RPP (mgcarey@mit.edu) +# Describes: Facility walls, foundation, floors for activation calculations +Material_40 = openmc.Material() +Material_40.set_density("g/cm3", 2.3) +Material_40.add_nuclide("Fe54", 2.0138e-05, "ao") +Material_40.add_nuclide("Fe56", 0.00031874, "ao") +Material_40.add_nuclide("Fe57", 7.2915e-06, "ao") +Material_40.add_nuclide("Fe58", 1.0416e-06, "ao") +Material_40.add_nuclide("H1", 0.01374, "ao") +Material_40.add_nuclide("H2", 2.0613e-06, "ao") +Material_40.add_nuclide("O16", 0.045685, "ao") +Material_40.add_nuclide("O17", 1.8318e-05, "ao") +Material_40.add_nuclide("Mg24", 9.0027e-05, "ao") +Material_40.add_nuclide("Mg25", 1.1397e-05, "ao") +Material_40.add_nuclide("Mg26", 1.2548e-05, "ao") +Material_40.add_nuclide("Ca40", 0.001474, "ao") +Material_40.add_nuclide("Ca42", 9.8378e-06, "ao") +Material_40.add_nuclide("Ca43", 2.0527e-06, "ao") +Material_40.add_nuclide("Ca44", 3.1718e-05, "ao") +Material_40.add_nuclide("Ca46", 6.0821e-08, "ao") +Material_40.add_nuclide("Ca48", 2.8434e-06, "ao") +Material_40.add_nuclide("Si28", 0.015328, "ao") +Material_40.add_nuclide("Si29", 0.00077613, "ao") +Material_40.add_nuclide("Si30", 0.0005152, "ao") +Material_40.add_nuclide("Na23", 0.00096395, "ao") +Material_40.add_nuclide("K39", 0.00042949, "ao") +Material_40.add_nuclide("K40", 4.6053e-08, "ao") +Material_40.add_nuclide("K41", 3.0993e-05, "ao") +Material_40.add_nuclide("Al27", 0.0017453, "ao") +Material_40.add_nuclide("C12", 0.00011404, "ao") +Material_40.add_nuclide("C13", 1.28e-06, "ao") + +# Soil material taken from PNNL Materials Compendium for Earth, U.S. Average +Soil = openmc.Material(name="Soil") +Soil.set_density("g/cm3", 1.52) +Soil.add_element("O", 0.670604, percent_type="ao") +Soil.add_element("Na", 0.005578, percent_type="ao") +Soil.add_element("Mg", 0.011432, percent_type="ao") +Soil.add_element("Al", 0.053073, percent_type="ao") +Soil.add_element("Si", 0.201665, percent_type="ao") +Soil.add_element("K", 0.007653, percent_type="ao") +Soil.add_element("Ca", 0.026664, percent_type="ao") +Soil.add_element("Ti", 0.002009, percent_type="ao") +Soil.add_element("Mn", 0.000272, percent_type="ao") +Soil.add_element("Fe", 0.021050, percent_type="ao") + +# Brick material taken from "Brick, Common Silica" from the PNNL Materials Compendium +# PNNL-15870, Rev. 2 +Brick = openmc.Material(name="Brick") +Brick.set_density("g/cm3", 1.8) +Brick.add_element("O", 0.663427, percent_type="ao") +Brick.add_element("Al", 0.003747, percent_type="ao") +Brick.add_element("Si", 0.323229, percent_type="ao") +Brick.add_element("Ca", 0.007063, percent_type="ao") +Brick.add_element("Fe", 0.002534, percent_type="ao") + +# Previous model uses 10% borated high density polyethylene, but +# according to Melhus, et. al., RicoRad consists of "2.00% mass boron +# in a polyethylene-based matrix having a mass density of 0.945 g/cm^3" +# Source: +# Melhus, Christopher, et al. ‘Storage Safe Shielding Assessment for a +# HDR Californium-252 Brachytherapy Source’. +# Monte Carlo 2005 Topical Meeting, 01 2005, pp. 219–229. + +RicoRad = openmc.Material(name="RicoRad") +RicoRad.set_density("g/cm3", 0.945) +RicoRad.add_element("H", 0.14, percent_type="wo") +RicoRad.add_element("C", 0.84, percent_type="wo") +RicoRad.add_element("B", 0.02, percent_type="wo") + +### LIBRA Materials +Steel = openmc.Material(name="Steel") +Steel.add_element("C", 0.005, "wo") +Steel.add_element("Fe", 0.995, "wo") +Steel.set_density("g/cm3", 7.82) + +# Stainless Steel 304 from PNNL Materials Compendium (PNNL-15870 Rev2) +SS304 = openmc.Material(name="Stainless Steel 304") +# SS304.temperature = 700 + 273 +SS304.add_element("C", 0.000800, "wo") +SS304.add_element("Mn", 0.020000, "wo") +SS304.add_element("P", 0.000450, "wo") +SS304.add_element("S", 0.000300, "wo") +SS304.add_element("Si", 0.010000, "wo") +SS304.add_element("Cr", 0.190000, "wo") +SS304.add_element("Ni", 0.095000, "wo") +SS304.add_element("Fe", 0.683450, "wo") +SS304.set_density("g/cm3", 8.00) + +# Using Microtherm with 1 a% Al2O3, 27 a% ZrO2, and 72 a% SiO2 +# https://www.foundryservice.com/product/microporous-silica-insulating-boards-mintherm-microtherm-1925of-grades/ +Firebrick = openmc.Material(name="Firebrick") +# Estimate average temperature of Firebrick to be around 300 C +# Firebrick.temperature = 273 + 300 +Firebrick.add_element("Al", 0.004, "ao") +Firebrick.add_element("O", 0.666, "ao") +Firebrick.add_element("Si", 0.240, "ao") +Firebrick.add_element("Zr", 0.090, "ao") +Firebrick.set_density("g/cm3", 0.30) + +# Using 2:1 atom ratio of LiF to BeF2, similar to values in +# Seifried, Jeffrey E., et al. ‘A General Approach for Determination of +# Acceptable FLiBe Impurity Concentrations in Fluoride-Salt Cooled High +# Temperature Reactors (FHRs)’. Nuclear Engineering and Design, vol. 343, 2019, +# pp. 85–95, https://doi.org10.1016/j.nucengdes.2018.09.038. +# Also using natural lithium enrichment (~7.5 a% Li6) +Flibe_nat = openmc.Material(name="Flibe_nat") +# Flibe_nat.temperature = 700 + 273 +Flibe_nat.add_element("Be", 0.142857, "ao") +Flibe_nat.add_nuclide("Li6", 0.021685, "ao") +Flibe_nat.add_nuclide("Li7", 0.264029, "ao") +Flibe_nat.add_element("F", 0.571429, "ao") +Flibe_nat.set_density("g/cm3", 1.94) + +Copper = openmc.Material(name="Copper") +# Estimate copper temperature to be around 100 C +# Copper.temperature = 100 + 273 +Copper.add_element("Cu", 1.0, "ao") +Copper.set_density("g/cm3", 8.96) + +Be = openmc.Material(name="Be") +# Estimate Be temperature to be around 100 C +# Be.temperature = 100 + 273 +Be.add_element("Be", 1.0, "ao") +Be.set_density("g/cm3", 1.848) diff --git a/data/processed_data.json b/data/processed_data.json new file mode 100644 index 0000000..de05710 --- /dev/null +++ b/data/processed_data.json @@ -0,0 +1,6 @@ +{ + "modelled_TBR": { + "mean": 0.0010284561041604611, + "std_dev": 2.92884836844823e-05 + } +} \ No newline at end of file diff --git a/environment.yml b/environment.yml index 75faaa1..a32ae23 100644 --- a/environment.yml +++ b/environment.yml @@ -1,9 +1,9 @@ -name: libra-run-env +name: BABY_1l_LiPb channels: - conda-forge dependencies: - python - - openmc # add version tag + - openmc~=0.15.0 - openmc-plotter - numpy # add version tag - scipy # add version tag @@ -16,7 +16,7 @@ dependencies: - pint - pip - pip: - - git+https://github.com/libra-project/libra-toolbox # add version tag - - openmc_data_downloader + - git+https://github.com/libra-project/libra-toolbox@v0.3 + - openmc_data_downloader~=0.6.0 - matplotlib-label-lines - - h-transport-materials + - h-transport-materials~=0.17