gammasimtools 0.18.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

simtools/camera/camera_efficiency.py

@@ -5,10 +5,11 @@ import re
 from collections import defaultdict
 
 import astropy.io.ascii
+import astropy.units as u
 import numpy as np
 from astropy.table import Table
 
-from simtools.io_operations import io_handler
+from simtools.io import io_handler
 from simtools.model.model_utils import initialize_simulation_models
 from simtools.simtel.simulator_camera_efficiency import SimulatorCameraEfficiency
 from simtools.utils import names
@@ -23,32 +24,20 @@ class CameraEfficiency:
 
     Parameters
     ----------
-    simtel_path: str (or Path)
-        Location of sim_telarray installation.
     db_config: dict
         Configuration for the database.
     label: str
         Instance label, optional.
     config_data: dict.
         Dict containing the configurable parameters.
-    test: bool
-        Is it a test instance (at the moment only affects the location of files).
     """
 
-    def __init__(
-        self,
-        simtel_path,
-        config_data,
-        label,
-        db_config,
-        test=False,
-    ):
+    def __init__(self, config_data, label, db_config):
         """Initialize the CameraEfficiency class."""
         self._logger = logging.getLogger(__name__)
 
-        self._simtel_path = simtel_path
+        self._simtel_path = config_data.get("simtel_path")
         self.label = label
-        self.test = test
 
         self.io_handler = io_handler.IOHandler()
         self.telescope_model, self.site_model = initialize_simulation_models(
@@ -66,15 +55,16 @@ class CameraEfficiency:
         self.config = self._configuration_from_args_dict(config_data)
         self._file = self._load_files()
 
+        self.nsb_pixel_pe_per_ns = None
+        self.nsb_rate_ref_conditions = None
+
     def __repr__(self):
         """Return string representation of the CameraEfficiency instance."""
         return f"CameraEfficiency(label={self.label})\n"
 
     def _configuration_from_args_dict(self, config_data):
         """
-        Extract the configuration data from the args_dict.
-
-        Zenith and azimuth angles are set to default values if not provided.
+        Extract configuration data from command line arguments.
 
         Parameters
         ----------
@@ -86,22 +76,9 @@ class CameraEfficiency:
         dict
             Configuration data.
         """
-        zenith_angle = config_data.get("zenith_angle")
-        if zenith_angle is not None:
-            zenith_angle = zenith_angle.to("deg").value
-        else:
-            zenith_angle = 20.0
-            self._logger.info(f"Setting zenith angle to default value {zenith_angle} deg")
-        azimuth_angle = config_data.get("azimuth_angle")
-        if azimuth_angle is not None:
-            azimuth_angle = azimuth_angle.to("deg").value
-        else:
-            azimuth_angle = 0.0
-            self._logger.info(f"Setting azimuth angle to default value {azimuth_angle} deg")
-
         return {
-            "zenith_angle": zenith_angle,
-            "azimuth_angle": azimuth_angle,
+            "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),
         }
 
@@ -149,7 +126,7 @@ class CameraEfficiency:
                 "skip_correction_to_nsb_spectrum", False
             ),
         )
-        simtel.run(test=self.test)
+        simtel.run()
 
     def export_model_files(self):
         """Export model and config files to the output directory."""
@@ -159,6 +136,30 @@ class CameraEfficiency:
                 model_directory=self.telescope_model.config_file_directory
             )
 
+    def get_nsb_pixel_rate(self, reference_conditions=False):
+        """
+        Return the expected NSB pixel rate for each camera pixel.
+
+        This is an approximation, as testeff calculates the expected NSB pixel rate
+        for the on-axis pixel only.
+
+        Returns
+        -------
+        list
+            Expected NSB pixel rate in p.e./ns for the provided NSB spectrum.
+        """
+        base_rate = (
+            self.nsb_rate_ref_conditions if reference_conditions else self.nsb_pixel_pe_per_ns
+        )
+        # Accept either a plain float (assumed already in GHz) or an astropy Quantity
+        if isinstance(base_rate, u.Quantity):
+            base_rate_ghz = base_rate.to(u.GHz).value
+        else:
+            base_rate_ghz = float(base_rate)
+
+        n_pixels = int(self.telescope_model.get_parameter_value("camera_pixels"))
+        return u.Quantity(np.full(n_pixels, base_rate_ghz), u.GHz)
+
     def analyze(self, export=True, force=False):
         """
         Analyze camera efficiency output file and store the results in _results.
