gammasimtools 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

simtools/applications/validate_file_using_schema.py

@@ -36,12 +36,10 @@ import logging
 import re
 from pathlib import Path
 
-import jsonschema
-
 import simtools.utils.general as gen
 from simtools.configuration import configurator
 from simtools.constants import MODEL_PARAMETER_SCHEMA_PATH
-from simtools.data_model import metadata_collector, metadata_model, validate_data
+from simtools.data_model import metadata_collector, schema, validate_data
 
 
 def _parse(label, description):
@@ -116,7 +114,20 @@ def _get_schema_file_name(args_dict, data_dict=None):
     return schema_file
 
 
-def validate_schema(args_dict, logger):
+def _get_json_file_list(file_directory=None, file_name=None):
+    """Return list of json files in a directory."""
+    file_list = []
+    if file_directory is not None:
+        file_list = list(Path(file_directory).rglob("*.json"))
+        if not file_list:
+            raise FileNotFoundError(f"No files found in {file_directory}")
+    elif file_name is not None:
+        file_list = [file_name]
+
+    return file_list
+
+
+def validate_dict_using_schema(args_dict, logger):
     """
     Validate a schema file (or several files) given in yaml or json format.
 
@@ -124,33 +135,26 @@ def validate_schema(args_dict, logger):
     the metadata section of the data dictionary.
 
     """
-    if args_dict.get("file_directory") is not None:
-        file_list = list(Path(args_dict["file_directory"]).rglob("*.json"))
-    else:
-        file_list = [args_dict["file_name"]]
-    for file_name in file_list:
+    for file_name in _get_json_file_list(
+        args_dict.get("file_directory"), args_dict.get("file_name")
+    ):
         try:
             data = gen.collect_data_from_file(file_name=file_name)
         except FileNotFoundError as exc:
             logger.error(f"Error reading schema file from {file_name}")
             raise exc
-        try:
-            metadata_model.validate_schema(data, _get_schema_file_name(args_dict, data))
-        except jsonschema.exceptions.ValidationError as exc:
-            logger.error(f"Failed validation of file {file_name}")
-            raise exc
+        schema.validate_dict_using_schema(data, _get_schema_file_name(args_dict, data))
         logger.info(f"Successful validation of file {file_name}")
 
 
 def validate_data_files(args_dict, logger):
     """Validate data files."""
-    file_directory = args_dict.get("file_directory")
-    if file_directory is not None:
+    if args_dict.get("file_directory") is not None:
         tmp_args_dict = {}
-        for file_name in Path(file_directory).rglob("*.json"):
+        for file_name in _get_json_file_list(args_dict.get("file_directory")):
             tmp_args_dict["file_name"] = file_name
             parameter_name = re.sub(r"-\d+\.\d+\.\d+", "", file_name.stem)
-            schema_file = MODEL_PARAMETER_SCHEMA_PATH / f"{parameter_name}.schema.yml"
+            schema_file = schema.get_model_parameter_schema_file(f"{parameter_name}")
             tmp_args_dict["schema"] = schema_file
             tmp_args_dict["data_type"] = "model_parameter"
             tmp_args_dict["require_exact_data_type"] = args_dict["require_exact_data_type"]
@@ -166,9 +170,9 @@ def validate_data_file(args_dict, logger):
         data_file=args_dict["file_name"],
         check_exact_data_type=args_dict["require_exact_data_type"],
     )
-    data_validator.validate_and_transform(is_model_parameter=True)
-    if args_dict["data_type"].lower() == "model_parameter":
-        data_validator.validate_parameter_and_file_name()
+    data_validator.validate_and_transform(
+        is_model_parameter=(args_dict["data_type"].lower() == "model_parameter")
+    )
 
     logger.info(f"Successful validation of data file {args_dict['file_name']}")
 
