las2witsml 0.1.1

data/LICENSE

@@ -0,0 +1,2 @@
+Copyright 2012 Wellstorm Development. 
+Licensed under the Apache License 2.0

data/README

@@ -0,0 +1,33 @@
+las2witsml -- Convert Log ASCII Stanfard (LAS) files to WITSML <log> objects.
+
+Use this script to convert LAS files to WITSML logs. The script attempts to be forgiving
+of some commonly encountered variations. It can process most LAS v2 and v3 files.
+It does not stand on ceremony.  
+
+Usage: wmls [options]
+    -Dvariable=value                 Replace occurrences of %variable% with value, in the query template
+    -v, --verbose                    Run verbosely
+    -r, --url url                    URL of the WITSML service
+    -u, --username USER              HTTP user name
+    -p, --password PASS              HTTP password
+    -q, --query QUERYFILE            Path to file containing query, delete, add or update template
+    -a cap|get|add|update|delete         WITSML action; default is 'get'
+        --action
+    -o, --optionsin OPTIONSIN        optionsIn string (optional)    
+    -h, --help                       Show this message
+
+Example:
+wmls -q query_v1311/get_all_wells.xml -r https://witsml.wellstorm.com/witsml/services/store -u username -p mypassword -a get
+
+I've included a bunch of sample query templates originally created by Gary Masters of Energistics. 
+
+License: Apache 2.0
+
+History:
+
+10 Mar 2011 -- initial commit.
+16 Oct 2011 -- added -D option to wmls command line tool  (0.1.7)
+01 May 2012 -- added GetCap support (0.1.8)
+01 May 2012 -- added support for capabilitiesIn parameter to all calls (0.1.9)
+04 May 2012 -- added support for a headers parameter to all calls (0.1.11)
+07 May 2012 -- fix headers param to get_cap (default should be {}) (0.1.13)

data/bin/las2witsml

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby -w
+# Copyright 2012 Wellstorm Development LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'optparse'
+
+require "las_file"
+require "witsml_file"
+require "las2witsml"
+
+options = {:v=>false}
+
+opts =OptionParser.new do |o|
+  o.banner = "Usage: las2witsml [-n name] [-u uid] [-b uid] [-l uid] [-x version] [-h] [-v] lasfile"
+
+  o.on("-n", "--namelog name", "Name to give the WITSML log; default 'Untitled'") do |v|
+    options[:name] = v
+  end
+
+  o.on("-u", "--uidwell uid", "WITSML uid of the containing well") do |v|
+    options[:uw] = v
+  end
+  o.on("-b", "--uidwellbore uid", "WITSML uid of the containing wellbore") do |v|
+    options[:uwb] = v
+  end
+  o.on("-l", "--uidlog  uid", "WITSML uid to assign the log") do |v|
+    options[:ul] = v
+  end
+  o.on("-x", "--version  version", "WITSML version to emit, either 1.3.1 or 1.4.1; default 1.4.1") do |v|
+    options[:version] = v
+  end
+  o.on("-v", "--verbose", "Emit diagnostic output on stderr") do |v|
+    options[:v] = v
+  end
+
+  o.on_tail("-h", "--help", "Show this message") do
+    puts o
+    exit
+  end
+end
+
+
+
+opts.parse!
+if ( !options[:url] )
+  #puts(opts.help)
+  #exit 1
+end
+
+
+ARGV.each do|a|
+  l2w = Las2Witsml.new
+  infile = File.new a, 'r'
+  outfile = $stdout
+
+  case options[:version]
+  when '1.3.1', '1.3.1.1', '1.3.1.0'
+    version = 1311
+  else
+    version = 1410
+  end
+    
+  l2w.run infile, outfile, options[:uw] || "",  options[:uwb] || "",  options[:ul] || "", options[:name] || 'Untitled', version, options[:v] != false
+end
+
+
+

data/lib/las2witsml.rb

@@ -0,0 +1,23 @@
+#require 'java'
+#require 'las_file'
+#require 'witsml_file'
+class Las2Witsml
+  def run in_stream, out_stream, uid_well, uid_wellbore, uid_log, name_log, version = 1411, verbose=false
+    begin
+ 
+      las =LasFile.new in_stream 
+      las.process verbose
+      $stderr.puts 'processed las file'
+      
+      witsml = WitsmlFile.new out_stream, version
+      $stderr.puts 'made witsmlFile' if verbose
+      witsml.from_las_file(las, uid_well, uid_wellbore, uid_log, name_log,  verbose)   
+      $stderr.puts 'read from lasFile' if verbose
+      out_stream.flush
+      true
+    rescue => e
+      $stderr.puts e.backtrace.join("\n")
+      false
+    end
+  end
+end

