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])