ENH: add berkeley data

Author: giovaniceotto

docs/notebooks/time_post_process.py

@@ -0,0 +1,111 @@
+import timeit
+from unittest.mock import patch
+
+import numpy as np
+
+from rocketpy import Environment, SolidMotor, Rocket, Flight
+
+Env = Environment(
+    railLength=5.2, latitude=32.990254, longitude=-106.974998, elevation=1400
+)
+Pro75M1670 = SolidMotor(
+    thrustSource="../../data/motors/Cesaroni_M1670.eng",
+    burnOut=3.9,
+    grainNumber=5,
+    grainSeparation=5 / 1000,
+    grainDensity=1815,
+    grainOuterRadius=33 / 1000,
+    grainInitialInnerRadius=15 / 1000,
+    grainInitialHeight=120 / 1000,
+    nozzleRadius=33 / 1000,
+    throatRadius=11 / 1000,
+    interpolationMethod="linear",
+)
+Calisto = Rocket(
+    motor=Pro75M1670,
+    radius=127 / 2000,
+    mass=19.197 - 2.956,
+    inertiaI=6.60,
+    inertiaZ=0.0351,
+    distanceRocketNozzle=-1.255,
+    distanceRocketPropellant=-0.85704,
+    powerOffDrag="../../data/calisto/powerOffDragCurve.csv",
+    powerOnDrag="../../data/calisto/powerOnDragCurve.csv",
+)
+
+Calisto.setRailButtons([0.2, -0.5])
+NoseCone = Calisto.addNose(length=0.55829, kind="vonKarman", distanceToCM=0.71971)
+
+FinSet = Calisto.addTrapezoidalFins(
+    n=4,
+    rootChord=0.120,
+    tipChord=0.040,
+    span=0.100,
+    distanceToCM=-1.04956,
+    cantAngle=0,
+    radius=None,
+    airfoil=None,
+)
+
+Tail = Calisto.addTail(
+    topRadius=0.0635, bottomRadius=0.0435, length=0.060, distanceToCM=-1.194656
+)
+
+
+def drogueTrigger(p, y):
+    # p = pressure
+    # y = [x, y, z, vx, vy, vz, e0, e1, e2, e3, w1, w2, w3]
+    # activate drogue when vz < 0 m/s.
+    return True if y[5] < 0 else False
+
+
+def mainTrigger(p, y):
+    # p = pressure
+    # y = [x, y, z, vx, vy, vz, e0, e1, e2, e3, w1, w2, w3]
+    # activate main when vz < 0 m/s and z < 800 + 1400 m (+1400 due to surface elevation).
+    return True if y[5] < 0 and y[2] < 800 + 1400 else False
+
+
+Main = Calisto.addParachute(
+    "Main",
+    CdS=10.0,
+    trigger=mainTrigger,
+    samplingRate=105,
+    lag=1.5,
+    noise=(0, 8.3, 0.5),
+)
+
+Drogue = Calisto.addParachute(
+    "Drogue",
+    CdS=1.0,
+    trigger=drogueTrigger,
+    samplingRate=105,
+    lag=1.5,
+    noise=(0, 8.3, 0.5),
+)
+
+result = timeit.repeat(
+    "TestFlight = Flight(rocket=Calisto, environment=Env, inclination=85, heading=0)",
+    globals=globals(),
+    number=1,
+    repeat=15,
+)
+result = np.array(result)
+print("Mean: ", result.mean())
+print("Std: ", result.std())
+print("Min: ", np.min(result))
+print("Max: ", np.max(result))
+
+TestFlight = Flight(rocket=Calisto, environment=Env, inclination=85, heading=0)
+result = timeit.repeat(
+    """with patch('matplotlib.pyplot.show') as p, patch('matplotlib.pyplot.figure') as p, patch('matplotlib.pyplot.plot') as p, patch('builtins.print') as pp:
+    TestFlight.allInfo()""",
+    globals=globals(),
+    number=1,
+    repeat=15,
+)
+result = np.array(result)
+print("Mean: ", result.mean())
+print("Std: ", result.std())
+print("Min: ", np.min(result))
+print("Max: ", np.max(result))

