Working with LIS.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python 3.11.8\n",
    "# DLISIO v1.0.1\n",
    "# numpy v1.26.3\n",
    "# pandas v2.2.0\n",
    "# lasio v0.31\n",
    "\n",
    "from dlisio import lis\n",
    "import pandas as pd\n",
    "import os\n",
    "import lasio\n",
    "import numpy as np\n",
    "\n",
    "from IPython.display import display, HTML, Image\n",
    "\n",
    "display(HTML(data=\"\"\"\n",
    "<style>\n",
    "    div#notebook-container    { width: 95%; }\n",
    "    div#menubar-container     { width: 65%; }\n",
    "    div#maintoolbar-container { width: 60%; }\n",
    "</style>\n",
    "\"\"\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_wellname(f, find_wellname, manualwellname):\n",
    "    if find_wellname == \"Yes\":\n",
    "        records = f.wellsite_data()\n",
    "        inforec = records[0] # assume well name in is in the first record\n",
    "        #Can it be structured? Otherwise return an error\n",
    "        if inforec.isstructured() == True:\n",
    "            np_array = (inforec.table(simple=True)).T\n",
    "            df = pd.DataFrame(data=np_array)\n",
    "            \n",
    "            wellname_list = []\n",
    "\n",
    "            items = ['Well Name', 'wellname', 'WN', 'WELL NAME'] ##set all the possible search terms\n",
    "\n",
    "            for item in items:\n",
    "                df[\"string_index\"] = df[\"VALU\"].str.find(str(item)).values\n",
    "                wellname = df.loc[df['string_index'] >= 0, 'VALU'].values.tolist()\n",
    "                #wellname = wellname[0] #take the first value returned.\n",
    "                wellname_list.append(wellname)\n",
    "\n",
    "                df[\"string_index\"] = df[\"MNEM\"].str.find(str(item)).values\n",
    "                wellname = df.loc[df['string_index'] >= 0, 'VALU'].values.tolist()\n",
    "                wellname_list.append(wellname)\n",
    "\n",
    "            wellname_list = [x for x in wellname_list if x != []]\n",
    "            for wellname in wellname_list:\n",
    "                wellname = [s.replace('Well Name:', '') for s in wellname]\n",
    "                wellname = [s.replace(' WN', '') for s in wellname]\n",
    "                wellname = [s.replace('Well Name ', '') for s in wellname]\n",
    "                wellname = [s.replace('WN', '') for s in wellname]\n",
    "                wellname = [s.strip() for s in wellname]\n",
    "                \n",
    "            wellname = wellname[0]   ##take the first item in the list\n",
    "            \n",
    "            if len(wellname)>0:\n",
    "                wellname_report_error = \"\"\n",
    "            else:\n",
    "                wellname_report_error = \"Could not read header - no name extraction\"\n",
    "        else:\n",
    "            wellname_report_error = \"Could not read header - not structured\"\n",
    "    else:\n",
    "        wellname = manualwellname\n",
    "        wellname_report_error = ''\n",
    "    return wellname, wellname_report_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_las(curves_df, units, curvenames, wellname, filepath):\n",
    "    las = lasio.LASFile()\n",
    "    # write the pandas data to the las file\n",
    "    las.set_data(curves_df)\n",
    "    # write the curve metadata from our three lists.\n",
    "    counter = 0\n",
    "    for x in curvenames:\n",
    "        las.curves[x].unit = units[counter]\n",
    "        counter = counter + 1\n",
    "    las.well.WELL = wellname\n",
    "    las.params['LINEAGE'] = lasio.HeaderItem('LINEAGE', value=\"Python-converted from LIS\")\n",
    "    las.params['ORFILE'] = lasio.HeaderItem('ORFILE', value=filepath)\n",
    "    return las"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_las_file(las, filepath, frame_count, output_folder_location):\n",
    "    \n",
    "    filename = os.path.basename(filepath)\n",
    "    filename = os.path.splitext(filename)[0]\n",
    "    \n",
    "    outfile = filename + \"_\" + \"converted_with_python_\" + str(frame_count) + \".las\"\n",
    "    outpath = os.path.join(output_folder_location, outfile)\n",
    "\n",
    "    if not os.path.exists(output_folder_location):\n",
    "        print(\"Making output directory: [{}]\\n\".format(output_folder_location))\n",
    "        os.makedirs(output_folder_location)\n",
    "\n",
    "    print(\"Writing: [{}]\\n\".format(outpath))\n",
    "    las.write(outpath, version=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# process each logical file and each sampling rate (frame) at a time. \n",
    "# The goal with this function is to only read from the lis file once!\n",
    "# If you don't care about speed, and need the well names extracted from the lis header, set the find_wellname = Yes\n",
    "# Otherwise pass in the name of the well into the manualwellname variable.\n",
    "# The number of logical files times the number of groups of sample rates will determine the number of las files created.\n",
    "# Curves with no matching frame sample rate will not be included!!  See Fast Channels in the LIS User Guides @dlisio.readthedocs\n",
    "\n",
    "def lis_to_las(filepath, output_folder_location, manualwellname = \"set input\", find_wellname = \"Yes\"):\n",
    "    frame_count = 0\n",
    "    with lis.load(filepath) as files:\n",
    "        for f in files:\n",
    "            wellname = extract_wellname(f, find_wellname, manualwellname)\n",
    "            for fs in f.data_format_specs():\n",
    "                for frame in fs.sample_rates():\n",
    "                    curve_frames = []\n",
    "                    #create dataframe\n",
    "                    units = []\n",
    "                    curvenames = []\n",
    "                    meta = lis.curves_metadata(fs, sample_rate=frame)\n",
    "                    curves = lis.curves(f, fs, sample_rate=frame)\n",
    "                    curves_df = curves.T\n",
    "                    names = curves.dtype.names\n",
    "                    curves_df = pd.DataFrame(data=curves_df, columns=names)\n",
    "                    \n",
    "                    #check if dataframe is empty\n",
    "                    if curves_df.empty:\n",
    "                        frame_count = frame_count + 1\n",
    "                        print('Frame number '+ str(frame_count) + \" is empty\")\n",
    "                        break\n",
    "                    \n",
    "                    #get and set index curve\n",
    "                    index_curve = fs.index_mnem\n",
    "                    curves_df = curves_df.set_index(index_curve)\n",
    "                    \n",
    "                    #get inventories\n",
    "                    for n in names:\n",
    "                        spec = meta[n]\n",
    "                        units.append(spec.units)\n",
    "                        curvenames.append(n)\n",
    "                    \n",
    "                    # advance the count of sample rate frames\n",
    "                    frame_count = frame_count + 1\n",
    "                \n",
    "                    #Quick quality test\n",
    "                    unit_len = len(curvenames)\n",
    "                    name_len = len(units)\n",
    "                    if unit_len != name_len:\n",
    "                        warning = \"Frame \"+ str(frame_count)+\" \"+\"Mismatch in number of names and units; use with caution.\"\n",
    "                    else:\n",
    "                        warning = \"\"\n",
    "                    print(warning)\n",
    "                    \n",
    "                    las = create_las(curves_df, units, curvenames, wellname, filepath)\n",
    "                    \n",
    "                    write_las_file(las, filepath, frame_count, output_folder_location)\n",
    "                \n",
    "    report = (\"Number of frames = \" + str(frame_count))  \n",
    "    print(report)\n",
    "        \n",
    "    return report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filepath = r\"Volve_Well_logs_pr_WELL\\15_9-F-4\\04.COMPOSITE\\WLC_PETROPHYSICAL_COMPOSITE_1.LIS\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#filepath = r\"\\Volve_Well_logs_pr_WELL\\15_9-F-4\\01.MUD_LOG\\MUD_LOG_1.LIS\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_folder_location = \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#results = lis_to_las(filepath, output_folder_location, manualwellname = \"Volve\", find_wellname=\"No\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = lis_to_las(filepath, output_folder_location, find_wellname=\"Yes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}