gravitheque 0.4.0 → 0.5.0

data/lib/calculators/calories.rb

@@ -1,115 +0,0 @@
-require "conversions/extract"
-
-module Calculate
-
-  # Calculates calories derived from alcohol content.
-  # Supported extract units are `:brix`, `:plato` and `:specific_gravity`. Default: `:plato`
-  #
-  # @example
-  #    Calculate.calories_from_alcohol({ original: 17.5, terminal: 3.2 })
-  #
-  #    Calculate.calories_from_alcohol({
-  #      original: 1.055,
-  #      terminal: 1.010
-  #    }, :specific_gravity)
-  #
-  #    Calculate.calories_from_alcohol({
-  #      original: 15.2,
-  #      terminal: 7.8
-  #    }, :brix)
-  #
-  # @param [Hash] extract the original and terminal extract levels
-  # @param [Symbol] unit the unit used to measure extract
-  # @return [Fixnum] the total calories from alcohol per 500ml
-  def self.calories_from_alcohol extract, units = :plato
-    original = extract[:original]
-    terminal = extract[:terminal]
-
-    unless units == :specific_gravity
-      case units
-      when :brix
-        original = Convert.brix_to_specific_gravity extract[:original]
-        terminal = Convert.terminal_brix_to_terminal_gravity extract[:original], extract[:terminal]
-      when :plato
-        original = Convert.plato_to_specific_gravity extract[:original]
-        terminal = Convert.plato_to_specific_gravity extract[:terminal]
-      else
-        raise ArgumentError, "#{units} is an unknown unit of extract. Use :brix, :plato or :specific_gravity"
-      end
-    end
-
-    calories = (1881.22 * terminal) *
-               ((original - terminal) /
-               (1.775 - original))
-
-    (calories + (calories * 0.33)).round
-  end
-
-  # Calculates calories derived from extract.
-  # Supported extract units are `:brix`, `:plato` and `:specific_gravity`. Default: `:plato`
-  #
-  # @example
-  #     Calculate.calories_from_extract({ original: 17.5, terminal: 3.2 })
-  #
-  #     Calculate.calories_from_extract({
-  #       original: 1.055,
-  #       terminal: 1.010
-  #     }, :specific_gravity)
-  #
-  #     Calculate.calories_from_extract({
-  #       original: 15.2,
-  #       terminal: 7.8
-  #     }, :brix)
-  #
-  # @param [Hash] extract the original and terminal extract levels
-  # @param [Symbol] unit the unit used to measure extract
-  # @return [Fixnum] the total calories from extract per 500ml
-  def self.calories_from_extract extract, units = :plato
-    original = extract[:original]
-    terminal = extract[:terminal]
-
-    unless units == :specific_gravity
-      case units
-      when :brix
-        original = Convert.brix_to_specific_gravity extract[:original]
-        terminal = Convert.terminal_brix_to_terminal_gravity extract[:original], extract[:terminal]
-      when :plato
-        original = Convert.plato_to_specific_gravity extract[:original]
-        terminal = Convert.plato_to_specific_gravity extract[:terminal]
-      else
-        raise ArgumentError, "#{units} is an unknown unit of extract. Use :brix, :plato or :specific_gravity"
-      end
-    end
-
-    calories  = 3550.0 * terminal *
-                ((0.1808 * original) +
-                (0.8192 * terminal) - 1.0004)
-
-    (calories + (calories * 0.33)).round
-  end
-
-  # Calculates calories per serving.
-  # Supported extract units are `:brix`, `:plato` and `:specific_gravity`. Default: `:plato`
-  #
-  # @example
-  #     Calculate.calories_per_serving({ original: 17.5, terminal: 3.2 })
-  #
-  #     Calculate.calories_per_serving({
-  #       original: 1.055,
-  #       terminal: 1.010
-  #     }, :specific_gravity)
-  #
-  #     Calculate.calories_per_serving({
-  #       original: 15.2,
-  #       terminal: 7.8
-  #     }, :brix)
-  #
-  # @param [Hash] extract the original and terminal extract levels
-  # @param [Symbol] unit the unit used to measure extract
-  # @return [Fixnum] the total calories per 500ml
-  def self.calories_per_serving extract, units = :plato
-    (calories_from_alcohol extract, units) +
-    (calories_from_extract extract, units)
-  end
-
-end

data/lib/calculators/hops.rb

@@ -1,257 +0,0 @@
-require "conversions/extract"
-require "conversions/mass"
-require "conversions/volume"
-
-module Calculate
-
-  # Calculates hop utilization.
-  # Supported extract units are `:brix`, `:plato` and `:specific_gravity`. Default: `:plato`
-  #
-  # @example
-  #     Calculate.hop_utilization({ at: 20, extract: 12 })
-  #     Calculate.hop_utilization({ at: 20, extract: 12 }, :brix)
-  #     Calculate.hop_utilization({ at: 20, extract: 12 }, :specific_gravity)
-  #
-  # @param [Hash] data the extract level and time added
-  # @param [Symbol] unit the unit used to measure extract
-  # @return [Float] hop utilization
-  def self.hop_utilization data, units = :plato
-    unless units == :specific_gravity
-      data[:extract] = case units
-      when :brix then Convert.brix_to_specific_gravity data[:extract]
-      when :plato then Convert.plato_to_specific_gravity data[:extract]
-      else raise ArgumentError, "#{units} is an unknown unit of extract. Use :brix, :plato or :specific_gravity"
-      end
-    end
-
-    ((hop_extract_adjustment data[:extract], :specific_gravity) *
-    ((hop_boil_time_adjustment data[:at]) / 4.15)).round 2
-  end
-
-  # Calculates IBUs for hop addition.
-  # Supported extract units are `:brix`, `:plato` and `:specific_gravity`. Default: `:plato`
-  # Supported mass units are `:grams` and `:ounces`. Default: `:grams`
-  # Supported volume units are `:gallons` and `:liters`. Default: `:liters`
-  #
-  # @example
-  #     Calculate.ibus({
-  #       alpha: 12.4,
-  #       at: 90,
-  #       extract: 15,
-  #       mass: 56,
-  #       volume: 20
-  #     })
-  #
-  #     Calculate.ibus({
-  #       alpha: 6.5,
-  #       at: 60,
-  #       extract: 18.5,
-  #       mass: 30,
-  #       volume: 40
-  #     }, { extract: :brix })
-  #
-  #     Calculate.ibus({
-  #       alpha: 8,
-  #       at: 30,
-  #       extract: 1.055,
-  #       mass: 3,
-  #       volume: 5
-  #     }, { extract: :specific_gravity, mass: :ounces, volume: :gallons })
-  #
-  # @param [Hash] data data required to calculate IBUs; `extract`, `alpha`, `at`, `mass`, `volume`
-  # @param [Hash] units used to change default units for `extract`, `volume` and `mass`
-  # @return [Fixnum] IBUs from hop addition
-  def self.ibus data, units = {}
-    units.merge!(extract: :plato) unless units[:extract]
-    units.merge!(mass: :grams)    unless units[:mass]
-    units.merge!(volume: :liters) unless units[:volume]
-
-    unless units[:extract] == :specific_gravity
-      data[:extract] = case units[:extract]
-      when :brix then Convert.brix_to_specific_gravity data[:extract]
-      when :plato then Convert.plato_to_specific_gravity data[:extract]
-      else raise ArgumentError, "#{units[:extract]} is an unknown unit of extract. Use :brix, :plato or :specific_gravity"
-      end
-    end
-
-    unless units[:mass] == :grams
-      data[:mass] = case units[:mass]
-      when :ounces then Convert.ounces_to_grams data[:mass]
-      else raise ArgumentError, "#{units[:mass]} is an unknown unit of mass. Use :grams or :ounces"
-      end
-    end
-
-    unless units[:volume] == :liters
-      data[:volume] = case units[:volume]
-      when :gallons then Convert.gallons_to_liters data[:volume]
-      else raise ArgumentError, "#{units[:volume]} is an unknown unit of volume. Use :gallons or :liters"
-      end
-    end
-
-    (hop_extract_adjustment(data[:extract], :specific_gravity) *
-     hop_boil_time_adjustment(data[:at]) * (data[:alpha] / 100) *
-     data[:mass] * 1000 / (data[:volume] * 4.15)).round
-  end
-
-  # Calculates hop mass required to achieve specific IBUs.
-  # Supported extract units are `:brix`, `:plato` and `:specific_gravity`. Default: `:plato`
-  # Supported volume units are `:gallons` and `:liters`. Default: `:liters`
-  #
-  # @example
-  #     Calculate.hop_mass_required({
-  #       alpha: 13.5,
-  #       at: 60,
-  #       extract: 16,
-  #       ibus: 25,
-  #       volume: 20
-  #     })
-  #
-  #     Calculate.hop_mass_required({
-  #       alpha: 3.2,
-  #       at: 15,
-  #       extract: 14.5,
-  #       ibus: 15,
-  #       volume: 20
-  #     }, { extract: :brix })
-  #
-  #     Calculate.hop_mass_required({
-  #       alpha: 12.4,
-  #       at: 90,
-  #       extract: 1.05,
-  #       ibus: 100,
-  #       volume: 10
-  #     }, { extract: :specific_gravity, volume: :gallons })
-  #
-  # @param [Hash] data data required to calculate hop mass required; `extract`, `ibus`, `alpha`, `at`, `volume`
-  # @param [Hash] units used to change default units for `extract` and `volume`
-  # @return [Float] hop mass required to achieve specific IBUs
-  def self.hop_mass_required data, units = {}
-    units.merge!(extract: :plato) unless units[:extract]
-    units.merge!(mass: :grams) unless units[:mass]
-    units.merge!(volume: :liters) unless units[:volume]
-
-    unless units[:extract] == :specific_gravity
-      data[:extract] = case units[:extract]
-      when :brix then Convert.brix_to_specific_gravity data[:extract]
-      when :plato then Convert.plato_to_specific_gravity data[:extract]
-      else raise ArgumentError, "#{units[:extract]} is an unknown unit of extract. Use :brix, :plato or :specific_gravity"
-      end
-    end
-
-    unless units[:volume] == :liters
-      data[:volume] = case units[:volume]
-      when :gallons then Convert.gallons_to_liters data[:volume]
-      else raise ArgumentError, "#{units[:volume]} is an unknown unit of volume. Use :gallons or :liters"
-      end
-    end
-
-    mass = ((data[:volume] * data[:ibus]) /
-            (hop_utilization({extract: data[:extract], at: data[:at]}, :specific_gravity) *
-            data[:alpha] * 10))
-
-    units[:mass] == :grams ? mass.round : Convert.grams_to_ounces(mass).round(1)
-  end
-
-  # Calculate milliliters of HopShot required to achieve specific IBUs.
-  # Supported extract units are `:brix`, `:plato` and `:specific_gravity`. Default: `:plato`
-  # Supported volume units are `:gallons` and `:liters`. Default: `:liters`
-  #
-  # @example
-  #     Calculate.hopshot_required({
-  #       alpha: 13.5,
-  #       at: 60,
-  #       extract: 16,
-  #       ibus: 25,
-  #       volume: 20
-  #     })
-  #
-  #     Calculate.hopshot_required({
-  #       alpha: 3.2,
-  #       at: 15,
-  #       extract: 14.5,
-  #       ibus: 15,
-  #       volume: 20
-  #     }, { extract: :brix })
-  #
-  #     Calculate.hopshot_required({
-  #       alpha: 12.4,
-  #       at: 90,
-  #       extract: 1.05,
-  #       ibus: 100,
-  #       volume: 10
-  #     }, { extract: :specific_gravity, volume: :gallons })
-  #
-  # @param [Hash] data data required to calculate hop mass required; `extract`, `ibus`, `at`, `volume`
-  # @param [Hash] units used to change default units for `extract` and `volume`
-  # @return [Float] milliliters of HopShot required to achieve specific IBUs
-  def self.hopshot_required data, units = {}
-    units.merge!(extract: :plato) unless units[:extract]
-    units.merge!(volume: :liters) unless units[:volume]
-
-    unless units[:extract] == :specific_gravity
-      data[:extract] = case units[:extract]
-      when :brix then Convert.brix_to_specific_gravity data[:extract]
-      when :plato then Convert.plato_to_specific_gravity data[:extract]
-      else raise ArgumentError, "#{units[:extract]} is an unknown unit of extract. Use :brix, :plato or :specific_gravity"
-      end
-    end
-
-    unless units[:volume] == :liters
-      data[:volume] = case units[:volume]
-      when :gallons then Convert.gallons_to_liters data[:volume]
-      else raise ArgumentError, "#{units[:volume]} is an unknown unit of volume. Use :liters or :gallons"
-      end
-    end
-
-    unadjusted_amount = (data[:ibus] / 10.0) * (data[:volume] / 19.0)
-    hopshot_required  = unadjusted_amount
-
-    if data[:extract] >= 1.08 && data[:extract] < 1.1
-      hopshot_required = unadjusted_amount + (unadjusted_amount * 0.1)
-    elsif data[:extract] >= 1.1 && data[:extract] < 1.15
-      hopshot_required = unadjusted_amount + (unadjusted_amount * 0.2)
-    elsif data[:extract] >= 1.15
-      hopshot_required = unadjusted_amount + (unadjusted_amount * 0.3)
-    end
-
-    if data[:at] >= 90
-      hopshot_required = hopshot_required - (unadjusted_amount * 0.1)
-    end
-
-    hopshot_required.round 1
-  end
-
-  # Calculate hop boil time adjustment.
-  #
-  # @example
-  #    Calculate.hop_boil_time_adjustment 60
-  #    Calculate.hop_boil_time_adjustment 15
-  #
-  # @param [Fixnum] at boil time remaining when hop addition is made
-  # @return [Float] boil time adjustment
-  def self.hop_boil_time_adjustment at
-    (1 - Math.exp(-0.04 * at)).round 2
-  end
-
-  # Calculate hop extract adjustment.
-  #
-  # @example
-  #    Calculate.hop_extract_adjustment 12
-  #    Calculate.hop_extract_adjustment 14.2, :brix
-  #    Calculate.hop_extract_adjustment 1.065, :specific_gravity
-  #
-  # @param [Float] extract extract level when hop addition is made
-  # @return [Float] extract adjustment
-  def self.hop_extract_adjustment extract, units = :plato
-    unless units == :specific_gravity
-      extract = case units
-      when :brix then Convert.brix_to_specific_gravity extract
-      when :plato then Convert.plato_to_specific_gravity extract
-      else raise ArgumentError, "#{units} is an unknown unit of extract. Use :brix, :plato or :specific_gravity"
-      end
-    end
-
-    (1.65 * 0.000125 ** (extract - 1)).round 2
-  end
-
-end