@@ -243,6 +244,8 @@ class CameraEfficiency:
         self._results = Table(_results)
         self._has_results = True
 
+        self.nsb_pixel_pe_per_ns, self.nsb_rate_ref_conditions = self.calc_nsb_rate()
+
         print("\33[40;37;1m")
         self._logger.info(f"\n{self.results_summary()}")
         print("\033[0m")
@@ -257,7 +260,6 @@ class CameraEfficiency:
         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.
         """
-        nsb_pixel_pe_per_ns, nsb_rate_ref_conditions = self.calc_nsb_rate()
         nsb_spectrum_text = (
             f"NSB spectrum file: {self.config['nsb_spectrum']}"
             if self.config["nsb_spectrum"]
@@ -277,9 +279,9 @@ class CameraEfficiency:
             "(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"{nsb_pixel_pe_per_ns:.4f} [p.e./ns]\n"
+            f"{self.nsb_pixel_pe_per_ns:.4f} [p.e./ns]\n"
             "Expected NSB pixel rate for the reference NSB: "
-            f"{nsb_rate_ref_conditions:.4f} [p.e./ns]\n"
+            f"{self.nsb_rate_ref_conditions:.4f} [p.e./ns]\n"
         )
 
     def export_results(self):
@@ -388,10 +390,17 @@ class CameraEfficiency:
         c2_sum = np.sum(c2_reduced_wl)
         return c2_sum / c1_sum / self._results["masts"][0]
 
-    def calc_nsb_rate(self):
+    def calc_nsb_rate(self, wavelength_range=(300 * u.nm, 650 * u.nm)):
         """
         Calculate the NSB rate.
 
+        CTAO reference wavelength range is 300-650 nm.
+
+        Parameters
+        ----------
+        wavelength_range: tuple
+            Wavelength range used for the NSB rate calculation (default: (300 nm, 650 nm)).
+
         Returns
         -------
         nsb_rate_provided_spectrum: float
@@ -400,27 +409,34 @@ class CameraEfficiency:
             NSB pixel rate in p.e./ns for reference conditions
             (https://jama.cta-observatory.org/perspective.req#/items/26694?projectId=11)
         """
-        nsb_rate_provided_spectrum = (
+        self.nsb_pixel_pe_per_ns = (
             np.sum(self._results["N4"])
             * self.telescope_model.camera.get_pixel_active_solid_angle()
             * self.telescope_model.get_on_axis_eff_optical_area().to("m2").value
             / self.telescope_model.get_parameter_value("telescope_transmission")[0]
         )
 
-        # (integral is in ph./(m^2 ns sr) ) from 300 - 650 nm:
-        n1_reduced_wl = self._results["N1"][[299 < wl_now < 651 for wl_now in self._results["wl"]]]
+        wavelength_range = (
+            wavelength_range[0].to("nm").value,
+            wavelength_range[1].to("nm").value,
+        )
+
+        # (integral is in ph./(m^2 ns sr) ) over wavelength_range
+        n1_reduced_wl = self._results["N1"][
+            [wavelength_range[0] <= wl_now <= wavelength_range[1] for wl_now in self._results["wl"]]
+        ]
         n1_sum = np.sum(n1_reduced_wl)
         n1_integral_edges = self._results["N1"][
-            [wl_now in [300, 650] for wl_now in self._results["wl"]]
+            [wl_now in [wavelength_range[0], wavelength_range[1]] for wl_now in self._results["wl"]]
         ]
         n1_integral_edges_sum = np.sum(n1_integral_edges)
         nsb_integral = 0.0001 * (n1_sum - 0.5 * n1_integral_edges_sum)
-        nsb_rate_ref_conditions = (
-            nsb_rate_provided_spectrum
+        self.nsb_rate_ref_conditions = (
+            self.nsb_pixel_pe_per_ns
             * self.site_model.get_parameter_value("nsb_reference_value")
             / nsb_integral
         )
-        return nsb_rate_provided_spectrum, nsb_rate_ref_conditions
+        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):
         """

simtools/camera/single_photon_electron_spectrum.py

@@ -15,7 +15,7 @@ import simtools.data_model.model_data_writer as writer
 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_operations import io_handler
+from simtools.io import io_handler
 
 
 class SinglePhotonElectronSpectrum:

simtools/configuration/commandline_parser.py

@@ -222,6 +222,13 @@ class CommandLineParser(argparse.ArgumentParser):
             required=False,
             default=None,
         )
