def readData(self, dataFile):
logger.debug(">>readData() Reading file: " + str(dataFile))
dataIO = DataIO()
fullPath = ISOCALCSOUTPUTPATH + dataFile
dataDf = dataIO.readCSV(fullPath)
assert isinstance(dataDf, pd.DataFrame) and len(dataDf.index) > 0
return dataDf
def test_topsReader(self):
dataIO = DataIO()
tops = TopsModel()
topsDf = dataIO.readCSVZeroIndex(self.topsPath)
logger.debug("--() topsDf length: " + str(len(topsDf.index)))
tops.topsList = dataIO.topsReader(topsDf)
self.assertEquals(34, len(tops.topsList))
self.assertEquals("ANGL", tops.topsList[0])
def test_getData(self):
logger.debug(">test_getData()")
dataIO = DataIO()
markersPD = dataIO.readCSVZeroIndex(self.markersPath)
markerData = dataIO.getData(markersPD)
angelSurfs = markerData.get("ANGEL_1")
self.assertEqual("DELA", angelSurfs[0].surfaceName)
self.assertEqual("ANGEL_1", angelSurfs[0].well)
#self.assertEqual("marker", angelSurfs[0].surfaceType)
self.assertEqual(79.9, angelSurfs[0].z)
self.assertEqual(146.5, angelSurfs[0].twtAuto)
def calcDifferences(self):
dataIO = DataIO()
self.wellTopDf = dataIO.readCSVZeroIndex(self.wellTopPath)
wellTopDict = dataIO.getData(self.wellTopDf, self.negativeZ)
self.gridDf = dataIO.readCSVZeroIndex(self.gridPath)
gridDict = dataIO.getData(self.gridDf, self.negativeZ)
deltaList = []
for gridList in gridDict.values():
for gridModel in gridList:
for topList in wellTopDict.values():
for topModel in topList:
if gridModel.well == topModel.well:
if gridModel.surfaceName == topModel.surfaceName:
deltaModel = DeltaModel()
deltaModel.well = gridModel.well
deltaModel.surfaceName = gridModel.surfaceName
deltaModel.gridTwt = gridModel.twtAuto
deltaModel.wellTwt = topModel.twtAuto
deltaModel.gridZ = gridModel.z
deltaModel.wellZ = topModel.z
deltaModel.deltaTWT = gridModel.twtAuto - topModel.twtAuto
deltaModel.deltaZ = ((-1) * gridModel.z) - (
(-1) * topModel.z)
deltaList.append(deltaModel.getDataList())
if len(deltaList) > 0:
deltaList.insert(0, DeltaModel.HEADERS)
dataIO.writeIsoModels(deltaList, DELTACALCSPATH, "DeltaCalcs",
False)
else:
logger.debug("No matching surfaces found")
def runCalcs(self):
dataIO = DataIO()
self.wellDataDf = dataIO.readCSVZeroIndex(self.attributeDataPath)
markerModels = dataIO.getAttributeData(self.wellDataDf,
self.attribute,
zIsNegative=self.negativeZ,
twtIsNegative=self.negativeTWT)
functionsDf = dataIO.readCSVZeroIndex(self.zoneDataPath)
self.functionList = dataIO.functionReader(functionsDf)
calculations = Calculations()
allModels = []
isoFunctionName = ""
modelList = []
for function in self.functionList:
isoModels = calculations.doIsoCalculations(function, markerModels)
if len(isoModels) > 0:
isoFunctionName = isoModels[0].calcFunction
for item in isoModels:
modelList.append(item.getDataList())
if len(modelList) == 0:
logger.info(
"No data to output. Check input file is formatted correctly")
else:
modelList.insert(0, IsoModel.HEADERS)
dataIO.writeIsoModels(modelList, ATTRIBCALCSOUTPUTPATH,
'AttributeData', False)
def test_calcDiffTWT(self):
dataIO = DataIO()
markersPD = dataIO.readCSVZeroIndex(self.isoCalcsMarkersPath)
markerData = dataIO.getData(markersPD)
well = "ADAMS_1"
surface = SurfaceModel()
topSurface = surface.getSurface(markerData[well], "BARE")
baseSurface = surface.getSurface(markerData[well], "TREL")
npt.assert_allclose(430.09, topSurface.twtAuto, rtol=1e-5)
npt.assert_allclose(803.45, baseSurface.twtAuto, rtol=1e-5)
calculations = Calculations()
deltaVal = calculations.calcIsochron(baseSurface, topSurface)
calcFunction = calculations.getZoneText(baseSurface, topSurface)
logger.debug("--test_calcDiffTWT() fn:{0}".format(calcFunction))
self.assertEqual("BARE-TREL", calcFunction)
npt.assert_allclose(373.36, deltaVal, rtol=1e-5)
def test_computeSingleDiff(self):
dataIO = DataIO()
markersPD = dataIO.readCSVZeroIndex(self.isoCalcsMarkersPath)
markerData = dataIO.getData(markersPD)
calculations = Calculations()
resultObject = IsoModel()
resultObject.calcDomain = "TWT"
domain = "TWT"
well = "ADAMS_1"
surface = SurfaceModel()
topSurface = surface.getSurface(markerData[well], "BARE")
baseSurface = surface.getSurface(markerData[well], "MAND")
self.assertEqual("BARE", topSurface.surfaceName)
self.assertEqual("MAND", baseSurface.surfaceName)
resultObject = calculations.computeSingleDiff(well, baseSurface, topSurface)
logger.debug("fn:{0}".format(resultObject.calcFunction))
self.assertEqual("BARE-MAND", resultObject.calcFunction)
npt.assert_allclose(880.75, resultObject.isochron, rtol=1e-5)
def test_doIsoCalculations(self):
dataIO = DataIO()
calculations = Calculations()
resultObject = IsoModel()
resultObject.calcDomain = "TWT"
function = Function()
function.top = "BARE"
function.base = "MAND"
baseSurface1 = SurfaceModel()
topSurface1 = SurfaceModel()
well = "ADAMS_1"
baseSurface1.well = well
baseSurface1.surfaceName = "MAND"
baseSurface1.z = 2000
baseSurface1.twtAuto = 1000
topSurface1.well = well
topSurface1.surfaceName = "BARE"
topSurface1.z = 1500
topSurface1.twtAuto = 800
baseSurface2 = SurfaceModel()
topSurface2 = SurfaceModel()
well = "ADAMS_2"
baseSurface2.well = well
baseSurface2.surfaceName = "MAND"
baseSurface2.z = 2000
baseSurface2.twtAuto = 1000
topSurface2.well = well
topSurface2.surfaceName = "BARE"
topSurface2.z = 1500
topSurface2.twtAuto = 800
models = []
models.append(topSurface1)
models.append(baseSurface1)
models2 = []
models2.append(topSurface2)
models2.append(baseSurface2)
wellSurfaceData = {}
wellSurfaceData['ADAMS_1'] = models
wellSurfaceData['ADAMS_2'] = models2
isoModels = calculations.doIsoCalculations(function, wellSurfaceData)
self.assertEquals(2, len(isoModels))
self.assertEquals("0, ADAMS_2, BARE-MAND, 200, 500, 5000.0",isoModels[0].__str__() )
def test_writeCSV(self):
logger.debug(">>test_writeCSV")
dataIO = DataIO()
isoModel = IsoModel()
results = []
for i in range(10):
isoModel.row = i
isoModel.well = "Well_" + str(i)
isoModel.calcFunction = "A-B"
isoModel.isochron = 234.55 + i
isoModel.isopach = 10 + i
isoModel.vint = 1000 + 10 * i
results.append(isoModel.getDataList())
self.assertEquals(10, len(results))
testFile = TESTDATAPATH + "20150507_test_writeCSV.csv"
results.insert(0, IsoModel.HEADERS)
dataIO.writeCSV(results, testFile, appendFlag=False)
#Read data back in and check it
readBackDf = dataIO.readCSV(testFile)
assert isinstance(readBackDf,
pd.DataFrame) and len(readBackDf.index) > 0
isochrons = []
isopachs = []
vints = []
for i, row in readBackDf.iterrows():
isochron = row['Isochron']
isopach = row['Isopach']
vint = row['Vint']
isochrons.append(isochron)
isopachs.append(isopach)
vints.append(vint)
npt.assert_allclose(234.55, float(isochrons[0]), rtol=1e-5)
npt.assert_allclose(19.0, float(isopachs[9]), rtol=1e-5)
npt.assert_allclose(1050.0, float(vints[5]), rtol=1e-5)
def test_writeIsoModels(self):
dataIO = DataIO()
markersDf = dataIO.readCSVZeroIndex(self.markersPath)
markersData = dataIO.getData(markersDf)
topsDf = dataIO.readCSVZeroIndex(self.topsPath)
topsList = ["DUMMY", "DELA", "BARE"]
wellSurfaces = dataIO.checkMissingSurfaces(markersData, topsList)
surfacesList = wellSurfaces["ANGEL_1"]
self.assertEquals("DUMMY", surfacesList[0])
def findMissingMarkers(self):
if self.markersPath == "":
logger.error("Markers file has not been specified")
return
elif self.topsPath == "":
logger.error("TopsModel file has not been specified")
return
dataIO = DataIO()
markersDf = dataIO.readCSVZeroIndex(self.markersPath)
if len(markersDf.index)==0:
logger.error("Markers data is empty")
return
markersData = dataIO.getData(markersDf)
topsDf = dataIO.readCSVZeroIndex(self.topsPath)
if len(topsDf.index)==0:
logger.error("TopsModel data is empty")
return
topsList = dataIO.topsReader(topsDf)
wellSurfaces = dataIO.checkMissingSurfaces(markersData, topsList)
dataIO.writeDictToCSV(wellSurfaces, MISSINGCALCSPATH+"MissingSurfaces_Output.csv")
def runCalcs(self):
dataIO = DataIO()
self.wellDataDf = dataIO.readCSVZeroIndex(self.wellDataPath)
markerModels = dataIO.getData(self.wellDataDf, self.negativeZ)
functionsDf = dataIO.readCSVZeroIndex(self.isoCalcFunctions)
self.functionList = dataIO.functionReader(functionsDf)
calculations = Calculations()
allModels = []
isoFunctionName = ""
for function in self.functionList:
modelList = []
isoModels = calculations.doIsoCalculations(function, markerModels)
if len(isoModels) > 0:
isoFunctionName = isoModels[0].calcFunction
for item in isoModels:
modelList.append(item.getDataList())
modelList.insert(0, IsoModel.HEADERS)
dataIO.writeIsoModels(modelList, ISOCALCSOUTPUTPATH,
isoFunctionName, False)
def checkFiles(self):
dataIO = DataIO()
exists1 = dataIO.checkFileExists(self.wellDataPath)
exists2 = dataIO.checkFileExists(self.isoCalcFunctions)
if exists1 and exists2:
return True