atmospheris 0.5.1

data/lib/atmospheris/export/pressure_attrs.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  module Export
+    class PressureAttrs < Lutaml::Model::Serializable
+      include Utils
+      attribute :pressures, UnitValueFloat, collection: true
+      attribute :geometric_altitudes, UnitValueFloat, collection: true
+      attribute :geopotential_altitudes, UnitValueFloat, collection: true
+
+      key_value do
+        map "pressure", to: :pressures
+        map "geopotential-altitude", to: :geopotential_altitudes
+        map "geometric-altitude", to: :geometric_altitudes
+      end
+
+      xml do
+        element "hypsometrical-attributes"
+        namespace Atmospheris::Iso2533Namespace
+        map_element "pressure", to: :pressures
+        map_element "geometric-altitude", to: :geometric_altitudes
+        map_element "geopotential-altitude", to: :geopotential_altitudes
+      end
+
+      def set_pressure(value:, unit: :mbar, precision: :reduced)
+        method_name = "geopotential_altitude_from_pressure_#{unit}"
+        gp_h_m = Isa::NormalPrecision.instance.send(method_name, value)
+        gp_h_ft = m_to_ft(gp_h_m)
+        gm_h_m = Isa::NormalPrecision.instance.geometric_altitude_from_geopotential(gp_h_m)
+        gm_h_ft = m_to_ft(gm_h_m)
+
+        realize_altitudes(gm_h_m, gm_h_ft, gp_h_m, gp_h_ft, precision: precision)
+        realize_pressures(value, unit: unit)
+
+        self
+      end
+
+      def realize_altitudes(hgmm, hgmf, hgpm, hgpf, precision: :reduced)
+        self.geometric_altitudes = [
+          UnitValueFloat.new(
+            value: precision == :reduced ? hgmm.round(1) : hgmm,
+            unitsml: "m"
+          ),
+          UnitValueFloat.new(
+            value: precision == :reduced ? hgmf.round : hgmf,
+            unitsml: "ft"
+          )
+        ]
+
+        self.geopotential_altitudes = [
+          UnitValueFloat.new(
+            value: precision == :reduced ? hgpm.round(1) : hgpm,
+            unitsml: "m"
+          ),
+          UnitValueFloat.new(
+            value: precision == :reduced ? hgpf.round : hgpf,
+            unitsml: "ft"
+          )
+        ]
+      end
+
+      def realize_pressures(input, unit:)
+        self.pressures = case unit
+                         when :mbar
+                           [
+                             UnitValueFloat.new(value: input, unitsml: "mbar"),
+                             UnitValueFloat.new(
+                               value: Isa::NormalPrecision.instance.mbar_to_mmhg(input),
+                               unitsml: "mm_Hg"
+                             )
+                           ]
+                         when :mmhg
+                           [
+                             UnitValueFloat.new(
+                               value: Isa::NormalPrecision.instance.mmhg_to_mbar(input),
+                               unitsml: "mbar"
+                             ),
+                             UnitValueFloat.new(value: input, unitsml: "mm_Hg")
+                           ]
+                         else
+                           raise ArgumentError,
+                                 "Invalid unit: #{unit}. Use :mbar or :mmhg."
+                         end
+      end
+    end
+  end
+end

data/lib/atmospheris/export/utils.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  module Export
+    module Utils
+      def values_in_m_ft(value, unit: :meters)
+        case unit
+        when :meters
+          [value.to_f, m_to_ft(value)]
+        when :feet
+          [ft_to_m(value), value.to_f]
+        end
+      end
+
+      def round_to_sig_figs(num, num_sig_figs)
+        return 0.0 if num.nil? || num.zero?
+
+        num.round(num_sig_figs - Math.log10(num.abs).ceil).to_f
+      end
+
+      def m_to_ft(meters)
+        meters / 0.3048
+      end
+
+      def ft_to_m(feet)
+        feet * 0.3048
+      end
+    end
+  end
+end

