atmospheric 0.4.3 → 0.4.4

data/lib/atmospheric/export/altitude_attrs.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "../unit_value_float"
+require_relative "../unit_value_integer"
+
+module Atmospheric
+  module Export
+    class AltitudeAttrs < Lutaml::Model::Serializable
+      include AltitudeConvertableModel
+
+      # From Group One
+      attribute :temperature_k, UnitValueFloat
+      attribute :temperature_c, UnitValueFloat
+      attribute :pressure_mbar, UnitValueFloat
+      attribute :pressure_mmhg, UnitValueFloat
+      attribute :density, UnitValueFloat
+      attribute :acceleration, UnitValueFloat
+
+      # From Group Two
+      attribute :ppn, UnitValueFloat
+      attribute :rhorhon, UnitValueFloat
+      attribute :sqrt_rhorhon, UnitValueFloat
+      attribute :speed_of_sound, UnitValueFloat
+      attribute :dynamic_viscosity, UnitValueFloat
+      attribute :kinematic_viscosity, UnitValueFloat
+      attribute :thermal_conductivity, UnitValueFloat
+
+      # From Group Three
+      attribute :pressure_scale_height, UnitValueFloat
+      attribute :specific_weight, UnitValueFloat
+      attribute :air_number_density, UnitValueFloat
+      attribute :mean_speed, UnitValueFloat
+      attribute :frequency, UnitValueFloat
+      attribute :mean_free_path, UnitValueFloat
+
+      key_value do
+        map "geometric-altitude-m", to: :geometric_altitude_m
+        map "geometric-altitude-ft", to: :geometric_altitude_ft
+        map "geopotential-altitude-m", to: :geopotential_altitude_m
+        map "geopotential-altitude-ft", to: :geopotential_altitude_ft
+
+        # From Group One
+        map "temperature-k", to: :temperature_k
+        map "temperature-c", to: :temperature_c
+        map "pressure-mbar", to: :pressure_mbar
+        map "pressure-mmhg", to: :pressure_mmhg
+        map "density", to: :density
+        map "acceleration", to: :acceleration
+
+        # From Group Two
+        map "ppn", to: :ppn
+        map "rhorhon", to: :rhorhon
+        map "sqrt-rhorhon", to: :sqrt_rhorhon
+        map "speed-of-sound", to: :speed_of_sound
+        map "dynamic-viscosity", to: :dynamic_viscosity
+        map "kinematic-viscosity", to: :kinematic_viscosity
+        map "thermal-conductivity", to: :thermal_conductivity
+
+        # From Group Three
+        map "pressure-scale-height", to: :pressure_scale_height
+        map "specific-weight", to: :specific_weight
+        map "air-number-density", to: :air_number_density
+        map "mean-speed", to: :mean_speed
+        map "frequency", to: :frequency
+        map "mean-free-path", to: :mean_free_path
+      end
+
+      xml do
+        root "atmosphere-attributes"
+        map_element "geometric-altitude-m", to: :geometric_altitude_m
+        map_element "geometric-altitude-ft", to: :geometric_altitude_ft
+        map_element "geopotential-altitude-m", to: :geopotential_altitude_m
+        map_element "geopotential-altitude-ft", to: :geopotential_altitude_ft
+
+        # From Group One
+        map_element "temperature-k", to: :temperature_k
+        map_element "temperature-c", to: :temperature_c
+        map_element "pressure-mbar", to: :pressure_mbar
+        map_element "pressure-mmhg", to: :pressure_mmhg
+        map_element "density", to: :density
+        map_element "acceleration", to: :acceleration
+
+        # From Group Two
+        map_element "ppn", to: :ppn
+        map_element "rhorhon", to: :rhorhon
+        map_element "sqrt-rhorhon", to: :sqrt_rhorhon
+        map_element "speed-of-sound", to: :speed_of_sound
+        map_element "dynamic-viscosity", to: :dynamic_viscosity
+        map_element "kinematic-viscosity", to: :kinematic_viscosity
+        map_element "thermal-conductivity", to: :thermal_conductivity
+
+        # From Group Three
+        map_element "pressure-scale-height", to: :pressure_scale_height
+        map_element "specific-weight", to: :specific_weight
+        map_element "air-number-density", to: :air_number_density
+        map_element "mean-speed", to: :mean_speed
+        map_element "frequency", to: :frequency
+        map_element "mean-free-path", to: :mean_free_path
+      end
+
+      # In meters only
+      def realize_values_from_geopotential(gp_h_m, precision: :reduced)
+        %i[
+          temperature_k temperature_c pressure_mbar pressure_mmhg density
+          acceleration ppn rhorhon sqrt_rhorhon speed_of_sound
+          dynamic_viscosity kinematic_viscosity thermal_conductivity
+          pressure_scale_height specific_weight air_number_density mean_speed
+          frequency mean_free_path
+        ].each do |attr|
+          v = calculate(gp_h_m, attr, precision: precision)
+          send("#{attr}=", v) if respond_to?("#{attr}=")
+        end
+      end
+
+      def calculate(gp_h_m, name, precision: :reduced)
+        case name
+        when :temperature_k
+          v = Isa::NormalPrecision.instance.temperature_at_layer_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? (v * 1000.0).round : v,
+            unitsml: "K"
+          )
+        when :temperature_c
+          v = Isa::NormalPrecision.instance.temperature_at_layer_celcius(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? (v * 1000.0).round : v,
+            unitsml: "degC"
+          )
+        when :pressure_mbar
+          v = Isa::NormalPrecision.instance.pressure_from_geopotential_mbar(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 6) : v,
+            unitsml: "mbar"
+          )
+        when :pressure_mmhg
+          v = Isa::NormalPrecision.instance.pressure_from_geopotential_mmhg(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 6) : v,
+            unitsml: "u:mm_Hg"
+          )
+        when :density
+          v = Isa::NormalPrecision.instance.density_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 6) : v,
+            unitsml: "kg*m^-3"
+          )
+        when :acceleration
+          v = Isa::NormalPrecision.instance.gravity_at_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? v.round(4) : v,
+            unitsml: "m*s^-2"
+          )
+        when :ppn
+          v = Isa::NormalPrecision.instance.p_p_n_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 6) : v,
+            unitsml: nil
+          )
+        when :rhorhon
+          v = Isa::NormalPrecision.instance.rho_rho_n_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 6) : v,
+            unitsml: nil
+          )
+        when :sqrt_rhorhon
+          v = Isa::NormalPrecision.instance.root_rho_rho_n_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 6) : v,
+            unitsml: nil
+          )
+        when :speed_of_sound
+          v = Isa::NormalPrecision.instance.speed_of_sound_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? (v * 1000.0).round : v,
+            unitsml: "m*s^-1"
+          )
+        when :dynamic_viscosity
+          v = Isa::NormalPrecision.instance.dynamic_viscosity_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 5) : v,
+            unitsml: "Pa*s"
+          )
+        when :kinematic_viscosity
+          v = Isa::NormalPrecision.instance.kinematic_viscosity_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 5) : v,
+            unitsml: "m^2*s^-1"
+          )
+        when :thermal_conductivity
+          v = Isa::NormalPrecision.instance.thermal_conductivity_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 5) : v,
+            unitsml: "W*m^-1*K^-1"
+          )
+        when :pressure_scale_height
+          v = Isa::NormalPrecision.instance.pressure_scale_height_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? v.round(1) : v,
+            unitsml: "m"
+          )
+        when :specific_weight
+          v = Isa::NormalPrecision.instance.specific_weight_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 5) : v,
+            unitsml: "N*m^-3"
+          )
+        when :air_number_density
+          v = Isa::NormalPrecision.instance.air_number_density_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 5) : v,
+            unitsml: "m^-3"
+          )
+        when :mean_speed
+          v = Isa::NormalPrecision.instance.mean_air_particle_speed_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? v.round(2) : v,
+            unitsml: "m*s^-1"
+          )
+        when :frequency
+          v = Isa::NormalPrecision.instance.air_particle_collision_frequency_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 5) : v,
+            unitsml: "s^-1"
+          )
+        when :mean_free_path
+          v = Isa::NormalPrecision.instance.mean_free_path_of_air_particles_from_geopotential(gp_h_m)
+          UnitValueFloat.new(
+            value: precision == :reduced ? round_to_sig_figs(v, 5) : v,
+            unitsml: "m"
+          )
+        else
+          raise ArgumentError, "Unknown attribute: #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/atmospheric/export/altitude_convertable_model.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "utils"
+require_relative "../unit_value_float"
+require_relative "../unit_value_integer"
+
+module Atmospheric
+  module Export
+    module AltitudeConvertableModel
+      include Utils
+
+      def self.included(base)
+        base.class_eval do
+          attribute :geometric_altitude_m, UnitValueInteger
+          attribute :geometric_altitude_ft, UnitValueInteger
+          attribute :geopotential_altitude_m, UnitValueInteger
+          attribute :geopotential_altitude_ft, UnitValueInteger
+        end
+      end
+
+      def set_altitude(value:, type: :geometric, unit: :meters,
+                       precision: :reduced)
+        case type
+        when :geometric
+          set_geometric_altitude(value, unit: unit, precision: precision)
+        when :geopotential
+          set_geopotential_altitude(value, unit: unit, precision: precision)
+        else
+          raise ArgumentError,
+                "Invalid type: #{type}. Use :geometric or :geopotential."
+        end
+
+        self
+      end
+
+      def set_geopotential_altitude(h, unit: :meters, precision: :reduced)
+        hgpm, hgpf = values_in_m_ft(h, unit: unit)
+        hgmm = Isa::NormalPrecision.instance.geometric_altitude_from_geopotential(hgpm)
+        hgmf = m_to_ft(hgmm).round
+        # TODO: We have to used reduced here because we must round values for
+        # the Integer data type as defined.
+        realize_altitudes(hgmm, hgmf, hgpm, hgpf, precision: :reduced)
+        realize_values_from_geopotential(hgpm, precision: precision)
+      end
+
+      def set_geometric_altitude(h, unit: :meters, precision: :reduced)
+        hgmm, hgmf = values_in_m_ft(h, unit: unit)
+        hgpm = Isa::NormalPrecision.instance.geopotential_altitude_from_geometric(hgmm)
+        hgpf = m_to_ft(hgpm).round
+        # TODO: We have to used reduced here because we must round values for
+        # the Integer data type as defined.
+        realize_altitudes(hgmm, hgmf, hgpm, hgpf, precision: :reduced)
+        realize_values_from_geopotential(hgpm, precision: precision)
+      end
+
+      def realize_altitudes(hgmm, hgmf, hgpm, hgpf, precision: :reduced)
+        self.geometric_altitude_m = UnitValueInteger.new(
+          value: precision == :reduced ? hgmm.round : hgmm,
+          unitsml: "m"
+        )
+
+        self.geometric_altitude_ft = UnitValueInteger.new(
+          value: precision == :reduced ? hgmf.round : hgmf,
+          unitsml: "ft"
+        )
+
+        self.geopotential_altitude_m = UnitValueInteger.new(
+          value: precision == :reduced ? hgpm.round : hgpm,
+          unitsml: "m"
+        )
+
+        self.geopotential_altitude_ft = UnitValueInteger.new(
+          value: precision == :reduced ? hgpf.round : hgpf,
+          unitsml: "ft"
+        )
+      end
+
+      def realize_values_from_geopotential(gp_h_m, precision:)
+        raise NotImplementedError,
+              "realize_values_from_geopotential method must be implemented in the including class"
+      end
+    end
+  end
+end

