atmospheris 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f654d212bfc8c25b833e2160aed6f2239c0aff5370a93c619a453adf069b9b6
-  data.tar.gz: bc4f7f631574da017f4d6d52417e373738e91c6b9d583aca7db167273cb0d4a9
+  metadata.gz: 82f15c900161ab68525b236a39381bfaab2b04319299b2141f4f2e4c31096201
+  data.tar.gz: fe1733ba6452b666a0cc8d0a02706eae8ec8eb74e725ee950d7ed7ccf0c30bdf
 SHA512:
-  metadata.gz: 80d70a6abca6270efaebd34e3b7f6b24e0820bad8a56703d50a550e38e055dafdf916eb0435a88bb48491e150ffffa5aff47ff8b1a9eccc3636c7526f90862a8
-  data.tar.gz: 893fff10ca11df76ccb6f1bdcc4017063dec1ae9396dc8947487feced0cdc1c7c99a2cdce11fe06b2bed18099fe4ba90236f223ceaf379c9f15cd38cce7c9dc2
+  metadata.gz: d3dd8fc1684642111da82a16c92c761fb8ba962b7514f3ad0fbf1b1b7c3568a529a2c649647758af16e69fdb812e6ce8518c542bec89c1ec8efa284f301b7b17
+  data.tar.gz: 5317c6deb64a6cf1ffc7b9ff276bafd91f31df37d52d76c0827043263a730d530497ab10d44b51ddff5b72f64dec0e523ffb8a840dc0a59970679c4c67a74a26

data/README.adoc

@@ -1,4 +1,4 @@
-= Atmospheris for Ruby (ISO Standard Atmosphere / ICAO Standard Atmosphere (ISA))
+= Atmospheris for Ruby (ISO 2533 Standard Atmosphere / ISO 5878 Reference Atmospheres)
 
 == Purpose
 
@@ -8,12 +8,15 @@ following standards:
 * International Standard Atmosphere (ISA) from ISO 2533:1975,
   ISO 2533:1975/ADD 1:1985 and ISO 2533:1975/ADD 2:1997
 * https://store.icao.int/en/manual-of-the-icao-standard-atmosphere-extended-to-80-kilometres-262500-feet-doc-7488[ICAO Standard Atmosphere (ICAO Doc 7488/3, 1994)]
+* ISO 5878 reference atmospheres for aerospace use, including wind
+  distribution calculations (Rice/circular normal distribution)
 
-Which are technically identical standards but different in presentation and
-units (the ICAO document includes `ft` in addition to `m`).
+The ISO 2533 and ICAO Doc 7488/3 standards are technically identical but
+different in presentation and units (the ICAO document includes `ft` in
+addition to `m`).
 
 This library serves as a reference implementation for the values defined in
-ISO CD 2533:2025.
+ISO CD 2533:2025 and ISO/DIS 5878.
 
 
 == Usage
@@ -577,6 +580,273 @@ speed_n.class
 ====
 
 
