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

simtools/ray_tracing/psf_analysis.py

@@ -7,9 +7,7 @@ Main functionalities are: computing centroids, psf containers etc.
 
 import gzip
 import logging
-import shlex
-import shutil
-import subprocess
+import tempfile
 from math import fabs, pi, sqrt
 from pathlib import Path
 
@@ -17,6 +15,8 @@ import astropy.units as u
 import matplotlib.pyplot as plt
 import numpy as np
 
+from simtools import settings
+from simtools.job_execution import job_manager
 from simtools.utils.general import collect_kwargs, set_default_kwargs
 
 
@@ -36,8 +36,6 @@ class PSFImage:
         Scatter area of all photons in cm^2. If not given, effective area cannot be computed.
     containment_fraction: float
         Containment fraction for PSF calculation.
-    simtel_path: str
-        Path to sim_telarray installation.
     """
 
     __PSF_RADIUS = "Radius [cm]"
@@ -48,11 +46,9 @@ class PSFImage:
         focal_length=None,
         total_scattered_area=None,
         containment_fraction=None,
-        simtel_path=None,
     ):
         """Initialize PSFImage class."""
         self._logger = logging.getLogger(__name__)
-        self.simtel_path = simtel_path
 
         self._total_photons = None
         self._number_of_detected_photons = None
@@ -96,33 +92,49 @@ class PSFImage:
         photons_file: str
             Name of sim_telarray file with photon list.
         """
+        rx_command = [
+            f"{settings.config.sim_telarray_path}/bin/rx",
+            "-f",
+            f"{self._containment_fraction:.2f}",
+            "-v",
+        ]
+
         try:
-            rx_output = subprocess.Popen(  # pylint: disable=consider-using-with
-                shlex.split(
-                    f"{self.simtel_path}/sim_telarray/bin/rx -f {self._containment_fraction:.2f} -v"
-                ),
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-            )
-            with gzip.open(photon_file, "rb") as _stdin:
-                with rx_output.stdin:
-                    shutil.copyfileobj(_stdin, rx_output.stdin)
-                    try:
-                        rx_output = rx_output.communicate()[0].splitlines()[-1:][0].split()
-                    except IndexError as e:
-                        raise IndexError(f"Unexpected output format from rx: {rx_output}") from e
+            with tempfile.NamedTemporaryFile(mode="wb", delete=False) as tmp_file:
+                with gzip.open(photon_file, "rb") as gz:
+                    tmp_file.write(gz.read())
+                tmp_file_path = tmp_file.name
+
+            try:
+                with open(tmp_file_path, "rb") as tmp_f:
+                    result = job_manager.submit(rx_command, stdin=tmp_f)
+
+                data_lines = [
+                    line.strip()
+                    for line in result.stdout.strip().split("\n")
+                    if line.strip() and not line.startswith("#")
+                ]
+
+                if not data_lines:
+                    raise IndexError("No data line found in RX output")
+
+                rx_output = data_lines[-1].split()
+                self.set_psf(
+                    2 * float(rx_output[0]), fraction=self._containment_fraction, unit="cm"
+                )
+                self.centroid_x = float(rx_output[1])
+                self.centroid_y = float(rx_output[2])
+                self._effective_area = float(rx_output[5])
+
+            finally:
+                Path(tmp_file_path).unlink(missing_ok=True)
+
         except FileNotFoundError as e:
             raise FileNotFoundError(f"Photon list file not found: {photon_file}") from e
