gammasimtools 0.17.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

simtools/ray_tracing/ray_tracing.py

@@ -13,7 +13,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 from astropy.table import QTable
 
-from simtools.io_operations import io_handler
+from simtools.io import io_handler
 from simtools.model.model_utils import compute_telescope_transmission
 from simtools.ray_tracing.psf_analysis import PSFImage
 from simtools.simtel.simulator_ray_tracing import SimulatorRayTracing
@@ -49,6 +49,8 @@ class RayTracing:
         Single mirror mode flag.
     use_random_focal_length: bool
         Use random focal length flag.
+    random_focal_length_seed: int
+        Seed for the random number generator used for focal length variation.
     mirror_numbers: list, str
         List of mirror numbers (or 'all').
     """
@@ -71,6 +73,7 @@ class RayTracing:
         source_distance=10.0 * u.km,
         single_mirror_mode=False,
         use_random_focal_length=False,
+        random_focal_length_seed=None,
         mirror_numbers="all",
     ):
         """Initialize RayTracing class."""
@@ -87,6 +90,7 @@ class RayTracing:
         self.off_axis_angle = np.around(off_axis_angle.to("deg").value, 5)
         self.single_mirror_mode = single_mirror_mode
         self.use_random_focal_length = use_random_focal_length
+        self.random_focal_length_seed = random_focal_length_seed
         self.mirrors = self._initialize_mirror_configuration(source_distance, mirror_numbers)
         self.output_directory = self._io_handler.get_output_directory(
             label=self.label, sub_dir="ray_tracing"
@@ -185,7 +189,7 @@ class RayTracing:
         """
         _focal_length = self.telescope_model.get_parameter_value("mirror_focal_length")
         if self.use_random_focal_length:
-            rng = np.random.default_rng()
+            rng = np.random.default_rng(self.random_focal_length_seed)
             _random_focal_length = self.telescope_model.get_parameter_value("random_focal_length")
             if _random_focal_length[0] > 0.0:
                 _focal_length += rng.normal(loc=0, scale=_random_focal_length[0])

simtools/reporting/docs_read_parameters.py

@@ -9,14 +9,14 @@ from collections import defaultdict
 from itertools import groupby
 from pathlib import Path
 
+import matplotlib.pyplot as plt
 import numpy as np
 
 from simtools.db import db_handler
-from simtools.io_operations import io_handler
+from simtools.io import ascii_handler, io_handler
 from simtools.model.telescope_model import TelescopeModel
-from simtools.utils import general as gen
 from simtools.utils import names
-from simtools.visualization import plot_pixels
+from simtools.visualization import plot_pixels, plot_tables
 
 logger = logging.getLogger()
 
@@ -64,72 +64,141 @@ class ReadParameters:
             )
         self._model_version = model_version
 