+=== ISO 5878 — Wind characteristics
+
+The library implements wind speed distribution calculations per ISO 5878
+(Reference atmospheres for aerospace use). Wind speed is modeled using the
+*circular normal (Rice) distribution*, which derives scalar wind speed
+statistics from observed vector components.
+
+
+==== Quick start — Wind distribution
+
+[source,ruby]
+----
+require 'atmospheris'
+
+# Compute derived wind characteristics from observed parameters
+wind = Atmospheris::Iso5878.compute_wind_derived(-3.9, -1.2, 5.9)
+
+wind.vr     #=> 4.08 — vector mean wind magnitude (m/s)
+wind.vsc    #=> 6.03 — scalar mean wind speed (m/s)
+wind.sigma  #=> 4.17 — per-component standard deviation (m/s)
+
+# Percentile wind speeds
+wind.percentiles[1].high    #=> ~14.7 (not exceeded on 99% of occasions)
+wind.percentiles[10].low    #=> ~0.5
+wind.percentiles[10].high   #=> ~12.0
+wind.percentiles[20]        #=> PercentilePair with low and high
+----
+
+
+==== WindObservation
+
+The `Atmospheris::Iso5878::WindObservation` class encapsulates a single
+altitude-level wind observation with its empirically measured parameters
+and lazily computed derived statistics.
+
+[source,ruby]
+----
+require 'atmospheris'
+
+obs = Atmospheris::Iso5878::WindObservation.new(
+  geopotential_altitude: 1000,
+  vx: -3.9,
+  vy: -1.2,
+  sigma_r: 5.9,
+  vsa: 7.6   # optional: observed scalar mean speed
+)
+
+obs.vr                          #=> 4.08
+obs.theta                       #=> direction in radians from east
+obs.vsc                         #=> 6.03 (calculated)
+obs.percentile_bounds[1].high   #=> ~14.7
+obs.derived_fields              #=> WindDerivedFields struct
+----
+
+Parameters:
+
+* `geopotential_altitude` — Altitude in metres
+* `vx` — Mean zonal wind component (m/s)
+* `vy` — Mean meridional wind component (m/s)
+* `sigma_r` — Standard deviation of vector mean wind (m/s)
+* `vsa` — (optional) Observed scalar mean speed (m/s)
+* `nu_max` — (optional) Max observed speed once in 10 years (m/s)
+* `use_absolute_vx` — (default: false) For zones > 20°N where Vy ≈ 0
+
+
+==== RiceDistribution
+
+The `Atmospheris::Iso5878::RiceDistribution` class encapsulates a Rice
+distribution with fixed parameters (Vr, sigma_r), providing lazy-cached
+statistical computations.
+
+[source,ruby]
+----
+require 'atmospheris'
+
+dist = Atmospheris::Iso5878::RiceDistribution.new(vr: 4.08, sigma_r: 5.9)
+
+dist.mean              #=> 6.03 (scalar mean wind speed Vsc)
+dist.pdf(5.0)          #=> probability density at 5 m/s
+dist.cdf(10.0)         #=> P(wind ≤ 10 m/s)
+dist.quantile(0.99)    #=> ~14.7 (wind speed exceeded on 1% of occasions)
+dist.percentile_bounds #=> { 1 => Pair, 10 => Pair, 20 => Pair }
+----
+
+Methods:
+
+* `pdf(nu)` — Probability density at wind speed nu
+* `cdf(x)` — Cumulative distribution function
+* `quantile(p)` — Inverse CDF (quantile function)
+* `mean` — Analytical Rice distribution mean (Vsc, Eq. 4)
+* `percentile_bounds` — Hash mapping percentage (1, 10, 20) to `PercentilePair`
+
+
+==== Low-level functions
+
+Module-level functions in `Atmospheris::Iso5878` for direct access to the
+underlying mathematical operations:
+
+[cols="3,5",grid="none"]
+|===
+|Method |Description
+
+|`bessel_i0(x)` |Modified Bessel function of the first kind, order zero
+|`bessel_i1(x)` |Modified Bessel function of the first kind, order one
+|`rice_pdf(nu, vr, sigma_r)` |Rice distribution PDF (Eq. 3)
+|`rice_cdf(x, vr, sigma_r)` |Rice distribution CDF (adaptive Simpson quadrature)
+|`rice_inv_cdf(p, vr, sigma_r)` |Rice inverse CDF via bisection
+|`rice_mean(vr, sigma_r)` |Rice analytical mean (Eq. 4)
+|`compute_wind_derived(vx, vy, sigma_r, use_absolute_vx:)` |Compute all derived wind fields
+|===
+
+
+==== Wind table export
+
+The `Atmospheris::Export::Iso5878.generate_wind_table` method augments
+empirical wind observation YAML data with computed derived fields (Vsc,
+percentile bounds):
+
+[source,ruby]
+----
+require 'atmospheris'
+
+wind_data = YAML.load_file('table1.yaml')
+augmented = Atmospheris::Export::Iso5878.generate_wind_table(wind_data)
+File.write('table1-computed.yaml', YAML.dump(augmented))
+----
+
+Empirical fields (Vx, Vy, sigma-r, Vsa, nu-max) are never overwritten.
+Only blank computed fields (Vsc, percentile bounds) are filled.
+
+
+==== Data structures
+
+`PercentilePair` — Struct with `low` and `high` fields (keyword init):
+
+[source,ruby]
+----
+pair = Atmospheris::Iso5878::PercentilePair.new(low: 0.5, high: 14.7)
+pair.low   #=> 0.5
+pair.high  #=> 14.7
+----
+
+`WindDerivedFields` — Struct with `vr`, `sigma`, `vsc`, `percentiles` (keyword init):
+
+[source,ruby]
+----
+fields = Atmospheris::Iso5878::WindDerivedFields.new(
+  vr: 4.08,
+  sigma: 4.17,
+  vsc: 6.03,
+  percentiles: { 1 => pair, 10 => pair2, 20 => pair3 }
+)
+----
+
+
+=== ISO 5878 — Reference atmosphere profiles
+
+ISO 5878 defines reference atmospheres as temperature layer structures for
+selected latitudes (15°, 30°, 45°, 60°, 80°) and seasons, anchored to
+latitude-specific surface conditions. The library models these with
+`SurfaceParameters`, `AtmosphereProfile` and `AtmosphereModelRegistry`.
+
+
+==== SurfaceParameters
+
+Latitude-dependent constants per ISO 5878 Eq. 0 (Lambert's equation for
+sea-level gravity), Eq. 13 (nominal earth radius), Eq. 7–9 (altitude
+conversions using latitude-specific gravity and radius):
+
+[source,ruby]
+----
+require 'atmospheris'
+
+sp = Atmospheris::Iso5878::SurfaceParameters.new(45)
+
+sp.gravity_at_sea_level        #=> 9.80616 (m/s^2)
+sp.nominal_earth_radius        #=> 6356364 (m)
+sp.geopotential_from_geometric(5000)   #=> ~4995.8 (m)
+sp.gravity_at_geometric(10_000)        #=> 9.7754 (m/s^2)
+----
+
+
+==== AtmosphereProfile
+
+An `AtmosphereProfile` is an `Isa::Algorithms` subclass whose constants and
+temperature layers are injected instead of using the ISO 2533 defaults:
+
+[source,ruby]
+----
+require 'atmospheris'
+
+sp = Atmospheris::Iso5878::SurfaceParameters.new(45)
+
+layers = Atmospheris::Iso5878::TemperatureLayerStructure.from_yaml_rows([
+  { geopotential_altitude: 0.0,     temperature_K: 272.65 },
+  { geopotential_altitude: 16_500,  temperature_K: 216.65 },
+  # ...
+]).to_a
+
+profile = Atmospheris::Iso5878::AtmosphereProfile.new(
+  surface_params: sp,
+  surface_temperature: 272.65,
+  surface_pressure: 101_800.0,
+  layers: layers
+)
+
+profile.temperature_at_layer_from_geopotential(5000)
+profile.pressure_from_geopotential(5000)
+profile.density_from_geopotential(5000)
+----
+
+
+==== AtmosphereModelRegistry
+
+The registry maps model IDs to latitude, season and surface conditions
+(ISO 5878 Table 2), and builds profiles from Table 16/19 layer data.
+Available model IDs:
+
+`15-annual`,
+`30-winter`, `30-summer`,
+`45-winter`, `45-summer`,
+`60-winter`, `60-summer`, `60-warm`, `60-cold`,
+`80-winter`, `80-summer`, `80-warm`, `80-cold`.
+
+[source,ruby]
+----
+require 'atmospheris'
+require 'yaml'
+
+table16 = YAML.load_file('table16.yaml')
+
+profile = Atmospheris::Iso5878::AtmosphereModelRegistry.create("45-winter", table16)
+
+profile.temperature_at_layer_from_geopotential(0)     #=> 272.62 (K)
+profile.pressure_from_geopotential(5000)              #=> 52999.1 (Pa)
+profile.density_from_geopotential(5000)               #=> 0.74254 (kg/m^3)
+
+Atmospheris::Iso5878::AtmosphereModelRegistry.model_ids
+#=> ["15-annual", "30-winter", ...]
+----
+
+
+==== Atmosphere profile export
+
+The `Atmospheris::Export::Iso5878.generate_atmosphere_profile` method
+generates ISO 5878 atmosphere table YAML data for a given model:
+
+[source,ruby]
+----
+require 'atmospheris'
+require 'yaml'
+
+table16 = YAML.load_file('table16.yaml')
+
+data = Atmospheris::Export::Iso5878.generate_atmosphere_profile(
+  "45-winter", table16,
+  table_id: "atmosphere-table-5",
+  title_en: "January reference atmosphere, 45N",
+  geometric_altitudes: [0, 5000, 10_000, 20_000]
+)
+
+data["rows-h"][0]
+#=> {"geometrical-altitude"=>0, "geopotential-altitude"=>0,
+#     "temperature-K"=>272.62, "temperature-C"=>-0.53,
+#     "p-mbar"=>1018.0, "density"=>1.300853}
+----
+
 
 
 == Generating ISO 2533 tables

