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

simtools/corsika/corsika_config.py

@@ -1,325 +1,381 @@
-import copy
+"""CORSIKA configuration."""
+
 import logging
 from pathlib import Path
 
-import astropy.units as u
 import numpy as np
-from astropy.io.misc import yaml
+from astropy import units as u
 
 import simtools.utils.general as gen
+from simtools.corsika.primary_particle import PrimaryParticle
 from simtools.io_operations import io_handler
-from simtools.layout.array_layout import ArrayLayout
-from simtools.utils import names
-from simtools.utils.general import collect_data_from_file_or_dict
+from simtools.model.model_parameter import ModelParameter
 
 __all__ = [
     "CorsikaConfig",
-    "MissingRequiredInputInCorsikaConfigData",
-    "InvalidCorsikaInput",
+    "InvalidCorsikaInputError",
 ]
 
 
-class MissingRequiredInputInCorsikaConfigData(Exception):
-    """Exception for missing required input in corsika config data."""
-
-
-class InvalidCorsikaInput(Exception):
+class InvalidCorsikaInputError(Exception):
     """Exception for invalid corsika input."""
 
 
 class CorsikaConfig:
     """
-    CorsikaConfig deals with configuration for running CORSIKA. User parameters must be given by \
-    the corsika_config_data or corsika_config_file arguments. An example of corsika_config_data
-    follows below.
-
-    .. code-block:: python
-
-        corsika_config_data = {
-            'data_directory': .
-            'primary': 'proton',
-            'nshow': 10000,
-            'nrun': 1,
-            'zenith': 20 * u.deg,
-            'viewcone': 5 * u.deg,
-            'erange': [10 * u.GeV, 100 * u.TeV],
-            'eslope': -2,
-            'phi': 0 * u.deg,
-            'cscat': [10, 1500 * u.m, 0]
-        }
+    Configuration for the CORSIKA air shower simulation software.
+
+    Follows closely the CORSIKA definitions and output format (see CORSIKA manual).
+
+    The configuration is set as a dict corresponding to the command line configuration groups
+    (especially simulation_software, simulation configuration, simulation parameters).
 
     Parameters
     ----------
-    mongo_db_config: dict
+    array_model : ArrayModel
+        Array model.
+    args_dict : dict
+        Configuration dictionary.
+    db_config : dict
         MongoDB configuration.
-    site: str
-        North or South.
-    layout_name: str
-        Name of the layout.
-    label: str
+    label : str
         Instance label.
-    corsika_config_data: dict
-        CORSIKA user parameters.
-    corsika_config_file: str
-        Name of the yaml configuration file. If not provided, \
-        data/parameters/corsika_parameters.yml will be used.
-    corsika_parameters_file: str
-        Name of the yaml file to set remaining CORSIKA parameters.
-    simtel_source_path: str or Path
-        Location of source of the sim_telarray/CORSIKA package.
     """
 
-    def __init__(
-        self,
-        mongo_db_config,
-        site,
-        layout_name,
-        label=None,
-        corsika_config_data=None,
-        corsika_config_file=None,
-        corsika_parameters_file=None,
-        simtel_source_path=None,
-    ):
-        """
-        Initialize CorsikaConfig.
-        """
-
+    def __init__(self, array_model, args_dict, db_config=None, label=None):
+        """Initialize CorsikaConfig."""
         self._logger = logging.getLogger(__name__)
         self._logger.debug("Init CorsikaConfig")
 
         self.label = label
-        self.site = names.validate_site_name(site)
-        self.primary = None
-        self.eslope = None
+        self.zenith_angle = None
+        self.azimuth_angle = None
+        self._run_number = None
         self.config_file_path = None
-        self._output_generic_file_name = None
-        self._simtel_source_path = simtel_source_path
+        # The following uses the setter defined below, that is why the args_dict is passed
+        self.primary_particle = args_dict
 
         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
 