+        _job_group.add_argument(
+            "--db_simulation_model_version",
+            help="version of simulation model database",
+            type=str.strip,
+            required=False,
+            default=None,
+        )
 
     def initialize_simulation_model_arguments(self, model_options):
         """
@@ -307,6 +314,12 @@ class CommandLineParser(argparse.ArgumentParser):
                 selected_parameters=simulation_configuration["corsika_configuration"],
                 available_parameters=self._get_dictionary_with_shower_configuration(),
             )
+        if "sim_telarray_configuration" in simulation_configuration:
+            self._initialize_simulation_configuration(
+                group_name="sim_telarray configuration",
+                selected_parameters=simulation_configuration["sim_telarray_configuration"],
+                available_parameters=self._get_dictionary_with_sim_telarray_configuration(),
+            )
 
     def _initialize_simulation_software(self):
         """Initialize simulation software arguments."""
@@ -351,11 +364,13 @@ class CommandLineParser(argparse.ArgumentParser):
                 ),
                 "type": CommandLineParser.azimuth_angle,
                 "required": True,
+                "default": 0 * u.deg,
             },
             "zenith_angle": {
                 "help": "Zenith angle in degrees (between 0 and 180).",
                 "type": CommandLineParser.zenith_angle,
                 "required": True,
+                "default": 20 * u.deg,
             },
             "nshow": {
                 "help": "Number of showers per run to simulate.",
@@ -429,6 +444,27 @@ class CommandLineParser(argparse.ArgumentParser):
             },
         }
 
+    @staticmethod
+    def _get_dictionary_with_sim_telarray_configuration():
+        """Return dictionary with sim_telarray configuration parameters."""
+        return {
+            "sim_telarray_instrument_seeds": {
+                "help": (
+                    "Random seed used for sim_telarray instrument setup. "
+                    "If '--sim_telarray_random_instrument_instances' is not set: "
+                    "use as sim_telarray seed ('random_seed' parameter). Otherwise: "
+                    "use as base seed to generate the random instrument instance seeds."
+                ),
+                "type": str,
+                "required": False,
+            },
+            "sim_telarray_random_instrument_instances": {
+                "help": "Number of random instrument instances initialized in sim_telarray.",
+                "type": int,
+                "required": False,
+            },
+        }
+
     def _initialize_simulation_configuration(
         self, group_name, selected_parameters, available_parameters
     ):
@@ -711,28 +747,27 @@ class CommandLineParser(argparse.ArgumentParser):
     @staticmethod
     def parse_quantity_pair(string):
         """
-        Parse a string representing a pair of astropy quantities separated by a space.
-
-        Args:
-            string: The input string (e.g., "0 deg 1.5 deg").
+        Parse a string representing a pair of astropy quantities.
 
         Returns
         -------
-            tuple: A tuple containing two astropy.units.Quantity objects.
+        tuple
+            A tuple of two astropy.units.Quantity objects.
 
         Raises
         ------
-            ValueError: If the string is not formatted correctly (e.g., missing space).
+        ValueError
+            If the string cannot be parsed into exactly two quantities.
         """
-        pattern = r"(\d+\.?\d*)\s*([a-zA-Z]+)"
+        pattern = r"(?>[\d\.eE+-]+)\s*(?>[A-Za-z]+)"
         matches = re.findall(pattern, string)
         if len(matches) != 2:
             raise ValueError("Input string does not contain exactly two quantities.")
 
-        return (
-            u.Quantity(float(matches[0][0]), matches[0][1]),
-            u.Quantity(float(matches[1][0]), matches[1][1]),
-        )
+        try:
+            return tuple(u.Quantity(m) for m in matches)
+        except Exception as exc:
+            raise ValueError(f"Could not parse quantities: {exc}") from exc
 
     @staticmethod
     def parse_integer_and_quantity(input_string):

simtools/configuration/configurator.py

@@ -11,7 +11,7 @@ from dotenv import load_dotenv
 
 import simtools.configuration.commandline_parser as argparser
 from simtools.db.db_handler import jsonschema_db_dict
-from simtools.io_operations import io_handler
+from simtools.io import ascii_handler, io_handler
 from simtools.utils import general as gen
 
 __all__ = [
@@ -280,15 +280,15 @@ class Configurator:
         try:
             self._logger.debug(f"Reading configuration from {config_file}")
             _config_dict = (
-                gen.collect_data_from_file(file_name=config_file) if config_file else None
+                ascii_handler.collect_data_from_file(file_name=config_file) if config_file else None
             )
             # yaml parser adds \n in multiline strings, remove them
             _config_dict = gen.remove_substring_recursively_from_dict(_config_dict, substring="\n")
             # read configuration for first application
-            if "CONFIGURATION" in _config_dict.get("CTA_SIMPIPE", {}).get("APPLICATIONS", [{}])[0]:
+            if "configuration" in _config_dict.get("applications", [{}])[0]:
                 self._fill_from_config_dict(
                     input_dict=gen.change_dict_keys_case(
-                        _config_dict["CTA_SIMPIPE"]["APPLICATIONS"][0]["CONFIGURATION"],
+                        _config_dict["applications"][0]["configuration"],
                     ),
                     overwrite=True,
                 )

simtools/corsika/corsika_config.py

@@ -7,7 +7,7 @@ import numpy as np
 from astropy import units as u
 
 from simtools.corsika.primary_particle import PrimaryParticle
-from simtools.io_operations import io_handler
+from simtools.io import io_handler
 from simtools.model.model_parameter import ModelParameter
 
 __all__ = [
@@ -39,9 +39,12 @@ class CorsikaConfig:
         MongoDB configuration.
     label : str
         Instance label.
+    dummy_simulations : bool
+        If True, the configuration is generated for dummy simulations
+        (e.g., sim_telarray requires for some run modes a valid CORSIKA input file).
     """
 
