flightanalysis 0.3.7__tar.gz → 0.3.9__tar.gz

{flightanalysis-0.3.7/flightanalysis.egg-info → flightanalysis-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flightanalysis
-Version: 0.3.7
+Version: 0.3.9
 Summary: A package for analysing flight data
 Author-email: Thomas David <thomasdavid0@gmail.com>
 License: GNU GPL v3
@@ -16,7 +16,7 @@ Requires-Dist: simplejson
 Requires-Dist: loguru
 Requires-Dist: joblib
 Requires-Dist: pfc-geometry>=0.2.11
-Requires-Dist: flightdata>=0.2.19
+Requires-Dist: flightdata>=0.2.20
 Requires-Dist: GitPython
 Requires-Dist: pyperclip
 Requires-Dist: packaging
@@ -29,7 +29,7 @@ Requires-Dist: simplejson; extra == "dev"
 Requires-Dist: loguru; extra == "dev"
 Requires-Dist: joblib; extra == "dev"
 Requires-Dist: pfc-geometry>=0.2.11; extra == "dev"
-Requires-Dist: flightdata>=0.2.19; extra == "dev"
+Requires-Dist: flightdata>=0.2.20; 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.7 → flightanalysis-0.3.9}/create_schedules.py

@@ -6,6 +6,8 @@ from flightanalysis.builders.schedules.f3a_f25 import f25_def
 from flightanalysis.builders.schedules.f3auk_clubman import clubman_def as f3auk_club_def
 from flightanalysis.builders.schedules.f3auk_intermediate import intermediate_def as f3auk_int_def
 from flightanalysis.builders.schedules.baeaglid_intermediate import sdef as baeaglid_intermediate_def
+from flightanalysis.builders.schedules.baeapower_unlimited2024 import sdef as baeapower_unlimited2024_def
+from flightanalysis.builders.schedules.baeapower_advanced2024 import sdef as baeapower_advanced2024_def
 sdefs = {
     'f3a_p23_schedule': p23_def, 
     'f3a_a25_schedule': a25_def, 
@@ -14,7 +16,9 @@ sdefs = {
     #'IMAC_Unlimited2024_schedule': imac_unl2024_def, 
     'f3auk_clubman_schedule': f3auk_club_def, 
     'f3auk_inter_schedule': f3auk_int_def,
-    "baeaglid_intermediate_schedule": baeaglid_intermediate_def
+    "baeaglid_intermediate_schedule": baeaglid_intermediate_def,
+    "baeapower_unlimited2024_schedule": baeapower_unlimited2024_def,
+    "baeapower_advanced2024_schedule": baeapower_advanced2024_def
 }
 
 def create_all():

{flightanalysis-0.3.7 → flightanalysis-0.3.9}/examples/make_manoeuvre.py

@@ -2,30 +2,24 @@ from flightplotting import plotsec, plot_regions
 from flightplotting.traces import axis_rate_trace
 from flightanalysis import (
     ManDef, BoxLocation, Position, Height, Direction, 
-    Orientation, ManInfo, Heading)
+    Orientation, ManInfo, Heading, ManParm, Combination)
 import numpy as np
 from flightanalysis.builders.manbuilder import r, MBTags, c45, centred
 from flightanalysis.builders.f3a.manbuilder import f3amb
+from flightanalysis.builders.IAC.manbuilder import iacmb    
+from flightanalysis.builders.schedules.baeapower_advanced2024 import sdef
 from flightdata import NumpyEncoder
 import plotly.graph_objects as go
 from json import dumps
 import geometry as g
 
-mdef: ManDef = f3amb.create(ManInfo(
-    "half square", "hSqL", k=2, position=Position.END, 
-    start=BoxLocation(Height.TOP, Direction.UPWIND, Orientation.INVERTED),
-    end=BoxLocation(Height.BTM)
-),[
-    f3amb.loop(np.pi/2),
-    f3amb.roll(r(1)),
-    f3amb.loop(np.pi/2), 
-])
+mdef: ManDef = sdef[4]
 
 data = mdef.to_dict()
 print(dumps(data, indent=2, cls=NumpyEncoder))
 mdef = ManDef.from_dict(data)
 
-it = mdef.guess_itrans(170, Heading.RIGHT)
+it = mdef.guess_itrans(600, Heading.RIGHT)
 
 mdef.fit_box(it)
 
@@ -34,9 +28,7 @@ man = mdef.create()
 tp = man.create_template(it)
 
 fig = plot_regions(tp, 'element', span=5)
-fig = plotsec(tp, fig=fig, nmodels=10, scale=5)
-#fig.add_traces(boxtrace())
+fig = plotsec(tp, fig=fig, nmodels=10, scale=20)
+
 fig.show()
 
-#fig = go.Figure(data=axis_rate_trace(tp))
-#fig.show()

flightanalysis-0.3.9/examples/making_elements.py

@@ -0,0 +1,16 @@
+from flightanalysis import Loop, Line, Snap, Elements, Manoeuvre
+import numpy as np
+from flightdata import State
+import geometry as g
+from flightplotting import plotsec
+
+
+man = Manoeuvre(Elements([
+    Line('entry_line', 30, 60, 0),
+    Loop('loop', 30, np.pi, 50, 0, 0),
+    Snap('snap', 30, 60, 1.5*2*np.pi, np.radians(20), np.radians(45), np.radians(45)),
+]), Line('exit_line', 30, 60, 0))
+
+
+tp = man.create_template(State.from_transform(g.Transformation()))
+plotsec(tp, nmodels=10).show()  

{flightanalysis-0.3.7 → flightanalysis-0.3.9}/flightanalysis/analysis/manoeuvre_analysis/basic.py

@@ -23,16 +23,6 @@ class Basic(Analysis):
     def name(self):
         return self.mdef.uid
 
-
-    def to_analysis_dict(self) -> dict:
-        return dict(
-            id=self.id,
-            mdef=self.mdef.to_dict(),
-            flown=self.flown.to_dict(),
-            entry=self.entry.name if self.entry else None,
-            exit=self.exit.name if self.exit else None,
-        )
-
     def run_all(self, optimise_aligment=True, force=False) -> Scored:
         """Run the analysis to the final stage"""
         drs = [r._run(True) for r in self.run()]

{flightanalysis-0.3.7 → flightanalysis-0.3.9}/flightanalysis/analysis/sch_analysis.py

@@ -26,14 +26,14 @@ class ScheduleAnalysis(Collection):
 
         flight = Flight.from_fc_json(data) if flight is None else flight
 
-        info = ScheduleInfo(*fcj["parameters"]["schedule"]).fcj_to_pfc()
+        info = ScheduleInfo(*data["parameters"]["schedule"]).fcj_to_pfc()
         sdef = SchedDef.load(info)
         box = Origin.from_fcjson_parameters(data["parameters"])
 
         state = State.from_flight(flight, box)
 
         state = state.splitter_labels(
-            data["mans"], sdef.uids, t0=fcj["data"][0]["time"] / 1e6
+            data["mans"], sdef.uids, t0=data["data"][0]["time"] / 1e6
         )
 
         heading = Heading.infer(state.get_manoeuvre(sdef[0].uid)[0].att.bearing()[0])
@@ -44,7 +44,7 @@ class ScheduleAnalysis(Collection):
 
             if "fcs_scores" in data and len(data["fcs_scores"]) > 0:
                 st = st.label_els(
-                    list(data["fcs_scores"].values())[-1]["manresults"][i + 1]["els"]
+                    list(data["fcs_scores"])[-1]["manresults"][i + 1]["els"]
                 )
 
             nma = analysis.Basic(
@@ -61,28 +61,27 @@ class ScheduleAnalysis(Collection):
         if not isinstance(data, dict):
             data = load(open(data, "r"))
 
-        sts = data["states"]["data"]
-        entry = Heading.infer(State(sts[data["mans"][0]["start"]]).att.bearing()[0])
-
         mas = []
         for man in data["mans"]:
-            mdef = ManDef.load(ScheduleInfo(**man["sinfo"]), man["name"])
-            if not data["isComp"]:
-                heading = Heading.infer(State(sts[man["start"]]).att.bearing()[0])
-            else:
-                heading = mdef.info.start.direction.wind_swap_heading(entry)
+            mdef = ManDef.load(ScheduleInfo(**man["schedule"]), man["name"])
 
             st = (
-                State.from_dict(sts[man["start"] : man["stop"]])
+                State.from_dict(man["flown"]['data'])
                 .label(manoeuvre=man["name"])
                 .label_els(list(man["history"].values())[-1]["els"])
             )
 
+            if not data["isComp"] or len(mas)==0:
+                heading = Heading.infer(st[0].att.bearing()[0])
+            else:
+                heading = mdef.info.start.direction.wind_swap_heading(mas[0].entry)
+
+
             mas.append(analysis.Basic(man["id"], mdef, st, heading, None))
 
         return ScheduleAnalysis(mas)
 
-    def create_analysis_dict(self, **kwargs) -> dict:
+    def create_analysis_json(self, **kwargs) -> dict:
         pass
 
 

{flightanalysis-0.3.7 → flightanalysis-0.3.9}/flightanalysis/base/utils.py

@@ -11,3 +11,5 @@ def combine_args(names: list[str], *args, **kwargs) -> dict:
         if n in kwargs:
             _kwargs[n] = kwargs[n]
     return _kwargs
+
+

{flightanalysis-0.3.7 → flightanalysis-0.3.9}/flightanalysis/builders/BAeAGlid/manbuilder.py

@@ -2,13 +2,13 @@ import numpy as np
 
 from flightanalysis.definition import ManParm, ManParms
 from flightanalysis.builders.BAeAGlid.criteria import Glider
-from flightanalysis.builders.BAeAGlid.downgrades import dggrps
+from flightanalysis.builders.IAC.downgrades import dg_applicator
 from flightanalysis.builders.BAeAGlid.box import box
 from ..elbuilders import line, loopmaker, rollmaker, spin, stallturn
 from ..manbuilder import ManBuilder
 
 
-f3amb = ManBuilder(
+glidmb = ManBuilder(
     ManParms(
         [
             ManParm("speed", Glider.inter.speed, 45.0, "m/s"),
@@ -104,7 +104,7 @@ f3amb = ManBuilder(
             ),
         ),
     ),
-    dggrps,
+    dg_applicator,
     Glider.inter,
     box
 )

flightanalysis-0.3.9/flightanalysis/builders/IAC/box.py

@@ -0,0 +1,19 @@
+from flightanalysis.scoring.box import RectangularBox
+from flightanalysis.builders.IAC.criteria import IAC
+from flightanalysis.scoring.box import BoxDG
+
+
+unlimited_box = RectangularBox(
+    width=1000,
+    height=1000,
+    depth=1000,
+    distance=200,
+    floor=100,
+    bound_dgs=dict(
+        bottom=BoxDG(IAC.intra.btmbox, "m"),
+        **{
+            direc: BoxDG(IAC.intra.box, "m")
+            for direc in ["top", "left", "right", "front", "back"]
+        }
+    ),
+)

flightanalysis-0.3.9/flightanalysis/builders/IAC/criteria.py

@@ -0,0 +1,84 @@
+from flightanalysis.scoring.criteria import (
+    Single,
+    Limit,
+    Peak, Trough,
+    Exponential,
+    Continuous,
+    ContinuousValue,
+    Bounded,
+    Comparison,
+    free,
+)
+import numpy as np
+
+
+class IACIntra:
+    angle = Single(Exponential.fit_points(np.radians([30, 90]), [3, 9], 10))
+    end_track = Single(Exponential.fit_points(np.radians([30, 90]), [3, 9], 10))
+    end_roll = Single(Exponential.fit_points(np.radians([30, 90]), [2, 9], 10))
+    track = Continuous(Exponential.fit_points(np.radians([30, 90]), [3, 9], 10))
+    roll = Continuous(Exponential.fit_points(np.radians([30, 90]), [2, 9], 10))
+    
+    loopshape = Continuous(Exponential.fit_points([1.5, 3], [0.5, 1], 3))
+    loopsmoothness = ContinuousValue(Exponential.fit_points([1, 2], [0.25, 0.7], 3))
+
+    rollrate = Continuous(Exponential.fit_points([1, 3], [0.2, 0.6], 3))
+    rollsmoothness = ContinuousValue(Exponential.fit_points([1, 2], [0.25, 0.7], 3))
+
+    autorotation_rate = Continuous(Exponential.fit_points([1, 3], [0.02, 0.06], 0.5))
+    stallturn_speed = Limit(Exponential.fit_points([10, 20], [0.5, 1.0], 1), 15)
+    stallturn_width = Peak(Exponential.fit_points([20, 50], [0.25, 1.25], 10), 10)
+    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, 10), np.radians(7.5), -np.radians(7.5))
+    pos_autorotation_alpha = Bounded(Exponential(20, 1, 10), np.radians(7.5))
+    neg_autorotation_alpha = Bounded(Exponential(20, 1, 10), None, -np.radians(7.5))
+    drop_pitch_rate = Bounded(Exponential(10, 1, 0.1), 0.2)
+    peak_drop_pitch_rate = Trough(Exponential(10, 1, 10), 0.2)
+    recovery_roll_rate = Bounded(Exponential(1, 1, 0.01), np.pi * 2, -np.pi*2)
+    box = Bounded(Exponential.fit_points([50, 100], [0.5, 1], 10), 0, None)
+    btmbox = Bounded(Exponential.fit_points([50, 100], [5, 10], 10), 0, None)
+
+class IACInter:
+    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 IAC:
+    inter = IACInter
+    intra = IACIntra
+
+
+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(IACIntra)

flightanalysis-0.3.9/flightanalysis/builders/IAC/downgrades.py

@@ -0,0 +1,79 @@
+from flightanalysis.scoring.measurements import measures, Measurement
+from flightanalysis.scoring.downgrade import DownGrades, dg, DowgradeGroups
+from flightanalysis.scoring.selectors import selectors as sels
+from flightanalysis.scoring.smoothing import smoothers as sms
+from flightanalysis.builders.IAC.criteria import IAC
+import numpy as np
+from flightdata import State
+from flightanalysis.elements import Loop, Line, Snap, Spin, StallTurn
+import geometry as g
+
+#LINES
+#                                   track Y              Track Z
+# if vel is horizontal:             heading attitude     altitude track
+# if vel is not horizontal:         RF Y attitude        RF Z attitude
+
+#LOOPS
+#if axial direction vertical:       axial track
+#if axial direction not vertical:   axial attitude       
+#      if exit vel horizontal:                           exit radial track
+#      if exit vel not horizontal:                       exit radial attitude
+
+
+
+def dg_applicator(el: Loop | Line | Snap | Spin | StallTurn, tp: State, last_kind: object, next_kind: object ):
+    dgs = []
+
+    if el.__class__ is Line:
+        if abs(el.roll) > 0:
+            dgs.append(dg("roll_angle", measures.roll_angle(), None, sels.last(), IAC.intra.end_roll))
+        else:
+            dgs.append(dg("roll_angle", measures.roll_angle(), sms.lowpass(cutoff=1, order=5), None, IAC.intra.roll))
+        if max(tp.pos.z) - min(tp.pos.z) < 1:
+            dgs.append(dg("heading", measures.heading_track(), sms.lowpass(cutoff=2, order=5), None, IAC.intra.track))
+            dgs.append(dg("climb", measures.climb_track(), sms.lowpass(cutoff=2, order=5), None, IAC.intra.track))
+        else:
+            dgs.append(dg("pitch", measures.pitch_attitude(), None, None, IAC.intra.track))
+            dgs.append(dg("yaw", measures.yaw_attitude(), None, None, IAC.intra.track))
+    elif el.__class__ is Loop:
+        dgs.append(dg("roundness", measures.curvature_proj(), sms.curvature_lowpass(order=5), None, IAC.intra.loopshape))
+        dgs.append(dg("smoothness", measures.absolute_curvature_proj(), sms.lowpass(cutoff=2, order=5), sels.borders(tb=0.25), IAC.intra.loopsmoothness))
+        isCircle = g.point.is_parallel(Measurement.get_axial_direction(tp), g.PZ())
+        if isCircle:
+            dgs.append(dg("axial_track", measures.loop_axial_track(), sms.lowpass(cutoff=2, order=5), None, IAC.intra.track))
+        else:
+            dgs.append(dg("axial_attitude", measures.loop_axial_attitude(), sms.lowpass(cutoff=2, order=5), None, IAC.intra.track))
+        if g.point.is_parallel(tp.vel[-1], g.PX()) and not isCircle:
+            dgs.append(dg("radial_track", measures.loop_radial_track(), sms.lowpass(cutoff=2, order=5), sels.last(), IAC.intra.end_track))
+        else:
+            dgs.append(dg("radial_attitude", measures.loop_radial_attitude(), sms.lowpass(cutoff=2, order=5), sels.last(), IAC.intra.end_track))
+        if el.roll == 0:
+            dgs.append(dg("roll_angle", measures.roll_angle_p(), sms.lowpass(cutoff=1, order=5), None, IAC.intra.roll))
+        else:
+            dgs.append(dg("roll_angle", measures.roll_angle_p(), None, sels.last(), IAC.intra.roll))
+    elif el.__class__ is StallTurn:
+        dgs.append(dg("width", measures.stallturn_width(), None, None, IAC.intra.stallturn_width))
+        dgs.append(dg("speed", measures.vertical_speed(), None, sels.first_and_last(), IAC.intra.stallturn_speed))
+        dgs.append(dg("roll_angle", measures.roll_angle_z(), None, None, IAC.intra.roll))
+        dgs.append(dg("end_yaw", measures.yaw_attitude(), None, sels.last(), IAC.intra.end_track))
+    elif el.__class__ is Spin:
+        dgs.append(dg("turns", measures.roll_angle_y(), None, sels.last(), IAC.intra.end_roll))
+        dgs.append(dg("alpha", measures.spin_alpha_iac(), None, sels.before_recovery(rot=np.pi/4), IAC.intra.pos_autorotation_alpha))
+        dgs.append(dg("drop_pitch_rate", measures.pitch_down_rate(), None, sels.autorot_break(rot=np.radians(15)), IAC.intra.drop_pitch_rate ))
+        dgs.append(dg("peak_drop_pitch_rate", measures.pitch_down_rate(), None, sels.autorot_break(rot=np.radians(15)), IAC.intra.peak_drop_pitch_rate ))
+        dgs.append(dg("exit_y_track", measures.loop_radial_track(), None, sels.last(), IAC.intra.end_track))
+        dgs.append(dg("recovery_rate_delta", measures.delta_p(), None, sels.autorot_recovery(rot=np.pi/24), IAC.intra.recovery_roll_rate ))
+    elif el.__class__ is Snap:
+        dgs.append(dg("turns", measures.roll_angle_y(), None, sels.last(), IAC.intra.end_roll))
+        dgs.append(dg("recovery_rate_delta", measures.delta_p(), None, sels.autorot_recovery(rot=np.pi/24), IAC.intra.recovery_roll_rate ))
+        dgs.append(dg("alpha", measures.alpha_iac(), None, sels.autorotation(brot=np.pi/4, rrot=np.pi/2), IAC.intra.autorotation_alpha))
+        if last_kind is not Snap:
+            dgs.append(dg("peak_break_pitch_rate", measures.pitch_rate(), None, sels.autorot_break(rot=np.pi/4), IAC.intra.peak_break_pitch_rate ))
+            dgs.append(dg("break_pitch_rate", measures.pitch_rate(), None, sels.autorot_break(rot=np.pi/4), IAC.intra.break_pitch_rate ))
+    if (el.__class__ is Line or el.__class__ is Loop ):
+        if el.roll > 0:
+            dgs.append(dg("roll_rate", measures.roll_rate(), sms.rollrate_lowpass(order=5), None, IAC.intra.rollrate))
+            dgs.append(dg("roll_smoothness", measures.abs_roll_rate(), sms.lowpass(cutoff=2, order=5), None, IAC.intra.rollsmoothness))
+        
+
+    return DownGrades(dgs)