-        # Grabbing layout name and building ArrayLayout
-        self.layout_name = names.validate_array_layout_name(layout_name)
-        self.layout = ArrayLayout.from_array_layout_name(
-            mongo_db_config=mongo_db_config,
-            array_layout_name=f"{self.site}-{self.layout_name}",
-            label=self.label,
+    def __repr__(self):
+        """CorsikaConfig class representation."""
+        return (
+            f"<class {self.__class__.__name__}> "
+            f"(site={self.array_model.site}, "
+            f"layout={self.array_model.layout_name}, label={self.label})"
         )
 
-        # Load parameters
-        if corsika_parameters_file is None:
-            corsika_parameters_file = self.io_handler.get_input_data_file(
-                "parameters", "corsika_parameters.yml"
-            )
+    @property
+    def primary_particle(self):
+        """Primary particle."""
+        return self._primary_particle
 
-        self._corsika_parameters = self.load_corsika_parameters_file(corsika_parameters_file)
+    @primary_particle.setter
+    def primary_particle(self, args_dict):
+        """
+        Set primary particle from input dictionary.
 
-        corsika_config_data = collect_data_from_file_or_dict(
-            corsika_config_file, corsika_config_data
-        )
-        self.set_user_parameters(corsika_config_data)
-        self._is_file_updated = False
+        This is to make sure that when setting the primary particle,
+        we get the full PrimaryParticle object expected.
 
-    def __repr__(self):
-        text = (
-            f"<class {self.__class__.__name__}> "
-            f"(site={self.site}, layout={self.layout_name}, label={self.label})"
-        )
-        return text
+        Parameters
+        ----------
+        args_dict: dict
+            Configuration dictionary
+        """
+        self._primary_particle = self._set_primary_particle(args_dict)
 
-    @staticmethod
-    def load_corsika_parameters_file(corsika_parameters_file):
+    def fill_corsika_configuration(self, args_dict, db_config=None):
         """
-        Load CORSIKA parameters from the provided corsika_parameters_file.
+        Fill CORSIKA configuration.
+
+        Dictionary keys are CORSIKA parameter names.
+        Values are converted to CORSIKA-consistent units.
+
 
         Parameters
         ----------
-        corsika_parameters_file: str or Path
-            File with CORSIKA parameters.
+        args_dict : dict
+            Configuration dictionary.
+        db_config: dict
+            Database configuration.
 
         Returns
         -------
-        corsika_parameters: dict
+        dict
             Dictionary with CORSIKA parameters.
         """
+        if args_dict is None:
+            return {}
+
+        self._logger.debug("Setting CORSIKA parameters ")
+
+        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
+
+        self._logger.debug(
+            f"Setting CORSIKA parameters from database ({args_dict['model_version']})"
+        )
+
+        config = {}
+        config["USER_INPUT"] = self._corsika_configuration_from_user_input(args_dict)
+
+        if db_config is None:  # all following parameter require DB
+            return config
+
+        db_model_parameters = ModelParameter(
+            mongo_db_config=db_config, model_version=args_dict["model_version"]
+        )
+        parameters_from_db = db_model_parameters.get_simulation_software_parameters("corsika")
 
-        logger = logging.getLogger(__name__)
-        logger.debug(f"Loading CORSIKA parameters from file {corsika_parameters_file}")
-        with open(corsika_parameters_file, "r", encoding="utf-8") as f:
-            corsika_parameters = yaml.load(f)
-        return corsika_parameters
+        config["INTERACTION_FLAGS"] = self._corsika_configuration_interaction_flags(
+            parameters_from_db
+        )
+        config["CHERENKOV_EMISSION_PARAMETERS"] = self._corsika_configuration_cherenkov_parameters(
+            parameters_from_db
+        )
+        config["DEBUGGING_OUTPUT_PARAMETERS"] = self._corsika_configuration_debugging_parameters()
+        config["IACT_PARAMETERS"] = self._corsika_configuration_iact_parameters(parameters_from_db)
+
+        return config
 
-    def set_user_parameters(self, corsika_config_data):
+    def _corsika_configuration_from_user_input(self, args_dict):
         """
-        Set user parameters from a dict.
+        Get CORSIKA configuration from user input.
 
         Parameters
         ----------
-        corsika_config_data: dict
-            Contains the user parameters. Ex.
-
-            .. code-block:: python
-
-                corsika_config_data = {
-                    'primary': 'proton',
-                    'nshow': 10000,
-                    'nrun': 1,
-                    'zenith': 20 * u.deg,
-                    'viewcone': 5 * u.deg,
-                    'erange': [10 * u.GeV, 100 * u.TeV],
-                    'eslope': -2,
-                    'phi': 0 * u.deg,
-                    'cscat': [10, 1500 * u.m, 0]
-                }
+        args_dict : dict
+            Configuration dictionary.
 
-        Raises
-        ------
-        InvalidCorsikaInput
-            If any parameter given as input has wrong len, unit or
-            an invalid name.
-        MissingRequiredInputInCorsikaConfigData
-            If any required user parameter is missing.
-        """
-
-        self._logger.debug("Setting user parameters from corsika_config_data")
-        self._user_parameters = {}
-
-        user_pars = self._corsika_parameters["USER_PARAMETERS"]
-
-        # Collecting all parameters given as arguments
-        for key_args, value_args in corsika_config_data.items():
-            # Looping over USER_PARAMETERS and searching for a match
-            is_identified = False
-            for par_name, par_info in user_pars.items():
-                if key_args.upper() != par_name and key_args.upper() not in par_info["names"]:
-                    continue
-                # Matched parameter
-                validated_value_args = self._validate_and_convert_argument(
-                    par_name, par_info, value_args
-                )
-                self._user_parameters[par_name] = validated_value_args
-                is_identified = True
-
-            # Raising error for an unidentified input.
-            if not is_identified:
-                msg = f"Argument {key_args} cannot be identified."
-                self._logger.error(msg)
-                raise InvalidCorsikaInput(msg)
-
-        # Checking for parameters with default option
-        # If it is not given, filling it with the default value
-        for par_name, par_info in user_pars.items():
-            if par_name in self._user_parameters:
-                continue
-            if "default" in par_info.keys():
-                validated_value = self._validate_and_convert_argument(
-                    par_name, par_info, par_info["default"]
-                )
-                self._user_parameters[par_name] = validated_value
-            else:
-                msg = f"Required parameters {par_name} was not given (there may be more)."
-                self._logger.error(msg)
-                raise MissingRequiredInputInCorsikaConfigData(msg)
+        Returns
+        -------
+        dict
+            Dictionary with CORSIKA parameters.
+        """
+        return {
+            "EVTNR": [args_dict["event_number_first_shower"]],
+            "NSHOW": [args_dict["nshow"]],
+            "PRMPAR": [self.primary_particle.corsika7_id],
+            "ESLOPE": [args_dict["eslope"]],
+            "ERANGE": [
+                args_dict["energy_range"][0].to("GeV").value,
+                args_dict["energy_range"][1].to("GeV").value,
+            ],
+            "THETAP": [
+                float(args_dict["zenith_angle"].to("deg").value),
+                float(args_dict["zenith_angle"].to("deg").value),
+            ],
+            "PHIP": [
+                self._rotate_azimuth_by_180deg(
+                    args_dict["azimuth_angle"].to("deg").value,
+                    correct_for_geomagnetic_field_alignment=args_dict[
+                        "correct_for_b_field_alignment"
+                    ],
+                ),
+                self._rotate_azimuth_by_180deg(
+                    args_dict["azimuth_angle"].to("deg").value,
+                    correct_for_geomagnetic_field_alignment=args_dict[
+                        "correct_for_b_field_alignment"
+                    ],
+                ),
+            ],
+            "VIEWCONE": [
+                args_dict["view_cone"][0].to("deg").value,
+                args_dict["view_cone"][1].to("deg").value,
+            ],
+            "CSCAT": [
+                args_dict["core_scatter"][0],
+                args_dict["core_scatter"][1].to("cm").value,
+                0.0,
+            ],
+        }
 
-        # Converting AZM to CORSIKA reference (PHIP)
-        phip = 180.0 - self._user_parameters["AZM"][0]
-        phip = phip + 360.0 if phip < 0.0 else phip
-        phip = phip - 360.0 if phip >= 360.0 else phip
-        self._user_parameters["PHIP"] = [phip, phip]
+    def _corsika_configuration_interaction_flags(self, parameters_from_db):
+        """
+        Return CORSIKA interaction flags / parameters.
 
-        self._is_file_updated = False
+        Parameters
+        ----------
+        parameters_from_db : dict
+            CORSIKA parameters from the database.
 
-    def _validate_and_convert_argument(self, par_name, par_info, value_args_in):
+        Returns
+        -------
+        interaction_parameters : dict
+            Dictionary with CORSIKA interaction parameters.
         """
-        Validate input user parameter and convert it to the right units, if needed.
-        Returns the validated arguments in a list.
+        parameters = {}
+        parameters["FIXHEI"] = self._input_config_first_interaction_height(
+            parameters_from_db["corsika_first_interaction_height"]
+        )
+        parameters["FIXCHI"] = [
+            self._input_config_corsika_starting_grammage(
+                parameters_from_db["corsika_starting_grammage"]
+            )
+        ]
+        parameters["TSTART"] = ["T"]
+        parameters["ECUTS"] = self._input_config_corsika_particle_kinetic_energy_cutoff(
+            parameters_from_db["corsika_particle_kinetic_energy_cutoff"]
+        )
+        parameters["MUADDI"] = ["F"]
+        parameters["MUMULT"] = ["T"]
+        parameters["LONGI"] = self._input_config_corsika_longitudinal_parameters(
+            parameters_from_db["corsika_longitudinal_shower_development"]
+        )
+        parameters["MAXPRT"] = ["10"]
+        parameters["ECTMAP"] = ["1.e6"]
+
+        self._logger.debug(f"Interaction parameters: {parameters}")
+        return parameters
+
+    def _input_config_first_interaction_height(self, entry):
+        """Return FIXHEI parameter CORSIKA format."""
+        return [f"{entry['value']*u.Unit(entry['unit']).to('cm'):.2f}", "0"]
+
+    def _input_config_corsika_starting_grammage(self, entry):
+        """Return FIXCHI parameter CORSIKA format."""
+        return f"{entry['value']*u.Unit(entry['unit']).to('g/cm2')}"
+
+    def _input_config_corsika_particle_kinetic_energy_cutoff(self, entry):
+        """Return ECUTS parameter CORSIKA format."""
+        e_cuts = gen.convert_string_to_list(entry["value"])
+        return [
+            f"{e_cuts[0]*u.Unit(entry['unit']).to('GeV')} "
+            f"{e_cuts[1]*u.Unit(entry['unit']).to('GeV')} "
+            f"{e_cuts[2]*u.Unit(entry['unit']).to('GeV')} "
+            f"{e_cuts[3]*u.Unit(entry['unit']).to('GeV')}"
+        ]
+
+    def _input_config_corsika_longitudinal_parameters(self, entry):
+        """Return LONGI parameter CORSIKA format."""
+        return ["T", f"{entry['value']*u.Unit(entry['unit']).to('g/cm2')}", "F", "F"]
+
+    def _corsika_configuration_cherenkov_parameters(self, parameters_from_db):
         """
+        Return CORSIKA Cherenkov emission parameters.
 
-        # Turning value_args into a list, if it is not.
-        value_args = gen.copy_as_list(value_args_in)
-
-        if len(value_args) == 1 and par_name in ["THETAP", "AZM"]:
-            # Fixing single value zenith or azimuth angle.
-            # THETAP and AZM should be written as a 2 values range in the CORSIKA input file
-            value_args = value_args * 2
-        elif len(value_args) == 1 and par_name == "VIEWCONE":
-            # Fixing single value viewcone.
-            # VIEWCONE should be written as a 2 values range in the CORSIKA input file
-            value_args = [0 * par_info["unit"][0], value_args[0]]
-        elif par_name == "PRMPAR":
-            value_args = self._convert_primary_input_and_store_primary_name(value_args)
-        elif par_name == "ESLOPE":
-            self.eslope = value_args[0]
+        Parameters
+        ----------
+        parameters_from_db : dict
+            CORSIKA parameters from the database.
 
-        if len(value_args) != par_info["len"]:
-            msg = f"CORSIKA input entry with wrong len: {par_name}"
-            self._logger.error(msg)
-            raise InvalidCorsikaInput(msg)
+        Returns
+        -------
+        dict
+            Dictionary with CORSIKA Cherenkov emission parameters.
+        """
+        parameters = {}
+        parameters["CERSIZ"] = [parameters_from_db["corsika_cherenkov_photon_bunch_size"]["value"]]
+        parameters["CERFIL"] = "0"
+        parameters["CWAVLG"] = self._input_config_corsika_cherenkov_wavelength(
+            parameters_from_db["corsika_cherenkov_photon_wavelength_range"]
+        )
+        self._logger.debug(f"Cherenkov parameters: {parameters}")
+        return parameters
+
+    def _input_config_corsika_cherenkov_wavelength(self, entry):
+        """Return CWAVLG parameter CORSIKA format."""
+        wavelength_range = gen.convert_string_to_list(entry["value"])
+        return [
+            f"{wavelength_range[0]*u.Unit(entry['unit']).to('nm')}",
+            f"{wavelength_range[1]*u.Unit(entry['unit']).to('nm')}",
+        ]
+
+    def _corsika_configuration_iact_parameters(self, parameters_from_db):
+        """
+        Return CORSIKA IACT parameters.
 
-        if "unit" not in par_info.keys():
-            return value_args
+        Parameters
+        ----------
+        parameters_from_db : dict
+            CORSIKA parameters from the database.
 
-        # Turning par_info['unit'] into a list, if it is not.
-        par_unit = gen.copy_as_list(par_info["unit"])
+        Returns
+        -------
+        dict
+            Dictionary with CORSIKA IACT parameters.
+        """
+        parameters = {}
+        parameters["SPLIT_AUTO"] = [parameters_from_db["corsika_iact_split_auto"]["value"]]
+        parameters["IO_BUFFER"] = [
+            self._input_config_io_buff(parameters_from_db["corsika_iact_io_buffer"])
+        ]
+        parameters["MAX_BUNCHES"] = [parameters_from_db["corsika_iact_max_bunches"]["value"]]
+        self._logger.debug(f"IACT parameters: {parameters}")
+        return parameters
+
+    def _corsika_configuration_debugging_parameters(self):
+        """Return CORSIKA debugging output parameters."""
+        return {
+            "DEBUG": ["F", 6, "F", 1000000],
+            "DATBAS": ["yes"],
+            "DIRECT": ["/dev/null"],
+        }
 
-        # Checking units and converting them, if needed.
-        value_args_with_units = []
-        for arg, unit in zip(value_args, par_unit):
-            if unit is None:
-                value_args_with_units.append(arg)
-                continue
+    def _input_config_io_buff(self, entry):
+        """Return IO_BUFFER parameter CORSIKA format."""
+        return f"{entry['value']}{entry['unit']}"
 
-            if isinstance(arg, str):
-                arg = u.quantity.Quantity(arg)
+    def _rotate_azimuth_by_180deg(self, az, correct_for_geomagnetic_field_alignment=True):
+        """
+        Convert azimuth angle to the CORSIKA coordinate system.
 
-            if not isinstance(arg, u.quantity.Quantity):
-                msg = f"CORSIKA input given without unit: {par_name}"
-                self._logger.error(msg)
-                raise InvalidCorsikaInput(msg)
-            if not arg.unit.is_equivalent(unit):
-                msg = f"CORSIKA input given with wrong unit: {par_name}"
-                self._logger.error(msg)
-                raise InvalidCorsikaInput(msg)
+        Parameters
+        ----------
+        az: float
+            Azimuth angle in degrees.
+        correct_for_geomagnetic_field_alignment: bool
+            Whether to correct for the geomagnetic field alignment.
 
-            value_args_with_units.append(arg.to(unit).value)
+        Returns
+        -------
+        float
+            Azimuth angle in degrees in the CORSIKA coordinate system.
+        """
+        b_field_declination = 0
+        if correct_for_geomagnetic_field_alignment:
+            b_field_declination = self.array_model.site_model.get_parameter_value("geomag_rotation")
+        return (az + 180 + b_field_declination) % 360
 
-        return value_args_with_units
+    @property
+    def primary(self):
+        """Primary particle name."""
+        return self.primary_particle.name
 
-    def _convert_primary_input_and_store_primary_name(self, value):
+    def _set_primary_particle(self, args_dict):
         """
-        Convert a primary name into the proper CORSIKA particle ID and store its name in \
-        the self.primary attribute.
+        Set primary particle from input dictionary.
 
         Parameters
         ----------
-        value: str
-            Input primary name (e.g gamma, proton ...)
-
-        Raises
-        ------
-        InvalidPrimary
-            If the input name is not found.
+        args_dict: dict
+            Input dictionary.
 
         Returns
         -------
-        int
-            Respective number of the given primary.
+        PrimaryParticle
+            Primary particle.
+
         """
-        for prim_name, prim_info in self._corsika_parameters["PRIMARIES"].items():
-            if value[0].upper() == prim_name or value[0].upper() in prim_info["names"]:
-                self.primary = prim_name.lower()
-                return [prim_info["number"]]
-        msg = f"Primary not valid: {value}"
-        self._logger.error(msg)
-        raise InvalidCorsikaInput(msg)
+        if not args_dict or args_dict.get("primary_id_type") is None:
+            return PrimaryParticle()
+        return PrimaryParticle(
+            particle_id_type=args_dict.get("primary_id_type"), particle_id=args_dict.get("primary")
+        )
 
-    def get_user_parameter(self, par_name):
+    def get_config_parameter(self, par_name):
         """
-        Get the value of a user parameter.
+        Get value of CORSIKA configuration parameter.
 
         Parameters
         ----------
         par_name: str
-            Name of the parameter as used in the CORSIKA input file (e.g. PRMPAR, THETAP ...)
+            Name of the parameter as used in the CORSIKA input file (e.g. PRMPAR, THETAP ...).
 
         Raises
         ------
@@ -331,115 +387,130 @@ class CorsikaConfig:
         list
             Value(s) of the parameter.
         """
-        try:
-            par_value = self._user_parameters[par_name.upper()]
-        except KeyError:
-            self._logger.warning(f"Parameter {par_name} is not a user parameter")
-            raise
-
+        par_value = []
+        for _, values in self.config.items():
+            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
         return par_value if len(par_value) > 1 else par_value[0]
 
-    def print_user_parameters(self):
-        """Print user parameters for inspection."""
-        for par, value in self._user_parameters.items():
-            print(f"{par} = {value}")
+    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=""):
+        """
+        Return one parameter per line for each input parameter.
+
+        Parameters
+        ----------
+        pars: dict
+            Dictionary with the parameters to be written in the file.
+
+        Returns
+        -------
+        str
+            Text with the parameters.
+        """
+        text = ""
+        for par, values in pars.items():
+            line = line_begin + par + " "
+            for v in values:
+                line += str(v) + " "
+            line += "\n"
+            text += line
+        return text
 
-    def export_input_file(self, use_multipipe=False):
+    def generate_corsika_input_file(self, use_multipipe=False, use_test_seeds=False):
         """
-        Create and export CORSIKA input file.
+        Generate a CORSIKA input file.
 
         Parameters
         ----------
         use_multipipe: bool
             Whether to set the CORSIKA Inputs file to pipe
-            the output directly to sim_telarray or not.
-        """
+            the output directly to sim_telarray.
 
-        sub_dir = "corsika_simtel" if use_multipipe else "corsika"
-        self._set_output_file_and_directory(sub_dir)
-        self._logger.debug(f"Exporting CORSIKA input file to {self.config_file_path}")
-
-        def _get_text_single_line(pars):
-            text = ""
-            for par, values in pars.items():
-                line = par + " "
-                for v in values:
-                    line += str(v) + " "
-                line += "\n"
-                text += line
-            return text
-
-        def _get_text_multiple_lines(pars):
-            text = ""
-            for par, value_list in pars.items():
-                for value in value_list:
-                    new_pars = {par: value}
-                    text += _get_text_single_line(new_pars)
-            return text
+        """
+        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)
+        self._logger.info(f"Exporting CORSIKA input file to {self.config_file_path}")
 
         with open(self.config_file_path, "w", encoding="utf-8") as file:
             file.write("\n* [ RUN PARAMETERS ]\n")