data/lib/atmospheric/export/altitude_table.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Atmospheric
+  module Export
+    class AltitudeTable < Lutaml::Model::Serializable
+      # Step 50 from -2k to 40k, step 100 above 32k, 200 above 51k to 80k
+      def steps
+        ((-2000..31_950).step(50) +
+         (32_000..50_900).step(100) +
+         (51_000..80_000).step(200))
+      end
+
+      def steps_unit
+        :meters
+      end
+
+      def add_to_geometric(item)
+        by_geometric_altitude << item
+      end
+
+      def add_to_geopotential(item)
+        by_geopotential_altitude << item
+      end
+
+      def initialize_attrs
+        self.by_geometric_altitude = []
+        self.by_geopotential_altitude = []
+      end
+
+      def set_attrs(klass:, unit: steps_unit, precision: :normal)
+        initialize_attrs
+
+        steps.each do |h|
+          add_to_geometric(
+            klass.new.set_altitude(
+              type: :geometric, unit: unit, value: h, precision: precision
+            )
+          )
+          add_to_geopotential(
+            klass.new.set_altitude(
+              type: :geopotential, unit: unit, value: h, precision: precision
+            )
+          )
+        end
+        self
+      end
+    end
+  end
+end

data/lib/atmospheric/export/hypsometrical_table.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "pressure_attrs"
+
+module Atmospheric
+  module Export
+    class HypsometricalTable < Lutaml::Model::Serializable
+      attribute :rows, PressureAttrs, collection: true
+
+      xml do
+        root "atmospheric"
+        map_element "hypsometrical-attributes", to: :rows
+      end
+
+      def steps
+        (0..0)
+      end
+
+      def steps_unit
+        :mbar
+      end
+
+      def initialize_attrs
+        self.rows = []
+      end
+
+      def set_attrs(klass: PressureAttrs, unit: steps_unit, precision: :reduced)
+        initialize_attrs
+
+        steps.each do |p|
+          rows << klass.new.set_pressure(value: p, unit: unit, precision: precision)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/atmospheric/export/iso_25331975/group_one.rb