-    def __init__(self, array_model, args_dict, db_config=None, label=None):
+    def __init__(self, array_model, args_dict, db_config=None, label=None, dummy_simulations=False):
         """Initialize CorsikaConfig."""
         self._logger = logging.getLogger(__name__)
         self._logger.debug("Init CorsikaConfig")
@@ -51,13 +54,13 @@ class CorsikaConfig:
         self.azimuth_angle = None
         self._run_number = None
         self.config_file_path = None
-        # The following uses the setter defined below, that is why the args_dict is passed
-        self.primary_particle = args_dict
+        self.primary_particle = args_dict  # see setter for primary_particle
+        self.dummy_simulations = dummy_simulations
 
         self.io_handler = io_handler.IOHandler()
         self.array_model = array_model
         self.config = self.fill_corsika_configuration(args_dict, db_config)
-        self._is_file_updated = False
+        self.is_file_updated = False
 
     def __repr__(self):
         """CorsikaConfig class representation."""
@@ -110,7 +113,7 @@ class CorsikaConfig:
         if args_dict is None:
             return {}
 
-        self._is_file_updated = False
+        self.is_file_updated = False
         self.azimuth_angle = int(args_dict["azimuth_angle"].to("deg").value)
         self.zenith_angle = args_dict["zenith_angle"].to("deg").value
 
@@ -119,7 +122,10 @@ class CorsikaConfig:
         )
 
         config = {}
-        config["USER_INPUT"] = self._corsika_configuration_from_user_input(args_dict)
+        if self.dummy_simulations:
+            config["USER_INPUT"] = self._corsika_configuration_for_dummy_simulations()
+        else:
+            config["USER_INPUT"] = self._corsika_configuration_from_user_input(args_dict)
 
         if db_config is None:  # all following parameter require DB
             return config
@@ -200,6 +206,30 @@ class CorsikaConfig:
                         f"Values are {current_value} and {next_value} respectively."
                     )
 
+    def _corsika_configuration_for_dummy_simulations(self):
+        """
+        Return CORSIKA configuration for dummy simulations.
+
+        Settings are such that that the simulations are fast
+        and none (or not many) Cherenkov photons are generated.
+
+        Returns
+        -------
+        dict
+            Dictionary with CORSIKA parameters for dummy simulations.
+        """
+        return {
+            "EVTNR": [1],
+            "NSHOW": [1],
+            "PRMPAR": [1],  # CORSIKA ID 1 for primary gamma
+            "ESLOPE": [-2.0],
+            "ERANGE": [0.1, 0.1],
+            "THETAP": [20.0, 20.0],
+            "PHIP": [0.0, 0.0],
+            "VIEWCONE": [0.0, 0.0],
+            "CSCAT": [1, 0.0, 10.0],
+        }
+
     def _corsika_configuration_from_user_input(self, args_dict):
         """
         Get CORSIKA configuration from user input.
@@ -492,17 +522,9 @@ class CorsikaConfig:
             if par_name in values:
                 par_value = values[par_name]
         if len(par_value) == 0:
-            self._logger.error(f"Parameter {par_name} is not a CORSIKA config parameter")
-            raise KeyError
+            raise KeyError(f"Parameter {par_name} is not a CORSIKA config parameter")
         return par_value if len(par_value) > 1 else par_value[0]
 
-    def print_config_parameter(self):
-        """Print CORSIKA config parameters for inspection."""
-        for parameter_type, parameter_dict in self.config.items():
-            print(f"Parameter type: {parameter_type}\n")
-            for par, value in parameter_dict.items():
-                print(f"{par} = {value}")
-
     @staticmethod
     def _get_text_single_line(pars, line_begin=""):
         """
