autopep8

Author: yardasol

openmc/examples.py

@@ -7,6 +7,7 @@
 C5G7_N_DG = 8
 PINCELL_PITCH = 1.26
 
+
 def pwr_pin_cell() -> openmc.Model:
     """Create a PWR pin-cell model.
 
@@ -656,6 +657,7 @@ def slab_mg(num_regions=1, mat_names=None, mgxslib_name='2g.h5') -> openmc.Model
 
     return model
 
+
 def _generate_c5g7_materials(kinetic) -> openmc.Materials:
     """Generate materials utilizing multi-group cross sections based on the
     the C5G7 Benchmark.
@@ -836,6 +838,7 @@ def _generate_c5g7_materials(kinetic) -> openmc.Materials:
     materials.cross_sections = "mgxs.h5"
     return materials
 
+
 def _generate_random_ray_pin_cell(uo2, water) -> openmc.Universe:
     """Create a random ray pin cell universe. Helper function for
     random_ray_pin_cell() and random_ray_lattice()
@@ -905,6 +908,7 @@ def _generate_random_ray_pin_cell(uo2, water) -> openmc.Universe:
 
     return pincell
 
+
 def random_ray_pin_cell(kinetic=False) -> openmc.Model:
     """Create a PWR pin cell example using C5G7 cross section data.
     cross section data.
@@ -998,6 +1002,7 @@ def random_ray_pin_cell(kinetic=False) -> openmc.Model:
     model.tallies = tallies
     return model
 
+
 def random_ray_lattice(kinetic=False) -> openmc.Model:
     """Create a 2x2 PWR pin cell asymmetrical lattice example.
 
@@ -1034,7 +1039,7 @@ def random_ray_lattice(kinetic=False) -> openmc.Model:
     moderator_infinite = openmc.Cell(name='moderator infinite')
     if kinetic:
         water_reflector = water.clone()
-        water_reflector.name='Water Reflector'
+        water_reflector.name = 'Water Reflector'
         water_reflector.set_density('macro', 1.0)
         materials.append(water_reflector)
         moderator_infinite.fill = water_reflector
@@ -1146,6 +1151,7 @@ def random_ray_lattice(kinetic=False) -> openmc.Model:
     model.tallies = tallies
     return model
 
+
 def random_ray_three_region_cube() -> openmc.Model:
     """Create a three region cube model.
 

openmc/material.py

