def test_load_all_wells():
well_file = "55_33-A-1.w"
well_file = Path(
os.path.join(test_folder, data_folder, well_folder, well_file))
xtgeo_well_A1 = xtgeo.well_from_file(well_file, mdlogname="MD")
well_A1 = load_well(well_file)
wellbore_info = "wellbore_info.csv"
wellbore_info = Path(
os.path.join(test_folder, data_folder, well_folder, wellbore_info))
all_wells_info = read_csv(csv_file=wellbore_info)
all_wells_df = load_all_wells(all_wells_info)
well_A1_df = all_wells_df[all_wells_df["WELLBORE_NAME"] == "55/33-A-1"]
assert well_A1.dataframe["X_UTME"].all() == well_A1_df["X_UTME"].all()
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():
"""Create information about the well layers in WebViz-4D"""
description = "Create information about the well layers in WebViz-4D"
parser = argparse.ArgumentParser(description=description)
parser.add_argument("settings_file", help="Enter name of settings file")
parser.add_argument("interval", help="Enter wanted 4D interval")
args = parser.parse_args()
settings_file = args.settings_file
settings_file = os.path.abspath(settings_file)
settings_folder = os.path.dirname(settings_file)
settings = read_config(settings_file)
selected_interval = args.interval
well_folder = settings["well_data"]
well_folder = os.path.join(settings_folder, well_folder)
# Read production data
prod_folder = settings["production_data"]
prod_folder = os.path.join(settings_folder, prod_folder)
prod_names = [
"BORE_OIL_VOL.csv",
"BORE_GAS_VOL.csv",
"BORE_WAT_VOL.csv",
"BORE_GI_VOL.csv",
"BORE_WI_VOL.csv",
]
prod_data = read_csvs(folder=prod_folder, csv_files=prod_names)
print("Reading production data from", prod_folder)
print(prod_data)
incremental_intervals_df = get_incremental_intervals(prod_data)
columns = incremental_intervals_df.columns
intervals = []
for i in range(5, len(columns)):
interval = columns[i]
intervals.append(interval)
print("Reading well data from", well_folder)
if well_folder:
all_wells_info = read_csv(csv_file=Path(well_folder) / "wellbore_info.csv")
all_wells_info["file_name"] = all_wells_info["file_name"].apply(
lambda x: get_path(Path(x))
)
all_wells_df = load_all_wells(all_wells_info)
drilled_wells_df = all_wells_df.loc[
all_wells_df["layer_name"] == "Drilled wells"
]
drilled_wells_info = all_wells_info.loc[
all_wells_info["layer_name"] == "Drilled wells"
]
drilled_wells_df.sort_values(by=["WELLBORE_NAME"], inplace=True)
planned_wells_info = all_wells_info.loc[
all_wells_info["wellbore.type"] == "planned"
]
if planned_wells_info is not None:
planned_well_layers = planned_wells_info["layer_name"].unique()
else:
planned_well_layers = []
well_colors = {
"default": "black",
"oil_open": "lime",
"oil_production": "green",
"gas_open": "salmon",
"gas_production": "magenta",
"gas_injection": "red",
"water_injection": "blue",
"wag_injection": "blueviolet",
"planned": "purple",
}
drilled_well_layers = {
"drilled_wells": "Drilled wells",
"reservoir_section": "Reservoir sections",
"active_production": "Active producers",
"active_injection": "Active injectors",
"production": "Producers",
"production_start": "Producers - started",
"production_completed": "Producers - completed",
"injection": "Injectors",
"injection_start": "Injectors -started",
"injection_completed": "Injectors - completed",
}
fluids_dict = {
"production": ["oil"],
"active_production": ["oil"],
"production_start": ["oil"],
"production_completed": ["oil"],
"injection": ["gas", "water"],
"active_injection": ["gas", "water"],
"injection_start": ["gas", "water"],
"injection_completed": ["gas", "water"],
"planned": [],
}
headers = [
"Short name",
"Well type",
"Fluid(s)",
"Volume",
"Unit",
"Start year",
"Last year",
"Color",
]
for key in drilled_well_layers:
selection = key
value = drilled_well_layers[key]
if "active" in selection:
fluids = fluids_dict[selection]
interval_label = ""
elif "production" in selection or "injection" in selection:
fluids = fluids_dict[selection]
interval_label = "_" + selected_interval
else:
fluids = None
interval_label = ""
outfile = os.path.join(well_folder, selection + ".csv")
print("\n" + selection, interval, fluids)
well_layer = make_new_well_layer(
selected_interval,
all_wells_df,
drilled_wells_info,
prod_data,
well_colors,
selection=selection,
fluids=fluids,
label=value,
)
data = well_layer["data"]
short_names = []
well_types = []
fluids = []
volumes = []
units = []
start_years = []
last_years = []
colors = []
index = 1
for item in data:
tooltip = item["tooltip"]
info = tooltip.split(" ")
short_name = info[0].replace(":", "")
well_type = info[1]
if len(info) >= 3:
fluid = info[2]
if "Start:" in info:
ind = info.index("Start:") - 2
volume = info[ind]
unit = info[ind + 1]
start_year = info[ind + 3]
last_year = info[ind + 5].replace(")", "")
else:
ind = len(info)
start_year = None
last_year = None
volume = None
unit = None
for i in range(3, ind):
fluid = fluid + " " + info[i]
if "WAG" in fluid:
volume = None
unit = None
fluid = fluid.replace("(", "").replace(")", "")
color = item["color"]
index = index + 1
short_names.append(short_name)
well_types.append(well_type)
fluids.append(fluid)
volumes.append(volume)
units.append(unit)
start_years.append(start_year)
last_years.append(last_year)
colors.append(color)
zipped_list = list(
zip(
short_names,
well_types,
fluids,
volumes,
units,
start_years,
last_years,
colors,
)
)
layer_df = pd.DataFrame(zipped_list, columns=headers)
outfile = os.path.join(
well_folder, "well_layer_" + selection + interval_label + ".csv"
)
layer_df.to_csv(outfile, index=False)
print("List of wells in layer", selection, "stored in:", outfile)
selection = "planned"
fluids = []
for key in planned_well_layers:
value = key
print("\n" + selection, value)
well_layer = make_new_well_layer(
interval,
all_wells_df,
planned_wells_info,
prod_data,
well_colors,
selection=selection,
fluids=fluids,
label=value,
)
data = well_layer["data"]
index = 1
for item in data:
print(index, item["tooltip"], item["color"])
index = index + 1
def __init__(
self,
app,
wellfolder: Path = None,
production_data: Path = None,
polygons_folder: Path = None,
colormaps_folder: Path = None,
map1_defaults: dict = None,
map2_defaults: dict = None,
map3_defaults: dict = None,
map_suffix: str = ".gri",
default_interval: str = None,
settings: Path = None,
delimiter: str = "--",
surface_metadata_file: Path = None,
attribute_maps_file: Path = None,
interval_mode: str = "reverse",
selector_file: Path = None,
):
super().__init__()
self.shared_settings = app.webviz_settings["shared_settings"]
self.fmu_directory = self.shared_settings["fmu_directory"]
self.label = self.shared_settings.get("label", self.fmu_directory)
self.basic_well_layers = self.shared_settings.get(
"basic_well_layers", None)
self.additional_well_layers = self.shared_settings.get(
"additional_well_layers")
self.map_suffix = map_suffix
self.delimiter = delimiter
self.interval_mode = interval_mode
self.number_of_maps = 3
self.observations = "observed"
self.simulations = "simulated"
self.wellsuffix = ".w"
self.surface_layer = None
self.attribute_settings = {}
self.well_update = ""
self.production_update = ""
self.selected_names = [None, None, None]
self.selected_attributes = [None, None, None]
self.selected_ensembles = [None, None, None]
self.selected_realizations = [None, None, None]
self.well_base_layers = []
self.interval_well_layers = {}
# Define well layers
default_basic_well_layers = {
"drilled_wells": "Drilled wells",
"reservoir_section": "Reservoir sections",
"active_production": "Current producers",
"active_injection": "Current injectors",
}
if self.basic_well_layers is None:
self.basic_well_layers = default_basic_well_layers
default_additional_well_layers = {
"production": "Producers",
"production_start": "Producers - started",
"production_completed": "Producers - completed",
"injection": "Injectors",
"injection_start": "Injectors - started",
"injection_completed": "Injectors - completed",
}
if self.additional_well_layers is None:
self.additional_well_layers = default_additional_well_layers
# Read production data
self.prod_names = [
"BORE_OIL_VOL.csv", "BORE_GI_VOL.csv", "BORE_WI_VOL.csv"
]
self.prod_folder = production_data
self.prod_data = read_csvs(folder=self.prod_folder,
csv_files=self.prod_names)
print("Reading production data from", self.prod_folder)
# Read maps metadata
self.surface_metadata_file = surface_metadata_file
print("Reading maps metadata from", self.surface_metadata_file)
self.surface_metadata = (read_csv(
csv_file=self.surface_metadata_file) if self.surface_metadata_file
is not None else None)
self.selector_file = selector_file
self.selection_list = read_config(get_path(path=self.selector_file))
# Read custom colormaps
self.colormaps_folder = colormaps_folder
if self.colormaps_folder is not None:
self.colormap_files = [
get_path(Path(fn))
for fn in json.load(find_files(self.colormaps_folder, ".csv"))
]
print("Reading custom colormaps from:", self.colormaps_folder)
load_custom_colormaps(self.colormap_files)
# Read attribute maps settings (min-/max-values)
self.colormap_settings = None
self.attribute_maps_file = attribute_maps_file
if self.attribute_maps_file is not None:
self.colormap_settings = read_csv(
csv_file=self.attribute_maps_file)
print("Colormaps settings loaded from file",
self.attribute_maps_file)
# Read settings
self.settings_path = settings
if self.settings_path:
self.config = read_config(get_path(path=self.settings_path))
self.attribute_settings = None
self.delimiter = None
map_settings = self.config.get("map_settings")
self.attribute_settings = map_settings.get("attribute_settings")
self.default_colormap = map_settings.get("default_colormap",
"seismic")
# Read settings (defaults)
if default_interval is None:
try:
default_interval = self.selection_list[
self.observations]["interval"][0]
except:
try:
default_interval = self.selection_list[
self.simulations]["interval"][0]
except:
default_interval = None
self.map_defaults = []
self.maps_metadata_list = []
if map1_defaults is not None:
map1_defaults["interval"] = default_interval
self.map_defaults.append(map1_defaults)
self.map1_options = self.selection_list[map1_defaults["map_type"]]
if map2_defaults is not None:
map2_defaults["interval"] = default_interval
self.map_defaults.append(map2_defaults)
self.map2_options = self.selection_list[map2_defaults["map_type"]]
if map3_defaults is not None:
map3_defaults["interval"] = default_interval
self.map_defaults.append(map3_defaults)
self.map2_options = self.selection_list[map2_defaults["map_type"]]
print("Default interval", default_interval)
if map1_defaults is None or map2_defaults is None or map3_defaults is None:
self.map_defaults = get_map_defaults(
self.selection_list,
default_interval,
self.observations,
self.simulations,
)
else:
self.map_defaults = []
self.map_defaults.append(map1_defaults)
self.map_defaults.append(map2_defaults)
self.map_defaults.append(map3_defaults)
self.selected_intervals = [
default_interval, default_interval, default_interval
]
self.colors = get_well_colors(self.config)
# Load polygons
self.polygons_folder = polygons_folder
self.polygon_layers = None
self.zone_polygon_layers = None
if self.polygons_folder is not None:
self.polygon_files = [
get_path(Path(fn))
for fn in json.load(find_files(self.polygons_folder, ".csv"))
]
print("Reading polygons from:", self.polygons_folder)
polygon_colors = self.config.get("polygon_colors")
self.polygon_layers = load_polygons(self.polygon_files,
polygon_colors)
# Load zone fault if existing
self.zone_faults_folder = Path(
os.path.join(self.polygons_folder, "rms"))
self.zone_faults_files = [
get_path(Path(fn)) for fn in json.load(
find_files(self.zone_faults_folder, ".csv"))
]
print("Reading zone polygons from:", self.zone_faults_folder)
self.zone_polygon_layers = load_zone_polygons(
self.zone_faults_files, polygon_colors)
# Read update dates and well data
# self.drilled_wells_df: dataframe with wellpaths (x- and y positions) for all drilled wells
# self.drilled_wells_info: dataframe with metadata for all drilled wells
self.wellfolder = wellfolder
print("Reading well data from", self.wellfolder)
if self.wellfolder:
self.wellbore_info = read_csv(csv_file=Path(self.wellfolder) /
"wellbore_info.csv")
update_dates = get_update_dates(
welldata=get_path(
Path(self.wellfolder) / ".welldata_update.yaml"),
productiondata=get_path(
Path(self.wellfolder) / ".production_update.yaml"),
)
self.well_update = update_dates["well_update_date"]
self.production_update = update_dates["production_last_date"]
self.all_wells_info = read_csv(csv_file=Path(self.wellfolder) /
"wellbore_info.csv")
self.all_wells_info["file_name"] = self.all_wells_info[
"file_name"].apply(lambda x: get_path(Path(x)))
self.all_wells_df = load_all_wells(self.all_wells_info)
self.drilled_wells_files = list(
self.wellbore_info[self.wellbore_info["layer_name"] ==
"Drilled wells"]["file_name"])
self.drilled_wells_df = self.all_wells_df.loc[
self.all_wells_df["layer_name"] == "Drilled wells"]
self.drilled_wells_info = self.all_wells_info.loc[
self.all_wells_info["layer_name"] == "Drilled wells"]
interval = self.selected_intervals[0]
# Create well layers for the layers that are independent of the selected 4D interval
if self.drilled_wells_df is not None:
for key, value in self.basic_well_layers.items():
if value is not None:
if "production" in key:
fluids = ["oil"]
elif "injection" in key:
fluids = ["gas", "water"]
else:
fluids = []
print("Creating well layer for", value)
well_layer = make_new_well_layer(
interval,
self.drilled_wells_df,
self.drilled_wells_info,
self.prod_data,
self.colors,
selection=key,
fluids=fluids,
label=value,
)
if well_layer is not None:
self.well_base_layers.append(well_layer)
# Load wellpaths for planned wells and create planned well layers
try:
planned_well_df = self.all_wells_df.loc[
self.all_wells_df["layer_name"] != "Drilled wells"]
planned_well_info = self.all_wells_info.loc[
self.all_wells_info["layer_name"] != "Drilled wells"]
except:
planned_well_df = None
planned_well_info = None
if planned_well_df is not None:
planned_layers_df = planned_well_info["layer_name"].dropna()
planned_layers = planned_layers_df.unique()
for planned_layer in planned_layers:
self.well_base_layers.append(
make_new_well_layer(
self.selected_intervals[0],
planned_well_df,
planned_well_info,
prod_data=None,
colors=self.colors,
selection="planned",
fluids=[],
label=planned_layer,
))
# Create production and injection layers for the default interval
self.interval_well_layers = self.create_additional_well_layers(
interval)
# Create selectors (attributes, names and dates) for all 3 maps
self.selector = SurfaceSelector(app, self.selection_list,
self.map_defaults[0])
self.selector2 = SurfaceSelector(app, self.selection_list,
self.map_defaults[1])
self.selector3 = SurfaceSelector(app, self.selection_list,
self.map_defaults[2])
self.set_callbacks(app)
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 __init__(
self,
app,
wellfolder: Path = None,
production_data: Path = None,
map1_defaults: dict = None,
well_suffix: str = ".w",
map_suffix: str = ".gri",
default_interval: str = None,
settings: Path = None,
delimiter: str = "--",
surface_metadata: str = "surface_metadata.csv",
):
super().__init__()
self.shared_settings = app.webviz_settings["shared_settings"]
self.fmu_directory = self.shared_settings["fmu_directory"]
self.map_suffix = map_suffix
self.delimiter = delimiter
self.wellfolder = wellfolder
self.observations = "observations"
self.simulations = "results"
self.config = None
self.attribute_settings = {}
self.surface_metadata = None
self.well_base_layers = None
#print("default_interval", default_interval)
self.fmu_info = self.fmu_directory
self.well_update = ""
self.production_update = ""
self.number_of_maps = 1
self.metadata = get_metadata(
self.shared_settings, map_suffix, delimiter, surface_metadata
)
#print("Maps metadata")
#print(self.metadata)
self.intervals, incremental = get_all_intervals(self.metadata, "reverse")
#print(self.intervals)
if default_interval is None:
default_interval = self.intervals[-1]
self.surface_layer = None
if settings:
self.configuration = settings
self.config = read_config(self.configuration)
# print(self.config)
try:
self.attribute_settings = self.config["map_settings"][
"attribute_settings"
]
except:
pass
try:
colormaps_folder = self.config["map_settings"]["colormaps_folder"]
if colormaps_folder:
colormaps_folder = get_full_path(colormaps_folder)
print("Reading custom colormaps from:", colormaps_folder)
load_custom_colormaps(colormaps_folder)
except:
pass
try:
attribute_maps_file = self.config["map_settings"]["colormaps_settings"]
attribute_maps_file = get_full_path(attribute_maps_file)
self.surface_metadata = pd.read_csv(attribute_maps_file)
print("Colormaps settings loaded from file", attribute_maps_file)
#print(self.surface_metadata)
except:
pass
self.map_defaults = []
if map1_defaults is not None:
map1_defaults["interval"] = default_interval
self.map_defaults.append(map1_defaults)
print("Default interval", default_interval)
#print("Map 1 defaults:")
#print(map1_defaults)
if map1_defaults is None:
self.map_defaults = create_map_defaults(
self.metadata, default_interval, self.observations, self.simulations
)
else:
self.map_defaults = []
self.map_defaults.append(map1_defaults)
#print("map_defaults", self.map_defaults)
self.selected_interval = default_interval
self.selected_name = None
self.selected_attribute = None
self.selected_ensemble = None
self.selected_realization = None
self.wellsuffix = ".w"
self.well_base_layers = []
self.colors = get_well_colors(self.config)
if wellfolder and os.path.isdir(wellfolder):
self.wellfolder = wellfolder
update_dates = get_update_dates(wellfolder)
self.well_update = update_dates["well_update_date"]
self.production_update = update_dates["production_last_date"]
(
self.drilled_well_df,
self.drilled_well_info,
self.interval_df,
) = load_all_wells(wellfolder, self.wellsuffix)
if self.drilled_well_df is not None:
self.well_base_layers.append(
make_new_well_layer(
self.selected_interval,
self.drilled_well_df,
self.drilled_well_info,
)
)
self.well_base_layers.append(
make_new_well_layer(
self.selected_interval,
self.drilled_well_df,
self.drilled_well_info,
colors=self.colors,
selection="reservoir_section",
label="Reservoir sections",
)
)
planned_wells_dir = [f.path for f in os.scandir(wellfolder) if f.is_dir()]
for folder in planned_wells_dir:
planned_well_df, planned_well_info, dummy_df = load_all_wells(
folder, self.wellsuffix
)
if planned_well_df is not None:
self.well_base_layers.append(
make_new_well_layer(
self.selected_interval,
planned_well_df,
planned_well_info,
self.colors,
selection="planned",
label=os.path.basename(folder),
)
)
elif wellfolder and not os.path.isdir(wellfolder):
print("ERROR: Folder", wellfolder, "doesn't exist. No wells loaded")
self.selector = SurfaceSelector(
app, self.metadata, self.intervals, self.map_defaults[0]
)
self.set_callbacks(app)