data/lib/atmospheris/export/iso_5878/atmosphere_profile_export.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  module Export
+    module Iso5878
+      # Generates YAML data matching the existing table3.yaml–table15.yaml format.
+      #
+      # Computes temperature, pressure, and density at specified geometric altitudes
+      # using an AtmosphereProfile instance.
+      #
+      # @example
+      #   profile = AtmosphereModelRegistry.create("15-annual", table16_data)
+      #   export = AtmosphereProfileExport.new(
+      #     profile,
+      #     table_id: "atmosphere-table-3",
+      #     title_en: "Mean annual values ...",
+      #     geometric_altitudes: (0..10_000).step(1000).to_a + (12_000..80_000).step(2000).to_a
+      #   )
+      #   yaml_data = export.generate
+      class AtmosphereProfileExport
+        STANDARD_ALTITUDES = (
+          (0..10_000).step(1000).to_a + (12_000..80_000).step(2000).to_a
+        ).freeze
+
+        # @param profile [Iso5878::AtmosphereProfile]
+        # @param table_id [String]
+        # @param title_en [String]
+        # @param geometric_altitudes [Array<Integer>] geometric altitudes in metres
+        def initialize(profile, table_id:, title_en:, geometric_altitudes: STANDARD_ALTITUDES)
+          @profile = profile
+          @table_id = table_id
+          @title_en = title_en
+          @geometric_altitudes = geometric_altitudes
+        end
+
+        # @return [Hash] YAML-serializable atmosphere profile table data
+        def generate
+          {
+            "id" => @table_id,
+            "title-en" => @title_en,
+            "title-fr" => "",
+            "title-ru" => "",
+            "note-en" => "",
+            "note-fr" => "",
+            "note-ru" => "",
+            "rows-h" => @geometric_altitudes.map { |h_m| compute_row(h_m) }
+          }
+        end
+
+        private
+
+        def compute_row(h_m)
+          h_m_f = h_m.to_f
+          gp_h = @profile.geopotential_altitude_from_geometric(h_m_f)
+          t_k = @profile.temperature_at_layer_from_geopotential(gp_h)
+          t_c = t_k - 273.15
+          p_mbar = @profile.pressure_from_geopotential_mbar(gp_h)
+          rho = @profile.density_from_geopotential(gp_h)
+
+          {
+            "geometrical-altitude" => h_m,
+            "geopotential-altitude" => gp_h.round,
+            "temperature-K" => round3(t_k),
+            "temperature-C" => round2(t_c),
+            "p-mbar" => scientific_notation(p_mbar),
+            "density" => scientific_notation(rho)
+          }
+        end
+
+        def round2(v)
+          (v * 100).round / 100.0
+        end
+
+        def round3(v)
+          (v * 1000).round / 1000.0
+        end
+
+        # Format a float in scientific notation matching YAML convention.
+        # e.g. 1013.25 → "1.013250e3", 0.001779 → "1.177987e0"
+        def scientific_notation(v)
+          v.round(6)
+        end
+      end
+    end
+  end
+end

data/lib/atmospheris/export/iso_5878/wind_table_export.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  module Export
+    module Iso5878
+      # Takes the empirical wind YAML data (Table 1), computes derived fields
+      # using WindObservation, and returns augmented YAML with calculated
+      # columns filled in where they are nil.
+      #
+      # Empirical fields (Vx, Vy, sigma-r, Vsa, nu-max) are never overwritten.
+      # Only blank computed fields (Vsc, percentile bounds) are filled.
+      #
+      # @example
+      #   wind_data = YAML.load_file('04-yaml/table1.yaml')
+      #   augmented = WindTableExport.new(wind_data).generate
+      #   File.write('04-yaml/table1-computed.yaml', YAML.dump(augmented))
+      class WindTableExport
+        # @param wind_yaml_data [Hash] loaded from table1.yaml
+        def initialize(wind_yaml_data)
+          @source = wind_yaml_data
+        end
+
+        # @return [Hash] augmented YAML data with computed fields filled in
+        def generate
+          result = @source.dup
+          result["rows"] = result["rows"].map do |zone_row|
+            augment_zone(zone_row)
+          end
+          result
+        end
+
+        private
+
+        def augment_zone(zone_row)
+          zone_row.dup.tap do |row|
+            row["values"] = row["values"].map do |obs_row|
+              augment_observation(obs_row, zone_row)
+            end
+          end
+        end
+
+        def augment_observation(obs, zone_row)
+          vx = obs["Vx"]
+          sigma_r = obs["sigma-r"]
+          return obs.dup if vx.nil? || sigma_r.nil?
+
+          sigma_r_f = sigma_r.to_f
+          return obs.dup if sigma_r_f <= 0
+
+          use_abs_vx = zone_row["angle-low"].to_i >= 20
+          wind = ::Atmospheris::Iso5878::WindObservation.new(
+            geopotential_altitude: obs["geopotential-altitude"],
+            vx: vx.to_f,
+            vy: (obs["Vy"] || 0).to_f,
+            sigma_r: sigma_r_f,
+            use_absolute_vx: use_abs_vx
+          )
+
+          obs.dup.tap do |o|
+            o["Vsc"] = round1(wind.vsc) if obs["Vsc"].nil?
+
+            bounds = wind.percentile_bounds
+            o["Vsc-1-low"]  = round1(bounds[1].low) if obs["Vsc-1-low"].nil?
+            o["Vsc-1-high"] = round1(bounds[1].high)   if obs["Vsc-1-high"].nil?
+            o["Vsc-10-low"] = round1(bounds[10].low)   if obs["Vsc-10-low"].nil?
+            o["Vsc-10-high"] = round1(bounds[10].high) if obs["Vsc-10-high"].nil?
+            o["Vsc-20-low"] = round1(bounds[20].low) if obs["Vsc-20-low"].nil?
+            o["Vsc-20-high"] = round1(bounds[20].high) if obs["Vsc-20-high"].nil?
+          end
+        end
+
+        def round1(v)
+          (v * 10).round / 10.0
+        end
+      end
+    end
+  end
+end

data/lib/atmospheris/export/iso_5878.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  module Export
+    module Iso5878
+      autoload :AtmosphereProfileExport,
+               "atmospheris/export/iso_5878/atmosphere_profile_export"
+      autoload :WindTableExport,
+               "atmospheris/export/iso_5878/wind_table_export"
+
+      class << self
+        # Generate atmosphere profile YAML data for a given model.
+        #
+        # @param model_id [String] e.g. "15-annual", "60-warm"
+        # @param layers_data [Hash] YAML data from table16.yaml or table19.yaml
+        # @param table_id [String] YAML id field
+        # @param title_en [String] YAML title-en field
+        # @param geometric_altitudes [Array<Integer>] geometric altitudes in metres
+        # @return [Hash] YAML-serializable data
+        def generate_atmosphere_profile(model_id, layers_data, table_id:, title_en:, geometric_altitudes:)
+          profile = ::Atmospheris::Iso5878::AtmosphereModelRegistry.create(model_id, layers_data)
+          AtmosphereProfileExport.new(
+            profile,
+            table_id: table_id,
+            title_en: title_en,
+            geometric_altitudes: geometric_altitudes
+          ).generate
+        end
+
+        # Augment wind observation YAML data with computed derived fields.
+        #
+        # @param wind_yaml_data [Hash] loaded from table1.yaml
+        # @return [Hash] augmented data (computed fields filled where nil)
+        def generate_wind_table(wind_yaml_data)
+          WindTableExport.new(wind_yaml_data).generate
+        end
+      end
+    end
+  end
+end