data/lib/las_file.rb

@@ -0,0 +1,235 @@
+require 'time'
+
+
+class LogCurveInfo
+  attr_accessor :mnemonic,:unit,:description
+  def initialize(mnemonic, unit = nil, description = nil)
+    @mnemonic = mnemonic; @unit = unit; @description = description
+  end
+end
+
+class LasFile
+
+  
+  attr_reader :log_curve_infos, 
+  :measured_depth_unit,
+  :start_measured_depth_index, :stop_measured_depth_index, 
+  :start_date_time_index, :stop_date_time_index,
+  :null_value, :service_company, :curve_values,
+  :elevation_kelly_bushing, :log_measured_from, :permanent_datum, :above_permanent_datum
+    
+  def initialize(io)
+    @log_curve_infos = []
+    @curve_values = []
+    @in = io
+  end
+  
+  def process verbose=false
+    while block(verbose); end
+  end
+
+  #each_data_line is an optimization so we don't have to store 8 million
+  # or so ruby objects in memory (uses up 1.6GB).
+
+  def each_data_line verbose=false
+    lines_processed = 0
+    while line = next_line
+      yield(line.split)
+      lines_processed = lines_processed + 1
+      $stderr.puts "processed #{lines_processed} lines" if (verbose && lines_processed % 1000 == 0 )
+    end
+    
+  end
+    
+  private
+  
+  def block(verbose)
+    line = next_line
+    section = /^~([a-zA-Z]+).*/.match(line)
+    
+    $stderr.puts "processing #{section [1]} section" if verbose
+    case section [1].downcase
+    when 'well', 'w'
+      well_information
+    when 'version', 'v'
+      version_information
+    when 'curve', 'c'
+      curve_information
+    when 'parameter', 'p'
+      parameter_information
+    when 'other', 'o'
+      other_information
+    when 'a'
+      #assume this is the last block. we'll deliver 
+      # curve data on demand, in each_data_line
+      #curve_data(verbose) #how we used to process ~A
+    end if section
+  end
+  
+ 
+  def version_information
+    skip_block # we don't care for now
+  end
+  
+  def is_depth_unit(unit)
+    if unit then
+      dunit = unit.downcase
+      if (dunit == 'ft' || dunit == 'f' || dunit == 'm' || dunit == 'cm' || dunit == 'in') 
+        dunit
+      end
+    end
+  end
+
+  def parse_date_time (data,info, unit='s')
+    begin
+      Time.parse(data)    #nicely handles the case of either dd/mm/yy or hh:mm:ss
+    rescue
+      begin
+        offset = data.to_f  #for now I'm assuming unit of seconds
+
+        # The Chevron SLB data uses DATE as the units for seconds since 1/1/1970.
+        if unit.downcase == 'date'
+          Time.at(offset)
+        else
+          base = Time.parse(info) # hah! This works for the Scientif Drilling LAS files. They put in comments: 11/30/08 18:00:00.00 (Central Standard Time)"
+          base + offset
+        end
+      rescue
+        # ok, ok... nice try, but info did not have a date in it.
+        offset = data.to_f  #for now I'm assuming unit of seconds
+        Time.at(offset)
+      end
+    end
+  end   
+
+  def well_information
+    #['STRT','STOP','STEP','NULL','COMP','WELL','FLD','LOC','PROV','CNTY','STAT','CTRY','SRVC','DATE','UWI','API']    
+    while m = /^([^~][^\.]+)\.([^\s]*)(.*):(.*)$/.match(line = next_line)
+      mnemonic, unit, data, info = [*m].slice(1, 4).collect{|s| s.strip}
+ 
+      case mnemonic
+      when 'STRT'
+        if dunit = is_depth_unit(unit)  then
+          @measured_depth_unit = dunit
+          @start_measured_depth_index = data.to_f
+        else
+          @start_date_time_index = parse_date_time(data, info, unit)          
+        end
+      when 'STOP'
+        if  dunit = is_depth_unit(unit) then 
+          @measured_depth_unit = unit
+          @stop_measured_depth_index = data.to_f
+        else
+          @stop_date_time_index = parse_date_time(data, info, unit)          
+
+        end
+      when 'STEP'
+        @step_increment = data.to_f
+      when 'NULL'
+        @null_value = data
+      when 'SRVC'
+        @service_company = data    
+      end
+    end
+    put_back_line(line)
+  end
+  
+  def curve_information
+    while m = /^([^~][^\.]+)\.([^: \t]*)\s*([^:]*):(.*)$/.match(line = next_line)
+      mnemonic, unit, _, description = [*m].slice(1, 4).collect {|s| s.strip}   #api_code
+      log_curve_info mnemonic, unit, description
+    end
+    put_back_line(line)    
+  end
+
+  def parameter_information
+# BHT  .DEGF     210.00000                 :Bottom Hole Temperature (used in calculations)
+# DFD  .LB/G       9.70000                 :Drilling Fluid Density
+# DFL  .                                   :Drilling Fluid Loss
+# DFV  .S         54.00000                 :Drilling Fluid Viscosity
+# MATR .        LIME                       :Rock Matrix for Neutron Porosity Corrections
+# MDEN .G/C3       2.71000                 :Matrix Density
+# RANG .        101W                       :Range
+# TOWN .        154N                       :Township
+# SECT .        2                          :Section
+# APIN .        33-105-02119               :API Serial Number
+# FL1  .        285 FNL & 2000 FWL         :Field Location Line 1
+# FL   .        LOT3                       :Field Location
+# FN   .        TODD                       :Field Name
+# WN   .        WILLISTON AIRPORT 2-11     :Well Name
+# CN   .        BRIGHAM OIL & GAS  L.P.    :Company Name
+# RUN  .          1                        :RUN NUMBER
+# PDAT .        GROUND LEVEL               :Permanent Datum
+# EPD  .F         1972.000000              :Elevation of Permanent Datum above Mean Sea Level
+# LMF  .          KELLY BUSHING            :Logging Measured From (Name of Logging Elevation Reference)
+# APD  .F          19.000000               :Elevation of Depth Reference (LMF) above Permanent Dat
+       
+    while m = /^([^~][^\.]+)\.([^\s]*)(.*):(.*)$/.match(line = next_line)
+      mnemonic, unit, data = [*m].slice(1, 4).collect{|s| s.strip}
+ 
+      case mnemonic
+      when 'RUN'
+        @run_number = data.to_i
+      when 'PDAT' 
+        @permanent_datum = data
+      when 'EPD', 'EGL'
+        @elevation_permanent_datum = data.to_f
+        @elevation_unit = unit
+      when 'LMF'
+        @log_measured_from = data
+      when 'APD'
+        @above_permanent_datum = data.to_f
+        @elevation_unit = unit
+      when 'EKB'
+        @elevation_kelly_bushing = data
+        @elevation_unit = unit
+      end
+    end
+
+    if @elevation_kelly_bushing
+      @log_measured_from = "KELY BUSHING"
+    end
+    if @elevation_kelly_bushing and  @elevation_permanent_datum and not  @above_permanent_datum then
+      @above_permanent_datum = @elevation_kelly_bushing.to_f - @elevation_permanent_datum.to_f 
+    end
+    if not @elevation_kelly_bushing and  @elevation_permanent_datum and  @above_permanent_datum then
+      @elevation_kelly_bushing =  @above_permanent_datum.to_f +  @elevation_permanent_datum.to_f
+    end
+
+    put_back_line(line)
+  end
+  
+  def other_information
+    skip_block  
+  end
+
+  def next_line
+    if @next_line
+      line = @next_line
+      @next_line = nil
+    else
+      while /^((#.*)|(\s*))$/ =~(line = @in.gets);end   
+    end
+    line
+  end
+ 
+  def put_back_line(line)
+    @next_line = line
+  end
+  
+  def skip_block
+    while !(/^~.*$/ =~ (line = @in.readline)); end
+    put_back_line(line)    
+  end
+  
+  def log_curve_info mnemonic, las_unit, description
+    @log_curve_infos << LogCurveInfo.new(mnemonic, las_unit.downcase, description)
+
+  end
+  
+
+
+end
+
+
+

data/lib/witsml_file.rb

@@ -0,0 +1,326 @@
+#require 'las_file'
+require 'time'
+require 'tempfile'
+
+class WitsmlFile
+  
+  UNITS = {'ft'=>'ft',      
+    'klbs'=>'klbf',                 
+    'PSI'=>'psi',
+    'SPM'=>'1Pmin',
+    'RPM'=>'revPmin',
+    'UNITS'=>'ftTlbf',
+    'ft/hr'=>'ftPh' ,
+    'percent'=>'%',
+    'bbl'=>'bbl' ,
+    'ton-miles'=>'tonfUSTmi',
+    'strokes'=>'unitless',
+    'GPM'=>'galUSPmin'   ,
+    'hrs'=>'h' ,
+    'amps'=>'A' ,
+    'ppm'=>'ppm',
+    'barrels'=>'bbl',
+    'ft/min'=>'ftPmin',
+    'ksi'=>'kpsi',
+    'cm'=>'cm',
+    'ft per hour'=>'ftPh',
+    'min/ft'=>'minPft'}
+
+  def initialize(out, witsml_version = 1410)
+    @indent = 0
+    @out = out
+    @witsml_version = witsml_version
+  end
+  
+
+  def digest_las(las_file)
+    #pre chew the las
+
+    #merge date and time
+    lcis = las_file.log_curve_infos
+    
+    #Set these variables, which depend on whether we have a time or a depth log:
+    # new_lcis : possibly modified (to merge date+time) list of logCurveInfos
+    # index_lci: the LCI of the index curve
+    # is_index_index: proc to test the given integer to see whether it is one of the possibly one or two index curve indexes
+    # get_index: proc to extract the index from an array of values
+    
+    if las_file.measured_depth_unit then
+      # it's a depth log
+      # use the unaltered array of lcis
+      new_lcis = lcis
+      index_lci = lcis[0]
+      
+      is_index_index = lambda {|i| (i == 0) }
+      get_index = lambda { |values| values[0] }
+      
+    else
+      
+      #it's a time log
+      date_index, time_index, date_fmt = make_time_indexes(lcis)
+      
+      # make the new lci for the merged index. Name it 'DATETIME'
+      index_lci =  LogCurveInfo.new('DATETIME')
+      
+      rest_lcis = lcis.reject {|lci| ['time', 'date'].member?(lci.mnemonic.downcase)}    
+      
+      # use this new array of lcis now
+      new_lcis = [index_lci] + rest_lcis
+      is_index_index = lambda {|i| (i == time_index || i == date_index) }
+      get_index = lambda do |values|
+        date = values[date_index]
+        #$stderr.puts "date #{date} fmt = #{date_fmt}"
+       
+        if date_fmt == '1' then
+          #$stderr.puts "date = #{date}"
+          offset = las_file.start_date_time_index
+          dtf = date.to_f
+          if (dtf < 86400000 && offset) then
+            dt = Time.at(date.to_f + offset.to_f).iso8601
+          else
+            dt = Time.at(date.to_f).iso8601
+          end
+        else
+          #if we have "mmddyy", munge it so the parser works
+          date = date.sub(/(\d\d)(\d\d)(\d\d)/, '\2/\3/\1') if date_fmt == 'yymmdd'
+          time = values[time_index]
+          # Pason does not put colons between time components; SLB does:
+          time = time.sub(/(\d\d)(\d\d)(\d\d)/, '\1:\2:\3') if /\d\d\d\d\d\d/=~ time
+          dt = Time.parse(time + ' ' + date).iso8601
+        end
+        dt
+      end        
+    end
+    [new_lcis, index_lci, is_index_index, get_index]
+  end
+ 
+ 
+ 
+  
+  def from_las_file(las_file, uid_well='$UIDWELL', uid_wellbore='$UIDWELLBORE', uid='$UID', name='$NAME', verbose=false)
+    new_lcis, _, is_index_index, get_index = digest_las(las_file)  #unused index_lci
+ 
+    if @witsml_version >= 1410
+      ns = 'http://www.witsml.org/schemas/1series'
+      vers = '1.4.1.0'
+    else
+      ns = 'http://www.witsml.org/schemas/131'
+      vers = '1.3.1.1'
+    end
+    
+    index_curve = new_lcis[0].mnemonic  # assume first column is index
+    add_element('logs',{'xmlns'=>ns, 'version'=>vers}) do
+      add_element('log', {'uidWell' => uid_well, 'uidWellbore'=>uid_wellbore, 'uid' => uid}) do
+        add_text_element  'nameWell', name
+        add_text_element  'nameWellbore', name
+        add_text_element  'name', name
+        #add_text_element  'dataRowCount', las_file.curve_values.length
+        add_text_element  'serviceCompany', las_file.service_company
+        add_text_element  'description', 'Created by Wellstorm LAS Import'
+
+        measured_depth_unit = normalize_unit(las_file.measured_depth_unit);
+      
+        if measured_depth_unit then
+          add_text_element  'indexType', 'measured depth'
+          add_text_element  'startIndex', las_file.start_measured_depth_index, {'uom' => measured_depth_unit} if las_file.start_measured_depth_index
+          add_text_element  'endIndex', las_file.stop_measured_depth_index, {'uom' => measured_depth_unit} if las_file.stop_measured_depth_index        
+        else
+          add_text_element  'indexType', 'date time'
+
+
+          #puts ("start index in LAS is #{las_file.start_date_time_index}")
+
+          add_text_element  'startDateTimeIndex', las_file.start_date_time_index.iso8601 if las_file.start_date_time_index
+          add_text_element  'endDateTimeIndex', las_file.stop_date_time_index.iso8601 if las_file.stop_date_time_index
+        end 
+        #add_text_element  'direction' 
+        
+        if @witsml_version >= 1410
+          add_text_element  'indexCurve', index_curve
+        else
+          add_text_element  'indexCurve', index_curve, {'columnIndex'=>1}
+        end
+        add_text_element  'nullValue', las_file.null_value
+
+       
+        begin
+          # use this new array of curve values we build
+          tempfile = Tempfile.new 'las2witsml'
+
+          #keep track of start/stop for each channel
+          start = []
+          stop = []
+
+          las_file.each_data_line(verbose) do |values|
+            #$stderr.puts values
+            idx = get_index.call(values)
+            tempfile << idx
+            #$stderr.puts "idx #{idx}"
+            values.each_with_index do |v, i|
+            
+              start[i] = idx if start[i].nil? and v != las_file.null_value
+              stop[i] = idx if v != las_file.null_value
+              tempfile << ",#{v}" if  !is_index_index.call(i) 
+
+             # $stderr.puts "put #{v} on tempfile"
+            end
+            tempfile << $/
+            nil
+          end
+          $stderr.puts "done adding lines to tempfile" if verbose   
+ 
+          tempfile.rewind 
+
+          $stderr.puts "rewound #{tempfile}" if verbose
+ 
+          # Now we can build the lcis, surveying each curve for its min/max indexes
+          new_lcis.each_with_index do |lci, index|
+            add_log_curve_info lci, (index + 1), start[index+1],  stop[index+1], measured_depth_unit
+          end
+
+          $stderr.puts "added #{new_lcis.length} LCIs" if verbose   
+        
+          
+          # Now add the curve data
+          add_element 'logData' do
+            if @witsml_version >= 1410
+              add_text_element 'mnemonicList', new_lcis.map{|lci| lci.mnemonic}.join(',')
+              add_text_element 'unitList', new_lcis.map{|lci| lci.unit}.join(',')              
+            end 
+
+            n = 0
+            tempfile.each_line do |values|
+              add_text_element 'data', values
+              n = n + 1
+              $stderr.puts "converted #{n} lines to WITSML" if (verbose && n % 1000 == 0 )
+            end
+            $stderr.puts "converted a total of #{n} lines to WITSML" if verbose
+          end
+        rescue
+          tempfile.close true
+        end
+
+      end
+    end
+  end
+  
+  private
+  def add_element name, attrs = {}, one_liner = false
+    @indent.times {@out.write " "}
+    @out.write "<#{name}"
+    attrs.each_pair {|attr, val| @out.write " #{attr}='#{escape_attr(val)}'"}
+    if block_given?
+      @out.write ">"
+      @out.write "\n" if !one_liner
+      @indent += 2
+      yield
+      @indent -= 2
+      if !one_liner
+        @out.write "\n"
+        @indent.times {@out.write " "}
+      end
+      @out.write "</#{name}>\n"
+    else
+      out.write "/>\n"
+    end
+  end
+  
+  def add_text_element(name, text, attrs = {})
+    add_element name, attrs, true do
+      @out.write escape_text(text)
+    end
+  end
+  
+  def add_log_curve_info(las_lci, column_index, min_index, max_index, measured_depth_unit)
+    add_element('logCurveInfo', {'uid' => las_lci.mnemonic[0..63]}) do
+      add_text_element  'mnemonic', las_lci.mnemonic[0..31]
+      add_text_element  'unit', las_lci.unit.downcase if las_lci.unit
+      
+      if measured_depth_unit then
+        add_text_element  'minIndex', min_index, {'uom'=>measured_depth_unit} if min_index
+        add_text_element  'maxIndex', max_index, {'uom'=>measured_depth_unit} if max_index 
+      else
+        add_text_element  'minDateTimeIndex', min_index  if min_index
+        add_text_element  'maxDateTimeIndex', max_index if max_index
+      end
+      if @witsml_version < 1410
+        add_text_element  'columnIndex', column_index.to_s
+      end
+      add_text_element  'curveDescription',las_lci.description if las_lci.description && las_lci.description.length > 0
+    end
+  end
+
+  def escape_attr(text)
+    escape_text(text).sub(/'/, "&pos;").sub(/"/, "&quot;")
+  end
+  def escape_text(text)
+    text.to_s.strip.sub(/&/, "&amp;").sub(/</, "&lt;")
+  end
+
+
+
+  def make_time_indexes(lcis) 
+ 
+    # Typically we see DATE and TIME
+    # We can also see only TIME in which case we expect long integer seconds since 1970
+    # (There's no spec that says that; but this data comes from SLB's IDEAL which uses Unix epoch)
+    # M/D Totco declares one curve named DATE. It has space separated data and time.
+
+    
+    date_index = lcis.collect {|lci| lci.mnemonic.downcase}.index('date')
+    time_index = lcis.collect {|lci| lci.mnemonic.downcase}.index('time') 
+    
+    $stderr.puts("date_index #{date_index}, time_index #{time_index}")    
+
+ 
+    if !time_index then
+      #assume time will be in the next column
+      time_index = (date_index + 1) if date_index
+    end
+    # TODO we never used time_fmt -- why? commenting to suppress warning
+    #time_fmt = lcis[time_index].unit.downcase
+    
+    if !date_index then
+      date_index = time_index if time_index
+      date_fmt = '1'   # to signify integers since 1/1/1970
+      $stderr.puts 'using integer dates'
+    else
+      date_fmt = lcis[date_index].unit.downcase
+    end
+    
+    # at the moment we understand times of format "hhmmss"
+    # and dates "d" or "mmddyy"
+    raise "No TIME or DATE" if (!time_index && !date_index)
+    
+    [date_index, time_index, date_fmt]
+          
+  end
+
+  def normalize_unit(las_unit)
+    # translate to witsml unit
+    # n.b. for now we only do depth units!
+    # see https://svn.wellstorm.com/projects/wsp/ticket/274#comment:3
+
+    return las_unit if !las_unit
+    
+    map_las_to_witsml_units = {
+      'f'=>'ft', 
+      'feet'=>'ft',
+      'foot'=>'ft',
+      'meters'=>'m',
+      'meter'=>'m'}
+
+# just a few random ones from CWLS web site:
+# RHOB  .K/M3       45 350 02 00 :  2       BULK DENSITY
+#NPHI  .VOL/VO     42 890 00 00 :  3       NEUTRON POROSITY - SANDSTONE
+#MSFL  .OHMM       20 270 01 00 :  4       Rxo RESISTIVITY
+# SP    .MV         07 010 01 00 :  8       SPONTANEOUS POTENTIAL
+#GR    .GAPI       45 310 01 00 :  9       GAMMA RAY
+#CALI  .MM         45 280 01 00 :  10      CALIPER
+#DRHO .K/M3        45 356 01 00 :  11      DENSITY CORRECTION
+ 
+    map_las_to_witsml_units[las_unit.downcase] || las_unit.downcase
+    
+  end
+
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: las2witsml
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Hugh Winkler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-12 00:00:00.000000000 Z
+dependencies: []
+description: A command line tool and a library for converting Log ASCII Standard (LAS)
+  files to WITSML <log> objects.
+email: hugh.winkler@wellstorm.com
+executables:
+- las2witsml
+extensions: []
+extra_rdoc_files: []
+files:
+- README
+- LICENSE
+- lib/las2witsml.rb
+- lib/las_file.rb
+- lib/witsml_file.rb
+- bin/las2witsml
+homepage: https://github.com/wellstorm/las2witsml/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Converts Log ASCII Standard (LAS) files to WITSML <log> objects.
+test_files: []