flightanalysis-0.3.9/flightanalysis/builders/IAC/manbuilder.py

@@ -0,0 +1,116 @@
+import numpy as np
+
+from flightanalysis.definition import ManParm, ManParms
+from flightanalysis.builders.IAC.criteria import IAC
+from flightanalysis.builders.IAC.downgrades import dg_applicator
+from flightanalysis.builders.IAC.box import unlimited_box
+from ..elbuilders import line, loopmaker, rollmaker, spin, stallturn
+from ..manbuilder import ManBuilder
+
+
+_snap_rate = 3*np.pi
+_roll_rate = np.pi
+_spin_rate = np.pi / 2
+_speed = 60
+_break_angle = np.radians(20)
+
+iacmb = ManBuilder(
+    ManParms(
+        [
+            ManParm("speed", IAC.inter.speed, _speed, "m/s"),
+            ManParm("loop_radius", IAC.inter.radius, 70.0, "m"),
+            ManParm("line_length", IAC.inter.length, 180.0, "m"),
+            ManParm("point_length", IAC.inter.length, 20.0, "m"),
+            ManParm("partial_roll_rate", IAC.inter.roll_rate, _roll_rate, "rad/s"),
+            ManParm("full_roll_rate", IAC.inter.roll_rate, _roll_rate, "rad/s"),
+            ManParm("snap_rate", IAC.inter.roll_rate, _snap_rate, "rad/s"),
+            ManParm("stallturn_rate", IAC.inter.roll_rate, np.pi/4, "rad/s"),
+            ManParm("spin_rate", IAC.inter.roll_rate, _spin_rate, "rad/s"),
+            ManParm("ee_pause", IAC.inter.length, 20.0, "m"),
+        ]
+    ),
+    dict(
+        line=dict(
+            func=line,
+            args=[],
+            kwargs=dict(
+                speed=_speed,
+                length=180,
+            ),
+        ),
+        loop=dict(
+            func=loopmaker,
+            args=["angle"],
+            kwargs=dict(
+                speed=40,
+                radius=70,
+                rolls=0.0,
+                ke=False,
+                rollangle=None,
+                rolltypes="roll",
+                reversible=True,
+                pause_length="point_length",
+                break_angle=_break_angle,
+                snap_rate=_snap_rate,
+                break_roll=np.pi / 4,
+                recovery_roll=np.pi / 2,
+                mode="imac",
+            ),
+        ),
+        roll=dict(
+            func=rollmaker,
+            args=["rolls"],
+            kwargs=dict(
+                padded=True,
+                reversible=True,
+                speed=40,
+                line_length=180,
+                partial_rate=_roll_rate,
+                full_rate=_roll_rate,
+                pause_length="point_length",
+                mode="imac",
+                break_angle=_break_angle,
+                snap_rate=_snap_rate,
+                break_roll=np.pi / 4,
+                recovery_roll=np.pi / 2,
+                rolltypes="roll",
+            ),
+        ),
+        stallturn=dict(
+            func=stallturn, args=[], kwargs=dict(speed=0.0, yaw_rate="stallturn_rate")
+        ),
+        snap=dict(
+            func=rollmaker,
+            args=["rolls"],
+            kwargs=dict(
+                padded=True,
+                reversible=True,
+                speed=40,
+                line_length=180,
+                partial_rate=_roll_rate,
+                full_rate=_roll_rate,
+                pause_length="point_length",
+                mode="imac",
+                break_angle=np.radians(20),
+                snap_rate=_snap_rate,
+                break_roll=np.pi / 4,
+                recovery_roll=np.pi / 2,
+                rolltypes="snap",
+            ),
+        ),
+        spin=dict(
+            func=spin,
+            args=["turns"],
+            kwargs=dict(
+                speed=10,
+                break_angle=np.radians(30),
+                rate="spin_rate",
+                nd_turns=np.pi / 4,
+                recovery_turns=np.pi / 2,
+            ),
+        ),
+    ),
+    dg_applicator,
+    IAC.inter,
+    unlimited_box
+)