-
-        try:
-            self.set_psf(2 * float(rx_output[0]), fraction=self._containment_fraction, unit="cm")
-            self.centroid_x = float(rx_output[1])
-            self.centroid_y = float(rx_output[2])
-            self._effective_area = float(rx_output[5])
-        except IndexError as e:
-            raise IndexError(f"Unexpected output format from rx: {rx_output}") from e
-        except ValueError as e:
-            raise ValueError(f"Invalid output format from rx: {rx_output}") from e
+        except (IndexError, ValueError) as e:
+            raise type(e)(
+                f"Invalid RX output format: {locals().get('rx_output', 'unknown')}"
+            ) from e
 
     def read_photon_list_from_simtel_file(self, photons_file):
         """
@@ -150,9 +162,9 @@ class PSFImage:
                 self._process_simtel_line(line)
 
         if not self._is_photon_positions_ok():
-            msg = "Problems reading sim_telarray file - invalid data"
-            self._logger.error(msg)
-            raise RuntimeError(msg)
+            raise RuntimeError(
+                f"Problems reading sim_telarray photons file {photons_file} - invalid data"
+            )
 
         self.centroid_x = np.mean(self.photon_pos_x)
         self.centroid_y = np.mean(self.photon_pos_y)
@@ -384,7 +396,6 @@ class PSFImage:
                 if radius is not found (found_radius is False)
             """
             r0, r1 = rad_min, rad_min + dr
-            s0, s1 = 0, 0
             found_radius = False
             while not found_radius:
                 s0, s1 = self._sum_photons_in_radius(r0), self._sum_photons_in_radius(r1)
@@ -468,9 +479,10 @@ class PSFImage:
         ax.hist2d(data["X"], data["Y"], **kwargs_for_image)
         ax.set_aspect("equal", "datalim")
 
-        # PSF circle (80%)
+        # PSF circle (containment fraction)
+        fraction = self._containment_fraction if self._containment_fraction is not None else 0.8
         center = (0, 0) if centralized else (self.centroid_x, self.centroid_y)
-        circle = plt.Circle(center, self.get_psf(0.8) / 2, **kwargs_for_psf)
+        circle = plt.Circle(center, self.get_psf(fraction) / 2, **kwargs_for_psf)
         ax.add_artist(circle)
 
         ax.axhline(0, color="k", linestyle="--", zorder=3, linewidth=0.5)
@@ -496,11 +508,12 @@ class PSFImage:
         if radius is not None:
             radius_all = radius.to(u.cm).value if isinstance(radius, u.Quantity) else radius
         else:
-            radius_all = list(np.linspace(0, 1.6 * self.get_psf(0.8), 30))
-
-        intensity = []
-        for rad in radius_all:
-            intensity.append(self._sum_photons_in_radius(rad) / self._number_of_detected_photons)
+            fraction = self._containment_fraction if self._containment_fraction is not None else 0.8
+            radius_all = list(np.linspace(0, 1.6 * self.get_psf(fraction), 30))
+        intensity = [
+            self._sum_photons_in_radius(rad) / self._number_of_detected_photons
+            for rad in radius_all
+        ]
         d_type = {
             "names": (self.__PSF_RADIUS, self.__PSF_CUMULATIVE),
             "formats": ("f8", "f8"),
@@ -511,15 +524,15 @@ class PSFImage:
 
         return result
 
-    def plot_cumulative(self, file_name=None, d80=None, **kwargs):
+    def plot_cumulative(self, file_name=None, psf_diameter_cm=None, **kwargs):
         """Plot cumulative data (intensity vs radius).
 
         Parameters
         ----------
         file_name: str
             Name of the file to save the plot to.
-        d80: float
-            d80 value to be marked in the plot (in cm).
+        psf_diameter_cm: float
+            PSF diameter value to be marked in the plot (in cm).
         **kwargs:
             Customization of line plot (e.g., color, linestyle, linewidth).
         """
@@ -528,9 +541,10 @@ class PSFImage:
         ax.set_xlabel("Radius (cm)")
         ax.set_ylabel("Contained light %")
         ax.plot(data[self.__PSF_RADIUS], data[self.__PSF_CUMULATIVE], **kwargs)
-        ax.axvline(x=self.get_psf(0.8) / 2, color="b", linestyle="--", linewidth=1)
-        if d80 is not None:
-            ax.axvline(x=d80 / 2.0, color="r", linestyle="--", linewidth=1)
+        fraction = self._containment_fraction if self._containment_fraction is not None else 0.8
+        ax.axvline(x=self.get_psf(fraction) / 2, color="b", linestyle="--", linewidth=1)
+        if psf_diameter_cm is not None:
+            ax.axvline(x=psf_diameter_cm / 2.0, color="r", linestyle="--", linewidth=1)
         if file_name is not None:
             fig.savefig(file_name)
             plt.close(fig)

simtools/ray_tracing/psf_parameter_optimisation.py

@@ -857,11 +857,11 @@ def _run_ray_tracing_simulation(tel_model, site_model, args_dict, pars):
     if pars is None:
         raise ValueError("No best parameters found")
 
-    tel_model.overwrite_parameters(pars)
+    tel_model.overwrite_parameters(pars, flat_dict=True)
     ray = RayTracing(
         telescope_model=tel_model,
         site_model=site_model,
-        simtel_path=args_dict["simtel_path"],
+        label=args_dict.get("label") or getattr(tel_model, "label", None),
         zenith_angle=args_dict["zenith"] * u.deg,
         source_distance=args_dict["src_distance"] * u.km,
         off_axis_angle=[0.0] * u.deg,
@@ -1382,7 +1382,7 @@ def cleanup_intermediate_files(output_dir):
     output_dir : Path
         Directory containing output files to clean up.
     """
-    patterns = ["*.log", "*.lis*"]
+    patterns = ["*.log", "*.lis*", "*.dat"]
     files_removed = 0
 
     for pattern in patterns:

simtools/ray_tracing/ray_tracing.py

@@ -5,7 +5,6 @@ import logging
 import shutil
 from copy import copy
 from math import pi, tan
-from pathlib import Path
 
 import astropy.io.ascii
 import astropy.units as u
@@ -33,8 +32,6 @@ class RayTracing:
         telescope model
     site_model: SiteModel
         site model
-    simtel_path: str (or Path)
-        Location of sim_telarray installation.
     label: str
         label used for output file naming.
     zenith_angle: astropy.units.Quantity
@@ -54,8 +51,8 @@ class RayTracing:
     """
 
     YLABEL = {
-        "d80_cm": r"$D_{80}$",
-        "d80_deg": r"$D_{80}$",
+        "psf_cm": "PSF",
+        "psf_deg": "PSF",
         "eff_area": "Eff. mirror area",
         "eff_flen": "Eff. focal length",
     }
@@ -64,7 +61,6 @@ class RayTracing:
         self,
         telescope_model,
         site_model,
-        simtel_path,
         label=None,
         zenith_angle=20.0 * u.deg,
         off_axis_angle=[0.0] * u.deg,
@@ -78,7 +74,6 @@ class RayTracing:
         self._logger = logging.getLogger(__name__)
         self._logger.debug(f"Initializing RayTracing class {single_mirror_mode}")
 
-        self.simtel_path = Path(simtel_path)
         self._io_handler = io_handler.IOHandler()
 
         self.telescope_model, self.site_model = telescope_model, site_model
@@ -212,9 +207,9 @@ class RayTracing:
                     f"Simulating RayTracing for off_axis={this_off_axis}, mirror={mirror_number}"
                 )
                 simtel = SimulatorRayTracing(
-                    simtel_path=self.simtel_path,
                     telescope_model=self.telescope_model,
                     site_model=self.site_model,
+                    label=self.label,
                     test=test,
                     config_data={
                         "zenith_angle": self.zenith_angle,
@@ -408,11 +403,7 @@ class RayTracing:
         PSFImage
             PSF image object.
         """
-        image = PSFImage(
-            focal_length=focal_length,
-            containment_fraction=containment_fraction,
-            simtel_path=self.simtel_path,
-        )
+        image = PSFImage(focal_length=focal_length, containment_fraction=containment_fraction)
         image.process_photon_list(photons_file, use_rx)
         self._psf_images[this_off_axis] = copy(image)
         return image
@@ -478,22 +469,46 @@ class RayTracing:
         else:
             self._logger.error("No results to export")
 
+    def get_psf_mm(self, row_index: int = 0) -> float:
+        """Return PSF diameter from the analysis results in mm.
+
+        Parameters
+        ----------
+        row_index : int
+            Row index into the results table (default: 0).
+
+        Returns
+        -------
+        float
+            PSF diameter in millimeters.
+        """
+        if self._results is None:
+            raise RuntimeError("No results available; run analyze() first")
+        psf = self._results["psf_cm"][row_index]
+
+        if isinstance(psf, u.Quantity):
+            psf_cm = psf.to_value(u.cm)
+        else:
+            psf_cm = float(psf)
+
+        return psf_cm * 10.0
+
     def _read_results(self):
         """Read existing results file and store it in _results."""
         self._results = astropy.io.ascii.read(self._file_results, format="ecsv")
 
-    def plot(self, key, save=False, d80=None, **kwargs):
+    def plot(self, key, save=False, psf_diameter_cm=None, **kwargs):
         """
         Plot key vs off-axis angle and save the figure in pdf.
 
         Parameters
         ----------
         key: str
-            d80_cm, d80_deg, eff_area or eff_flen
+            psf_cm, psf_deg, eff_area or eff_flen
         save: bool
             If True, figure will be saved.
-        d80: float
-            d80 for cumulative PSF plot.
+        psf_diameter_cm: float
+            PSF diameter value to be marked in the cumulative PSF plot (in cm).
         **kwargs:
             kwargs for plt.plot
 
@@ -543,7 +558,9 @@ class RayTracing:
                     image_cumulative_file_name
                 )
                 self._logger.info(f"Saving cumulative PSF to {image_cumulative_file}")
-                image.plot_cumulative(file_name=image_cumulative_file, d80=d80)
+                image.plot_cumulative(
+                    file_name=image_cumulative_file, psf_diameter_cm=psf_diameter_cm
+                )
 
     def plot_histogram(self, key, **kwargs):
         """
@@ -552,7 +569,7 @@ class RayTracing:
         Parameters
         ----------
         key: str
-            d80_cm, d80_deg, eff_area or eff_flen
+            psf_cm, psf_deg, eff_area or eff_flen
         **kwargs:
             kwargs for plt.hist
 
@@ -574,7 +591,7 @@ class RayTracing:
         Parameters
         ----------
         key: str
-            d80_cm, d80_deg, eff_area or eff_flen
+            psf_cm, psf_deg, eff_area or eff_flen
 
         Returns
         -------
@@ -598,7 +615,7 @@ class RayTracing:
         Parameters
         ----------
         key: str
-            d80_cm, d80_deg, eff_area or eff_flen
+            psf_cm, psf_deg, eff_area or eff_flen
 
         Returns
         -------
@@ -623,10 +640,11 @@ class RayTracing:
         -------
         List of PSFImages
         """
-        images = []
-        for this_off_axis in self.off_axis_angle:
-            if self._psf_images and this_off_axis in self._psf_images:
-                images.append(self._psf_images[this_off_axis])
+        images = [
+            self._psf_images[this_off_axis]
+            for this_off_axis in self.off_axis_angle
+            if self._psf_images and this_off_axis in self._psf_images
+        ]
         if len(images) == 0:
             self._logger.warning("No image found")
             return None

simtools/reporting/docs_auto_report_generator.py

@@ -16,11 +16,10 @@ logger = logging.getLogger()
 class ReportGenerator:
     """Automate report generation."""
 
-    def __init__(self, db_config, args, output_path):
+    def __init__(self, args, output_path):
         """Initialise class."""
         self._logger = logging.getLogger(__name__)
-        self.db = db_handler.DatabaseHandler(db_config=db_config)
-        self.db_config = db_config
+        self.db = db_handler.DatabaseHandler()
         self.args = args
         self.output_path = output_path
 
@@ -99,7 +98,7 @@ class ReportGenerator:
         )
 
         output_path = Path(self.output_path) / str(model_version)
-        ReadParameters(self.db_config, self.args, output_path).produce_array_element_report()
+        ReadParameters(self.args, output_path).produce_array_element_report()
 
         logger.info(
             f"Markdown report generated for {site} "
@@ -167,9 +166,7 @@ class ReportGenerator:
                 }
             )
 
