Merge pull request #17 from dassh-dev/develop

Merge develop into master

Author: MilosAtz

dassh/__init__.py

@@ -14,7 +14,7 @@
 # permissions and limitations under the License.
 ########################################################################
 """
-date: 2023-02-28
+date: 2023-03-02
 author: Milos Atz, Micheal Smith
 """
 ########################################################################
@@ -46,4 +46,4 @@
 np.set_printoptions(threshold=sys.maxsize, linewidth=500)
 
 
-__version__ = '0.12.0'
+__version__ = '0.12.1'

dassh/__main__.py

@@ -14,7 +14,7 @@
 # permissions and limitations under the License.
 ########################################################################
 """
-date: 2022-12-19
+date: 2023-03-02
 author: matz
 Main DASSH calculation procedures
 """
@@ -59,7 +59,7 @@ def main(args=None):
     print(dassh._ascii._ascii_title)
     in_path = os.path.split(args.inputfile)[0]
     dassh_logger = dassh.logged_class.init_root_logger(in_path, 'dassh')
-    dassh_logger.info("DASSH logger initialized")
+    dassh_logger.info(f"DASSH v{dassh.__version__} logger initialized")
 
     # Pre-processing
     # Read input file and set up DASSH input object

dassh/hotspot.py

@@ -14,7 +14,7 @@
 # permissions and limitations under the License.
 ########################################################################
 """
-date: 2023-02-28
+date: 2023-03-02
 author: matz
 comment: Hot spot analysis via the semistatistical horizontal method
 """
@@ -128,26 +128,29 @@ def analyze(r_obj):
             # Collect assembly IDs that match the name
             ids = [a.id for a in r_obj.assemblies if a.name == asm_name]
             n_asm = len(ids)
-            # Do each hotspot calc
-            for k in _REGIONS:
-
+            for k in _REGIONS:  # Do each hotspot calc
                 if k in hs.keys():
                     # Add assembly IDs/names to relevant list
                     asm_ids[k] += ids
                     asm_names[k] += [asm_name for i in range(n_asm)]
+                    # Pull dT from the assembly
                     dT = _get_peak_dt(r_obj, asm_name, k)
-                    cols = _COLS_NEEDED[k]
-                    subf, expr = _read_hcf_table(hs[k]['subfactors'], cols)
+                    # Read the HCF from the table at the specified path
+                    subf, expr = _read_hcf_table(
+                        hs[k]['subfactors'],
+                        _COLS_NEEDED[k])
+                    # Split the clad OD-MW and MW-ID subfactors
                     if k in ('clad_id', 'fuel_od', 'fuel_cl'):
                         subf, expr = _split_clad_subfactors(subf, expr)
                     subf = _evaluate_hcf_expr(subf, expr, dT)
+                    # Crop the subfactors table based on the size of dT
+                    for typ in subf.keys():
+                        subf[typ] = subf[typ][:, :, :dT.shape[1]]
+                    # Do the calculations
                     peak_temps[k].append(
                         calculate_temps(r_obj.inlet_temp, dT, subf,
                                         IN_sigma=hs[k]['input_sigma'],
                                         OUT_sigma=hs[k]['output_sigma']))
-                # else:
-                #     empty_fill = np.zeros(n_asm)
-                #     peak_temps[k].append(empty_fill)
 
     # Need to sort! Create lists of ids, names, and temps. Sort
     # all according to ids. Then write into output table
@@ -163,14 +166,7 @@ def analyze(r_obj):
             order = np.argsort(asm_ids[k])
             asm_ids[k] = [asm_ids[k][i] for i in order]
             asm_names[k] = [asm_names[k][i] for i in order]
-            try:
-                # peak_temps[k] = np.hstack(peak_temps[k])
-                peak_temps[k] = np.vstack(peak_temps[k])
-            except:
-                print(k)
-                for x in peak_temps[k]:
-                    print(x.shape)
-                raise
+            peak_temps[k] = np.vstack(peak_temps[k])
             peak_temps[k] = peak_temps[k][order]
     # return peak_temps, asm_ids, asm_names
     return peak_temps, asm_ids

dassh/reactor.py

@@ -14,7 +14,7 @@
 # permissions and limitations under the License.
 ########################################################################
 """
-date: 2023-02-28
+date: 2023-03-02
 author: matz
 Object to hold and control DASSH components and execute simulations
 """
@@ -744,21 +744,12 @@ def _setup_core(self, inp_obj):
         gap_fr = inp_obj.data['Core']['bypass_fraction'] * self.flow_rate
 
         # Estimate outlet temperature based on core power
-        # print(t_in, self.total_power, total_fr)
         cool_mat = inp_obj.data['Core']['coolant_material'].lower()
-        # print(self.total_power, self.inlet_temp, self.flow_rate)
         t_out = dassh.utils.Q_equals_mCdT(self.total_power,
                                           self.inlet_temp,
                                           self.materials[cool_mat],
                                           mfr=self.flow_rate)
 
-        # Instantiate and load core object
-        # core_obj = dassh.core.Core(
-        #     geodst,
-        #     gap_fr,
-        #     self.materials[inp_obj.data['Core']['coolant_material'].lower()],
-        #     inlet_temperature=self.inlet_temp,
-        #     model=inp_obj.data['Core']['gap_model'])
         _asm = np.ones(len(inp_obj.data['Assignment']['ByPosition']))
         _asm *= np.nan
         for a in self.assemblies:
@@ -1597,7 +1588,6 @@ def _write_asm_pin_table(self, list_asm_id, list_ax_pos, datatype):
 
         # Load data for postprocessing
         f = os.path.join(self.path, 'temp_pin.csv')
-        print(list_ax_pos)
         temps = dassh.plot._load_data(f, list_ax_pos, list_asm_id_b0)
 
         # Initialize array for each assembly being dumped

dassh/region_rodded.py

@@ -14,7 +14,7 @@
 # permissions and limitations under the License.
 ########################################################################
 """
-date: 2022-12-20
+date: 2023-03-02
 author: matz
 Methods to describe the components of hexagonal fuel typical of
 liquid metal fast reactors
@@ -124,7 +124,6 @@ def make(inp, name, mat, fr, se2geo=False, update_tol=0.0, gravity=False):
                  0.86, 0.86, 4.0 + 0.16 * p2d**5]
         inp['PinModel']['pin_material'] = \
             [x.clone() for x in mat['pin']]
-        print(inp['PinModel'])
         rr.pin_model = PinModel(inp['pin_diameter'],
                                 inp['clad_thickness'],
                                 mat['clad'],