-            # Removing AZM entry first
-            _user_pars_temp = copy.copy(self._user_parameters)
-            _user_pars_temp.pop("AZM")
-            text_parameters = _get_text_single_line(_user_pars_temp)
+            text_parameters = self._get_text_single_line(self.config["USER_INPUT"])
             file.write(text_parameters)
 
             file.write("\n* [ SITE PARAMETERS ]\n")
-            text_site_parameters = _get_text_single_line(
-                self._corsika_parameters["SITE_PARAMETERS"][self.site]
+            text_site_parameters = self._get_text_single_line(
+                self.array_model.site_model.get_corsika_site_parameters(
+                    config_file_style=True, model_directory=self.array_model.get_config_directory()
+                )
             )
             file.write(text_site_parameters)
 
-            # Defining the IACT variables for the output file name
-            file.write("\n")
-            file.write(f"IACT setenv PRMNAME {self.primary}\n")
-            file.write(f"IACT setenv ZA {int(self._user_parameters['THETAP'][0])}\n")
-            file.write(f"IACT setenv AZM {int(self._user_parameters['AZM'][0])}\n")
+            file.write("\n* [ IACT ENV PARAMETERS ]\n")
+            file.write(f"IACT setenv PRMNAME {self.primary_particle.name}\n")
+            file.write(f"IACT setenv ZA {int(self.get_config_parameter('THETAP')[0])}\n")
+            file.write(f"IACT setenv AZM {self.azimuth_angle}\n")
 
             file.write("\n* [ SEEDS ]\n")
-            self._write_seeds(file)
+            self._write_seeds(file, use_test_seeds)
 
             file.write("\n* [ TELESCOPES ]\n")
-            telescope_list_text = self.layout.get_corsika_input_list()
+            telescope_list_text = self.get_corsika_telescope_list()
             file.write(telescope_list_text)
 
             file.write("\n* [ INTERACTION FLAGS ]\n")
-            text_interaction_flags = _get_text_single_line(
-                self._corsika_parameters["INTERACTION_FLAGS"]
-            )
+            text_interaction_flags = self._get_text_single_line(self.config["INTERACTION_FLAGS"])
             file.write(text_interaction_flags)
 
             file.write("\n* [ CHERENKOV EMISSION PARAMETERS ]\n")
-            text_cherenkov = _get_text_single_line(
-                self._corsika_parameters["CHERENKOV_EMISSION_PARAMETERS"]
+            text_cherenkov = self._get_text_single_line(
+                self.config["CHERENKOV_EMISSION_PARAMETERS"]
             )
             file.write(text_cherenkov)
 
             file.write("\n* [ DEBUGGING OUTPUT PARAMETERS ]\n")
-            text_debugging = _get_text_single_line(
-                self._corsika_parameters["DEBUGGING_OUTPUT_PARAMETERS"]
-            )
+            text_debugging = self._get_text_single_line(self.config["DEBUGGING_OUTPUT_PARAMETERS"])
             file.write(text_debugging)
 
-            file.write("\n* [ OUTUPUT FILE ]\n")
+            file.write("\n* [ OUTPUT FILE ]\n")
             if use_multipipe:
                 run_cta_script = Path(self.config_file_path.parent).joinpath("run_cta_multipipe")
-                file.write(f"TELFIL |{str(run_cta_script)}\n")
+                file.write(f"TELFIL |{run_cta_script!s}\n")
             else:
-                file.write(f"TELFIL {self._output_generic_file_name}\n")
+                file.write(f"TELFIL {_output_generic_file_name}\n")
 
             file.write("\n* [ IACT TUNING PARAMETERS ]\n")
-            text_iact = _get_text_multiple_lines(self._corsika_parameters["IACT_TUNING_PARAMETERS"])
+            text_iact = self._get_text_single_line(
+                self.config["IACT_PARAMETERS"],
+                "IACT ",
+            )
             file.write(text_iact)
-
             file.write("\nEXIT")
 
+        # Write out the atmospheric transmission file to the model directory.
+        # This is done explicitly because it is not done "automatically" when CORSIKA is not piped
+        # to sim_telarray.
+        self.array_model.site_model.export_atmospheric_transmission_file(
+            model_directory=self.array_model.get_config_directory()
+        )
+
         self._is_file_updated = True
+        return self.config_file_path
 
-    def get_file_name(self, file_type, run_number=None):
+    def get_corsika_config_file_name(self, file_type, run_number=None):
         """
-        Get a CORSIKA config style file name for various file types.
+        Get a CORSIKA config style file name for various configuration file types.
 
         Parameters
         ----------
@@ -453,65 +524,77 @@ class CorsikaConfig:
         -------
         str
             for file_type="config_tmp":
-                Get the CORSIKA input file for one specific run.
+                Return CORSIKA input file name for one specific run.
                 This is the input file after being pre-processed by sim_telarray (pfp).
             for file_type="config":
-                Get a general CORSIKA config inputs file.
+                Return generic CORSIKA config input file name.
             for file_type="output_generic"
-                Get a generic file name for the TELFIL option in the CORSIKA inputs file.
+                Return generic file name for the TELFIL option in the CORSIKA inputs file.
             for file_type="multipipe"
-                Get a multipipe "file name" for the TELFIL option in the CORSIKA inputs file.
+                Return multipipe "file name" for the TELFIL option in the CORSIKA inputs file.
 
         Raises
         ------
         ValueError
             If file_type is unknown or if the run number is not given for file_type==config_tmp.
         """
-
         file_label = f"_{self.label}" if self.label is not None else ""
-        view_cone = ""
-        if self._user_parameters["VIEWCONE"][0] != 0 or self._user_parameters["VIEWCONE"][1] != 0:
-            view_cone = (
-                f"_cone{int(self._user_parameters['VIEWCONE'][0]):d}-"
-                f"{int(self._user_parameters['VIEWCONE'][1]):d}"
-            )
-        file_name = (
-            f"{self.primary}_{self.site}_{self.layout_name}_"
-            f"za{int(self._user_parameters['THETAP'][0]):03}-"
-            f"azm{int(self._user_parameters['AZM'][0]):03}deg"
+
+        _vc_low = self.get_config_parameter("VIEWCONE")[0]
+        _vc_high = self.get_config_parameter("VIEWCONE")[1]
+        view_cone = (
+            f"_cone{int(_vc_low):d}-{int(_vc_high):d}" if _vc_low != 0 or _vc_high != 0 else ""
+        )
+
+        base_name = (
+            f"{self.primary_particle.name}_{self.array_model.site}_{self.array_model.layout_name}_"
+            f"za{int(self.get_config_parameter('THETAP')[0]):03}-"
+            f"azm{self.azimuth_angle:03}deg"
             f"{view_cone}{file_label}"
         )
 
         if file_type == "config_tmp":
-            if run_number is not None:
-                return f"corsika_config_run{run_number:06}_{file_name}.txt"
-            raise ValueError("Must provide a run number for a temporary CORSIKA config file")
+            if run_number is None:
+                raise ValueError("Must provide a run number for a temporary CORSIKA config file")
+            return f"corsika_config_run{run_number:06}_{base_name}.txt"
         if file_type == "config":
-            return f"corsika_config_{file_name}.input"
+            return f"corsika_config_{base_name}.input"
         if file_type == "output_generic":
             # The XXXXXX will be replaced by the run number after the pfp step with sed
-            file_name = (
-                f"corsika_runXXXXXX_"
-                f"{self.primary}_za{int(self._user_parameters['THETAP'][0]):03}deg_"
-                f"azm{int(self._user_parameters['AZM'][0]):03}deg"
-                f"_{self.site}_{self.layout_name}{file_label}.zst"
+            return (
+                f"runXXXXXX_{base_name}_{self.array_model.site}_"
+                f"{self.array_model.layout_name}{file_label}.zst"
             )
-            return file_name
         if file_type == "multipipe":
-            return f"multi_cta-{self.site}-{self.layout_name}.cfg"
+            return f"multi_cta-{self.array_model.site}-{self.array_model.layout_name}.cfg"
 
         raise ValueError(f"The requested file type ({file_type}) is unknown")
 
-    def _set_output_file_and_directory(self, sub_dir="corsika"):
-        config_file_name = self.get_file_name(file_type="config")
+    def set_output_file_and_directory(self, use_multipipe=False):
+        """
+        Set output file names and directories.
+
+        Parameters
+        ----------
+        use_multipipe: bool
+            Whether to set the CORSIKA Inputs file to pipe
+            the output directly to sim_telarray. Defines directory names.
+
+        Returns
+        -------
+        str
+            Output file name.
+        """
+        sub_dir = "corsika_simtel" if use_multipipe else "corsika"
+        config_file_name = self.get_corsika_config_file_name(file_type="config")
         file_directory = self.io_handler.get_output_directory(label=self.label, sub_dir=sub_dir)
-        self._logger.info(f"Creating directory {file_directory}, if needed.")
+        self._logger.debug(f"Creating directory {file_directory}")
         file_directory.mkdir(parents=True, exist_ok=True)
         self.config_file_path = file_directory.joinpath(config_file_name)
 
-        self._output_generic_file_name = self.get_file_name(file_type="output_generic")
+        return self.get_corsika_config_file_name(file_type="output_generic")
 
-    def _write_seeds(self, file):
+    def _write_seeds(self, file, use_test_seeds=False):
         """
         Generate and write seeds in the CORSIKA input file.
 
@@ -520,22 +603,79 @@ class CorsikaConfig:
         file: stream
             File where the telescope positions will be written.
         """
-        random_seed = self._user_parameters["PRMPAR"][0] + self._user_parameters["RUNNR"][0]
+        random_seed = self.get_config_parameter("PRMPAR") + self.run_number
         rng = np.random.default_rng(random_seed)
-        corsika_seeds = [int(rng.uniform(0, 1e7)) for i in range(4)]
-
+        corsika_seeds = [534, 220, 1104, 382]
+        if not use_test_seeds:
+            corsika_seeds = [int(rng.uniform(0, 1e7)) for _ in range(4)]
         for s in corsika_seeds:
             file.write(f"SEED {s} 0 0\n")
 
-    def get_input_file(self, use_multipipe=False):
+    def get_corsika_telescope_list(self):
         """
-        Get the full path of the CORSIKA input file.
+        List of telescope positions in the format required for the CORSIKA input file.
 
         Returns
         -------
-        Path:
-            Full path of the CORSIKA input file.
+        str
+            Piece of text to be added to the CORSIKA input file.
         """
-        if not self._is_file_updated:
-            self.export_input_file(use_multipipe)
-        return self.config_file_path
+        corsika_input_list = ""
+        for telescope_name, telescope in self.array_model.telescope_model.items():
+            positions = telescope.get_parameter_value_with_unit("array_element_position_ground")
+            corsika_input_list += "TELESCOPE"
+            for pos in positions:
+                corsika_input_list += f"\t {pos.to('cm').value:.3f}"
+            sphere_radius = telescope.get_parameter_value_with_unit("telescope_sphere_radius").to(
+                "cm"
+            )
+            corsika_input_list += f"\t {sphere_radius:.3f}"
+            corsika_input_list += f"\t # {telescope_name}\n"
+
+        return corsika_input_list
+
+    @property
+    def run_number(self):
+        """Set run number."""
+        return self._run_number
+
+    @run_number.setter
+    def run_number(self, run_number):
+        """
+        Set run number and validate it.
+
+        Parameters
+        ----------
+        run_number: int
+            Run number.
+        """
+        self._run_number = self.validate_run_number(run_number)
+
+    def validate_run_number(self, run_number):
+        """
+        Validate run number and return it.
+
+        Return run number from configuration if None.
+
+        Parameters
+        ----------
+        run_number: int
+            Run number.
+
+        Returns
+        -------
+        int
+            Run number.
+
+        Raises
+        ------
+        ValueError
+            If run_number is not a valid value (e.g., < 1).
+        """
+        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)
+        return run_number