fmdtools 2.2.1__tar.gz → 2.2.3__tar.gz

{fmdtools-2.2.1 → fmdtools-2.2.3}/LICENSE

@@ -1,4 +1,4 @@
-fmdtools version 2.2.1
+fmdtools version 2.2.3
 ---------------------------
                                  Apache License
                            Version 2.0, January 2004

{fmdtools-2.2.1/fmdtools.egg-info → fmdtools-2.2.3}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: fmdtools
-Version: 2.2.1
+Version: 2.2.3
 Summary: System resilience modelling, simulation, and assessment in Python
 Author: fmdtools Developers
 Maintainer-email: Daniel Hulse <daniel.e.hulse@nasa.gov>
-License: fmdtools version 2.2.1
+License: fmdtools version 2.2.3
         ---------------------------
                                          Apache License
                                    Version 2.0, January 2004
@@ -250,7 +250,7 @@ Requires-Dist: tqdm
 Requires-Dist: networkx
 Requires-Dist: numpy>=2.0
 Requires-Dist: matplotlib>=3.7.0
-Requires-Dist: pandas
+Requires-Dist: pandas[all]
 Requires-Dist: ordered-set
 Requires-Dist: dill
 Requires-Dist: recordclass==0.23.1
@@ -367,7 +367,7 @@ This may then be installed using:
 Note that this version reflects the latest version on the ``main`` git branch along with any local changes. To use a particular version of ``fmdtools`` you can checkout the tag corresponding to the version you want, e.g.:
 
 ```
-   git checkout v2.2.1
+   git checkout v2.2.3
 ```
 
 
@@ -386,7 +386,7 @@ numpy < 2.0
 # license: (BSD) https://numpy.org/doc/stable/license.html
 matplotlib
 # license: (mixed) https://matplotlib.org/stable/users/license.html
-pandas
+pandas[all]
 # license: (BSD 3-clause) https://pandas.pydata.org/pandas-docs/stable/getting_started/overview.html#license
 ordered-set
 # license: (MIT) https://github.com/rspeer/ordered-set/blob/master/MIT-LICENSE
@@ -505,8 +505,8 @@ To cite a particular version of the fmdtools, you may use:
   author = {{NASA}},
   title = {fmdtools},
   url = {https://github.com/nasa/fmdtools},
-  version = {2.2.1},
-  date = {2025-9-30},
+  version = {2.2.3},
+  date = {2025-12-4},
 }
 ```
 

{fmdtools-2.2.1 → fmdtools-2.2.3}/README.md

@@ -106,7 +106,7 @@ This may then be installed using:
 Note that this version reflects the latest version on the ``main`` git branch along with any local changes. To use a particular version of ``fmdtools`` you can checkout the tag corresponding to the version you want, e.g.:
 
 ```
-   git checkout v2.2.1
+   git checkout v2.2.3
 ```
 
 
@@ -125,7 +125,7 @@ numpy < 2.0
 # license: (BSD) https://numpy.org/doc/stable/license.html
 matplotlib
 # license: (mixed) https://matplotlib.org/stable/users/license.html
-pandas
+pandas[all]
 # license: (BSD 3-clause) https://pandas.pydata.org/pandas-docs/stable/getting_started/overview.html#license
 ordered-set
 # license: (MIT) https://github.com/rspeer/ordered-set/blob/master/MIT-LICENSE
@@ -244,8 +244,8 @@ To cite a particular version of the fmdtools, you may use:
   author = {{NASA}},
   title = {fmdtools},
   url = {https://github.com/nasa/fmdtools},
-  version = {2.2.1},
-  date = {2025-9-30},
+  version = {2.2.3},
+  date = {2025-12-4},
 }
 ```
 

{fmdtools-2.2.1 → fmdtools-2.2.3}/examples/eps/eps.py

@@ -35,11 +35,12 @@ from fmdtools.define.container.mode import Mode
 from fmdtools.define.architecture.function import FunctionArchitecture
 from fmdtools.define.container.state import State
 from fmdtools.define.flow.base import Flow
