def __init__(self, theDfsr, theFileId, xAxisIndex=0):
"""Constructed with an EFLR i.e. a DFSR
theDfsr - The DFSR.
theFileId - The ID of the file, this will be checked against any File object passed to me.
xAxisIndex - The index of the DSB block that describes the X axis, if indirect X this is ignored.
"""
# Check input. We take a strict view here of what a LogPass can support
# The DFSR must have at least one DSB even if indirect X otherwise
# a LogPass does not make a lot of sense when there are zero channels.
if len(theDfsr.dsbBlocks) == 0:
raise ExceptionLogPassCtor('LogPass.__init__(): xAxisIndex no channels to process')
if xAxisIndex < 0 or xAxisIndex >= len(theDfsr.dsbBlocks):
raise ExceptionLogPassCtor('LogPass.__init__(): xAxisIndex {:s} out of range when number of DSB blocks={:d}'.format(str(xAxisIndex), len(theDfsr.dsbBlocks)))
self._dfsr = theDfsr
self._fileId = theFileId
self._plan = Type01Plan.FrameSetPlan(self._dfsr)
self._xAxisIndex = xAxisIndex
# This is a map of {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.
self._chMap = self._retChMap()
# A map of {Mnem.Mnem(MNEM) : Mnem.Mnem(UNITS), ...} from the DFSR
self._unitMap = self._retUnitMap()
# Populated by setFrameSet() when the time comes
self._frameSet = None
# Set up RLE object
if self.isIndirectX:
self._rle = Rle.RLEType01(self._dfsr.ebs.depthUnits)
else:
assert(self._xAxisIndex >= 0 and self._xAxisIndex < len(self._dfsr.dsbBlocks))
self._rle = Rle.RLEType01(self._dfsr.dsbBlocks[self._xAxisIndex].units)
def setUp(self):
"""Set up."""
self._dfsr = MockDFSR(
MockEntryBlockSet(1, 73),
[MockDsb(4), MockDsb(8), MockDsb(2), MockDsb(16), MockDsb(2)],
)
self._tp = Type01Plan.FrameSetPlan(self._dfsr)
# 4+8+2+16+2=32
self.assertEqual(self._tp.frameSize, 4+8+2+16+2)
def test_07(self):
"""TestType01Plan.test_07(): Multiple channels, __str__()."""
myDfsr = MockDFSR(
MockEntryBlockSet(1, 73),
[MockDsb(4), MockDsb(8), MockDsb(2), MockDsb(16), MockDsb(2)],
)
myTp = Type01Plan.FrameSetPlan(myDfsr)
print()
print(str(myTp))
def test_11(self):
"""TestType01Plan.test_11(): _checkChIdx() two channels."""
myDfsr = MockDFSR(
MockEntryBlockSet(1, 73),
[MockDsb(4), MockDsb(4)],
)
myTp = Type01Plan.FrameSetPlan(myDfsr)
self.assertEqual(myTp._checkChIdx([1, 0]), [0,1])
self.assertRaises(Type01Plan.ExceptionFrameSetPlanNegLen, myTp._checkChIdx, [-1, 1])
self.assertRaises(Type01Plan.ExceptionFrameSetPlanOverrun, myTp._checkChIdx, [1, 2])
def test_10(self):
"""TestType01Plan.test_10(): _checkChIdx()."""
myDfsr = MockDFSR(
MockEntryBlockSet(1, 73),
[MockDsb(4), MockDsb(8), MockDsb(2), MockDsb(16), MockDsb(2)],
)
myTp = Type01Plan.FrameSetPlan(myDfsr)
self.assertEqual(myTp._checkChIdx([3, 1, 2]), [1,2,3])
self.assertRaises(Type01Plan.ExceptionFrameSetPlanNegLen, myTp._checkChIdx, [-1, 2])
self.assertRaises(Type01Plan.ExceptionFrameSetPlanOverrun, myTp._checkChIdx, [1, 7])
def test_01(self):
"""TestType01Plan.test_01(): Single channel, indirect X axis."""
myDfsr = MockDFSR(MockEntryBlockSet(1, 68), [MockDsb(4), ])
myTp = Type01Plan.FrameSetPlan(myDfsr)
# Test numFrames()
self.assertEqual(myTp.numFrames(8), 1)
self.assertRaises(Type01Plan.ExceptionFrameSetPlanNegLen, myTp.numFrames, -1024)
self.assertRaises(Type01Plan.ExceptionFrameSetPlan, myTp.numFrames, 1023)
# Test chOffset
self.assertEqual(myTp.chOffset(0, 0), 4)
self.assertEqual(myTp.chOffset(ch=0, frame=1), 8)
self.assertEqual(myTp.chOffset(ch=0, frame=2), 12)
self.assertRaises(IndexError, myTp.chOffset, 0, 1)
self.assertRaises(Type01Plan.ExceptionFrameSetPlanNegLen, myTp.chOffset, 0, -1)
def test_00(self):
"""TestType01Plan_Perf.test_00(): Construction, 8192 channels."""
myDfsr = MockDFSR(
MockEntryBlockSet(0, 73),
[MockDsb(4) for i in range(8192)],
)
start = time.perf_counter()
myTp = Type01Plan.FrameSetPlan(myDfsr)
execTime = time.perf_counter() - start
self.assertEqual(myTp.frameSize, 4*8192)
sys.stderr.write(' Time: {:.3f} (s)'.format(execTime))
#sys.stderr.write(' Rate: {:.3f} (MB/s)'.format(myReadSize /(1024*1024*execTime)))
sys.stderr.write(' Cost (on frame size): {:.3f} (ms/MB)'.format((execTime*1024)/(myTp.frameSize/(1024*1024))))
sys.stderr.write(' ')
def test_06(self):
"""TestType01Plan.test_06(): Multiple channel, genOffsets() failures."""
myDfsr = MockDFSR(
MockEntryBlockSet(1, 73),
[MockDsb(4), MockDsb(8), MockDsb(2), MockDsb(16), MockDsb(2)],
)
myTp = Type01Plan.FrameSetPlan(myDfsr)
myG = myTp.genOffsets([-1, 1, 2])
#print('There')
try:
next(myG)
self.fail('Type01Plan.ExceptionFrameSetPlanNegLen not raised.')
except Type01Plan.ExceptionFrameSetPlanNegLen:
pass
myG.close()
def _timeEvents(self, theFrameSlice, theChRange):
"""Time genEvents() from frame slice and channel range."""
myDfsr = MockDFSR(
MockEntryBlockSet(0, 73),
[MockDsb(4) for i in range(8192)],
)
myTp = Type01Plan.FrameSetPlan(myDfsr)
self.assertEqual(myTp.frameSize, 4*8192)
myReadSize = 0
numEvents = 0
start = time.perf_counter()
for e in myTp.genEvents(theFrameSlice, theChRange):
if e[0] == Type01Plan.EVENT_READ:
myReadSize += e[1]
numEvents += 1
self.writeCostToStderr(start, myReadSize, 'Events', numEvents)
def test_03(self):
"""TestType01Plan.test_03(): Multiple channel, indirect X axis."""
myDfsr = MockDFSR(
MockEntryBlockSet(1, 73),
[MockDsb(4),
MockDsb(8),
MockDsb(2),
MockDsb(16),
MockDsb(2)],
)
myTp = Type01Plan.FrameSetPlan(myDfsr)
# 32
self.assertEqual(myTp.frameSize, 4 + 8 + 2 + 16 + 2)
# Test numFrames()
self.assertEqual(myTp.numFrames(1028), 32)
self.assertRaises(Type01Plan.ExceptionFrameSetPlanNegLen,
myTp.numFrames, -1024)
self.assertRaises(Type01Plan.ExceptionFrameSetPlan, myTp.numFrames,
1027)
# Test chOffset
self.assertEqual(myTp.chOffset(ch=0, frame=0), 4)
self.assertEqual(myTp.chOffset(ch=0, frame=1), 4 + 32 * 1)
self.assertEqual(myTp.chOffset(ch=0, frame=2), 4 + 32 * 2)
self.assertEqual(myTp.chOffset(ch=1, frame=0), 8)
self.assertEqual(myTp.chOffset(ch=1, frame=1), 8 + 32 * 1)
self.assertEqual(myTp.chOffset(ch=1, frame=2), 8 + 32 * 2)
self.assertEqual(myTp.chOffset(ch=2, frame=0), 16)
self.assertEqual(myTp.chOffset(ch=2, frame=1), 16 + 32 * 1)
self.assertEqual(myTp.chOffset(ch=2, frame=2), 16 + 32 * 2)
self.assertEqual(myTp.chOffset(ch=3, frame=0), 18)
self.assertEqual(myTp.chOffset(ch=3, frame=1), 18 + 32 * 1)
self.assertEqual(myTp.chOffset(ch=3, frame=2), 18 + 32 * 2)
self.assertEqual(myTp.chOffset(ch=4, frame=0), 34)
self.assertEqual(myTp.chOffset(ch=4, frame=1), 34 + 32 * 1)
self.assertEqual(myTp.chOffset(ch=4, frame=2), 34 + 32 * 2)
self.assertRaises(IndexError, myTp.chOffset, 0, 5)
self.assertRaises(Type01Plan.ExceptionFrameSetPlanNegLen,
myTp.chOffset, 0, -1)
# skipToEndOfFrame()
self.assertEqual(myTp.skipToEndOfFrame(ch=0), 28)
self.assertEqual(myTp.skipToEndOfFrame(ch=1), 20)
self.assertEqual(myTp.skipToEndOfFrame(ch=2), 18)
self.assertEqual(myTp.skipToEndOfFrame(ch=3), 2)
self.assertEqual(myTp.skipToEndOfFrame(ch=4), 0)
self.assertRaises(IndexError, myTp.skipToEndOfFrame, 5)
self.assertRaises(Type01Plan.ExceptionFrameSetPlanNegLen,
myTp.skipToEndOfFrame, -1)
def test_05(self):
"""TestType01Plan.test_05(): Multiple channel, genOffsets() unsorted."""
myDfsr = MockDFSR(
MockEntryBlockSet(1, 73),
[MockDsb(4), MockDsb(8), MockDsb(2), MockDsb(16), MockDsb(2)],
)
myTp = Type01Plan.FrameSetPlan(myDfsr)
myOrigChS = [0, 4, 2]
myChS = sorted(myOrigChS)
myOffS = [0, 12, 30]
myG = myTp.genOffsets(myOrigChS)
for myF in range(4):
for myCidx in range(len(myChS)):
myTuple = next(myG)
#print(myTuple)
self.assertEqual(myTuple, (myF, myChS[myCidx], 4+myOffS[myCidx]+32*myF))
myG.close()
