cgse 2024.7.0__py3-none-any.whl → 2025.0.2__py3-none-any.whl

scripts/sron/correct_trp_swap_brigand.py

@@ -1,204 +0,0 @@
-import os
-import shutil
-from datetime import datetime
-
-import pandas as pd
-from pandas.core.frame import DataFrame
-
-from egse.config import find_file
-from egse.fee.n_fee_hk import counts_to_temperature, ORIGIN
-from egse.obsid import obsid_from_storage
-from egse.setup import load_setup, NavigableDict, Setup
-from dateutil.rrule import rrule, DAILY
-
-
-def correct_brigand(data_dir: str = None):
-    """ PLATO-SRON-PL-NCR-0052: FM1 TRP swap in EGSE telemetry dictionary maps sub-phase 2a.
-
-    During the Brigand test campaign, the TRP8 and TRP10 temperature sensors of the N-FEE were swapped in the TM
-    dictionary.  As a result, the columns with their raw values have been swapped in the N-FEE HK file and the
-    calibration is applied incorrectly (i.e. the TRP8 calibration has been applied to the raw TRP10 value, and vice
-    versa).
-
-    For all N-FEE HK files of the Brigand test campaign (obsid 308 - 829 / OD 20230629 - 20230918), this functions does
-    the following:
-
-        * Make a copy of the original N-FEE HK files (incl. "old" in their filename)
-        * In the original files:
-            - Swap the column names for the raw values for those two TRPs
-            - Apply the calibration for those two columns
-
-    These changes will be applied to the relevant folders in the /obs and /daily sub-folder of the given data folder.
-
-    Args:
-        - data_dir: Full path to the directory in which the data resides.  This is the folder with sub-folders /obs and
-                    /daily, in which the N-FEE HK files are stored.  Default is the content of the
-                    PLATO_DATA_STORAGE_LOCATION environment variable.
-    """
-
-    data_dir = data_dir or os.environ["PLATO_DATA_STORAGE_LOCATION"]
-
-    setup = load_setup(setup_id=130, site_id="SRON", from_disk=True)
-    sensor_info = setup.camera.fee.calibration.temperatures.TOU_TRP_PT1000
-
-    # Correct /obs folder
-
-    correct_obsid_range(308, 382, sensor_info, "brigand", data_dir, setup)
-    correct_obsid_range(383, 391, sensor_info, "arthureddington", data_dir, setup)
-    correct_obsid_range(392, 688, sensor_info, "brigand", data_dir, setup)
-
-    # Correct /daily folder
-
-    correct_od_range(20230629, 20230802, sensor_info, data_dir, setup)
-
-
-def correct_obsid_range(first_obsid: int, last_obsid: int, sensor_info: NavigableDict, camera_name: str, data_dir: str,
-                        setup: Setup):
-    """
-     Correct for the swap between TRP8 and TRP10 in the N-FEE HK file for the obsid range.
-
-     This function does the following:
-
-        * Make a copy of the original N-FEE HK files (incl. "old" in the filename)
-        * In the original files:
-            - Swap the column names for the raw values for those two TRPs
-            - Apply the calibration for those two columns
-
-     Args:
-         - first_obsid: First obsid.
-         - last_obsid: Last obsid.
-         - sensor_info: Calibration information for the TOU_TRP_PT1000 sensor type.
-         - data_dir: Full path to the directory in which the data resides.  This is the folder with sub-folders /obs and
-                    /daily, in which the N-FEE HK files are stored.
-         - setup: Setup.
-    """
-
-    for obsid in range(first_obsid, last_obsid + 1):
-        correct_obsid(obsid, sensor_info, camera_name, data_dir, setup)
-
-
-def correct_obsid(obsid: int, sensor_info: NavigableDict, camera_name: str, data_dir: str, setup: Setup):
-    """
-     Correct for the swap between TRP8 and TRP10 in the N-FEE HK file for the given obsid.
-
-     This function does the following:
-
-        * Make a copy of the original file (incl. "old" in the filename)
-        * In the original file:
-            - Swap the column names for the raw values for those two TRPs
-            - Apply the calibration for those two columns
-
-     Args:
-         - obsid: Observation identifier.
-         - sensor_info: Calibration information for the TOU_TRP_PT1000 sensor type.
-         - data_dir: Full path to the directory in which the data resides.  This is the folder with sub-folders /obs and
-                    /daily, in which the N-FEE HK files are stored.
-         - setup: Setup.
-    """
-
-    stored_obsid = obsid_from_storage(obsid, data_dir=data_dir, site_id="SRON", camera_name=camera_name)
-    pattern = f"{stored_obsid}_{ORIGIN}_*.csv"
-    nfee_hk_filename = find_file(pattern, root=f"{data_dir}/obs/{stored_obsid}")
-
-    if nfee_hk_filename is None:
-        print(f"No N-FEE HK available for obsid {stored_obsid}")
-        return
-
-    correct_file(str(nfee_hk_filename), sensor_info, setup)
-
-
-def correct_od_range(first_od: int, last_od: int, sensor_info: NavigableDict, data_dir: str, setup: Setup):
-    """
-     Correct for the swap between TRP8 and TRP10 in the N-FEE HK file for the OD range.
-
-     This function does the following:
-
-        * Make a copy of the original N-FEE HK files (incl. "old" in the filename)
-        * In the original files:
-            - Swap the column names for the raw values for those two TRPs
-            - Apply the calibration for those two columns
-
-     Args:
-         - first_od: First observing day [yyyymmdd].
-         - last_od: Last observing day [yyyymmdd].
-         - sensor_info: Calibration information for the TOU_TRP_PT1000 sensor type.
-         - data_dir: Full path to the directory in which the data resides.  This is the folder with sub-folders /obs and
-                    /daily, in which the N-FEE HK files are stored.
-         - setup: Setup.
-    """
-
-    start = datetime.strptime(str(first_od), "%Y%m%d")
-    end = datetime.strptime(str(last_od), "%Y%m%d")
-
-    for dt in rrule(DAILY, dtstart=start, until=end):
-        correct_od(dt.strftime("%Y%m%d"), sensor_info, data_dir, setup)
-
-
-def correct_od(od: int, sensor_info: NavigableDict, data_dir: str, setup: Setup):
-    """
-     Correct for the swap between TRP8 and TRP10 in the N-FEE HK file for the given OD.
-
-     This function does the following:
-
-        * Make a copy of the original N-FEE HK file (incl. "old" in the filename)
-        * In the original file:
-            - Swap the column names for the raw values for those two TRPs
-            - Apply the calibration for those two columns
-
-     Args:
-         - od: Observing day [yyyymmdd].
-         - sensor_info: Calibration information for the TOU_TRP_PT1000 sensor type.
-         - data_dir: Full path to the directory in which the data resides.  This is the folder with sub-folders /obs and
-                    /daily, in which the N-FEE HK files are stored.
-         - setup: Setup.
-    """
-
-    pattern = f"{od}_SRON_{ORIGIN}.csv"
-    nfee_hk_filename = find_file(pattern, root=f"{data_dir}/daily/{od}")
-
-    if nfee_hk_filename is None:
-        print(f"No N-FEE HK available for OD {od}")
-        return
-
-    correct_file(str(nfee_hk_filename), sensor_info, setup)
-
-
-def correct_file(filename: str, sensor_info: NavigableDict, setup: Setup):
-    """
-     Correct for the swap between TRP8 and TRP10 in the N-FEE HK file with the given filename.
-
-     This function does the following:
-
-        * Make a copy of the original file (incl. "old" in the filename)
-        * In the original file:
-            - Swap the column names for the raw values for those two TRPs
-            - Apply the calibration for those two columns
-
-     Args:
-         - filename: Filename of the original N-FEE HK file that needs to be corrected.
-         - sensor_info: Calibration information for the TOU_TRP_PT1000 sensor type.
-         - setup: Setup.
-    """
-
-    # Make a copy of the original file (incl. "old" in the filename) in the same folder
-
-    copy_filename = f"{filename.split('.')[0]}_old.csv"
-    if not os.path.isfile(copy_filename):
-        shutil.copyfile(filename, copy_filename)
-
-    # Swap the column names (TRP8 <-> TRP10)
-
-    dataframe: DataFrame = pd.read_csv(filename)
-    dataframe[["NFEE_TOU_TRP8_RAW", "NFEE_TOU_TRP10_RAW"]] = dataframe[["NFEE_TOU_TRP10_RAW", "NFEE_TOU_TRP8_RAW"]]
-
-    # Correct the calibration
-
-    for trp in ["NFEE_TOU_TRP8", "NFEE_TOU_TRP10"]:
-        raw_values = dataframe[f"{trp}_RAW"].values
-        calibrated_values = [counts_to_temperature(f"{trp}_RAW", raw_value, sensor_info[trp], setup)
-                             for raw_value in raw_values]
-        dataframe[trp] = calibrated_values
-
-    # Update the changes in the original file (not in the copy that was created at the beginning)
-
-    dataframe.to_csv(filename)

