gammasimtools 0.22.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

simtools/reporting/docs_auto_report_generator.py

@@ -19,7 +19,7 @@ class ReportGenerator:
     def __init__(self, db_config, args, output_path):
         """Initialise class."""
         self._logger = logging.getLogger(__name__)
-        self.db = db_handler.DatabaseHandler(mongo_db_config=db_config)
+        self.db = db_handler.DatabaseHandler(db_config=db_config)
         self.db_config = db_config
         self.args = args
         self.output_path = output_path
@@ -175,6 +175,10 @@ class ReportGenerator:
                 f"Markdown report generated for {site} Telescope {telescope}: {self.output_path}"
             )
 
+        # Also generate calibration device parameter comparison reports when using --all_telescopes
+        if self.args.get("all_telescopes"):
+            self._generate_calibration_device_parameter_reports()
+
     def _generate_observatory_report_combinations(self) -> Generator[tuple[str, str], None, None]:
         """Generate combinations of sites and model versions for observatory reports.
 
@@ -215,3 +219,107 @@ class ReportGenerator:
         """Generate all observatory reports based on which --all_* flags are passed."""
         for params in self._generate_observatory_report_combinations():
             self._generate_single_observatory_report(*params)
+
+    def auto_generate_simulation_configuration_reports(self):
+        """Generate simulation configuration reports for one or all model versions.
+
+        If --all_model_versions is set, produce reports for every model version in
+        the DB; otherwise produce reports only for the configured model_version.
+        """
+        model_versions = (
+            self.db.get_model_versions()
+            if self.args.get("all_model_versions")
+            else [self.args["model_version"]]
+        )
+
+        for version in model_versions:
+            # update args and create a per-version output directory
+            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()
+
+            logger.info(f"Configuration reports for (v{version}) produced: {output_path}")
+
+    def auto_generate_calibration_reports(self):
+        """Generate calibration reports for one or all model versions.
+
+        Mirrors the pattern used by other auto_generate_* methods: if
+        --all_model_versions is set, produce reports for every model version in
+        the DB; otherwise produce reports only for the configured model_version.
+        """
+        model_versions = (
+            self.db.get_model_versions()
+            if self.args.get("all_model_versions")
+            else [self.args["model_version"]]
+        )
+
+        for version in model_versions:
+            # update args and create a per-version output directory
+            self.args.update({"model_version": version})
+            output_path = Path(self.output_path) / str(version)
+
+            try:
+                ReadParameters(self.db_config, 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;
+                msg = str(err)
+                if "calibration_devices" in msg and "zero results" in msg:
+                    logger.info(
+                        f"Skipping model version {version}: no calibration devices defined ({msg})"
+                    )
+                    continue
+                # re-raise unexpected ValueErrors
+                raise
+
+    def _generate_calibration_device_parameter_reports(self):
+        """Generate parameter comparison reports for calibration devices for all model versions."""
+        # Get all model versions since no specific version is provided when using --all_telescopes
+        model_versions = self.db.get_model_versions()
+
+        for version in model_versions:
+            self._process_calibration_devices_for_version(version)
+
+    def _process_calibration_devices_for_version(self, version):
+        """Process calibration devices for a specific model version."""
+        try:
+            # Get all calibration devices for this version
+            calibration_array_elements = self.db.get_array_elements(
+                version, collection="calibration_devices"
+            )
+            array_elements = calibration_array_elements.copy()
+
+            # Add design models
+            for element in calibration_array_elements:
+                design_model = self.db.get_design_model(version, element, "calibration_devices")
+                if design_model and design_model not in array_elements:
+                    array_elements.append(design_model)
+
+            if array_elements:
+                # Create a copy of args with the current version for this iteration
+                version_args = self.args.copy()
+                version_args["model_version"] = version
+
+                # Generate parameter comparison reports for calibration devices
+                ReadParameters(
+                    self.db_config, version_args, self.output_path
+                ).generate_model_parameter_reports_for_devices(array_elements)
+
+                logger.info(
+                    "Calibration device parameter reports generated for"
+                    f" v{version}: {self.output_path}"
+                )
+
+        except ValueError as err:
+            # Some model versions may not have calibration_devices
+            msg = str(err)
+            if "calibration_devices" in msg and "zero results" in msg:
+                logger.info(
+                    f"Skipping model version {version}: no calibration devices defined ({msg})"
+                )
+                return
+            # re-raise unexpected ValueErrors
+            raise

simtools/reporting/docs_read_parameters.py

@@ -29,7 +29,7 @@ class ReadParameters:
     def __init__(self, db_config, args, output_path):
         """Initialise class."""
         self._logger = logging.getLogger(__name__)
-        self.db = db_handler.DatabaseHandler(mongo_db_config=db_config)
+        self.db = db_handler.DatabaseHandler(db_config=db_config)
         self.db_config = db_config
         self.array_element = args.get("telescope", None)
         self.site = args.get("site", None)
@@ -543,7 +543,8 @@ class ReadParameters:
             telescope_name=self.array_element,
             model_version=self.model_version,
             label="reports",
-            mongo_db_config=self.db_config,
+            db_config=self.db_config,
+            ignore_software_version=True,
         )
 
         output_filename = Path(self.output_path / (telescope_model.name + ".md"))
@@ -896,9 +897,6 @@ class ReadParameters:
                 output_filename, calibration_device, data, design_model
             )
 
-        # produce parameter comparison reports (site-independent)
-        self._generate_model_parameter_reports_for_devices(array_elements)
-
     def _collect_calibration_array_elements(self):
         """Return a list of calibration devices including their design models."""
         calibration_array_elements = self.db.get_array_elements(
@@ -954,11 +952,8 @@ class ReadParameters:
 
                 self._write_to_file(display_group, file)
 
-    def _generate_model_parameter_reports_for_devices(self, array_elements):
+    def generate_model_parameter_reports_for_devices(self, array_elements):
         """Create model-parameter comparison reports for calibration devices."""
-        new_output_path = Path(self.output_path).parent.parent / "parameters"
-        new_output_path.mkdir(parents=True, exist_ok=True)
-        self.output_path = new_output_path
         for calibration_device in array_elements:
             device_sites = names.get_site_from_array_element_name(calibration_device)
             # parameters are site independent so just take the first site to read from db

simtools/runners/corsika_runner.py

@@ -7,8 +7,6 @@ from pathlib import Path
 from simtools.io import io_handler
 from simtools.runners.runner_services import RunnerServices
 
-__all__ = ["CorsikaRunner", "MissingRequiredEntryInCorsikaConfigError"]
-
 
 class MissingRequiredEntryInCorsikaConfigError(Exception):
     """Exception for missing required entry in corsika config."""

simtools/runners/corsika_simtel_runner.py

@@ -8,8 +8,6 @@ import simtools.utils.general as gen
 from simtools.runners.corsika_runner import CorsikaRunner
 from simtools.simtel.simulator_array import SimulatorArray
 
-__all__ = ["CorsikaSimtelRunner"]
-
 
 class CorsikaSimtelRunner:
     """