@@ -183,7 +183,6 @@ def __init__(
         if components is not None:
             self.add_components(components, percent_type=percent_type)
 
-
     def __repr__(self) -> str:
         string = 'Material\n'
         string += '{: <16}=\t{}\n'.format('\tID', self._id)
@@ -204,7 +203,8 @@ def __repr__(self) -> str:
         string += '{: <16}\n'.format('\tS(a,b) Tables')
 
         if self._ncrystal_cfg:
-            string += '{: <16}=\t{}\n'.format('\tNCrystal conf', self._ncrystal_cfg)
+            string += '{: <16}=\t{}\n'.format('\tNCrystal conf',
+                                              self._ncrystal_cfg)
 
         for sab in self._sab:
             string += '{: <16}=\t{}\n'.format('\tS(a,b)', sab)
@@ -335,7 +335,7 @@ def fissionable_mass(self) -> float:
             Z = openmc.data.zam(nuc)[0]
             if Z >= 90:
                 density += 1e24 * atoms_per_bcm * openmc.data.atomic_mass(nuc) \
-                           / openmc.data.AVOGADRO
+                    / openmc.data.AVOGADRO
         return density*self.volume
 
     @property
@@ -384,7 +384,8 @@ def get_decay_photon_energy(
         cv.check_value('units', units, {'Bq', 'Bq/g', 'Bq/kg', 'Bq/cm3'})
 
         if exclude_nuclides is not None and include_nuclides is not None:
-            raise ValueError("Cannot specify both exclude_nuclides and include_nuclides")
+            raise ValueError(
+                "Cannot specify both exclude_nuclides and include_nuclides")
 
         if units == 'Bq':
             multiplier = volume if volume is not None else self.volume
@@ -515,12 +516,12 @@ def from_ncrystal(cls, cfg, **kwargs) -> Material:
         nc_mat = NCrystal.createInfo(cfg)
 
         def openmc_natabund(Z):
-            #nc_mat.getFlattenedComposition might need natural abundancies.
-            #This call-back function is used so NCrystal can flatten composition
-            #using OpenMC's natural abundancies. In practice this function will
-            #only get invoked in the unlikely case where a material is specified
-            #by referring both to natural elements and specific isotopes of the
-            #same element.
+            # nc_mat.getFlattenedComposition might need natural abundancies.
+            # This call-back function is used so NCrystal can flatten composition
+            # using OpenMC's natural abundancies. In practice this function will
+            # only get invoked in the unlikely case where a material is specified
+            # by referring both to natural elements and specific isotopes of the
+            # same element.
             elem_name = openmc.data.ATOMIC_SYMBOL[Z]
             return [
                 (int(iso_name[len(elem_name):]), abund)
@@ -564,7 +565,8 @@ def add_volume_information(self, volume_calc):
                 raise ValueError('No volume information found for material ID={}.'
                                  .format(self.id))
         else:
-            raise ValueError(f'No volume information found for material ID={self.id}.')
+            raise ValueError(
+                f'No volume information found for material ID={self.id}.')
 
     def set_density(self, units: str, density: float | None = None,
                     density_timeseries: list[float] | None = None):
@@ -608,9 +610,9 @@ def set_density(self, units: str, density: float | None = None,
             self._density = density
             if density_timeseries is not None:
                 cv.check_type(f'the density timeseries for Material ID="{self.id}"',
-                          density_timeseries, Iterable, Real)
+                              density_timeseries, Iterable, Real)
                 [cv.check_greater_than(f'an element in density timeseries for Material ID="{self.id}"',
-                                x, 0.0) for x in density_timeseries]
+                                       x, 0.0) for x in density_timeseries]
                 self._density_timeseries = density_timeseries
             else:
                 self._density_timeseries = None
@@ -635,7 +637,8 @@ def add_nuclide(self, nuclide: str, percent: float, percent_type: str = 'ao'):
 
         if self._macroscopic is not None:
             msg = 'Unable to add a Nuclide to Material ID="{}" as a ' \
-                  'macroscopic data-set has already been added'.format(self._id)
+                  'macroscopic data-set has already been added'.format(
+                      self._id)
             raise ValueError(msg)
 
         if self._ncrystal_cfg is not None:
@@ -872,7 +875,8 @@ def add_element(self, element: str, percent: float, percent_type: str = 'ao',
 
         if self._macroscopic is not None:
             msg = 'Unable to add an Element to Material ID="{}" as a ' \
-                  'macroscopic data-set has already been added'.format(self._id)
+                  'macroscopic data-set has already been added'.format(
+                      self._id)
             raise ValueError(msg)
 
         if enrichment is not None and enrichment_target is None:
@@ -961,10 +965,10 @@ def add_elements_from_formula(self, formula: str, percent_type: str = 'ao',
                         msg = f'Formula entry {token} not an element symbol.'
                         raise ValueError(msg)
                 elif token not in ['(', ')', ''] and not token.isdigit():
-                        msg = 'Formula must be made from a sequence of ' \
-                              'element symbols, integers, and brackets. ' \
-                              '{} is not an allowable entry.'.format(token)
-                        raise ValueError(msg)
+                    msg = 'Formula must be made from a sequence of ' \
+                          'element symbols, integers, and brackets. ' \
+                          '{} is not an allowable entry.'.format(token)
+                    raise ValueError(msg)
 
         # Checks that the number of opening and closing brackets are equal
         if formula.count('(') != formula.count(')'):
@@ -1026,12 +1030,13 @@ def add_s_alpha_beta(self, name: str, fraction: float = 1.0):
 
         if self._macroscopic is not None:
             msg = 'Unable to add an S(a,b) table to Material ID="{}" as a ' \
-                  'macroscopic data-set has already been added'.format(self._id)
+                  'macroscopic data-set has already been added'.format(
+                      self._id)
             raise ValueError(msg)
 
         if not isinstance(name, str):
             msg = 'Unable to add an S(a,b) table to Material ID="{}" with a ' \
-                        'non-string table name "{}"'.format(self._id, name)
+                'non-string table name "{}"'.format(self._id, name)
             raise ValueError(msg)
 
         cv.check_type('S(a,b) fraction', fraction, Real)
@@ -1168,7 +1173,7 @@ def get_nuclide_atom_densities(self, nuclide: str | None = None) -> dict[str, fl
         if not percent_in_atom:
             for n, nuc in enumerate(nucs):
                 nuc_densities[n] *= self.average_molar_mass / \
-                                    openmc.data.atomic_mass(nuc)
+                    openmc.data.atomic_mass(nuc)
 
         # Now that we have the atomic amounts, lets finish calculating densities
         sum_percent = np.sum(nuc_densities)
@@ -1177,7 +1182,7 @@ def get_nuclide_atom_densities(self, nuclide: str | None = None) -> dict[str, fl
         # Convert the mass density to an atom density
         if not density_in_atom:
             density = -density / self.average_molar_mass * 1.e-24 \
-                      * openmc.data.AVOGADRO
+                * openmc.data.AVOGADRO
 
         nuc_densities = density * nuc_densities
 
@@ -1217,19 +1222,19 @@ def get_element_atom_densities(self, element: str | None = None) -> dict[str, fl
 
         # Accumulate densities for each nuclide
         for nuclide, density in nuc_densities.items():
-            nuc_element = openmc.data.ATOMIC_SYMBOL[openmc.data.zam(nuclide)[0]]
+            nuc_element = openmc.data.ATOMIC_SYMBOL[openmc.data.zam(nuclide)[
+                0]]
             if element is None or element == nuc_element:
                 if nuc_element not in densities:
                     densities[nuc_element] = 0.0
                 densities[nuc_element] += float(density)
 
         # If specific element was requested, make sure it is present
         if element is not None and element not in densities:
-                raise ValueError(f'Element {element} not found in material.')
+            raise ValueError(f'Element {element} not found in material.')
 
         return densities
 
-
     def get_activity(self, units: str = 'Bq/cm3', by_nuclide: bool = False,
                      volume: float | None = None) -> dict[str, float] | float:
         """Returns the activity of the material or of each nuclide within.
@@ -1259,7 +1264,8 @@ def get_activity(self, units: str = 'Bq/cm3', by_nuclide: bool = False,
             of the material is returned as a float.
         """
 
-        cv.check_value('units', units, {'Bq', 'Bq/g', 'Bq/kg', 'Bq/cm3', 'Ci', 'Ci/m3'})
+        cv.check_value('units', units, {
+                       'Bq', 'Bq/g', 'Bq/kg', 'Bq/cm3', 'Ci', 'Ci/m3'})
         cv.check_type('by_nuclide', by_nuclide, bool)
 
         if volume is None:
@@ -1332,7 +1338,8 @@ def get_decay_heat(self, units: str = 'W', by_nuclide: bool = False,
             decay_erg = openmc.data.decay_energy(nuclide)
             inv_seconds = openmc.data.decay_constant(nuclide)
             decay_erg *= openmc.data.JOULE_PER_EV
-            decayheat[nuclide] = inv_seconds * decay_erg * 1e24 * atoms_per_bcm * multiplier
+            decayheat[nuclide] = inv_seconds * decay_erg * \
+                1e24 * atoms_per_bcm * multiplier
 
         return decayheat if by_nuclide else sum(decayheat.values())
 
@@ -1383,7 +1390,7 @@ def get_mass_density(self, nuclide: str | None = None) -> float:
         mass_density = 0.0
         for nuc, atoms_per_bcm in self.get_nuclide_atom_densities(nuclide=nuclide).items():
             density_i = 1e24 * atoms_per_bcm * openmc.data.atomic_mass(nuc) \
-                        / openmc.data.AVOGADRO
+                / openmc.data.AVOGADRO
             mass_density += density_i
         return mass_density
 
@@ -1566,12 +1573,13 @@ def _get_macroscopic_xml(self, macroscopic: str) -> ET.Element:
 
     def _get_nuclides_xml(
             self, nuclides: Iterable[NuclideTuple],
-            nuclides_to_ignore: Iterable[str] | None = None)-> list[ET.Element]:
+            nuclides_to_ignore: Iterable[str] | None = None) -> list[ET.Element]:
         xml_elements = []
 
         # Remove any nuclides to ignore from the XML export
         if nuclides_to_ignore:
-            nuclides = [nuclide for nuclide in nuclides if nuclide.name not in nuclides_to_ignore]
+            nuclides = [
+                nuclide for nuclide in nuclides if nuclide.name not in nuclides_to_ignore]
 
         xml_elements = [self._get_nuclide_xml(nuclide) for nuclide in nuclides]
 
@@ -1608,9 +1616,11 @@ def to_xml_element(
 
         if self._ncrystal_cfg:
             if self._sab:
-                raise ValueError("NCrystal materials are not compatible with S(a,b).")
+                raise ValueError(
+                    "NCrystal materials are not compatible with S(a,b).")
             if self._macroscopic is not None:
-                raise ValueError("NCrystal materials are not compatible with macroscopic cross sections.")
+                raise ValueError(
+                    "NCrystal materials are not compatible with macroscopic cross sections.")
 
             element.set("cfg", str(self._ncrystal_cfg))
 
@@ -1625,11 +1635,13 @@ def to_xml_element(
                 subelement.set("value", str(self._density))
             subelement.set("units", self._density_units)
             if self._density_timeseries is not None:
-                timeseries_text = " ".join(str(x) for x in self._density_timeseries)
+                timeseries_text = " ".join(str(x)
+                                           for x in self._density_timeseries)
                 subelement.set("value_timeseries", timeseries_text)
 
         else:
-            raise ValueError(f'Density has not been set for material {self.id}!')
+            raise ValueError(
+                f'Density has not been set for material {self.id}!')
 
         if self._macroscopic is None:
             # Create nuclide XML subelements
@@ -1730,17 +1742,18 @@ def mix_materials(cls, materials, fracs: Iterable[float],
                 nuc_per_cc = wgt*1.e24*atoms_per_bcm
                 nuclides_per_cc[nuc] += nuc_per_cc
                 mass_per_cc[nuc] += nuc_per_cc*openmc.data.atomic_mass(nuc) / \
-                                    openmc.data.AVOGADRO
+                    openmc.data.AVOGADRO
 
         # Create the new material with the desired name
         if "name" not in kwargs:
             kwargs["name"] = '-'.join([f'{m.name}({f})' for m, f in
-                             zip(materials, fracs)])
+                                       zip(materials, fracs)])
 
         new_mat = cls(**kwargs)
 
         # Compute atom fractions of nuclides and add them to the new material
-        tot_nuclides_per_cc = np.sum([dens for dens in nuclides_per_cc.values()])
+        tot_nuclides_per_cc = np.sum(
+            [dens for dens in nuclides_per_cc.values()])
         for nuc, atom_dens in nuclides_per_cc.items():
             new_mat.add_nuclide(nuc, atom_dens/tot_nuclides_per_cc, 'ao')
 
@@ -1887,7 +1900,6 @@ def deplete(
 
         return depleted_materials_dict[self.id]
 
-
     def mean_free_path(self, energy: float) -> float:
         """Calculate the mean free path of neutrons in the material at a given
         energy.
@@ -2030,7 +2042,8 @@ def _write_xml(self, file, header=True, level=0, spaces_per_level=2,
 
         # Write the <material> elements.
         for material in sorted(set(self), key=lambda x: x.id):
-            element = material.to_xml_element(nuclides_to_ignore=nuclides_to_ignore)
+            element = material.to_xml_element(
+                nuclides_to_ignore=nuclides_to_ignore)
             clean_indentation(element, level=level+1)
             element.tail = element.tail.strip(' ')
             file.write((level+1)*spaces_per_level*' ')
@@ -2116,7 +2129,6 @@ def from_xml(cls, path: PathLike = 'materials.xml') -> Materials:
 
         return cls.from_xml_element(root)
 
-
     def deplete(
         self,
         multigroup_fluxes: Sequence[Sequence[float]],