-    def _convert_to_md(self, parameter, parameter_version, input_file):
+    def _generate_plots(self, parameter, parameter_version, input_file, outpath, design_type):
+        """Generate plots based on the parameter type."""
+        plot_names = []
+
+        if parameter == "camera_config_file":
+            plot_names = self._plot_camera_config(parameter, parameter_version, input_file, outpath)
+        elif parameter_version:
+            plot_names = self._plot_parameter_tables(
+                parameter, parameter_version, outpath, design_type
+            )
+
+        return plot_names
+
+    def _plot_camera_config(self, parameter, parameter_version, input_file, outpath):
+        """Generate plots for camera configuration files."""
+        if not parameter_version:
+            return []
+
+        plot_names = []
+        plot_name = input_file.stem.replace(".", "-")
+        plot_path = Path(f"{outpath}/{plot_name}").with_suffix(".png")
+
+        if not plot_path.exists():
+            plot_config = {
+                "file_name": input_file.name,
+                "telescope": self.array_element,
+                "parameter_version": parameter_version,
+                "site": self.site,
+                "model_version": self.model_version,
+                "parameter": parameter,
+            }
+
+            plot_pixels.plot(
+                config=plot_config,
+                output_file=Path(f"{outpath}/{plot_name}"),
+                db_config=self.db_config,
+            )
+            plot_names.append(plot_name)
+        else:
+            logger.info(
+                "Camera configuration file plot already exists: %s",
+                plot_path,
+            )
+            plot_names.append(plot_name)
+
+        return plot_names
+
+    def _plot_parameter_tables(self, parameter, parameter_version, outpath, design_type):
+        """Generate plots for parameter tables."""
+        telescope_design = self.db.get_design_model(
+            self.model_version, self.array_element, collection="telescopes"
+        )
+
+        if not self.array_element:
+            tel = None
+        elif not design_type:
+            tel = telescope_design
+        else:
+            tel = self.array_element
+
+        config_data = plot_tables.generate_plot_configurations(
+            parameter=parameter,
+            parameter_version=parameter_version,
+            site=self.site,
+            telescope=tel,
+            output_path=outpath,
+            plot_type="all",
+            db_config=self.db_config,
+        )
+
+        if not config_data:
+            return []
+
+        plot_configs, output_files = config_data
+        plot_names = [i.stem for i in output_files]
+
+        for plot_config, output_file in zip(plot_configs, output_files):
+            image_output_file = outpath / output_file.name
+            if not image_output_file.with_suffix(".png").exists():
+                plot_tables.plot(
+                    config=plot_config,
+                    output_file=image_output_file,
+                    db_config=self.db_config,
+                )
+                plt.close("all")
+
+        return plot_names
+
+    def _convert_to_md(self, parameter, parameter_version, input_file, design_type=False):
         """Convert a file to a Markdown file, preserving formatting."""
         input_file = Path(input_file)
 
+        if not input_file.exists():
+            raise FileNotFoundError(f"Data file not found: {input_file}")
+
+        # Store the markdown output file path early and don't modify it
         output_data_path = Path(self.output_path / "_data_files")
         output_data_path.mkdir(parents=True, exist_ok=True)
         output_file_name = Path(input_file.stem + ".md")
-        output_file = output_data_path / output_file_name
-        image_name = f"{self.array_element}_{parameter}_{self.model_version.replace('.', '-')}"
-        outpath = Path(io_handler.IOHandler().get_output_directory().parent / "_images")
-        outpath.mkdir(parents=True, exist_ok=True)
-        image_path = Path(f"{outpath}/{image_name}")
-
-        if parameter == "camera_config_file" and parameter_version:
-            image_path = Path(f"{outpath}/{input_file.stem.replace('.', '-')}")
-            if not (image_path.with_suffix(".png")).exists():
-                logger.info("Plotting camera configuration file: %s", input_file.name)
-                plot_config = {
-                    "file_name": input_file.name,
-                    "telescope": self.array_element,
-                    "parameter_version": parameter_version,
-                    "site": self.site,
-                    "model_version": self.model_version,
-                    "parameter": parameter,
-                }
+        relative_path = f"_data_files/{output_file_name}"
+        markdown_output_file = output_data_path / output_file_name
 
-                plot_pixels.plot(
-                    config=plot_config,
-                    output_file=image_path,
-                    db_config=self.db_config,
-                )
-            else:
-                logger.info(
-                    "Camera configuration file plot already exists: %s",
-                    image_path.with_suffix(".png"),
-                )
+        if not markdown_output_file.exists():
+            outpath = Path(io_handler.IOHandler().get_output_directory().parent / "_images")
+            outpath.mkdir(parents=True, exist_ok=True)
 