+import numpy as np
 
 
 class GenericState(State):
-    rate: float = 1.0
-    effort: float = 1.0
+    rate: np.float64 = 1.0
+    effort: np.float64 = 1.0
 
 
 class GenericFlow(Flow):
@@ -48,7 +49,7 @@ class GenericFlow(Flow):
 
 
 class SigState(State):
-    value: float = 1.0
+    value: np.float64 = 1.0
 
 
 class Signal(Flow):
@@ -482,14 +483,14 @@ if __name__ == "__main__":
                                            to_return="graph")
 
     result.get_faulty().tend.graph.draw()
-    # endclasses, mdlhists = propagate.single_faults(mdl)
+    # results, hists = propagate.single_faults(mdl)
 
     # resgraph, mdlhists = propagate.one_fault(mdl, 'ee_to_me', 'toohigh_torque', to_return="fxnflowgraph")
     # result.graph.draw()
     ks = [*mdl.get_roles_as_dict("fxn", "flow", flex_prefixes=True)]
 
     summary = mdlhists.get_fault_degradation_summary(*ks)
-    # endclasses, mdlhists = propagate.single_faults(mdl)
+    # results, hists = propagate.single_faults(mdl)
     degradation = mdlhists.get_degraded_hist(*ks)
 
     degtimemap = degradation.get_summary(operator=np.sum)

{fmdtools-2.2.1 → fmdtools-2.2.3}/examples/eps/test_eps.py

@@ -139,4 +139,4 @@ if __name__ == "__main__":
     # mdl_nom = EPS()
     # endresults_nom, resgraph_nom, mdlhist_nom = propagate.nominal(mdl_nom)
 
-    # endclasses, reshists = propagate.single_faults(mdl)
+    # results, hists = propagate.single_faults(mdl)

{fmdtools-2.2.1 → fmdtools-2.2.3}/examples/multiflow_demo/multiflow_demo.py

@@ -24,10 +24,12 @@ from fmdtools.define.flow.multiflow import MultiFlow
 from fmdtools.define.flow.commsflow import CommsFlow
 from fmdtools.define.container.state import State
 
+import numpy as np
+
 
 class LocationState(State):
-    x: float = 0.0
-    y: float = 0.0
+    x: np.float64 = 0.0
+    y: np.float64 = 0.0
 
 
 class Communications(CommsFlow):
@@ -39,8 +41,8 @@ class Location(MultiFlow):
 
 
 class MoveParam(Parameter):
-    x_up: float = 0.0
-    y_up: float = 0.0
+    x_up: np.float64 = 0.0
+    y_up: np.float64 = 0.0
 
 
 class Mover(Function):

{fmdtools-2.2.1 → fmdtools-2.2.3}/examples/multirotor/drone_mdl_dynamic.py

@@ -60,9 +60,9 @@ class DroneEnvironmentGridParam(CoordsParam):
         Type of environment risk profile (urban or rural).
     """
 
-    x_size: int = 16
-    y_size: int = 16
-    blocksize: float = 10.0
+    x_size: np.int32 = 16
+    y_size: np.int32 = 16
+    blocksize: np.float64 = 10.0
     loc: str = 'rural'
 
 
@@ -240,10 +240,10 @@ class PlanPath(Function):
         e.g.::
         >>> p = PlanPath()
         >>> p.des_traj.s
-        DesTrajState(dx=np.float64(1.0), dy=np.float64(0.0), dz=np.float64(0.0), power=np.float64(1.0))
+        DesTrajState(dx=1.0, dy=0.0, dz=0.0, power=1.0)
         >>> p.assign_vectdist_to_goal()
         >>> p.des_traj.s
-        DesTrajState(dx=np.float64(0.0), dy=np.float64(0.0), dz=np.float64(50.0), power=np.float64(1.0))
+        DesTrajState(dx=0.0, dy=0.0, dz=50.0, power=1.0)
         """
         loc = self.dofs.s.get('x', 'y', 'z')
         vd = vectdist(self.s.goal, loc)
