def test_log_handling(self):
# type: () -> None
"""
Tests the log handling functionality
:return: Nothing
:raises AssertionError: Raises AssertionError if a test fails
"""
log_values = (
(
(10, 4, "", ""),
(15, "45.4", "name 1", "Comment 1"),
(16, 34.3, "", ""),
(17, 234, "", "Comment 2"),
(5, "34.4", "", "Comment 3")
),
(
(34.3, 4, "", ""),
(13, 234, "", "Comment 2"),
(34, "34.4", "", "Comment 3")
)
)
well = Well.load_by_wellname_from_db("Well_2", self.session)
for i in range(len(log_values)):
log = WellLog("log {}".format(i), "unit name", self.session, "", "")
log.save_to_db()
well.add_log(log)
for value in log_values[i]:
log.insert_log_value(WellLogValue(value[0], value[1], self.session, value[2], value[3]))
del log
del well
well = Well.load_by_wellname_from_db("Well_2", self.session)
self.assertEqual(2, len(well.logs))
self.assertEqual(5, len(well.logs[0].log_values))
self.assertEqual("log 0", well.logs[0].property_name)
self.assertEqual(3, len(well.logs[1].log_values))
self.assertEqual("log 1", well.logs[1].property_name)
well.delete_log(well.logs[1])
del well
well = Well.load_by_wellname_from_db("Well_2", self.session)
self.assertEqual(1, len(well.logs))
self.assertEqual(5, len(well.logs[0].log_values))
self.assertEqual("log 0", well.logs[0].property_name)
logs = WellLog.load_all_from_db(self.session)
self.assertEqual(1, len(logs))
def test_get_marker_by_depth(self):
# type: () -> None
"""
Test the Well.get_marker_by_depth function
:return: Nothing
:raises AssertionError: Raises AssertionError if a test fails
"""
well = Well.load_by_wellname_from_db("Well_1", self.session)
self.assertEqual(well.get_marker_by_depth(16).horizon.statigraphic_name, "sm")
self.assertRaises(ValueError, well.get_marker_by_depth, 100)
def test_loading(self):
# type: () -> None
"""
Test the different types of loading of lines from the db.
Part 1: load all wells from the database
Part 2: load well by name
Part 3: load wells in given extent
Part 4: load wells with minimal depth
:return: Nothing
:raises AssertionError: Raises AssertionError if a test fails
"""
# Part 1: load all wells from the database
wells = Well.load_all_from_db(self.session)
self.assertEqual(len(wells), 3)
self.assertEqual(wells[0].well_name, "Well_1")
self.assertEqual(wells[1].well_name, "Well_2")
self.assertEqual(wells[2].well_name, "Well_3")
self.assertEqual(len(wells[1].marker), 4)
self.assertTrue(wells[1].marker[0].horizon == wells[1].marker[3].horizon)
del wells
# Part 2: load well by name
well = Well.load_by_wellname_from_db("Well_2", self.session)
self.assertEqual(well.well_name, "Well_2")
self.assertEqual(well.short_name, "W2")
self.assertEqual(well.depth, 341)
self.assertEqual(len(well.marker), 4)
self.assertEqual(well.marker[1].horizon.statigraphic_name, "mm")
self.assertEqual(well.marker[1].depth, 120)
del well
# Part 3: load wells in given extent
# extent x: 500 - 1,300
# extent y: 0 - 2,400
# result: "Well_1" and "Well_2"
wells = Well.load_in_extent_from_db(self.session, 500, 1300, 0, 2400)
self.assertEqual(len(wells), 2)
self.assertEqual(wells[0].well_name, "Well_1")
self.assertEqual(wells[1].well_name, "Well_2")
self.assertEqual(len(wells[0].marker), 5)
self.assertEqual(len(wells[1].marker), 4)
del wells
# Part 4: load wells with minimal depth
wells = Well.load_deeper_than_value_from_db(self.session, 395.23)
self.assertEqual(len(wells), 2)
self.assertEqual(wells[0].well_name, "Well_1")
self.assertEqual(wells[1].well_name, "Well_3")
self.assertTrue(wells[0].depth >= 395.23)
self.assertTrue(wells[1].depth >= 395.23)
del wells
def test_delete_marker(self):
# type: () -> None
"""
Test the Well.get_marker_by_depth function
:return: Nothing
:raises AssertionError: Raises AssertionError if a test fails
"""
well = Well.load_by_wellname_from_db("Well_1", self.session)
marker = well.get_marker_by_depth(16)
self.assertEqual(marker.horizon.statigraphic_name, "sm")
self.assertRaises(ValueError, well.get_marker_by_depth, 100)
well.delete_marker(marker)
well.save_to_db()
self.assertEqual(len(well.marker), 4)
del well
well = Well.load_by_wellname_from_db("Well_1", self.session)
self.assertEqual(len(well.marker), 4)
new_marker = WellMarker(23423, StratigraphicObject.init_stratigraphy(self.session, "so"), self.session,
"Nothing")
self.assertRaises(ValueError, well.delete_marker, new_marker)
self.assertRaises(TypeError, well.delete_marker, "test")
def run(self):
"""
Save well logs to the database
:return: Nothing, emits Qt Signals
"""
self._mutex.lock()
service = DatabaseService.get_instance()
service.close_session()
service.connect()
session = service.get_session()
failed_imports = 0
try:
onekey = self._data[next(iter(self._data.keys()))]["values"]
# import json
# self._logger.info(json.dumps(onekey, indent=2))
count = len(onekey)
well_name_col = self._selection["well_name"]
depth_col = self._selection["depth"]
reference = ImportService.get_instance().get_crs()
if reference is None:
reference = ""
else:
reference = reference.toWkt()
self._logger.debug("Saving with reference system\n{}".format(reference))
for i in range(count):
self.update_progress.emit(100 * i / count)
try:
well_name = self._data[well_name_col]["values"][i]
except ValueError:
self._logger.warn("No well_name specified for current data set at line {}".format(i))
failed_imports += 1
continue
if (well_name is None) or (well_name == ""):
self._logger.warn("Unknown well name found: [{}]".format(well_name))
failed_imports += 1
continue
try:
well: Well = Well.load_by_wellname_from_db(well_name, session)
if well is None:
self._logger.warn("No well with name [{}] found...".format(well_name))
failed_imports += 1
continue
well.reference_system = reference
# add / update properties
for item in self._properties:
self._logger.debug("Property: {}".format(item))
if well.has_log(item.name):
log = well.get_log(item.name)
else:
log = WellLog(property_name = item.name, property_unit = item.unit, session=session)
well.add_log(log)
depth = self._data[depth_col]["values"][i]
value = self._data[item.name]["values"][i]
try:
log_value: WellLogValue = log.get_value_by_depth(depth)
except ValueError:
log_value = WellLogValue(depth, value, session=session)
log_value.value = value
log.insert_log_value(log_value)
self._logger.debug("well: {}".format(well))
well.save_to_db()
except DatabaseRequestException:
self._logger.warn("Cannot find well with name [{}]. Skipping log import".format(well_name))
failed_imports += 1
if self._cancel:
self._logger.debug("Import canceled")
self.import_failed.emit(self._message)
break
if not self._cancel:
if failed_imports > 0:
self.import_finished_with_warnings.emit("Could not import {} properties.".format(failed_imports))
self.update_progress.emit(100)
self.import_finished.emit()
except Exception as e:
msg = str(ExceptionHandler(e))
self.import_failed.emit(msg)
self._logger.error("Error", msg, to_messagebar=True)
finally:
service.close_session()
self._mutex.unlock()
self.quit()
def run(self) -> bool:
"""
Save the Well Object(s) to the database
:return: True if function executed successfully, else False
"""
self._mutex.lock()
service = DatabaseService.get_instance()
service.close_session()
service.connect()
session = DatabaseService.get_instance().get_session()
try:
onekey = self._data[next(iter(self._data.keys()))]["values"]
count = len(onekey)
name = self._selection["name"]
short_name = self._selection["short_name"]
east = self._selection["easting"]
north = self._selection["northing"]
alt = self._selection["altitude"]
total_depth = self._selection["total_depth"]
strat = self._selection["strat"]
depth_to = self._selection["depth_to"]
comment = self._selection["comment"]
reference = ImportService.get_instance().get_crs()
if reference is None:
reference = ""
else:
reference = reference.toWkt()
self._logger.debug("Saving with reference system\n{}".format(reference))
wells = dict()
maximum = count
for i in range(count):
if (self._data[east]["values"][i] == "") and (self._data[north]["values"][i] == ""):
continue
na = self._data[name]["values"][i]
sn = "" if short_name == "" else self._data[short_name]["values"][i]
e = float(self._data[east]["values"][i])
n = float(self._data[north]["values"][i])
kb = None if alt == "" else float(self._data[alt]["values"][i])
td = -1 if total_depth == "" else float(self._data[total_depth]["values"][i])
s = "" if strat == "" else self._data[strat]["values"][i]
dt = -1 if depth_to == "" else float(self._data[depth_to]["values"][i])
c = "" if comment == "" else self._data[comment]["values"][i]
strat_obj = StratigraphicObject.init_stratigraphy(session, s, -1)
strat_obj.save_to_db()
marker = WellMarker(dt, strat_obj, session=session, comment=c)
# marker.save_to_db()
# point = GeoPoint(None, False if (h is None) else True, reference,
# e, n, 0 if (h is None) else h, session, sn, c)
if na in wells:
wells[na]["marker"].append(marker)
else:
wells[na] = {
"short_name": sn,
"easting": e,
"northing": n,
"altitude": kb,
"total_depth": td,
"marker": [marker]
}
maximum += 1
if self._cancel:
self._logger.debug("Import canceled")
self.import_failed.emit(self._message)
break
self.update_progress.emit(100 * i / maximum)
i = count
if not self._cancel:
for well_name in wells:
i += 1
well = wells[well_name]
new_well = Well.load_by_wellname_from_db(well_name, session)
if new_well is not None:
try:
self._logger.debug("Updating existing well: {}".format(new_well))
for marker in new_well.marker:
WellMarker.delete_from_db(marker, session)
new_well.save_to_db()
new_well.marker = well["marker"]
new_well.short_name = well["short_name"]
new_well.easting = well["easting"]
new_well.northing = well["northing"]
new_well.depth = well["total_depth"]
except WellMarkerDepthException as e:
self._logger.error("WellMarkerDepthException", "{}\n{}".format(new_well, str(e)))
return False
else:
self._logger.debug("Creating new well with name [{}]".format(well_name))
new_well = Well(well_name, well["short_name"], well["total_depth"], reference_system=reference,
easting=well["easting"], northing=well["northing"], altitude=well["altitude"],
session=session)
new_well.marker = well["marker"]
new_well.save_to_db()
self._logger.debug("Saved well:\n{}".format(new_well))
self.update_progress.emit(100 * i / maximum)
if self._cancel:
self._logger.debug("Import canceled")
self.import_failed.emit(self._message)
break
if not self._cancel:
self.update_progress.emit(100)
self._logger.debug("Lines successfully imported")
self.import_finished.emit()
except Exception as e:
msg = str(ExceptionHandler(e))
self.import_failed.emit(msg)
self._logger.error("Error", msg)
finally:
service.close_session()
self._mutex.unlock()
self.quit()