data/lib/atmospheris/export.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  module Export
+    autoload :Utils, "atmospheris/export/utils"
+    autoload :AltitudeTable, "atmospheris/export/altitude_table"
+    autoload :AltitudeConvertableModel, "atmospheris/export/altitude_convertable_model"
+    autoload :AltitudeAttrs, "atmospheris/export/altitude_attrs"
+    autoload :PressureAttrs, "atmospheris/export/pressure_attrs"
+    autoload :HypsometricalTable, "atmospheris/export/hypsometrical_table"
+    autoload :PrecisionValue, "atmospheris/export/precision_value"
+    autoload :Iso25331975, "atmospheris/export/iso_25331975"
+    autoload :Iso25331985, "atmospheris/export/iso_25331985"
+    autoload :Iso25331997, "atmospheris/export/iso_25331997"
+    autoload :Iso25332025, "atmospheris/export/iso_25332025"
+  end
+end

data/lib/atmospheris/isa.rb

@@ -0,0 +1,493 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/math"
+require "singleton"
+
+module Atmospheris
+  module Isa
+    # International Standard Atmosphere (ISA) (ISO 2533:1975)
+    # ICAO Standard Atmosphere (ICAO Doc 7488/3, 1994)
+
+    class Algorithms
+      attr_accessor :precision
+      attr_reader :pressure_layers, :constants, :sqrt2, :pi
+
+      def set_precision(precision)
+        @precision = precision == :high ? :high : :normal
+        remove_instance_variable(:@pressure_layers) \
+          if defined?(@pressure_layers)
+        make_constants
+      end
+
+      # 2.3 Geopotential and geometric altitides; acceleration of free fall
+
+      # 2.3 Formula (8)
+      # H to h
+      # h(m)
+      def geometric_altitude_from_geopotential(geopotential_alt)
+        @constants[:radius] * geopotential_alt \
+          / (@constants[:radius] - geopotential_alt)
+      end
+
+      # 2.3 Formula (9)
+      # h to H
+      # H(m)
+      def geopotential_altitude_from_geometric(geometric_alt)
+        @constants[:radius] * geometric_alt \
+          / (@constants[:radius] + geometric_alt)
+      end
+
+      # 2.3 Formula (7)
+      # g(h)
+      def gravity_at_geometric(geometric_alt)
+        temp = @constants[:radius] / (@constants[:radius] + geometric_alt)
+        @constants[:g_n] * temp * temp
+      end
+
+      def gravity_at_geopotential(geopotential_alt)
+        geometric_h = geometric_altitude_from_geopotential(geopotential_alt)
+        gravity_at_geometric(geometric_h)
+      end
+
+      # 2.4 Atmospheric composition and air molar mass
+
+      # 2.5 Physical characteristics of the atmosphere at mean sea level
+
+      # 2.6 Temperature and vertical temperature gradient
+
+      # Formula (11)
+      # T
+      def temperature_at_layer_from_geopotential(geopotential_alt)
+        lower_layer_index = locate_lower_layer(geopotential_alt)
+        lower_layer = TEMPERATURE_LAYERS[lower_layer_index]
+        beta = num(lower_layer[:B])
+        capital_t_b = num(lower_layer[:T])
+        capital_h_b = num(lower_layer[:H])
+
+        capital_t_b + (beta * (geopotential_alt - capital_h_b))
+      end
+
+      def temperature_at_layer_celcius(geopotential_alt)
+        kelvin_to_celsius(
+          temperature_at_layer_from_geopotential(geopotential_alt)
+        )
+      end
+
+      def locate_lower_layer(geopotential_alt)
+        # Return first layer if lower than lowest
+        return 0 if geopotential_alt < num(TEMPERATURE_LAYERS[0][:H])
+
+        # Return second last layer if beyond last layer
+        i = TEMPERATURE_LAYERS.length - 1
+        return i - 1 if geopotential_alt >= num(TEMPERATURE_LAYERS[i][:H])
+
+        # find last layer with H smaller than our H
+        TEMPERATURE_LAYERS.each_with_index do |layer, ind|
+          return ind - 1 if num(layer[:H]) > geopotential_alt
+        end
+
+        nil
+      end
+
+      # Table 4 - Temperature and vertical temperature gradients
+      #
+      TEMPERATURE_LAYERS = [
+        # H is Geopotential altitude (base altitude) above mean sea level, m
+        # T is Temperature, K
+        # B is Temperature gradient, "beta", K m^-1
+
+        # This line is from ICAO 7488/3
+        # { H: "-5000", T: "320.65", B: "-0.0065" },
+
+        # This line is from ISO 2533:1975
+        { H: "-2000", T: "301.15", B: "-0.0065" },
+        { H: "0",     T: "288.15", B: "-0.0065" },
+        { H: "11000", T: "216.65", B: "0"       },
+        { H: "20000", T: "216.65", B: "0.001"   },
+        { H: "32000", T: "228.65", B: "0.0028"  },
+        { H: "47000", T: "270.65", B: "0"       },
+        { H: "51000", T: "270.65", B: "-0.0028" },
+        { H: "71000", T: "214.65", B: "-0.002"  },
+        { H: "80000", T: "196.65" }
+      ].freeze
+
+      # 2.7 Pressure
+
+      # Base pressure values given defined `TEMPERATURE_LAYERS` and constants
+      def pressure_layers
+        return @pressure_layers if @pressure_layers
+
+        # assume TEMPERATURE_LAYERS index 1 base altitude is 0 (mean sea level)
+        p = []
+
+        TEMPERATURE_LAYERS.each_with_index do |_x, i|
+          last_i = i.zero? ? 0 : i - 1
+          last_layer = TEMPERATURE_LAYERS[last_i]
+          beta = num(last_layer[:B])
+
+          if num(last_layer[:H]) <= 0
+            p_b = @constants[:p_n]
+            capital_h_b = 0
+            capital_t_b = @constants[:T_n]
+          else
+            p_b = p[last_i]
+            capital_h_b = num(last_layer[:H])
+            capital_t_b = num(last_layer[:T])
+          end
+
+          current_layer = TEMPERATURE_LAYERS[i]
+          geopotential_alt = num(current_layer[:H])
+          temp = num(current_layer[:T])
+          height_diff = geopotential_alt - capital_h_b
+
+          p_i = if beta.zero?
+                  # Formula (13)
+                  pressure_formula_beta_zero(p_b, temp, height_diff)
+                else
+                  # Formula (12)
+                  pressure_formula_beta_nonzero(p_b, beta, capital_t_b,
+                                                height_diff)
+                end
+          p[i] = p_i
+        end
+
+        @pressure_layers = p
+      end
+
+      # Formula (12)
+      def pressure_formula_beta_nonzero(p_b, beta, temp, height_diff)
+        p_b * (1 + ((beta / temp) * height_diff)) \
+          **(-@constants[:g_n] / (beta * @constants[:R]))
+      end
+
+      # Formula (13)
+      def pressure_formula_beta_zero(p_b, temp, height_diff)
+        p_b *
+          Math.exp(-(@constants[:g_n] / (@constants[:R] * temp)) * height_diff)
+      end
+
+      # puts "PRE-CALCULATED PRESSURE LAYERS:"
+      # pp @pressure_layers
+
+      def pa_to_mmhg(pascal)
+        pascal * num("0.007500616827")
+      end
+
+      def pa_to_mbar(pascal)
+        pascal * num("0.01")
+      end
+
+      # Pressure for a given geopotential altitude `H` (m) above mean sea level
+      def pressure_from_geopotential(geopotential_alt)
+        i = locate_lower_layer(geopotential_alt)
+        lower_temperature_layer = TEMPERATURE_LAYERS[i]
+        beta = num(lower_temperature_layer[:B])
+        capital_h_b = num(lower_temperature_layer[:H])
+        capital_t_b = num(lower_temperature_layer[:T])
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        p_b = pressure_layers[i]
+        height_diff = geopotential_alt - capital_h_b
+
+        if beta.zero?
+          # Formula (13)
+          pressure_formula_beta_zero(p_b, temp, height_diff)
+        else
+          # Formula (12)
+          pressure_formula_beta_nonzero(p_b, beta, capital_t_b, height_diff)
+        end
+      end
+
+      def pressure_from_geopotential_mbar(geopotential_alt)
+        pa_to_mbar(pressure_from_geopotential(geopotential_alt))
+      end
+
+      def pressure_from_geopotential_mmhg(geopotential_alt)
+        pa_to_mmhg(pressure_from_geopotential(geopotential_alt))
+      end
+
+      def p_p_n_from_geopotential(geopotential_alt)
+        pressure_from_geopotential(geopotential_alt) / @constants[:p_n]
+      end
+
+      # 2.8 Density and specific weight
+
+      # Density for a given geopotential altitude `H` (m) above mean sea level
+      # Formula (14)
+      # rho
+      def density_from_geopotential(geopotential_alt)
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        p = pressure_from_geopotential(geopotential_alt)
+
+        p / (@constants[:R] * temp)
+      end
+
+      def rho_rho_n_from_geopotential(geopotential_alt)
+        density_from_geopotential(geopotential_alt) / @constants[:rho_n]
+      end
+
+      def root_rho_rho_n_from_geopotential(geopotential_alt)
+        sqrt(rho_rho_n_from_geopotential(geopotential_alt))
+      end
+
+      # Specific weight
+      # Formula (15)
+      # gamma
+      def specific_weight_from_geopotential(geopotential_alt)
+        density_from_geopotential(geopotential_alt) *
+          gravity_at_geopotential(geopotential_alt)
+      end
+
+      # 2.9 Pressure scale height
+      # Formula (16)
+      # H_p
+      def pressure_scale_height_from_temp(temp)
+        (@constants[:R] * temp) / @constants[:g_n]
+      end
+
+      def pressure_scale_height_from_geopotential(geopotential_alt)
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        (@constants[:R] * temp) / gravity_at_geopotential(geopotential_alt)
+      end
+
+      # 2.10 Air number density
+      # Formula (17)
+      # n
+      def air_number_density_from_geopotential(geopotential_alt)
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        p = pressure_from_geopotential(geopotential_alt)
+
+        @constants[:N_A] * p / (@constants[:R_star] * temp)
+      end
+
+      # 2.11 Mean air-particle speed
+      # Formula (18)
+      # v_bar
+      # CORRECT
+      def mean_air_particle_speed_from_temp(temp)
+        num("1.595769") * sqrt(@constants[:R] * temp)
+      end
+
+      def mean_air_particle_speed_from_geopotential(geopotential_alt)
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        mean_air_particle_speed_from_temp(temp)
+      end
+
+      # 2.12 Mean free path of air particles
+      # Formula (19)
+      # l
+      def mean_free_path_of_air_particles_from_geopotential(geopotential_alt)
+        # 1 / (sqrt(2) * Pi * (3.65e-10**2) * air_number_density
+        1 / (@sqrt2 * @pi * num("0.133225e-18") * \
+          air_number_density_from_geopotential(geopotential_alt))
+      end
+
+      # 2.13 Air-particle collision frequency
+      # Formula (20)
+      # omega
+      def air_particle_collision_frequency_from_temp(air_number_density, temp)
+        # 4 * (3.65e-10**2) * ...
+        4 * num("0.133225e-18") *
+          ((@pi / (@constants[:R_star] * @constants[:M]))**num("0.5")) *
+          air_number_density * @constants[:R_star] * (temp**num("0.5"))
+      end
+
+      def air_particle_collision_frequency_from_geopotential(geopotential_alt)
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        n = air_number_density_from_geopotential(geopotential_alt)
+        air_particle_collision_frequency_from_temp(n, temp)
+      end
+
+      # 2.14 Speed of sound
+      # Formula (21)
+      # a (ms-1)
+      # CORRECT
+      def speed_of_sound_from_temp(temp)
+        # `kappa` (ratio of c_p / c_v) = 1.4 (see 2.14)
+        kappa = num("1.4")
+        sqrt(kappa * @constants[:R] * temp)
+      end
+
+      def speed_of_sound_from_geopotential(geopotential_alt)
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        speed_of_sound_from_temp(temp)
+      end
+
+      # 2.15 Dynamic viscosity
+      # Formula (22)
+      # mu (Pa s)
+      def dynamic_viscosity(temp)
+        # Sutherland's empirical constants in the equation for dynamic viscosity
+        capital_b_s = num("1.458e-6")
+        capital_s = num("110.4")
+
+        (capital_b_s * (temp**num("1.5"))) / (temp + capital_s)
+      end
+
+      def dynamic_viscosity_from_geopotential(geopotential_alt)
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        dynamic_viscosity(temp)
+      end
+
+      # 2.16 Kinematic viscosity
+      # Formula (23)
+      # v
+      def kinematic_viscosity(temp)
+        dynamic_viscosity(temp) / @constants[:rho_n]
+      end
+
+      def kinematic_viscosity_from_geopotential(geopotential_alt)
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        dynamic_viscosity(temp) / density_from_geopotential(geopotential_alt)
+      end
+
+      # 2.17 Thermal conductivity
+      # Formula (24)
+      # lambda
+      def thermal_conductivity_from_temp(temp)
+        (num("2.648151e-3") * (temp**num("1.5"))) \
+          / (temp + (num("245.4") * (num("10")**(num("-12") / temp))))
+      end
+
+      def thermal_conductivity_from_geopotential(geopotential_alt)
+        temp = temperature_at_layer_from_geopotential(geopotential_alt)
+        thermal_conductivity_from_temp(temp)
+      end
+
+      def kelvin_to_celsius(kelvin)
+        kelvin - num("273.15")
+      end
+
+      # ADD 1
+      # Formulae used in the calculation of the relationships
+      # between geopotential altitude and pressure
+      def geopotential_altitude_from_pressure_mbar(pressure)
+        if pressure >= pa_to_mbar(pressure_layers[2]) # H <= 11 000 m
+          (num("3.731444") - pressure**num("0.1902631")) / num("8.41728e-5")
+        elsif pressure >= pa_to_mbar(pressure_layers[3]) # H <= 20 000 m
+          (num("3.1080387") - log10(pressure)) / num("6.848325e-5")
+        elsif pressure >= pa_to_mbar(pressure_layers[4]) # H <= 32 000 m
+          (num("1.2386515") - pressure**num("0.02927125")) \
+/ (num("5.085177e-6") * pressure**num("0.02927125"))
+        elsif pressure >= pa_to_mbar(pressure_layers[5]) # H <= 47 000 m
+          (num("1.9630052") - pressure**num("0.08195949")) \
+/ (num("2.013664e-5") * pressure**num("0.08195949"))
+        end
+      end
+
+      def geopotential_altitude_from_pressure_mmhg(pressure)
+        if pressure >= pa_to_mmhg(pressure_layers[2]) # H <= 11 000 m
+          (num("3.532747") - pressure**num("0.1902631")) / num("7.96906e-5")
+        elsif pressure >= pa_to_mmhg(pressure_layers[3]) # H <= 20 000 m
+          (num("2.9831357") - log10(pressure)) / num("6.848325e-5")
+        elsif pressure >= pa_to_mmhg(pressure_layers[4]) # H <= 32 000 m
+          (num("1.2282678") - pressure**num("0.02927125")) \
+            / (num("5.085177e-6") * pressure**num("0.02927125"))
+        elsif pressure >= pa_to_mmhg(pressure_layers[5]) # H <= 47 000 m
+          (num("1.9172753") - pressure**num("0.08195949")) \
+            / (num("2.013664e-5") * pressure**num("0.08195949"))
+        end
+      end
+
+      def mbar_to_mmhg(mbar)
+        # Convert mbar to Pa, then Pa to mmHg
+        pa = mbar / num("0.01") # or mbar * 100
+        pa_to_mmhg(pa)
+      end
+
+      def mmhg_to_mbar(mmhg)
+        # Convert mmHg to Pa, then Pa to mbar
+        pa = mmhg / num("0.007500616827")
+        pa_to_mbar(pa)
+      end
+
+      private
+
+      def num(str)
+        if @precision == :high
+          BigDecimal(str)
+        else
+          str.to_f
+        end
+      end
+
+      def sqrt(num)
+        if @precision == :high
+          BigMath.sqrt(num, 100)
+        else
+          Math.sqrt(num)
+        end
+      end
+
+      def log10(num)
+        if @precision == :high
+          BigMath.log(num, 100) / BigMath.log(10, 100)
+        else
+          Math.log10(num)
+        end
+      end
+
+      def make_constants
+        # 2.1 Primary constants and characteristics
+        # Table 1 - Main constants and characteristics adopted for
+        #           the calculation of the ISO Standard Atmosphere
+        @constants = {
+          # g_n gravitation at mean sea level (m.s-2)
+          g_n: num("9.80665"),
+
+          # Avogadro constant (mol-1)
+          N_A: num("6.02257e+23"),
+
+          # p_n pressure at mean sea level (Pa)
+          p_n: num("101325"),
+
+          # rho_n standard air density
+          rho_n: num("1.225"),
+
+          # T_n standard thermodynamic air temperature at mean sea level
+          T_n: num("288.15"),
+
+          # universal gas constant
+          R_star: num("8.31432"),
+
+          # radius of the Earth (m)
+          radius: num("6356766"),
+
+          # adiabatic index (dimensionless)
+          k: num("1.4")
+        }
+
+        # 2.2 The equation of the static atmosphere and the perfect gas law
+        # Formula (2)
+        # M: air molar mass at sea level, kg.kmol-1
+        # Value given in 2.1 as M: 28.964720
+        @constants[:M] =
+          (@constants[:rho_n] * @constants[:R_star] * @constants[:T_n]) / @constants[:p_n]
+
+        # Formula (3)
+        # R: specific gas constant, J.K-1.kg-1.
+        # Value given in 2.1 as R: 287.05287
+        @constants[:R] = @constants[:R_star] / @constants[:M]
+
+        @sqrt2 = sqrt(num("2"))
+        @pi = @precision == :high ? BigMath.PI(100) : Math::PI
+      end
+    end
+
+    class HighPrecision < Algorithms
+      include Singleton
+
+      def initialize
+        set_precision(:high)
+      end
+    end
+
+    class NormalPrecision < Algorithms
+      include Singleton
+
+      def initialize
+        set_precision(:normal)
+      end
+    end
+  end
+end