@@ -192,7 +196,7 @@ def main():  # noqa: D103
     if args_dict["data_type"].lower() == "metadata":
         validate_metadata(args_dict, logger)
     elif args_dict["data_type"].lower() == "schema":
-        validate_schema(args_dict, logger)
+        validate_dict_using_schema(args_dict, logger)
     else:
         validate_data_files(args_dict, logger)
 

simtools/camera/single_photon_electron_spectrum.py

@@ -0,0 +1,168 @@
+"""Single photon electron spectral analysis."""
+
+import logging
+import re
+import subprocess
+import tempfile
+from io import BytesIO
+from pathlib import Path
+
+from astropy.table import Table
+
+import simtools.data_model.model_data_writer as writer
+from simtools.constants import SCHEMA_PATH
+from simtools.data_model import validate_data
+from simtools.data_model.metadata_collector import MetadataCollector
+from simtools.io_operations import io_handler
+
+
+class SinglePhotonElectronSpectrum:
+    """
+    Single photon electron spectral analysis.
+
+    Parameters
+    ----------
+    args_dict: dict
+        Dictionary with input arguments.
+    """
+
+    prompt_column = "frequency (prompt)"
+    prompt_plus_afterpulse_column = "frequency (prompt+afterpulsing)"
+    afterpulse_column = "frequency (afterpulsing)"
+
+    input_schema = SCHEMA_PATH / "input" / "single_pe_spectrum.schema.yml"
+
+    def __init__(self, args_dict):
+        """Initialize SinglePhotonElectronSpectrum class."""
+        self._logger = logging.getLogger(__name__)
+        self._logger.debug("Initialize SinglePhotonElectronSpectrum class.")
+
+        self.args_dict = args_dict
+        # default output is of ecsv format
+        self.args_dict["output_file"] = str(
+            Path(self.args_dict["output_file"]).with_suffix(".ecsv")
+        )
+        self.io_handler = io_handler.IOHandler()
+        self.data = ""  # Single photon electron spectrum data (as string)
+        self.metadata = MetadataCollector(args_dict=self.args_dict)
+
+    def derive_single_pe_spectrum(self):
+        """Derive single photon electron spectrum."""
+        if self.args_dict.get("use_norm_spe"):
+            return self._derive_spectrum_norm_spe()
+
+        raise NotImplementedError(
+            "Derivation of single photon electron spectrum using a simtool is not yet implemented."
+        )
+
+    def write_single_pe_spectrum(self):
+        """
+        Write single photon electron spectrum plus metadata to disk.
+
+        Includes writing in simtel and simtools (ecsv) formats.
+
+        """
+        simtel_file = self.io_handler.get_output_directory() / Path(
+            self.args_dict["output_file"]
+        ).with_suffix(".dat")
+        self._logger.debug(f"norm_spe output file: {simtel_file}")
+        with open(simtel_file, "w", encoding="utf-8") as simtel:
+            simtel.write(self.data)
+
+        cleaned_data = re.sub(r"%%%.+", "", self.data)  # remove norm_spe row metadata
+        table = Table.read(
+            BytesIO(cleaned_data.encode("utf-8")),
+            format="ascii.no_header",
+            comment="#",
+            delimiter="\t",
+        )
+        table.rename_columns(
+            ["col1", "col2", "col3"],
+            ["amplitude", self.prompt_column, self.prompt_plus_afterpulse_column],
+        )
+
+        writer.ModelDataWriter.dump(
+            args_dict=self.args_dict,
+            metadata=self.metadata.top_level_meta,
+            product_data=table,
+            validate_schema_file=None,
+        )
+
+    def _derive_spectrum_norm_spe(self):
+        """
+        Derive single photon electron spectrum using sim_telarray tool 'norm_spe'.
+
+        Returns
+        -------
+        int
+            Return code of the executed command
+
+        Raises
+        ------
+        subprocess.CalledProcessError
+            If the command execution fails.
+        """
+        tmp_input_file = self._get_input_data(
+            input_file=self.args_dict["input_spectrum"],
+            frequency_column=self.prompt_column,
+        )
+        tmp_ap_file = self._get_input_data(
+            input_file=self.args_dict.get("afterpulse_spectrum"),
+            frequency_column=self.afterpulse_column,
+        )
+
+        command = [
+            f"{self.args_dict['simtel_path']}/sim_telarray/bin/norm_spe",
+            "-r",
+            f"{self.args_dict['step_size']},{self.args_dict['max_amplitude']}",
+            tmp_input_file.name,
+        ]
+        if tmp_ap_file:
+            command.insert(1, "-a")
+            command.insert(2, f"{tmp_ap_file.name}")
+
+        self._logger.debug(f"Running norm_spe command: {' '.join(command)}")
+        try:
+            result = subprocess.run(command, capture_output=True, text=True, check=True)
+        except subprocess.CalledProcessError as exc:
+            self._logger.error(f"Error running norm_spe: {exc}")
+            self._logger.error(f"stderr: {exc.stderr}")
+            raise exc
+        finally:
+            for tmp_file in [tmp_input_file, tmp_ap_file]:
+                try:
+                    Path(tmp_file.name).unlink()
+                except (AttributeError, FileNotFoundError):
+                    pass
+
+        self.data = result.stdout
+        return result.returncode
+
+    def _get_input_data(self, input_file, frequency_column):
+        """
+        Return input data for norm_spe command.
+
+        Input data need to be space separated values of the amplitude spectrum.
+        """
+        input_data = ""
+        if not input_file:
+            return None
+        input_file = Path(input_file)
+
+        if input_file.suffix == ".ecsv":
+            data_validator = validate_data.DataValidator(
+                schema_file=self.input_schema, data_file=input_file
+            )
+            table = data_validator.validate_and_transform()
+            input_data = "\n".join(f"{row['amplitude']} {row[frequency_column]}" for row in table)
+        else:
+            with open(input_file, encoding="utf-8") as f:
+                input_data = (
+                    f.read().replace(",", " ")
+                    if frequency_column == self.prompt_column
+                    else f.read()
+                )
+
+        with tempfile.NamedTemporaryFile(delete=False, mode="w", encoding="utf-8") as tmpfile:
+            tmpfile.write(input_data)
+        return tmpfile

