Add instance parameter to data generation and update output files

Author: markcoletti

examples-proposed/024-aggregated-compute-ensemble/gen_data.py

@@ -5,24 +5,28 @@
 import argparse
 from typing import Any
 import json
+import csv
 import numpy as np
 import matplotlib.pyplot as plt
 
+from ipsframework.resourceHelper import get_platform_info
 
-def main(alpha: float, L:float, T_final:float, Nx:int, Nt:int) -> dict[str, Any]:
+def main(instance: str,
+         alpha: float, L:float, T_final:float, Nx:int, Nt:int) -> dict[str, Any]:
     """ Generate synthetic data to emulate an actual simulation or complex
             calculation.
 
         As a side-effect it will save a plot to the current working directory with
         the name `solution.png`.
 
+        :param instance: instance name
         :param alpha: thermal diffusivity
         :param L: domain length
         :param T_final: final time
         :param Nx: number of spatial grid points
         :param Nt: number of time steps
         :returns: x, y, where x is the steps and u the corresponding values
-        """
+    """
     # Discretization
     dx = L / (Nx - 1)
     dt = T_final / Nt
@@ -33,9 +37,6 @@ def main(alpha: float, L:float, T_final:float, Nx:int, Nt:int) -> dict[str, Any]
         print("Warning: Stability condition r <= 0.5 is not met. "
               "Results may be inaccurate.")
 
-    # Initialize solution array
-    u = np.zeros(Nx)
-
     # Initial condition (e.g., a sine wave)
     x = np.linspace(0, L, Nx)
     u = np.sin(np.pi * x)
@@ -60,13 +61,36 @@ def main(alpha: float, L:float, T_final:float, Nx:int, Nt:int) -> dict[str, Any]
     plt.grid(True)
     plt.savefig("solution.png")
 
+    # Save some per-component stats
+    stats_fname = f'{instance}_stats_{timestamp}.csv'
+    run_env = get_platform_info()
+
+    with open(stats_fname, 'w') as f:
+        # Write run-time stats to a CSV as well as the runtime parameters
+        # specific to this instance.
+        writer = csv.writer(f)
+        writer.writerow(
+                ['instance', 'hostname', 'pid', 'core',
+                 'affinity',
+                 'alpha', 'L', 'T_final', 'Nx', 'Nt',
+                 'start', 'end'])
+
+        writer.writerow([instance_id, run_env['hostname'],
+                         run_env['pid'], run_env['core_id'],
+                         run_env['affinity'],
+                         alpha, L, T_final, Nx, Nt,
+                         start, time()])
+
     return {'x': x.tolist(), 'u': u.tolist()}
 
 
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description='Generate synthetic data to '
-                                                 'emulate an actual simulation or complex')
+                                                 'emulate an actual simulation '
+                                                 'or complex')
+    parser.add_argument('--instance', type=str,
+                        help='instance name')
     parser.add_argument('--alpha', type=float, default=1.0,)
     parser.add_argument('--L', type=float, default=1.0,)
     parser.add_argument('--T_final', type=float, default=1.0,)
@@ -75,7 +99,12 @@ def main(alpha: float, L:float, T_final:float, Nx:int, Nt:int) -> dict[str, Any]
 
     args = parser.parse_args()
 
-    data = main(args.alpha, args.L, args.T_final, args.Nx, args.Nt)
+    data = main(args.instance,
+                args.alpha, args.L, args.T_final, args.Nx, args.Nt)
+
+    file_name = f'{args.instance}_solution.json'
+
+    print(f'Writing to {file_name}')
 
-    with open('solution.json', 'w') as f:
+    with open(file_name, 'w') as f:
         json.dump(data, f)

examples-proposed/024-aggregated-compute-ensemble/instance_component.py

@@ -1,29 +1,32 @@
 #!/usr/bin/env python3
 """
-Component to be stepped in instance
-"""
+Component to be stepped in instance.
 
-import csv
-import sys
+This should generate a PNG image, a JSON file, and a CSV file.  The first
+two are from synthetic data generated from `gen_data.py`.  The latter is
+also generated from provenance data captured in `gen_data.py`, too.
+"""
+from pathlib import Path
 from time import time
 from typing import Any
-from pathlib import Path
 
 from ipsframework import Component
-from ipsframework.resourceHelper import get_platform_info
 
 
-def create_cmd(alpha: float, L:float, T_final:float, Nx:int, Nt:int) -> list[Any]:
+def create_cmd(instance: str, alpha: float, L:float, T_final:float,
+               Nx:int, Nt:int) -> list[Any]:
     """ create the command to run the external data generator
 
+    :parma instance: instance name
     :param alpha: thermal diffusivity
     :param L: domain length
     :param T_final: final time
     :param Nx: number of spatial grid points
     :param Nt: number of time steps
     :returns: list of command line arguments to be executed in step()
     """
-    cmd = ['python3', 'gen_data.py', '--alpha', alpha, '--L', L, '--T_final', T_final,
+    cmd = ['python3', 'gen_data.py', '--instance', instance,
+           '--alpha', alpha, '--L', L, '--T_final', T_final,
            '--Nx', Nx, '--Nt', Nt]
     return cmd
 
@@ -45,7 +48,8 @@ def step(self, timestamp: float = 0.0, **keywords):
                            f'T_final={self.T_final}, Nx={self.Nx}, '
                            f'Nt={self.Nt}')
 
-        cmd = create_cmd(self.alpha, self.L, self.T_final, self.Nx, self.Nt)
+        cmd = create_cmd(instance_id,
+                         self.alpha, self.L, self.T_final, self.Nx, self.Nt)
 
         working_dir = str(Path('.').absolute())
         self.services.info(f'{instance_id}: Launching executable '
@@ -60,29 +64,10 @@ def step(self, timestamp: float = 0.0, **keywords):
             self.services.critical(f'{instance_id}: Unable to launch '
                                    f'executable in {working_dir}')
 
-        self.services.wait_task(run_id)  # block until done
-
-        self.services.info(f'{instance_id}: Completed MPI executable.')
-
-
-        # Save some per-component stats
-        stats_fname = f'stats_{timestamp}.csv'
-        run_env = get_platform_info()
+        return_value = self.services.wait_task(run_id)  # block until done
 
-        with open(stats_fname, 'w') as f:
-            # Write run-time stats to a CSV as well as the runtime parameters
-            # specific to this instance.
-            writer = csv.writer(f)
-            writer.writerow(
-                    ['instance', 'executable', 'hostname', 'pid', 'core',
-                     'affinity',
-                     'alpha', 'L', 'T_final', 'Nx', 'Nt',
-                     'start', 'end'])
-            writer.writerow([instance_id, sys.argv[0], run_env['hostname'],
-                             run_env['pid'], run_env['core_id'],
-                             run_env['affinity'],
-                             self.alpha, self.L, self.T_final, self.Nx, self.Nt,
-                             start, time()])
+        self.services.info(f'{instance_id}: Completed MPI executable with '
+                           f'return value: {return_value}.')
 
         # TODO temporarily commenting this out until the actual
         # example is ready to consider adding data files to the portal.  This