scripts/sron/gimbal_conversions.py

@@ -1,75 +0,0 @@
-"""
-SRON specific functions
-
-Version 1.0 20211202 First version
-        2.0 20211215 fov_angles_to_gimbal_rotations, gimbal_rotations_to_fov_angles both accept scalar and array inputs
-        3.0 20230918 changed transformation based on plato-test-scripts#589
-
-P. Royer, R. Huisman, S.N.Gomashie
-"""
-
-import numpy as np
-
-
-def fov_angles_to_gimbal_rotations(theta, phi):
-    """
-    fov_angles_to_gimbal_rotations(theta,phi)
-
-    INPUT
-    theta, phi : field angles = [elevation, azimuth]
-
-    OUTPUT
-    SRON gimbal rotation angles
-
-    REF.
-    Adapted from mgse.sron_point_source_to_fov (see PLATO-SRON-PL- PLATO CAM TVAC Gimbal Characterization Report draft)
-    """
-    theta, phi = np.deg2rad(theta), np.deg2rad(phi)
-
-    gimbal_rx = -(np.rad2deg(np.arctan2(-np.sin(phi) * np.sin(theta), np.cos(theta))))
-    gimbal_ry = np.rad2deg(np.arcsin(np.cos(phi) * np.sin(theta)))
-
-    return gimbal_rx, gimbal_ry
-
-
-def gimbal_rotations_to_fov_angles(rotx, roty):
-    """
-    gimbal_rotations_to_fov_angles(rotx, roty)
-
-    INPUT
-    rotx, roty : SRON gimbal rotation angles
-
-    OUTPUT
-    theta, phi : field angles = [elevation, azimuth]
-
-    REF.
-    Adapted from mgse.sron_point_source_to_fov (see PLATO-SRON-PL- PLATO CAM TVAC Gimbal Characterization Report draft)
-    """
-
-    tolerance = 1.e-5
-
-    flag_scalar_input = False
-    if isinstance(roty, float):
-        rotx = np.array([rotx])
-        roty = np.array([roty])
-        flag_scalar_input = True
-
-    rotx, roty = np.deg2rad(rotx), np.deg2rad(roty)
-
-    theta = np.arccos(np.cos(rotx) * np.cos(roty))
-
-    phi = np.zeros_like(roty)
-
-    sel = np.where(np.abs(roty) < tolerance)
-    phi[sel] = np.sign(rotx[sel]) * np.pi / 2.
-
-    sel = np.where(np.abs(roty) > tolerance)
-
-    phi[sel] = np.arctan2(-np.sin(-rotx[sel]) * np.cos(roty[sel]), np.sin(roty[sel]))
-
-    theta, phi = np.rad2deg(theta), np.rad2deg(phi)
-
-    if flag_scalar_input:
-        theta, phi = theta[0], phi[0]
-
-    return theta, phi