data/lib/atmospheris/export.rb

@@ -13,5 +13,6 @@ module Atmospheris
     autoload :Iso25331985, "atmospheris/export/iso_25331985"
     autoload :Iso25331997, "atmospheris/export/iso_25331997"
     autoload :Iso25332025, "atmospheris/export/iso_25332025"
+    autoload :Iso5878, "atmospheris/export/iso_5878"
   end
 end

data/lib/atmospheris/iso5878/atmosphere_profile.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "atmospheris/isa"
+
+module Atmospheris
+  module Iso5878
+    # Generalized ISA engine for ISO 5878 reference atmospheres.
+    #
+    # Extends Isa::Algorithms (open/closed principle) by injecting custom
+    # temperature layer structures and latitude-dependent surface conditions.
+    # All barometric formula methods (pressure, density, etc.) are inherited
+    # and automatically use the custom configuration.
+    #
+    # One AtmosphereProfile instance = one atmosphere model (e.g. "15 annual"
+    # or "60N winter warm regime").
+    #
+    # @example
+    #   params = SurfaceParameters.new(15)
+    #   layers = Iso5878::TemperatureLayerStructure.from_yaml_rows(yaml_rows)
+    #   profile = AtmosphereProfile.new(
+    #     surface_params: params,
+    #     surface_temperature: 299.65,
+    #     surface_pressure: 101325.0,
+    #     layers: layers.to_a
+    #   )
+    #   profile.pressure_from_geopotential_mbar(5000)
+    class AtmosphereProfile < Isa::Algorithms
+      R_SPECIFIC = 287.05287
+
+      attr_reader :surface_params, :surface_temperature, :surface_pressure, :model_layers
+
+      # @param surface_params [SurfaceParameters]
+      # @param surface_temperature [Numeric] T at sea level (K)
+      # @param surface_pressure [Numeric] P at sea level (Pa)
+      # @param layers [Array<Hash>] ISA-format temperature layers
+      #   [{ H: 0.0, T: 299.65, B: -0.006 }, ...]
+      #   H in metres, T in Kelvin, B in K/m. Last layer has no :B key.
+      def initialize(surface_params:, surface_temperature:, surface_pressure:, layers:)
+        @surface_params = surface_params
+        @surface_temperature = surface_temperature.to_f
+        @surface_pressure = surface_pressure.to_f
+        @model_layers = layers
+        set_precision(:normal)
+      end
+
+      private
+
+      # Override: inject latitude-specific constants instead of ISA defaults.
+      def make_constants
+        g0 = surface_params.gravity_at_sea_level
+        radius = surface_params.nominal_earth_radius
+        p_n = surface_pressure
+        t_n = surface_temperature
+        r_star = 8.31432
+        rho_n = p_n / (R_SPECIFIC * t_n)
+        molar = rho_n * r_star * t_n / p_n
+
+        @constants = {
+          g_n: g0,
+          N_A: 6.02257e23,
+          p_n: p_n,
+          rho_n: rho_n,
+          T_n: t_n,
+          R_star: r_star,
+          radius: radius,
+          k: 1.4,
+          M: molar,
+          R: r_star / molar
+        }
+
+        @sqrt2 = Math.sqrt(2)
+        @pi = Math::PI
+      end
+
+      # Override: locate layer index using injected model_layers.
+      def locate_lower_layer(geopotential_alt)
+        return 0 if geopotential_alt < model_layers[0][:H]
+
+        i = model_layers.length - 1
+        return i - 1 if geopotential_alt >= model_layers[i][:H]
+
+        model_layers.each_with_index do |layer, ind|
+          return ind - 1 if layer[:H] > geopotential_alt
+        end
+        nil
+      end
+
+      # Override: pressure layer base values computed from injected layers.
+      def pressure_layers
+        return @pressure_layers if @pressure_layers
+
+        p = []
+        model_layers.each_with_index do |_x, i|
+          last_i = i.zero? ? 0 : i - 1
+          last_layer = model_layers[last_i]
+          beta = last_layer[:B] || 0.0
+
+          if last_layer[:H] <= 0
+            p_b = @constants[:p_n]
+            h_b = 0.0
+            t_b = @constants[:T_n]
+          else
+            p_b = p[last_i]
+            h_b = last_layer[:H]
+            t_b = last_layer[:T]
+          end
+
+          current_layer = model_layers[i]
+          h_curr = current_layer[:H]
+          dh = h_curr - h_b
+
+          p[i] = if beta.zero?
+                   pressure_formula_beta_zero(p_b, current_layer[:T], dh)
+                 else
+                   pressure_formula_beta_nonzero(p_b, beta, t_b, dh)
+                 end
+        end
+
+        @pressure_layers = p
+      end
+
+      # --- Public method overrides (must remain public) ---
+
+      # Override: temperature lookup uses injected model_layers.
+      def temperature_at_layer_from_geopotential(geopotential_alt)
+        idx = locate_lower_layer(geopotential_alt)
+        layer = model_layers[idx]
+        beta = layer[:B] || 0.0
+        t_b = layer[:T]
+        h_b = layer[:H]
+        t_b + beta * (geopotential_alt - h_b)
+      end
+
+      # Override: pressure at altitude uses injected model_layers.
+      def pressure_from_geopotential(geopotential_alt)
+        i = locate_lower_layer(geopotential_alt)
+        layer = model_layers[i]
+        beta = layer[:B] || 0.0
+        h_b = layer[:H]
+        t_b = layer[:T]
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        p_b = pressure_layers[i]
+        dh = geopotential_alt - h_b
+
+        if beta.zero?
+          pressure_formula_beta_zero(p_b, temp, dh)
+        else
+          pressure_formula_beta_nonzero(p_b, beta, t_b, dh)
+        end
+      end
+
+      public :temperature_at_layer_from_geopotential, :pressure_from_geopotential
+    end
+
+    # Converts YAML breakpoint data (Table 16 / Table 19 format) into
+    # the ISA-compatible layer format used by AtmosphereProfile.
+    #
+    # Input format (YAML rows):
+    #   [{ geopotential_altitude: 0.0, temperature_K: 299.65 },
+    #    { geopotential_altitude: 2.25, temperature_K: 286.15 },
+    #    ...]
+    #
+    # Output format (ISA layers):
+    #   [{ H: 0.0, T: 299.65, B: -0.006 },
+    #    { H: 2250.0, T: 286.15, B: 0.0032 },
+    #    ...]
+    #
+    # Gradients (B) are computed from consecutive temperature/altitude pairs
+    # rather than read from the YAML gradient column, ensuring consistency
+    # with the specified temperature breakpoints.
+    class TemperatureLayerStructure
+      attr_reader :layers
+
+      # @param yaml_rows [Array<Hash>] breakpoint data from table16/19 YAML
+      #   Keys: :geopotential_altitude (km), :temperature_K (K)
+      def initialize(yaml_rows)
+        @layers = build_layers(yaml_rows)
+      end
+
+      # Construct from a YAML row subset (e.g., yaml_data["rows-15"])
+      # @param rows [Array<Hash>]
+      # @return [TemperatureLayerStructure]
+      def self.from_yaml_rows(rows)
+        new(rows)
+      end
+
+      # @return [Array<Hash>] ISA-format layers
+      def to_a
+        @layers
+      end
+
+      private
+
+      def build_layers(rows)
+        layers = []
+        rows.each_with_index do |row, i|
+          h_m = row[:geopotential_altitude].to_f * 1000.0 # km -> m
+          t_k = row[:temperature_K].to_f
+
+          if i < rows.length - 1
+            next_row = rows[i + 1]
+            next_h = next_row[:geopotential_altitude].to_f * 1000.0
+            next_t = next_row[:temperature_K].to_f
+            dh = next_h - h_m
+            beta = dh.abs < 1e-12 ? 0.0 : (next_t - t_k) / dh # K/m
+            layers << { H: h_m, T: t_k, B: beta }
+          else
+            # Last breakpoint — no layer above it
+            layers << { H: h_m, T: t_k }
+          end
+        end
+        layers
+      end
+    end
+  end
+end

