def test_30(self):
"""TestFILMRead.test_30(): PhysFilmCfgLISRead._retTracks()."""
# print()
# print(self._fc.keys())
# print(self._fc[Mnem.Mnem(b'1')]._retTracks(b'EEE ', b'----'))
self.assertEqual(4, len(self._fc[Mnem.Mnem(b'1')]._retTracks(b'EEE ', b'----')))
self.assertEqual(4, len(self._fc[Mnem.Mnem(b'1')]._retTracks(b'EEE ', b'--- ')))
def test_14(self):
"""TestFILMRead.test_14(): PhysFilmCfg.retFILMDest() using curve destination b'12'."""
self.assertEqual(
b'1\x00\x00\x00',
self._fc.retFILMDest(Mnem.Mnem(b'1'), Mnem.Mnem(b'12')).name)
self.assertEqual(
b'2\x00\x00\x00',
self._fc.retFILMDest(Mnem.Mnem(b'2'), Mnem.Mnem(b'12')).name)
def test_30(self):
"""TestMnem.test_30(): Hash tests."""
myM = Mnem.Mnem(b'AB ')
self.assertEqual(hash(myM.m), hash(myM))
self.assertEqual(hash(Mnem.Mnem(b'AB')), hash(myM))
myM = Mnem.Mnem(b'AB\x00\x00')
self.assertEqual(hash(myM.m), hash(myM))
self.assertEqual(hash(Mnem.Mnem(b'AB')), hash(myM))
def test_21(self):
"""TestFILMRead.test_21(): PhysFilmCfg.interpretTrac() using curve destination b'1' and b'2' mismatches, track b'T1 '."""
self.assertTrue(
self._fc.interpretTrac(Mnem.Mnem(b'2'), Mnem.Mnem(b'1'), b'T1 ')
is None)
self.assertTrue(
self._fc.interpretTrac(Mnem.Mnem(b'1'), Mnem.Mnem(b'2'), b'T1 ')
is None)
def test_11(self):
"""TestFILMRead.test_11(): PhysFilmCfg.retFILMDest() using curve destination b'BOTH'."""
# print('myPfc', self._fc.retFILMDest(b'1', b'BOTH'))
self.assertEqual(b'1\x00\x00\x00',
self._fc.retFILMDest(Mnem.Mnem(b'1'), b'BOTH').name)
# print('myPfc', self._fc.retFILMDest(b'1', b'BOTH'))
self.assertEqual(b'2\x00\x00\x00',
self._fc.retFILMDest(Mnem.Mnem(b'2'), b'BOTH').name)
def test_31(self):
"""TestMnem.test_31(): Hash map tests."""
myMap = {
Mnem.Mnem(b'AB'): b'AB',
Mnem.Mnem(b'ABCDEF'): b'ABCDEF',
}
# print(myMap)
self.assertTrue(Mnem.Mnem(b'AB') in myMap)
self.assertTrue(Mnem.Mnem(b'AB ') in myMap)
self.assertTrue(Mnem.Mnem(b'ABCD') in myMap)
def test_10(self):
"""TestMnem.test_10(): Equality tests."""
self.assertEqual(Mnem.Mnem(b'\x00\x00\x00\x00'), Mnem.Mnem(b''))
self.assertTrue(Mnem.Mnem(b'') == b'\x00\x00\x00\x00')
self.assertEqual(Mnem.Mnem(b'AB'), Mnem.Mnem(b'AB\x00'))
self.assertEqual(Mnem.Mnem(b'AB'), Mnem.Mnem(b'AB '))
self.assertEqual(Mnem.Mnem(b'AB '), Mnem.Mnem(b'AB '))
def test_32(self):
"""TestMnem.test_32(): Hash map tests interchanging bytes and Mnem objects."""
myMap = {
Mnem.Mnem(b'AB'): b'AB',
Mnem.Mnem(b'ABCDEF'): b'ABCDEF',
}
# print(myMap)
self.assertEqual(hash(b'AB\x00\x00'), hash(Mnem.Mnem(b'AB')))
self.assertTrue(b'AB\x00\x00' in myMap)
self.assertTrue(b'AB\x00\x00' in myMap)
self.assertTrue(b'ABCD' in myMap)
def test_20(self):
"""TestMnem.test_20(): Sorting tests."""
myL = [
Mnem.Mnem(b'B '),
Mnem.Mnem(b'AB'),
]
# print([M.m for M in sorted(myL)])
self.assertEqual([
'AB\x00\x00',
'B\x00\x00\x00',
], [str(M) for M in sorted(myL)])
def test_64(self):
"""TestMnem.test_64(): Padding of <4 chars when len_mnem is negative."""
myM = Mnem.Mnem(b'AB', len_mnem=-4)
self.assertEqual(b'AB\x00\x00', myM.m)
myM = Mnem.Mnem(b'AB\x00', len_mnem=-4)
self.assertEqual(b'AB\x00\x00', myM.m)
myM = Mnem.Mnem(b'AB\x00\x00', len_mnem=-4)
self.assertEqual(b'AB\x00\x00', myM.m)
myM = Mnem.Mnem(b'AB ', len_mnem=-4)
self.assertEqual(b'AB\x00\x00', myM.m)
myM = Mnem.Mnem(b'AB ', len_mnem=-4)
self.assertEqual(b'AB\x00\x00', myM.m)
# print(str(myM))
self.assertEqual('AB\x00\x00', str(myM))
def test_03(self):
"""TestMnem.test_03(): Padding of <4 chars."""
myM = Mnem.Mnem(b'AB')
self.assertEqual(b'AB\x00\x00', myM.m)
myM = Mnem.Mnem(b'AB\x00')
self.assertEqual(b'AB\x00\x00', myM.m)
myM = Mnem.Mnem(b'AB\x00\x00')
self.assertEqual(b'AB\x00\x00', myM.m)
myM = Mnem.Mnem(b'AB ')
self.assertEqual(b'AB\x00\x00', myM.m)
myM = Mnem.Mnem(b'AB ')
self.assertEqual(b'AB\x00\x00', myM.m)
# print(str(myM))
self.assertEqual('AB\x00\x00', str(myM))
def test_61(self):
"""TestMnem.test_61(): No padding of <4 chars when len_mnem is zero."""
myM = Mnem.Mnem(b'AB', len_mnem=0)
self.assertEqual(b'AB', myM.m)
myM = Mnem.Mnem(b'AB\x00', len_mnem=0)
self.assertEqual(b'AB\x00', myM.m)
myM = Mnem.Mnem(b'AB\x00\x00', len_mnem=0)
self.assertEqual(b'AB\x00\x00', myM.m)
myM = Mnem.Mnem(b'AB ', len_mnem=0)
self.assertEqual(b'AB\x00', myM.m)
myM = Mnem.Mnem(b'AB ', len_mnem=0)
self.assertEqual(b'AB\x00\x00', myM.m)
# print(str(myM))
self.assertEqual('AB\x00\x00', str(myM))
def test_06(self):
"""PresCfgXMLRead.test_06(): create a PRESCfgXML.PresCfgXMLRead() from "Resistivity_3Track_Logrithmic.xml" outputs for destination."""
myPcxr = PRESCfgXML.PresCfgXMLRead(
self._fcxr,
"Resistivity_3Track_Logrithmic.xml",
)
self.assertTrue(
myPcxr.usesOutpChannel("Resistivity_3Track_Logrithmic.xml",
Mnem.Mnem('BS')))
self.assertFalse(
myPcxr.usesOutpChannel("Resistivity_3Track_Logrithmic.xml",
Mnem.Mnem('NOTBS')))
self.assertFalse(
myPcxr.usesOutpChannel("Resistivity_3Track_Logrithmic.xml", 'BS'))
def test_20(self):
"""TestFILMRead.test_20(): PhysFilmCfg.interpretTrac() using curve destination b'1' and b'2', track b'T1 '."""
self.assertEqual((
Coord.Dim(value=0.0, units='in'),
Coord.Dim(value=2.4, units='in'),
0,
2,
), self._fc.interpretTrac(Mnem.Mnem(b'1'), Mnem.Mnem(b'1'), b'T1 '))
self.assertEqual((
Coord.Dim(value=0.0, units='in'),
Coord.Dim(value=2.4, units='in'),
0,
2,
), self._fc.interpretTrac(Mnem.Mnem(b'2'), Mnem.Mnem(b'2'), b'T1 '))
def _retUnitMap(self):
"""Returns a map of {Mnem.Mnem(MNEM) : Mnem.Mnem(UNITS), ...}
Warnings are produced for duplicates which are ignored. In principle
as a PRES table (for example) can only identify a channel by MNEM
then we assume here that the MNEM is unique."""
retMap = {}
# for aDsb in self._dfsr.dsbBlocks:
# m = Mnem.Mnem(aDsb.mnem)
# if m in retMap:
# logging.warning('LogPass._retUnitMap() ignoring duplicate mnemonic: {:s}'.format(str(m)))
# else:
# retMap[m] = Mnem.Mnem(aDsb.units)
for ch, aDsb in enumerate(self._dfsr.dsbBlocks):
# All sub-channels take the same units
u = aDsb.units
for sc in range(aDsb.subChannels):
m = aDsb.subChMnem(sc)
if m is None:
logging.warning(
'LogPass._retUnitMap() unknown mnemonic: for channel {:d}, sub-channel {:d}'
.format(ch, sc))
elif m in retMap:
logging.warning(
'LogPass._retUnitMap() ignoring duplicate mnemonic: {:s}'
.format(str(m)))
else:
retMap[Mnem.Mnem(m)] = u #Mnem.Mnem(u)
return retMap
def test_17(self):
"""TestFILMCfgXML.test_17(): "Resistivity_3Track_Logrithmic.xml" test retFILMDest()."""
myFcxr = FILMCfgXML.FilmCfgXMLRead()
self.assertEqual(29, len(myFcxr))
self.assertTrue(
myFcxr.retFILMDest("Resistivity_3Track_Logrithmic.xml",
Mnem.Mnem('BS')) is not None)
def test_21(self):
"""TestMnem.test_21(): Sorting tests, mixed bytes and Mnem objects."""
myL = [
b'B ',
Mnem.Mnem(b'AB'),
]
# print(sorted(myL))
# print([M.m for M in sorted(myL)])
self.assertEqual([
Mnem.Mnem(b'AB\x00\x00'),
Mnem.Mnem(b'B '),
], sorted(myL))
self.assertEqual([
'AB\x00\x00',
"b'B '",
], [str(M) for M in sorted(myL)])
def test_40(self):
"""TestMnem.test_40(): Iteration tests."""
myM = Mnem.Mnem(b'ABCDEF')
# print([v for v in myM])
# for aVal in myM:
# print(aVal)
self.assertEqual([65, 66, 67, 68], [v for v in myM])
def test_16(self):
"""TestFILMCfgXML.test_16(): "Resistivity_3Track_Logrithmic.xml" test retAllFILMDestS() fails."""
myFcxr = FILMCfgXML.FilmCfgXMLRead()
self.assertEqual(29, len(myFcxr))
# print(myFcxr._chOutpMnemFilmMap)
self.assertRaises(FILMCfgXML.ExceptionFILMCfgXMLReadLookUp,
myFcxr.retAllFILMDestS, Mnem.Mnem('NOTBS',
len_mnem=0))
def test_03(self):
"""PresCfgXMLRead.test_03(): create a PRESCfgXML.PresCfgXMLRead() from "Resistivity_3Track_Logrithmic.xml" correct curves."""
myPcxr = PRESCfgXML.PresCfgXMLRead(
self._fcxr,
"Resistivity_3Track_Logrithmic.xml",
)
self.assertEqual(
sorted([
Mnem.Mnem(v, len_mnem=0) for v in [
'PCAL',
'ILD',
'AHT60_8',
'MSFL',
'ILM',
'AHO90_9',
'ATR',
'AHF90_9',
'AHF30_7',
'A34H_ARC',
'AHT10_6',
'AHF60_8',
'RXO',
'AHT90_9',
'LLM',
'RLA1',
'AHT30_7',
'RLA3',
'RLA2',
'RLA5',
'RLA4',
'P34H_ARC',
'LLD',
'ROP5',
'A22H_ARC',
'AHO60_8',
'AHF20_5',
'BS_7',
'RLA0',
'AHO30_7',
'AHT20_5',
'P28H_ARC',
'SP_10',
'GR_9',
'AHO10_6',
'HiltCaliper',
'AHF10_6',
'TENS_6',
'SFL',
'P16H_ARC',
'AHO20_5',
'PSR',
'CALI_8',
]
]),
sorted(myPcxr.keys()),
)
self.assertTrue('BS_7' in myPcxr)
def setUp(self):
"""Set up Typical FILM record
Table record (type 34) type: FILM
MNEM GCOD GDEC DEST DSCA
-----------------------------
A LLLL 1111 PFA D200
"""
myByFilm = b'"\x00' \
+ b'IA\x04\x00TYPE FILM' \
+ b'\x00A\x04\x00MNEM A\x00\x00\x00' \
+ b'EA\x04\x00GCOD LLLL' \
+ b'EA\x04\x00GDEC 1111' \
+ b'EA\x04\x00DEST PFA ' \
+ b'EA\x04\x00DSCA D200'
myFi = self._retFileSinglePr(myByFilm)
self._fc = FILMCfg.FilmCfgLISRead(LogiRec.LrTableRead(myFi))
self.assertTrue(Mnem.Mnem(b'A ') in self._fc)
self.assertFalse(Mnem.Mnem(b'B ') in self._fc)
def test_18(self):
"""TestFILMCfgXML.test_18(): "Resistivity_3Track_Logrithmic.xml" test retFILMDest() fails."""
myFcxr = FILMCfgXML.FilmCfgXMLRead()
self.assertEqual(29, len(myFcxr))
self.assertRaises(
FILMCfgXML.ExceptionFILMCfgXMLReadLookUp,
myFcxr.retFILMDest,
"Resistivity_3Track_Logrithmic.xml",
Mnem.Mnem('NOTBS', len_mnem=0),
)
def test_05(self):
"""PresCfgXMLRead.test_05(): create a PRESCfgXML.PresCfgXMLRead() from "Resistivity_3Track_Logrithmic.xml" outputs for destination."""
myPcxr = PRESCfgXML.PresCfgXMLRead(
self._fcxr,
"Resistivity_3Track_Logrithmic.xml",
)
self.assertEqual(
1,
len(
myPcxr.outpCurveIDs("Resistivity_3Track_Logrithmic.xml",
Mnem.Mnem('BS'))),
)
self.assertEqual(
[
'BS_7',
],
myPcxr.outpCurveIDs("Resistivity_3Track_Logrithmic.xml",
Mnem.Mnem('BS')),
)
def test_10(self):
"""TestFILMCfgXML.test_10(): "Resistivity_3Track_Logrithmic.xml" tracks chOutpMnemInFilmId()."""
myFcxr = FILMCfgXML.FilmCfgXMLRead()
self.assertEqual(29, len(myFcxr))
myFilmID = 'Resistivity_3Track_Logrithmic.xml'
# print()
# pprint.pprint(myFcxr._chOutpMnemFilmMap)
self.assertTrue(myFilmID in myFcxr)
for aCuOutp in (Mnem.Mnem(c, len_mnem=-Mnem.LEN_MNEM) for c in (
'BS',
'ROP5',
'CALI',
'PCAL',
'HCAL',
'SP',
'GR',
'ATR',
'PSR',
'AHT10',
'AHT20',
'AHT30',
'AHT60',
'AHT90',
'AHO10',
'AHO20',
'AHO30',
'AHO60',
'AHO90',
'AHF10',
'AHF20',
'AHF30',
'AHF60',
'AHF90',
'RLA0',
'RLA1',
'RLA2',
'RLA3',
'RLA4',
'RLA5',
'SFL',
'ILM',
'ILD',
'MSFL',
'RXO',
'LLM',
'LLD',
'A22H',
'A34H',
'P16H_RT',
'P28H_RT',
'P34H_RT',
'TENS',
)):
self.assertTrue(myFcxr.chOutpMnemInFilmId(aCuOutp, myFilmID),
'aCuOutp="{!r:s}"'.format(aCuOutp))
def retAllFILMDestS(self, curveDestID):
"""Returns an unordered list of FILM destinations for a curve destination.
For example if curveDestID is b'BOTH' this might return [b'2 ', b'1 ']
"""
retList = []
if curveDestID in self._plotCfgMap:
retList = [curveDestID]
elif curveDestID == Mnem.Mnem(b'BOTH') and len(self._plotCfgMap) == 2:
retList = list(self._plotCfgMap.keys())
elif curveDestID == Mnem.Mnem(b'ALL'):
retList = list(self._plotCfgMap.keys())
else:
retList = []
# Decompose, for example for b'123 '
for aBy in curveDestID:
aMnem = Mnem.Mnem(bytes([aBy]))
if aMnem in self._plotCfgMap:
retList.append(aMnem)
return retList
def test_02(self):
"""TestFILMReadFourTrack.test_02(): interpretTrac()."""
myPfc = self._fc[Mnem.Mnem(b'A\x00\x00\x00')]
# print()
# print('FD', myPfc.interpretTrac(b'FD '))
# print('F1', myPfc.interpretTrac(b'F1 '))
self.assertEqual(
(
Coord.Dim(value=0.0, units='in'),
Coord.Dim(value=1.0, units='in'),
0, # Half track start
2, # Half track span
),
myPfc.interpretTrac(b'FD '),
)
self.assertEqual(
(
Coord.Dim(value=1.0, units='in'),
Coord.Dim(value=2.75, units='in'),
2, # Half track start
2, # Half track span
),
myPfc.interpretTrac(b'F1 '),
)
self.assertEqual(
(
Coord.Dim(value=2.75, units='in'),
Coord.Dim(value=4.5, units='in'),
4, # Half track start
2, # Half track span
),
myPfc.interpretTrac(b'F2 '),
)
self.assertEqual(
(
Coord.Dim(value=4.5, units='in'),
Coord.Dim(value=6.25, units='in'),
6, # Half track start
2, # Half track span
),
myPfc.interpretTrac(b'F3 '),
)
self.assertEqual(
(
Coord.Dim(value=6.25, units='in'),
Coord.Dim(value=8.0, units='in'),
8, # Half track start
2, # Half track span
),
myPfc.interpretTrac(b'F4 '),
)
def setUp(self):
"""Set up Typical FILM record
Table record (type 34) type: FILM
MNEM GCOD GDEC DEST DSCA
-----------------------------
1 E20 -4-- PF1 D200
2 E2E -4-- PF2 D200
"""
myByFilm = b'"\x00' \
+ b'IA\x04\x00TYPE FILM' \
+ b'\x00A\x04\x00MNEM 1\x00\x00\x00' \
+ b'EA\x04\x00GCOD E20 ' \
+ b'EA\x04\x00GDEC -4--' \
+ b'EA\x04\x00DEST PF1 ' \
+ b'EA\x04\x00DSCA D200' \
+ b'\x00A\x04\x00MNEM 2\x00\x00\x00' \
+ b'EA\x04\x00GCOD EEE ' \
+ b'EA\x04\x00GDEC ----' \
+ b'EA\x04\x00DEST PF2 ' \
+ b'EA\x04\x00DSCA D200'
myFi = self._retFileSinglePr(myByFilm)
self._fc = FILMCfg.FilmCfgLISRead(LogiRec.LrTableRead(myFi))
self.assertTrue(Mnem.Mnem(b'1 ') in self._fc)
self.assertFalse(Mnem.Mnem(b'10 ') in self._fc)
def _retChMap(self):
"""Returns a map of {Mnem.Mnem(MNEM) : (extCh, sub_ch), ...}
Warnings are produced for duplicates which are ignored. In principle
as a PRES table (for example) can only identify a channel by MNEM
then we assume here that the MNEM is unique."""
retMap = {}
for ch, b in enumerate(self._dfsr.dsbBlocks):
for sc in range(b.subChannels):
m = b.subChMnem(sc)
if m is None:
logging.warning('LogPass._retChMap() unknown mnemonic: for channel {:d}, sub-channel {:d}'.format(ch, sc))
elif m in retMap:
logging.warning('LogPass._retChMap() ignoring duplicate mnemonic: {:s}'.format(str(m)))
else:
retMap[Mnem.Mnem(m)] = (ch, sc)
return retMap
def test_01(self):
"""TestXMLMatches.test_01(): Which XML LgFormat files can plot LAS file, single TripleCombo XML file."""
myLasFile = LASRead.LASRead(
io.StringIO(TestPlotLASData.LAS_00_200_FEET_DOWN))
# Assume the formats/ directory relative to this module
d = os.path.join(os.path.dirname(__file__), 'formats')
filmMap = XMLMatches.fileCurveMap(myLasFile, d)
# Actual curves in this LAS file:
# ['BMIN', 'BMNO', 'CALI', 'DEPT', 'DPHI', 'DRHO', 'GR', 'ILD', 'ILM', 'NPHI', 'PEF', 'RHOB', 'SFLU', 'SP', 'TNPH']
#
# In XML file:
# ['AHT10', 'AHT20', 'AHT30', 'AHT60', 'AHT90', 'APDC', 'APLC', 'APSC', 'ATR', 'BS', 'C1', 'C2', 'CALI', 'CMFF', 'CMRP', 'DPHB', 'DPHI', 'DPHZ', 'DPOR_CDN', 'DSOZ', 'ENPH', 'GR', 'HCAL', 'HMIN', 'HMNO', 'ILD', 'ILM', 'LLD', 'LLM', 'MSFL', 'NPHI', 'NPOR', 'PCAL', 'PEFZ', 'PSR', 'RLA0', 'RLA1', 'RLA2', 'RLA3', 'RLA4', 'RLA5', 'ROP5', 'RSOZ', 'RXO', 'RXOZ', 'SFL', 'SNP', 'SP', 'SPHI', 'TENS', 'TNPB', 'TNPH', 'TNPH_CDN', 'TPHI']
#
# Alleged result:
# ['CALI', 'DPHI', 'GR ', 'ILD ', 'ILM ', 'NPHI', 'SP ', 'TNPH']
#
# Formated, sorted.
# -----------------
# Actual curves in this LAS file:
# ['BMIN', 'BMNO', 'CALI', 'DEPT', 'DPHI', 'DRHO', 'GR', 'ILD', 'ILM',
# 'NPHI', 'PEF', 'RHOB', 'SFLU', 'SP', 'TNPH']
#
# In XML file:
# ['AHT10', 'AHT20', 'AHT30', 'AHT60', 'AHT90', 'APDC', 'APLC', 'APSC',
# 'ATR', 'BS', 'C1', 'C2', 'CALI', 'CMFF', 'CMRP', 'DPHB', 'DPHI', 'DPHZ',
# 'DPOR_CDN', 'DSOZ', 'ENPH', 'GR', 'HCAL', 'HMIN', 'HMNO', 'ILD', 'ILM',
# 'LLD', 'LLM', 'MSFL', 'NPHI', 'NPOR', 'PCAL', 'PEFZ', 'PSR', 'RLA0',
# 'RLA1', 'RLA2', 'RLA3', 'RLA4', 'RLA5', 'ROP5', 'RSOZ', 'RXO', 'RXOZ',
# 'SFL', 'SNP', 'SP', 'SPHI', 'TENS', 'TNPB', 'TNPH', 'TNPH_CDN', 'TPHI']
#
# Result, note SFL is achieved by substitution of an alternate:
# ['CALI', 'DPHI', 'GR ', 'ILD ', 'ILM ', 'NPHI', 'SFL ', 'SP ', 'TNPH']
print()
pprint.pprint(filmMap)
self.assertEqual(1, len(filmMap))
self.assertTrue('Triple_Combo' in filmMap)
# pprint.pprint(sorted([m.pStr() for m in filmMap['Triple_Combo']]))
self.assertEqual(
[
Mnem.Mnem(o) for o in [
'CALI', 'DPHI', 'GR ', 'ILD ', 'ILM ', 'NPHI', 'SFL ',
'SP ', 'TNPH'
]
],
sorted(filmMap['Triple_Combo']),
)
def __init__(self, theRow):
"""Reads a LogiRec.TableRow object and populates a CurveCfg.
Example::
MNEM GCOD GDEC DEST DSCA
-----------------------------
1 E20 -4-- PF1 D200
"""
myName = Mnem.Mnem(theRow[b'MNEM'].value)
myTrackS = self._retTracks(theRow[b'GCOD'].value,
theRow[b'GDEC'].value)
myDest = theRow[b'DEST'].value
myDscaleKey = theRow[b'DSCA'].value
super().__init__(theName=myName,
theTracks=myTrackS,
theDest=myDest,
theX=self.DSCA_MAP[myDscaleKey])
