gammasimtools 0.26.0__py3-none-any.whl → 0.27.1__py3-none-any.whl

simtools/applications/simulate_prod.py

@@ -57,7 +57,8 @@ r"""
 """
 
 from simtools.application_control import startup_application
-from simtools.configuration import configurator
+from simtools.configuration import commandline_parser, configurator
+from simtools.constants import CORSIKA_MAX_SEED
 from simtools.simulator import Simulator
 
 
@@ -97,11 +98,11 @@ def _parse():
         default=False,
     )
     config.parser.add_argument(
-        "--corsika_test_seeds",
-        help="Use predefined random seeds for CORSIKA for testing purposes.",
-        action="store_true",
-        required=False,
-        default=False,
+        "--corsika_seeds",
+        help="Use fixed random seeds for CORSIKA for testing purposes.",
+        nargs=4,
+        type=commandline_parser.CommandLineParser.bounded_int(1, CORSIKA_MAX_SEED),
+        metavar=("S1", "S2", "S3", "S4"),
     )
     config.parser.add_argument(
         "--sequential",
@@ -127,7 +128,7 @@ def main():
     """Run simulations for productions."""
     app_context = startup_application(_parse, setup_io_handler=False)
 
-    simulator = Simulator(label=app_context.args.get("label"), args_dict=app_context.args)
+    simulator = Simulator(label=app_context.args.get("label"))
 
     simulator.simulate()
     simulator.validate_metadata()

simtools/applications/submit_data_from_external.py

@@ -95,7 +95,8 @@ def main():
     )
 
     writer.ModelDataWriter.dump(
-        args_dict=app_context.args,
+        output_file=app_context.args["output_file"],
+        output_file_format=app_context.args.get("output_file_format"),
         metadata=_metadata,
         product_data=data_validator.validate_and_transform(),
     )

simtools/applications/validate_camera_efficiency.py

@@ -44,12 +44,11 @@ r"""
     The output is saved in simtools-output/validate_camera_efficiency.
 """
 
-from pathlib import Path
-
-import simtools.data_model.model_data_writer as writer
 from simtools.application_control import get_application_label, startup_application
 from simtools.camera.camera_efficiency import CameraEfficiency
 from simtools.configuration import configurator
+from simtools.io.ascii_handler import write_data_to_file
+from simtools.utils import names
 
 
 def _parse():
@@ -106,31 +105,33 @@ def main():
     """Calculate the camera efficiency and NSB pixel rates."""
     app_context = startup_application(_parse)
 
-    ce = CameraEfficiency(
-        label=app_context.args.get("label"),
-        config_data=app_context.args,
-    )
-    ce.simulate()
-    ce.analyze(force=True)
-    ce.plot_efficiency(efficiency_type="Cherenkov", save_fig=True)
-    ce.plot_efficiency(efficiency_type="NSB", save_fig=True)
-
-    writer.ModelDataWriter.dump_model_parameter(
-        parameter_name="nsb_pixel_rate",
-        value=ce.get_nsb_pixel_rate(
-            reference_conditions=app_context.args.get(
-                "write_reference_nsb_rate_as_parameter", False
-            )
-        ),
-        instrument=app_context.args["telescope"],
-        parameter_version=app_context.args.get("parameter_version", "0.0.0"),
-        output_file=Path(
-            f"nsb_pixel_rate-{app_context.args.get('parameter_version', '0.0.0')}.json"
-        ),
-        output_path=app_context.io_handler.get_output_directory()
-        / app_context.args["telescope"]
-        / "nsb_pixel_rate",
+    results = {}
+    for efficiency_type in ["Shower", "NSB", "Muon"]:
+        ce = CameraEfficiency(
+            label=app_context.args.get("label"),
+            config_data=app_context.args,
+            efficiency_type=efficiency_type,
+        )
+        ce.simulate()
+        ce.analyze(force=True)
+        results |= ce.results_summary()
+        ce.plot_efficiency(save_fig=True)
+
+        if ce.efficiency_type == "nsb":
+            ce.dump_nsb_pixel_rate()
+        if ce.efficiency_type == "muon":
+            ce.calc_partial_efficiency()
+
+    results_file = app_context.io_handler.get_output_directory() / names.generate_file_name(
+        file_type="camera_efficiency_summary",
+        suffix=".yml",
+        site=app_context.args["site"],
+        telescope_model_name=app_context.args["telescope"],
+        zenith_angle=app_context.args["zenith_angle"].value,
+        azimuth_angle=app_context.args["azimuth_angle"].value,
     )
+    app_context.logger.info(f"Writing results summary to {results_file}")
+    write_data_to_file(results, results_file, unique_lines=True)
 
 
 if __name__ == "__main__":

simtools/applications/validate_cumulative_psf.py

@@ -135,12 +135,10 @@ def main():
         model_version=app_context.args["model_version"],
     )
 