data/lib/atmospheris/iso5878/model_registry.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  module Iso5878
+    # Factory for constructing AtmosphereProfile instances from model identifiers.
+    #
+    # Maps model IDs (e.g. "15-annual", "60-warm") to their latitude, season,
+    # and temperature layer structure key. Surface conditions are looked up
+    # from Table 2 data. Layer structures are loaded from YAML data (Table 16/19).
+    #
+    # Open/closed: new models can be added to MODELS without modifying
+    # AtmosphereProfile or TemperatureLayerStructure.
+    class AtmosphereModelRegistry
+      # Model definitions: maps model_id to configuration
+      MODELS = {
+        "15-annual" => { latitude: 15,  season: :annual, layers_key: :"rows-15" },
+        "30-winter" => { latitude: 30,  season: :winter, layers_key: :"rows-30-w" },
+        "30-summer" => { latitude: 30,  season: :summer, layers_key: :"rows-30-s" },
+        "45-winter" => { latitude: 45,  season: :winter, layers_key: :"rows-45-w" },
+        "45-summer" => { latitude: 45,  season: :summer, layers_key: :"rows-45-s" },
+        "60-winter" => { latitude: 60,  season: :winter, layers_key: :"rows-60-w" },
+        "60-summer" => { latitude: 60,  season: :summer, layers_key: :"rows-60-s" },
+        "60-warm" => { latitude: 60,  season: :winter, layers_key: :"rows-60-warm" },
+        "60-cold" => { latitude: 60,  season: :winter, layers_key: :"rows-60-cold" },
+        "80-winter" => { latitude: 80,  season: :winter, layers_key: :"rows-80-w" },
+        "80-summer" => { latitude: 80,  season: :summer, layers_key: :"rows-80-s" },
+        "80-warm" => { latitude: 80,  season: :winter, layers_key: :"rows-80-warm" },
+        "80-cold" => { latitude: 80,  season: :winter, layers_key: :"rows-80-cold" }
+      }.freeze
+
+      # Surface conditions from ISO 5878 Table 2.
+      # Pressures in Pa, temperatures in K.
+      SURFACE_CONDITIONS = {
+        15 => {
+          annual: { T: 299.650, P: 101_325.0 }
+        },
+        30 => {
+          winter: { T: 283.150, P: 102_050.0 },
+          summer: { T: 297.150, P: 101_400.0 }
+        },
+        45 => {
+          winter: { T: 272.650, P: 101_800.0 },
+          summer: { T: 291.150, P: 101_350.0 }
+        },
+        60 => {
+          winter: { T: 256.150, P: 101_300.0 },
+          summer: { T: 282.150, P: 101_020.0 }
+        },
+        80 => {
+          winter: { T: 248.950, P: 101_380.0 },
+          summer: { T: 276.650, P: 101_200.0 }
+        }
+      }.freeze
+
+      # Construct an AtmosphereProfile for the given model ID.
+      #
+      # @param model_id [String] e.g. "15-annual", "60-warm"
+      # @param layers_data [Hash] YAML data from table16.yaml or table19.yaml
+      #   Must contain the key matching the model's layers_key
+      # @return [AtmosphereProfile]
+      def self.create(model_id, layers_data)
+        config = MODELS.fetch(model_id) do
+          raise ArgumentError, "Unknown ISO 5878 model: #{model_id}. " \
+                               "Available: #{MODELS.keys.join(", ")}"
+        end
+
+        surface = SURFACE_CONDITIONS.dig(config[:latitude], config[:season])
+        raise ArgumentError, "No surface conditions for #{config[:latitude]}° #{config[:season]}" unless surface
+
+        raw_rows = layers_data[config[:layers_key].to_s]
+        raise ArgumentError, "Layer data key '#{config[:layers_key]}' not found in provided data" unless raw_rows
+
+        # Normalize YAML keys to symbols
+        normalized = raw_rows.map do |row|
+          {
+            geopotential_altitude: row["geopotential-altitude"] || row[:geopotential_altitude],
+            temperature_K: row["temperature-K"] || row[:temperature_K]
+          }
+        end
+
+        tls = TemperatureLayerStructure.from_yaml_rows(normalized)
+        params = SurfaceParameters.new(config[:latitude])
+
+        AtmosphereProfile.new(
+          surface_params: params,
+          surface_temperature: surface[:T],
+          surface_pressure: surface[:P],
+          layers: tls.to_a
+        )
+      end
+
+      # List all available model IDs.
+      # @return [Array<String>]
+      def self.model_ids
+        MODELS.keys
+      end
+    end
+  end
+end

data/lib/atmospheris/iso5878/rice_distribution.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  module Iso5878
+    # Encapsulates a single Rice (circular normal) distribution instance
+    # with fixed parameters (Vr, sigma_r).
+    #
+    # Wraps the existing module-level methods (bessel_i0, rice_pdf, etc.)
+    # in an object-oriented interface, enabling lazy caching and clean
+    # composition by WindObservation.
+    #
+    # @example
+    #   dist = RiceDistribution.new(vr: 3.9, sigma_r: 5.9)
+    #   dist.mean           # => 6.03
+    #   dist.quantile(0.99) # => 14.7
+    #   dist.percentile_bounds
+    class RiceDistribution
+      attr_reader :vr, :sigma_r, :sigma
+
+      # @param vr [Numeric] magnitude of vector mean wind (m/s)
+      # @param sigma_r [Numeric] standard deviation of vector mean wind (m/s)
+      def initialize(vr:, sigma_r:)
+        @vr = vr.to_f
+        @sigma_r = sigma_r.to_f
+        @sigma = @sigma_r / Math.sqrt(2)
+      end
+
+      # Probability density at wind speed nu.
+      # @param nu [Numeric] wind speed (m/s)
+      # @return [Float]
+      def pdf(nu)
+        Iso5878.rice_pdf(nu, vr, sigma_r)
+      end
+
+      # Cumulative distribution function at wind speed x.
+      # @param x [Numeric] wind speed (m/s)
+      # @return [Float] probability in [0, 1]
+      def cdf(x)
+        Iso5878.rice_cdf(x, vr, sigma_r)
+      end
+
+      # Inverse CDF (quantile function) for probability p.
+      # @param p [Numeric] probability in (0, 1)
+      # @return [Float] wind speed (m/s)
+      def quantile(p)
+        Iso5878.rice_inv_cdf(p, vr, sigma_r)
+      end
+
+      # Analytical mean of the Rice distribution (Eq. 4).
+      # This is the calculated scalar mean wind speed Vsc.
+      # @return [Float] mean wind speed (m/s)
+      def mean
+        @mean ||= Iso5878.rice_mean(vr, sigma_r)
+      end
+
+      # Percentile bounds as defined in ISO 5878.
+      # Returns hash mapping percentage to PercentilePair (low/high).
+      # @return [Hash{Integer => PercentilePair}]
+      def percentile_bounds
+        @percentile_bounds ||= {
+          1 => PercentilePair.new(
+            low: quantile(0.01),
+            high: quantile(0.99)
+          ),
+          10 => PercentilePair.new(
+            low: quantile(0.10),
+            high: quantile(0.90)
+          ),
+          20 => PercentilePair.new(
+            low: quantile(0.20),
+            high: quantile(0.80)
+          )
+        }
+      end
+    end
+  end
+end

data/lib/atmospheris/iso5878/surface_parameters.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  module Iso5878
+    # Encapsulates latitude-dependent surface parameters for ISO 5878
+    # reference atmospheres.
+    #
+    # Computes gravity at sea level (Lambert's equation, Eq. 0) and nominal
+    # earth radius (Eq. 13) from geographic latitude. Provides altitude
+    # conversion methods that use latitude-specific gravity and radius.
+    #
+    # Immutable value object — all derived values are computed from latitude.
+    class SurfaceParameters
+      G_N = 9.80665 # standard gravity (m/s^2), ISO 2533
+      R_SPECIFIC = 287.05287 # specific gas constant (J/(kg*K))
+
+      attr_reader :latitude_deg
+
+      # @param latitude_deg [Numeric] geographic latitude in degrees
+      def initialize(latitude_deg)
+        @latitude_deg = latitude_deg.to_f
+      end
+
+      # Eq. 0 — Lambert's equation for acceleration of free fall at sea level.
+      # @return [Float] g_0(phi) in m/s^2
+      def gravity_at_sea_level
+        phi_rad = @latitude_deg * Math::PI / 180.0
+        cos2phi = Math.cos(2.0 * phi_rad)
+        9.80616 * (1.0 - 0.0026373 * cos2phi + 0.0000059 * cos2phi * cos2phi)
+      end
+
+      # Eq. 13 — Nominal earth radius at the given latitude.
+      # @return [Float] r_phi in metres
+      def nominal_earth_radius
+        phi_rad = @latitude_deg * Math::PI / 180.0
+        cos2phi = Math.cos(2.0 * phi_rad)
+        g0 = gravity_at_sea_level
+        g0 * 2.0 / (3.085462e-6 + 2.27e-9 * cos2phi)
+      end
+
+      # Eq. 7 — Acceleration of free fall at geometric altitude h.
+      # @param h_m [Numeric] geometric altitude in metres
+      # @return [Float] g_phi(h) in m/s^2
+      def gravity_at_geometric(h_m)
+        r = nominal_earth_radius
+        ratio = r / (r + h_m)
+        gravity_at_sea_level * ratio * ratio
+      end
+
+      # Eq. 8 — Geopotential altitude from geometric altitude.
+      # @param h_m [Numeric] geometric altitude in metres
+      # @return [Float] geopotential altitude in metres
+      def geopotential_from_geometric(h_m)
+        r = nominal_earth_radius
+        g0 = gravity_at_sea_level
+        (r * h_m / (r + h_m)) * (g0 / G_N)
+      end
+
+      # Eq. 9 — Geometric altitude from geopotential altitude.
+      # @param gp_m [Numeric] geopotential altitude in metres
+      # @return [Float] geometric altitude in metres
+      def geometric_from_geopotential(gp_m)
+        r = nominal_earth_radius
+        g0 = gravity_at_sea_level
+        (r * gp_m) / ((g0 / G_N) * r - gp_m)
+      end
+    end
+  end
+end