data/lib/atmospheris/namespace.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  class Iso2533Namespace < Lutaml::Xml::W3c::XmlNamespace
+    prefix_default "iso2533"
+    uri "urn:iso:std:iso:2533:tech:xsd"
+  end
+end

data/lib/atmospheris/unit_value_float.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  class UnitValueFloat < Lutaml::Model::Serializable
+    attribute :value, :float
+    attribute :unitsml, :string
+    attribute :type, :string, default: -> { "float" }
+
+    key_value do
+      map "value", to: :value
+      map "unitsml", to: :unitsml
+      map "type", to: :type, render_default: true
+    end
+
+    xml do
+      element "unit-value-float"
+      namespace Atmospheris::Iso2533Namespace
+      map_content to: :value
+      map_attribute :unitsml, to: :unitsml
+      map_attribute :type, to: :type, render_default: true
+    end
+  end
+end

data/lib/atmospheris/unit_value_integer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Atmospheris
+  class UnitValueInteger < Lutaml::Model::Serializable
+    attribute :value, :integer
+    attribute :unitsml, :string
+    attribute :type, :string, default: -> { "integer" }
+
+    key_value do
+      map "value", to: :value
+      map "unitsml", to: :unitsml
+      map "type", to: :type, render_default: true
+    end
+
+    xml do
+      element "unit-value-integer"
+      namespace Atmospheris::Iso2533Namespace
+      map_content to: :value
+      map_attribute :unitsml, to: :unitsml
+      map_attribute :type, to: :type, render_default: true
+    end
+  end
+end

data/lib/atmospheris/version.rb

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