@@ -354,13 +354,13 @@ class AffectDOF(AffectDOFStatic):
         >>> a.dofs.s.put(x=0.0, y=0.0, z=100.0, planvel=1.0, vertvel=0.0)
         >>> a.inc_pos()
         >>> a.dofs.s
-        DOFstate(vertvel=np.float64(0.0), planvel=np.float64(1.0), planpwr=np.float64(1.0), uppwr=np.float64(1.0), x=np.float64(1.0), y=np.float64(0.0), z=np.float64(100.0))
+        DOFstate(vertvel=0.0, planvel=1.0, planpwr=1.0, uppwr=1.0, x=1.0, y=0.0, z=100.0)
 
         or, for climbing::
         >>> a.dofs.s.put(vertvel=1.0, planvel=0.0)
         >>> a.inc_pos()
         >>> a.dofs.s
-        DOFstate(vertvel=np.float64(1.0), planvel=np.float64(0.0), planpwr=np.float64(1.0), uppwr=np.float64(1.0), x=np.float64(1.0), y=np.float64(0.0), z=np.float64(101.0))
+        DOFstate(vertvel=1.0, planvel=0.0, planpwr=1.0, uppwr=1.0, x=1.0, y=0.0, z=101.0)
         """
         # increment x,y,z
         vec_factor = self.des_traj.s.dist2d()
@@ -428,7 +428,7 @@ class Drone(FunctionArchitecture):
 
         Returns
         -------
-        endclass : dict
+        result : dict
             Rate, cost, and expected cost for scenario.
         """
         if -5 > self.h.flows.dofs.s.x[-1] or 5 < self.h.flows.dofs.s.x[-1]:
@@ -439,7 +439,7 @@ class Drone(FunctionArchitecture):
             lostcost = 50000
         else:
             lostcost = 0
-        a = 1
+
         if any(self.h.fxns.hold_payload.m.faults['break']):
             crashcost = 100000
         else:
@@ -451,7 +451,8 @@ class Drone(FunctionArchitecture):
         totcost = repcost + crashcost + lostcost
         rate = scen.rate
         expcost = totcost*rate*1e5
-        return {'rate': rate, 'cost': totcost, 'expected_cost': expcost}
+        return {'rate': rate, 'cost': totcost, 'expected_cost': expcost,
+                'lost_cost': lostcost, 'crashcost': crashcost}
 
 
 def finddist(p1, p2):

{fmdtools-2.2.1 → fmdtools-2.2.3}/examples/multirotor/drone_mdl_hierarchical.py

@@ -16,7 +16,7 @@ under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 CONDITIONS OF ANY KIND, either express or implied. See the License for the
 specific language governing permissions and limitations under the License.
 """
-from examples.multirotor.drone_mdl_static import m2to1, DistEE, BaseLine
+from examples.multirotor.drone_mdl_static import m2to1, DistEE, BaseLine, ControlState
 from examples.multirotor.drone_mdl_static import Force, EE, Control, DOFs, DesTraj
 from examples.multirotor.drone_mdl_static import AffectDOFMode, AffectDOFState
 from examples.multirotor.drone_mdl_dynamic import StoreEE, CtlDOF, PlanPath, HoldPayload
@@ -25,16 +25,15 @@ from examples.multirotor.drone_mdl_dynamic import Drone as DynDrone
 from examples.multirotor.drone_mdl_dynamic import AffectDOF as AffectDOFDynamic
 
 from fmdtools.define.container.parameter import Parameter
-from fmdtools.define.container.state import State
 from fmdtools.define.block.component import Component
 from fmdtools.define.architecture.component import ComponentArchitecture
-from fmdtools.define.architecture.function import FunctionArchitecture
+from fmdtools.define.flow.multiflow import MultiFlow
 
 import fmdtools.sim as fs
 
 import numpy as np
 
-class OverallAffectDOFState(State):
+class OverallAffectDOFState(AffectDOFState):
     """
     Overall states for the multirotor AffectDOF architecture.
 