data/lib/atmospheris/iso5878/wind_observation.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  module Iso5878
+    # Encapsulates a single altitude-level wind observation with its
+    # empirically measured parameters and lazily computed derived statistics.
+    #
+    # Empirical inputs: Vx, Vy, sigma_r, Vsa (optional), nu_max (optional)
+    # Derived outputs: Vr, theta, Vsc, percentile bounds
+    #
+    # @example
+    #   obs = WindObservation.new(
+    #     geopotential_altitude: 1000,
+    #     vx: -3.9, vy: -1.2, sigma_r: 5.9,
+    #     vsa: 7.6
+    #   )
+    #   obs.vr          # => 4.08
+    #   obs.vsc         # => 6.03 (calculated)
+    #   obs.distribution.percentile_bounds[1].high  # => 14.7
+    class WindObservation
+      attr_reader :geopotential_altitude, :vx, :vy, :sigma_r, :vsa, :nu_max
+
+      # @param geopotential_altitude [Numeric] altitude in metres
+      # @param vx [Numeric] mean zonal wind component (m/s)
+      # @param vy [Numeric] mean meridional wind component (m/s)
+      # @param sigma_r [Numeric] standard deviation of vector mean wind (m/s)
+      # @param vsa [Numeric, nil] observed scalar mean speed (m/s)
+      # @param nu_max [Numeric, nil] max observed speed once in 10 years (m/s)
+      # @param use_absolute_vx [Boolean] for zones > 20°N where Vy ≈ 0
+      def initialize(geopotential_altitude:, vx:, vy:, sigma_r:, vsa: nil, nu_max: nil, use_absolute_vx: false)
+        @geopotential_altitude = geopotential_altitude.to_f
+        @vx = vx.to_f
+        @vy = vy.to_f
+        @sigma_r = sigma_r.to_f
+        @vsa = vsa
+        @nu_max = nu_max
+        @use_absolute_vx = use_absolute_vx
+      end
+
+      # Magnitude of the vector mean wind.
+      # For zones > 20°N, uses |Vx| as specified in ISO 5878 Section 5.4.
+      # @return [Float]
+      def vr
+        @vr ||= @use_absolute_vx ? @vx.abs : Math.sqrt(@vx**2 + @vy**2)
+      end
+
+      # Direction of the vector mean wind (radians from east).
+      # @return [Float]
+      def theta
+        @theta ||= Math.atan2(@vy, @vx)
+      end
+
+      # The Rice distribution for this observation level.
+      # Lazily constructed and cached.
+      # @return [RiceDistribution]
+      def distribution
+        @distribution ||= RiceDistribution.new(vr: vr, sigma_r: @sigma_r)
+      end
+
+      # Calculated scalar mean wind speed (Vsc).
+      # @return [Float]
+      def vsc
+        @vsc ||= distribution.mean
+      end
+
+      # Calculated percentile bounds.
+      # @return [Hash{Integer => PercentilePair}]
+      def percentile_bounds
+        @percentile_bounds ||= distribution.percentile_bounds
+      end
+
+      # Full derived result as a WindDerivedFields struct (legacy API compat).
+      # @return [WindDerivedFields]
+      def derived_fields
+        @derived_fields ||= WindDerivedFields.new(
+          vr: vr,
+          sigma: distribution.sigma,
+          vsc: vsc,
+          percentiles: percentile_bounds
+        )
+      end
+    end
+  end
+end

data/lib/atmospheris/iso5878.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+# ISO 5878 — Reference atmospheres for aerospace use
+# Wind characteristics: circular normal (Rice) distribution
+# Implements Section 5.4 calculation methods
+
+module Atmospheris
+  module Iso5878
+    autoload :SurfaceParameters, "atmospheris/iso5878/surface_parameters"
+    autoload :AtmosphereProfile, "atmospheris/iso5878/atmosphere_profile"
+    autoload :TemperatureLayerStructure, "atmospheris/iso5878/atmosphere_profile"
+    autoload :AtmosphereModelRegistry, "atmospheris/iso5878/model_registry"
+    autoload :RiceDistribution, "atmospheris/iso5878/rice_distribution"
+    autoload :WindObservation, "atmospheris/iso5878/wind_observation"
+
+    # --- Bessel functions (Abramowitz & Stegun polynomial approximations) ---
+    # Relative error < 1.6x10^-7
+
+    # Modified Bessel function of the first kind, order zero (I_0).
+    # Polynomial approximation from A&S 9.8.1/9.8.2.
+    def self.bessel_i0(x)
+      ax = x.abs
+      if ax <= 3.75
+        y = (x / 3.75)**2
+        1.0 + y * (3.5156229 + y * (3.0899424 + y * (1.2067492 +
+          y * (0.2659732 + y * (0.0360768 + y * 0.0045813)))))
+      else
+        y = 3.75 / ax
+        (Math.exp(ax) / Math.sqrt(ax)) * (0.39894228 + y * (0.01328592 +
+          y * (0.00225319 + y * (-0.00157565 + y * (0.00916281 +
+          y * (-0.02057706 + y * (0.02635537 + y * (-0.01647633 +
+          y * 0.00392377))))))))
+      end
+    end
+
+    # Modified Bessel function of the first kind, order one (I_1).
+    # Polynomial approximation from A&S 9.8.3/9.8.4.
+    def self.bessel_i1(x)
+      ax = x.abs
+      if ax <= 3.75
+        y = (x / 3.75)**2
+        value = ax * (0.5 + y * (0.87890594 + y * (0.51498869 +
+          y * (0.15084934 + y * (0.02658733 + y * (0.00301532 +
+          y * 0.00032411))))))
+      else
+        y = 3.75 / ax
+        value = (Math.exp(ax) / Math.sqrt(ax)) * (0.39894228 + y * (-0.03988024 +
+          y * (-0.00362018 + y * (0.00163801 + y * (-0.01031555 +
+          y * (0.02282967 + y * (-0.02895312 + y * (0.01787654 +
+          y * -0.00420059))))))))
+      end
+      x.negative? ? -value : value
+    end
+
+    # --- Rice (circular normal) distribution ---
+    # ISO 5878 Eq. 3 PDF:
+    #   f(v) = (2v/sigma_r^2) exp(-(v^2 + V_r^2)/sigma_r^2) I_0(2vV_r/sigma_r^2)
+
+    # Rice distribution PDF per ISO 5878 Eq. 3.
+    def self.rice_pdf(nu, vr, sigma_r)
+      return 0.0 if nu <= 0
+
+      sr2 = sigma_r * sigma_r
+      ratio = 2.0 * nu * vr / sr2
+      (2.0 * nu / sr2) * Math.exp(-(nu * nu + vr * vr) / sr2) * bessel_i0(ratio)
+    end
+
+    # Rice distribution CDF via adaptive Simpson quadrature on the PDF.
+    def self.rice_cdf(x, vr, sigma_r)
+      return 0.0 if x <= 0
+
+      sigma = sigma_r / Math.sqrt(2)
+
+      # Rayleigh limit for very small Vr
+      return 1.0 - Math.exp(-x * x / (2.0 * sigma * sigma)) if vr < sigma * 1e-6
+
+      adaptive_simpson(
+        ->(t) { rice_pdf(t, vr, sigma_r) },
+        0.0, x, 1e-10, 30
+      ).clamp(0.0, 1.0)
+    end
+
+    # Rice distribution inverse CDF (quantile function) via bisection.
+    def self.rice_inv_cdf(p, vr, sigma_r)
+      return 0.0 if p <= 0
+      return Float::INFINITY if p >= 1
+
+      sigma = sigma_r / Math.sqrt(2)
+
+      lo = 0.0
+      hi = sigma * Math.sqrt(-2.0 * Math.log(1 - p)) * 3 + vr + 4 * sigma
+
+      100.times do
+        mid = (lo + hi) / 2.0
+        cdf = rice_cdf(mid, vr, sigma_r)
+        if cdf < p
+          lo = mid
+        else
+          hi = mid
+        end
+        break if hi - lo < 1e-10
+      end
+      (lo + hi) / 2.0
+    end
+
+    # Rice distribution mean (scalar wind speed Vsc per ISO 5878 Eq. 4).
+    def self.rice_mean(vr, sigma_r)
+      sigma = sigma_r / Math.sqrt(2)
+      lambda = vr * vr / (4.0 * sigma * sigma)
+      prefactor = sigma * Math.sqrt(Math::PI / 2.0) * Math.exp(-lambda)
+      b0 = bessel_i0(lambda)
+      b1 = bessel_i1(lambda)
+      prefactor * ((1.0 + 2.0 * lambda) * b0 + 2.0 * lambda * b1)
+    end
+
+    # --- Main API (legacy) ---
+
+    WindDerivedFields = Struct.new(:vr, :sigma, :vsc, :percentiles, keyword_init: true)
+    PercentilePair = Struct.new(:low, :high, keyword_init: true)
+
+    # Compute wind distribution derived fields from observed parameters
+    # using the circular normal (Rice) distribution per ISO 5878 Section 5.4.
+    #
+    # @param vx [Float] Mean zonal component of the wind (m/s)
+    # @param vy [Float] Mean meridional component of the wind (m/s)
+    # @param sigma_r [Float] Standard deviation of the vector mean wind (m/s)
+    # @param use_absolute_vx [Boolean] For zones > 20degN where Vy ~ 0
+    def self.compute_wind_derived(vx, vy, sigma_r, use_absolute_vx: false)
+      vr = use_absolute_vx ? vx.abs : Math.sqrt(vx * vx + vy * vy)
+      sigma = sigma_r / Math.sqrt(2)
+
+      WindDerivedFields.new(
+        vr: vr,
+        sigma: sigma,
+        vsc: rice_mean(vr, sigma_r),
+        percentiles: {
+          1 => PercentilePair.new(
+            low: rice_inv_cdf(0.01, vr, sigma_r),
+            high: rice_inv_cdf(0.99, vr, sigma_r)
+          ),
+          10 => PercentilePair.new(
+            low: rice_inv_cdf(0.10, vr, sigma_r),
+            high: rice_inv_cdf(0.90, vr, sigma_r)
+          ),
+          20 => PercentilePair.new(
+            low: rice_inv_cdf(0.20, vr, sigma_r),
+            high: rice_inv_cdf(0.80, vr, sigma_r)
+          )
+        }
+      )
+    end
+
+    # Adaptive Simpson quadrature (iterative).
+    def self.adaptive_simpson(f, a, b, tol, max_depth)
+      fa = f.call(a)
+      fb = f.call(b)
+      m = (a + b) / 2.0
+      fm = f.call(m)
+      whole = (b - a) / 6.0 * (fa + 4.0 * fm + fb)
+
+      stack = [[a, b, fa, fb, fm, whole, tol, 0]]
+      total = 0.0
+
+      while (item = stack.pop)
+        la, lb, lfa, lfb, lfm, s_whole, l_tol, depth = item
+        lm = (la + lb) / 2.0
+        h = lb - la
+
+        lm1 = (la + lm) / 2.0
+        lm2 = (lm + lb) / 2.0
+        fm1 = f.call(lm1)
+        fm2 = f.call(lm2)
+        s_left = h / 12.0 * (lfa + 4.0 * fm1 + lfm)
+        s_right = h / 12.0 * (lfm + 4.0 * fm2 + lfb)
+        s_refined = s_left + s_right
+
+        if depth >= max_depth || (s_refined - s_whole).abs <= 15.0 * l_tol
+          total += s_refined + (s_refined - s_whole) / 15.0
+        else
+          stack.push([lm, lb, lfm, lfb, fm2, s_right, l_tol / 2.0, depth + 1])
+          stack.push([la, lm, lfa, lfm, fm1, s_left, l_tol / 2.0, depth + 1])
+        end
+      end
+
+      [[0.0, total].max, 1.0].min
+    end
+  end
+end

