gammasimtools 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

simtools/production_configuration/interpolation_handler.py

@@ -214,17 +214,15 @@ class InterpolationHandler:
         np.ndarray
             Reduced production grid points.
         """
-        production_grid_points = []
-
-        for point in self.grid_points_production:
-            production_grid_points.append(
-                [
-                    point["azimuth"]["value"],
-                    point["zenith_angle"]["value"],
-                    point["nsb"]["value"],
-                    point["offset"]["value"],
-                ]
-            )
+        production_grid_points = [
+            [
+                point["azimuth"]["value"],
+                point["zenith_angle"]["value"],
+                point["nsb"]["value"],
+                point["offset"]["value"],
+            ]
+            for point in self.grid_points_production
+        ]
 
         production_grid_points = np.array(production_grid_points)
 
@@ -280,11 +278,13 @@ class InterpolationHandler:
         reduced_production_grid_points = self._prepare_production_grid_points()
         energy_grid = self.energy_grids[0] if self.energy_grids else []
 
-        energy_query_grid = []
-        for energy in energy_grid:
-            for grid_point in reduced_production_grid_points:
-                energy_query_grid.append(np.hstack([energy.to(u.TeV).value, grid_point]))
-
+        energy_query_grid = [
+            [
+                np.hstack([energy.to(u.TeV).value, grid_point])
+                for energy in energy_grid
+                for grid_point in reduced_production_grid_points
+            ]
+        ]
         energy_query_grid = np.array(energy_query_grid)
 
         self._logger.debug(f"Grid points with energy shape: {grid_points_energy.shape}")

simtools/ray_tracing/incident_angles.py

@@ -9,13 +9,16 @@ Angle of incidence on to secondary mirror [deg] (if available).
 import logging
 import math
 import re
-import subprocess
 from pathlib import Path
 
 import astropy.units as u
-from astropy.table import QTable
+import numpy as np
+from astropy.table import QTable, vstack
 
+from simtools import settings
 from simtools.data_model.metadata_collector import MetadataCollector
+from simtools.data_model.model_data_writer import ModelDataWriter
+from simtools.job_execution import job_manager
 from simtools.model.model_utils import initialize_simulation_models
 
 
@@ -24,10 +27,6 @@ class IncidentAnglesCalculator:
 
     Parameters
     ----------
-    simtel_path : str or pathlib.Path
-        Path to the sim_telarray installation directory (containing ``sim_telarray/bin``).
-    db_config : dict
-        Database configuration passed to ``initialize_simulation_models``.
     config_data : dict
         Simulation configuration (e.g. ``site``, ``telescope``, ``model_version``,
         ``off_axis_angle``, ``source_distance``, ``number_of_photons``).
@@ -48,15 +47,12 @@ class IncidentAnglesCalculator:
 
     def __init__(
         self,
-        simtel_path,
-        db_config,
         config_data,
         output_dir,
         label=None,
     ):
         self.logger = logging.getLogger(__name__)
 
-        self._simtel_path = Path(simtel_path)
         self.config_data = config_data
         self.output_dir = Path(output_dir)
         self.label = label or f"incident_angles_{config_data['telescope']}"
@@ -82,7 +78,6 @@ class IncidentAnglesCalculator:
         )
         self.telescope_model, self.site_model, _ = initialize_simulation_models(
             label=self.label,
-            db_config=db_config,
             site=config_data["site"],
             telescope_name=config_data["telescope"],
             model_version=config_data["model_version"],
@@ -216,8 +211,6 @@ class IncidentAnglesCalculator:
             Path to the generated shell script.
         """
         script_path = self.scripts_dir / f"run_incident_angles_{self._label_suffix()}.sh"
-        simtel_bin = self._simtel_path / "sim_telarray/bin/sim_telarray_debug_trace"
-        corsika_dummy = self._simtel_path / "sim_telarray/run9991.corsika.gz"
 
         theta = self.ZENITH_ANGLE_DEG
         off = float(self.config_data["off_axis_angle"].to_value(u.deg))
@@ -258,7 +251,10 @@ class IncidentAnglesCalculator:
             cfg("camera_filter", "none"),
         ]
 
-        command = f"{simtel_bin} {' '.join(opts)} {corsika_dummy}"
+        command = (
+            f"{settings.config.sim_telarray_exe_debug_trace} {' '.join(opts)} "
+            f"{settings.config.corsika_dummy_file}"
+        )
         with script_path.open("w", encoding="utf-8") as sh:
             sh.write("#!/usr/bin/env bash\n\n")
             sh.write("set -e\nset -o pipefail\n\n")
@@ -279,8 +275,8 @@ class IncidentAnglesCalculator:
         """
         self.logger.info("Executing %s (logging to %s)", script_path, log_file)
         try:
-            subprocess.check_call([str(script_path)])
-        except subprocess.CalledProcessError as exc:
+            job_manager.submit(script_path)
+        except job_manager.JobExecutionError as exc:
             raise RuntimeError(f"Incident angles run failed, see log: {log_file}") from exc
 
     def _compute_incidence_angles_from_imaging_list(self, photons_file):
@@ -289,7 +285,7 @@ class IncidentAnglesCalculator:
         Column positions may differ between telescope types and sim_telarray versions.
         Header lines (``# Column N: ...``) are parsed to find indices; otherwise
         legacy positions (1-based) are used: focal=26, primary=32, secondary=36,
-        primary X/Y = 29/30, secondary X/Y = 33/34.
+        primary X/Y = 29/30, secondary X/Y=33/34.
 
         Parameters
         ----------
@@ -698,9 +694,88 @@ class IncidentAnglesCalculator:
             self.logger.warning("No results to save")
             return
         output_file = self.results_dir / f"incident_angles_{self._label_suffix()}.ecsv"
-        self.results.write(output_file, format="ascii.ecsv", overwrite=True)
+
+        data = self.results["angle_incidence_focal"].to(u.deg).value
+        bin_centers, hist = self._calculate_histogram(data, bins=1000)
+
+        output_table = QTable()
+        output_table["Incidence angle"] = bin_centers * u.deg
+        output_table["Fraction"] = hist
+
+        output_table.write(output_file, format="ascii.ecsv", overwrite=True)
 
         MetadataCollector.dump(
             args_dict=self.config_data,
             output_file=output_file.with_suffix(".yml"),
         )
+
+    def save_model_parameters(self, results_by_offset):
+        """
+        Write model parameters dictionary (json) + astropy table with incident angles.
+
+        Parameters
+        ----------
+        results_by_offset : dict
+            Dictionary with results for each offset.
+        """
+        # Combine results from all offsets
+        tables = [res for res in results_by_offset.values() if res is not None and len(res) > 0]
+        if not tables:
+            self.logger.warning("No results to write model parameters.")
+            return
+
+        combined_table = vstack(tables)
+
+        parameter_mapping = {
+            "camera_filter_incidence_angle": "angle_incidence_focal",
+            "primary_mirror_incidence_angle": "angle_incidence_primary",
+            "secondary_mirror_incidence_angle": "angle_incidence_secondary",
+        }
+
+        for param_name, col_name in parameter_mapping.items():
+            if col_name not in combined_table.colnames:
+                continue
+
+            data = combined_table[col_name].to(u.deg).value
+            # Create histogram
+            bin_centers, hist = self._calculate_histogram(data, bins=100)
+
+            table = QTable()
+            table["Incidence angle"] = bin_centers * u.deg
+            table["Fraction"] = hist
+
+            writer = ModelDataWriter(output_file=self.output_dir / f"{param_name}.ecsv")
+            writer.write(
+                product_data=table,
+                metadata=MetadataCollector(args_dict=self.config_data),
+            )
+
+            ModelDataWriter.dump_model_parameter(
+                parameter_name=param_name,
+                value=f"{param_name}.ecsv",
+                instrument=self.config_data["telescope"],
+                parameter_version=self.config_data["model_version"],
+                output_file=f"{param_name}.json",
+                output_path=self.output_dir,
+                metadata_input_dict=self.config_data,
+            )
+
+    def _calculate_histogram(self, data, bins=100):
+        """
+        Calculate normalized histogram (density).
+
+        Parameters
+        ----------
+        data : numpy.ndarray
+            Data to calculate histogram for.
+        bins : int
+            Number of bins.
+
+        Returns
+        -------
+        tuple
+            Bin centers and histogram values (density).
+        """
+        hist, bin_edges = np.histogram(data, bins=bins, density=True)
+        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+        return bin_centers, hist