def main():
""" Compile metadata for all timelapse maps """
parser = argparse.ArgumentParser(description="Compile metadata for all maps")
parser.add_argument(
"config_file", help="Enter path to the WebViz-4D configuration file"
)
args = parser.parse_args()
config_file = args.config_file
config = common.read_config(config_file)
shared_settings = config["shared_settings"]
fmu_directory = shared_settings["fmu_directory"]
surface_metadata = common.get_config_item(config, "surface_metadata")
metadata_file = os.path.join(fmu_directory, surface_metadata)
print("Maps metadata file: ", metadata_file)
if os.path.isfile(metadata_file):
os.remove(metadata_file)
print(" - file removed")
map_suffix = common.get_config_item(config, "map_suffix")
delimiter = common.get_config_item(config, "delimiter")
metadata_file = common.get_config_item(config, "surface_metadata")
metadata = get_metadata(shared_settings, map_suffix, delimiter, metadata_file)
print(metadata)
def main():
""" Import and convert DSG colormaps """
parser = argparse.ArgumentParser(
description="Import and convert DSG colormaps")
parser.add_argument("config_file",
help="Enter path to the WebViz-4D configuration file")
args = parser.parse_args()
config_file = args.config_file
config = common.read_config(config_file)
settings_file = common.get_config_item(config, "settings")
settings_file = common.get_full_path(settings_file)
settings = common.read_config(settings_file)
folder = settings["map_settings"]["colormaps_folder"]
SUFFIX = ".clx"
import_colormaps(folder, SUFFIX)
def main():
""" Display the tooltip info found in all well list (pickle) files found in a folder
Parameters
----------
configuration_file : str
The name of WebViz-4D configuration file
Returns
-------
"""
description = "Check well list files"
parser = argparse.ArgumentParser(description=description)
parser.add_argument("config_file",
help="Enter path to the WebViz-4D configuration file")
args = parser.parse_args()
print(description)
print(args)
config_file = args.config_file
config = common.read_config(config_file)
wellfolder = common.get_config_item(config, "wellfolder")
wellfolder = common.get_full_path(wellfolder)
print("Reading well lists in", wellfolder)
pickle_files = glob.glob(wellfolder + "/*.pkl")
for pickle_file in pickle_files:
file_object = open(pickle_file, "rb")
info = pickle.load(file_object)
print(pickle_file)
data = info["data"]
if len(data) > 0:
for item in data:
print(item["tooltip"])
print("")
def main():
""" Create production data tables """
description = "Create production data tables"
parser = argparse.ArgumentParser(description=description)
parser.add_argument("config_file",
help="Enter path to the WebViz-4D configuration file")
args = parser.parse_args()
print(description)
print(args)
config_file = args.config_file
config_file = common.read_config(config_file)
production_directory = common.get_config_item(config_file,
"production_data")
production_directory = common.get_full_path(production_directory)
production_table_file = os.path.join(production_directory,
"production_fluid_table.csv")
injection_table_file = os.path.join(production_directory,
"injection_fluid_table.csv")
bore_oil_file = os.path.join(production_directory, "BORE_OIL_VOL.csv")
bore_gas_file = os.path.join(production_directory, "BORE_GAS_VOL.csv")
bore_water_file = os.path.join(production_directory, "BORE_WAT_VOL.csv")
print("Loading oil volumes from file", bore_oil_file)
bore_oil = pd.read_csv(bore_oil_file)
print("Loading gas volumes from file", bore_gas_file)
bore_gas = pd.read_csv(bore_gas_file)
print("Loading water volumes from file", bore_water_file)
bore_water = pd.read_csv(bore_water_file)
with open(production_table_file, "w") as file_object:
file_object.write("Well_name,4D_interval,Volumes,Fluid\n")
fluid = "Oil_[Sm3]"
write_data(bore_oil, fluid, 1, file_object)
fluid = "Gas_[kSm3]"
write_data(bore_gas, fluid, 1000, file_object)
fluid = "Water_[Sm3]"
write_data(bore_water, fluid, 1, file_object)
print("Production volumes table stored to file", production_table_file)
inject_gas_file = os.path.join(production_directory, "BORE_GI_VOL.csv")
inject_water_file = os.path.join(production_directory, "BORE_WI_VOL.csv")
print("Loading injected gas volumes from file", inject_gas_file)
inject_gas = pd.read_csv(inject_gas_file)
print("Loading injected water volumes from file", inject_water_file)
inject_water = pd.read_csv(inject_water_file)
with open(injection_table_file, "w") as file_object:
file_object.write("Well_name,4D_interval,Volumes,Fluid\n")
fluid = "Injected_Gas_[kSm3]"
write_data(inject_gas, fluid, 1000, file_object)
fluid = "Injected_Water_[Sm3]"
write_data(inject_water, fluid, 1, file_object)
print("Injection volumes table stored to file", injection_table_file)
def main():
# Main
description = "Create well lists based on production data"
parser = argparse.ArgumentParser(description=description)
parser.add_argument("config_file",
help="Enter path to the WebViz-4D configuration file")
args = parser.parse_args()
print(description)
print(args)
config_file = args.config_file
config = common.read_config(config_file)
# Well and production data
well_suffix = common.get_config_item(config, "well_suffix")
map_suffix = common.get_config_item(config, "map_suffix")
delimiter = common.get_config_item(config, "delimiter")
metadata_file = common.get_config_item(config, "surface_metadata")
well_directory = common.get_config_item(config, "wellfolder")
well_directory = common.get_full_path(well_directory)
prod_info_dir = common.get_config_item(config, "production_data")
prod_info_dir = common.get_full_path(prod_info_dir)
update_metadata_file = os.path.join(prod_info_dir,
".production_update.yaml")
update_dates = common.get_update_dates(well_directory)
production_update = update_dates["production_last_date"]
print("Production data update", production_update)
try:
settings_file = common.get_config_item(config, "settings")
settings_file = common.get_full_path(settings_file)
settings = common.read_config(settings_file)
interval = common.get_config_item(config, "default_interval")
except:
settings_file = None
settings = None
interval = None
shared_settings = config["shared_settings"]
print("Extracting 4D intervals ...")
metadata_file = common.get_config_item(config, "surface_metadata")
metadata = get_metadata(shared_settings, delimiter, map_suffix,
metadata_file)
intervals_4d, incremental = get_all_intervals(metadata, "reverse")
colors = common.get_well_colors(settings)
prod_info_files = [os.path.join(prod_info_dir, OIL_PRODUCTION_FILE)]
prod_info_files.append(os.path.join(prod_info_dir, GAS_INJECTION_FILE))
prod_info_files.append(os.path.join(prod_info_dir, WATER_INJECTION_FILE))
prod_info_list = []
for prod_info_file in prod_info_files:
print("Reading production info from file " + str(prod_info_file))
prod_info = pd.read_csv(prod_info_file)
prod_info.name = os.path.basename(str(prod_info_file))
prod_info_list.append(prod_info)
drilled_well_df, drilled_well_info, interval_df = well.load_all_wells(
well_directory, well_suffix)
drilled_well_info = add_production_volumes(drilled_well_info,
prod_info_list)
#well_info = WellDataFrame(drilled_well_info)
wellbores = drilled_well_info["wellbore.name"].unique()
# print("well_info.data_frame")
print("Last production update", production_update)
print("Looping through all 4D intervals ...")
for interval_4d in intervals_4d:
print("4D interval:", interval_4d)
if interval_4d[0:10] <= production_update:
well_layer = make_new_well_layer(
interval_4d,
drilled_well_df,
drilled_well_info,
interval_df,
prod_info_list,
colors,
selection="production",
label="Producers",
)
label = "production_well_layer_"
store_well_layer(well_layer, well_directory, label, interval_4d)
well_layer = make_new_well_layer(
interval_4d,
drilled_well_df,
drilled_well_info,
interval_df,
prod_info_list,
colors,
selection="production_start",
label="Producers - started",
)
label = "production_start_well_layer_"
store_well_layer(well_layer, well_directory, label, interval_4d)
well_layer = make_new_well_layer(
interval_4d,
drilled_well_df,
drilled_well_info,
interval_df,
prod_info_list,
colors,
selection="production_completed",
label="Producers - completed",
)
label = "production_completed_well_layer_"
store_well_layer(well_layer, well_directory, label, interval_4d)
well_layer = make_new_well_layer(
interval_4d,
drilled_well_df,
drilled_well_info,
interval_df,
prod_info_list,
colors,
selection="injection",
label="Injectors",
)
label = "injection_well_layer_"
store_well_layer(well_layer, well_directory, label, interval_4d)
well_layer = make_new_well_layer(
interval_4d,
drilled_well_df,
drilled_well_info,
interval_df,
prod_info_list,
colors,
selection="injection_start",
label="Injectors - started",
)
label = "injection_start_well_layer_"
store_well_layer(well_layer, well_directory, label, interval_4d)
well_layer = make_new_well_layer(
interval_4d,
drilled_well_df,
drilled_well_info,
interval_df,
prod_info_list,
colors,
selection="injection_completed",
label="Injectors - completed",
)
label = "injection_completed_well_layer_"
store_well_layer(well_layer, well_directory, label, interval_4d)
else:
print(" - no production data for this time interval")
prod_headers = prod_info.columns
last_header = prod_headers[-1]
interval_4d = last_header
well_layer = make_new_well_layer(
interval_4d,
drilled_well_df,
drilled_well_info,
interval_df,
prod_info_list,
colors,
selection="active",
label="Active wells",
)
if well_layer:
label = "active_well_layer_"
store_well_layer(well_layer, well_directory, label, interval_4d)
def main():
""" Compile metadata from all wells and extract top reservoir depths """
description = "Compile metadata from all wells and extract top reservoir depths"
parser = argparse.ArgumentParser(description=description)
parser.add_argument("config_file",
help="Enter path to the WebViz-4D configuration file")
args = parser.parse_args()
print(description)
print(args)
config_file = args.config_file
config = common.read_config(config_file)
try:
well_directory = common.get_config_item(config, "wellfolder")
well_directory = common.get_full_path(well_directory)
except:
well_directory = None
print("ERROR: Well directory", well_directory, "not found")
print("Execution stopped")
print("Well directory", well_directory)
if well_directory:
try:
settings_file = common.get_config_item(config, "settings")
settings_file = common.get_full_path(settings_file)
settings = common.read_config(settings_file)
surface_file = settings["depth_maps"]["top_reservoir"]
surface = load_surface(surface_file)
except:
surface_file = None
surface = None
else:
print("ERROR: Well data not found in", well_directory)
exit()
print("Surface file", surface_file)
WELLBORE_INFO_FILE = "wellbore_info.csv"
INTERVALS_FILE = "intervals.csv"
WELL_SUFFIX = ".w"
wellbore_info, intervals = extract_metadata(well_directory)
pd.set_option("display.max_rows", None)
print(wellbore_info)
wellbore_info = compile_data(surface, well_directory, wellbore_info,
WELL_SUFFIX)
wellbore_info.to_csv(os.path.join(well_directory, WELLBORE_INFO_FILE))
intervals.to_csv(os.path.join(well_directory, INTERVALS_FILE))
# print(intervals)
print("Metadata stored to " +
os.path.join(well_directory, WELLBORE_INFO_FILE))
print("Completion intervals stored to " +
os.path.join(well_directory, INTERVALS_FILE))
planned_wells_dir = [
f.path for f in os.scandir(well_directory) if f.is_dir()
]
for folder in planned_wells_dir:
wellbore_info = pd.DataFrame()
wellbore_info = compile_data(surface, folder, wellbore_info,
WELL_SUFFIX)
wellbore_info.to_csv(os.path.join(folder, WELLBORE_INFO_FILE))
print(wellbore_info)
print("Metadata stored to " + os.path.join(folder, WELLBORE_INFO_FILE))
def test_read_config():
well_folder = common.get_config_item(config, "wellfolder")
assert well_folder == "./well_data"
import os
import pytest
import webviz_4d._datainput.common as common
config_file = "./tests/data/example_config.yaml"
config = common.read_config(config_file)
config_folder = os.path.dirname(config_file)
settings_file = common.get_config_item(config, "settings")
settings_file = os.path.join(config_folder, settings_file)
settings = common.read_config(settings_file)
def test_read_config():
well_folder = common.get_config_item(config, "wellfolder")
assert well_folder == "./well_data"
def test_get_well_colors():
colors = common.get_well_colors(settings)
default = colors["default"]
oil = colors["oil_production"]
assert default == "black"
assert oil == "green"
def main():
# Reek data
print("Reek")
config_file = "./examples/reek_4d.yaml"
config = common.read_config(config_file)
print(config_file)
print(config)
wellfolder = common.get_config_item(config, "wellfolder")
print("wellfolder", wellfolder)
settings_file = common.get_config_item(config, "settings_file")
print("settings_file", settings_file)
settings_file = common.get_full_path(settings_file)
print("settings_file", settings_file)
print("")
# Johan Sverdrup (Eli/Tonje)
print("Johan Sverdrup - synthetic 4D maps")
config_file = "configurations/js_test_eli_v2.yaml"
config = common.read_config(config_file)
shared_settings = config["shared_settings"]
print(config_file)
print(config)
map_suffix = common.get_config_item(config, "map_suffix")
delimiter = common.get_config_item(config, "delimiter")
metadata_file = common.get_config_item(config, "surface_metadata")
metadata = get_metadata(shared_settings, map_suffix, delimiter, metadata_file)
print(metadata)
all_intervals, incremental_intervals = get_all_intervals(metadata, "reverse")
print("incremental_intervals")
print(incremental_intervals)
print("all_intervals")
print(all_intervals)
print("")
# Johan Sverdrup (Simulation model)
print("Johan Sverdrup - simulation model")
config_file = "configurations/js_test.yaml"
config = common.read_config(config_file)
shared_settings = config["shared_settings"]
print(config_file)
print(config)
map_suffix = common.get_config_item(config, "map_suffix")
delimiter = common.get_config_item(config, "delimiter")
metadata_file = common.get_config_item(config, "surface_metadata")
metadata = get_metadata(shared_settings, map_suffix, delimiter, metadata_file)
print(metadata)
all_intervals, incremental_intervals = get_all_intervals(metadata, "reverse")
print("incremental_intervals")
print(incremental_intervals)
print("all_intervals")
print(all_intervals)
print("")
# Grane
print("Grane")
config_file = "configurations/config_template.yaml"
print(config_file)
config = common.read_config(config_file)
shared_settings = config["shared_settings"]
map_suffix = common.get_config_item(config, "map_suffix")
print("map_suffix", map_suffix)
delimiter = common.get_config_item(config, "delimiter")
print("delimiter", delimiter)
metadata_file = common.get_config_item(config, "surface_metadata")
print("metadata_file", metadata_file)
metadata = get_metadata(shared_settings, map_suffix, delimiter, metadata_file)
print(metadata)
all_intervals, incremental_intervals = get_all_intervals(metadata, "normal")
print("incremental_intervals")
print(incremental_intervals)
print("all_intervals")
print(all_intervals)
read_config,
get_config_item,
)
from webviz_4d._datainput._polygons import (
load_polygons,
load_zone_polygons,
make_new_polyline_layer,
get_zone_layer,
)
config_file = "./tests/data/example_config.yaml"
config = read_config(config_file)
config_folder = os.path.dirname(config_file)
settings_file = get_config_item(config, "settings")
settings_file = os.path.join(config_folder, settings_file)
settings_folder = os.path.dirname(settings_file)
settings = read_config(settings_file)
polygon_folder = settings["polygon_data"]
polygon_folder = Path(os.path.join(settings_folder, polygon_folder))
polygon_colors = settings.get("polygon_colors")
fault_layer = {
"name": "Faults",
"checked": True,
"base_layer": False,
}
owc_layer = {
"name": "Initial OWC",
def main():
# Main
description = "Create a well overview file (.csv) with relevant metadata"
parser = argparse.ArgumentParser(description=description)
parser.add_argument("config_file",
help="Enter path to the WebViz-4D configuration file")
args = parser.parse_args()
print(description)
print(args)
config_file = args.config_file
config = common.read_config(config_file)
# Well and production data
well_suffix = common.get_config_item(config, "well_suffix")
map_suffix = common.get_config_item(config, "map_suffix")
delimiter = common.get_config_item(config, "delimiter")
metadata_file = common.get_config_item(config, "surface_metadata")
well_directory = common.get_config_item(config, "wellfolder")
well_directory = common.get_full_path(well_directory)
prod_info_dir = common.get_config_item(config, "production_data")
prod_info_dir = common.get_full_path(prod_info_dir)
update_metadata_file = os.path.join(prod_info_dir,
".production_update.yaml")
prod_info_files = [os.path.join(prod_info_dir, OIL_PRODUCTION_FILE)]
prod_info_files.append(os.path.join(prod_info_dir, GAS_INJECTION_FILE))
prod_info_files.append(os.path.join(prod_info_dir, WATER_INJECTION_FILE))
prod_info_list = []
for prod_info_file in prod_info_files:
print("Reading production info from file " + str(prod_info_file))
prod_info = pd.read_csv(prod_info_file)
prod_info.name = os.path.basename(str(prod_info_file))
prod_info_list.append(prod_info)
_drilled_well_df, drilled_well_info, interval_df = well.load_all_wells(
well_directory, well_suffix)
print(interval_df)
drilled_well_info = add_production_volumes(drilled_well_info,
prod_info_list)
wellbore_overview = drilled_well_info[[
"wellbore.name",
"wellbore.well_name",
"BORE_OIL_VOL.csv_PDM well name",
"wellbore.drilling_end_date",
"wellbore.type",
"wellbore.fluids",
"BORE_OIL_VOL.csv_Start date",
"BORE_OIL_VOL.csv_Stop date",
"BORE_GI_VOL.csv_Start date",
"BORE_GI_VOL.csv_Stop date",
"BORE_WI_VOL.csv_Start date",
"BORE_WI_VOL.csv_Stop date",
]]
print(wellbore_overview)
wellbores = wellbore_overview["wellbore.name"].unique()
top_completion = []
end_completion = []
for wellbore in wellbores:
try:
top_md = interval_df[interval_df["interval.wellbore"] ==
wellbore]["interval.mdTop"].values[0]
except:
top_md = None
top_completion.append(top_md)
try:
base_md = interval_df[interval_df["interval.wellbore"] ==
wellbore]["interval.mdBottom"].values[-1]
except:
base_md = None
print(wellbore, top_md, base_md)
end_completion.append(base_md)
wellbore_overview.insert(6, "Top Screen", top_completion)
wellbore_overview.insert(7, "Base Screen", end_completion)
wellbore_overview.rename(columns={
"wellbore.name": "Wellbore",
"wellbore.well_name": "Well",
"wellbore.drilling_end_date": "Drilling ended",
"wellbore.type": "Type",
"wellbore.fluids": "Fluid(s)",
"BORE_OIL_VOL.csv_PDM well name": "PDM Well",
"BORE_OIL_VOL.csv_Start date": "Start oil prod.",
"BORE_OIL_VOL.csv_Stop date": "End oil prod.",
"BORE_GI_VOL.csv_Start date": "Start gas inj.",
"BORE_GI_VOL.csv_Stop date": "End gas inj.",
"BORE_WI_VOL.csv_Start date": "Start water inj.",
"BORE_WI_VOL.csv_Stop date": "End water inj.",
},
inplace=True)
wellbore_overview.sort_values("Wellbore", inplace=True)
print(wellbore_overview)
csv_file = os.path.join(well_directory, "wellbore_overview.csv")
wellbore_overview.to_csv(csv_file, index=False, float_format='%.1f')
print("Wellbore overview saved to:", csv_file)
def main():
""" Extract min-/max-values for all maps """
parser = argparse.ArgumentParser(
description="Extract min-/max-values for all maps")
parser.add_argument("config_file",
help="Enter path to the WebViz-4D configuration file")
parser.add_argument(
"--mode",
help=
"Full=> all maps, Standard (default)=> only one realization and iteration",
default="Standard",
)
args = parser.parse_args()
config_file = args.config_file
mode = args.mode
config = common.read_config(config_file)
shared_settings = config["shared_settings"]
map_suffix = common.get_config_item(config, "map_suffix")
delimiter = common.get_config_item(config, "delimiter")
metadata_file = common.get_config_item(config, "surface_metadata")
settings_file = common.get_config_item(config, "settings")
settings_file = common.get_full_path(settings_file)
settings = common.read_config(settings_file)
csv_file = settings["map_settings"]["colormaps_settings"]
csv_file = common.get_full_path(csv_file)
print(csv_file)
if csv_file is not None and os.path.isfile(csv_file):
old_map_df = pd.read_csv(csv_file)
print(" - file loaded")
print(old_map_df)
else:
old_map_df = None
csv_file = settings["map_settings"]["colormaps_settings"]
surface_metadata = _metadata.get_metadata(shared_settings, map_suffix,
delimiter, metadata_file)
print("surface_metadata")
print(surface_metadata)
surface_types = ["observations", "results"]
mapping_dict = {"observations": "observed", "results": "simulated"}
results_map_dir = mapping_dict["results"] + "_maps"
if results_map_dir is not None:
map_settings = shared_settings[results_map_dir]
realization_names = map_settings["realization_names"]
iteration_names = map_settings["ensemble_names"]
selected_realization = realization_names[0].replace("*", "0")
selected_iteration = iteration_names[0].replace("*", "0")
map_types = []
surface_names = []
attributes = []
intervals = []
map_files = []
min_values = []
max_values = []
lower_limits = []
upper_limits = []
headers = [
"map type",
"name",
"attribute",
"interval",
"minimum value",
"maximum value",
"lower_limit",
"upper_limit",
"file_path",
]
map_df = pd.DataFrame()
surface_files = surface_metadata["filename"]
surface_files = surface_files.replace("/.", "/").replace(".yaml", "")
for _index, row in surface_metadata.iterrows():
#print(row)
map_type = row["map_type"]
surface_name = row["data.name"]
attribute = row["data.content"]
interval = (row["data.time.t2"].replace("-", "") + "_" +
row["data.time.t1"].replace("-", ""))
surface_file = row["filename"]
surface_file = surface_file.replace("/.", "/").replace(".yaml", "")
# print(surface_file)
print(map_type, surface_name, attribute, interval)
if not mode == "Full":
realization = row["fmu_id.realization"]
iteration = row["fmu_id.ensemble"]
# print(realization, iteration)
if map_type == "results":
if (realization == selected_realization
and iteration == selected_iteration):
surface = load_surface(surface_file)
map_types.append(map_type)
surface_names.append(surface_name)
attributes.append(attribute)
intervals.append(interval)
zvalues = get_surface_arr(surface)[2]
min_val = np.nanmin(zvalues)
max_val = np.nanmax(zvalues)
min_values.append(min_val)
max_values.append(max_val)
map_files.append(surface_file)
lower_limit, upper_limit = get_plot_limits(
old_map_df, map_type, surface_name, attribute,
interval)
lower_limits.append(lower_limit)
upper_limits.append(upper_limit)
else:
surface = load_surface(surface_file)
map_types.append(map_type)
surface_names.append(surface_name)
attributes.append(attribute)
intervals.append(interval)
zvalues = get_surface_arr(surface)[2]
min_val = np.nanmin(zvalues)
max_val = np.nanmax(zvalues)
min_values.append(min_val)
max_values.append(max_val)
map_files.append(surface_file)
lower_limit, upper_limit = get_plot_limits(
old_map_df, map_type, surface_name, attribute, interval)
lower_limits.append(lower_limit)
upper_limits.append(upper_limit)
else:
surface = load_surface(surface_file)
map_types.append(map_type)
surface_names.append(surface_name)
attributes.append(attribute)
intervals.append(interval)
zvalues = get_surface_arr(surface)[2]
min_val = np.nanmin(zvalues)
max_val = np.nanmax(zvalues)
min_values.append(min_val)
max_values.append(max_val)
map_files.append(surface_file)
lower_limit, upper_limit = get_plot_limits(old_map_df, map_type,
surface_name, attribute,
interval)
lower_limits.append(lower_limit)
upper_limits.append(upper_limit)
map_df[headers[0]] = map_types
map_df[headers[1]] = surface_names
map_df[headers[2]] = attributes
map_df[headers[3]] = intervals
map_df[headers[4]] = min_values
map_df[headers[5]] = max_values
map_df[headers[6]] = lower_limits
map_df[headers[7]] = upper_limits
map_df[headers[8]] = map_files
print(map_df)
map_df.to_csv(csv_file, index=False)
print("Data saved to ", csv_file)
def test_get_config_item():
config_file = "../../reek_4d.yaml"
config = read_config(config_file)
print(get_config_item(config, "fmu_directory"))
assert get_config_item(config, "fmu_directory") == FMU_DIRECTORY