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

simtools/corsika/corsika_runner.py

@@ -3,13 +3,13 @@ import os
 from copy import copy
 from pathlib import Path
 
-from simtools import io_handler
 from simtools.corsika.corsika_config import (
     CorsikaConfig,
     MissingRequiredInputInCorsikaConfigData,
 )
+from simtools.io_operations import io_handler
 from simtools.utils import names
-from simtools.utils.general import collect_data_from_yaml_or_dict
+from simtools.utils.general import collect_data_from_file_or_dict
 
 __all__ = ["CorsikaRunner", "MissingRequiredEntryInCorsikaConfig"]
 
@@ -96,7 +96,7 @@ class CorsikaRunner:
 
         self.label = label
         self.site = names.validate_site_name(site)
-        self.layout_name = names.validate_layout_array_name(layout_name)
+        self.layout_name = names.validate_array_layout_name(layout_name)
 
         self._keep_seeds = keep_seeds
 
@@ -106,7 +106,8 @@ class CorsikaRunner:
         self._output_directory = self.io_handler.get_output_directory(self.label, _runner_directory)
         self._logger.debug(f"Creating output dir {self._output_directory}, if needed,")
 
-        corsika_config_data = collect_data_from_yaml_or_dict(
+        self._corsika_parameters_file = corsika_parameters_file
+        corsika_config_data = collect_data_from_file_or_dict(
             corsika_config_file, corsika_config_data
         )
         self._load_corsika_config_data(corsika_config_data)
@@ -151,6 +152,7 @@ class CorsikaRunner:
                 layout_name=self.layout_name,
                 corsika_config_data=self._corsika_config_data,
                 simtel_source_path=self._simtel_source_path,
+                corsika_parameters_file=self._corsika_parameters_file,
             )
             # CORSIKA input file used as template for all runs
             self._corsika_input_file = self.corsika_config.get_input_file(use_multipipe)
@@ -239,6 +241,8 @@ class CorsikaRunner:
             if use_pfp:
                 file.write("\n# Running pfp\n")
                 file.write(pfp_command)
+                file.write("\n# Replacing the XXXXXX placeholder with the run number\n")
+                file.write(f"sed -i 's/XXXXXX/{run_number:06}/g' {corsika_input_tmp_file}\n")
             else:
                 file.write("\n# Copying CORSIKA input file to run location\n")
                 file.write(f"cp {self._corsika_input_file} {corsika_input_tmp_file}")

simtools/corsika_simtel/corsika_simtel_runner.py

@@ -90,7 +90,7 @@ class CorsikaSimtelRunner(CorsikaRunner, SimtelRunnerArray):
             run_number=run_number,
             input_file="-",  # Tell sim_telarray to take the input from standard output
         )
