How to use the rocketpy.Function.Function function in rocketpy
To help you get started, we’ve selected a few rocketpy examples, based on popular ways it is used in public projects.
Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
giovaniceotto / RocketPy / rocketpy / Environment.py View on Github 
outputs="Wind Direction (Deg True)",
interpolation="linear",
)
self.windHeading = Function(
data_array[:, (1, 5)],
inputs="Height Above Sea Level (m)",
outputs="Wind Heading (Deg True)",
interpolation="linear",
)
self.windSpeed = Function(
data_array[:, (1, 7)],
inputs="Height Above Sea Level (m)",
outputs="Wind Speed (m/s)",
interpolation="linear",
)
self.windVelocityX = Function(
data_array[:, (1, 3)],
inputs="Height Above Sea Level (m)",
outputs="Wind Velocity X (m/s)",
interpolation="linear",
)
self.windVelocityY = Function(
data_array[:, (1, 4)],
inputs="Height Above Sea Level (m)",
outputs="Wind Velocity Y (m/s)",
interpolation="linear",
)
# Retrieve station elevation from station info
station_elevation_text = station_info.split("\n")[6]
# Convert station elevation text into float valueTb = temperature[layer]
Pb = pressure[layer]
B = beta[layer]
# Compute presure
if B != 0:
P = Pb * (1 + (B / Tb) * (H - Hb)) ** (-g / (B * R))
else:
T = Tb + B * (H - Hb)
P = Pb * np.exp(-(H - Hb) * (g / (R * T)))
# Return answer
return P
# Save international standard atmosphere pressure profile
self.pressureISA = Function(
pressure_function,
inputs="Height Above Sea Level (m)",
outputs="Pressure (Pa)",
)
return Noneoutputs="Temperature (K)",
interpolation="linear",
)
self.windDirection = Function(
data_array[:, (1, 6)],
inputs="Height Above Sea Level (m)",
outputs="Wind Direction (Deg True)",
interpolation="linear",
)
self.windHeading = Function(
data_array[:, (1, 5)],
inputs="Height Above Sea Level (m)",
outputs="Wind Heading (Deg True)",
interpolation="linear",
)
self.windSpeed = Function(
data_array[:, (1, 7)],
inputs="Height Above Sea Level (m)",
outputs="Wind Speed (m/s)",
interpolation="linear",
)
self.windVelocityX = Function(
data_array[:, (1, 3)],
inputs="Height Above Sea Level (m)",
outputs="Wind Velocity X (m/s)",
interpolation="linear",
)
self.windVelocityY = Function(
data_array[:, (1, 4)],
inputs="Height Above Sea Level (m)",
outputs="Wind Velocity Y (m/s)",
interpolation="linear",A Function object which gives the result of other(x)**self(x).
"""
# Check if Function object source is array and other is float
if isinstance(other, (float, int, complex)):
if isinstance(self.source, np.ndarray):
# Operate on grid values
Ys = other ** self.source[:, 1]
Xs = self.source[:, 0]
source = np.concatenate(([Xs], [Ys])).transpose()
# Retrieve inputs, outputs and interpolation
inputs = self.__inputs__[:]
outputs = str(other) + "**" + self.__outputs__[0]
outputs = "(" + outputs + ")"
interpolation = self.__interpolation__
# Create new Function object
return Function(source, inputs, outputs, interpolation)
else:
return Function(lambda x: (other ** self.getValue(x)))
# Or if it is just a callable
elif callable(other):
return Function(lambda x: (other(x) ** self.getValue(x)))
level in meters and return a corresponding wind-v in m/s.
Return
------
None
"""
# Intialize a estimage of maximum expected atmospheric model height
maxExpectedHeight = 1000
# Save pressure profile
if pressure is None:
# Use standard atmosphere
self.pressure = self.pressureISA
else:
# Use costum input
self.pressure = Function(
pressure,
inputs="Height Above Sea Level (m)",
outputs="Pressure (Pa)",
interpolation="linear",
)
# Check maximum height of costum pressure input
if not callable(self.pressure.source):
maxExpectedHeight = max(self.pressure[-1, 0], maxExpectedHeight)
# Save temperature profile
if temperature is None:
# Use standard atmosphere
self.temperature = self.temperatureISA
else:
self.temperature = Function(
temperature,# Operate on grid values
Ys = other * self.source[:, 1]
Xs = self.source[:, 0]
source = np.concatenate(([Xs], [Ys])).transpose()
# Retrieve inputs, outputs and interpolation
inputs = self.__inputs__[:]
outputs = str(other) + "*" + self.__outputs__[0]
outputs = "(" + outputs + ")"
interpolation = self.__interpolation__
# Create new Function object
return Function(source, inputs, outputs, interpolation)
else:
return Function(lambda x: (other * self.getValue(x)))
# Or if it is just a callable
elif callable(other):
return Function(lambda x: (other(x) * self.getValue(x)))and isinstance(self.source, np.ndarray)
and self.__interpolation__ == other.__interpolation__
and self.__inputs__ == other.__inputs__
and np.any(self.source[:, 0] - other.source[:, 0]) == False
):
# Operate on grid values
Ys = self.source[:, 1] - other.source[:, 1]
Xs = self.source[:, 0]
source = np.concatenate(([Xs], [Ys])).transpose()
# Retrieve inputs, outputs and interpolation
inputs = self.__inputs__[:]
outputs = self.__outputs__[0] + " - " + other.__outputs__[0]
outputs = "(" + outputs + ")"
interpolation = self.__interpolation__
# Create new Function object
return Function(source, inputs, outputs, interpolation)
else:
return Function(lambda x: (self.getValue(x) * other(x)))
# If other is Float except...
except:
if isinstance(other, (float, int, complex)):
# Check if Function object source is array or callable
if isinstance(self.source, np.ndarray):
# Operate on grid values
Ys = self.source[:, 1] - other
Xs = self.source[:, 0]
source = np.concatenate(([Xs], [Ys])).transpose()
# Retrieve inputs, outputs and interpolation
inputs = self.__inputs__[:]
outputs = self.__outputs__[0] + " - " + str(other)
outputs = "(" + outputs + ")"
interpolation = self.__interpolation__outputs="Pressure (Pa)",
interpolation="linear",
)
self.temperature = Function(
data_array[:, (1, 2)],
inputs="Height Above Sea Level (m)",
outputs="Temperature (K)",
interpolation="linear",
)
self.windDirection = Function(
data_array[:, (1, 6)],
inputs="Height Above Sea Level (m)",
outputs="Wind Direction (Deg True)",
interpolation="linear",
)
self.windHeading = Function(
data_array[:, (1, 5)],
inputs="Height Above Sea Level (m)",
outputs="Wind Heading (Deg True)",
interpolation="linear",
)
self.windSpeed = Function(
data_array[:, (1, 7)],
inputs="Height Above Sea Level (m)",
outputs="Wind Speed (m/s)",
interpolation="linear",
)
self.windVelocityX = Function(
data_array[:, (1, 3)],
inputs="Height Above Sea Level (m)",
outputs="Wind Velocity X (m/s)",
interpolation="linear",) # Converts Knots to m/s
windHeading_array = windDirection_array[:, :] * 1
windHeading_array[:, 1] = (
windDirection_array[:, 1] + 180
) % 360 # Convert wind direction to wind heading
windU = windSpeed_array[:, :] * 1
windV = windSpeed_array[:, :] * 1
windU[:, 1] = windSpeed_array[:, 1] * np.sin(
windHeading_array[:, 1] * np.pi / 180
)
windV[:, 1] = windSpeed_array[:, 1] * np.cos(
windHeading_array[:, 1] * np.pi / 180
)
# Save wind data
self.windDirection = Function(
windDirection_array,
inputs="Height Above Sea Level (m)",
outputs="Wind Direction (Deg True)",
interpolation="linear",
)
self.windHeading = Function(
windHeading_array,
inputs="Height Above Sea Level (m)",
outputs="Wind Heading (Deg True)",
interpolation="linear",
)
self.windSpeed = Function(
windSpeed_array,
inputs="Height Above Sea Level (m)",
outputs="Wind Speed (m/s)",
interpolation="linear",rO = self.grainOuterRadius
def geometryDot(y, t):
grainMassDot = self.massDot(t) / self.grainNumber
rI, h = y
rIDot = (
-0.5 * grainMassDot / (density * np.pi * (rO ** 2 - rI ** 2 + rI * h))
)
hDot = 1.0 * grainMassDot / (density * np.pi * (rO ** 2 - rI ** 2 + rI * h))
return [rIDot, hDot]
# Solve the system of differential equations
sol = integrate.odeint(geometryDot, y0, t)
# Write down functions for innerRadius and height
self.grainInnerRadius = Function(
np.concatenate(([t], [sol[:, 0]])).transpose().tolist(),
"Time (s)",
"Grain Inner Radius (m)",
self.interpolate,
"constant",
)
self.grainHeight = Function(
np.concatenate(([t], [sol[:, 1]])).transpose().tolist(),
"Time (s)",
"Grain Height (m)",
self.interpolate,
"constant",
)
# Create functions describing burn rate, Kn and burn area
# Burn Arearocketpy
Advanced 6-DOF trajectory simulation for High-Power Rocketry.