-        try:
-            # with input_file.open("r", encoding="utf-8") as infile:
-            file_contents = gen.read_file_encoded_in_utf_or_latin(input_file)
-
-            if self.model_version is not None:
-                with output_file.open("w", encoding="utf-8") as outfile:
-                    outfile.write(f"# {input_file.stem}\n")
-                    outfile.write(f"![Parameter plot.]({image_path}.png)\n\n")
-                    outfile.write(
-                        "\n\nThe full file can be found in the Simulation Model repository [here]"
-                        "(https://gitlab.cta-observatory.org/cta-science/simulations/"
-                        "simulation-model/simulation-models/-/blob/main/simulation-models/"
-                        f"model_parameters/Files/{input_file.name}).\n\n"
-                    )
-                    outfile.write("\n\n")
-                    outfile.write("The first 30 lines of the file are:\n")
-                    outfile.write("```\n")
-                    first_30_lines = "".join(file_contents[:30])
-                    outfile.write(first_30_lines)
-                    outfile.write("\n```")
+            plot_names = self._generate_plots(
+                parameter, parameter_version, input_file, outpath, design_type
+            )
+            # Write markdown file using the stored path
+            file_contents = ascii_handler.read_file_encoded_in_utf_or_latin(input_file)
+
+            with markdown_output_file.open("w", encoding="utf-8") as outfile:
+                outfile.write(f"# {input_file.stem}\n")
 
-        except FileNotFoundError as exc:
-            logger.exception(f"Data file not found: {input_file}.")
-            raise FileNotFoundError(f"Data file not found: {input_file}.") from exc
+                for plot_name in plot_names:
+                    outfile.write(f"![Parameter plot.]({outpath}/{plot_name}.png)\n\n")
 
-        return f"_data_files/{output_file_name}"
+                outfile.write(
+                    "\n\nThe full file can be found in the Simulation Model repository [here]"
+                    "(https://gitlab.cta-observatory.org/cta-science/simulations/"
+                    "simulation-model/simulation-models/-/blob/main/simulation-models/"
+                    f"model_parameters/Files/{input_file.name}).\n\n"
+                )
+                outfile.write("\n\n")
+                outfile.write("The first 30 lines of the file are:\n")
+                outfile.write("```\n")
+                first_30_lines = "".join(file_contents[:30])
+                outfile.write(first_30_lines)
+                outfile.write("\n```")
+
+        return relative_path
 
     def _format_parameter_value(
-        self, parameter, value_data, unit, file_flag, parameter_version=None
+        self, parameter, value_data, unit, file_flag, parameter_version=None, design_type=False
     ):
         """Format parameter value based on type."""
         if file_flag:
@@ -140,7 +209,9 @@ class ReadParameters:
                     "cta-science/simulations/simulation-model/simulation-models/-/blob/main/"
                     f"simulation-models/model_parameters/Files/{value_data})"
                 ).strip()
-            output_file_name = self._convert_to_md(parameter, parameter_version, input_file_name)
+            output_file_name = self._convert_to_md(
+                parameter, parameter_version, input_file_name, design_type
+            )
             return f"[{Path(value_data).name}]({output_file_name})".strip()
         if isinstance(value_data, (str | int | float)):
             return f"{value_data} {unit}".strip()
@@ -326,9 +397,10 @@ class ReadParameters:
             if value_data is None:
                 continue
 
+            design_type = names.is_design_type(telescope_model.name)
             file_flag = parameter_data.get("file", False)
             value = self._format_parameter_value(
-                parameter, value_data, unit, file_flag, parameter_version
+                parameter, value_data, unit, file_flag, parameter_version, design_type
             )
 
             description = parameter_descriptions.get(parameter).get("description")
@@ -338,10 +410,10 @@ class ReadParameters:
             inst_class = parameter_descriptions.get(parameter).get("inst_class")
 
             matching_instrument = parameter_data["instrument"] == telescope_model.name
-            if not names.is_design_type(telescope_model.name) and matching_instrument:
+            if not design_type and matching_instrument:
                 parameter = f"***{parameter}***"
                 parameter_version = f"***{parameter_version}***"