data/lib/atmospheris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Atmospheris
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/lib/atmospheris.rb

@@ -11,4 +11,5 @@ module Atmospheris
   autoload :UnitValueFloat, "atmospheris/unit_value_float"
   autoload :UnitValueInteger, "atmospheris/unit_value_integer"
   autoload :Export, "atmospheris/export"
+  autoload :Iso5878, "atmospheris/iso5878"
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atmospheris
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Ribose Inc.
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -53,15 +54,16 @@ dependencies:
         version: '0'
 description: |-
   Implementation of the ISO Standard Atmosphere (ISA) model as
-  defined in ISO 2533 and ICAO 7488/3 1994.
-  Reference implementation used in ISO 2533:2025."
+  defined in ISO 2533 and ICAO 7488/3 1994, plus ISO 5878
+  reference atmospheres with wind distribution (Rice) calculations.
+  Reference implementation used in ISO 2533:2025.
 email:
 - open.source@ribose.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- LICENSE.txt
 - README.adoc
+- LICENSE.txt
 files:
 - LICENSE.txt
 - README.adoc
@@ -85,18 +87,28 @@ files:
 - lib/atmospheris/export/iso_25332025.rb
 - lib/atmospheris/export/iso_25332025/altitude_attrs_group.rb
 - lib/atmospheris/export/iso_25332025/combined_altitude_attrs_group.rb
+- lib/atmospheris/export/iso_5878.rb
+- lib/atmospheris/export/iso_5878/atmosphere_profile_export.rb
+- lib/atmospheris/export/iso_5878/wind_table_export.rb
 - lib/atmospheris/export/precision_value.rb
 - lib/atmospheris/export/pressure_attrs.rb
 - lib/atmospheris/export/utils.rb
 - lib/atmospheris/isa.rb
+- lib/atmospheris/iso5878.rb
+- lib/atmospheris/iso5878/atmosphere_profile.rb
+- lib/atmospheris/iso5878/model_registry.rb
+- lib/atmospheris/iso5878/rice_distribution.rb
+- lib/atmospheris/iso5878/surface_parameters.rb
+- lib/atmospheris/iso5878/wind_observation.rb
 - lib/atmospheris/namespace.rb
 - lib/atmospheris/unit_value_float.rb
 - lib/atmospheris/unit_value_integer.rb
 - lib/atmospheris/version.rb
-homepage: https://github.com/metanorma/atmospheris
+homepage: https://github.com/atmospheris/atmospheris
 licenses:
 - BSD-2-Clause
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -111,7 +123,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
-summary: Implementation of the ISO Standard Atmosphere (ISA) model"
+summary: ISO 2533 Standard Atmosphere and ISO 5878 Reference Atmospheres
 test_files: []