@@ -1,36 +1,24 @@
-require_relative "./group_base"
-# rubocop:disable Metrics/AbcSize
-# rubocop:disable Metrics/BlockLength
-# rubocop:disable Metrics/CyclomaticComplexity
-# rubocop:disable Metrics/MethodLength
-# rubocop:disable Metrics/PerceivedComplexity
-# rubocop:disable Layout/LineLength
-# rubocop:disable Layout/HashAlignment
+# frozen_string_literal: true
+
+require_relative "../altitude_table"
+require_relative "group_one_attrs"
+
 module Atmospheric
   module Export
     module Iso25331975
+      class GroupOne < AltitudeTable
+        attribute :by_geometric_altitude, GroupOneAttrs, collection: true
+        attribute :by_geopotential_altitude, GroupOneAttrs, collection: true
 
-      class GroupOne < GroupBase
-        # In meters only
-        def row_from_geopotential(gp_h_f)
-          {
-            "temperature-K" => (Isa.temperature_at_layer_from_geopotential(gp_h_f) * 1000.0).round,
-            "temperature-C" => (Isa.temperature_at_layer_celcius(gp_h_f) * 1000.0).round,
-            "pressure-mbar" => round_to_sig_figs(Isa.pressure_from_geopotential_mbar(gp_h_f), 6),
-            "pressure-mmhg" => round_to_sig_figs(Isa.pressure_from_geopotential_mmhg(gp_h_f), 6),
-            "density"       => round_to_sig_figs(Isa.density_from_geopotential(gp_h_f), 6),
-            "acceleration"  => Isa.gravity_at_geopotential(gp_h_f).round(4),
-          }
+        key_value do
+          map "by-geometric-altitude", to: :by_geometric_altitude
+          map "by-geopotential-altitude", to: :by_geopotential_altitude
+        end
+
+        def set_attrs(klass: GroupOneAttrs, unit: steps_unit, precision: :reduced)
+          super
         end
       end
     end
