Upload 6 files

DecisionTree.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b8f324bde5f91a95920ae53fb4a13fcd13e37861f0a34282a4fd02ac5f32354
+size 651272

app.py

@@ -0,0 +1,226 @@
+from pathlib import Path
+import streamlit as st
+from functions import *
+
+
+# Initialize session state
+if 'pumping_file' not in st.session_state:
+    st.session_state.pumping_file = None
+if 'pumping_df' not in st.session_state:
+    st.session_state.pumping_df = None 
+if 'cwt_df' not in st.session_state:
+    st.session_state.cwt_df = None   
+if 'ms_df' not in st.session_state:
+    st.session_state.ms_df = None  
+if 'mc_events_predicted_df' not in st.session_state:
+    st.session_state.mc_events_predicted_df = None    
+if 'date_col' not in st.session_state:
+    st.session_state.date_col = None     
+if 'pressure_col' not in st.session_state:
+    st.session_state.pressure_col = None 
+if 'rate_col' not in st.session_state:
+    st.session_state.rate_col = None 
+if 'start_date' not in st.session_state:
+    st.session_state.start_date = None 
+if 'start_time' not in st.session_state:
+    st.session_state.start_time = None
+if 'end_date' not in st.session_state:
+    st.session_state.end_date = None  
+if 'end_time' not in st.session_state:
+    st.session_state.end_time = None    
+if 'east' not in st.session_state:
+    st.session_state.east = None 
+if 'north' not in st.session_state:
+    st.session_state.north = None 
+if 'depth' not in st.session_state:
+    st.session_state.depth = None 
+    
+if 'start_datetime_selector' not in st.session_state:
+    st.session_state.start_datetime_selector = False   
+if 'end_datetime_selector' not in st.session_state:
+    st.session_state.end_datetime_selector = False 
+   
+x_names = [str(i) for i in range(1,257)]
+y_names=['delta_east', 'delta_north', 'delta_depth']
+
+             
+#Main decoration
+st.set_page_config(page_title='Microseismic Prediction',
+                   layout="wide",page_icon='📈')
+st.title('Microseismic Prediction')
+st.markdown('Predict Microseismic Events (X, Y, Z)')
+image_path = Path('uh-primary.png')
+st.sidebar.image(str(image_path))
+
+
+
+click_event_container = st.empty()
+
+
+# Define tab titles
+tab_titles = ["Pumping pressure table", "Pumping pressure chart", "Adjusted chart" , "Predicted Microseismic Events","Quality Check"]
+
+# Create tabs using st.tabs
+tabs = st.tabs(tab_titles)
+
+uploaded_pumping_file = st.sidebar.\
+    file_uploader("Please upload pumping XLSX file", type=["xlsx"])
+
+    
+
+# Add content to each tab
+with tabs[0]:
+    st.header("Table of pumping data")
+    pumping_data_frame_container = st.empty()
+    if uploaded_pumping_file:
+        #create a pumping dataframe
+        pumping_data_frame_container.\
+            dataframe(st.session_state.pumping_df, use_container_width=True)
+
+with tabs[1]:
+    st.header("Pumping pressure and rate chart")
+    with st.container():
+            #check box with date selector
+            
+        option = st.radio("Which date you want to select?", ("Start date", "End date"),captions=("Select start date and time", "Select end date and time"))
+        if option == "Start date":
+            st.session_state.start_datetime_selector = True
+            st.session_state.end_datetime_selector = False
+        elif option == "End date":
+            st.session_state.start_datetime_selector = False
+            st.session_state.end_datetime_selector = True
+           
+                    
+    with st.form(key='pumping_chart_form'):
+        
+        if st.session_state.pumping_df is not None:
+            fig = plot_pumping_data(st.session_state.pumping_df, \
+                        st.session_state.date_col, st.session_state.pressure_col,\
+                            st.session_state.rate_col)
+            st.empty()
+            selected_events = plotly_events(fig)                
+            if selected_events:
+                    click_event = selected_events[0]
+                    x_value = click_event['x']
+                    
+                    if st.session_state.start_datetime_selector:
+                        #convert x_value to datetime
+                        x_value = pd.to_datetime(x_value)
+                        #extract date and time then assign to start_date and start_time
+                        st.session_state.start_date = x_value.date()
+                        st.session_state.start_time = x_value.time()
+                        
+                        st.write(f"Start date: {st.session_state.start_date}")
+                        st.write(f"Start time: {st.session_state.start_time}")
+                        
+                    if st.session_state.end_datetime_selector:
+                        #convert x_value to datetime
+                        x_value = pd.to_datetime(x_value)
+                        #extract date and time then assign to end_date and end_time
+                        st.session_state.end_date = x_value.date()
+                        st.session_state.end_time = x_value.time()
+                        
+                        st.write(f"End date: {st.session_state.end_date}")
+                        st.write(f"End time: {st.session_state.end_time}")
+        
+        #open tab 3
+        
+        
+        st.form_submit_button(label = "Transfer new chart")
+
+    
+with tabs[2]:
+    if st.session_state.pumping_df is not None:
+    
+        fig = plot_pumping_data(st.session_state.pumping_df, \
+                            st.session_state.date_col, st.session_state.pressure_col,st.session_state.rate_col)
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        with st.form(key='adjusted_chart_form'):
+            st.empty()
+            st.write("Please provide the x, y, z for mid perforation")
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.session_state.east = st.number_input("East", value=0.0)
+            with col2:
+                st.session_state.north = st.number_input("North", value=0.0)
+            with col3:
+                st.session_state.depth = st.number_input("Depth", value=0.0)
+                
+            calc_cwt = st.form_submit_button(label = "Predict Microseismic Events")
+            if calc_cwt:
+                st.session_state.cwt_df = calculate_cwt(st.session_state.pumping_df, st.session_state.date_col, st.session_state.pressure_col)
+                st.write("CWT calculated")
+                
+                with st.expander("CWT Data"):
+                    st.dataframe(st.session_state.cwt_df)
+    
+
+with tabs[3]:
+    if st.session_state.cwt_df is not None:
+        with st.container():
+             st.session_state.mc_events_predicted_df = predict_microseismic_events(\
+                st.session_state.cwt_df,x_names, y_names,\
+                st.session_state.east, st.session_state.north, st.session_state.depth)
+            
+        with st.expander("Microseismic Events"):
+            st.dataframe( st.session_state.mc_events_predicted_df)
+            
+        fig = plot_microseismic_events( st.session_state.mc_events_predicted_df)
+        st.plotly_chart(fig, use_container_width=True)
+        
+    else:
+        st.write("Please calculate CWT first")
+    
+
+with tabs[4]:
+    #upload file
+    
+        
+    with st.container():
+        actual_ms_uploaded_file = \
+        st.file_uploader("Please upload actual Micro Seismic events XLSX file", type=["xlsx"])
+
+        if actual_ms_uploaded_file:
+            st.session_state.ms_df = convert_ms_to_df(actual_ms_uploaded_file)
+            
+            col1, col2, col3,col4 = st.columns(4)         
+            ms_east_col = col1.selectbox("Select the east column", st.session_state.ms_df.columns)
+            ms_north_col = col2.selectbox("Select the north column", st.session_state.ms_df.columns)
+            ms_depth_col = col3.selectbox("Select the depth column", st.session_state.ms_df.columns)
+            depth_shift = col4.number_input("Depth shift", value=0.0)
+               
+    
+            with st.form('compare_form'):        
+                    if st.session_state.mc_events_predicted_df is not None:
+                        fig = compare_microseismic_events(st.session_state.mc_events_predicted_df,\
+                            st.session_state.ms_df,\
+                            ms_east_col,ms_north_col,ms_depth_col,depth_shift)
+                    
+                    compare_btn = st.form_submit_button(label = "Compare")
+                    if compare_btn:
+                        st.plotly_chart(fig, use_container_width=True)
+                    
+        
+              
+
+if uploaded_pumping_file:
+
+    st.session_state.pumping_file = uploaded_pumping_file
+    st.session_state.pumping_df = convert_pumping_data_to_df(st.session_state.pumping_file)
+    st.session_state.date_col = st.sidebar.selectbox("Select the date column", st.session_state.pumping_df.columns)
+    st.session_state.pressure_col = st.sidebar.selectbox("Select the pressure column", st.session_state.pumping_df.columns)
+    st.session_state.rate_col = st.sidebar.selectbox("Select the rate column", st.session_state.pumping_df.columns)
+
+    #view pumping data via clicking the button
+    view_pumping_data_btn =  st.sidebar.button("View pumping Data")
+    if view_pumping_data_btn:
+        try:
+            #create a pumping dataframe
+            pumping_data_frame_container.\
+                dataframe(st.session_state.pumping_df, use_container_width=True)
+        except:
+            pass
+            
+        