@@ -538,7 +560,7 @@ class CorsikaConfig:
             the output directly to sim_telarray.
 
         """
-        if self._is_file_updated:
+        if self.is_file_updated:
             self._logger.debug(f"CORSIKA input file already updated: {self.config_file_path}")
             return self.config_file_path
         _output_generic_file_name = self.set_output_file_and_directory(use_multipipe=use_multipipe)
@@ -605,7 +627,7 @@ class CorsikaConfig:
             model_directory=self.array_model.get_config_directory()
         )
 
-        self._is_file_updated = True
+        self.is_file_updated = True
         return self.config_file_path
 
     def get_corsika_config_file_name(self, file_type, run_number=None):
@@ -758,9 +780,7 @@ class CorsikaConfig:
 
     def validate_run_number(self, run_number):
         """
-        Validate run number and return it.
-
-        Return run number from configuration if None.
+        Validate run number and return it. Return run number from configuration if None.
 
         Parameters
         ----------
@@ -775,12 +795,12 @@ class CorsikaConfig:
         Raises
         ------
         ValueError
-            If run_number is not a valid value (e.g., < 1).
+            If run_number is not a valid value (< 1 or > 999999).
         """
         if run_number is None:
             return self.run_number
         if not float(run_number).is_integer() or run_number < 1 or run_number > 999999:
-            msg = f"Invalid type of run number ({run_number}) - it must be an uint < 1000000."
-            self._logger.error(msg)
-            raise ValueError(msg)
+            raise ValueError(
+                f"Invalid type of run number ({run_number}) - it must be an uint < 1000000."
+            )
         return run_number

simtools/corsika/corsika_histograms.py

@@ -17,9 +17,9 @@ from ctapipe.io import write_table
 from eventio import IACTFile
 
 from simtools import version
-from simtools.io_operations import io_handler
-from simtools.io_operations.hdf5_handler import fill_hdf5_table
-from simtools.utils.general import collect_data_from_file
+from simtools.io import io_handler
+from simtools.io.ascii_handler import collect_data_from_file
+from simtools.io.hdf5_handler import fill_hdf5_table
 from simtools.utils.geometry import convert_2d_to_radial_distr, rotate
 from simtools.utils.names import sanitize_name
 
@@ -752,8 +752,9 @@ class CorsikaHistograms:
             elif label == "time_altitude":
                 mini_hist = self.hist_time_altitude[i_telescope]
                 hist_values.append(self.hist_time_altitude[i_telescope].view().T)
-            x_bin_edges.append(mini_hist.axes.edges[0].flatten())
-            y_bin_edges.append(mini_hist.axes.edges[1].flatten())
+            if mini_hist is not None:
+                x_bin_edges.append(mini_hist.axes.edges[0].flatten())
+                y_bin_edges.append(mini_hist.axes.edges[1].flatten())
 
         return np.array(hist_values), np.array(x_bin_edges), np.array(y_bin_edges)
 

simtools/data_model/data_reader.py

@@ -6,9 +6,9 @@ import astropy.units as u
 from astropy.io.registry.base import IORegistryError
 from astropy.table import QTable
 
-import simtools.utils.general as gen
 from simtools.data_model import validate_data
 from simtools.data_model.metadata_collector import MetadataCollector
+from simtools.io import ascii_handler
 
 __all__ = ["read_table_from_file", "read_value_from_file"]
 
@@ -56,7 +56,6 @@ def read_table_from_file(file_name, schema_file=None, validate=False, metadata_f
         metadata = MetadataCollector(
             args_dict=None,
             metadata_file_name=(metadata_file if metadata_file is not None else file_name),
-            data_model_name=None,
         )
 
         _validator = validate_data.DataValidator(
@@ -105,7 +104,7 @@ def read_value_from_file(file_name, schema_file=None, validate=False):
 
     """
     try:
-        data = gen.collect_data_from_file(file_name=file_name)
+        data = ascii_handler.collect_data_from_file(file_name=file_name)
     except FileNotFoundError as exc:
         _logger.error("Error reading data from %s", file_name)
         raise exc