Module: SeisRuby::Data::Sac::Head

Defined in:: lib/seis_ruby/data/sac/head.rb

Defined Under Namespace

Classes: Field

Constant Summary collapse

NAMES = SAC header field names.

[
  :delta,     :depmin,   :depmax,   :scale,    :odelta,
  :b,         :e,        :o,        :a,        :internal1,
  :t0,        :t1,       :t2,       :t3,       :t4,
  :t5,        :t6,       :t7,       :t8,       :t9,
  :f,         :resp0,    :resp1,    :resp2,    :resp3,
  :resp4,     :resp5,    :resp6,    :resp7,    :resp8,
  :resp9,     :stla,     :stlo,     :stel,     :stdp,
  :evla,      :evlo,     :evel,     :evdp,     :mag,
  :user0,     :user1,    :user2,    :user3,    :user4,
  :user5,     :user6,    :user7,    :user8,    :user9,
  :dist,      :az,       :baz,      :gcarc,    :internal2,
  :internal3, :depmen,   :cmpaz,    :cmpinc,   :xminimum,
  :xmaximum,  :yminimum, :ymaximum, :adjtm,    :unused1,
  :unused2,   :unused3,  :unused4,  :unused5,  :unused6,
  :nzyear,    :nzjday,   :nzhour,   :nzmin,    :nzsec,
  :nzmsec,    :nvhdr,    :norid,    :nevid,    :npts,
  :nsnpts,    :nwfid,    :nxsize,   :nysize,   :unused7,
  :iftype,    :idep,     :iztype,   :unused8,  :iinst,
  :istreg,    :ievreg,   :ievtyp,   :iqual,    :isynth,
  :imagtyp,   :imagsrc,  :unused9,  :unused10, :unused11,
  :unused12,  :unused13, :unused14, :unused15, :unused16,
  :leven,     :lpspol,   :lovrok,   :lcalda,   :unused17,
  :kstnm,     :kevnm,
  :khole,     :ko,       :ka,
  :kt0,       :kt1,      :kt2,
  :kt3,       :kt4,      :kt5,
  :kt6,       :kt7,      :kt8,
  :kt9,       :kf,       :kuser0,
  :kuser1,    :kuser2,   :kcmpnm,
  :knetwk,    :kdatrd,   :kinst,
]

ENUMERATED_VALUES = Enumerated values and their meanings.

[
  :itime,    :irlim,  :iamph,  :ixy,
  :iunkn,    :idisp,  :ivel,   :iacc,
  :ib,       :iday,   :io,     :ia,
  :it0,      :it1,    :it2,    :it3,
  :it4,      :it5,    :it6,    :it7,
  :it8,      :it9,    :iradnv, :itannv,
  :iradev,   :itanev, :inorth, :ieast,
  :ihorza,   :idown,  :iup,    :illlbb,
  :iwwsn1,   :iwwsn2, :ihglp,  :isro,
  :inucl,    :ipren,  :ipostn, :iquake,
  :ipreq,    :ipostq, :ichem,  :iother,
  :igood,    :iglch,  :idrop,  :ilowsn,
  :irldta,   :ivolts, :ixyz,   :imb,
  :ims,      :iml,    :imw,    :imd,
  :imx,      :ineic,  :ipde,   :iisc,
  :ireb,     :iusgs,  :ibrk,   :icaltech,
  :illnl,    :ievloc, :ijsop,  :iuser,
  :iunknown, :iqb,    :iqb1,   :iqb2,
  :iqbx,     :iqmt,   :ieq,    :ieq1,
  :ieq2,     :ime,    :iex,    :inu,
  :inc,      :io,     :il,     :ir,
  :it,       :iu,
].map.with_index.with_object({}){|(v, i), h| h[i + 1] = v}

CONVERTER_FROM_HEAD_FLOAT = Float

lambda{|x|
  x_f = x.to_f
  return nil if x_f == -12345.0
  x_f
}

CONVERTER_TO_HEAD_FLOAT =

lambda{|x|
  return -12345.0 if x.nil?
  x.to_f
}

CONVERTER_FROM_HEAD_INTEGER = Integer

lambda{|n|
  n_i = n.to_f.round
  return nil if n_i == -12345
  n_i
}

CONVERTER_TO_HEAD_INTEGER =

lambda{|n|
  return -12345 if n.nil?
  n.to_f.round
}

CONVERTER_FROM_HEAD_ENUMERATED_VALUE = Enumerated value

lambda{|n|
  n_i = n.to_f.round
  return nil if n_i == -12345
  raise ArgumentError, "Enumerated value out of range: #{n.inspect}.to_f.round" unless ENUMERATED_VALUES.has_key?(n_i)
  ENUMERATED_VALUES.fetch(n_i)
}

CONVERTER_TO_HEAD_ENUMERATED_VALUE =

lambda{|sym|
  return -12345 if sym.nil?
  sym_sym = sym.to_sym
  raise ArgumentError, "Unknown enumerated value: #{sym.inspect}.to_sym" unless ENUMERATED_VALUES.has_value?(sym_sym)
  ENUMERATED_VALUES.key(sym_sym)
}

CONVERTER_FROM_HEAD_LOGICAL = Logical

lambda{|n| n.to_f.round == 1}

CONVERTER_TO_HEAD_LOGICAL =

lambda{|v|
  if v
    1
  else
    0
  end
}

CONVERTER_FROM_HEAD_STRING = String

lambda{|str|
  stripped_str = str.to_s.strip
  return nil if stripped_str == "-12345"
  stripped_str
}

CONVERTER_TO_HEAD_STRING =

lambda{|str|
  return "-12345" if str.nil?
  str.to_s.strip
}

CONVERTERS_FROM_HEAD =

[CONVERTER_FROM_HEAD_FLOAT]*70\
+ [CONVERTER_FROM_HEAD_INTEGER]*15\
+ [CONVERTER_FROM_HEAD_ENUMERATED_VALUE]*20\
+ [CONVERTER_FROM_HEAD_LOGICAL]*5\
+ [CONVERTER_FROM_HEAD_STRING]*23

CONVERTERS_TO_HEAD =

[CONVERTER_TO_HEAD_FLOAT]*70\
+ [CONVERTER_TO_HEAD_INTEGER]*15\
+ [CONVERTER_TO_HEAD_ENUMERATED_VALUE]*20\
+ [CONVERTER_TO_HEAD_LOGICAL]*5\
+ [CONVERTER_TO_HEAD_STRING]*23

FIELDS =

NAMES\
.zip(CONVERTERS_FROM_HEAD, CONVERTERS_TO_HEAD)\
.map{|name, from, to| Field.new(name, from, to)}

Class Method Summary collapse

Class Method Details

.convert_from_head(array) ⇒ `Hash`

Parameters:

array (Array)

Returns:

(Hash)

# File 'lib/seis_ruby/data/sac/head.rb', line 142

def convert_from_head(array)
  name_val = FIELDS\
    .zip(array)\
    .map{|field, val|
    begin
      [field.name, field.converter_from_head.call(val)]
    rescue ArgumentError => e
      $stderr.puts "#{field.name.inspect}"
      raise e
    end
  }
  Hash[name_val]
end

.convert_to_head(hash) ⇒ `Array`