-        multipipe_file = Path(self.corsika_config._config_file_path.parent).joinpath(
+        multipipe_file = Path(self.corsika_config.config_file_path.parent).joinpath(
             self.corsika_config.get_file_name("multipipe")
         )
         with open(multipipe_file, "w", encoding="utf-8") as file:
@@ -107,7 +107,7 @@ class CorsikaSimtelRunner(CorsikaRunner, SimtelRunnerArray):
             The name of the multipipe file which contains all of the multipipe commands.
         """
 
-        multipipe_executable = Path(self.corsika_config._config_file_path.parent).joinpath(
+        multipipe_executable = Path(self.corsika_config.config_file_path.parent).joinpath(
             "run_cta_multipipe"
         )
         with open(multipipe_executable, "w", encoding="utf-8") as file:
@@ -136,34 +136,29 @@ class CorsikaSimtelRunner(CorsikaRunner, SimtelRunnerArray):
 
         """
 
-        # TODO: These definitions of the files can probably be separated from
-        # the the run command and put back into the parent class.
         info_for_file_name = SimtelRunnerArray.get_info_for_file_name(self, kwargs["run_number"])
-        self._log_file = SimtelRunnerArray.get_file_name(
-            self, file_type="log", **info_for_file_name
-        )
-        histogram_file = SimtelRunnerArray.get_file_name(
-            self, file_type="histogram", **info_for_file_name
-        )
-        output_file = SimtelRunnerArray.get_file_name(
-            self, file_type="output", **info_for_file_name
-        )
+        weak_pointing = any(pointing in self.label for pointing in ["divergent", "convergent"])
 
-        # TODO: Implement the weak pointing for divergent pointing
-        # TODO: Think how to create multiple run commands for various pipes (e.g., NSB levels)
-        # 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", "auto")
+        command += super()._config_option(
+            "telescope_theta", self.config.zenith_angle, weak_option=weak_pointing
+        )
+        command += super()._config_option(
+            "telescope_phi", self.config.azimuth_angle, weak_option=weak_pointing
+        )
+        command += super()._config_option("power_law", abs(self.corsika_config.eslope))
+        command += super()._config_option(
+            "histogram_file", self.get_file_name("histogram", **info_for_file_name)
+        )
+        command += super()._config_option(
+            "output_file", self.get_file_name("output", **info_for_file_name)
+        )
+        command += super()._config_option("random_state", "none")
         command += super()._config_option("show", "all")
         command += f" {kwargs['input_file']}"
-        command += f" | gzip > {self._log_file} 2>&1 || exit"
+        command += f" | gzip > {self.get_file_name('log', **info_for_file_name)} 2>&1 || exit"
 
         return command
 

simtools/data_model/data_reader.py

@@ -0,0 +1,129 @@
+import logging
+
+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 metadata_model, validate_data
+from simtools.data_model.metadata_collector import MetadataCollector
+
+__all__ = ["read_table_from_file", "read_value_from_file"]
+
+_logger = logging.getLogger(__name__)
+
+
+def read_table_from_file(file_name, schema_file=None, validate=False, metadata_file=None):
+    """
+    Read astropy table from file and validate against schema.
+    Metadata is read from metadata file or from the metadata section of the data file.
+    Schema for validation can be given as argument, or is determined
+    from the metadata associated to the file.
+
+    Parameters:
+    -----------
+    file_name: str or Path
+        Name of file to be read.
+    schema_file: str or Path
+        Name of schema file to be used for validation.
+    validate: bool
+        Validate data against schema (if true).
+    metadata_file: str or Path
+        Name of metadata file to be read.
+
+    Returns:
+    --------
+    astropy Table
+        Table read from file.
+
+    Raises
+    ------
+    FileNotFoundError
+        If file does not exist.
+
+    """
+
+    try:
+        data_table = QTable.read(file_name)
+    except (FileNotFoundError, IORegistryError) as exc:
+        _logger.error("Error reading tabled data from %s", file_name)
+        raise exc
+    _logger.info("Reading table data from %s", file_name)
+
+    if validate:
+        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(
+            schema_file=(
+                schema_file
+                if schema_file is not None
+                else metadata.get_data_model_schema_file_name()
+            ),
+            data_table=data_table,
+        )
+        return _validator.validate_and_transform()
+
+    return data_table
+
+
+def read_value_from_file(file_name, schema_file=None, validate=False):
+    """
+    Read value from file and validate against schema. Expect data to follow the convention for
+    how simulation model parameters are stored in the simulation model database: to be a single
+    value stored in the 'value' field (with possible units in the 'units' field).
+    Metadata is read from metadata file or from the metadata section of the data file.
+    Schema for validation can be given as argument, or is determined
+    from the metadata associated to the file.
+
+    Parameters:
+    -----------
+    file_name: str or Path
+        Name of file to be read.
+    schema_file: str or Path
+        Name of schema file to be used for validation.
+    validate: bool
+        Validate data against schema (if true).
+
+    Returns:
+    --------
+    astro quantity or str
+        Value read from file. If units are given, return an astropy quantity, otherwise a string.
+        Return None if no value is found in the file.
+
+    Raises
+    ------
+    FileNotFoundError
+        If file does not exist.
+
+    """
+
+    try:
+        data = gen.collect_data_from_file_or_dict(file_name=file_name, in_dict=None)
+    except FileNotFoundError as exc:
+        _logger.error("Error reading data from %s", file_name)
+        raise exc
+    _logger.info("Reading data from %s", file_name)
+
+    if validate:
+        if schema_file is None and "meta_schema_url" in data:
+            schema_file = data["meta_schema_url"]
+            _logger.debug(f"Using schema from meta_schema_url: {schema_file}")
+        if schema_file is None:
+            _collector = MetadataCollector(None, metadata_file_name=file_name)
+            schema_file = _collector.get_data_model_schema_file_name()
+            _logger.debug(f"Using schema from meta_data_url: {schema_file}")
+
+        metadata_model.validate_schema(data, schema_file)
+        _logger.debug("Successful validation of yaml/json file")
+
+    if "Value" not in data or data["Value"] is None:
+        return None
+
+    if "units" in data and len(data["units"]) > 0:
+        return data["Value"] * u.Unit(data["units"])
+
+    return data["Value"]