pep8

Author: shimwell

openmc_dagmc_wrapper/Geometry.py

@@ -1,4 +1,3 @@
-
 from typing import Tuple
 
 import dagmc_h5m_file_inspector as di
@@ -30,7 +29,7 @@ def __init__(
         self,
         h5m_filename: str = None,
         reflective_angles: Tuple[float, float] = None,
-        graveyard_box=None
+        graveyard_box=None,
     ):
         self.h5m_filename = h5m_filename
         self.reflective_angles = reflective_angles
@@ -45,7 +44,7 @@ def make_root(self):
         if self.reflective_angles is None:
             # if a graveyard is not found in the dagmc geometry a CSG one is
             # made
-            if 'graveyard' not in di.get_materials_from_h5m(self.h5m_filename):
+            if "graveyard" not in di.get_materials_from_h5m(self.h5m_filename):
                 # vac_surfs = self.create_cube_of_vacuum_surfaces()
                 # # creates a cube of surfaces for the boundary conditions
                 # region = +vac_surfs[0] & \
@@ -58,9 +57,7 @@ def make_root(self):
                 region = -vac_surf
 
                 containing_cell = openmc.Cell(
-                    cell_id=9999,
-                    region=region,
-                    fill=dag_univ
+                    cell_id=9999, region=region, fill=dag_univ
                 )
                 root = [containing_cell]
             else:
@@ -72,7 +69,7 @@ def make_root(self):
                 c=0.0,
                 d=0.0,
                 surface_id=9991,
-                boundary_type='reflective'
+                boundary_type="reflective",
             )
 
             reflective_2 = openmc.Plane(
@@ -81,22 +78,18 @@ def make_root(self):
                 c=0.0,
                 d=0.0,
                 surface_id=9990,
-                boundary_type='reflective'
+                boundary_type="reflective",
             )
 
             # if a graveyard is not found in the dagmc geometry a CSG one is
             # made
-            if 'graveyard' in di.get_materials_from_h5m(self.h5m_filename):
+            if "graveyard" in di.get_materials_from_h5m(self.h5m_filename):
                 region = -reflective_1 & +reflective_2
             else:
                 vac_surf = self.create_sphere_of_vacuum_surface()
                 region = -vac_surf & -reflective_1 & +reflective_2
 
-            containing_cell = openmc.Cell(
-                cell_id=9999,
-                region=region,
-                fill=dag_univ
-            )
+            containing_cell = openmc.Cell(cell_id=9999, region=region, fill=dag_univ)
 
             root = [containing_cell]
         return root
@@ -112,9 +105,8 @@ def create_sphere_of_vacuum_surface(self):
         largest_radius = max(max(bbox[0]), max(bbox[1]))
 
         sphere_surface = openmc.Sphere(
-            r=largest_radius,
-            surface_id=9999,
-            boundary_type='vacuum')
+            r=largest_radius, surface_id=9999, boundary_type="vacuum"
+        )
 
         return sphere_surface
 
@@ -130,31 +122,13 @@ def create_cube_of_vacuum_surfaces(self):
         bbox[0][0] = 0.0
         bbox[0][1] = 0.0
 
-        lower_x = openmc.XPlane(
-            bbox[0][0],
-            surface_id=9999,
-            boundary_type='vacuum')
-        upper_x = openmc.XPlane(
-            bbox[1][0],
-            surface_id=9998,
-            boundary_type='vacuum')
-
-        lower_y = openmc.YPlane(
-            bbox[0][1],
-            surface_id=9997,
-            boundary_type='vacuum')
-        upper_y = openmc.YPlane(
-            bbox[1][1],
-            surface_id=9996,
-            boundary_type='vacuum')
-
-        lower_z = openmc.ZPlane(
-            bbox[0][2],
-            surface_id=9995,
-            boundary_type='vacuum')
-        upper_z = openmc.ZPlane(
-            bbox[1][2],
-            surface_id=9994,
-            boundary_type='vacuum')
+        lower_x = openmc.XPlane(bbox[0][0], surface_id=9999, boundary_type="vacuum")
+        upper_x = openmc.XPlane(bbox[1][0], surface_id=9998, boundary_type="vacuum")
+
+        lower_y = openmc.YPlane(bbox[0][1], surface_id=9997, boundary_type="vacuum")
+        upper_y = openmc.YPlane(bbox[1][1], surface_id=9996, boundary_type="vacuum")
+
+        lower_z = openmc.ZPlane(bbox[0][2], surface_id=9995, boundary_type="vacuum")
+        upper_z = openmc.ZPlane(bbox[1][2], surface_id=9994, boundary_type="vacuum")
 
         return [lower_x, upper_x, lower_y, upper_y, lower_z, upper_z]

