las_reader 0.0.1 → 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.swp
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in las_reader.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Gilberto P. Carmo Jr.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+# LasReader
+
+cwls-las-reader
+Ruby gem for reading CWLS LAS files
+
+The Canadian Well Logging Society's Floppy Disk Committee has designed a standard format for log data on floppy disks. It is known as the LAS format (Log ASCII Standard). LAS consists of files written in ASCII containing minimal header information and is intended for optical curves only.
+
+Details of the LAS format are described in this paper (http://www.cwls.org/docs/LAS12_Standards.txt).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'las_reader'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install las_reader
+
+## Quick irb Usage
+    
+    irb> require 'rubygems'
+    irb> require 'las_reader'
+    irb> my_las = CWLSLas.new('my_well.las')
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/las_reader.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'las_reader/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "las_reader"
+  gem.version       = LasReader::VERSION
+  gem.authors       = ["Gilberto P. Carmo Jr."]
+  gem.email         = ["gpcarmo@gmail.com"]
+  gem.description   = %q{A simple gem to read CWLS-LAS file format. File in this format will contain well log data in ASCII format}
+
+  gem.add_development_dependency  "rspec"
+
+  gem.summary       = %q{Read CWLS LAS files}
+  gem.homepage      = "https://github.com/gpcarmo/cwls-las-reader"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/las_reader.rb

@@ -0,0 +1,286 @@
+require "las_reader/version"
+require "las_reader/curve_info"
+require "las_reader/curve"
+require "las_reader/mnemonic"
+require "las_reader/well_info"
+
+module LasReader
+
+  attr_reader :version
+  attr_reader :wrap
+  attr_reader :curves
+  attr_reader :parameters
+  attr_reader :well_info
+
+  def set_version(info)
+    version = info.match(/(VERS\.).+([1-3]\.[0-9]).*:\s*(.*)/)
+    if version.nil?
+      wrap_mode = info.match(/(WRAP\.).+(YES|NO).*:\s*(.*)/)
+      if not wrap_mode.nil?
+          @wrap =  (wrap_mode[2] == "YES") ? true : false
+      end
+    else
+      @version = version[2]
+      raise "LAS version not supported" if @version.to_f > 2.0
+    end
+  end
+
+  def set_curve_info(info)
+    mnemonic = info.match(/(\w+)\s*\.(\S*)\s+(.*):\s*(.*)/)
+    unless mnemonic.nil?
+      @curves["#{mnemonic[1]}"] = Curve.new(mnemonic[1],mnemonic[2],mnemonic[3],mnemonic[4])
+      @acurves << mnemonic[1]
+    end
+  end
+
+  def set_parameters(info)
+    mnemonic = info.match(/(\w+)\s*\.(\S+)\s+(.*):\s*(.*)/)
+    unless mnemonic.nil?
+      @parameters["#{mnemonic[1]}"] = Mnemonic.new(mnemonic[1],mnemonic[2],mnemonic[3],mnemonic[4])
+    end
+  end
+
+  def set_well_info(info)
+
+    strt = info.match(/(STRT)\.(\w).+\s([0-9]+\.[0-9]+).*:\s*(.*)/)
+    unless strt.nil?
+      @well_info.start_depth = strt[3].to_f
+      @well_info.depth_unit = strt[2]
+      return
+    end
+
+    stop = info.match(/(STOP)\.(\w).+\s([0-9]+\.[0-9]+).*:\s*(.*)/)
+    unless stop.nil?
+      @well_info.stop_depth = stop[3].to_f
+      return
+    end
+
+    step = info.match(/(STEP)\.(\w).+\s(-?[0-9]+\.[0-9]+).*:\s*(.*)/)
+    unless step.nil?
+      @well_info.step = step[3].to_f
+      return
+    end
+
+    null = info.match(/(NULL)\..+\s(-?[0-9]+\.[0-9]+).*:\s*(.*)/)
+    unless null.nil?
+      @well_info.null_value = null[2].to_f
+      return
+    end
+
+    comp = info.match(/(COMP\..+COMPANY:\s*(.*))|(COMP\s*\.\s*(.*)\s+:COMPANY)/)
+    unless comp.nil?
+      @well_info.company_name = (comp[2] or comp[4]).strip
+      return
+    end
+
+    well = info.match(/(WELL\..+WELL:\s*(.*))|(WELL\s*\.\s*(.*)\s+:WELL)/)
+    unless well.nil?
+      @well_info.well_name = (well[2] or well[4]).strip
+      return
+    end
+
+    fld = info.match(/(FLD \..+FIELD:\s*(.*))|(FLD\s*\.\s*(.*)\s+:FIELD)/)
+    unless fld.nil?
+      @well_info.field_name = (fld[2] or fld[4]).strip
+      return
+    end
+
+    loc = info.match(/(LOC \..+LOCATION:\s*(.*))|(LOC\s*\.\s*(.*)\s+:LOCATION)/)
+    unless loc.nil?
+      @well_info.location = (loc[2] or loc[4]).strip
+      return
+    end
+
+    prov = info.match(/(PROV\..+PROVINCE:\s*(.*))|(PROV\s*\.\s*(.*)\s+:PROVINCE)/)
+    unless prov.nil?
+      @well_info.province = (prov[2] or prov[4]).strip
+      return
+    end
+
+    cnty = info.match(/(CNTY\..+COUNTY:\s*(.*))|(CNTY\s*\.\s*(.*)\s+:COUNTY)/)
+    unless cnty.nil?
+      @well_info.county = (cnty[2] or cnty[4]).strip
+      return
+    end
+
+    stat = info.match(/(STAT\..+STATE:\s*(.*))|(STAT\s*\.\s*(.*)\s+:STATE)/)
+    unless stat.nil?
+      @well_info.state = (stat[2] or stat[4]).strip
+      return
+    end
+
+    ctry  = info.match(/(CTRY\..+COUNTRY:\s*(.*))|(CTRY\s*\.\s*(.*)\s+:COUNTRY)/)
+    unless ctry.nil?
+      @well_info.country = (ctry[2] or ctry[4]).strip
+      return
+    end
+
+    srvc = info.match(/(SRVC\..+SERVICE COMPANY:\s*(.*))|(SRVC\s*\.\s*(.*)\s+:SERVICE COMPANY)/)
+    unless srvc.nil?
+      @well_info.service_company = (srvc[2] or srvc[4]).strip
+      return
+    end
+
+    data = info.match(/(DATE\..+LOG DATE:\s*(.*))|(DATE\s*\.\s*(.*)\s+:LOG DATE)/)
+    unless data.nil?
+      @well_info.date_logged = (data[2] or data[4]).strip
+      return
+    end
+
+    uwi = info.match(/(UWI \..+UNIQUE WELL ID:\s*(.*))|(UWI\s*\.\s*(.*)\s+:UNIQUE WELL ID)/)
+    unless uwi.nil?
+      @well_info.uwi = (uwi[2] or uwi[4]).strip
+      return
+    end
+
+  end
+
+  def set_other_info(info)
+  end
+
+  def log_wrap_data(info,temp_array)
+    d=info.scan(/[-]?[0-9]+.[0-9]+/)
+    a = temp_array + d if not d.nil?
+    if a.size == self.curves.size
+      self.curves.each do |k,v|
+        value = a[@acurves.index(k)].to_f
+        v.log_data << ((value == @well_info.null_value) ? nil : value)
+      end
+      a = []
+    end
+    return a
+  end
+
+  def log_nowrap_data(info)
+    d=info.scan(/[-]?[0-9]+.[0-9]+/)
+    unless d.nil?
+      self.curves.each do |k,v|
+        value = d[@acurves.index(k)].to_f
+        v.log_data << ((value == @well_info.null_value) ? nil : value)
+      end
+    end
+  end
+
+  def load_file(file_name)
+
+    temp_array = []
+    @curves = {}
+    @parameters = {}
+    @acurves = []
+
+    read_state = 0
+
+    #section_definition = {
+    #  'V' => "Version and wrap mode information",
+    #  'W' => "well identification",
+    #  'C' => "curve information",
+    #  'P' => "parameters or constants",
+    #  'O' => "other information such as comments",
+    #  'A' => "ASCII log data"
+    #}
+
+    unless File.exist?(file_name)
+      raise "No such file or directory"
+    end
+
+    File.open(file_name).each do |line|
+      # ignore comments
+      next if line[0].chr == '#' 
+      # The '~' is used to inform the beginning of a section
+      if line[0].chr == '~' 
+         # unless section_definition.keys.include? line[1].chr
+         #   raise "unsupported_file_format for #{line}"
+         # end
+          case line[1].chr
+            when 'V' # Version information section
+              read_state = 1 
+            when 'W' # Well identification section
+              @well_info = WellInfo.new
+              read_state = 2 
+            when 'C' # Curve information section
+              read_state = 3
+            when 'P' # Parameters information section
+              #set_log_pattern(curves.size)
+              read_state = 4 
+            when 'O' # Other information section
+              read_state = 5 
+            when 'A' # ASCII Log data section
+              read_state = 6 
+          else
+            raise "unsupported file format for #{line}"
+            read_state = 0 # Unknow file format
+          end
+      else
+        case read_state
+          when 1
+            set_version(line.lstrip)
+          when 2
+            set_well_info(line.lstrip) 
+          when 3
+            set_curve_info(line.lstrip)
+          when 4
+            set_parameters(line.lstrip)
+          when 5
+            set_other_info(line) 
+          when 6
+            if self.wrap
+              temp_array = log_wrap_data(line,temp_array)
+            else
+              log_nowrap_data(line)
+            end 
+        end
+      end
+    end
+  end
+
+end
+
+class CWLSLas
+
+  include LasReader
+
+  def initialize(filename=nil)
+    load_file(filename) if not filename.nil?
+  end
+
+  def curve_names
+    self.curves.keys
+  end
+
+  def curve(curve_name)
+    self.curves[curve_name]
+  end
+
+  def well_name
+    self.well_info.well_name
+  end
+
+  def company_name
+    self.well_info.company_name
+  end
+
+  def field_name
+    self.well_info.field_name
+  end
+
+  def location
+    self.well_info.location
+  end
+ 
+  def province
+    self.well_info.province
+  end
+
+  def service_company
+    self.well_info.service_company
+  end
+
+  def log_date
+    self.well_info.date_logged
+  end
+
+  def uwi
+    self.well_info.uwi
+  end
+
+end

data/lib/las_reader/curve.rb

@@ -0,0 +1,21 @@
+class LasReader::Curve
+  attr_reader :name, :unit, :api, :description
+  attr_accessor :log_data
+  def initialize(name,unit,api,info)
+    @name = name
+    @unit = unit
+    @api = api
+    @description = info
+    @log_data = []
+  end
+  def add(*p)
+    p.each do |point|
+      if point.respond_to?(:each) 
+        @log_data += point 
+      else
+        @log_data << point 
+      end
+    end
+  end
+end
+

data/lib/las_reader/curve_info.rb

@@ -0,0 +1,9 @@
+class LasReader::CurveInfo
+  attr_reader :name, :unit, :api, :description
+  def initialize(name,unit,api,info)
+    @name = name
+    @unit = unit
+    @api = api
+    @description = info
+  end
+end

data/lib/las_reader/mnemonic.rb

@@ -0,0 +1,9 @@
+class LasReader::Mnemonic
+  attr_reader :name, :unit, :value, :description
+  def initialize(name,unit,value,info)
+    @name = name
+    @unit = unit
+    @value = value
+    @description = info
+  end
+end