-    if app_context.args.get("overwrite_model_parameters"):
-        tel_model.overwrite_parameters_from_file(app_context.args["overwrite_model_parameters"])
-
     ray = RayTracing(
         telescope_model=tel_model,
         site_model=site_model,
+        label=app_context.args.get("label"),
         zenith_angle=app_context.args["zenith"] * u.deg,
         source_distance=app_context.args["src_distance"] * u.km,
         off_axis_angle=[0.0] * u.deg,

simtools/applications/validate_optics.py

@@ -134,6 +134,7 @@ def main():
     ray = RayTracing(
         telescope_model=tel_model,
         site_model=site_model,
+        label=app_context.args.get("label") or Path(__file__).stem,
         zenith_angle=app_context.args["zenith"] * u.deg,
         source_distance=app_context.args["src_distance"] * u.km,
         off_axis_angle=np.linspace(
@@ -147,7 +148,7 @@ def main():
     ray.analyze(force=True)
 
     # Plotting
-    for key in ["d80_deg", "d80_cm", "eff_area", "eff_flen"]:
+    for key in ["psf_deg", "psf_cm", "eff_area", "eff_flen"]:
         plt.figure(figsize=(8, 6), tight_layout=True)
 
         ray.plot(key, marker="o", linestyle=":", color="k")

simtools/atmosphere.py

@@ -0,0 +1,83 @@
+"""Profiles of atmospheric parameters as a function of altitude."""
+
+import logging
+from pathlib import Path
+
+import astropy.units as u
+import numpy as np
+
+
+class AtmosphereProfile:
+    """
+    Profiles of atmospheric parameters as a function of altitude.
+
+    Parameters
+    ----------
+    filename: str or Path
+        Path to the atmosphere profile file (CORSIKA table format)
+    """
+
+    def __init__(self, filename):
+        """AtmosphereProfile initialization."""
+        self._logger = logging.getLogger(__name__)
+        self.columns = {}
+        self.read_atmosphere_profile(filename)
+
+    def read_atmosphere_profile(self, filename):
+        """
+        Read atmosphere profile from file.
+
+        Parameters
+        ----------
+        filename: str or Path
+            Path to the atmosphere profile file (CORSIKA table format)
+
+        """
+        filename = Path(filename)
+        data = []
+        self._logger.debug(f"Reading atmosphere profile from {filename}")
+        with filename.open(encoding="utf-8") as f:
+            for line in f:
+                if not line.strip() or line.lstrip().startswith("#"):
+                    continue
+                data.append([float(x) for x in line.split()])
+
+        self.data = np.array(data)
+        self.columns = {
+            "alt": 0,
+            "rho": 1,
+            "thick": 2,
+            "n_minus_1": 3,
+            "T": 4,
+            "p": 5,
+            "pw_over_p": 6,
+        }
+
+    def interpolate(self, altitude, column="thick"):
+        """
+        Interpolate the atmosphere profile at a given altitude.
+
+        Parameters
+        ----------
+        altitude: astropy.units.Quantity
+            Altitude
+        column: str
+            Column name to interpolate.
+
+        Returns
+        -------
+        float
+            Interpolated value.
+        """
+        if column not in self.columns:
+            raise KeyError(f"Unknown column: {column}")
+
+        altitude = altitude.to(u.km).value
+
+        x = self.data[:, 0]
+        y = self.data[:, self.columns[column]]
+
+        if altitude < x.min() or altitude > x.max():
+            raise ValueError("Altitude out of bounds")
+
+        return np.interp(altitude, x, y)

simtools/camera/camera_efficiency.py

@@ -3,13 +3,17 @@
 import logging
 import re
 from collections import defaultdict
+from pathlib import Path
 
 import astropy.io.ascii
 import astropy.units as u
 import numpy as np
 from astropy.table import Table
 
-from simtools.io import io_handler
+import simtools.data_model.model_data_writer as writer
+from simtools import settings
+from simtools.atmosphere import AtmosphereProfile
+from simtools.io import ascii_handler, io_handler
 from simtools.model.model_utils import initialize_simulation_models
 from simtools.simtel.simulator_camera_efficiency import SimulatorCameraEfficiency
 from simtools.utils import names
@@ -26,9 +30,11 @@ class CameraEfficiency:
         Instance label, optional.
     config_data: dict.
         Dict containing the configurable parameters.
+    efficiency_type: str
+        The type of efficiency to simulate (e.g., 'Shower', 'Muon', or 'NSB').
     """
 
-    def __init__(self, config_data, label):
+    def __init__(self, label, config_data, efficiency_type):
         """Initialize the CameraEfficiency class."""
         self._logger = logging.getLogger(__name__)
 
@@ -45,8 +51,9 @@ class CameraEfficiency:
 
         self._results = None
         self._has_results = False
+        self.efficiency_type = efficiency_type.lower()
 
-        self.config = self._configuration_from_args_dict(config_data)
+        self.config = self._configuration(config_data)
         self._file = self._load_files()
 
         self.nsb_pixel_pe_per_ns = None
@@ -56,9 +63,9 @@ class CameraEfficiency:
         """Return string representation of the CameraEfficiency instance."""
         return f"CameraEfficiency(label={self.label})\n"
 
-    def _configuration_from_args_dict(self, config_data):
+    def _configuration(self, config_data):
         """
-        Extract configuration data from command line arguments.
+        Extract configuration data from command line and class parameters.
 
         Parameters
         ----------
@@ -74,6 +81,7 @@ class CameraEfficiency:
             "zenith_angle": config_data["zenith_angle"].to("deg").value,
             "azimuth_angle": config_data["azimuth_angle"].to("deg").value,
             "nsb_spectrum": config_data.get("nsb_spectrum", None),
+            "efficiency_type": self.efficiency_type,
         }
 
     def _load_files(self):
@@ -84,15 +92,13 @@ class CameraEfficiency:
             [".ecsv", ".dat", ".log"],
         ):
             file_name = names.generate_file_name(
-                file_type=(
-                    "camera_efficiency_table" if label == "results" else "camera_efficiency"
-                ),
+                file_type="camera_efficiency",
                 suffix=suffix,
                 site=self.telescope_model.site,
                 telescope_model_name=self.telescope_model.name,
                 zenith_angle=self.config["zenith_angle"],
                 azimuth_angle=self.config["azimuth_angle"],
-                label=self.label,
+                label=self.efficiency_type,
             )
 
             _file[label] = self.io_handler.get_output_directory().joinpath(file_name)
@@ -111,6 +117,7 @@ class CameraEfficiency:
             file_simtel=self._file["sim_telarray"],
             file_log=self._file["log"],
             label=self.label,
+            x_max=self._get_x_max_for_efficiency_type(),
             nsb_spectrum=self.config["nsb_spectrum"],
             skip_correction_to_nsb_spectrum=self.config.get(
                 "skip_correction_to_nsb_spectrum", False
@@ -245,34 +252,78 @@ class CameraEfficiency:
 
     def results_summary(self):
         """
-        Print a summary of the results.
+        Fill a dictionary with summary of the results.
 
         Include a header for the zenith/azimuth settings and the NSB spectrum file which was used.
         The summary includes the various CTAO requirements and the final expected NSB pixel rate.
+
+        Returns
+        -------
+        dict
+            Summary of the results.
         """
-        nsb_spectrum_text = (
-            f"NSB spectrum file: {self.config['nsb_spectrum']}"
-            if self.config["nsb_spectrum"]
-            else "default sim_telarray spectrum."
-        )
-        return (
-            f"Results summary for {self.telescope_model.name} at "
-            f"zenith={self.config['zenith_angle']:.1f} deg, "
-            f"azimuth={self.config['azimuth_angle']:.1f} deg\n"
-            f"Using the {nsb_spectrum_text}\n"
-            f"\nSpectrum weighted reflectivity: {self.calc_reflectivity():.4f}\n"
-            "Camera nominal efficiency with gaps (B-TEL-1170): "
-            f"{self.calc_camera_efficiency():.4f}\n"
-            "Telescope total efficiency"
-            f" with gaps (was A-PERF-2020): {self.calc_tel_efficiency():.4f}\n"
-            "Telescope total Cherenkov light efficiency / sqrt(total NSB efficiency) "
-            "(A-PERF-2025/B-TEL-0090): "
-            f"{self.calc_tot_efficiency(self.calc_tel_efficiency()):.4f}\n"
-            "Expected NSB pixel rate for the provided NSB spectrum: "
-            f"{self.nsb_pixel_pe_per_ns:.4f} [p.e./ns]\n"
-            "Expected NSB pixel rate for the reference NSB: "
-            f"{self.nsb_rate_ref_conditions:.4f} [p.e./ns]\n"
-        )
+        meta = {
+            "meta": {
+                "tel": self.telescope_model.name,
+                "model_version": self.telescope_model.model_version,
+                "zen": self.config["zenith_angle"],
+                "az": self.config["azimuth_angle"],
+                "nsb": (
+                    self.config["nsb_spectrum"]
+                    if self.config["nsb_spectrum"]
+                    else "default sim_telarray spectrum"
+                ),
+            }
+        }
+
+        metrics = {}
+        if self.efficiency_type == "shower":
+            metrics |= {
+                "reflectivity": {
+                    "value": self.calc_reflectivity(),
+                    "description": "Spectrum weighted reflectivity",
+                },
+                "cam_eff": {
+                    "value": self.calc_camera_efficiency(),
+                    "description": "Camera nominal efficiency with gaps (B-TEL-1170)",
+                },
+                "tel_eff": {
+                    "value": self.calc_tel_efficiency(),
+                    "description": "Telescope total efficiency with gaps (was A-PERF-2020)",
+                },
+                "tot_sens": {
+                    "value": self.calc_tot_efficiency(self.calc_tel_efficiency()),
+                    "description": (
+                        "Telescope total Cherenkov light efficiency / sqrt(total NSB efficiency) "
+                        "(A-PERF-2025/B-TEL-0090)"
+                    ),
+                },
+            }
+
+        elif self.efficiency_type == "nsb":
+            metrics |= {
+                "nsb_rate": {
+                    "value": self.nsb_pixel_pe_per_ns,
+                    "description": "Expected NSB pixel rate for the provided NSB spectrum",
+                },
+                "nsb_ref": {
+                    "value": self.nsb_rate_ref_conditions,
+                    "description": "Expected NSB pixel rate for the reference NSB",
+                },
+            }
+
+        elif self.efficiency_type == "muon":
+            metrics |= {
+                "muon_frac": {
+                    "value": self.calc_partial_efficiency(lambda_min=200.0, lambda_max=290.0),
+                    "description": (
+                        "Fraction of light (from muons) in the wavelength range 200-290 nm "
+                        "(B-TEL-0095)"
+                    ),
+                },
+            }
+
+        return meta | metrics
 
     def export_results(self):
         """Export results to a ecsv file."""
@@ -283,12 +334,9 @@ class CameraEfficiency:
             astropy.io.ascii.write(
                 self._results, self._file["results"], format="basic", overwrite=True
             )
-            _results_summary_file = (
-                str(self._file["results"]).replace(".ecsv", ".txt").replace("_table_", "_summary_")
-            )
+            _results_summary_file = str(self._file["results"]).replace(".ecsv", "_summary.yml")
             self._logger.info(f"Exporting summary results to {_results_summary_file}")
-            with open(_results_summary_file, "w", encoding="utf-8") as file:
-                file.write(self.results_summary())
+            ascii_handler.write_data_to_file(self.results_summary(), Path(_results_summary_file))
 
     def _read_results(self):
         """Read existing results file and store it in _results."""
@@ -363,6 +411,39 @@ class CameraEfficiency:
 
         return tel_efficiency / np.sqrt(tel_efficiency_nsb)
 
+    def calc_partial_efficiency(self, lambda_min=200.0, lambda_max=290.0):
+        """
+        Compare efficiency in a given wavelength range with total efficiency.
+
+        Parameters
+        ----------
+        lambda_min: float
+            Minimum wavelength in nm.
+        lambda_max: float
+            Maximum wavelength in nm.
+
+        Returns
+        -------
+        Float
+            Fraction of light in the given wavelength range compared to total efficiency.
+
+        """
+        # Sum(C4) from lamba_min to lambda_max nm:
+        c4_reduced_wl = self._results["C4"][
+            [lambda_min < wl_now < lambda_max for wl_now in self._results["wl"]]
+        ]
+        c4_sum = np.sum(c4_reduced_wl)
+        # Sum(C4) from 200 - 999 nm:
+        c4_sum_total = np.sum(self._results["C4"])
+        # (no need to apply masts or fill factors as in calc_tel_efficiency, they cancel out)
+
+        self._logger.info(
+            f"Fraction of light in the wavelength range {lambda_min}-{lambda_max} nm: "
+            f"{c4_sum / c4_sum_total:.4f}"
+        )
+
+        return c4_sum / c4_sum_total
+
     def calc_reflectivity(self):
         """
         Calculate the Cherenkov spectrum weighted reflectivity in the range 300-550 nm.
@@ -428,14 +509,12 @@ class CameraEfficiency:
         )
         return self.nsb_pixel_pe_per_ns * u.GHz, self.nsb_rate_ref_conditions * u.GHz
 
-    def plot_efficiency(self, efficiency_type, save_fig=False):
+    def plot_efficiency(self, save_fig=False):
         """
         Plot efficiency vs wavelength.
 
         Parameters
         ----------
-        efficiency_type: str
-            The type of efficiency to plot (Cherenkov 'C' or NSB 'N')
         save_fig: bool
             If True, the figure will be saved to a file.
 
@@ -444,9 +523,9 @@ class CameraEfficiency:
         fig
             The figure instance of pyplot
         """
-        self._logger.info(f"Plotting {efficiency_type} efficiency vs wavelength")
+        self._logger.info(f"Plotting {self.efficiency_type} efficiency vs wavelength")
 
-        _col_type = "C" if efficiency_type == "Cherenkov" else "N"
+        _col_type = "C" if self.efficiency_type in ("shower", "muon") else "N"
 
         column_titles = {
             "wl": "Wavelength [nm]",
@@ -464,21 +543,21 @@ class CameraEfficiency:
         for column_now, column_title in column_titles.items():
             table_to_plot.rename_column(column_now, column_title)
 
-        y_title = f"{efficiency_type} light efficiency"
-        if efficiency_type == "NSB":
+        y_title = f"{self.efficiency_type} light efficiency"
+        if self.efficiency_type == "nsb":
             y_title = r"Diff. ph. rate [$10^{9} \times $ph/(nm s m$^2$ sr)]"
         plot = visualize.plot_table(
             table_to_plot,
             y_title=y_title,
-            title=f"{self.telescope_model.name} response to {efficiency_type} light",
+            title=f"{self.telescope_model.name} response to {self.efficiency_type} light",
             no_markers=True,
         )
-        if efficiency_type == "NSB":
+        if self.efficiency_type == "nsb":
             plot.gca().set_yscale("log")
             ylim = plot.gca().get_ylim()
             plot.gca().set_ylim(1e-3, ylim[1])
         if save_fig:
-            self._save_plot(plot, efficiency_type.lower())
+            self._save_plot(plot, self.efficiency_type)
         return plot
 
     def _save_plot(self, fig, plot_title):
@@ -496,3 +575,47 @@ class CameraEfficiency:
             self.label + "_" + self.telescope_model.name + "_" + plot_title
         )
         visualize.save_figure(fig, plot_file, log_title=f"{plot_title} efficiency")
+
+    def dump_nsb_pixel_rate(self):
+        """Write NSB pixel rate parameter file."""
+        cfg = settings.config.args
+
+        writer.ModelDataWriter.dump_model_parameter(
+            parameter_name="nsb_pixel_rate",
+            value=self.get_nsb_pixel_rate(
+                reference_conditions=settings.config.args.get(
+                    "write_reference_nsb_rate_as_parameter", False
+                )
+            ),
+            instrument=cfg.get("telescope"),
+            parameter_version=cfg.get("parameter_version") or "0.0.0",
+            output_file=Path(f"nsb_pixel_rate-{cfg.get('parameter_version', '0.0.0')}.json"),
+            output_path=self.output_dir / cfg.get("telescope") / "nsb_pixel_rate",
+        )
+
+    def _get_x_max_for_efficiency_type(self):
+        """
+        Get X max value in g/cm2 depending on the efficiency type.
+
+        Returns
+        -------
+        float
+             max value in g/cm2
+        """
+        # typical value for shower X-max around 10 km (not relevant for NSB type)
+        x_max = 300.0
+        obs_level = self.site_model.get_parameter_value_with_unit("corsika_observation_level")
+        if self.efficiency_type == "muon":
+            atmo = AtmosphereProfile(
+                self.site_model.config_file_directory
+                / self.site_model.get_parameter_value("atmospheric_profile")
+            )
+            alt = obs_level.to(u.km) + 0.1 * u.km
+            x_max = atmo.interpolate(altitude=alt, column="thick")
+
+        self._logger.info(
+            f"Using X-max for {self.efficiency_type} efficiency: {x_max:.2f} g/cm2"
+            f" (at observation level: {obs_level:.2f})"
+        )
+
+        return x_max

simtools/camera/single_photon_electron_spectrum.py

@@ -2,7 +2,6 @@
 
 import logging
 import re
-import subprocess
 import tempfile
 from io import BytesIO
 from pathlib import Path
@@ -17,6 +16,7 @@ from simtools.constants import MODEL_PARAMETER_SCHEMA_URL, SCHEMA_PATH
 from simtools.data_model import validate_data
 from simtools.data_model.metadata_collector import MetadataCollector
 from simtools.io import io_handler
+from simtools.job_execution import job_manager
 
 
 class SinglePhotonElectronSpectrum:
@@ -97,7 +97,8 @@ class SinglePhotonElectronSpectrum:
         )
 
         writer.ModelDataWriter.dump(
-            args_dict=self.args_dict,
+            output_file=self.args_dict["output_file"],
+            output_file_format=self.args_dict.get("output_file_format"),
             metadata=self.metadata,
             product_data=table,
             validate_schema_file=None,
@@ -126,7 +127,7 @@ class SinglePhotonElectronSpectrum:
 
         Raises
         ------
-        subprocess.CalledProcessError
+        job_manager.JobExecutionError
             If the command execution fails.
         """
         tmp_input_file = self._get_input_data(
@@ -153,10 +154,9 @@ class SinglePhotonElectronSpectrum:
 
         self._logger.info(f"Running norm_spe command: {' '.join(command)}")
         try:
-            result = subprocess.run(command, capture_output=True, text=True, check=True)
-        except subprocess.CalledProcessError as exc:
+            result = job_manager.submit(command)
+        except job_manager.JobExecutionError as exc:
             self._logger.error(f"Error running norm_spe: {exc}")
-            self._logger.error(f"stderr: {exc.stderr}")
             raise exc
         finally:
             for tmp_file in [tmp_input_file, tmp_ap_file]: