pyBADA 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

pyBADA/configuration.py

@@ -2,8 +2,9 @@
 Common configuration module
 """
 
-import os
 import importlib.resources
+import os
+
 import pandas as pd
 
 

pyBADA/conversions.py

@@ -2,158 +2,131 @@
 Common unit conversions module
 """
 
-from math import pi
 from datetime import datetime
+from math import pi
 from time import mktime
 
+import numpy as np
+import xarray as xr
+import pandas as pd
+
+from pyBADA import utils
+
+
+def _unit_converter(factor):
+    """
+    Returns a function that multiplies its input by `factor`,
+    vectorized through utils._extract / utils._wrap.
+    """
+    def converter(val):
+        # pull out the raw array
+        arr = utils._extract(val)
+        # do the multiplication
+        core = arr * factor
+        # pass both the result and the original to _wrap
+        return utils._wrap(core, original=val)
+    return converter
+
+# Linear unit conversions (factor-based)
+_factor_map = {
+    "ft2m":    0.3048,
+    "nm2m":    1852.0,
+    "h2s":     3600.0,
+    "kt2ms":   0.514444,
+    "lb2kg":   0.453592,
+    "deg2rad": pi / 180.0,
+    "rad2deg": 180.0 / pi,
+    "m2ft":    1 / 0.3048,
+    "m2nm":    1 / 1852.0,
+    "s2h":     1 / 3600.0,
+    "ms2kt":   1 / 0.514444,
+    "kg2lb":   1 / 0.453592,
+    "hp2W":    745.699872,
+}
 
-def ft2m(val):
-    """
-    This function converts from ft to m s
-
-    :param val: value in ft
-    :returns: vaue in m
-    """
-    return round(float(val) * 0.3048, 10)
-
-
-def nm2m(val):
-    """
-    This function converts from nautical miles to m
-
-    :param val: value in nautical miles
-    :returns: vaue in m
-    """
-    return val * 1852.0
-
-
-def h2s(val):
-    """
-    This function converts from hours to m seconds
-
-    :param val: value in hours
-    :returns: vaue in seconds
-    """
-    return val * 3600.0
-
-
-def kt2ms(val):
-    """
-    This function converts from kt to m s^-1
-
-    :param val: value in kt
-    :returns: vaue in m s^-1
-    """
-
-    if val is None:
-        return None
-    else:
-        return round(float(val) * 0.514444, 10)
-
-
-def lb2kg(val):
-    """This function converts from lb to kg.
-
-    :param val: value in lb
-    :returns: vaue in kg
-    """
-    return val * 0.453592
-
-
-def deg2rad(val):
-    """This function converts from decimal degrees to radians.
-
-    :param val: value in decimal degrees
-    :returns: vaue in radians
-    """
-    return val * pi / 180.0
-
-
-def m2ft(val):
-    """This function converts from meters to feets.
-
-    :param val: value in meters
-    :returns: value in feets
-    """
-
-    return round(float(val) / 0.3048, 10)
-
-
-def m2nm(val):
-    """This function converts from meters to nautical miles.
-
-    :param val: value in meters
-    :returns: value in nautical miles
-    """
-    return val / 1852.0
-
-
-def s2h(val):
-    """This function converts from seconds to hours.
-
-    :param val: value in seconds
-    :returns: value in hours
-    """
-    return val / 3600.0
-
-
-def ms2kt(val):
-    """This function converts from m s^-1 to kt.
-
-    :param val: value in m s^-1
-    :returns: value in kt
-    """
-
-    if val is None:
-        return None
-    else:
-        return round(float(val) / 0.514444, 10)
-
-
-def kg2lb(val):
-    """This function converts from kg to lb.
-
-    :param val: value in kg
-    :returns: value in lb
-    """
-    return val / 0.453592
-
-
-def rad2deg(val):
-    """This function converts from radians to decimal degrees.
-
-    :param val: value in radians
-    :returns: value in decimal degrees
-    """
-    return val / pi * 180.0
-
-
-def hp2W(val):
-    """This function converts from horsepower to watts.
-
-    :param val: value in horsepower
-    :returns: value in watts
-    """
-    return val * 745.699872
+# Dynamically create each converter in the module namespace
+for _name, _factor in _factor_map.items():
+    globals()[_name] = _unit_converter(_factor)
 
 
 def date2posix(val):
-    """This function converts a date format to posix.
-
-    :param val: date in %Y-%m-%d %H:%M:%S format
-    :returns: posix time referenced to 01-01-1970 [s]
     """