simtools/runners/simtel_runner.py

@@ -8,8 +8,6 @@ from pathlib import Path
 import simtools.utils.general as gen
 from simtools.runners.runner_services import RunnerServices
 
-__all__ = ["InvalidOutputFileError", "SimtelExecutionError", "SimtelRunner"]
-
 
 class SimtelExecutionError(Exception):
     """Exception for sim_telarray execution error."""

simtools/schemas/model_parameters/transit_time_random.schema.yml

@@ -0,0 +1,29 @@
+%YAML 1.2
+---
+title: Schema for transit_time_random model parameter
+schema_version: 0.1.0
+meta_schema: simpipe-schema
+meta_schema_url: https://raw.githubusercontent.com/gammasim/simtools/main/src/simtools/schemas/model_parameter_and_data_schema.metaschema.yml
+meta_schema_version: 0.1.0
+name: transit_time_random
+description: Event-wise and pixel-wise random fluctuations in the signal transit time.
+data:
+  - type: float64
+    unit: ns
+    default: 0.
+    allowed_range:
+      min: 0.0
+instrument:
+  class: Camera
+activity:
+  setting:
+    - SetParameterFromExternal
+  validation:
+    - ValidateParameterByExpert
+    - ValidateCameraTimeResponse
+source:
+  - Initial instrument setup
+simulation_software:
+  - name: sim_telarray
+  - name: simtools
+    version: ">=0.22.0"

simtools/schemas/simulation_models_info.schema.yml

@@ -14,11 +14,12 @@ definitions:
       model_version:
         $ref: 'common_definitions.schema.yml#/$defs/semantic_version_pattern'
       model_update:
-        type: string
+        type: [string, 'null']
         description: The type of update for the model version.
         enum:
           - patch_update
           - full_update
+          - null
       model_version_history:
         type: array
         description: A list of previous model versions.

simtools/simtel/simtel_config_reader.py

@@ -10,8 +10,6 @@ import numpy as np
 from simtools.io import ascii_handler
 from simtools.utils import names
 
-__all__ = ["SimtelConfigReader"]
-
 
 def get_list_of_simtel_parameters(simtel_config_file):
     """

simtools/simtel/simtel_config_writer.py

@@ -13,8 +13,6 @@ import simtools.version
 from simtools.io import ascii_handler
 from simtools.utils import names
 
-__all__ = ["SimtelConfigWriter"]
-
 
 def sim_telarray_random_seeds(seed, number):
     """
@@ -67,6 +65,7 @@ class SimtelConfigWriter:
         model_version,
         layout_name=None,
         telescope_model_name=None,
+        telescope_design_model=None,
         label=None,
         simtel_path=None,
     ):
@@ -79,9 +78,12 @@ class SimtelConfigWriter:
         self._label = label
         self._layout_name = layout_name
         self._telescope_model_name = telescope_model_name
+        self._telescope_design_model = telescope_design_model
         self._simtel_path = simtel_path
 
-    def write_telescope_config_file(self, config_file_path, parameters, telescope_name=None):
+    def write_telescope_config_file(
+        self, config_file_path, parameters, telescope_name=None, telescope_design_model=None
+    ):
         """
         Write the sim_telarray config file for a single telescope.
 
@@ -93,22 +95,30 @@ class SimtelConfigWriter:
             Model parameters
         telescope_name: str
             Name of the telescope (use self._telescope_model_name if None)
+        telescope_design_model: str
+            Telescope design model.
         """
         self._logger.debug(f"Writing telescope config file {config_file_path}")
 
         simtel_par = self._get_parameters_for_sim_telarray(parameters, config_file_path)
+        telescope_name = telescope_name or self._telescope_model_name
+        _telescope_design_model = telescope_design_model or self._telescope_design_model
 
         with open(config_file_path, "w", encoding="utf-8") as file:
             self._write_header(file, "TELESCOPE CONFIGURATION FILE")
 
-            telescope_name = telescope_name or self._telescope_model_name
             file.write("#ifdef TELESCOPE\n")
             file.write(f"   echo Configuration for {telescope_name} - TELESCOPE $(TELESCOPE)\n")
             file.write("#endif\n\n")
 
             for simtel_name, simtel_value in simtel_par.items():
                 file.write(f"{simtel_name} = {self._get_value_string_for_simtel(simtel_value)}\n")
-            for meta in self._get_sim_telarray_metadata("telescope", parameters, telescope_name):
+            for meta in self._get_sim_telarray_metadata(
+                "telescope",
+                parameters,
+                telescope_name,
+                telescope_design_model=_telescope_design_model,
+            ):
                 file.write(f"{meta}\n")
 
     def _get_parameters_for_sim_telarray(self, parameters, config_file_path):
@@ -211,12 +221,17 @@ class SimtelConfigWriter:
         value = "none" if value is None else value  # simtel requires 'none'
         if isinstance(value, bool):
             value = 1 if value else 0
-        elif isinstance(value, (list, np.ndarray)):  # noqa: UP038
+        elif isinstance(value, (list, np.ndarray)):
             value = gen.convert_list_to_string(value, shorten_list=True)
         return value
 
     def _get_sim_telarray_metadata(
-        self, config_type, model_parameters, telescope_model_name, additional_metadata=None
+        self,
+        config_type,
+        model_parameters,
+        telescope_model_name,
+        additional_metadata=None,
+        telescope_design_model=None,
     ):
         """
         Return sim_telarray metadata.
@@ -231,6 +246,8 @@ class SimtelConfigWriter:
             Name of the telescope model
         additional_metadata: dict
             Dictionary with additional metadata to include using 'set'.
+        telescope_design_model: str
+            Name of the telescope design model.
 
         Returns
         -------
@@ -241,14 +258,15 @@ class SimtelConfigWriter:
             f"config_release = {self._model_version} with simtools v{simtools.version.__version__}",
             f"config_version = {self._model_version}",
         ]
+        telescope_design_model = telescope_design_model or "design_model_not_set"
         if config_type == "telescope":
             meta_parameters.extend(
                 [
-                    f"camera_config_name = {telescope_model_name}",
-                    "camera_config_variant = ",
+                    f"camera_config_name = {telescope_design_model}",
+                    f"camera_config_variant = {telescope_model_name}",
                     f"camera_config_version = {self._model_version}",
-                    f"optics_config_name = {telescope_model_name}",
-                    "optics_config_variant = ",
+                    f"optics_config_name = {telescope_design_model}",
+                    f"optics_config_variant = {telescope_model_name}",
                     f"optics_config_version = {self._model_version}",
                 ]
             )
@@ -510,7 +528,7 @@ class SimtelConfigWriter:
         """
         file.write(self.TAB + "% Site parameters\n")
         for par, value in site_parameters.items():