@@ -48,9 +47,8 @@ class OverallAffectDOFState(State):
         Amplification factor (for fault recovery)
     """
 
-    lrstab: float = 0.0
-    frstab: float = 0.0
-    amp_factor: float = 1.0
+    lrstab: np.float64 = 0.0
+    frstab: np.float64 = 0.0
 
 
 class LineArchParam(Parameter):
@@ -117,144 +115,194 @@ class LineArchParam(Parameter):
                                     lr_dict=lr_dict, fr_dict=fr_dict, opposite=opposite)
         super().__init__(*args, strict_immutability=False)
 
-class LineArchState(State):
-    """
-    States of the line architecture.
+    def get_forward_factors(self):
+        if self.archtype == 'quad':
+            return {'rf': 0.5, 'lf': 0.5, 'lr': -0.5, 'rr': -0.5}
+        elif self.archtype == 'hex':
+            return {'rf': 0.5, 'lf': 0.5, 'lr': -0.5, 'rr': -0.5, 'r': -0.75, 'f': 0.75}
+        elif self.archtype == 'oct':
+            return {'rf': 0.5, 'lf': 0.5, 'lr': -0.5, 'rr': -0.5,
+                    'rf2': 0.5, 'lf2': 0.5, 'lr2': -0.5, 'rr2': -0.5}
 