simtools/configuration/commandline_parser.py

@@ -70,6 +70,7 @@ class CommandLineParser(argparse.ArgumentParser):
             self.initialize_output_arguments()
         self.initialize_config_files()
         self.initialize_application_execution_arguments()
+        self.initialize_user_arguments()
 
     def initialize_config_files(self):
         """Initialize configuration files."""
@@ -175,6 +176,34 @@ class CommandLineParser(argparse.ArgumentParser):
             "--version", action="version", version=f"%(prog)s {simtools.version.__version__}"
         )
 
+    def initialize_user_arguments(self):
+        """Initialize user arguments."""
+        _job_group = self.add_argument_group("user")
+        _job_group.add_argument(
+            "--user_name",
+            help="user name",
+            type=str,
+            required=False,
+        )
+        _job_group.add_argument(
+            "--user_organization",
+            help="user organization",
+            type=str,
+            required=False,
+        )
+        _job_group.add_argument(
+            "--user_email",
+            help="user email",
+            type=str,
+            required=False,
+        )
+        _job_group.add_argument(
+            "--user_orcid",
+            help="user ORCID",
+            type=str,
+            required=False,
+        )
+
     def initialize_db_config_arguments(self):
         """Initialize DB configuration parameters."""
         _job_group = self.add_argument_group("database configuration")
@@ -239,7 +268,14 @@ class CommandLineParser(argparse.ArgumentParser):
         if "model_version" in model_options:
             _job_group.add_argument(
                 "--model_version",
-                help="model version",
+                help="production model version",
+                type=str,
+                default=None,
+            )
+        if "parameter_version" in model_options:
+            _job_group.add_argument(
+                "--parameter_version",
+                help="model parameter version",
                 type=str,
                 default=None,
             )