-                if not re.match(r"^\[.*\]\(.*\)$", value.strip()):
+                if not self.is_markdown_link(value):
                     value = f"***{value}***"
                 description = f"***{description}***"
                 short_description = f"***{short_description}***"
@@ -723,7 +795,7 @@ class ReadParameters:
             if not names.is_design_type(array_element) and matching_instrument:
                 parameter = f"***{parameter}***"
                 parameter_version = f"***{parameter_version}***"
-                if not re.match(r"^\[.*\]\(.*\)$", value.strip()):
+                if not self.is_markdown_link(value):
                     value = f"***{value}***"
                 description = f"***{description}***"
                 short_description = f"***{short_description}***"
@@ -750,6 +822,22 @@ class ReadParameters:
 
         return data
 
+    def is_markdown_link(self, value):
+        """
+        Return True if the string is a Markdown-style link: [text](target).
+
+        Parameters
+        ----------
+        value : str
+            The string to check.
+
+        Returns
+        -------
+        bool
+            True if the string is a Markdown link, False otherwise.
+        """
+        return bool(re.fullmatch(r"\[[^\]]*\]\([^)]+\)", value.strip()))
+
     def produce_calibration_reports(self):
         """Write calibration reports."""
         calibration_array_elements = self.db.get_array_elements(

simtools/resources/array-element-ids.json

@@ -0,0 +1,126 @@
+{
+  "metadata": {
+    "CTA DATA MODEL NAME": "ctao.common.identifiers.array_elements",
+    "CTA DATA MODEL URL": "https://gitlab.cta-observatory.org/cta-computing/common",
+    "CTA DATA MODEL VERSION": 2,
+    "CTA DATA PRODUCT DESCRIPTION": "This file contains a mapping of array element ID number to human-readable name. The ids define the telescopes and other array elements at CTAO-North and CTAO-South",
+    "CTA PRODUCT ID": "350917c3-fb77-453d-b1bc-296471f5e7fb"
+  },
+
+  "array_elements": [
+    {"id": 1, "name": "LSTN-01"},
+    {"id": 2, "name": "LSTN-02"},
+    {"id": 3, "name": "LSTN-03"},
+    {"id": 4, "name": "LSTN-04"},
+    {"id": 5, "name": "MSTN-01"},
+    {"id": 6, "name": "MSTN-02"},
+    {"id": 7, "name": "MSTN-03"},
+    {"id": 8, "name": "MSTN-04"},
+    {"id": 9, "name": "MSTN-05"},
+    {"id": 10, "name": "MSTN-06"},
+    {"id": 11, "name": "MSTN-07"},
+    {"id": 12, "name": "MSTN-08"},
+    {"id": 13, "name": "MSTN-09"},
+    {"id": 14, "name": "MSTN-10"},
+    {"id": 15, "name": "MSTN-11"},
+    {"id": 16, "name": "MSTN-12"},
+    {"id": 17, "name": "MSTN-13"},
+    {"id": 18, "name": "MSTN-14"},
+    {"id": 19, "name": "MSTN-15"},
+    {"id": 20, "name": "RLDN-01"},
+    {"id": 21, "name": "STPN-01"},
+    {"id": 22, "name": "MSPN-01"},
+    {"id": 23, "name": "ILLN-01"},
+    {"id": 24, "name": "ILLN-02"},
+    {"id": 25, "name": "CEIN-01"},
+    {"id": 26, "name": "WSTN-01"},
+    {"id": 27, "name": "WSTN-02"},
+    {"id": 28, "name": "WSTN-03"},
+    {"id": 29, "name": "ASCN-01"},
+    {"id": 30, "name": "DUSN-01"},
+    {"id": 31, "name": "LISN-01"},
+    {"id": 101, "name": "LSTS-01"},
+    {"id": 102, "name": "LSTS-02"},
+    {"id": 103, "name": "LSTS-03"},
+    {"id": 104, "name": "LSTS-04"},
+    {"id": 105, "name": "MSTS-01"},
+    {"id": 106, "name": "MSTS-02"},
+    {"id": 107, "name": "MSTS-03"},
+    {"id": 108, "name": "MSTS-04"},
+    {"id": 109, "name": "MSTS-05"},
+    {"id": 110, "name": "MSTS-06"},
+    {"id": 111, "name": "MSTS-07"},
+    {"id": 112, "name": "MSTS-08"},
+    {"id": 113, "name": "MSTS-09"},
+    {"id": 114, "name": "MSTS-10"},
+    {"id": 115, "name": "MSTS-11"},
+    {"id": 116, "name": "MSTS-12"},
+    {"id": 117, "name": "MSTS-13"},
+    {"id": 118, "name": "MSTS-14"},
+    {"id": 119, "name": "SSTS-01"},
+    {"id": 120, "name": "SSTS-02"},
+    {"id": 121, "name": "SSTS-03"},
+    {"id": 122, "name": "SSTS-04"},
+    {"id": 123, "name": "SSTS-05"},
+    {"id": 124, "name": "SSTS-06"},
+    {"id": 125, "name": "SSTS-07"},
+    {"id": 126, "name": "SSTS-08"},
+    {"id": 127, "name": "SSTS-09"},
+    {"id": 128, "name": "SSTS-10"},
+    {"id": 129, "name": "SSTS-11"},
+    {"id": 130, "name": "SSTS-12"},
+    {"id": 131, "name": "SSTS-13"},
+    {"id": 132, "name": "SSTS-14"},
+    {"id": 133, "name": "SSTS-15"},
+    {"id": 134, "name": "SSTS-16"},
+    {"id": 135, "name": "SSTS-17"},
+    {"id": 136, "name": "SSTS-18"},
+    {"id": 137, "name": "SSTS-19"},
+    {"id": 138, "name": "SSTS-20"},
+    {"id": 139, "name": "SSTS-21"},
+    {"id": 140, "name": "SSTS-22"},
+    {"id": 141, "name": "SSTS-23"},
+    {"id": 142, "name": "SSTS-24"},
+    {"id": 143, "name": "SSTS-25"},
+    {"id": 144, "name": "SSTS-26"},
+    {"id": 145, "name": "SSTS-27"},
+    {"id": 146, "name": "SSTS-28"},
+    {"id": 147, "name": "SSTS-29"},
+    {"id": 148, "name": "SSTS-30"},
+    {"id": 149, "name": "SSTS-31"},
+    {"id": 150, "name": "SSTS-32"},
+    {"id": 151, "name": "SSTS-33"},
+    {"id": 152, "name": "SSTS-34"},
+    {"id": 153, "name": "SSTS-35"},
+    {"id": 154, "name": "SSTS-36"},
+    {"id": 155, "name": "SSTS-37"},
+    {"id": 156, "name": "SSTS-38"},
+    {"id": 157, "name": "SSTS-39"},
+    {"id": 158, "name": "SSTS-40"},
+    {"id": 159, "name": "SSTS-41"},
+    {"id": 160, "name": "SSTS-42"},
+    {"id": 161, "name": "SSTS-43"},
+    {"id": 162, "name": "SSTS-44"},
+    {"id": 163, "name": "SSTS-45"},
+    {"id": 164, "name": "SSTS-46"},
+    {"id": 165, "name": "SSTS-47"},
+    {"id": 166, "name": "SSTS-48"},
+    {"id": 167, "name": "SSTS-49"},
+    {"id": 168, "name": "SSTS-50"},
+    {"id": 169, "name": "CEIS-01"},
+    {"id": 170, "name": "RLDS-01"},
+    {"id": 171, "name": "RLDS-02"},
+    {"id": 172, "name": "STPS-01"},
+    {"id": 173, "name": "STPS-02"},
+    {"id": 174, "name": "MSPS-01"},
+    {"id": 175, "name": "ILLS-01"},
+    {"id": 176, "name": "ILLS-02"},
+    {"id": 177, "name": "ILLS-03"},
+    {"id": 178, "name": "ILLS-04"},
+    {"id": 179, "name": "WSTS-01"},
+    {"id": 180, "name": "WSTS-02"},
+    {"id": 181, "name": "WSTS-03"},
+    {"id": 182, "name": "ASCS-01"},
+    {"id": 183, "name": "DUSS-01"}
+  ]
+}

simtools/runners/corsika_runner.py

@@ -4,7 +4,7 @@ import logging
 import stat
 from pathlib import Path
 
-from simtools.io_operations import io_handler
+from simtools.io import io_handler
 from simtools.runners.runner_services import RunnerServices
 
 __all__ = ["CorsikaRunner", "MissingRequiredEntryInCorsikaConfigError"]

simtools/runners/corsika_simtel_runner.py

@@ -43,6 +43,7 @@ class CorsikaSimtelRunner:
         use_multipipe=False,
         sim_telarray_seeds=None,
         sequential=False,
+        calibration_runner_args=None,
     ):
         self._logger = logging.getLogger(__name__)
         self.corsika_config = (
@@ -55,6 +56,7 @@ class CorsikaSimtelRunner:
         self.sim_telarray_seeds = sim_telarray_seeds
         self.label = label
         self.sequential = "--sequential" if sequential else ""
+        self.calibration_runner_args = calibration_runner_args
 
         self.base_corsika_config.set_output_file_and_directory(use_multipipe)
         self.corsika_runner = CorsikaRunner(
@@ -124,11 +126,18 @@ class CorsikaSimtelRunner:
 
         with open(multipipe_file, "w", encoding="utf-8") as file:
             for simulator_array in self.simulator_array:
-                run_command = simulator_array.make_run_command(
-                    run_number=run_number,
-                    input_file="-",  # instruct sim_telarray to take input from standard output
-                    weak_pointing=self._determine_pointing_option(self.label),
-                )
+                if self.calibration_runner_args:
+                    run_command = simulator_array.make_run_command_for_calibration_simulations(
+                        run_number=run_number,
+                        input_file="-",  # instruct sim_telarray to take input from standard output
+                        calibration_runner_args=self.calibration_runner_args,
+                    )
+                else:
+                    run_command = simulator_array.make_run_command(
+                        run_number=run_number,
+                        input_file="-",  # instruct sim_telarray to take input from standard output
+                        weak_pointing=self._determine_pointing_option(self.label),
+                    )
                 file.write(f"{run_command}")
                 file.write("\n")
         self._logger.info(f"Multipipe script: {multipipe_file}")

simtools/runners/runner_services.py

@@ -3,7 +3,7 @@
 import logging
 from pathlib import Path
 
-from simtools.io_operations import io_handler
+from simtools.io import io_handler
 
 _logger = logging.getLogger(__name__)
 
@@ -139,11 +139,16 @@ class RunnerServices:
         zenith = self.corsika_config.get_config_parameter("THETAP")[0]
         azimuth = self.corsika_config.azimuth_angle
         run_number_string = self._get_run_number_string(info_for_file_name["run_number"])
-        return (
+        prefix = (
             f"{info_for_file_name['primary']}_{run_number_string}_"
-            f"za{round(zenith):02}deg_azm{azimuth:03}deg_"
-            f"{info_for_file_name['site']}_{info_for_file_name['array_name']}_"
-            f"{info_for_file_name['model_version']}{file_label}"
+            if info_for_file_name["primary"]
+            else f"{run_number_string}_"
+        )
+        return (
+            prefix
+            + f"za{round(zenith):02}deg_azm{azimuth:03}deg_"
+            + f"{info_for_file_name['site']}_{info_for_file_name['array_name']}_"
+            + f"{info_for_file_name['model_version']}{file_label}"
         )
 
     def _get_log_file_path(self, file_type, file_name):