-    Fields
-    ------
-    forward : dict
-        Correction factors for moving forward (based on which rotors are in front).
-    upward: dict
-        Correction factors for moving upward (1.0 unless in a recovery mode).
-    """
-    forward: dict = dict()
-    upward: dict = dict()
+
+class MultiControl(MultiFlow):
+    container_s = ControlState
 
 
 class AffectDOFArch(ComponentArchitecture):
+    """
+    Drone line architecture (quad/hex/octorotor).
+
+    Architecture reconfigures rotors when a fault is present, see:
+
+    Examples
+    --------
+    >>> adf = AffectDOFArch()
+    >>> adf.flows['ctl_in'].s.put(forward=1.0, upward=1.0)
+    >>> adf.static_behavior()
+    >>> adf.flows['ctl']
+    ctl MultiControl
+    - s=ControlState(forward=1.0, upward=1.0)
+    LOCALS:
+    - lf=(s=(forward=0.5, upward=1.0))
+    - lf_factors=(s=(forward=0.5, upward=1.0))
+    - lr=(s=(forward=-0.5, upward=1.0))
+    - lr_factors=(s=(forward=-0.5, upward=1.0))
+    - rf=(s=(forward=0.5, upward=1.0))
+    - rf_factors=(s=(forward=0.5, upward=1.0))
+    - rr=(s=(forward=-0.5, upward=1.0))
+    - rr_factors=(s=(forward=-0.5, upward=1.0))
+    >>> adf.comps['lf'].m.add_fault("mechbreak") # if one is broken, should adjust ctl
+    >>> adf.static_behavior()
+    >>> adf.flows['ctl']
+    ctl MultiControl
+    - s=ControlState(forward=1.0, upward=1.0)
+    LOCALS:
+    - lf=(s=(forward=0.0, upward=0.0))
+    - lf_factors=(s=(forward=0.0, upward=0.0))
+    - lr=(s=(forward=-1.0, upward=2.0))
+    - lr_factors=(s=(forward=-1.0, upward=2.0))
+    - rf=(s=(forward=1.0, upward=2.0))
+    - rf_factors=(s=(forward=1.0, upward=2.0))
+    - rr=(s=(forward=0.0, upward=0.0))
+    - rr_factors=(s=(forward=0.0, upward=0.0))
+    """
+
     container_p = LineArchParam
-    container_s = LineArchState
 
     def init_architecture(self, **kwargs):
-        # add lines
-        for compname in self.p.components:
-            self.add_comp(compname, Line)
+        self.add_flow("ee_in", EE)
+        self.add_flow("force", Force)
+        self.add_flow("ctl_in", Control)
+        self.add_flow("ctl", MultiControl)
         # add state configuration - relative throttle for each line
-        if self.p.archtype == 'quad':
-            self.s.forward.update({'rf': 0.5, 'lf': 0.5, 'lr': -0.5, 'rr': -0.5})
-        elif self.p.archtype == 'hex':
-            self.s.forward.update({'rf': 0.5, 'lf': 0.5, 'lr': -0.5,
-                                   'rr': -0.5, 'r': -0.75, 'f': 0.75})
-        elif self.p.archtype == 'oct':
-            self.s.forward.update({'rf': 0.5, 'lf': 0.5, 'lr': -0.5, 'rr': -0.5,
-                                   'rf2': 0.5, 'lf2': 0.5, 'lr2': -0.5, 'rr2': -0.5})
-        self.s.upward = {c: 1.0 for c in self.p.components}
+        forward = self.p.get_forward_factors()
+        # add lines
+        for cname in self.p.components:
+            self.add_comp(cname, Line, 'ee_in', 'ctl', 'force')
+            s={'forward': forward[cname], 'upward': 1.0}
+            self.flows['ctl'].create_local(cname+"_factors", s=s)
+
+    def static_behavior(self):
+        """Trigger reconfiguration during static behavior step."""
+        if self.p.opposite and self.get_faults(with_base_faults=False):
+            self.reconfig_faults()
+        self.send_local_control_signals()
+
+    def send_local_control_signals(self):
+        """Calc and send local control signals to lines."""
+        for cname in self.comps:
+            ctl = self.flows['ctl'].get_view(cname)
+            facts = self.flows['ctl'].get_view(cname+"_factors")
+            ctl.s.put(forward=facts.s.forward*self.flows['ctl_in'].s.forward,
+                      upward=facts.s.upward*self.flows['ctl_in'].s.upward)
+
+    def reconfig_faults(self):
+        """
+        Correct for individual line faultmodes.
+
+        Turns off the opposite rotor and upping the throttle (amp_factor).
+        """
+        empty_comps = [c for c, comp in self.comps.items()
+                       if comp.m.faults or self.comps[self.p.opposite[c]].m.faults]
+        num_remaining = len(self.comps)-len(empty_comps)
+        if num_remaining:
+            amp_factor = len(self.comps)/num_remaining
+        else:
+            amp_factor = 0.0
+        forward = self.p.get_forward_factors()
+        for cname, comp in self.comps.items():
+            if cname in empty_comps:
+                new_facts = dict(forward=0.0, upward=0.0)
+            else:
+                new_facts = dict(forward=forward[cname]*amp_factor, upward=amp_factor)
+            self.flows['ctl'].get_view(cname+'_factors').s.put(**new_facts)
 
 
 class AffectDOF(AffectDOFDynamic):
-    """Rotor locomotion (multi-component extension)."""
+    """
+    Multirotor locomotion (multi-component extension).
 
-    container_s = OverallAffectDOFState
-    arch_ca = AffectDOFArch
+    Each rotor is simulated individually, producing current and air values that are
+    aggregated in the power output calculation.
 