simtools/configuration/configurator.py

@@ -287,16 +287,14 @@ class Configurator:
             )
             # yaml parser adds \n in multiline strings, remove them
             _config_dict = gen.remove_substring_recursively_from_dict(_config_dict, substring="\n")
-            if "CTA_SIMPIPE" in _config_dict:
-                try:
-                    self._fill_from_config_dict(
-                        input_dict=gen.change_dict_keys_case(
-                            _config_dict["CTA_SIMPIPE"]["CONFIGURATION"],
-                        ),
-                        overwrite=True,
-                    )
-                except KeyError:
-                    self._logger.info(f"No CTA_SIMPIPE:CONFIGURATION dict found in {config_file}.")
+            # read configuration for first application
+            if "CONFIGURATION" in _config_dict.get("CTA_SIMPIPE", {}).get("APPLICATIONS", [{}])[0]:
+                self._fill_from_config_dict(
+                    input_dict=gen.change_dict_keys_case(
+                        _config_dict["CTA_SIMPIPE"]["APPLICATIONS"][0]["CONFIGURATION"],
+                    ),
+                    overwrite=True,
+                )
             else:
                 self._fill_from_config_dict(
                     input_dict=gen.change_dict_keys_case(_config_dict), overwrite=True

simtools/constants.py

@@ -2,8 +2,15 @@
 
 from importlib.resources import files
 
+# Schema path
+SCHEMA_PATH = files("simtools") / "schemas"
 # Path to metadata jsonschema
-METADATA_JSON_SCHEMA = files("simtools") / "schemas/metadata.metaschema.yml"
-
+METADATA_JSON_SCHEMA = SCHEMA_PATH / "metadata.metaschema.yml"
+# Path to model parameter metaschema
+MODEL_PARAMETER_METASCHEMA = SCHEMA_PATH / "model_parameter.metaschema.yml"
+# Path to model parameter description metaschema
+MODEL_PARAMETER_DESCRIPTION_METASCHEMA = (
+    SCHEMA_PATH / "model_parameter_and_data_schema.metaschema.yml"
+)
 # Path to model parameter schema files
-MODEL_PARAMETER_SCHEMA_PATH = files("simtools") / "schemas/model_parameters"
+MODEL_PARAMETER_SCHEMA_PATH = SCHEMA_PATH / "model_parameters"

simtools/corsika/corsika_config.py

@@ -6,7 +6,6 @@ from pathlib import Path
 import numpy as np
 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.model.model_parameter import ModelParameter
@@ -111,8 +110,6 @@ class CorsikaConfig:
         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
@@ -235,25 +232,25 @@ class CorsikaConfig:
 
     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"]
+        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')}"
+        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"])
+        e_cuts = 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')}"
+            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"]
+        return ["T", f"{entry['value'] * u.Unit(entry['unit']).to('g/cm2')}", "F", "F"]
 
     def _corsika_configuration_cherenkov_parameters(self, parameters_from_db):
         """
@@ -280,10 +277,10 @@ class CorsikaConfig:
 
     def _input_config_corsika_cherenkov_wavelength(self, entry):
         """Return CWAVLG parameter CORSIKA format."""
-        wavelength_range = gen.convert_string_to_list(entry["value"])
+        wavelength_range = entry["value"]
         return [
-            f"{wavelength_range[0]*u.Unit(entry['unit']).to('nm')}",
-            f"{wavelength_range[1]*u.Unit(entry['unit']).to('nm')}",
+            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):
@@ -314,12 +311,17 @@ class CorsikaConfig:
         return {
             "DEBUG": ["F", 6, "F", 1000000],
             "DATBAS": ["yes"],
-            "DIRECT": ["/dev/null"],
+            "DIRECT": ["./"],
+            "PAROUT": ["F", "F"],
         }
 
     def _input_config_io_buff(self, entry):
-        """Return IO_BUFFER parameter CORSIKA format."""
-        return f"{entry['value']}{entry['unit']}"
+        """Return IO_BUFFER parameter CORSIKA format (Byte or MB required)."""
+        value = entry["value"] * u.Unit(entry["unit"]).to("Mbyte")
+        # check if value is integer-like
+        if value.is_integer():
+            return f"{int(value)}MB"
+        return f"{int(entry['value'] * u.Unit(entry['unit']).to('byte'))}"
 
     def _rotate_azimuth_by_180deg(self, az, correct_for_geomagnetic_field_alignment=True):
         """

simtools/corsika/corsika_histograms.py

@@ -678,7 +678,7 @@ class CorsikaHistograms:
         ----------
         new_individual_telescopes: bool
             if False, the histograms are supposed to be filled for all telescopes.
-            if True, one histogram is set for each telescope sepparately.
+            if True, one histogram is set for each telescope separately.
         """
         if new_individual_telescopes is None:
             self._individual_telescopes = False
@@ -944,10 +944,10 @@ class CorsikaHistograms:
 
         hist_2d_values_list, x_position_list, y_position_list = self.get_2d_photon_position_distr()
 
-        for i_hist, _ in enumerate(x_position_list):
+        for i_hist, x_pos in enumerate(x_position_list):
             hist_1d, bin_edges_1d = convert_2d_to_radial_distr(
                 hist_2d_values_list[i_hist],
-                x_position_list[i_hist],  # pylint: disable=unnecessary-list-index-lookup
+                x_pos,
                 y_position_list[i_hist],
                 bins=bins,
                 max_dist=max_dist,
@@ -1248,8 +1248,7 @@ class CorsikaHistograms:
                     meta_data=self._meta_dict,
                 )
                 self._logger.info(
-                    f"Writing 1D histogram with name {hdf5_table_name} to "
-                    f"{self.hdf5_file_name}."
+                    f"Writing 1D histogram with name {hdf5_table_name} to {self.hdf5_file_name}."
                 )
                 # overwrite takes precedence over append
                 if overwrite is True:
@@ -1382,8 +1381,7 @@ class CorsikaHistograms:
                 )
 
                 self._logger.info(
-                    f"Writing 2D histogram with name {hdf5_table_name} to "
-                    f"{self.hdf5_file_name}."
+                    f"Writing 2D histogram with name {hdf5_table_name} to {self.hdf5_file_name}."
                 )
                 # Always appending to table due to the file previously created
                 # by self._export_1d_histograms.

simtools/corsika/corsika_histograms_visualize.py

@@ -93,8 +93,7 @@ def _kernel_plot_2d_photons(histograms_instance, property_name, log_z=False):
         all_figs.append(fig)
         if histograms_instance.individual_telescopes is False:
             ax.set_title(
-                f"{histograms_instance.dict_2d_distributions[property_name]['file name']}"
-                "_all_tels"
+                f"{histograms_instance.dict_2d_distributions[property_name]['file name']}_all_tels"
             )
         else:
             ax.text(
@@ -285,8 +284,7 @@ def _kernel_plot_1d_photons(histograms_instance, property_name, log_y=True):
             ax.set_yscale("log")
         if histograms_instance.individual_telescopes is False:
             ax.set_title(
-                f"{histograms_instance.dict_1d_distributions[property_name]['file name']}"
-                "_all_tels"
+                f"{histograms_instance.dict_1d_distributions[property_name]['file name']}_all_tels"
             )
         else:
             ax.set_title(

simtools/data_model/data_reader.py

@@ -112,9 +112,6 @@ def read_value_from_file(file_name, schema_file=None, validate=False):
     _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()

simtools/data_model/metadata_collector.py

@@ -6,17 +6,16 @@ implementation of the observatory metadata model.
 
 """
 
-import datetime
 import getpass
 import logging
 import uuid
-from importlib.resources import files
 from pathlib import Path
 
 import simtools.constants
 import simtools.utils.general as gen
 import simtools.version
-from simtools.data_model import metadata_model
+from simtools.constants import METADATA_JSON_SCHEMA
+from simtools.data_model import metadata_model, schema
 from simtools.io_operations import io_handler
 from simtools.utils import names
 
@@ -97,9 +96,9 @@ class MetadataCollector:
 
         """
         try:
-            self.top_level_meta[self.observatory]["activity"][
-                "end"
-            ] = datetime.datetime.now().isoformat(timespec="seconds")
+            self.top_level_meta[self.observatory]["activity"]["end"] = (
+                gen.now_date_time_in_isoformat()
+            )
         except KeyError:
             pass
         return self.top_level_meta
@@ -135,7 +134,7 @@ class MetadataCollector:
         # from data model name
         if self.data_model_name:
             self._logger.debug(f"Schema file from data model name: {self.data_model_name}")
-            return f"{files('simtools')}/schemas/model_parameters/{self.data_model_name}.schema.yml"
+            return str(schema.get_model_parameter_schema_file(self.data_model_name))
 
         # from input metadata
         try:
@@ -200,8 +199,17 @@ class MetadataCollector:
         contact_dict: dict
             Dictionary for contact metadata fields.
         """
-        if contact_dict.get("name", None) is None:
+        contact_dict["name"] = contact_dict.get("name") or self.args_dict.get("user_name")
+        if contact_dict["name"] is None:
+            self._logger.warning("No user name provided, take user info from system level.")
             contact_dict["name"] = getpass.getuser()
+        meta_dict = {
+            "email": "user_mail",
+            "orcid": "user_orcid",
+            "organization": "user_organization",
+        }
+        for key, value in meta_dict.items():
+            contact_dict[key] = contact_dict.get(key) or self.args_dict.get(value)
 
     def _fill_context_meta(self, context_dict):
         """
@@ -267,7 +275,7 @@ class MetadataCollector:
             self._logger.error("Unknown metadata file format: %s", metadata_file_name)
             raise gen.InvalidConfigDataError
 
-        metadata_model.validate_schema(_input_metadata, None)
+        schema.validate_dict_using_schema(_input_metadata, schema_file=METADATA_JSON_SCHEMA)
 
         return gen.change_dict_keys_case(
             self._process_metadata_from_file(_input_metadata),
@@ -327,7 +335,7 @@ class MetadataCollector:
         self.schema_dict = self.get_data_model_schema_dict()
 
         product_dict["id"] = str(uuid.uuid4())
-        product_dict["creation_time"] = datetime.datetime.now().isoformat(timespec="seconds")
+        product_dict["creation_time"] = gen.now_date_time_in_isoformat()
         product_dict["description"] = self.schema_dict.get("description", None)
 
         # DATA:CATEGORY
@@ -367,7 +375,7 @@ class MetadataCollector:
         )
         if instrument_dict["ID"]:
             instrument_dict["class"] = names.get_collection_name_from_array_element_name(
-                instrument_dict["ID"]
+                instrument_dict["ID"], False
             )
 
     def _fill_process_meta(self, process_dict):
@@ -395,7 +403,7 @@ class MetadataCollector:
         activity_dict["name"] = self.args_dict.get("label", None)
         activity_dict["type"] = "software"
         activity_dict["id"] = self.args_dict.get("activity_id", "UNDEFINED_ACTIVITY_ID")
-        activity_dict["start"] = datetime.datetime.now().isoformat(timespec="seconds")
+        activity_dict["start"] = gen.now_date_time_in_isoformat()
         activity_dict["end"] = activity_dict["start"]
         activity_dict["software"]["name"] = "simtools"
         activity_dict["software"]["version"] = simtools.version.__version__