ptwrapper 2.7.1__tar.gz → 2.7.2__tar.gz

{ptwrapper-2.7.1 → ptwrapper-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ptwrapper
-Version: 2.7.1
+Version: 2.7.2
 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.1 → ptwrapper-2.7.2}/pyproject.toml

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

{ptwrapper-2.7.1 → ptwrapper-2.7.2}/src/ptwrapper/subscribers.py

@@ -30,7 +30,9 @@ class OsvePtrLogger(OsvePtrAbstract):
 
     remove_checks = True
 
-    swi_check = False
+    # Initialize attributes
+    swi_pointing_check = False
+    swi_drift_check = False
     swi_block_violation = False
     swi_et_prev = 0.0
     swi_x_t_prev = None
@@ -50,6 +52,7 @@ class OsvePtrLogger(OsvePtrAbstract):
     gala_rate_violation = False
     gala_rate_sun_exclusion_block_violation = False
 
+    peplo_jna_sun_check = False
     peplo_jna_violation = False
     peplo_jna_start_time = False
     peplo_jna_sun_exclusion_block_violation = False
@@ -91,10 +94,12 @@ class OsvePtrLogger(OsvePtrAbstract):
             return
 
         for obs in block_data["observations"]["observations"]:
-            if obs.get("instrument") == 'SWI' and obs.get("type") in {'PRIME', 'DESIGNER'}:
-                self.swi_check = True
+            if (obs.get("unit") == 'SWI' or obs.get("instrument") == 'SWI') and obs.get("type") in {'PRIME', 'DESIGNER'}:
+                self.swi_pointing_check = False # this is a temporary solution, to be fixed when SWI pointing check is implemented
+                self.swi_drift_check = True
                 self._set_swi_target(obs, block_data)
-                self._check_swi_block_duration(obs, block_data)
+                self._set_swi_drift_rate(obs, block_data)
+                #self._check_swi_block_duration(obs, block_data)
 
     def _set_swi_target(self, observation, block_data):
         try:
@@ -107,6 +112,15 @@ class OsvePtrLogger(OsvePtrAbstract):
             warning_msg = f'SWI observation {observation.get("definition", "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)
+    
+    def _set_swi_drift_rate(self, observation, block_data):
+        # If SWI observation drift rates could not be set, we should disable SWI drift checks
+        # self.swi_drift_check = False -> future
+
+        # For now, we will set a default value if maxATDriftRate or maxCTDriftRate are not provided
+        DRMAX = 6.0e-6  # deg/s
+        self.swi_at_drift_rate = float(observation.get("maxATDriftRate", DRMAX))
+        self.swi_ct_drift_rate = float(observation.get("maxCTDriftRate", DRMAX))
 
     def _check_swi_block_duration(self, observation, block_data):
         violation, message = self._swi_block_duration_check(block_data, observation.get("definition", "UNKNOWN"))
@@ -119,7 +133,7 @@ class OsvePtrLogger(OsvePtrAbstract):
             return
 
         for obs in block_data["observations"]["observations"]:
-            if obs.get("instrument") == 'PEPHI' and obs.get("type") in {'PRIME', 'DESIGNER'}:
+            if (obs.get("unit") == 'PEPHI' or obs.get("instrument") == 'PEPHI') and obs.get("type") in {'PRIME', 'DESIGNER'}:
                 self.pephi_jeni_check = True
                 self._set_pephi_jeni_target(obs, block_data)
 
@@ -178,14 +192,15 @@ class OsvePtrLogger(OsvePtrAbstract):
             self.onMsgReceived('WARNING', 'PTWR', blockdata["block_end"], 'SWI Pointing and/or drift range not recovered.')
 
         # Deactivate the SWI checks at the end of the block.
-        self.swi_check = False
+        self.swi_pointing_check = False
+        self.swi_drift_check = False
         self.swi_block_violation = False
 
         # --------------------------------------------------------------------------------------------------------------
         # PEPHI JENI Sun and Target Concurrence Check
         # --------------------------------------------------------------------------------------------------------------
         if self.pephi_jeni_block_violation:
-            log(self.pephi_jeni_severity, 'PTWR', blockdata["block_end"], f'{self.pephi_jeni_message} End')
+            log(self.pephi_jeni_severity, 'PTWR', blockdata["block_end"], f'PEPHI block end and JENI Sun avoidance not recovered')
             self.onMsgReceived(self.pephi_jeni_severity, 'PTWR', blockdata["block_end"],
                                f'{self.pephi_jeni_message} End')
 