-
   end
 end
-# rubocop:enable Metrics/AbcSize
-# rubocop:enable Metrics/BlockLength
-# rubocop:enable Metrics/CyclomaticComplexity
-# rubocop:enable Metrics/MethodLength
-# rubocop:enable Metrics/PerceivedComplexity
-# rubocop:enable Layout/LineLength
-# rubocop:enable Layout/HashAlignment

data/lib/atmospheric/export/iso_25331975/group_one_attrs.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "../altitude_convertable_model"
+
+module Atmospheric
+  module Export
+    module Iso25331975
+      class GroupOneAttrs < Lutaml::Model::Serializable
+        include AltitudeConvertableModel
+
+        attribute :temperature_k, UnitValueInteger
+        attribute :temperature_c, UnitValueInteger
+        attribute :pressure_mbar, UnitValueFloat
+        attribute :pressure_mmhg, UnitValueFloat
+        attribute :density, UnitValueFloat
+        attribute :acceleration, UnitValueFloat
+
+        key_value do
+          map "geometric-altitude-m", to: :geometric_altitude_m
+          map "geometric-altitude-ft", to: :geometric_altitude_ft
+          map "geopotential-altitude-m", to: :geopotential_altitude_m
+          map "geopotential-altitude-ft", to: :geopotential_altitude_ft
+          map "temperature-k", to: :temperature_k
+          map "temperature-c", to: :temperature_c
+          map "pressure-mbar", to: :pressure_mbar
+          map "pressure-mmhg", to: :pressure_mmhg
+          map "density", to: :density
+          map "acceleration", to: :acceleration
+        end
+
+        # In meters only
+        def realize_values_from_geopotential(gp_h_m, precision: :reduced)
+          %i[
+            temperature_k temperature_c pressure_mbar pressure_mmhg density
+            acceleration
+          ].each do |attr|
+            v = calculate(gp_h_m, attr, precision: precision)
+            send("#{attr}=", v) if respond_to?("#{attr}=")
+          end
+        end
+
+        def calculate(gp_h_m, name, precision: :reduced)
+          case name
+          when :temperature_k
+            v = Isa::NormalPrecision.instance.temperature_at_layer_from_geopotential(gp_h_m)
+            UnitValueInteger.new(
+              value: precision == :reduced ? (v * 1000.0).round : v,
+              unitsml: "K"
+            )
+          when :temperature_c
+            v = Isa::NormalPrecision.instance.temperature_at_layer_celcius(gp_h_m)
+            UnitValueInteger.new(
+              value: precision == :reduced ? (v * 1000.0).round : v,
+              unitsml: "degC"
+            )
+          when :pressure_mbar
+            v = Isa::NormalPrecision.instance.pressure_from_geopotential_mbar(gp_h_m)
+            UnitValueFloat.new(
+              value: precision == :reduced ? round_to_sig_figs(v, 6) : v,
+              unitsml: "mbar"
+            )
+          when :pressure_mmhg
+            v = Isa::NormalPrecision.instance.pressure_from_geopotential_mmhg(gp_h_m)
+            UnitValueFloat.new(
+              value: precision == :reduced ? round_to_sig_figs(v, 6) : v,
+              unitsml: "u:mm_Hg"
+            )
+          when :density
+            v = Isa::NormalPrecision.instance.density_from_geopotential(gp_h_m)
+            UnitValueFloat.new(
+              value: precision == :reduced ? round_to_sig_figs(v, 6) : v,
+              unitsml: "kg*m^-3"
+            )
+          when :acceleration
+            v = Isa::NormalPrecision.instance.gravity_at_geopotential(gp_h_m)
+            UnitValueFloat.new(
+              value: precision == :reduced ? v.round(4) : v,
+              unitsml: "m*s^-2"
+            )
+          else
+            raise ArgumentError, "Unknown attribute: #{name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/atmospheric/export/iso_25331975/group_three.rb