-    return mktime(datetime.strptime(val, "%Y-%m-%d %H:%M:%S").timetuple())
+    Convert date(s) to POSIX timestamp in seconds since 1970-01-01, vectorized for
+    numpy arrays, pandas Series/DataFrame, and xarray.DataArray.
+
+    :param val: Input date(s). Can be string, datetime, numpy array of strings/datetimes,
+                pandas Series/DataFrame of datetime-like, or xarray.DataArray of datetime64.
+    :type val: str or datetime or array-like or pandas Series/DataFrame or xarray.DataArray
+    :returns: POSIX timestamp(s) in seconds, matching input type.
+    """
+    # xarray DataArray of datetime64
+    if isinstance(val, xr.DataArray):
+        out = val.astype('datetime64[s]').astype(int)
+        out.attrs.update(units='s', long_name='POSIX timestamp')
+        return out
+
+    if isinstance(val, (pd.Series, pd.DataFrame)):
+        ts = pd.to_datetime(val)
+        arr = ts.values.astype('datetime64[s]').astype(int)
+        if isinstance(val, pd.Series):
+            return pd.Series(arr, index=val.index, name=val.name)
+        return pd.DataFrame(arr, index=val.index, columns=val.columns)
+
+    if isinstance(val, str):
+        dt = datetime.strptime(val, "%Y-%m-%d %H:%M:%S")
+        return mktime(dt.timetuple())
+
+    try:
+        if isinstance(val, datetime):
+            return mktime(val.timetuple())
+    except NameError:
+        pass
+
+    arr = np.asarray(val)
+    try:
+        dt64 = arr.astype('datetime64[s]')
+        return dt64.astype(int)
+    except Exception:
+        flat = arr.ravel()
+        result = []
+        for v in flat:
+            if isinstance(v, str):
+                dt = datetime.strptime(v, "%Y-%m-%d %H:%M:%S")
+                result.append(mktime(dt.timetuple()))
+            else:
+                result.append(mktime(v.timetuple()))
+        out = np.array(result)
+        return out.reshape(arr.shape)
 
 
 def unix2date(val):
-    """This function converts posix to date format.
-
-    :param val: time referenced to 01-01-1970 [s]
-    :returns: date in %Y-%m-%d %H:%M:%S format
     """
-    return datetime.fromtimestamp(int(val)).strftime("%Y-%m-%d %H:%M:%S")
-
+    Convert POSIX timestamp(s) in seconds to date string(s) in "%Y-%m-%d %H:%M:%S" format, vectorized for
+    numpy arrays, pandas Series/DataFrame, and xarray.DataArray.
+
+    :param val: Input POSIX timestamp(s). Float, numpy array, pandas Series/DataFrame of floats,
+                or xarray.DataArray of ints.
+    :type val: float or array-like or pandas Series/DataFrame or xarray.DataArray
+    :returns: Date string(s) in "%Y-%m-%d %H:%M:%S", matching input type.
+    """
+    if isinstance(val, xr.DataArray):
+        dt64 = val.astype('datetime64[s]')
+        return dt64.dt.strftime("%Y-%m-%d %H:%M:%S")
+
+    if isinstance(val, (pd.Series, pd.DataFrame)):
+        ts = pd.to_datetime(val, unit='s')
+        return ts.dt.strftime("%Y-%m-%d %H:%M:%S")
+
+    arr = np.asarray(val, dtype=float)
+    flat = arr.ravel()
+    result = []
+    for v in flat:
+        dt = datetime.fromtimestamp(int(v))
+        result.append(dt.strftime("%Y-%m-%d %H:%M:%S"))
+    res_arr = np.array(result)
+    if res_arr.ndim == 0:
+        return res_arr.item()
+    return res_arr.reshape(arr.shape)
 
 convertFrom = {
     "unix": unix2date,

pyBADA/flightTrajectory.py

@@ -2,8 +2,9 @@
 Generic flight trajectory module
 """
 
-import os
 import datetime
+import os
+
 import pandas as pd
 import simplekml
 

pyBADA/geodesic.py

@@ -3,23 +3,129 @@ Geodesic calculation module
 """
 
 from math import (
-    tan,
-    atan2,
-    sin,
     asin,
+    atan,
+    atan2,
     cos,
-    radians,
     degrees,
-    sqrt,
-    pi,
     log,
     log2,
+    pi,
+    radians,
+    sin,
+    sqrt,
+    tan,
 )
-from pyBADA.aircraft import Airplane as airplane
+
 from pyBADA import constants as const
+from pyBADA import conversions as conv
+from pyBADA.aircraft import Airplane as airplane
+
+class GeodesicCommon:
+    @classmethod
+    def requiredSlope(cls, waypoint_init, waypoint_final):
+        """
+        Calculate the climb/descent slope and horizontal distance between
+        two WGS84 waypoints with pressure altitude.
+
+        :param waypoint_init: dict with keys 'latitude', 'longitude', 'altitude' (ft)
+        :param waypoint_final: dict with keys 'latitude', 'longitude', 'altitude' (ft)
+        :type waypoint_init: dict[str, float]
+        :type waypoint_final: dict[str, float]
+        :return: (slope_degrees, distance_meters)
+        :rtype: (float, float)
+        """
+
+        dist = cls.distance(waypoint_init['latitude'], waypoint_init['longitude'], waypoint_final['latitude'], waypoint_final['longitude'])
+        if dist == 0:
+            raise ValueError("Waypoints must be distinct (distance = 0)")
+
+        delta_h = conv.ft2m(waypoint_final['altitude'] - waypoint_init['altitude'])
+        slope = degrees(atan(delta_h / dist))
+        return slope, dist
+
+    @staticmethod
+    def finalAltitudeApplyingSlopeForDistance(
+        altitude: float,
+        slope: float,
+        distance: float
+    ) -> float:
+        """
+        Calculate the final pressure altitude after applying a constant
+        climb/descent slope over a horizontal distance.
+
+        :param delta_h_ft: Initial pressure altitude in feet
+        :param slope:   Flight‐path angle in degrees
+                             (positive for climb, negative for descent)
+        :param distance: Horizontal distance to travel in nautical miles
+        :type altitude: float
+        :type slope: float
+        :type distance: float
+        :return: Final pressure altitude in feet
+        :rtype: float
+        """
+
+        horizontal_m = conv.nm2m(distance)
+        delta_h_ft = conv.m2ft(tan(radians(slope)) * horizontal_m)
+        return altitude + delta_h_ft
+
+    @classmethod
+    def destinationPointApplyingSlopeForDistance(
+        cls,
+        waypoint_init: dict,
+        slope: float,
+        distance: float,
+        bearing: float
+    ) -> dict:
+        """
+        Calculate the destination waypoint after traveling a horizontal
+        distance from an initial WGS84 waypoint on a given bearing and
+        applying a constant climb/descent slope.
+
+        :param waypoint_init: Initial waypoint, as a dict containing:
+            - 'latitude': Latitude in decimal degrees
+            - 'longitude': Longitude in decimal degrees
+            - 'altitude':  Pressure altitude in feet
+        :param slope: Flight‐path angle in degrees
+                             (positive for climb, negative for descent)
+        :param distance: Horizontal distance to travel from the initial
+                             point in nautical miles
+        :param bearing: Initial bearing (direction) in degrees from
+                             true north
+        :type waypoint_init: dict[str, float]
+        :type slope: float
+        :type distance: float
+        :type bearing: float
+        :return: Destination waypoint with keys:
+            - 'latitude': Destination latitude in decimal degrees
+            - 'longitude': Destination longitude in decimal degrees
+            - 'altitude': Final pressure altitude in feet
+        :rtype: dict[str, float]
+        """
+
+        horizontal_dist_m = conv.nm2m(distance)
+
+        dest_lat, dest_lon = cls.destinationPoint(
+            waypoint_init['latitude'],
+            waypoint_init['longitude'],
+            horizontal_dist_m,
+            bearing
+        )
+
+        final_alt_ft = cls.finalAltitudeApplyingSlopeForDistance(
+            waypoint_init['altitude'],
+            slope,
+            distance
+        )
+
+        return {
+            'latitude':  dest_lat,
+            'longitude': dest_lon,
+            'altitude':  final_alt_ft
+        }
 
 
-class Haversine:
+class Haversine(GeodesicCommon):
     """This class implements the geodesic calculations on sherical earth
     (ignoring ellipsoidal effects).
 
@@ -146,7 +252,7 @@ class Haversine:
         return bearing
 
 
-class Vincenty:
+class Vincenty(GeodesicCommon):
     """This class implements the vincenty calculations of geodesics on the
     ellipsoid-model earth.
 
@@ -492,7 +598,7 @@ class Vincenty:
         return (dest[0], dest[1])
 
 
-class RhumbLine:
+class RhumbLine(GeodesicCommon):
     """This class implements the rhumb line (loxodrome) calculations of
     geodesics on the ellipsoid-model earth.
 

pyBADA/magnetic.py

@@ -2,8 +2,9 @@
 Magnetic declination module
 """
 
-import json
 import bisect
+import json
+
 from pyBADA import configuration
 
 

pyBADA/trajectoryPrediction.py

@@ -2,28 +2,29 @@
 Basic calculations for the Trajectory Prediction (TP) using BADA
 """
 
-from pyBADA import atmosphere as atm
 from math import exp
 
+from pyBADA import atmosphere as atm
+
 
-def cruiseFuelConsumption(AC, altitude, M, deltaTemp):
+def cruiseFuelConsumption(AC, altitude, M, DeltaTemp):
     """
     Calculate the cruise fuel consumption for an aircraft during cruise flight using BADA.
 
     :param AC: Aircraft object (instance of Bada3Aircraft, Bada4Aircraft, or BadaHAircraft).
     :param altitude: Altitude in meters.
     :param M: Mach number at cruising altitude.
-    :param deltaTemp: Temperature deviation from standard atmosphere.
+    :param DeltaTemp: Temperature deviation from standard atmosphere.
     :type AC: object
     :type altitude: float
     :type M: float
-    :type deltaTemp: float
+    :type DeltaTemp: float
     :return: Fuel flow in kg/s.
     :rtype: float
     """
 
     [theta, delta, sigma] = atm.atmosphereProperties(
-        h=altitude, DeltaTemp=deltaTemp
+        h=altitude, DeltaTemp=DeltaTemp
     )
     TAS = atm.mach2Tas(Mach=M, theta=theta)
 
@@ -62,7 +63,7 @@ def cruiseFuelConsumption(AC, altitude, M, deltaTemp):
         CT = AC.CT(Thrust=THR, delta=delta)
 
         fuelFlow = AC.ff(
-            CT=CT, delta=delta, theta=theta, M=M, deltaTemp=deltaTemp
+            CT=CT, delta=delta, theta=theta, M=M, DeltaTemp=DeltaTemp
         )  # [kg/s]
 
     elif AC.BADAFamily.BADAH:
@@ -131,7 +132,7 @@ def getInitialMass(
     payload=60,
     fuelReserve=3600,
     flightPlanInitialMass=None,
-    deltaTemp=0,
+    DeltaTemp=0,
 ):
     """Calculates the estimated initial aircraft mass assumig cruise phase,
     combining flight plan data, aircraft envelope constraints, and an
@@ -147,7 +148,7 @@ def getInitialMass(
         or 1 hour).
     :param flightPlanInitialMass: Optional initial mass from a flight plan, in
         kg.
-    :param deltaTemp: Temperature deviation from standard atmosphere.
+    :param DeltaTemp: Temperature deviation from standard atmosphere.
     :type AC: object
     :type distance: float
     :type altitude: float
@@ -155,7 +156,7 @@ def getInitialMass(
     :type payload: float, optional
     :type fuelReserve: float, optional
     :type flightPlanInitialMass: float, optional
-    :type deltaTemp: float, optional
+    :type DeltaTemp: float, optional
     :return: Estimated initial aircraft mass in kg.
     :rtype: float
     """
@@ -166,7 +167,7 @@ def getInitialMass(
     else:
         # in case of no wind, the ground speed is the same as true airspeed
         [theta, delta, sigma] = atm.atmosphereProperties(
-            h=altitude, DeltaTemp=deltaTemp
+            h=altitude, DeltaTemp=DeltaTemp
         )
         TAS = atm.mach2Tas(Mach=M, theta=theta)
         GS = TAS
@@ -179,7 +180,7 @@ def getInitialMass(
                 initialMass = AC.MREF
             else:
                 cruiseFuelFlow = cruiseFuelConsumption(
-                    AC=AC, altitude=altitude, M=M, deltaTemp=deltaTemp
+                    AC=AC, altitude=altitude, M=M, DeltaTemp=DeltaTemp
                 )
                 initialMass = breguetLeducInitialMass(
                     AC=AC,
@@ -196,7 +197,7 @@ def getInitialMass(
                 initialMass = AC.MREF
             else:
                 cruiseFuelFlow = cruiseFuelConsumption(
-                    AC=AC, altitude=altitude, M=M, deltaTemp=deltaTemp
+                    AC=AC, altitude=altitude, M=M, DeltaTemp=DeltaTemp
                 )
                 initialMass = breguetLeducInitialMass(
                     AC=AC,