-            ReadParameters(
-                self.db_config, self.args, self.output_path
-            ).produce_model_parameter_reports()
+            ReadParameters(self.args, self.output_path).produce_model_parameter_reports()
 
             logger.info(
                 f"Markdown report generated for {site} Telescope {telescope}: {self.output_path}"
@@ -211,7 +208,7 @@ class ReportGenerator:
         )
 
         output_path = Path(self.output_path) / str(model_version)
-        ReadParameters(self.db_config, self.args, output_path).produce_observatory_report()
+        ReadParameters(self.args, output_path).produce_observatory_report()
 
         logger.info(f"Observatory report generated for {site} (v{model_version}): {output_path}")
 
@@ -237,9 +234,7 @@ class ReportGenerator:
             self.args.update({"model_version": version})
             output_path = Path(self.output_path) / str(version)
 
-            ReadParameters(
-                self.db_config, self.args, output_path
-            ).produce_simulation_configuration_report()
+            ReadParameters(self.args, output_path).produce_simulation_configuration_report()
 
             logger.info(f"Configuration reports for (v{version}) produced: {output_path}")
 
@@ -262,7 +257,7 @@ class ReportGenerator:
             output_path = Path(self.output_path) / str(version)
 
             try:
-                ReadParameters(self.db_config, self.args, output_path).produce_calibration_reports()
+                ReadParameters(self.args, output_path).produce_calibration_reports()
                 logger.info(f"Calibration reports for (v{version}) produced: {output_path}")
             except ValueError as err:
                 # Some model versions do not have calibration_devices in the DB;
