gammasimtools 0.6.1__py3-none-any.whl → 0.8.1__py3-none-any.whl

simtools/simtel/simtel_runner_array.py

@@ -1,293 +0,0 @@
-import logging
-from pathlib import Path
-
-import simtools.utils.general as gen
-from simtools.io_operations import io_handler
-from simtools.simtel.simtel_runner import InvalidOutputFile, SimtelRunner
-
-__all__ = ["SimtelRunnerArray"]
-
-
-class SimtelRunnerArray(SimtelRunner):
-    """
-    SimtelRunnerArray is the interface with sim_telarray to perform array simulations.
-
-    Configurable parameters:
-        simtel_data_directory:
-            len: 1
-            default: null
-            unit: null
-        primary:
-            len: 1
-            unit: null
-        zenith_angle:
-            len: 1
-            unit: deg
-            default: 20 deg
-        azimuth_angle:
-            len: 1
-            unit: deg
-            default: 0 deg
-
-    Parameters
-    ----------
-    array_model: str
-        Instance of TelescopeModel class.
-    label: str
-        Instance label. Important for output file naming.
-    simtel_source_path: str or Path
-        Location of sim_telarray installation.
-    config_data: dict
-        Dict containing the configurable parameters.
-    config_file: str or Path
-        Path of the yaml file containing the configurable parameters.
-    """
-
-    def __init__(
-        self,
-        array_model,
-        label=None,
-        simtel_source_path=None,
-        config_data=None,
-        config_file=None,
-    ):
-        """
-        Initialize SimtelRunnerArray.
-        """
-        self._logger = logging.getLogger(__name__)
-        self._logger.debug("Init SimtelRunnerArray")
-
-        super().__init__(label=label, simtel_source_path=simtel_source_path)
-
-        self.array_model = self._validate_array_model(array_model)
-        self.label = label if label is not None else self.array_model.label
-        self._log_file = None
-
-        self.io_handler = io_handler.IOHandler()
-
-        self._base_directory = self.io_handler.get_output_directory(self.label, "array-simulator")
-
-        # Loading config_data
-        _config_data_in = gen.collect_data_from_file_or_dict(config_file, config_data)
-        _parameter_file = self.io_handler.get_input_data_file(
-            "parameters", "simtel-runner-array_parameters.yml"
-        )
-        _parameters = gen.collect_data_from_file_or_dict(_parameter_file, None)
-        self.config = gen.validate_config_data(_config_data_in, _parameters)
-
-        self._load_simtel_data_directories()
-
-    def _load_simtel_data_directories(self):
-        """
-        Create sim_telarray output directories for data, log and input.
-
-        If simtel_data_directory is not given as a configurable parameter,
-        the standard directory of simtools output (simtools-output) will
-        be used. A sub directory simtel-data will be created and sub directories for
-        log and data will be created inside it.
-        """
-
-        if self.config.simtel_data_directory is None:
-            # Default config value
-            simtel_base_dir = self._base_directory
-        else:
-            simtel_base_dir = Path(self.config.simtel_data_directory)
-
-        simtel_base_dir = simtel_base_dir.joinpath("simtel-data")
-        simtel_base_dir = simtel_base_dir.joinpath(self.array_model.site)
-        simtel_base_dir = simtel_base_dir.joinpath(self.config.primary)
-        simtel_base_dir = simtel_base_dir.absolute()
-
-        self._simtel_data_dir = simtel_base_dir.joinpath("data")
-        self._simtel_data_dir.mkdir(parents=True, exist_ok=True)
-        self._simtel_log_dir = simtel_base_dir.joinpath("log")
-        self._simtel_log_dir.mkdir(parents=True, exist_ok=True)
-
-    def get_info_for_file_name(self, run_number):
-        """
-        Get a dictionary with the info necessary for building the sim_telarray file names.
-
-        Returns
-        -------
-        dict
-            Dictionary with the keys necessary for building the sim_telarray file names.
-        """
-        return {
-            "run": run_number,
-            "primary": self.config.primary,
-            "array_name": self.array_model.layout_name,
-            "site": self.array_model.site,
-            "zenith": self.config.zenith_angle,
-            "azimuth": self.config.azimuth_angle,
-            "label": self.label,
-        }
-
-    def get_file_name(self, file_type, **kwargs):
-        """
-        Get a sim_telarray style file name for various file types.
-
-        Parameters
-        ----------
-        file_type: str
-            The type of file (determines the file suffix). Choices are log, histogram, output or\
-             sub_log.
-        kwargs: dict
-            The dictionary must include the following parameters (unless listed as optional):
-                run: int
-                    Run number.
-                primary: str
-                    Primary particle (e.g gamma, proton etc).
-                zenith: float
-                    Zenith angle (deg).
-                azimuth: float
-                    Azimuth angle (deg).
-                site: str
-                    Site name (usually North/South or Paranal/LaPalma).
-                array_name: str
-                    Array name.
-                label: str
-                    Instance label (optional).
-                mode: str
-                    out or err (optional, relevant only for sub_log).
-
-        Returns
-        -------
-        str
-            File name with full path.
-
-        Raises
-        ------
-        ValueError
-            If file_type is unknown.
-        """
-
-        file_label = (
-            f"_{kwargs['label']}" if "label" in kwargs and kwargs["label"] is not None else ""
-        )
-        file_name = (
-            f"run{kwargs['run']:06}_{kwargs['primary']}_"
-            f"za{round(kwargs['zenith']):03}deg_azm{round(kwargs['azimuth']):03}deg_"
-            f"{kwargs['site']}_{kwargs['array_name']}{file_label}"
-        )
-        if file_type == "log":
-            return self._simtel_log_dir.joinpath(f"{file_name}.log.gz")
-        if file_type == "histogram":
-            return self._simtel_log_dir.joinpath(f"{file_name}.hdata.zst")
-        if file_type == "output":
-            return self._simtel_data_dir.joinpath(f"{file_name}.simtel.zst")
-        if file_type == "sub_log":
-            suffix = ".log"
-            if "mode" in kwargs:
-                suffix = f".{kwargs['mode']}"
-            return self._simtel_log_dir.joinpath(f"log_sub_{file_name}{suffix}")
-
-        raise ValueError(f"The requested file type ({file_type}) is unknown")
-
-    def has_file(self, file_type, run_number, mode="out"):
-        """
-        Checks that the file of file_type for the specified run number exists.
-
-        Parameters
-        ----------
-        file_type: str
-            File type to check.
-            Choices are log, histogram, output or sub_log.
-        run_number: int
-            Run number.
-        mode: str
-            Mode.
-        """
-
-        info_for_file_name = self.get_info_for_file_name(run_number)
-        run_sub_file = self.get_file_name(file_type, **info_for_file_name, mode=mode)
-        return Path(run_sub_file).is_file()
-
-    def get_resources(self, run_number):
-        """
-        Reading run time from last line of submission log file.
-
-        Parameters
-        ----------
-        run_number: int
-            Run number.
-
-        Returns
-        -------
-        dict
-            run time of job in seconds.
-
-        """
-
-        info_for_file_name = self.get_info_for_file_name(run_number)
-        sub_log_file = self.get_file_name("sub_log", **info_for_file_name, mode="out")
-
-        self._logger.debug(f"Reading resources from {sub_log_file}")
-
-        _resources = {}
-
-        _resources["runtime"] = None
-        with open(sub_log_file, "r", encoding="utf-8") as file:
-            for line in reversed(list(file)):
-                if "RUNTIME" in line:
-                    _resources["runtime"] = int(line.split()[1])
-                    break
-
-        if _resources["runtime"] is None:
-            self._logger.debug("RUNTIME was not found in run log file")
-
-        return _resources
-
-    def _shall_run(self, **kwargs):
-        """Tells if simulations should be run again based on the existence of output files."""
-        output_file = self.get_file_name(
-            file_type="output", **self.get_info_for_file_name(kwargs["run_number"])
-        )
-        return not output_file.exists()
-
-    def _make_run_command(self, **kwargs):
-        """
-        Builds and returns the command to run simtel_array.
-
-        Parameters
-        ----------
-        kwargs: dict
-            The dictionary must include the following parameters (unless listed as optional):
-                input_file: str
-                    Full path of the input CORSIKA file
-                run_number: int (optional)
-                    run number
-
-        """
-
-        run_number = kwargs["run_number"] if "run_number" in kwargs else 1
-        info_for_file_name = self.get_info_for_file_name(run_number)
-        self._log_file = self.get_file_name(file_type="log", **info_for_file_name)
-        histogram_file = self.get_file_name(file_type="histogram", **info_for_file_name)
-        output_file = self.get_file_name(file_type="output", **info_for_file_name)
-
-        # Array
-        command = str(self._simtel_source_path.joinpath("sim_telarray/bin/sim_telarray"))
-        command += f" -c {self.array_model.get_config_file()}"
-        command += f" -I{self.array_model.get_config_directory()}"
-        command += super()._config_option("telescope_theta", self.config.zenith_angle)
-        command += super()._config_option("telescope_phi", self.config.azimuth_angle)
-        command += super()._config_option("power_law", "2.5")
-        command += super()._config_option("histogram_file", histogram_file)
-        command += super()._config_option("output_file", output_file)
-        command += super()._config_option("random_state", "none")
-        command += super()._config_option("show", "all")
-        command += f" {kwargs['input_file']}"
-        command += f" > {self._log_file} 2>&1 || exit"
-
-        return command
-
-    def _check_run_result(self, **kwargs):
-        # Checking run
-        output_file = self.get_file_name(
-            file_type="output", **self.get_info_for_file_name(kwargs["run_number"])
-        )
-        if not output_file.exists():
-            msg = "sim_telarray output file does not exist."
-            self._logger.error(msg)
-            raise InvalidOutputFile(msg)
-        self._logger.debug(f"simtel_array output file {output_file} exists.")