-    def static_behavior(self):
-        """Rotor dynamic behavior with architecture-base recovery."""
-        if self.ca.p.opposite:
-            self.reconfig_faults()
-        self.calc_pwr()
+    Examples
+    --------
+    >>> a = AffectDOF()
+    >>> a.dofs.s.put(z=100.0)
+    >>> a.ctl_in.s.put(forward=0.0, upward=1.0) # ascent - only going up
+    >>> a.ca() # simulate component arch
+    >>> a.calc_pwr()
+    >>> a.dofs.s
+    DOFstate(vertvel=1.0, planvel=1.0, planpwr=-0.0, uppwr=1.0, x=0.0, y=0.0, z=100.0)
+    >>> a.ctl_in.s.put(forward=1.0, upward=1.0) # ascent and forward flight - both
+    >>> a.ca() # simulate component arch
+    >>> a.calc_pwr()
+    >>> a.dofs.s
+    DOFstate(vertvel=1.0, planvel=1.0, planpwr=1.0, uppwr=1.0, x=0.0, y=0.0, z=100.0)
+    """
 
-    def reconfig_faults(self):
-        """Corrects for individual line faultmodes by turning off the opposite rotor
-        and upping the throttle (amp_factor)"""
-        if self.get_faults(with_base_faults=False, only_present=True):
-            for cname, comp in self.ca.comps.items():
-                if comp.m.faults:
-                    oname = self.ca.p.opposite[cname]
-                    if self.ca.s.forward[cname] != 0.0:
-                        self.ca.s.forward[cname] = 0.0
-                        self.ca.s.upward[cname] = 0.0
-                    if self.ca.s.forward[oname] != 0.0:
-                        self.ca.s.forward[oname] = 0.0
-                        self.ca.s.upward[oname] = 0.0
-        tot_comps = len(self.ca.comps)
-        empty_comps = len([c for c in self.ca.s.forward if self.ca.s.forward[c] == 0.0])
-        try:
-            self.s.amp_factor = tot_comps / (tot_comps - empty_comps)
-        except ZeroDivisionError:
-            self.s.amp_factor = 1.0
+    container_s = OverallAffectDOFState
+    arch_ca = AffectDOFArch
 
     def calc_pwr(self):
         """