scripts/sron/tm_gen/tm_gen_agilent.py

@@ -1,37 +0,0 @@
-from argparse import ArgumentParser
-
-import pandas as pd
-
-from egse.setup import load_setup
-
-# This script generates the tm_dictionary entries for the agilent channels defined in the setup.
-# It uses Heino's harnes excel sheet to fill in what each channel is connected to in the description.
-
-long_names = ['agilent34970_0', 'agilent34970_1', 'agilent34972_0', 'agilent34972_1']
-short_names = ['AG34970_0', 'AG34970_1', 'AG34972_0', 'AG34972_1']
-storage_mnemonic = ['AG34970-0', 'AG34970-1', 'AG34972-0', 'AG34972-1']
-sensor_types = ['two_wire', 'four_wire', 'thermocouples', 'pt100']
-
-parser = ArgumentParser()
-parser.add_argument('--filename', '-f', type=str, required=True, help="path to Heino's connection spreadsheet")
-args = parser.parse_args()
-
-with open(args.filename, 'rb') as f:
-    harness = pd.read_excel(f)
-
-setup = load_setup()
-
-for long_name, short_name, mnemonic in zip(long_names, short_names, storage_mnemonic):
-    for sensor_type in sensor_types:
-        for channel in setup.gse[long_name][sensor_type]:
-
-            # find matching column in excel sheet
-            description = ""
-            for index, row in harness.iterrows():
-                if row[1].lower() == long_name and row[2] == channel:
-                    description = row[3]
-                    break
-
-            print(f'{long_name} temperature read-out;{mnemonic};GSRON_{short_name}_R{channel};GSRON_{short_name}_R{channel};timestamp;;;;;{description};;Ohm;;;;;;;;')
-            print(f'{long_name} temperature read-out;{mnemonic};GSRON_{short_name}_T{channel};GSRON_{short_name}_T{channel};timestamp;;;;;{description};;DegCelsius;;;;;;;;')
-            