@@ -258,7 +273,7 @@ class OsvePtrLogger(OsvePtrAbstract):
         # ----------------------------------------------------------------------------------------------------------
         # SWI Pointing Compatibility Check
         # ----------------------------------------------------------------------------------------------------------
-        if self.swi_check:
+        if self.swi_drift_check or self.swi_pointing_check:
             # We calculate the sc quaternion for the current state and jump to the
             # next simulation step to calculate the drift.
             x_t, y_t, dx_dt, dy_dt = self._swi_pointing_drift(data)
@@ -310,7 +325,7 @@ class OsvePtrLogger(OsvePtrAbstract):
         # ----------------------------------------------------------------------------------------------------------
         # PEPLO JNA Sun Exclusion Check
         # ----------------------------------------------------------------------------------------------------------
-        if self._sun_distance_threshold(data["time"], 2.0):
+        if self._sun_distance_threshold(data["time"], 2.0) and self.peplo_jna_sun_check:
 
             violation = self._peplo_jna_sun_exclusion_check(data)
             if violation:
@@ -694,22 +709,26 @@ class OsvePtrLogger(OsvePtrAbstract):
         at0 = 0.324
         ct0 = 0.188
         drmax = 6.0e-6
+        drmax_at = self.swi_at_drift_rate # deg/s
+        drmax_ct = self.swi_ct_drift_rate # deg/s
 
         flags = {'AT': 'OK', 'CT': 'OK', 'ATDRIFT': 'OK', 'CTDRIFT': 'OK'}
         violation = False
 
-        if (np.abs(x) >= (atmax + at0)):
-            flags['AT'] = f'SWI Pointing out of AT range: {np.abs(x):.2f} [deg] >= {atmax + at0:.2f} [deg]'
-            violation = True
-        elif (np.abs(y) >= (ctmax + ct0)):
-            flags['CT'] = f'SWI Pointing out of CT range: {np.abs(y):.2f} [deg] >= {ctmax + ct0:.2f} [deg]'
-            violation = True
-        elif (np.abs(dx) > drmax):
-            flags['ATDRIFT'] = f'SWI Drift along AT out of range: {np.abs(dx):.3E} [deg/s] > {drmax:.3E} [deg/s]'
-            violation = True
-        elif (np.abs(dy) > drmax):
-            flags['CTDRIFT'] = f'SWI Drift along CT out of range: {np.abs(dy):.3E} [deg/s] > {drmax:.3E} [deg/s]'
-            violation = True
+        if self.swi_pointing_check is True:
+            if (np.abs(x) >= (atmax + at0)):
+                flags['AT'] = f'SWI Pointing out of AT range: {np.abs(x):.2f} [deg] >= {atmax + at0:.2f} [deg]'
+                violation = True
+            if (np.abs(y) >= (ctmax + ct0)):
+                flags['CT'] = f'SWI Pointing out of CT range: {np.abs(y):.2f} [deg] >= {ctmax + ct0:.2f} [deg]'
+                violation = True
+        if self.swi_drift_check is True:
+            if (np.abs(dx) > drmax_at):
+                flags['ATDRIFT'] = f'SWI Drift along AT out of range: {np.abs(dx):.3E} [deg/s] > {drmax_at:.3E} [deg/s]'
+                violation = True
+            if (np.abs(dy) > drmax_ct):
+                flags['CTDRIFT'] = f'SWI Drift along CT out of range: {np.abs(dy):.3E} [deg/s] > {drmax_ct:.3E} [deg/s]'
+                violation = True
 
         return flags, violation
 
@@ -1046,62 +1065,38 @@ class OsvePtrLogger(OsvePtrAbstract):
         et = spice.utc2et(data["time"])
         targ = self.pephi_jeni_target
 
-        # 2) Spacecraft's known quaternion (J2000 -> s/c)
+        # 1) 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
 
-        # 4) Position of the target w.r.t. s/c in J2000 at time et
+        # 2) 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)
-        state_sun, _ = spice.spkpos('SUN', et, "J2000", "NONE", "JUICE")
-        r_j2000_sun = state_sun
+        state_sun, _ = spice.spkpos('SUN', et, 'J2000', 'NONE', 'JUICE')
+        r_j2000_sun  = spice.vhat(state_sun)
 
-        state_tar, _ = spice.spkpos(targ, et, "J2000", "NONE", "JUICE")
-        r_j2000_tar = state_tar
+        state_tar, _ = spice.spkpos(targ, et, 'J2000', 'NONE', 'JUICE')
+        r_j2000_tar  = spice.vhat(state_tar)
 