-        Calculates overall power and stability based on individual rotor output.
-
-        e.g., ::
-        >>> a = AffectDOF()
-        >>> a.dofs.s.put(z=100.0)
-        >>> a.ctl_in.s.put(forward=0.0, upward=1.0)
-        >>> a.calc_pwr()
-        >>> a.dofs.s
-        DOFstate(vertvel=np.float64(1.0), planvel=np.float64(1.0), planpwr=np.float64(-0.0), uppwr=np.float64(1.0), x=np.float64(0.0), y=np.float64(0.0), z=np.float64(100.0))
-        >>> a.ctl_in.s.put(forward=1.0, upward=1.0)
-        >>> a.calc_pwr()
-        >>> a.dofs.s
-        DOFstate(vertvel=np.float64(1.0), planvel=np.float64(1.0), planpwr=np.float64(1.0), uppwr=np.float64(1.0), x=np.float64(0.0), y=np.float64(0.0), z=np.float64(100.0))
+        Calculate overall power and stability based on individual rotor output.
+
+        Aggregates current and air from contained component architecture lines to
+        calculate high-level output to dofs.
         """
-        air, ee_in = {}, {}
-        # injects faults into lines
-        for linname, lin in self.ca.comps.items():
-            a, ee = lin.behavior(self.ee_in.s.effort,
-                                 self.ctl_in,
-                                 self.ca.s.upward[linname] * self.s.amp_factor,
-                                 self.ca.s.forward[linname] * self.s.amp_factor,
-                                 self.force.s.support)
-            air[lin.name] = a
-            ee_in[lin.name] = ee
-
-        if any(value >= 10 for value in ee_in.values()):
+        over_state = self.s.mul("e_to", "e_ti", "ct", "mt", "pt")
+        airs = {cname: c.s.air for cname, c in self.ca.comps.items()}
+        currents = {cname: c.ee.s.rate for cname, c in self.ca.comps.items()}
+
+        if any(value >= 10 for value in currents.values()):
             self.ee_in.s.rate = 10
-        elif any(value != 0.0 for value in ee_in.values()):
-            self.ee_in.s.rate = sum(ee_in.values()) / \
-                len(ee_in)  # should it really be max?
+        elif any(value != 0.0 for value in currents.values()):
+            self.ee_in.s.rate = sum(currents.values()) / len(currents)  # should it really be max?
         else:
             self.ee_in.s.rate = 0.0
 
-        self.s.lrstab = (sum([air[comp] for comp in self.ca.p.lr_dict['l']]) -
-                         sum([air[comp] for comp in self.ca.p.lr_dict['r']]))/len(air)
-        self.s.frstab = (sum([air[comp] for comp in self.ca.p.fr_dict['r']]) -
-                         sum([air[comp] for comp in self.ca.p.fr_dict['f']]))/len(air)
+        self.s.lrstab = (sum([airs[comp] for comp in self.ca.p.lr_dict['l']]) -
+                         sum([airs[comp] for comp in self.ca.p.lr_dict['r']]))/len(airs)
+        self.s.frstab = (sum([airs[comp] for comp in self.ca.p.fr_dict['r']]) -
+                         sum([airs[comp] for comp in self.ca.p.fr_dict['f']]))/len(airs)
         if abs(self.s.lrstab) >= 0.4 or abs(self.s.frstab) >= 0.75:
             self.dofs.s.put(uppwr=0.0, planpwr=0.0)
         else:
-            airs = list(air.values())
-            self.dofs.s.uppwr = np.mean(airs)
-            self.dofs.s.planpwr = -2*self.s.frstab
+            self.dofs.s.uppwr = np.mean(list(airs.values())) * over_state
+            self.dofs.s.planpwr = -2*self.s.frstab * over_state
+
 
+class LineState(AffectDOFState):
+    """AffectDOFState with air output for individual rotor."""
+
+    air : np.float64 = 0.0
 
 class Line(Component, BaseLine):
     """Individual version of a line (extends BaseLine in static model)."""
 
-    container_s = AffectDOFState
+    container_s = LineState
     container_m = AffectDOFMode
+    flow_ee_in = EE
+    flow_ee = EE
+    flow_ctl = MultiControl
+    flow_force = Force
+
+    def init_block(self, **kwargs):
+        self.ctl = self.ctl.create_local(self.name)
 
-    def behavior(self, ee_in, ctlin, u_fact, f_fact, force):
-        """Calculate air, ee out based on inputs and modes."""
-        if force <= 0.0:
+    def static_behavior(self):
+        if self.force.s.support <= 0.0:
             self.m.add_fault('mechbreak', 'propbreak')
-        elif force <= 0.5:
+        elif self.force.s.support <= 0.5:
             self.m.add_fault('mechfriction')
-
         self.calc_faults()
-
-        pwr = ctlin.s.upward * u_fact + ctlin.s.forward * f_fact
-        airout = m2to1([ee_in,
-                        self.s.e_ti,
-                        pwr,
-                        self.s.ct,
-                        self.s.mt,
-                        self.s.pt])
-        ee_in = m2to1([ee_in, self.s.e_to, pwr])
-        return airout, ee_in
+        pwr = self.ctl.s.upward + self.ctl.s.forward
+        self.ee.s.effort = self.ee_in.s.effort
+        self.ee.s.rate = m2to1([self.ee_in.s.effort, self.s.e_to, pwr])
+        self.s.air = m2to1([self.ee_in.s.effort, self.s.e_ti, pwr, self.s.ct, self.s.mt,
+                            self.s.pt])
 
 
 class DroneParam(Parameter, readonly=True):
@@ -303,11 +351,11 @@ if __name__ == "__main__":
 
     # check rf_mechbreack fault propagation in quad architecture:
     hierarchical_model = Drone(p=DroneParam(arch='quad'))
-    # endclass, mdlhist = fs.propagate.one_fault(hierarchical_model,
-    #                                            'affect_dof.ca.comps.rf',
-    #                                            'mechbreak',
-    #                                            time=5)
-    # mdlhist.plot_line('flows.dofs.s.x', 'flows.dofs.s.y', 'flows.dofs.s.z', 'fxns.store_ee.s.soc')
+    result, mdlhist = fs.propagate.one_fault(hierarchical_model,
+                                             'affect_dof.ca.comps.rf',
+                                             'mechbreak',
+                                             time=5)
+    mdlhist.plot_line('flows.dofs.s.x', 'flows.dofs.s.y', 'flows.dofs.s.z', 'fxns.store_ee.s.soc')
 
     # check rr2_propstuck fault in oct architecture over several times:
     mdl = Drone(p=DroneParam(arch='oct'))