simtools/simtel/simtel_runner_ray_tracing.py

@@ -1,277 +0,0 @@
-import logging
-
-import astropy.units as u
-
-import simtools.utils.general as gen
-from simtools.io_operations import io_handler
-from simtools.simtel.simtel_runner import SimtelRunner
-from simtools.utils import names
-
-__all__ = ["SimtelRunnerRayTracing"]
-
-# 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.
-
-
-class SimtelRunnerRayTracing(SimtelRunner):
-    """
-    SimtelRunnerRayTracing is the interface with sim_telarray to perform ray tracing simulations.
-
-    Configurable parameters:
-        zenith_angle:
-            len: 1
-            unit: deg
-            default: 20 deg
-        off_axis_angle:
-            len: 1
-            unit: deg
-            default: 0 deg
-        source_distance:
-            len: 1
-            unit: km
-            default: 10 km
-        single_mirror_mode:
-            len: 1
-            default: False
-        use_random_focal_length:
-            len: 1
-            default: False
-        mirror_numbers:
-            len: 1
-            default: 1
-
-    Parameters
-    ----------
-    telescope_model: str
-        Instance of TelescopeModel class.
-    label: str
-        Instance label. Important for output file naming.
-    simtel_source_path: str or Path
-        Location of sim_telarray installation.
-    config_data: dict
-        Dict containing the configurable parameters.
-    config_file: str or Path
-        Path of the yaml file containing the configurable parameters.
-    force_simulate: bool
-        Remove existing files and force re-running of the ray-tracing simulation.
-    """
-
-    def __init__(
-        self,
-        telescope_model,
-        label=None,
-        simtel_source_path=None,
-        config_data=None,
-        config_file=None,
-        force_simulate=False,
-        test=False,
-    ):
-        """
-        Initialize SimtelRunner.
-        """
-        self._logger = logging.getLogger(__name__)
-        self._logger.debug("Init SimtelRunnerRayTracing")
-
-        super().__init__(label=label, simtel_source_path=simtel_source_path)
-
-        self.telescope_model = self._validate_telescope_model(telescope_model)
-        self.label = label if label is not None else self.telescope_model.label
-
-        self.io_handler = io_handler.IOHandler()
-        self._base_directory = self.io_handler.get_output_directory(self.label, "ray-tracing")
-
-        # Loading config_data
-        self.config = gen.validate_config_data(
-            gen.collect_data_from_file_or_dict(config_file, config_data),
-            self.ray_tracing_default_configuration(True),
-        )
-
-        # RayTracing - default parameters
-        self._rep_number = 0
-        self.runs_per_set = 1 if self.config.single_mirror_mode else 20
-        self.photons_per_run = 100000 if not test else 10000
-
-        self._load_required_files(force_simulate)
-
-    def _load_required_files(self, force_simulate):
-        """
-        Which file are required for running depends on the mode.
-        Here we define and write some information into these files. Log files are always required.
-        """
-
-        # This file is not actually needed and does not exist in simtools.
-        # However, we need to provide the name of a CORSIKA input file to sim_telarray
-        # so it is set up here.
-        self._corsika_file = self._simtel_source_path.joinpath("run9991.corsika.gz")
-
-        # Loop to define and remove existing files.
-        # Files will be named _base_file = self.__dict__['_' + base + 'File']
-        for base_name in ["stars", "photons", "log"]:
-            file_name = names.ray_tracing_file_name(
-                self.telescope_model.site,
-                self.telescope_model.name,
-                self.config.source_distance,
-                self.config.zenith_angle,
-                self.config.off_axis_angle,
-                self.config.mirror_numbers if self.config.single_mirror_mode else None,
-                self.label,
-                base_name,
-            )
-            file = self._base_directory.joinpath(file_name)
-            if file.exists() and force_simulate:
-                file.unlink()
-            # Defining the file name variable as an class attribute.
-            self.__dict__["_" + base_name + "_file"] = file
-
-        if not file.exists() or force_simulate:
-            # Adding header to photon list file.
-            with self._photons_file.open("w", encoding="utf-8") as file:
-                file.write(f"#{50 * '='}\n")
-                file.write("# List of photons for RayTracing simulations\n")
-                file.write(f"#{50 * '='}\n")
-                file.write(f"# config_file = {self.telescope_model.get_config_file()}\n")
-                file.write(f"# zenith_angle [deg] = {self.config.zenith_angle}\n")
-                file.write(f"# off_axis_angle [deg] = {self.config.off_axis_angle}\n")
-                file.write(f"# source_distance [km] = {self.config.source_distance}\n")
-                if self.config.single_mirror_mode:
-                    file.write(f"# mirror_number = {self.config.mirror_numbers}\n\n")
-
-            # Filling in star file with a single light source.
-            # Parameters defining light source:
-            # - azimuth
-            # - elevation
-            # - flux
-            # - distance of light source
-            with self._stars_file.open("w", encoding="utf-8") as file:
-                file.write(
-                    f"0. {90.0 - self.config.zenith_angle} 1.0 {self.config.source_distance}\n"
-                )
-
-    def _shall_run(self, **kwargs):  # pylint: disable=unused-argument; applies only to this line
-        """Tells if simulations should be run again based on the existence of output files."""
-        return not self._is_photon_list_file_ok()
-
-    def _make_run_command(self, **kwargs):  # pylint: disable=unused-argument
-        """Return the command to run simtel_array."""
-
-        if self.config.single_mirror_mode:
-            _mirror_focal_length = float(
-                self.telescope_model.get_parameter_value("mirror_focal_length")
-            )
-
-        # RayTracing
-        command = str(self._simtel_source_path.joinpath("sim_telarray/bin/sim_telarray"))
-        command += f" -c {self.telescope_model.get_config_file()}"
-        command += " -I../cfg/CTA"
-        command += f" -I{self.telescope_model.get_config_directory()}"
-        command += super()._config_option("random_state", "none")
-        command += super()._config_option("IMAGING_LIST", str(self._photons_file))
-        command += super()._config_option("stars", str(self._stars_file))
-        command += super()._config_option(
-            "altitude", self.telescope_model.get_parameter_value("altitude")
-        )
-        command += super()._config_option(
-            "telescope_theta", self.config.zenith_angle + self.config.off_axis_angle
-        )
-        command += super()._config_option("star_photons", str(self.photons_per_run))
-        command += super()._config_option("telescope_phi", "0")
-        command += super()._config_option("camera_transmission", "1.0")
-        command += super()._config_option("nightsky_background", "all:0.")
-        command += super()._config_option("trigger_current_limit", "1e10")
-        command += super()._config_option("telescope_random_angle", "0")
-        command += super()._config_option("telescope_random_error", "0")
-        command += super()._config_option("convergent_depth", "0")
-        command += super()._config_option("maximum_telescopes", "1")
-        command += super()._config_option("show", "all")
-        command += super()._config_option("camera_filter", "none")
-        if self.config.single_mirror_mode:
-            command += super()._config_option("focus_offset", "all:0.")
-            command += super()._config_option("camera_config_file", "single_pixel_camera.dat")
-            command += super()._config_option("camera_pixels", "1")
-            command += super()._config_option("trigger_pixels", "1")
-            command += super()._config_option("camera_body_diameter", "0")
-            command += super()._config_option(
-                "mirror_list",
-                self.telescope_model.get_single_mirror_list_file(
-                    self.config.mirror_numbers, self.config.use_random_focal_length
-                ),
-            )
-            command += super()._config_option(
-                "focal_length", self.config.source_distance * u.km.to(u.cm)
-            )
-            command += super()._config_option("dish_shape_length", _mirror_focal_length)
-            command += super()._config_option("mirror_focal_length", _mirror_focal_length)
-            command += super()._config_option("parabolic_dish", "0")
-            command += super()._config_option("mirror_align_random_distance", "0.")
-            command += super()._config_option("mirror_align_random_vertical", "0.,28.,0.,0.")
-        command += " " + str(self._corsika_file)
-        command += " 2>&1 > " + str(self._log_file) + " 2>&1"
-
-        return command
-
-    def _check_run_result(self, **kwargs):  # pylint: disable=unused-argument
-        """Checking run results.
-
-        Raises
-        ------
-        RuntimeError
-            if Photon list is empty.
-        """
-        # Checking run
-        if not self._is_photon_list_file_ok():
-            msg = "Photon list is empty."
-            self._logger.error(msg)
-            raise RuntimeError(msg)
-
-        self._logger.debug("Everything looks fine with output file.")
-
-    def _is_photon_list_file_ok(self):
-        """Check if the photon list is valid,"""
-        n_lines = 0
-        with open(self._photons_file, "rb") as ff:
-            for _ in ff:
-                n_lines += 1
-                if n_lines > 100:
-                    break
-
-        return n_lines > 100
-
-    @staticmethod
-    def ray_tracing_default_configuration(config_runner=False):
-        """
-        Get default ray tracing configuration.
-
-        Returns
-        -------
-        dict
-            Default configuration for ray tracing.
-
-        """
-
-        return {
-            "zenith_angle": {
-                "len": 1,
-                "unit": u.Unit("deg"),
-                "default": 20.0 * u.deg,
-                "names": ["zenith", "theta"],
-            },
-            "off_axis_angle": {
-                "len": 1 if config_runner else None,
-                "unit": u.Unit("deg"),
-                "default": 0.0 * u.deg,
-                "names": ["offaxis", "offset"],
-            },
-            "source_distance": {
-                "len": 1,
-                "unit": u.Unit("km"),
-                "default": 10.0 * u.km,
-                "names": ["sourcedist", "srcdist"],
-            },
-            "single_mirror_mode": {"len": 1, "default": False},
-            "use_random_focal_length": {"len": 1, "default": False},
-            "mirror_numbers": {
-                "len": 1 if config_runner else None,
-                "default": 1 if config_runner else "all",
-            },
-        }