data/lib/calculators/mash.rb

@@ -1,82 +0,0 @@
-module Calculate
-
-  # Calculates temperature of strike water for dough in.
-  # Supported units are `:metric` and `:us`. Default: `:metric`
-  #
-  # @example
-  #     Calculate.strike_temperature({
-  #       ratio: 1.5,
-  #       initial: 20,
-  #       target: 75
-  #     })
-  #
-  #     Calculate.strike_temperature({
-  #       ratio: 1.25,
-  #       initial: 65,
-  #       target: 154
-  #     }, :us)
-  #
-  #     Calculate.strike_temperature({
-  #       ratio: 1.5,
-  #       initial: 60,
-  #       target: 150,
-  #       loss: 1.015
-  #     }, :us)
-  #
-  # @param [Hash] data data required to calculate hop mass required; `ratio`, `initial`, `target`
-  # @param [Symbol] units the unit used to measure temperature
-  # @return [Fixnum] strike water temperature
-  def self.strike_temperature data, units = :metric
-    constant = case units
-    when :metric then 0.41
-    when :us then 0.2
-    else raise ArgumentError, "#{units} is an unknown unit of measures. Use :metric or :us"
-    end
-
-    data.merge!(loss: 1) unless data[:loss]
-
-    (((constant / data[:ratio]) *
-      (data[:target] - data[:initial]) +
-       data[:target]) * data[:loss]).round
-  end
-
-  # Calculates volume of boiling infusion water needed to increase mash temperature.
-  # Supported units are `:metric` and `:us`. Default: `:metric`
-  #
-  # @example
-  #     Calculate.infusion_volume({
-  #       ratio: 1,
-  #       initial: 40,
-  #       target: 60,
-  #       mass: 3.6,
-  #       volume: 3.6
-  #     })
-  #
-  #     Calculate.infusion_volume({
-  #       ratio: 1,
-  #       initial: 104,
-  #       target: 140,
-  #       mass: 8,
-  #       volume: 8
-  #     }, :us)
-  #
-  # @param [Hash] data data required to calculate infusion volume; `ratio`, `initial`, `target`, `mass`, `volume`
-  # @param [Symbol] units the unit used for measurements
-  # @return [Fixnum] infusion water volume
-  def self.infusion_volume data, units = :metric
-    case units
-    when :metric
-      boiling = 100
-      constant = 0.41
-    when :us
-      boiling = 212
-      constant = 0.2
-    else raise ArgumentError, "#{units} is an unknown unit of measures. Use :metric or :us"
-    end
-
-    ((data[:target] - data[:initial]) *
-     ((constant * data[:mass]) + data[:volume]) /
-     (boiling - data[:target])).round 1
-  end
-
-end