seis_ruby 0.1.2 → 0.2.0

data/README.rdoc

@@ -1,5 +1,24 @@
 = SeisRuby
-== Executables
-=== seis_ruby
-Please see details by typing:
-  > seis_ruby help
+== What is this?
+Ruby library and command line tools for earthquake science.
+
+== Command line tool
+  seis_ruby help
+
+== Library
+Please check {SeisRuby::Command} which provides handy methods via {::SeisRuby}.
+
+== Quick start
+  require 'seis_ruby'
+  sac = SeisRuby.load_file('test_read.SAC') # Read a SAC file
+  sac.head[:a] += 3.0                       # Shift Tp 3.0 seconds
+  sac.dump_file('test_dump_shifted.SAC')    # Output a SAC file
+
+== License
+{http://www.gnu.org/licenses/gpl.html GPL v3}
+
+== Author
+Kasahara Amato
+
+== Semantic Versioning
+This software basically follow the {http://semver.org/ Semantic Versioning}.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+require 'ruby_patch'
+
+task default: [:test]
+
+desc "Run tests"
+::Rake::TestTask.new do |t|
+  t.libs = ['lib', 'test'].map{|dir| File.join(__DIR__, dir)}
+  t.pattern = "test/**/*_test.rb"
+end

data/bin/seis_ruby

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 
 require 'seis_ruby'
-::SeisRuby::Bin::SeisRubyRunner.start
+::SeisRuby::Application.start

data/lib/seis_ruby/application.rb

@@ -0,0 +1,76 @@
+require 'thor'
+
+class ::SeisRuby::Application < Thor
+  require 'yaml'
+  require 'pry'
+  require 'fileutils'
+  require 'ruby_patch'
+
+  COMMAND = 'seis_ruby'
+  COMPLETION_FILE = File.join(ENV['HOME'], ".config", COMMAND, "completion.bash")
+
+  desc "repl", "Start interactive mode."
+  def repl
+    Pry.start(
+        ::TOPLEVEL_BINDING,
+        prompt: [
+                lambda{|obj, nest_level, pry| "[#{pry.input_array.size}] SeisRuby(#{obj}):#{nest_level}> "},
+                lambda{|obj, nest_level, pry| "[#{pry.input_array.size}] SeisRuby(#{obj}):#{nest_level}* "}])
+  end
+
+  desc "yamlize URI", "Read data from URI, parse it and output to STDOUT in YAML format."
+  def yamlize(uri)
+    puts YAML.dump(::SeisRuby.load_file(uri))
+  end
+
+  desc "generate_completion", "Generate bash completion of seis_ruby's commands."
+  def generate_completion
+    FileUtils.mkdir_p(File.dirname(COMPLETION_FILE))
+    FileUtils.mv(COMPLETION_FILE, "#{COMPLETION_FILE}.#{Time.now.ymdhms}.bak") if File.exist?(COMPLETION_FILE)
+    File.write(COMPLETION_FILE, completion_function_str)
+
+    puts <<-EOS
+Please add following code to your ~/.bashrc if necessary.
+
+# enable seis_ruby completion.
+if [ -f #{COMPLETION_FILE} ]; then
+    source #{COMPLETION_FILE}
+fi
+    EOS
+  end
+
+  desc 'version', 'Print seis_ruby version'
+  def version
+    puts ::SeisRuby::VERSION
+  end
+
+  private
+
+  def completion_function_str
+    <<-EOS
+_#{COMMAND}()
+{
+  local sub_commands current previous
+  sub_commands="#{sub_commands_str()}"
+  current="${COMP_WORDS[COMP_CWORD]}"
+  previous="${COMP_WORDS[COMP_CWORD-1]}"
+
+  case "${previous}" in
+    #{COMMAND}|help)
+      COMPREPLY=( $(compgen -W "${sub_commands}" ${current}) );;
+    * )
+      COMPREPLY=( $(compgen -f ${current}) );;
+  esac
+}
+complete -F _#{COMMAND} #{COMMAND}
+    EOS
+  end
+
+  def sub_commands_str
+    `#{COMMAND} --help`\
+      .split("\n")\
+      .select{|l| l =~ / *#{COMMAND} /}\
+      .map{|l| l.split[1]}\
+      .join(' ')
+  end
+end

data/lib/seis_ruby/command.rb

@@ -0,0 +1,15 @@
+module ::SeisRuby::Command
+  require 'yaml'
+
+  # @param [String] uri URI of file or database query.
+  # @return [Array, Hash, ::SeisRuby::Data::*]
+  def load_file(uri)
+    if (klass = ::SeisRuby::Data::Sac).uri_for_self?(uri)
+      klass.load_file(uri)
+    elsif (klass = ::SeisRuby::Database::GlobalCmtCatalogSearch).uri_for_self?(uri)
+      klass.load_file(uri)
+    else
+      raise ArgumentError, "File type undetectable: #{uri}"
+    end
+  end
+end

data/lib/seis_ruby/core_ext/file.rb

@@ -0,0 +1,7 @@
+class ::File
+  require 'open-uri'
+
+  def self.read_uri(uri)
+    ::Kernel.open(uri){|io| io.read}
+  end
+end

data/lib/seis_ruby/core_ext.rb

@@ -0,0 +1,5 @@
+module ::SeisRuby::CoreExt
+  %w[
+    file
+  ].each{|lib| require "seis_ruby/core_ext/#{lib}"}
+end

data/lib/seis_ruby/data/cmtsolution.rb

@@ -1,77 +1,97 @@
-module SeisRuby
-  module Data
-    module Cmtsolution
-      require 'ruby_patch'
-      extend ::RubyPatch::AutoLoad
+class ::SeisRuby::Data::Cmtsolution < ::SeisRuby::Data
+  require 'ostruct'
 
-      ParseError = Class.new(StandardError)
+  def self.load_file(file)
+    load(File.read_uri(file), file: file)
+  end
 
-      module_function
+  def self.load(raw_data, meta_data)
+    new(raw_data, meta_data)
+  end
 
-      def _preprocess_for_parse(text_for_one_event)
-        text_for_one_event\
-          .sub(/\A\n*/, '')\
-          .sub(/\n*\z/, '')\
-          .split("\n")
-      end
+  def initialize(raw_data, meta_data)
+    @raw_data = raw_data
+    @meta_data = meta_data
+    parse!
+  end
+  attr_accessor :hypocenter
+  attr_accessor :centroid
 
-      def _parse_lines(lines)
-        h = {hypocenter: {}, centroid: {}}
+  private
 
-        line0 = lines[0]
-        h[:hypocenter][:data_source] = line0[0..4].strip
-        line0_rest = line0[5..-1].split
-        [:year, :month, :day, :hour, :minute].each{|k|
-          raise ParseError if line0_rest.empty?
-          h[:hypocenter][k] = line0_rest.shift.to_i
-        }
-        [:second, :latitude, :longitude, :depth, :mb, :ms].each{|k|
-          raise ParseError if line0_rest.empty?
-          h[:hypocenter][k] = line0_rest.shift.to_f
-        }
-        h[:hypocenter][:region_name] = line0_rest.join(' ')
-        h[:event_name] = lines[1].split(':')[1].strip
-        values = lines[2..-1].map{|line| line.split(':')[1].to_f}
-        [
-         :time_shift, :half_duration,
-         :latitude, :longitude, :depth,
-         :mrr, :mtt, :mpp, :mrt, :mrp, :mtp,
-        ].zip(values).each{|k, v| h[:centroid][k] = v}
+  def parse!
+    lines\
+    = @raw_data\
+      .split("\n")\
+      .map(&:strip)\
+      .delete_if(&:empty?)
+    @hypocenter = Hypocenter.new(lines[0])
+    @centroid = Centroid.new(lines[1..-1])
+  end
 
+  class Hypocenter < OpenStruct
+    FIELDS = [
+      # name,        column,    converter
+      [:data_source, ( 0..3 ), :strip],
+      [:year,        ( 4..8 ), :to_i ],
+      [:month,       ( 9..11), :to_i ],
+      [:day,         (12..14), :to_i ],
+      [:hour,        (15..17), :to_i ],
+      [:minute,      (18..20), :to_i ],
+      [:second,      (21..26), :to_f ],
+      [:latitude,    (27..35), :to_f ],
+      [:longitude,   (36..45), :to_f ],
+      [:depth,       (46..51), :to_f ],
+      [:mb,          (52..55), :to_f ],
+      [:ms,          (56..59), :to_f ],
+      [:region_name, (60..-1), :strip],
+    ]
 
-        h
-      end
+    def initialize(str)
+      h = {}
+      FIELDS.each{|name, column, converter|
+        h[name] = str[column].__send__(converter)
+      }
+      super(h)
+    end
+    attr_accessor :table
 
-      def _parse_one_event(text_for_one_event)
-        begin
-          lines = _preprocess_for_parse(text_for_one_event)
-          _parse_lines(lines)
-        rescue
-          raise ParseError, text_for_one_event
-        end
-      end
+    # Origin time
+    def origin_time
+      sec = self.second
+      int_sec = sec.to_i
+      decimal_sec = sec - int_sec
+      micro_sec = (decimal_sec*(10**6)).round
+      Time.gm(
+           self.year, self.month, self.day,
+           self.hour, self.minute, int_sec, micro_sec)
+    end
+  end
 
-      # @param [String, Array<String>] events List of CMTSOLUTION format texts.
-      # @return [Array<Hash>] You can access :event_name, :hypocenter, :centroid.
-      def parse(*events)
-        h = events.flatten.map{|ev|
-          begin
-            _parse_one_event(ev)
-          rescue ParseError => e
-            e
-          end
-        }.group_by{|o| o.exception?}
-        h.default_proc = lambda{|h, k| h[k] = []}
-        unless (error_list = h[true]).empty?
-          error_message = error_list.map{|e| e.message}.join("\n\n")
-          raise ParseError, <<-EOS
-Could not parse following events:
-#{error_message}
-          EOS
-        end
+  class Centroid < OpenStruct
+    FIELDS = [
+      # name,           converter
+      [:event_name,    :strip],
+      [:time_shift,    :to_f ],
+      [:half_duration, :to_f ],
+      [:latitude,      :to_f ],
+      [:longitude,     :to_f ],
+      [:depth,         :to_f ],
+      [:mrr,           :to_f ],
+      [:mtt,           :to_f ],
+      [:mpp,           :to_f ],
+      [:mrt,           :to_f ],
+      [:mrp,           :to_f ],
+      [:mtp,           :to_f ],
+    ]
 
-        h[false]
-      end
+    def initialize(lines)
+      h = {}
+      FIELDS.zip(lines){|(name, converter), str|
+        h[name] = str.split(':', 2).last.__send__(converter)
+      }
+      super(h)
     end
+    attr_accessor :table
   end
 end

data/lib/seis_ruby/data/sac/ascii/head.rb

@@ -0,0 +1,49 @@
+module ::SeisRuby::Data::Sac::Ascii::Head
+  N_LINES = 30
+
+  RANGES_15_BY_5 = [[(0..14), (15..29), (30..44), (45..59), (60..-1)]]
+  RANGE_10_BY_5 = [[(0..9), (10..19), (20..29), (30..39), (40..-1)]]
+  RANGES_8_BY_3 = [[(0..7), (8..15), (16..-1)]]
+  RANGES = [
+    *(RANGES_15_BY_5*14),
+    *(RANGE_10_BY_5*8),
+    [(0..7), (8..-1)],
+    *(RANGES_8_BY_3*7),
+  ]
+
+  FORMATS_15_7G_BY_5 = ["%#15.7g", "%#15.7g", "%#15.7g", "%#15.7g", "%#15.7g\n"]
+  FORMATS_10I_BY_5 = ["%10i", "%10i", "%10i", "%10i", "%10i\n"]
+  FORMATS_8S_BY_3 = ["%-8s", "%-8s", "%-8s\n"]
+  FORMATS = [
+    *(FORMATS_15_7G_BY_5*14),
+    *(FORMATS_10I_BY_5*8),
+    "%-8s", "%-16s\n",
+    *(FORMATS_8S_BY_3*7),
+  ]
+
+  class << self
+    def convert_from_head_str(head_str)
+      ::SeisRuby::Data::Sac::Head\
+        .convert_from_head(split_head_str(head_str))
+    end
+
+    def convert_to_head_str(head)
+      array = ::SeisRuby::Data::Sac::Head\
+        .convert_to_head(head)
+      sprintf(FORMATS.join, *array)
+    end
+
+    private
+
+    def split_head_str(head_str)
+      head_lines = head_str.split("\n")
+      raise ArgumentError unless head_lines.size == N_LINES
+
+      head_lines\
+        .zip(RANGES)\
+        .map{|line, ranges| ranges\
+          .map{|range| line[range]}}\
+        .flatten
+    end
+  end
+end

data/lib/seis_ruby/data/sac/ascii.rb

@@ -0,0 +1,61 @@
+class ::SeisRuby::Data::Sac::Ascii < ::SeisRuby::Data::Sac
+  require 'seis_ruby/data/sac/ascii/head'
+
+  EXT = '.sac_ascii'
+
+  DATA_COLUMN_SIZE = 5
+  DATA_FORMAT_STRING = '%#15.7g'
+
+  class << self
+    def parse(str)
+      head_str, body_str = separate_head_body(str)
+
+      head = ::SeisRuby::Data::Sac::Ascii::Head\
+        .convert_from_head_str(head_str)
+      body = ::SeisRuby::Data::Sac::Body\
+        .shape_body(body_str.split.map(&:to_f), head)
+
+      [head, body]
+    end
+
+    def dump(head, body)
+      ::SeisRuby::Data::Sac::Ascii::Head.convert_to_head_str(head)\
+      + format_body(::SeisRuby::Data::Sac::Body.body_for_dump(body, head))
+    end
+
+    def uri_for_self?(uri)
+      uri =~ /#{Regexp.escape(EXT)}\z/i
+    end
+
+    private
+
+    def format_body(body)
+      body\
+        .each_slice(DATA_COLUMN_SIZE)\
+        .map{|line| line\
+          .map{|v| sprintf(DATA_FORMAT_STRING, v)}\
+          .join << "\n"}\
+        .join
+    end
+
+    def separate_head_body(str)
+      # Use <tt>nth_index</tt> to deal with bloken SAC_ASCII file produced by SAC's <tt>write alpha</tt> command.
+      last_of_head = nth_index(str, "\n", ::SeisRuby::Data::Sac::Ascii::Head::N_LINES)
+      head_str = str[0..last_of_head]
+      body_str = str[(last_of_head + 1)..-1]
+
+      [head_str, body_str]
+    end
+
+    def nth_index(str, pattern, nth = 1, pos = 0)
+      raise ArgumentError, "nth should >= 1: #{nth}" if nth < 1
+
+      index = str.index(pattern, pos)
+      if index.nil? || nth == 1
+        index
+      else
+        nth_index(str, pattern, nth - 1, index + 1)
+      end
+    end
+  end
+end

data/lib/seis_ruby/data/sac/binary/head.rb

@@ -0,0 +1,5 @@
+module ::SeisRuby::Data::Sac::Binary::Head
+  HEAD_FORMAT_STRING = "f70i40A8A16" + "A8"*21
+  BODY_FORMAT_STRING = "f*"
+  FORMAT_STRING = HEAD_FORMAT_STRING + BODY_FORMAT_STRING
+end

data/lib/seis_ruby/data/sac/binary.rb

@@ -0,0 +1,26 @@
+module ::SeisRuby::Data::Sac::Binary
+  require 'seis_ruby/data/sac/binary/head'
+
+  EXT = '.sac'
+
+  def self.parse(raw_data)
+    raw_data_array = raw_data.unpack(::SeisRuby::Data::Sac::Binary::Head::FORMAT_STRING)
+    head = ::SeisRuby::Data::Sac::Head\
+      .convert_from_head(raw_data_array[0...::SeisRuby::Data::Sac::Head::NAMES.size])
+    body = ::SeisRuby::Data::Sac::Body\
+      .shape_body(raw_data_array[head.size..-1], head)
+
+    [head, body]
+  end
+
+  def self.dump(head, body)
+    (
+      ::SeisRuby::Data::Sac::Head.convert_to_head(head)\
+      + ::SeisRuby::Data::Sac::Body.body_for_dump(body, head))\
+      .pack(::SeisRuby::Data::Sac::Binary::Head::FORMAT_STRING)
+  end
+
+  def self.uri_for_self?(uri)
+    uri =~ /#{Regexp.escape(EXT)}\z/i
+  end
+end

data/lib/seis_ruby/data/sac/body.rb

@@ -0,0 +1,62 @@
+module ::SeisRuby::Data::Sac::Body
+  module_function
+
+  def shape_body(body, head)
+    case head[:iftype]
+    when :itime
+      # [y0, y1, ...]
+      body
+    when :ixy, :iamph
+      # ixy: [[x0, y0], [x1, y1], ...]
+      # iamph: [[theta0, amp0], [theta1, amp1], ...]
+      body\
+        .each_slice(body.size/2)\
+        .to_a\
+        .reverse\
+        .transpose
+    when :irlim
+      # [(real0, imaginary0), (real1, imaginary1), ...]
+      body\
+        .each_slice(body.size/2)\
+        .to_a\
+        .transpose\
+        .map{|real, imaginary| Complex(real, imaginary)}
+    when :ixyz
+      # z[ix][iy]
+      body\
+        .each_slice(head[:nxsize])\
+        .to_a\
+        .transpose
+    else
+      raise ArgumentError, "Unknown iftype: #{head[:iftype].inspect}"
+    end
+  end
+
+  def body_for_dump(body, head)
+    case head[:iftype]
+    when :itime
+      # [y0, y1, ...]
+      body
+    when :ixy, :iamph
+      # ixy: [[x0, y0], [x1, y1], ...]
+      # iamph: [[theta0, amp0], [theta1, amp1], ...]
+      body\
+        .transpose\
+        .reverse\
+        .flatten
+    when :irlim
+      # [(real0, imaginary0), (real1, imaginary1), ...]
+      body\
+        .map{|c| [c.real, c.imaginary]}\
+        .transpose\
+        .flatten
+    when :ixyz
+      # z[ix][iy]
+      body\
+        .transpose\
+        .flatten
+    else
+      raise ArgumentError, "Unknown iftype: #{head[:iftype].inspect}"
+    end
+  end
+end

data/lib/seis_ruby/data/sac/head.rb

@@ -0,0 +1,162 @@
+module ::SeisRuby::Data::Sac::Head
+
+  # SAC header field names.
+  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 and their meanings.
+  ENUMERATED_VALUES = [
+    :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}
+
+  # Float
+  CONVERTER_FROM_HEAD_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
+  }
+
+  # Integer
+  CONVERTER_FROM_HEAD_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
+  }
+
+  # Enumerated value
+  CONVERTER_FROM_HEAD_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)
+  }
+
+  # Logical
+  CONVERTER_FROM_HEAD_LOGICAL = lambda{|n| n.to_f.round == 1}
+  CONVERTER_TO_HEAD_LOGICAL = lambda{|v|
+    if v
+      1
+    else
+      0
+    end
+  }
+
+  # String
+  CONVERTER_FROM_HEAD_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
+
+  Field = Struct.new(:name, :converter_from_head, :converter_to_head)
+  FIELDS = NAMES\
+    .zip(CONVERTERS_FROM_HEAD, CONVERTERS_TO_HEAD)\
+    .map{|name, from, to| Field.new(name, from, to)}
+
+  class << self
+    # @param [Array] array
+    # @return [Hash]
+    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
+
+    # @param [Hash] hash
+    # @return [Array]
+    def convert_to_head(hash)
+      FIELDS.map{|field| field.converter_to_head.call(hash[field.name])}
+    end
+  end
+end