openmc_dagmc_wrapper/Materials.py

@@ -1,4 +1,3 @@
-
 import dagmc_h5m_file_inspector as di
 import neutronics_material_maker as nmm
 import openmc
@@ -34,16 +33,13 @@ def correspondence_dict(self):
     @correspondence_dict.setter
     def correspondence_dict(self, value):
         if not isinstance(value, dict):
-            raise TypeError(
-                ".correspondence_dict should be a dictionary"
-            )
+            raise TypeError(".correspondence_dict should be a dictionary")
         self._correspondence_dict = value
 
     def set_openmc_materials(self):
         openmc_materials = {}
         for material_tag, material_entry in self.correspondence_dict.items():
-            openmc_material = create_material(
-                material_tag, material_entry)
+            openmc_material = create_material(material_tag, material_entry)
             openmc_materials[material_tag] = openmc_material
 
         self.openmc_materials = openmc_materials
@@ -70,7 +66,8 @@ def checks(self):
                 f"the number of materials provided in the correspondence_dict "
                 f"{len(self.correspondence_dict.keys())} "
                 f"is not equal to the number of materials specified in the "
-                f"DAGMC h5m file {required_nb_of_materials}")
+                f"DAGMC h5m file {required_nb_of_materials}"
+            )
             raise ValueError(msg)
 
         silently_remove_file("materials.xml")

openmc_dagmc_wrapper/Settings.py

@@ -1,4 +1,3 @@
-
 import openmc
 
 
@@ -13,5 +12,5 @@ def __init__(self):
         super().__init__()
 
         # performed after the super init as these are setting attributes
-        self.run_mode = 'fixed source'
+        self.run_mode = "fixed source"
         self.inactive = 0

openmc_dagmc_wrapper/Tally.py

@@ -17,11 +17,7 @@ class Tally(openmc.Tally):
     specified materials or volumes.
     """
 
-    def __init__(
-        self,
-        tally_type,
-        **kwargs
-    ):
+    def __init__(self, tally_type, **kwargs):
 
         self.tally_type = tally_type
         super().__init__(**kwargs)
@@ -61,9 +57,12 @@ def tally_type(self, value):
 
     def set_score(self):
         flux_scores = [
-            "neutron_fast_flux", "photon_fast_flux",
-            "neutron_spectra", "photon_spectra",
-            "neutron_effective_dose", "photon_effective_dose"
+            "neutron_fast_flux",
+            "photon_fast_flux",
+            "neutron_spectra",
+            "photon_spectra",
+            "neutron_effective_dose",
+            "photon_effective_dose",
         ]
 
         if self.tally_type == "TBR":
@@ -155,29 +154,25 @@ class CellTallies:
         h5m_filename
     """
 
-    def __init__(
-            self,
-            tally_types,
-            targets=[None],
-            materials=None,
-            h5m_filename=None):
+    def __init__(self, tally_types, targets=[None], materials=None, h5m_filename=None):
         self.tallies = []
         self.tally_types = tally_types
         self.targets = targets
         self.materials = materials
         self.h5m_filename = h5m_filename
 
-        if self.targets == 'all_volumes':
+        if self.targets == "all_volumes":
             all_targets = di.get_volumes_from_h5m(self.h5m_filename)
-        elif self.targets == 'all_materials':
+        elif self.targets == "all_materials":
             all_targets = di.get_materials_from_h5m(self.h5m_filename)
         else:
             all_targets = self.targets
 
         for score in self.tally_types:
             for target in all_targets:
-                self.tallies.append(CellTally(
-                    tally_type=score, target=target, materials=materials))
+                self.tallies.append(
+                    CellTally(tally_type=score, target=target, materials=materials)
+                )
 
 
 class TetMeshTally(Tally):
@@ -208,11 +203,9 @@ def create_unstructured_mesh(self):
             # format
             library = "moab"
         else:
-            msg = ("only h5m or exo files are accepted as valid "
-                   "filename values")
+            msg = "only h5m or exo files are accepted as valid " "filename values"
             raise ValueError(msg)
-        self.umesh = openmc.UnstructuredMesh(
-            self.filename, library=library)
+        self.umesh = openmc.UnstructuredMesh(self.filename, library=library)
 
 
 class TetMeshTallies:
@@ -231,17 +224,12 @@ def __init__(self, tally_types, filenames):
         self.tally_types = tally_types
         for score in self.tally_types:
             for filename in filenames:
-                self.tallies.append(
-                    TetMeshTally(tally_type=score, filename=filename))
+                self.tallies.append(TetMeshTally(tally_type=score, filename=filename))
 
 
 class MeshTally3D(Tally):
     def __init__(
-        self,
-        tally_type,
-        mesh_resolution=(100, 100, 100),
-        bounding_box=None,
-        **kwargs
+        self, tally_type, mesh_resolution=(100, 100, 100), bounding_box=None, **kwargs
     ):
         self.tally_type = tally_type
         self.mesh_resolution = mesh_resolution
@@ -253,8 +241,7 @@ def __init__(
     def add_mesh_filter(self, bounding_box):
 
         if isinstance(bounding_box, str):
-            self.bounding_box = find_bounding_box(
-                h5m_filename=bounding_box)
+            self.bounding_box = find_bounding_box(h5m_filename=bounding_box)
         else:
             self.bounding_box = bounding_box
 
@@ -277,10 +264,7 @@ class MeshTallies3D:
     """
 
     def __init__(
-        self,
-        tally_types,
-        meshes_resolution=(100, 100, 100),
-        bounding_box=None
+        self, tally_types, meshes_resolution=(100, 100, 100), bounding_box=None
     ):
         self.tallies = []
         self.tally_types = tally_types
@@ -289,7 +273,8 @@ def __init__(
                 MeshTally3D(
                     tally_type=tally_type,
                     mesh_resolution=meshes_resolution,
-                    bounding_box=bounding_box)
+                    bounding_box=bounding_box,
+                )
             )
 
 
@@ -305,11 +290,7 @@ class MeshTally2D(Tally):
     """
 
     def __init__(
-        self,
-        tally_type,
-        plane,
-        mesh_resolution=(400, 400),
-        bounding_box=None
+        self, tally_type, plane, mesh_resolution=(400, 400), bounding_box=None
     ):
         self.tally_type = tally_type
         self.plane = plane
@@ -403,8 +384,7 @@ def set_bounding_box(self, bounding_box):
 
         if isinstance(bounding_box, str):
             self.bbox_from_h5 = True
-            self.bounding_box = find_bounding_box(
-                h5m_filename=bounding_box)
+            self.bounding_box = find_bounding_box(h5m_filename=bounding_box)
         else:
             self.bbox_from_h5 = False
             self.bounding_box = bounding_box
@@ -434,9 +414,11 @@ def __init__(
             for plane in planes:
                 self.tallies.append(
                     MeshTally2D(
-                        tally_type=tally_type, plane=plane,
+                        tally_type=tally_type,
+                        plane=plane,
                         mesh_resolution=meshes_resolution,
-                        bounding_box=bounding_box)
+                        bounding_box=bounding_box,
+                    )
                 )
 
 
@@ -471,12 +453,12 @@ def compute_filters(tally_type):
         additional_filters = [photon_particle_filter, energy_filter]
     elif tally_type == "neutron_effective_dose":
         energy_function_filter_n = openmc.EnergyFunctionFilter(
-            energy_bins_n, dose_coeffs_n)
-        additional_filters = [
-            neutron_particle_filter, energy_function_filter_n]
+            energy_bins_n, dose_coeffs_n
+        )
+        additional_filters = [neutron_particle_filter, energy_function_filter_n]
     elif tally_type == "photon_effective_dose":
         energy_function_filter_p = openmc.EnergyFunctionFilter(
-            energy_bins_p, dose_coeffs_p)
-        additional_filters = [
-            photon_particle_filter, energy_function_filter_p]
+            energy_bins_p, dose_coeffs_p
+        )
+        additional_filters = [photon_particle_filter, energy_function_filter_p]
     return additional_filters

openmc_dagmc_wrapper/__init__.py

@@ -2,6 +2,12 @@
 
 from .Geometry import Geometry
 from .Materials import Materials
-from .Tally import CellTally, CellTallies, MeshTally2D, MeshTallies2D, \
-    MeshTally3D, MeshTallies3D
+from .Tally import (
+    CellTally,
+    CellTallies,
+    MeshTally2D,
+    MeshTallies2D,
+    MeshTally3D,
+    MeshTallies3D,
+)
 from .Settings import FusionSettings