scripts/sron/tm_gen/tm_gen_heaters.py

@@ -1,4 +0,0 @@
-for board in range(6):
-    for channel in range(4):
-        print(f'Beaglebone Temperature Control;BBB_HEATERS;GSRON_HTR_I_{board}_{channel};GSRON_HTR_I_{board}_{channel};timestamp;;;;;Current of beaglebone {board} heater {channel};;Ampère;;;;;;;;')
-        print(f'Beaglebone Temperature Control;BBB_HEATERS;GSRON_HTR_V_{board}_{channel};GSRON_HTR_V_{board}_{channel};timestamp;;;;;Voltage of beaglebone {board} heater {channel};;Volts;;;;;;;;')

scripts/sron/tm_gen/tm_gen_spid.py

@@ -1,13 +0,0 @@
-from egse.setup import load_setup
-
-setup = load_setup()
-
-channels = []
-for category, channels in setup.gse.spid.configuration.heaters.items():
-    for channel in channels:
-        print(f'PID Controller;SPID;GSRON_PID_CH{channel[0]}_ENABLED;GSRON_PID_CH{channel[0]}_ENABLED;timestamp;;;;;{category};;;;;;;;;;')
-        print(f'PID Controller;SPID;GSRON_PID_CH{channel[0]}_SETPOINT;GSRON_PID_CH{channel[0]}_SETPOINT;timestamp;;;;;{category};;DegCelsius;;;;;;;;')
-        print(f'PID Controller;SPID;GSRON_PID_CH{channel[0]}_INPUT;GSRON_PID_CH{channel[0]}_INPUT;timestamp;;;;;{category};;DegCelsius;;;;;;;;')
-        print(f'PID Controller;SPID;GSRON_PID_CH{channel[0]}_ERROR;GSRON_PID_CH{channel[0]}_ERROR;timestamp;;;;;{category};;DegCelsius;;;;;;;;')
-        print(f'PID Controller;SPID;GSRON_PID_CH{channel[0]}_OUTPUT;GSRON_PID_CH{channel[0]}_OUTPUT;timestamp;;;;;{category};;;;;;;;;;')
-        print(f'PID Controller;SPID;GSRON_PID_CH{channel[0]}_ISUM;GSRON_PID_CH{channel[0]}_ISUM;timestamp;;;;;{category};;;;;;;;;;')

scripts/update_operational_cgse.py

