ptwrapper 2.7.5__tar.gz → 2.7.7__tar.gz

{ptwrapper-2.7.5 → ptwrapper-2.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ptwrapper
-Version: 2.7.5
+Version: 2.7.7
 Summary: A Pointing Tool OSVE wrapper
 License: European Space Agency Public License (ESA-PL) Permissive (Type 3) – v2.4
 License-File: LICENSE.txt

{ptwrapper-2.7.5 → ptwrapper-2.7.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ptwrapper"
-version = "2.7.5"
+version = "2.7.7"
 description = "A Pointing Tool OSVE wrapper"
 authors = [
     "Marc Costa <marc.costa@ext.esa.int>",

{ptwrapper-2.7.5 → ptwrapper-2.7.7}/src/ptwrapper/subscribers.py

@@ -8,14 +8,17 @@
 #                                                                             #
 # (C) Copyright European Space Agency, 2025                                   #
 # *************************************************************************** #
+from asyncio import events
 import os
 
 import numpy as np
 import spiceypy as spice
 from osve.subscribers.osve_ptr_abstract import OsvePtrAbstract
-from .utils import log
+from .utils import get_evf_path, log, parse_events_from_evf
 import xml.etree.ElementTree as ET
 from spiceypy.utils.exceptions import SpiceyError
+from datetime import datetime
+import pprint
 
 
 class OsvePtrLogger(OsvePtrAbstract):
@@ -32,6 +35,10 @@ class OsvePtrLogger(OsvePtrAbstract):
 
     remove_checks = True
 
+    # Retrieve eclipse events (geopipeline file) to mask panel illuminations
+    evf_file = get_evf_path()
+    eclipse_events = parse_events_from_evf(evf_file, keyword="SUN_OCC")
+
     # Initialize attributes
     swi_observations = []
     swi_pointing_check = False
@@ -66,7 +73,7 @@ class OsvePtrLogger(OsvePtrAbstract):
     px_illumination_block_violation = False
     pz_illumination_block_violation = False
     janus_sun_exclusion_block_violation = False
-
+    block_mode = None
 
     def __init__(self, meta_kernel, remove_obs_comp=False, remove_checks=True):
         """
@@ -102,6 +109,7 @@ class OsvePtrLogger(OsvePtrAbstract):
                 if rules_xml: 
                     obs.update(self._parse_numeric_subnodes(rules_xml))
         
+        self._get_pointing_block_mode(block_data)
         self._handle_swi_checks(block_data)
         self._handle_pephi_jeni_checks(block_data)
         self._handle_peplo_checks(block_data)
@@ -109,6 +117,10 @@ class OsvePtrLogger(OsvePtrAbstract):
         self._handle_pz_illumination_check(block_data)
         self._handle_janus_sun_exclusion_check(block_data)
         return 0
+    
+    def _get_pointing_block_mode(self, block_data):
+        if block_data["block_type"] != "SLEW":
+            self.block_mode = block_data["block_mode"]
 
     def _handle_swi_checks(self, block_data):
         if self.remove_obs_comp or "observations" not in block_data:
@@ -123,7 +135,7 @@ class OsvePtrLogger(OsvePtrAbstract):
                 obs["swi_drift_check"] = True
                 obs["swi_point_violation"] = False
                 obs["swi_drift_violation"] = False
-                obs["swi_et_prev"] = 0.0
+                obs["swi_et_prev"]  = None
                 obs["swi_x_t_prev"] = None
                 obs["swi_y_t_prev"] = None
                 self.swi_observations.append(obs) 
@@ -241,16 +253,26 @@ class OsvePtrLogger(OsvePtrAbstract):
                 self._set_pephi_jeni_target(obs, block_data)
 
     def _set_pephi_jeni_target(self, observation, block_data):
-        try:
-            target = observation.get("target", "JUPITER")
-            if '.' in target:
-                target = target.split('.')[-1]
-            self.pephi_jeni_target = target
-        except Exception:
-            self.pephi_jeni_target = 'JUPITER'
+        target = observation.get("target")
+        if target is not None and '.' in target:
+            target = target.split('.')[-1].upper()
+            # Check SPICE target ID
+            try:
+                code = spice.bodn2c(target)
+                if code < 0: code = None # Not a celestial body
+            except SpiceyError:
+                code = None
+        else:
+            code = None
+
+        # If target is not valid -> set JUPITER as default value
+        if code is None: 
+            target = 'JUPITER'
             warning_msg = f'PEPHI JENI observation {observation.get("obsId", "UNKNOWN")} has no target, setting to JUPITER as default.'
-            log('WARNING', 'PTWR', block_data["block_start"], warning_msg)
-            self.onMsgReceived('WARNING', 'PTWR', block_data["block_start"], warning_msg)
+            log('INFO', 'PTWR', block_data["block_start"], warning_msg)
+            self.onMsgReceived('INFO', 'PTWR', block_data["block_start"], warning_msg)
+        
+        self.pephi_jeni_target = target
 
     def _handle_peplo_checks(self, block_data):
         if self.remove_obs_comp or  "observations" not in block_data:
@@ -261,8 +283,19 @@ class OsvePtrLogger(OsvePtrAbstract):
                 # Future implementation
                 # self.peplo_nim_check = True
                 pass
+    
+    def _is_in_eclipse(self, time_str):
+        current_time = datetime.strptime(time_str.replace("Z", ""), "%Y-%m-%dT%H:%M:%S")
+        for e in self.eclipse_events:
+            if e["startTime"] <= current_time <= e["endTime"]:
+                return True
+        return False
 
     def _handle_px_illumination_check(self, block_data):
+        #self.px_illumination_block_violation = 
+        # We implement here masking for eclipse periods if the +X panel illumination is during an eclipse,
+        # therefore, even if AGM report a +X panel illumination, we do not report a violation at the start 
+        # of the block if the +X panel illumination is masked by an eclipse event in the EVF file (geopipeline)
         self.px_illumination_block_violation = bool(block_data.get('px_illumination'))
 
     def _handle_pz_illumination_check(self, block_data):
@@ -329,6 +362,8 @@ class OsvePtrLogger(OsvePtrAbstract):
             log('ERROR', 'PTWR', blockdata["block_end"], 'Block has +X Panel Illuminated')
             self.onMsgReceived('ERROR', 'PTWR', blockdata["block_end"],
                                'Block has +X Panel Illuminated')
+        
+        self.px_illumination_block_violation = False # restart
 
         # --------------------------------------------------------------------------------------------------------------
         # +Z Illumination Constraint Check per pointing block
@@ -459,7 +494,7 @@ class OsvePtrLogger(OsvePtrAbstract):
         # ----------------------------------------------------------------------------------------------------------
         # +X Illumination Constraint Check per pointing block - Complements AGM constraint.
         # ----------------------------------------------------------------------------------------------------------
-        if data['px_illumination']:
+        if data['px_illumination'] and not self._is_in_eclipse(data["time"]):
             self.px_illumination_block_violation = True
 
         # ----------------------------------------------------------------------------------------------------------
@@ -501,7 +536,7 @@ class OsvePtrLogger(OsvePtrAbstract):
             if key in ['ATDRIFT', 'CTDRIFT'] and not reportDrift:
                 continue
 
-            msg = f'[{type}] [{obsId}] {value}'
+            msg = f'[{type}] [{obsId}] [MODE: {self.block_mode}] {value}'
             log(severity, 'PTWR', f'{time}Z', msg)
             self.onMsgReceived(severity, 'PTWR', f'{time}Z', msg)
 
@@ -589,7 +624,6 @@ class OsvePtrLogger(OsvePtrAbstract):
         else:
             severity = ["ERROR", "WARNING"]
 
-        # Iterate over each log and check if it matches the condition
         for log in logs:
             severity_matches = log["severity"] in severity
             module_matches = log["module"] in ["AGM", "AGE", "PTWR"]
@@ -607,10 +641,14 @@ class OsvePtrLogger(OsvePtrAbstract):
         Processes a standard (non-SLEW) block and updates the log.
         """
         designer, designer_obs = self._get_designer_and_obs(block_data)
-        if verbose:
-            self._print_block_summary(idx, designer, designer_obs, block_data["block_start"], block_data["block_end"], block_data["status"])
 
         error_messages = self._extract_error_messages(block_data, verbose)
+        # If error_messages is empty, it means there are no relevant logs to report for this block, so we can skip logging it.
+        # This is particularly relevant for the case of error blocks that have been masked here (e.g., panel illumination during eclipse events)
+        if not error_messages: return
+
+        if verbose:
+            self._print_block_summary(idx, designer, designer_obs, block_data["block_start"], block_data["block_end"], block_data["status"])
 
         try:
             block_status = str(block_data["status"])
@@ -656,12 +694,15 @@ class OsvePtrLogger(OsvePtrAbstract):
         if prev_info is None or next_info is None:
             log('WARNING', 'PTWR', '', f'The SLEW block {idx - 1} cannot be logged')
             return
+        
+        # If error_messages is empty, it means there are no relevant logs to report for this block, so we can skip logging it.
+        # This is particularly relevant for the case of error blocks that have been masked here (e.g., panel illumination during eclipse events)
+        error_messages = self._extract_error_messages(block_data, verbose, slew_prev=prev_info, slew_next=next_info)
+        if not error_messages: return
 
         if verbose:
             self._print_slew_summary(idx, prev_info, next_info)
 
-        error_messages = self._extract_error_messages(block_data, verbose, slew_prev=prev_info, slew_next=next_info)
-
         try:
             self._update_slew_log(ptr_log, prev_info, next_info, idx, error_messages)
         except (ValueError, KeyError, TypeError) as e:
@@ -755,13 +796,16 @@ class OsvePtrLogger(OsvePtrAbstract):
             exec_percentage = self._calculate_execution_percentage(time_exec, time_start, time_end)
 
             ##Temporary fix
-            print(block_data)
+            # 1. Increase slew violation severity if "above maximum allowed" is found in the log text, as this is a common message for slew violations in AGM.
             if "above maximum allowed" in log['text']: 
                 log['severity'] = 'ERROR'
-
+            # 2. Mask +X panel illumination messages during eclipse periods
+            if ("Panel Illumination" in log.get("text", "") and self._is_in_eclipse(log.get("time", ""))):
+                continue
+            
             if verbose:
                 print(f"      {log['severity']} , {exec_percentage}, {log['time']} , {log['text']}")
-
+                
             error_messages.append(self._format_error(log, exec_percentage))
 
         return error_messages
@@ -948,25 +992,31 @@ class OsvePtrLogger(OsvePtrAbstract):
         y_t_prev = observation.get("swi_y_t_prev")
 
         # The constraint is only checked every 30 seconds.
-        if et_prev:
+        if et_prev is not None:
             dt = et - et_prev
             if dt < 30:
                 return None, None, None, None
 
-        # 1) Spacecraft's known quaternion (J2000 -> s/c)
+        # 2) Spacecraft's known quaternion (J2000 -> s/c)
         q_t = np.array([data['qs'], data['q1'], data['q2'], data['q3']])
         q_t = q_t / np.linalg.norm(q_t)  # make sure it's unit
 
-        # 2) Position of the target w.r.t. s/c in J2000 at time et
+        # 3) Position of the target w.r.t. s/c in J2000 at time et
         #    (state_t = [x, y, z, vx, vy, vz], ignoring velocity index here)
-        target, _ = self._get_swi_target(observation)
-        state_t, _ = spice.spkezr(target, et, "JUICE_SPACECRAFT", "LT+S", "JUICE")
-        x_t, y_t = self._swi_get_xy_from_body_vector(state_t)
+        target, _  = self._get_swi_target(observation)
+        state_t, _ = spice.spkezr(target, et, "J2000", "LT+S", "JUICE")
+        r_j2000_t  = state_t[:3]
+
+        # 4) Rotation matrix from J2000 to s/c
+        r_j2000_to_sc = spice.q2m(q_t)
 
-        # 3) Obtain (x, y) drift rates in deg/s
-        if et_prev != 0.:
+        # 5) Transform target vector into s/c frame, compute (x, y) at time t
+        rb_t = spice.mxv(r_j2000_to_sc, r_j2000_t)
+        x_t, y_t = self._swi_get_xy_from_body_vector(rb_t)
+
+        if et_prev is not None:
             dt = et - et_prev
-            # 12) Approximate drift rate in deg/s
+            # 6) Approximate drift rate in deg/s
             dx_dt = (x_t - x_t_prev) / dt
             dy_dt = (y_t - y_t_prev) / dt
         else:
@@ -979,6 +1029,7 @@ class OsvePtrLogger(OsvePtrAbstract):
 
         return x_t, y_t, dx_dt, dy_dt
 
+
     def _swi_block_duration_check(self, blockdata, observation_definition):
         """
         Check if the SWI observation block's duration meets the minimum required duration.

{ptwrapper-2.7.5 → ptwrapper-2.7.7}/src/ptwrapper/utils.py

@@ -12,6 +12,8 @@ import json
 import os
 import shutil
 import re
+from datetime import datetime
+from pathlib import Path
 
 
 class MyError(Exception):
@@ -317,3 +319,46 @@ def crema_identifier(metakernel_path):
 def log(level, tag, time, message):
     severity = f"[{level}]"
     print(f"{severity:<10}<{tag:<4}> {time:<20} {message}")
+
+def get_evf_path():
+    base_dir = Path(__file__).resolve().parent
+    evf_path = base_dir / "input" / "evf" / "EVT_CREMA_5_1_150LB_23_1_A3_GEOPIPELINE.EVF"
+    return evf_path
+
+def parse_events_from_evf(evf_file_path, keyword=None):
+    open_events = {}
+    parsed_events = []
+    with open(evf_file_path, 'r') as file:
+        for line in file:
+            line = line.strip()
+            if not line or line.startswith('#'):  # Skip empty lines and comments
+                continue
+            
+            # Get parts of the line, expecting at least a time and an event name
+            parts = line.split()
+            if len(parts) < 2:
+                continue  # Skip lines that don't have at least a time and an event name
+            time_str   = parts[0]
+            event_name = parts[1]
+
+            # Convert time
+            event_time = datetime.strptime(time_str, "%d-%b-%Y_%H:%M:%S")
+
+            # If a keyword is provided, filter events by the keyword in the event name
+            if keyword and keyword.upper() not in event_name.upper():
+                continue
+
+            # Handle start/end pairing
+            if event_name.endswith("_START"):
+                base_name = event_name[:-6]
+                open_events[base_name] = event_time
+            elif event_name.endswith("_END"):
+                base_name = event_name[:-4]
+                if base_name in open_events:
+                    parsed_events.append({
+                        "name": base_name,
+                        "startTime": open_events.pop(base_name),
+                        "endTime": event_time
+                    })
+
+    return parsed_events