-            simtel_name, value = self._convert_model_parameters_to_simtel_format(
+            simtel_name, simtel_value = self._convert_model_parameters_to_simtel_format(
                 names.get_simulation_software_name_from_parameter_name(
                     par, software_name="sim_telarray"
                 ),
@@ -519,9 +537,9 @@ class SimtelConfigWriter:
                 telescope_model,
             )
             if simtel_name is not None:
-                file.write(f"{self.TAB}{simtel_name} = {value}\n")
+                file.write(f"{self.TAB}{simtel_name} = {simtel_value}\n")
         for meta in self._get_sim_telarray_metadata(
-            "site", site_parameters, self._telescope_model_name, additional_metadata
+            "site", site_parameters, None, additional_metadata
         ):
             file.write(f"{self.TAB}{meta}\n")
         file.write("\n")
@@ -574,34 +592,111 @@ class SimtelConfigWriter:
         telescope_model: dict of TelescopeModel
             Telescope models.
         """
+        trigger_per_telescope_type = self._group_telescopes_by_type(telescope_model)
+        hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity = (
+            self._process_telescope_triggers(array_triggers, trigger_per_telescope_type)
+        )
+
+        array_triggers_file = "array_triggers.dat"
+        with open(model_path / array_triggers_file, "w", encoding="utf-8") as file:
+            file.write("# Array trigger definition\n")
+            self._write_trigger_lines(
+                file, hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity
+            )
+
+        return array_triggers_file
+
+    def _group_telescopes_by_type(self, telescope_model):
+        """Group telescopes by their type."""
         trigger_per_telescope_type = {}
         for count, tel_name in enumerate(telescope_model.keys()):
             telescope_type = names.get_array_element_type_from_name(tel_name)
             trigger_per_telescope_type.setdefault(telescope_type, []).append(count + 1)
+        return trigger_per_telescope_type
+
+    def _process_telescope_triggers(self, array_triggers, trigger_per_telescope_type):
+        """Process telescope triggers and group them by hardstereo and parameters."""
+        hardstereo_lines = []
+        non_hardstereo_groups = {}
+        all_non_hardstereo_tels = []
+        multiplicity = None
 
-        trigger_lines = {}
         for tel_type, tel_list in trigger_per_telescope_type.items():
             trigger_dict = self._get_array_triggers_for_telescope_type(
                 array_triggers, tel_type, len(tel_list)
             )
-            trigger_lines[tel_type] = f"Trigger {trigger_dict['multiplicity']['value']} of "
-            trigger_lines[tel_type] += ", ".join(map(str, tel_list))
-            width = trigger_dict["width"]["value"] * u.Unit(trigger_dict["width"]["unit"]).to("ns")
-            trigger_lines[tel_type] += f" width {width}"
-            if trigger_dict.get("hard_stereo"):
-                trigger_lines[tel_type] += " hardstereo"
-            if all(trigger_dict["min_separation"][key] is not None for key in ["value", "unit"]):
-                min_sep = trigger_dict["min_separation"]["value"] * u.Unit(
-                    trigger_dict["min_separation"]["unit"]
-                ).to("m")
-                trigger_lines[tel_type] += f" minsep {min_sep}"
-
-        array_triggers_file = "array_triggers.dat"
-        with open(model_path / array_triggers_file, "w", encoding="utf-8") as file:
-            file.write("# Array trigger definition\n")
-            file.writelines(f"{line}\n" for line in trigger_lines.values())
-
-        return array_triggers_file
+            width, minsep = self._extract_trigger_parameters(trigger_dict)
+            multiplicity = trigger_dict["multiplicity"]["value"]  # Store for later use
+
+            if trigger_dict.get("hard_stereo", {}).get("value"):
+                line = self._build_trigger_line(
+                    trigger_dict, tel_list, width, minsep, hardstereo=True
+                )
+                hardstereo_lines.append(line)
+            else:
+                key = (width, minsep)
+                non_hardstereo_groups.setdefault(key, []).extend(tel_list)
+                all_non_hardstereo_tels.extend(tel_list)
+
+        return hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity
+
+    def _extract_trigger_parameters(self, trigger_dict):
+        """Extract width and min_separation parameters from trigger dictionary."""
+        width = trigger_dict["width"]["value"] * u.Unit(trigger_dict["width"]["unit"]).to("ns")
+        minsep = None
+        if all(trigger_dict["min_separation"][key] is not None for key in ["value", "unit"]):
+            minsep = trigger_dict["min_separation"]["value"] * u.Unit(
+                trigger_dict["min_separation"]["unit"]
+            ).to("m")
+        return width, minsep
+
+    def _build_trigger_line(self, trigger_dict, tel_list, width, minsep, hardstereo=False):
+        """Build a trigger line string."""
+        line = f"Trigger {trigger_dict['multiplicity']['value']} of "
+        line += ", ".join(map(str, tel_list))
+        line += f" width {width}"
+        if hardstereo:
+            line += " hardstereo"
+        if minsep is not None:
+            line += f" minsep {minsep}"
+        return line
+
+    def _write_trigger_lines(
+        self, file, hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity
+    ):
+        """Write all trigger lines to file."""
+        # Write hardstereo lines first
+        for line in hardstereo_lines:
+            file.write(f"{line}\n")
+
+        # Write individual non-hardstereo groups if they have different parameters
+        if len(non_hardstereo_groups) > 1:
+            for (width, minsep), tel_list in non_hardstereo_groups.items():
+                line = f"Trigger {multiplicity} of "
+                line += ", ".join(map(str, tel_list))
+                line += f" width {width}"
+                if minsep is not None:
+                    line += f" minsep {minsep}"
+                file.write(f"{line}\n")
+
+        # Write combined line with all non-hardstereo telescopes using shortest values
+        if all_non_hardstereo_tels:
+            min_width = min(width for width, minsep in non_hardstereo_groups.keys())
+            min_minsep = self._get_minimum_minsep(non_hardstereo_groups)
+
+            combined_line = f"Trigger {multiplicity} of "
+            combined_line += ", ".join(map(str, sorted(all_non_hardstereo_tels)))
+            combined_line += f" width {min_width}"
+            if min_minsep is not None:
+                combined_line += f" minsep {min_minsep}"
+            file.write(f"{combined_line}\n")
+
+    def _get_minimum_minsep(self, non_hardstereo_groups):
+        """Get minimum min_separation value from groups."""
+        minsep_values = [
+            minsep for width, minsep in non_hardstereo_groups.keys() if minsep is not None
+        ]
+        return min(minsep_values) if minsep_values else None
 
     def _get_array_triggers_for_telescope_type(
         self, array_triggers, telescope_type, num_telescopes_of_type

simtools/simtel/simtel_io_metadata.py

@@ -105,8 +105,8 @@ def get_sim_telarray_telescope_id(telescope_name, file):
     _, telescope_meta = read_sim_telarray_metadata(file)
     telescope_name_to_sim_telarray_id = {}
     for tel_id in telescope_meta.keys():
-        _optics_name = telescope_meta[tel_id].get("optics_config_name", None)
-        _camera_name = telescope_meta[tel_id].get("camera_config_name", None)
+        _optics_name = telescope_meta[tel_id].get("optics_config_variant", None)
+        _camera_name = telescope_meta[tel_id].get("camera_config_variant", None)
         if _optics_name == _camera_name and _optics_name == telescope_name:
             telescope_name_to_sim_telarray_id[telescope_name] = tel_id
 
@@ -132,7 +132,7 @@ def get_sim_telarray_telescope_id_to_telescope_name_mapping(file):
     for i, (tel_id, meta) in enumerate(telescope_meta.items()):
         try:
             telescope_name = names.validate_array_element_name(
-                meta.get("optics_config_name", f"Unknown-{tel_id}")
+                meta.get("optics_config_variant", f"Unknown-{tel_id}")
             )
         except ValueError:
             telescope_name = _guess_telescope_name_for_legacy_files(i, file)

simtools/simtel/simulator_array.py

@@ -6,8 +6,6 @@ from simtools.io import io_handler
 from simtools.runners.simtel_runner import InvalidOutputFileError, SimtelRunner
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
 
-__all__ = ["SimulatorArray"]
-
 
 class SimulatorArray(SimtelRunner):
     """
@@ -73,41 +71,33 @@ class SimulatorArray(SimtelRunner):
         command = self._common_run_command(run_number, weak_pointing)
 
         if self.calibration_config:
-            command += self._make_run_command_for_calibration_simulations(input_file)
+            command += self._make_run_command_for_calibration_simulations()
         else:
-            command += self._make_run_command_for_shower_simulations(input_file)
+            command += self._make_run_command_for_shower_simulations()
+
+        # "-C show=all" should be the last option
+        command += super().get_config_option("show", "all")
+        command += f" {input_file} | gzip > {self._log_file} 2>&1 || exit"
 
         return clear_default_sim_telarray_cfg_directories(command)
 
-    def _make_run_command_for_shower_simulations(self, input_file=None):
+    def _make_run_command_for_shower_simulations(self):
         """
         Build and return the command to run sim_telarray shower simulations.
 
-        Parameters
-        ----------
-        input_file: str
-            Full path of the input CORSIKA file
-        run_number: int (optional)
-            run number
-        weak_pointing: bool (optional)
-            Specify weak pointing option for sim_telarray.
-
         Returns
         -------
         str
             Command to run sim_telarray.
         """
-        command = f" {input_file}"
-        command += f" | gzip > {self._log_file} 2>&1 || exit"
-        command += super().get_config_option(
+        return super().get_config_option(
             "power_law",
             SimulatorArray.get_power_law_for_sim_telarray_histograms(
                 self.corsika_config.primary_particle
             ),
         )
-        return command
 
-    def _make_run_command_for_calibration_simulations(self, input_file=None):
+    def _make_run_command_for_calibration_simulations(self):
         """Build sim_telarray command for calibration simulations."""
         cfg = self.calibration_config
         altitude = self.corsika_config.array_model.site_model.get_parameter_value_with_unit(
@@ -133,7 +123,6 @@ class SimulatorArray(SimtelRunner):
             n_events = cfg.get("number_of_flasher_events", cfg["number_of_events"])
             command += super().get_config_option("laser_events", n_events)
 
-        command += f" {input_file} | gzip > {self._log_file} 2>&1 || exit"
         return command
 
     def _common_run_command(self, run_number, weak_pointing=None):
@@ -162,7 +151,6 @@ class SimulatorArray(SimtelRunner):
             )
         elif self.sim_telarray_seeds and self.sim_telarray_seeds.get("seed"):
             command += super().get_config_option("random_seed", self.sim_telarray_seeds["seed"])
-        command += super().get_config_option("show", "all")
         command += super().get_config_option("output_file", output_file)
 
         return command

simtools/simtel/simulator_camera_efficiency.py

@@ -7,8 +7,6 @@ from simtools.io import ascii_handler
 from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils import general
 
-__all__ = ["SimulatorCameraEfficiency"]
-
 
 class SimulatorCameraEfficiency(SimtelRunner):
     """

simtools/simtel/simulator_light_emission.py

@@ -15,8 +15,6 @@ from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
 from simtools.utils.geometry import fiducial_radius_from_shape
 
-__all__ = ["SimulatorLightEmission"]
-
 
 class SimulatorLightEmission(SimtelRunner):
     """
@@ -41,7 +39,7 @@ class SimulatorLightEmission(SimtelRunner):
             simtel_path=light_emission_config.get("simtel_path"), label=label, corsika_config=None
         )
 
-        self.output_directory = self.io_handler.get_output_directory(label)
+        self.output_directory = self.io_handler.get_output_directory()
 
         self.telescope_model, self.site_model, self.calibration_model = (
             initialize_simulation_models(

simtools/simtel/simulator_ray_tracing.py

@@ -10,8 +10,6 @@ from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils import names
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
 
-__all__ = ["SimulatorRayTracing"]
-
 # pylint: disable=no-member
 # The line above is needed because there are members which are created
 # by adding them to the __dict__ of the class rather than directly.