0.1.13Why would you want to do this? You can think of both LAS 2.0 and JSON as file formats that hold strings. The difference is JSON is a very common data format widely used across a variety of computer languages. It is used extensively on the web to hold data. LAS 2.0 is not. LAS 2.0 is specifically for well logs. Well logs are measurements along a well bore that meausure changes in subsurface properties. By converting LAS 2.0 to JSON, we get data into a format that is much easier to work with on the web. Wellio's companion library wellioviz takes the JSON that results from Wellio and visualizes it by leveraging D3.js v5. However, you could visualize the same wellio JSON with a wide variety of other visualization tools too, because nearly all of them can consume JSON.
https://github.com/JustinGOSSES/wellio.js
The README.md has additional information to the README, including sections:
In the wellio documentation, we have split out "How to Install & Get Ready to Use" and "How to Use Once Installed", because installation varies depending on whether wellio is being used as front-end JavaScript code on a website, in an Observable JavaScript Notebook, or server-side via a command line or node.js script.
Once installed and ready to use, however, how to use wellio is identical no matter where used.
Wellio.js is packaged as npm module as seen here.
The code that you pull when you install the npm module is found in the dist folder of the wellio repository on GitHub.
It can be run from the back-end or front-end. Frontend being from a webpage running HTML, CSS, and JavaScript. Backend meaning on a server or in your terminal. Most people will probably be interested in running it on the frontend, but we'll start by explaining how to run it on the backend or server side as that's a bit easier to explain.
When you install Node.js, you should also get npm as described here. 2. Navigate in your terminal to where you want to work. 3. To install wellio run:
npm install wellio
node
wellio = require('wellio')
The process for installing wellio in an Observable notebook is very easy as it is a npm module. It is literally as easy as:
wellio = require(wellio)
As seen in the example notebook here. Once wellio is imported using require, you can call any wellio function like:
well_as_wellio_style_json_in_memory = wellio.las2json(las_file_read_in_as_string)
Due to wellio being a npm module, we'll need to use require to pull it into front-end code. Require can be confusing and I've not found their documentation to be super clear. That's less a problem of documentation as it is that there's multiple ways for npm modules to work and therefore differences in how require can end up working, which gets confusing.
I'll try to explain one way to bring in wellio that is used to make the demo page that lives as a github pages page in the main wellio repository.
The demo page that lets you try out wellio.js is here.
The code for that demo page is at the top level of the wellio repository as seen here. Go have a look.
If you look at code that makes up the index.html page that builds the demo page, you'll see in the header section that multiple CSS and JS libraries are pulled into index.html.
<script src="https://requirejs.org/docs/release/2.3.5/minified/require.js"></script> This imports the requirejs JavaScript library that we'll use to import the wellio npm module into our code such that we can call it.
<script src="./dist/index.js"></script> This pulls in the JavaScript at that location. It is a relative location, meaning relative to the index.html page that calls it and makes up the demo. It is the same code that makes up wellio and is sent to the npm (node package manager).
If you're not working with the demo page that is in the same folder location as the main wellio code, there's a couple other ways to go. If you're familar with node modules, you probably already know how to work with them and aren't reading this demo.
If you're confused, you can simply use an absolute url rather than a relative one.
For example, <script src="https://raw.githubusercontent.com/JustinGOSSES/wellio.js/master/dist/index.js"></script> will pull in the code you need from the current master branch of wellio.
<script src="./js/main.js"></script> Main.js is the JavaScript file that pulls in wellio and uses it in the demo page. If you look at the code, you'll see starting on line 13...
wellio = require(['./dist/index.js'],function(wellio_obj){console.log("wellio test",wellio) wellio = wellio_obj})
This is where require pulls in wellio and makes a wellio object to call all the wellio functions as described in the "How to Use Once Installed" section.
No matter how you use wellio, you'll eventually get to the point where you'll start using it in your code by bringin it in via require, like this:
wellio = require('wellio')
Now we have wellio installed and imported, so it is ready for use. We can load a well log saved as a .las file with:
file_loaded_as_string = wellio.loadLAS("path_to_file")
We can convert that string into wellio style JSON in memory with:
wellio_style_json = wellio.las2json(file_loaded_as_string)
We can now use the wellio_style_json object that is in memory! Getting to this point is the main reason for wellio.
We can manipulate it with other JavaScript code or use wellioviz to visualize it. The wellioviz README has several links to various tutorials and demos for how to use wellioviz.
We can also save it to as a JSON file to our local computer, which follows the commands below. You'll have to stringify it first and then write it to a file. In this case, the resulting JSON file is named "UWI_of_Well.json".s
well_json_string = JSON.stringify(well_json)
fs.writeFile("UWI_of_Well.json", well_json_string, 'utf8', function (err) {console.log("error")})
help and returnThing functionsThese are mostly in wellio for easy ways to test if it was installed and imported successfully. They don't require any inputs to work. They can simply be called.
wellio.help()
wellio.returnThing("This is a test string that should be returned exactly as shown")
Although getting information out of the wellio-style JSON is as straight forward as navigating a python dict, there are a few helper functions built-in. Clicking on each will bring you to the documenation for that function.
wellio.CurveNames() will return all the curve names in a wellio-style JSON.wellio.VER_block() will return version information that was in the original LAS file now in the wellio-style JSON.wellio.UWI() wellio.UWI will return the UWI if it exists. If you use this, wrap it in a function that fails as you intend it to.wellio.getCurve() will return all the curve data for a given curve name in a wellio-style JSON.These two functions are for converting Lasio-style JSON to wellio-style JSON. They are defined in the "functions section". Clicking on them will take you directly to their documentation. Why they exist is explained in the section directly below.
wellio.read_lasio_json_file
and
wellio.lasio_obj_2_wellio_obj.
As mentioned above in the upper most section, JSON is a format for storing data. It is based on keys and values and can store a huge variety of different types of data and informaion.
As such, it shouldn't be surprising that there is more than one way to store well log data that was originally in LAS 2.0 file format in JSON format. As of writing this, there are 3 that the author knows about.
If you're confused about what's a json-style JSON, that's okay. I'll try to explain. Another group, not involved with wellio, made an attempt at a standardized way to store well log data in JSON. They named it "JSON Well Log Format". This causes confusion as you start talking about JSON JSON and whether wellio JSON is compliant with JSON JSON.
At the time of writing, there are not any functions to convert between the json-style JSON and wellio-style JSON. However, that could be added in the future.
To quote from their docs, "lasio is a Python 3 package to read and write Log ASCII Standard (LAS) files, used for borehole data such as geophysical, geological, or petrophysical logs. It’s compatible with versions 1.2 and 2.0 of the LAS file specification, published by the Canadian Well Logging Society. In principle it is designed to read as many types of LAS files as possible, including ones containing s common errors or non-compliant formatting."
Lasio is the most common way to read well logs in Python. Sometimes it is used directly and other times people use welly, which wraps Lasio and provides a Pandas-like interface. Lasio has the ability to export data loaded from a LAS 2.0 well log file into JSON format and save it as a JSON file.
There are two functions in wellio for converting these lasio-style JSON files into wellio-style JSON.
A sequence of using them to load a lasio-style JSON file and convert it into wellio-style JSON is below:
let wellio = require('wellio')
let lasio_json_str = wellio.read_lasio_json_file('lasio.json');
let lasio_obj = JSON.parse(lasio_json_str);
let wellio_obj = wellio.lasio_obj_2_wellio_obj(lasio_obj);
To give you an idea what the wellio-style JSON structure is like, here's a blank well log in the wellio-style JSON format.
documentation build -c docs/documentation.yml dist/* -f html -o docs cp css/style.css docs/assets/. This is an extra step to overwrite the default styling of documentation.js to code elements show up a little more.git clone https://github.com/JustinGOSSES/wellio.js.gitcd wellio.js.npm install to install all the node module dependencies. You may want to check what version of node.js you're running first. I know I often end up thinking I'm running latest version but I'm not. NVM or node version manager is good for that.git checkout -b YourDevelopmentBranchNamegit add * then git commit -m "message here".git push origin main, then go to GitHub and start a pull request.dist/test/ folder.npm run test.A helper function that takes no input arugments and returns a string with some basic information about wellio.
string:
A predetermined string message to the user about wellio.
wellio.help() >>> Wellio has the following functions: 'help', 'returnThing', 'loadLAS', 'las2json', 'read_lasio_json_file', and 'lasio_obj_2_wellio_obj'. You'll probably want to do well_string = wellio.loadLAS and then well_as_json = las2json(well_string)."
A helper function that proves wellio,js was installed correctly. It merely returns the argument provided to it. For example, "test" as input would return "test".
(string)
Any string
string:
Returns the input that was given as an argument. This is just for
testing that wellio was installed correctly.
wellio.returnThing("test") >>> "test"
Loads a LAS 2.0 file from local files. Takes one argument wellLog and returns
a string representation of the contents of the well log file.
(string)
A string reprepresentatiion of filename of well log to be
loaded into memory
string:
A string representation of the contents of that well log file.
It is a single string.
las2json function converts a LAS 2.0 file already loaded into memory as a string into a wellio-style JSON object
(string)
A string representation of a LAS 2.0 well log file.
Typically from the result of the loadLAS function.
(boolean
= true)
A true or false boolean. If true, intermediate products
are sent to console.warn() to help withe debugging.
Object:
A JSON object that represents the information that was in the
LAS 2.0 well log file but in JSON wellio style format.
Given a well already converted into wellio-style json in memory, the CurveNames function returns the available curves in that well.
(object)
A wellio-style json in memory, typically resulting
from the wellio.las2json() function.
Array:
An array of strings representing the curve names in the well.
Given a well already converted into wellio-style json in memory, the VER_block function returns the entire version block of the original LAS file as a string.
(object)
A wellio-style json in memory, typically resulting from
the wellio.las2json() function.
string:
An array of strings representing the entire version block of the
original LAS file as a string.
Given a well already converted into wellio-style json in memory, the UWI function attempts to return the UWI field of the original LAS file as a string. Pleaes note that this doesn't exist in every well log and will therefore fail sometimes!
(object)
A wellio-style json in memory, typically resulting from
the wellio.las2json() function.
string:
An a string representing the UWI field of the original LAS file.
Given a well already converted into wellio-style json in memory, the wellio.getCurve() function attempts to return the curve data of a given well log. If it doesn't exist, the message "that curve does not exist! see console.warn" is outputted to console.warn and returned by the function.
(object)
A wellio-style json in memory, typically resulting from the
wellio.las2json() function.
(string)
A string representation of a particular curve name.
array:
An array of integers or floats representing the data for a particular
curve in a given well log.
File reading utility function for a JSON file that contains what was a LAS 2.0 well
log already converted into JSON by the Python package Lasio.
Lasio is also used by Welly.
This function will read the file and keep it in memory.
After running this function, You'll likely want to use the lasio_obj_2_wellio_obj
function to convert the lasio-style JSON in memory to wellio-style JSON in memory.
(string)
: file_to_read - The file to open.s
string:
: The file's contents as a string.
The lasio_obj_2_wellio_obj function transforms lasio-style JSON strings into wellio-style
JSON data format in memory and returns it.
If you're working with a JSON file created by lasio, you'll want to load it into memory
first using the read_lasio_json_file function.
(any)
(object)
A JavaScript object representation of lasio well log format
object:
A wellio style JSON object
This is an example of a full sequence of calls that also uses this function.
let wellio = require('wellio')
let lasio_json_str = wellio.read_lasio_json_file('lasio.json');
let lasio_obj = JSON.parse(lasio_json_str);
let wellio_obj = wellio.lasio_obj_2_wellio_obj(lasio_obj);