@@ -1,37 +1,24 @@
-require_relative "./group_base"
-# rubocop:disable Metrics/AbcSize
-# rubocop:disable Metrics/BlockLength
-# rubocop:disable Metrics/CyclomaticComplexity
-# rubocop:disable Metrics/MethodLength
-# rubocop:disable Metrics/PerceivedComplexity
-# rubocop:disable Layout/LineLength
-# rubocop:disable Layout/HashAlignment
+# frozen_string_literal: true
+
+require_relative "../altitude_table"
+require_relative "group_three_attrs"
+
 module Atmospheric
   module Export
     module Iso25331975
+      class GroupThree < AltitudeTable
+        attribute :by_geometric_altitude, GroupThreeAttrs, collection: true
+        attribute :by_geopotential_altitude, GroupThreeAttrs, collection: true
 
-      class GroupThree < GroupBase
-        # In meters only
-        def row_from_geopotential(gp_h_f)
-          {
-            "pressure-scale-height" => Isa.pressure_scale_height_from_geopotential(gp_h_f).round(1),
-            "specific-weight"       => round_to_sig_figs(Isa.specific_weight_from_geopotential(gp_h_f), 5),
-            "air-number-density"    => round_to_sig_figs(Isa.air_number_density_from_geopotential(gp_h_f), 5),
-            "mean-speed"            => Isa.mean_air_particle_speed_from_geopotential(gp_h_f).round(2),
-            "frequency"             => round_to_sig_figs(Isa.air_particle_collision_frequency_from_geopotential(gp_h_f), 5),
-            "mean-free-path"        => round_to_sig_figs(Isa.mean_free_path_of_air_particles_from_geopotential(gp_h_f), 5),
-          }
+        key_value do
+          map "by-geometric-altitude", to: :by_geometric_altitude
+          map "by-geopotential-altitude", to: :by_geopotential_altitude
         end
 
+        def set_attrs(klass: GroupThreeAttrs, unit: steps_unit, precision: :reduced)
+          super
+        end
       end
     end
-
   end
 end
-# rubocop:enable Metrics/AbcSize
-# rubocop:enable Metrics/BlockLength
-# rubocop:enable Metrics/CyclomaticComplexity
-# rubocop:enable Metrics/MethodLength
-# rubocop:enable Metrics/PerceivedComplexity
-# rubocop:enable Layout/LineLength
-# rubocop:enable Layout/HashAlignment