@@ -305,7 +300,7 @@ class ReportGenerator:
 
                 # Generate parameter comparison reports for calibration devices
                 ReadParameters(
-                    self.db_config, version_args, self.output_path
+                    version_args, self.output_path
                 ).generate_model_parameter_reports_for_devices(array_elements)
 
                 logger.info(

simtools/reporting/docs_read_parameters.py

@@ -26,11 +26,10 @@ MARKDOWN_LINK_RE = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
 class ReadParameters:
     """Read and manage model parameter data for report generation."""
 
-    def __init__(self, db_config, args, output_path):
+    def __init__(self, args, output_path):
         """Initialise class."""
         self._logger = logging.getLogger(__name__)
-        self.db = db_handler.DatabaseHandler(db_config=db_config)
-        self.db_config = db_config
+        self.db = db_handler.DatabaseHandler()
         self.array_element = args.get("telescope", None)
         self.site = args.get("site", None)
         self.model_version = args.get("model_version", None)
@@ -109,7 +108,6 @@ class ReadParameters:
             plot_pixels.plot(
                 config=plot_config,
                 output_file=Path(f"{outpath}/{plot_name}"),
-                db_config=self.db_config,
             )
             plot_names.append(plot_name)
         else:
@@ -142,7 +140,6 @@ class ReadParameters:
             plot_mirrors.plot(
                 config=plot_config,
                 output_file=Path(f"{outpath}/{plot_name}"),
-                db_config=self.db_config,
             )
             plot_names.append(plot_name)
         else:
@@ -165,7 +162,6 @@ class ReadParameters:
             telescope=tel,
             output_path=outpath,
             plot_type="all",
-            db_config=self.db_config,
         )
 
         if not config_data:
@@ -180,7 +176,6 @@ class ReadParameters:
                 plot_tables.plot(
                     config=plot_config,
                     output_file=image_output_file,
-                    db_config=self.db_config,
                 )
                 plt.close("all")
 
@@ -582,7 +577,6 @@ class ReadParameters:
             telescope_name=self.array_element,
             model_version=self.model_version,
             label="reports",
-            db_config=self.db_config,
             ignore_software_version=True,
         )