flightanalysis 0.3.0__tar.gz → 0.3.2__tar.gz

{flightanalysis-0.3.0/flightanalysis.egg-info → flightanalysis-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.3.0
+Version: 0.3.2
 Summary: A package for analysing flight data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3
@@ -15,8 +15,8 @@ Requires-Dist: fastdtw
 Requires-Dist: simplejson
 Requires-Dist: loguru
 Requires-Dist: joblib
-Requires-Dist: pfc-geometry>=0.2.9
-Requires-Dist: flightdata>=0.2.17
+Requires-Dist: pfc-geometry>=0.2.10
+Requires-Dist: flightdata>=0.2.18
 Requires-Dist: GitPython
 Requires-Dist: pyperclip
 Provides-Extra: dev
@@ -27,8 +27,8 @@ Requires-Dist: fastdtw; extra == "dev"
 Requires-Dist: simplejson; extra == "dev"
 Requires-Dist: loguru; extra == "dev"
 Requires-Dist: joblib; extra == "dev"
-Requires-Dist: pfc-geometry>=0.2.9; extra == "dev"
-Requires-Dist: flightdata>=0.2.17; extra == "dev"
+Requires-Dist: pfc-geometry>=0.2.10; extra == "dev"
+Requires-Dist: flightdata>=0.2.18; extra == "dev"
 Requires-Dist: ardupilot_log_reader>=0.3.3; extra == "dev"
 Requires-Dist: pymavlink; extra == "dev"
 Requires-Dist: GitPython; extra == "dev"

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/analysis/manoeuvre_analysis/complete.py

@@ -163,7 +163,7 @@ class Complete(Alignment):
 
     def optimise_alignment(self):
         fl = self.flown.copy()
-        elns = ["entry_line"] + list(self.mdef.eds.data.keys())
+        elns = list(self.mdef.eds.data.keys())
 
         padjusted = set(elns)
         count = 0

flightanalysis-0.3.2/flightanalysis/data/__init__.py

@@ -0,0 +1,15 @@
+from importlib_resources import files
+from json import load
+
+
+def get_json_resource(name):
+    return load(files("flightanalysis.data").joinpath(name).open('r'))
+  
+
+def list_resources(rtype: str):
+    return [file.name for file in files("flightanalysis.data").iterdir() if file.name.endswith(f"{rtype}.json")]
+
+if __name__ == "__main__":
+    resources = list_resources('schedule')
+    print(resources)
+    data = get_json_resource(resources[0])

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/data/f3a_a25_schedule.json

@@ -1521,6 +1521,8 @@
           "length": "(0.5*(180-((abs(e_3_rolls[0])*speed)/partial_roll_rate)))"
         },
         "dgs": [
+          "initial_track_y_after_speedup",
+          "initial_track_z_after_speedup",
           "track_y_after_speedup",
           "track_z_after_speedup",
           "line_roll_angle"
@@ -2993,6 +2995,7 @@
         "dgs": [
           "snap_spin_turns",
           "spin_alpha",
+          "peak_drop_pitch_rate",
           "drop_pitch_rate",
           "recovery_rate_delta",
           "end_track_y",

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/data/f3a_f25_schedule.json

@@ -1216,6 +1216,7 @@
         },
         "dgs": [
           "snap_spin_turns",
+          "peak_break_pitch_rate",
           "break_pitch_rate",
           "snap_alpha",
           "recovery_rate_delta",
@@ -1461,6 +1462,7 @@
         "dgs": [
           "snap_spin_turns",
           "spin_alpha",
+          "peak_drop_pitch_rate",
           "drop_pitch_rate",
           "recovery_rate_delta",
           "end_track_y",
@@ -1994,6 +1996,7 @@
         },
         "dgs": [
           "snap_spin_turns",
+          "peak_break_pitch_rate",
           "break_pitch_rate",
           "snap_alpha",
           "recovery_rate_delta"
@@ -4537,6 +4540,7 @@
         },
         "dgs": [
           "snap_spin_turns",
+          "peak_break_pitch_rate",
           "break_pitch_rate",
           "snap_alpha",
           "recovery_rate_delta",
@@ -5218,6 +5222,8 @@
           "length": "(0.5*(line_length-((speed*abs(e_5_rolls[0]))/snap_rate)))"
         },
         "dgs": [
+          "initial_track_y_after_speedup",
+          "initial_track_z_after_speedup",
           "track_y_after_speedup",
           "track_z_after_speedup",
           "line_roll_angle"
@@ -5236,6 +5242,7 @@
         },
         "dgs": [
           "snap_spin_turns",
+          "peak_break_pitch_rate",
           "break_pitch_rate",
           "snap_alpha",
           "recovery_rate_delta",

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/data/f3a_p23_schedule.json

@@ -1510,6 +1510,7 @@
         },
         "dgs": [
           "snap_spin_turns",
+          "peak_break_pitch_rate",
           "break_pitch_rate",
           "snap_alpha",
           "recovery_rate_delta",
@@ -2245,6 +2246,7 @@
         "dgs": [
           "snap_spin_turns",
           "spin_alpha",
+          "peak_drop_pitch_rate",
           "drop_pitch_rate",
           "recovery_rate_delta",
           "end_track_y",
@@ -3395,6 +3397,8 @@
           "length": "line_length"
         },
         "dgs": [
+          "initial_track_y_after_speedup",
+          "initial_track_z_after_speedup",
           "track_y_after_speedup",
           "track_z_after_speedup",
           "line_roll_angle"
@@ -3455,6 +3459,8 @@
           "length": "(0.5*(line_length-((abs(roll_option[1])*30)/partial_roll_rate)))"
         },
         "dgs": [
+          "initial_track_y_after_speedup",
+          "initial_track_z_after_speedup",
           "track_y_after_speedup",
           "track_z_after_speedup",
           "line_roll_angle"

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/data/f3a_p25_schedule.json

@@ -1908,6 +1908,8 @@
           "length": "(0.5*(180-((abs(e_3_rolls[0])*speed)/partial_roll_rate)))"
         },
         "dgs": [
+          "initial_track_y_after_speedup",
+          "initial_track_z_after_speedup",
           "track_y_after_speedup",
           "track_z_after_speedup",
           "line_roll_angle"
@@ -3983,6 +3985,7 @@
         "dgs": [
           "snap_spin_turns",
           "spin_alpha",
+          "peak_drop_pitch_rate",
           "drop_pitch_rate",
           "recovery_rate_delta",
           "end_track_y",
@@ -4885,6 +4888,7 @@
         },
         "dgs": [
           "snap_spin_turns",
+          "peak_break_pitch_rate",
           "break_pitch_rate",
           "snap_alpha",
           "recovery_rate_delta",

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/data/f3auk_clubman_schedule.json

@@ -1564,6 +1564,8 @@
           "length": "line_length"
         },
         "dgs": [
+          "initial_track_y_after_speedup",
+          "initial_track_z_after_speedup",
           "track_y_after_speedup",
           "track_z_after_speedup",
           "line_roll_angle"
@@ -2704,6 +2706,7 @@
         "dgs": [
           "snap_spin_turns",
           "spin_alpha",
+          "peak_drop_pitch_rate",
           "drop_pitch_rate",
           "recovery_rate_delta",
           "end_track_y",

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/data/f3auk_inter_schedule.json

@@ -2700,6 +2700,7 @@
         "dgs": [
           "snap_spin_turns",
           "spin_alpha",
+          "peak_drop_pitch_rate",
           "drop_pitch_rate",
           "recovery_rate_delta",
           "end_track_y",

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/definition/scheddef.py

@@ -51,7 +51,7 @@ class SchedDef(Collection):
     def load(name: Union[str,ScheduleInfo]) -> Self:
         sinfo = ScheduleInfo.from_str(name) if isinstance(name, str) else name 
             
-        return SchedDef.from_dict(get_json_resource(f"{str(sinfo).lower()}_schedule"))
+        return SchedDef.from_dict(get_json_resource(f"{str(sinfo).lower()}_schedule.json"))
     
 
     def plot(self):

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/elements/line.py

@@ -48,9 +48,6 @@ class Line(Element):
             speed=abs(flown.vel).mean()
         )
 
-    @staticmethod
-    def from_roll(speed: float, rate: float, angle: float) -> Line:
-        return Line(speed, rate * angle * speed, angle )
 
     def copy_direction(self, other) -> Line:
         return self.set_parms(roll=abs(self.roll) * np.sign(other.roll))

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/scoring/criteria/__init__.py

@@ -1,9 +1,9 @@
 from .exponential import Exponential, free
 from .criteria import Criteria
-from .intra.single import Single, Limit
-from .intra.peak import Peak
+from .intra.single import Single, Limit, Threshold
+from .intra.peak import Peak, Trough
 from .intra.continuous import Continuous, ContinuousValue
-from .intra.bounded import MaxBound, MinBound, InsideBound, OutsideBound, Bounded
+from .intra.bounded import Bounded
 from .inter.comparison import Comparison
 from .inter.combination import Combination
 

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/scoring/criteria/criteria.py

@@ -39,10 +39,12 @@ class Criteria:
     
     def to_py(self):
         _so = f"{self.__class__.__name__}(Exponential({self.lookup.factor},{self.lookup.exponent}, {self.lookup.limit} )"
-        if hasattr(self, 'bound'):
-            _so = f"{_so}, {self.bound}"
-        if hasattr(self, 'cutoff'):
-            _so = f"{_so}, {self.cutoff}"
+        if hasattr(self, 'min_bound'):
+            _so = f"{_so}, min_bound={self.min_bound}"
+        if hasattr(self, 'min_bound'):
+            _so = f"{_so}, max_bound={self.max_bound}"
+        if hasattr(self, 'limit'):
+            _so = f"{_so}, limit={self.limit}"
         return _so + ')'
     
         

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/scoring/criteria/exponential.py

@@ -13,6 +13,10 @@ class Exponential:
         val = self.factor * value**self.exponent
         return np.minimum(val, self.limit) if self.limit and limits else val
 
+    @property
+    def error_limit(self):
+        return (self.limit / self.factor) ** (1 / self.exponent)
+
     @staticmethod
     def linear(factor: float):
         return Exponential(factor, 1)

flightanalysis-0.3.2/flightanalysis/scoring/criteria/f3a_criteria.py

@@ -0,0 +1,84 @@
+from flightanalysis.scoring.criteria import (
+    Single,
+    Limit,
+    Threshold,
+    Peak, Trough,
+    Exponential,
+    Continuous,
+    ContinuousValue,
+    Bounded,
+    Comparison,
+    free,
+)
+import numpy as np
+
+
+class F3AIntra:
+    angle = Single(Exponential.fit_points(np.radians([30, 90]), [2, 6], 6))
+    end_track = Single(Exponential.fit_points(np.radians([30, 90]), [2, 6], 6))
+    end_roll = Single(Exponential.fit_points(np.radians([30, 90]), [1, 6], 6))
+    track = Continuous(Exponential.fit_points(np.radians([30, 90]), [1.75, 6], 6))
+    roll = Continuous(Exponential.fit_points(np.radians([30, 90]), [1.25, 6], 6))
+    radius = Continuous(Exponential.fit_points([1.5, 3], [0.5, 1], 1))
+    speed = ContinuousValue(Exponential.fit_points([5, 15], [0.03, 0.09], 0.5))
+    roll_rate = Continuous(Exponential.fit_points([1, 3], [0.02, 0.06], 0.5))
+    autorotation_rate = Continuous(Exponential.fit_points([1, 3], [0.02, 0.06], 0.5))
+    stallturn_speed = Limit(Exponential.fit_points([2, 4], [0.05, 0.1], 4), 4)
+    stallturn_width = Peak(Exponential.fit_points([2, 5], [0.25, 1.25], 6), 2)
+    break_pitch_rate = Bounded(Exponential(10, 1, 0.1), 0.6, -0.6)
+    peak_break_pitch_rate = Trough(Exponential(10, 1, 6), limit=0.6)
+    
+    autorotation_alpha = Bounded(
+        Exponential(20, 1, 6), np.radians(7.5), -np.radians(7.5)
+    )
+    pos_autorotation_alpha = Bounded(Exponential(20, 1, 6), np.radians(7.5))
+    neg_autorotation_alpha = Bounded(Exponential(20, 1, 6), None, -np.radians(7.5))
+    drop_pitch_rate = Bounded(Exponential(10, 1, 0.1), 0.2)
+    peak_drop_pitch_rate = Trough(Exponential(10, 1, 6), 0.2)
+    recovery_roll_rate = Bounded(Exponential(1, 1, 0.01), None, 0)
+    box = Bounded(Exponential(10 / np.radians(7.5), 1), -np.radians(60), np.radians(60))
+    depth = Bounded(Exponential.fit_points([20, 40], [0.5, 1]), None, 170)
+
+
+class F3AInter:
+    radius = Comparison(Exponential.fit_points([1, 2], [1, 2], 2))
+    speed = Comparison(free)
+    roll_rate = Comparison(Exponential.fit_points([1, 2], [0.25, 0.5], 1))
+    length = Comparison(Exponential.fit_points([1, 2], [1, 2], 2))
+    free = Comparison(free)
+
+
+class F3A:
+    inter = F3AInter
+    intra = F3AIntra
+
+
+def plot_lookup(lu, v0=0, v1=10):
+    import plotly.express as px
+
+    x = np.linspace(v0, v1, 30)
+    px.line(x=x, y=lu(x)).show()
+
+
+def plot_all(crits):
+    from plotly.subplots import make_subplots
+    import plotly.graph_objects as go
+
+    crits = {k: getattr(crits, k) for k in dir(crits) if not k.startswith("__")}
+    # names = [f'{k}_{cr}' for k, crit in crits.items() for cr in crit.keys()]
+
+    nplots = len(crits)
+    ncols = 7
+    fig = make_subplots(
+        int(np.ceil(nplots / ncols)), ncols, subplot_titles=list(crits.keys())
+    )
+
+    for i, crit in enumerate(crits.values()):
+        fig.add_trace(
+            crit.lookup.trace(showlegend=False), row=1 + i // ncols, col=1 + i % ncols
+        )
+    fig.show()
+
+
+if __name__ == "__main__":
+    plot_all(F3AIntra)

flightanalysis-0.3.2/flightanalysis/scoring/criteria/intra/bounded.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+import numpy as np
+import numpy.typing as npt
+from .. import Criteria
+from dataclasses import dataclass
+
+
+@dataclass
+class Bounded(Criteria):
+    """The bounded criteria downgrades for regions outside of bounds.
+    A single downgrade is applied for each group of values outside the bounds.
+    The ids correspond to the middle value in each group.
+    The downgrade is the average distance from the bound multiplied by the ratio
+    of the group width to the total width and by the average visibility of the group.
+    """
+
+    min_bound: float = None  # values below the min bound will be downgraded
+    max_bound: float = None  # values above the max bound will be downgraded
+
+    def __call__(self, vs: npt.NDArray, limits=True):
+        """each downgrade corresponds to a group of values outside the bounds, ids
+        correspond to the last value in each case"""
+        # sample = self.prepare(vs)
+
+        groups = np.concatenate([[0], np.diff(vs != 0).cumsum()])
+        dgids = np.append(
+            np.arange(len(groups))[1:][np.diff(groups).astype(bool)], len(groups) - 1
+        )
+
+        errors = np.array(
+            [
+                np.mean(vs[groups == grp]) * len(vs[groups == grp]) / len(vs)
+                for grp in set(groups)
+            ]
+        )
+        dgs = self.lookup(np.abs(errors), limits)
+
+        return errors[dgs>0], dgs[dgs>0], dgids[dgs>0]
+
+    def prepare(self, data: npt.NDArray):
+        """prepare the sample for"""
+        oarr = np.zeros_like(data)
+        # below_min = np.maximum(self.min_bound - data, 0) if self.min_bound is not None else np.zeros_like(data)
+        # above_max = np.maximum(data - self.max_bound, 0) if self.max_bound is not None else np.zeros_like(data)
+
+        if self.min_bound is None and self.max_bound is None:
+            raise Exception("Bounds not set.")
+        elif (
+            self.min_bound is not None
+            and self.max_bound is not None
+            and self.min_bound >= self.max_bound
+        ):  # Downgrade values inside the bound.:
+            midbound = (self.max_bound + self.min_bound) / 2
+            b1fail = (data > midbound) & (data < self.min_bound)
+            b0fail = (data <= midbound) & (data > self.max_bound)
+            oarr[b1fail] = self.max_bound - data[b1fail]
+            oarr[b0fail] = data[b0fail] - self.max_bound
+        else:
+            if self.min_bound is not None:  # downgrade below the min bound
+                oarr[data < self.min_bound] = (
+                    self.min_bound - data[data < self.min_bound]
+                )
+
+            if self.max_bound is not None:  # downgrade above the max bound
+                oarr[data > self.max_bound] = (
+                    data[data > self.max_bound] - self.max_bound
+                )
+
+        return oarr

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/scoring/criteria/intra/continuous.py

@@ -13,8 +13,6 @@ class Continuous(Criteria):
     treats each separate increase (peak - trough) as a new error.
     """
 
-    cutoff: int = 4
-
     @staticmethod
     def get_peak_locs(arr, rev=False):
         increasing = np.sign(np.diff(np.abs(arr))) > 0
@@ -68,7 +66,7 @@ class ContinuousValue(Continuous):
     def mistakes(data, peaks, troughs):
         '''All changes are downgraded (peaks and troughs)'''
         values = data[peaks + troughs]
-        return values[:-1] - values[1:]
+        return values[1:] - values[:-1]
     
 
     @staticmethod

flightanalysis-0.3.2/flightanalysis/scoring/criteria/intra/peak.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+import numpy as np
+import numpy.typing as npt
+from dataclasses import dataclass
+from .. import Criteria
+
+
+
+@dataclass
+class Peak(Criteria):
+    limit: float=0
+    """Downgrade the largest absolute value based on its distance above the limit."""
+    def __call__(self, vs: npt.NDArray, limits: bool=True) -> npt.NDArray:
+        idx = np.argmax(vs)
+        errors = np.array([vs[idx]])
+        if errors[0] == 0:
+            return np.array([]), np.array([]), np.array([], dtype=int)
+        else:
+            return errors, self.lookup(errors, limits), np.array([idx])
+    
+    def prepare(self, vs):
+        return np.maximum(np.abs(vs) - self.limit, 0)
+    
+
+@dataclass
+class Trough(Criteria):
+    limit: float=0
+    """Downgrade the largest absolute value based on its distance below the limit."""
+    def __call__(self, vs: npt.NDArray, limits: bool=True) -> npt.NDArray:
+        idx = np.argmin(vs)
+        errors = np.array([vs[idx]])
+        if errors[0] == 0:
+            return np.array([]), np.array([]), np.array([], dtype=int)
+        else:
+            return errors, self.lookup(errors, limits), np.array([idx])
+    
+    def prepare(self, vs):
+        return np.maximum(self.limit - np.abs(vs), 0)

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/scoring/criteria/intra/single.py

@@ -16,11 +16,22 @@ class Single(Criteria):
 
 @dataclass
 class Limit(Criteria):
-    """Downgrade the largest value above a threshold"""
+    """Downgrade based on the distance above a limit"""
     limit: float = 0
-    def __call__(self, vs: npt.NDArray, limits: bool=True) -> np.Any:
-        errors = np.maximum(np.abs(vs) - self.limit, 0)
+    def __call__(self, vs: npt.NDArray, limits: bool=True) -> npt.NDArray:
+        idx = np.arange(len(vs))
+        return vs, self.lookup(vs, limits), idx 
+
+    def prepare(self, vs):
+        return np.maximum(np.abs(vs) - self.limit, 0)
+
+@dataclass
+class Threshold(Criteria):
+    """downgrade based on the distance below the limit"""
+    limit: float = 0
+    def __call__(self, vs: npt.NDArray, limits: bool=False) -> npt.NDArray:
         idx = np.arange(len(vs))
-        return errors, self.lookup(errors, limits), idx 
+        return vs, self.lookup(vs, limits), idx 
 
-    
+    def prepare(self, vs):
+        return np.maximum(self.limit - np.abs(vs), 0)

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/scoring/downgrade.py

@@ -53,7 +53,7 @@ class DownGrade:
     def __call__(self, fl, tp, limits=True) -> Result:
         measurement: Measurement = self.measure(fl, tp)
         
-        sample = visibility(self.criteria.prepare(measurement.value), measurement.visibility, self.criteria.lookup.limit)
+        sample = visibility(self.criteria.prepare(measurement.value), measurement.visibility, self.criteria.lookup.error_limit)
         
         for sm in self.smoothers:
             sample = sm(sample)

{flightanalysis-0.3.0 → flightanalysis-0.3.2}/flightanalysis/scoring/f3a_downgrades.py

@@ -12,41 +12,47 @@ dgs = DownGrades([
     dg("end_track_z", "track_z", Measurement.track_z, None, sels.last(), F3A.intra.end_track),
     dg("end_roll_angle", "roll", Measurement.roll_angle, None, sels.last(), F3A.intra.end_roll),
 
-    dg("speed", "speed", Measurement.speed_value, None, None, F3A.intra.speed),
+    dg("speed", "speed", Measurement.speed_value, sms.lowpass(cutoff=0.5, order=5), None, F3A.intra.speed),
     dg("line_track_y", "track_y", Measurement.track_y, sms.lowpass(cutoff=2, order=5), None, F3A.intra.track),
     dg("line_track_z", "track_z", Measurement.track_z, sms.lowpass(cutoff=2, order=5), None, F3A.intra.track),
     dg("line_roll_angle", "roll", Measurement.roll_angle, sms.lowpass(cutoff=1, order=5), None, F3A.intra.roll),
     dg("roll_rate", "roll_rate", Measurement.roll_rate, sms.lowpass(cutoff=2, order=5), None, F3A.intra.roll_rate),
+
     dg("loop_curvature", "curvature", Measurement.curvature_proj, sms.lowpass(cutoff=0.5, order=5), None, F3A.intra.radius),
     dg("loop_track_y", "track_y", Measurement.track_proj_vel, sms.lowpass(cutoff=2, order=5), None, F3A.intra.track),
     dg("loop_track_z", "track_z", Measurement.track_proj_ang, sms.lowpass(cutoff=2, order=5), sels.last(), F3A.intra.end_track),
     dg("loop_roll_angle", "roll", Measurement.roll_angle_p, sms.lowpass(cutoff=1, order=5), None, F3A.intra.roll),
     dg("rolling_loop_roll_angle", "roll", Measurement.roll_angle_p, None, sels.last(), F3A.intra.roll),
+
     dg("stallturn_width", "width", Measurement.stallturn_width, None, None, F3A.intra.stallturn_width),
-    dg("stallturn_speed", "speed", lambda fl, tp: Measurement.speed_value(fl, tp, g.PZ()), None, sels.first_and_last(), F3A.intra.stallturn_speed),
+    dg("stallturn_speed", "speed", Measurement.vertical_speed, None, sels.first_and_last(), F3A.intra.stallturn_speed),
     dg("stallturn_roll_angle", "roll", Measurement.roll_angle_z, None, None, F3A.intra.roll),
 
     dg("snap_spin_turns", "roll", Measurement.roll_angle_y, None, sels.last(), F3A.intra.end_roll),# correct number of turns performed
-    dg("spin_alpha", "alpha", Measurement.alpha, None, sels.before_recovery(rot=np.pi/4), F3A.intra.autorotation_alpha),#alpha > 7.5 until last 45 degrees of turn
+    dg("spin_alpha", "alpha", Measurement.spin_alpha, None, sels.before_recovery(rot=np.pi/4), F3A.intra.pos_autorotation_alpha),#alpha > 7.5 until last 45 degrees of turn
     dg("drop_pitch_rate", "pitch", Measurement.pitch_down_rate, None, sels.autorot_break(rot=np.radians(15)), F3A.intra.drop_pitch_rate ),#pitch down rate > 0.3 until 15 degree of turn
-    dg("recovery_rate_delta", "recovery", Measurement.delta_p, None, sels.autorot_recovery(rot=np.pi/24), F3A.intra.recovery_roll_rate ),#roll rate reducing in last 45 degrees of turn
+    dg("peak_drop_pitch_rate", "peak_pitch", Measurement.pitch_down_rate, None, sels.autorot_break(rot=np.radians(15)), F3A.intra.peak_drop_pitch_rate ),#pitch down rate > 0.3 until 15 degree of turn
 
+    dg("recovery_rate_delta", "recovery", Measurement.delta_p, None, sels.autorot_recovery(rot=np.pi/24), F3A.intra.recovery_roll_rate ),#roll rate reducing in last 45 degrees of turn
 
     dg("break_pitch_rate", "break", Measurement.pitch_rate, None, sels.autorot_break(rot=np.pi/4), F3A.intra.break_pitch_rate ),
+    dg("peak_break_pitch_rate", "peak_break", Measurement.pitch_rate, None, sels.autorot_break(rot=np.pi/4), F3A.intra.peak_break_pitch_rate ),
     dg("snap_alpha", "alpha", Measurement.alpha, None, sels.autorotation(brot=np.pi/4, rrot=np.pi/2), F3A.intra.autorotation_alpha),#alpha > 7.5
 
-    dg("track_y_before_slowdown", "track_y", Measurement.track_y, sms.lowpass(cutoff=4, order=5), sels.before_slowdown(sp=5), F3A.intra.track),
-    dg("track_z_before_slowdown", "track_z", Measurement.track_z, sms.lowpass(cutoff=4, order=5), sels.before_slowdown(sp=5), F3A.intra.track),
-    dg("pitch_after_slowdown", "pitch", Measurement.pitch_attitude, None, sels.after_slowdown(sp=5), F3A.intra.track),
-    dg("yaw_after_slowdown", "yaw", Measurement.yaw_attitude, None, sels.after_slowdown(sp=5), F3A.intra.track),
+    dg("track_y_before_slowdown", "track_y", Measurement.track_y, sms.lowpass(cutoff=4, order=5), sels.before_slowdown(sp=13), F3A.intra.track),
+    dg("track_z_before_slowdown", "track_z", Measurement.track_z, sms.lowpass(cutoff=4, order=5), sels.before_slowdown(sp=13), F3A.intra.track),
+    dg("pitch_after_slowdown", "pitch", Measurement.pitch_attitude, None, sels.after_slowdown(sp=13), F3A.intra.track),
+    dg("yaw_after_slowdown", "yaw", Measurement.yaw_attitude, None, sels.after_slowdown(sp=13), F3A.intra.track),
 
-    dg("track_y_after_speedup", "track_y", Measurement.track_y, sms.lowpass(cutoff=4, order=5), None, F3A.intra.track),
-    dg("track_z_after_speedup", "track_z", Measurement.track_z, sms.lowpass(cutoff=4, order=5), None, F3A.intra.track),
-    dg("pitch_before_speedup", "pitch", Measurement.pitch_attitude, None, sels.first(), F3A.intra.end_track),
+    dg("track_y_after_speedup", "track_y", Measurement.track_y, sms.lowpass(cutoff=4, order=5), sels.after_speedup(sp=13), F3A.intra.track),
+    dg("track_z_after_speedup", "track_z", Measurement.track_z, sms.lowpass(cutoff=4, order=5), sels.after_speedup(sp=13), F3A.intra.track),
+    dg("initial_track_y_after_speedup", "itrack_y", Measurement.track_y, sms.lowpass(cutoff=4, order=5), [sels.after_speedup(sp=13), sels.first()], F3A.intra.end_track),
+    dg("initial_track_z_after_speedup", "itrack_z", Measurement.track_z, sms.lowpass(cutoff=4, order=5), [sels.after_speedup(sp=13), sels.first()], F3A.intra.end_track),
 
-    dg("end_yaw", "yaw", Measurement.yaw_attitude, None, sels.last(), F3A.intra.end_track),
 
+    dg("pitch_before_speedup", "pitch", Measurement.pitch_attitude, None, sels.first(), F3A.intra.end_track),
 
+    dg("end_yaw", "yaw", Measurement.yaw_attitude, None, sels.last(), F3A.intra.end_track),
 ])
 
 
@@ -57,13 +63,13 @@ class DGGrps:
     roll = DownGrades([dgs.speed, dgs.line_track_y, dgs.line_track_z, dgs.roll_rate, dgs.end_roll_angle])
     loop = DownGrades([dgs.speed, dgs.loop_curvature, dgs.loop_track_y, dgs.loop_track_z, dgs.loop_roll_angle])
     rolling_loop = DownGrades([dgs.speed, dgs.loop_curvature, dgs.loop_track_y, dgs.loop_track_z, dgs.roll_rate, dgs.end_roll_angle])
-    snap = DownGrades([dgs.snap_spin_turns, dgs.break_pitch_rate, dgs.snap_alpha, dgs.recovery_rate_delta, dgs.end_track_y, dgs.end_track_z])
-    first_snap = DownGrades([dgs.snap_spin_turns, dgs.break_pitch_rate, dgs.snap_alpha, dgs.recovery_rate_delta])
+    snap = DownGrades([dgs.snap_spin_turns, dgs.peak_break_pitch_rate, dgs.break_pitch_rate, dgs.snap_alpha, dgs.recovery_rate_delta, dgs.end_track_y, dgs.end_track_z])
+    first_snap = DownGrades([dgs.snap_spin_turns, dgs.peak_break_pitch_rate, dgs.break_pitch_rate, dgs.snap_alpha, dgs.recovery_rate_delta])
     rebound_snap = DownGrades([dgs.snap_spin_turns, dgs.snap_alpha, dgs.recovery_rate_delta, dgs.end_track_y, dgs.end_track_z])
-    spin = DownGrades([dgs.snap_spin_turns, dgs.spin_alpha, dgs.drop_pitch_rate, dgs.recovery_rate_delta, dgs.end_track_y, dgs.end_track_z])
+    spin = DownGrades([dgs.snap_spin_turns, dgs.spin_alpha, dgs.peak_drop_pitch_rate, dgs.drop_pitch_rate, dgs.recovery_rate_delta, dgs.end_track_y, dgs.end_track_z])
     stallturn = DownGrades([dgs.stallturn_width, dgs.stallturn_speed, dgs.stallturn_roll_angle, dgs.end_yaw])
     st_line_before = DownGrades([dgs.track_y_before_slowdown, dgs.track_z_before_slowdown, dgs.line_roll_angle, dgs.pitch_after_slowdown, dgs.yaw_after_slowdown])
-    st_line_after = DownGrades([dgs.track_y_after_speedup, dgs.track_z_after_speedup, dgs.line_roll_angle])  
+    st_line_after = DownGrades([dgs.initial_track_y_after_speedup, dgs.initial_track_z_after_speedup, dgs.track_y_after_speedup, dgs.track_z_after_speedup, dgs.line_roll_angle])  
     sp_line_before = DownGrades([dgs.track_y_before_slowdown, dgs.line_track_z, dgs.line_roll_angle, dgs.yaw_after_slowdown])
     sp_line_after = DownGrades([dgs.line_track_y, dgs.line_track_z, dgs.line_roll_angle])