functions.py

@@ -0,0 +1,246 @@
+import pickle
+from pathlib import Path
+import streamlit as st
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from streamlit_plotly_events import plotly_events
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import preprocessing
+import pywt
+
+
+def convert_pumping_data_to_df(uploaded_file):
+    
+    df = pd.read_excel(uploaded_file)
+    # convert the date column to datatime
+    try:
+        #convert the first column to datetime
+        df.iloc[:,0] = pd.to_datetime(df.iloc[:,0])
+       
+    except Exception as e:
+        st.warning(f"An error occurred while converting the date column to datetime: {e}")
+        
+    return df
+
+def convert_ms_to_df(uploaded_file):
+    
+    df = pd.read_excel(uploaded_file)
+    # convert the date column to datatime
+    try:
+        #convert the first column to datetime
+        df.iloc[:,0] = pd.to_datetime(df.iloc[:,0])
+       
+    except Exception as e:
+        st.warning(f"An error occurred while converting the date column to datetime: {e}")
+        
+    return df    
+
+def plot_pumping_data(df, date_col, pressure_col, rate_col):
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+    fig.add_trace(go.Scatter(x=df[date_col], y=df[pressure_col], mode='lines', name='Pressure', line=dict(color='blue')), secondary_y=False)
+    fig.add_trace(go.Scatter(x=df[date_col], y=df[rate_col], mode='lines', name='Rate', line=dict(color='red')), secondary_y=True)
+    fig.update_layout(title_text="Pumping Data")
+    fig.update_xaxes(title_text="Date")
+    fig.update_yaxes(title_text="Pressure", secondary_y=False)
+    fig.update_yaxes(title_text="Rate", secondary_y=True)
+    #update the legend to be horizonal at the top
+    fig.update_layout(legend=dict(
+        orientation="h",
+        yanchor="bottom",
+        y=1.02,
+        xanchor="right",
+        x=1
+    ))
+    
+    #remove secondary axis gridlines
+    fig.update_yaxes(showgrid=False, secondary_y=True)
+    #click event on the chart to get the x axis value
+    # Attempt to capture click events using streamlit-plotly-events (install required)
+    
+    
+    return fig
+    
+
+def calculate_cwt(df,time_col,pressure_col):
+
+
+    #convert first column in both data frame pumping and microseismic to datetime
+    df[time_col] = pd.to_datetime(df[time_col])
+
+    norm_coef2_a,period,time_data,scales_a,coef_a, freqs_a,pressure_data = continous_wavelet_transformer(df[pressure_col],df[time_col])
+    #transpose norm_coef2_a
+    norm_coef2_a = norm_coef2_a.T   
+    #merge the norm_coef2_a with time_data as date time and pressure data and QC_LOC_X,Y,Z and remove the nulls in time_data
+    norm_coef2_a = pd.DataFrame(norm_coef2_a,columns=scales_a)
+        
+    norm_coef2_a['t'] = df[time_col]
+    norm_coef2_a['p'] = df[pressure_col]
+    norm_coef2_a = norm_coef2_a.dropna(subset=['t'])
+
+    return norm_coef2_a
+
+
+def continous_wavelet_transformer(pressure_data,time_data):
+    scales_a = np.linspace(1, 256, 256)
+    coef_a, freqs_a = pywt.cwt(pressure_data, scales_a, "cmor1.5-1.0")
+
+    energy = np.sqrt(coef_a.real**2 + coef_a.imag**2)
+    coef2_a = np.log2(energy)
+    period = 1.0 / freqs_a
+    scaler=preprocessing.MinMaxScaler(feature_range=(0,1)).fit(coef2_a)
+    norm_coef2_a=scaler.transform(coef2_a)
+    
+    return norm_coef2_a,period,time_data,scales_a,coef_a, freqs_a,pressure_data
+
+def reload_DT_model():
+    # Load the model from the file
+    with open(Path('DecisionTree.pkl'), 'rb') as file:
+        model = pickle.load(file)
+    return model
+
+def import_min_max():
+    #import min max from txt file
+    with open(Path('max_min.txt'),'r') as f:
+        
+        min_max = f.readlines()
+        min_max = [x.strip() for x in min_max]
+        min_max = [x.split(',') for x in min_max]
+        min_max = [[float(y) for y in x] for x in min_max]
+        min_max = np.array(min_max)
+    return min_max
+
+def predict_microseismic_events(df,x_names,y_names,east_perf,north_perf,depth_perf):
+    
+    model = reload_DT_model()
+    #predict the microseismic events
+    
+    df.reset_index(drop=True, inplace=True)
+    df.rename(columns=dict(zip(df.columns[:256], x_names)), inplace=True)
+    
+    ds_test = df[x_names]
+    
+
+    # Convert example_data to a DataFrame with column names (cont_names)
+
+    example_data_df = pd.DataFrame(ds_test, columns=x_names)
+
+    # Make predictions on the example data
+
+    predictions = model.predict(example_data_df)
+    
+    # convert the predictions to dataframe
+
+    predictions_df = pd.DataFrame(predictions, columns=y_names)
+   
+    # trail the column names with _pred
+
+    predictions_df.columns = [
+        str(col) + '_pred' for col in predictions_df.columns]
+
+    final_df = predictions_df.reset_index(drop=True)
+    
+    # denormalize the pred columns using min max
+
+    min_max = import_min_max()
+    
+    final_df['delta_east_pred_denormalized'] = final_df['delta_east_pred'] * \
+        (min_max[0][1] - min_max[0][0]) + min_max[0][0]
+
+    final_df['delta_north_pred_denormalized'] = (
+        final_df['delta_north_pred'] * (min_max[1][1] - min_max[1][0]) + min_max[1][0])
+
+    final_df['delta_depth_pred_denormalized'] = final_df['delta_depth_pred'] * \
+        (min_max[2][1] - min_max[2][0]) + min_max[2][0]
+
+    final_df['east_pred'] = final_df['delta_east_pred_denormalized'] +  east_perf
+
+    final_df['north_pred'] = final_df['delta_north_pred_denormalized'] + north_perf
+
+    final_df['depth_pred'] = final_df['delta_depth_pred_denormalized'] + depth_perf
+    
+    final = pd.concat([df, final_df], axis=1)
+
+    return final
+
+def plot_microseismic_events(final):
+  
+    fig = go.Figure(data=[go.Scatter3d(
+        x=final['east_pred'],
+        y=final['north_pred'],
+        z=final['depth_pred'],
+        mode='markers',
+        marker=dict(
+            size=3,
+            opacity=1,
+            color='red'
+        ),
+        name='Predicted'
+    )])
+    # #add the predicted
+    # fig.add_trace(go.Scatter3d(
+    #     x=final['east_pred'],
+    #     y=final['north_pred'],
+    #     z=final['depth_pred'],
+    #     mode='markers',
+    #     marker=dict(
+    #         size=2,
+    #         opacity=0.2,
+    #         color='red'
+    #     ),
+    #     name='predicted'
+    # ))
+    fig.update_layout(title=f"Predicted Micro Seismic Events", xaxis_title="east", yaxis_title="north",height=800)
+    return fig
+
+def compare_microseismic_events(final,actual,east,north,depth,depth_shift):
+    # #convert first column in final to datetime64[ns]
+    # final['t'] = pd.to_datetime(final['t'])
+    
+    # st.write(actual[time_col])
+    # st.write(final.t)
+    
+    
+
+    # #write the type of final.t column and actual[time_col] column
+    # st.write(f"actual[time_col] column type: {actual[time_col].dtype}")
+    # st.write(f"final.t column type: {final.t.dtype}")
+    
+    # #join the final and actual depending on column zero
+    
+    # # joined_df = pd.merge(final, actual, left_on='t', right_on=time_col, how='outer')
+
+    # st.write(joined_df)
+    
+    actual[depth] = depth_shift - actual[depth]
+    
+    
+    fig = go.Figure(data=[go.Scatter3d(
+        x=final['east_pred'],
+        y=final['north_pred'],
+        z=final['depth_pred'],
+        mode='markers',
+        marker=dict(
+            size=2,
+            opacity=0.3,
+            color='red'
+        ),
+        name='Predicted'
+    )])
+    #add the actual
+    fig.add_trace(go.Scatter3d(
+        x=actual[east],
+        y=actual[north],
+        z=actual[depth],
+        mode='markers',
+        marker=dict(
+            size=3,
+            opacity=1,
+            color='navy'
+        ),
+        name='Actual'
+    ))
+    fig.update_layout(title=f"Predicted Micro Seismic Events", xaxis_title="east", yaxis_title="north",height=800)
+    return fig

max_min.txt

@@ -0,0 +1,3 @@
+-3310.3351891629864,2156.3472485230304
+-2622.2025576928863,3026.023548964993
+-433.7171200566636,428.34999036096906