rocketpy/Function.py

@@ -626,6 +626,52 @@ def reset(
 
         return self
 
+    # Define transformation methods
+    def crop(self, domain):
+        """This method allows the user to crop a Function object, i.e. to define
+        a new Function object with a smaller domain.
+
+        Parameters
+        ----------
+        domain : list of tuples
+            List of tuples containing the lower and upper bounds of the domain
+            to be cropped. The length of the list must be equal to the domain
+            dimension of the Function object.
+
+        Examples
+        --------
+        >>> from rocketpy import Function
+        >>> f = Function(lambda x: x**2, inputs='x', outputs='y')
+        >>> f
+        Function from R1 to R1 : (x) → (y)
+        >>> f.crop([(-1, 1)])
+
+        Returns
+        -------
+        self : Function
+        """
+        if not isinstance(domain, list):
+            raise TypeError("domain must be a list of tuples.")
+        if len(domain) != self.__domDim__:
+            raise ValueError(
+                "domain must have the same length as the domain dimension."
+            )
+
+        if self.__domDim__ == 1:
+            self.source = self.source[
+                (self.source[:, 0] >= domain[0][0])
+                & (self.source[:, 0] <= domain[0][1])
+            ]
+        elif self.__domDim__ == 2:
+            self.source = self.source[
+                (self.source[:, 0] >= domain[0][0])
+                & (self.source[:, 0] <= domain[0][1])
+                & (self.source[:, 1] >= domain[1][0])
+                & (self.source[:, 1] <= domain[1][1])
+            ]
+
+        return self
+
     # Define all get methods
     def getInputs(self):
         "Return tuple of inputs of the function."
@@ -2227,7 +2273,50 @@ def integral(self, a, b, numerical=False):
                     # self.__extrapolation__ = 'zero'
                     pass
         elif self.__interpolation__ == "linear" and numerical is False:
-            return np.trapz(self.source[:, 1], x=self.source[:, 0])
+            # Integrate from a to b using np.trapz
+            xData = self.source[:, 0]
+            yData = self.source[:, 1]
+            # Get data in interval
+            xData = xData[(xData >= a) & (xData <= b)]
+            yData = yData[(xData >= a) & (xData <= b)]
+            # Check to see if interval starts before point data
+            if a < xData[0]:
+                if self.__extrapolation__ == "constant":
+                    yData = np.append(yData[0], yData)
+                    xData = np.append(a, xData)
+                elif self.__extrapolation__ == "natural":
+                    # Linearly extrapolate first point
+                    yData = np.append(
+                        yData[0]
+                        + (yData[0] - yData[1])
+                        / (xData[1] - xData[0])
+                        * (a - xData[0]),
+                        yData,
+                    )
+                    xData = np.append(a, xData)
+                else:
+                    # self.__extrapolation__ = 'zero'
+                    pass
+            # Check to see if interval ends after point data
+            if b > xData[-1]:
+                if self.__extrapolation__ == "constant":
+                    yData = np.append(yData, yData[-1])
+                    xData = np.append(xData, b)
+                elif self.__extrapolation__ == "natural":
+                    # Linearly extrapolate last point
+                    yData = np.append(
+                        yData,
+                        yData[-1]
+                        + (yData[-1] - yData[-2])
+                        / (xData[-1] - xData[-2])
+                        * (b - xData[-1]),
+                    )
+                    xData = np.append(xData, b)
+                else:
+                    # self.__extrapolation__ = 'zero'
+                    pass
+            # Integrate using np.trapz
+            ans = np.trapz(yData, xData)
         else:
             # Integrate numerically
             ans, _ = integrate.quad(self, a, b, epsabs=0.1, limit=10000)