@@ -1,268 +0,0 @@
-import logging
-import multiprocessing
-import os
-import sys
-import textwrap
-from pathlib import Path
-
-import click
-import git
-import invoke
-import rich
-from rich.console import Console
-
-multiprocessing.current_process().name = "update_cgse"
-
-from egse.system import chdir
-
-THIS_FILE_LOCATION = Path(__file__).parent
-
-# The ROOT_PROJECT_FOLDER is the location where the Common-EGSE was installed.
-# For development installations, this is where the git repository was cloned,
-# for the operational system, this is usually '/cgse', but should match the
-# PLATO_INSTALL_LOCATION environment variable in any case.
-
-ROOT_PROJECT_FOLDER = THIS_FILE_LOCATION / "../.."
-
-MODULE_LOGGER = logging.getLogger("egse.scripts")
-
-
-class DirtyRepoError(Exception):
-    pass
-
-
-class GitCommandError(Exception):
-    pass
-
-
-def check_and_report_dirty_repo():
-    repo = git.Repo(Path.cwd())
-
-    if repo.is_dirty(untracked_files=False):
-        rich.print("You have uncommitted changes, unable to install the Common-EGSE.")
-
-        for item in repo.index.diff(None):
-            rich.print(f"  [red]Modified: {item.a_path}")
-
-        rich.print("Stash or submit your changes to GitHub.")
-
-        raise DirtyRepoError()
-
-
-def run_shell_command(cmd: str, hide: bool = True, warn: bool = True, msg: str = None):
-    if msg is None:
-        rich.print(f"Executing '{cmd}'...", end="", flush=True)
-    else:
-        rich.print(f"{msg}...", end="", flush=True)
-
-    response = invoke.run(cmd, hide=hide, warn=warn)
-
-    if response.return_code:
-        rich.print("[red]FAILED[/red]")
-        if response.stdout:
-            rich.print(f"{response.stdout}")
-        rich.print(f"[red]{response.stderr}[/]")
-        raise GitCommandError()
-    else:
-        rich.print("[green]succeeded[/green]")
-
-    return response
-
-
-def is_operational_install(location: str):
-    # location can be the following:
-    #
-    #   * root folder where Common-EGSE is installed, e.g. /cgse/lib/python
-    #   * the actual 'egg' folder where Common-EGSE is installed,
-    #     e.g. /cgse/lib/python/Common_EGSE-2021.3_SRON_RC37-py3.8.egg
-
-    rich.print(f"{location=}")
-
-    if ".egg" in location:
-        return True
-
-    candidates = [path for path in os.listdir(location) if path.startswith("Common_EGSE") or path.startswith("cgse")]
-
-    rich.print(f"{candidates=}")
-
-    if candidates and candidates[0].endswith(".egg"):
-        return True
-
-    # add other tests here that might indicate operational install
-
-    return False
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option("--tag", help="The Release number to install.")
-def ops(tag=None):
-    """
-    Update the Common-EGSE on the operational machine. An operational installation is different
-    from a developer installation. There is no virtual environment and the all required Python
-    packages, including the Common-EGSE are installed at a specific location. The installation
-    process makes use of the following environment variables:
-
-      * PLATO_COMMON_EGSE_PATH: the location of the plato-common-egse repository on your machine, e.g., '~/git/plato-common-egse'
-
-      * PLATO_INSTALL_LOCATION: the location where the packages shall be installed, usually '/cgse'
-
-    Don't update the operational system without a tag.
-
-    The following commands will be executed:
-
-      * git fetch updates
-      * get checkout develop
-      * git checkout tags/<tag> -b <tag>-branch
-      * python -m pip install --home=$PLATO_INSTALL_LOCATION .
-
-    You will need to manually restart the core services as root on the egse-server:
-
-      * sudo systemctl restart log_cs cm_cs sm_cs pm_cs dyn_cs
-
-    NOTE: This command only works on an installation with setuptools (not a development
-          installation). The installation must have been done in the location set by the
-          environment variable PLATO_INSTALL_LOCATION.
-
-    Args:
-        tag: the tag that needs to be used for the update.
-
-    """
-
-    try:
-        plato_install_location = os.environ["PLATO_INSTALL_LOCATION"]
-        MODULE_LOGGER.info(f"{plato_install_location=}")
-    except KeyError:
-        rich.print(
-            "[red]On an operational system, the PLATO_INSTALL_LOCATION environment variable must "
-            "be set.[/]\n"
-            "Please set this to the root folder of the installation, usually [default]'/cgse'."
-        )
-        return
-
-    if not Path(plato_install_location).exists():
-        rich.print(
-            f"[orange3]I didn't find the '{plato_install_location}' location on your system.[/]\n"
-            "Please check if the PLATO_INSTALL_LOCATION is set to the correct folder."
-        )
-        return
-
-    try:
-        plato_cgse_location = os.environ["PLATO_COMMON_EGSE_PATH"]
-        MODULE_LOGGER.info(f"{plato_cgse_location=}")
-    except KeyError:
-        rich.print(
-            "[red]On an operational system, the PLATO_COMMON_EGSE_PATH environment variable must "
-            "be set.[/]\nPlease set this to the root folder of the cloned repository, "
-            "usually [default]'~/git/plato-common-egse'."
-        )
-        return
-
-    with chdir(plato_cgse_location):
-        rich.print("Updating plato-common-egse...")
-
-        try:
-            run_shell_command("git fetch updates")
-            run_shell_command("git checkout develop")
-        except GitCommandError:
-            return
-
-        try:
-            check_and_report_dirty_repo()
-        except DirtyRepoError:
-            return
-
-        if tag:
-            try:
-                run_shell_command(f"git checkout tags/{tag} -b {tag}-branch")
-                run_shell_command(f"{sys.executable} -m pip install --prefix={plato_install_location} . ")
-            except GitCommandError:
-                return
-        else:
-            # git rev-list --tags --timestamp --no-walk | sort -nr | head -n1 | cut -f 2 -d ' ' | xargs git describe --contains
-            rich.print("Usage: update_cgse ops --tag=<tag name>")
-            rc = invoke.run("git describe --tags --abbrev=0", hide="stdout")
-            rich.print(f"The latest tag name is '{rc.stdout.strip()}'.")
-            return
-
-        console = Console()
-        console.print(
-            textwrap.dedent(
-                f"""
-                To complete the installation process, perform the following actions:
-                
-                On the egse-client:
-                  * stop all device control servers from the PM GUI
-            
-                On the egse-server:
-                  * run (in the root folder of plato-common-egse): [grey50]invoke stop-core-egse[/]
-                  * the core services should automatically be re-started by systemd,
-                  * (if not, run (in the root folder of plato-common-egse): [grey50]invoke start-core-egse[/])
-                  * Alternatively, you can run: [grey50]sudo systemctl restart log_cs sm_cs cm_cs pm_cs syn_cs[/]
-            
-                """
-            ), highlight=False
-        )
-
-
-
-@cli.command()
-def develop():
-    """
-    Update the Common-EGSE on a develop machine.
-
-    The following commands will be executed in the background:
-
-      * git fetch updates
-
-      * git rebase updates/develop
-
-      * python3 -m pip install -e .
-
-    """
-
-    with chdir(ROOT_PROJECT_FOLDER):
-        rich.print("Updating plato-common-egse development environment.")
-
-        try:
-            check_and_report_dirty_repo()
-        except DirtyRepoError:
-            return
-
-        try:
-            run_shell_command("git fetch updates")
-            run_shell_command("git checkout develop")
-            run_shell_command("git rebase updates/develop")
-            run_shell_command(f"{sys.executable} -m pip install -e .")
-            response = run_shell_command(f"{sys.executable} -m egse.version")
-        except GitCommandError:
-            return
-
-        release = response.tail("stdout").split("\n")[-1]
-
-        try:
-            response = run_shell_command("git describe --tags --long")
-            tag = response.stdout.strip().split("-")
-
-            # The tag format is:
-            #   * the annotated tag
-            #   * the number of commits since the tag
-            #   * abbreviated commit name (starts with the letter 'g')
-
-            number_of_commits = tag[-2]
-            bare_tag = "-".join(tag[:-2])
-
-        except GitCommandError:
-            return
-
-        rich.print(f"{release.strip()}")
-        if number_of_commits != 0:
-            rich.print(f"Number of commits since {bare_tag}: {number_of_commits}")
-
-
-if __name__ == "__main__":
-    cli()