-        # 5) Rotation matrix from J2000 to s/c
-        r_j2000_to_sc = spice.q2m(q_t)
+        # 3) Example with Jupiter:
+        # Jupiter is in PY FOV, Sun is in PY FOR: yellow -> WARNING
+        # Jupiter is in MY FOV, Sun is in MY FOR: yellow -> WARNING
+        sun_in_fov_p = spice.fovray('JUICE_PEP_JENI_FOR_PY', r_j2000_sun, 'J2000', 'NONE', 'JUICE', et)
+        sun_in_fov_m = spice.fovray('JUICE_PEP_JENI_FOR_MY', r_j2000_sun, 'J2000', 'NONE', 'JUICE', et)
+        tar_in_fov_m = spice.fovray('JUICE_PEP_JENI_E_SLIT_MY', r_j2000_tar, 'J2000', 'NONE', 'JUICE', et)
+        tar_in_fov_p = spice.fovray('JUICE_PEP_JENI_E_SLIT_PY', r_j2000_tar, 'J2000', 'NONE', 'JUICE', et)
 
-        # 6) Transform target vector into s/c frame, compute (x, y) at time t
-        rb_sun = spice.mxv(r_j2000_to_sc, r_j2000_sun)
-        rb_tar = spice.mxv(r_j2000_to_sc, r_j2000_tar)
-
-        # Example wit Jupiter:
-        # Jupiter is in PY FOV, Sun is completely outside JENI’s FOV (PY or MY): green -> INFO
-        # Jupiter is in PY FOV, Sun is in MY FOV: yellow -> WARNING
-        # Jupiter and Sun are in PY FOV: red -> ERROR
-        sun_in_fov_p = spice.fovray('JUICE_PEP_JENI_FOR_PY', rb_sun, 'JUICE_SPACECRAFT', 'NONE', 'SUN', et)
-        sun_in_fov_m = spice.fovray('JUICE_PEP_JENI_FOR_MY', rb_sun, 'JUICE_SPACECRAFT', 'NONE', 'SUN', et)
-        tar_in_fov_m = spice.fovray('JUICE_PEP_JENI_FOR_MY', rb_tar, 'JUICE_SPACECRAFT', 'NONE', targ, et)
-        tar_in_fov_p = spice.fovray('JUICE_PEP_JENI_FOR_PY', rb_tar, 'JUICE_SPACECRAFT', 'NONE', targ, et)
-
-        if tar_in_fov_p and (not sun_in_fov_p and not sun_in_fov_m):
+        if tar_in_fov_m and sun_in_fov_m:
             violation = True
-            severity = 'INFO'
-            message = f'PEPHI JENI with {targ.capitalize()} in the PY FOR and Sun outside FOR'
-        elif tar_in_fov_m and (not sun_in_fov_p and not sun_in_fov_m):
-            violation = True
-            severity = 'INFO'
-            message = f'PEPHI JENI with {targ.capitalize()} in the MY FOR and Sun outside FOR'
-        elif tar_in_fov_m and sun_in_fov_p:
-            violation = True
-            severity = 'WARNING'
-            message = f'PEPHI JENI with {targ.capitalize()} in the MY FOR and Sun in the PY FOR'
-        elif tar_in_fov_p and sun_in_fov_m:
-            violation = True
-            severity = 'WARNING'
-            message = f'PEPHI JENI with {targ.capitalize()} in the PY FOR and Sun in the MY FOR'
+            severity  = 'WARNING'
+            message   = f'PEPHI JENI with {targ.capitalize()} in the MY E_SLIT FoV and Sun in the MY FoR'
         elif tar_in_fov_p and sun_in_fov_p:
             violation = True
-            severity = 'ERROR'
-            message = f'PEPHI JENI with {targ.capitalize()} and the Sun in the PY FOR'
-        elif tar_in_fov_m and sun_in_fov_m:
-            violation = True
-            severity = 'ERROR'
-            message = f'PEPHI JENI with {targ.capitalize()} and Sun in the MY FOR'
+            severity  = 'WARNING'
+            message   = f'PEPHI JENI with {targ.capitalize()} in the PY E_SLIT FoV and Sun in the PY FoR'
         else:
             violation = False
-            message = False
-            severity = False
+            message   = False
+            severity  = False
 
         return message, severity, violation
 
@@ -1122,7 +1117,7 @@ class OsvePtrLogger(OsvePtrAbstract):
     def _report_pephi_jeni_recovery(self, time):
 
         severity = 'INFO'
-        message = 'PEPHI JENI Sun and Target in FOR recovered'
+        message  = 'PEPHI JENI Sun avoidance recovered'
 
         log(severity, 'PTWR', f'{time}Z', message)
         self.onMsgReceived(severity, 'PTWR', f'{time}Z', message)