def setUp(self):
     # Start the GDA SWMR demo
     #ioc = "/dls_sw/work/R3.14.12.3/support/mapping/iocs/TS-EA-IOC-02/bin/linux-x86_64/stTS-EA-IOC-02.sh"
     #self.ioc = subprocess.Popen([ioc, "512", "512"], stdin=subprocess.PIPE)
     #cothread.Sleep(5)
     from socket import gethostname
     hostname = gethostname().split(".")[0]
     pre = "{}-AD-SIM-01:".format(hostname)
     self.s = SimDetector("S", pre + "CAM:")
     self.s.loop_run()
     self.p = PositionPlugin("P", pre + "POS:")
     self.p.loop_run()
     self.h = Hdf5Writer("H", pre + "HDF5:")
     self.h.loop_run()
     # Wait for things to get their portName
     cothread.Sleep(0.5)
     self.assertNotEqual(self.s.portName, None)
     self.assertNotEqual(self.p.portName, None)
     self.assertNotEqual(self.h.portName, None)
     self.sp = SimDetectorPersonality("SP", self.s, self.p, self.h)
     self.sp.loop_run()
     self.positions = [
         ("y", VDouble, numpy.repeat(numpy.arange(6, 9), 5) * 0.1, 'mm'),
         ("x", VDouble, numpy.tile(numpy.arange(5), 3) * 0.1, 'mm'),
     ]
     self.in_params = dict(exposure=0.1, positions=self.positions, 
                           hdf5File="/tmp/demo2.hdf5")
     self.numImages = len(self.positions[0][2])
     self.runtime = self.numImages * 0.1
示例#2
0
 def setUp(self):
     self.simDetectorDriver = MagicMock()
     self.simDetectorDriver.stateMachine.name = "simDetectorDriver.sm"
     self.positionPlugin = MagicMock()
     self.positionPlugin.stateMachine.name = "positionPlugin.sm"
     self.hdf5Writer = MagicMock()
     self.hdf5Writer.stateMachine.name = "hdfWriter.sm"
     self.s = SimDetector("S", self.simDetectorDriver,
                                     self.positionPlugin, self.hdf5Writer)
     self.s.loop_run()
     self.positions = [
         ("y", VDouble, np.repeat(np.arange(6, 9), 5) * 0.1, 'mm'),
         ("x", VDouble, np.tile(np.arange(5), 3) * 0.1, 'mm'),
     ]
     self.valid_positions = self.positions + [
         ("y_index", VInt, np.repeat(np.arange(3, dtype=np.int32), 5).view(boolean_ndarray), ''),
         ("x_index", VInt, np.tile(np.arange(5, dtype=np.int32), 3).view(boolean_ndarray), '')
     ]
     self.in_params = dict(exposure=0.1, positions=self.positions,
                           hdf5File="/tmp/demo.hdf5")
     self.numImages = len(self.positions[0][2])
     self.valid_params = dict(abortTimeout=1,
                              configureTimeout=1,
                              dimensions=[3, 5],
                              exposure=0.1,
                              hdf5File='/tmp/demo.hdf5',
                              pauseTimeout=1,
                              period=0.1,
                              positions=self.valid_positions,
                              resetTimeout=1,
                              resumeTimeout=1,
                              rewindTimeout=1,
                              runTime=self.numImages * 0.1,
                              runTimeout=(self.numImages + 1) * 0.1,
                              totalSteps=15)
     self.maxDiff = None
     self.simDetectorDriver.validate.return_value = dict(
         runTime=self.numImages * 0.1, runTimeout=(self.numImages + 1) * 0.1,
         period=0.1)
     #self.positionPlugin.validate.return_value = dict(
     #    dimensions=[3, 5])
     self.hdf5Writer.validate.return_value = dict(
         filePath='/tmp', fileName='demo.hdf5',
         dimNames=['y_index', 'x_index'], dimSizes=[3, 5],
         dimUnits=['mm', 'mm'])
     self.hdf5Writer.configure.arguments = self.hdf5Writer.validate.return_value
class SimDetectorPersonalityTest(unittest.TestCase):

    def setUp(self):
        # Start the GDA SWMR demo
        #ioc = "/dls_sw/work/R3.14.12.3/support/mapping/iocs/TS-EA-IOC-02/bin/linux-x86_64/stTS-EA-IOC-02.sh"
        #self.ioc = subprocess.Popen([ioc, "512", "512"], stdin=subprocess.PIPE)
        #cothread.Sleep(5)
        from socket import gethostname
        hostname = gethostname().split(".")[0]
        pre = "{}-AD-SIM-01:".format(hostname)
        self.s = SimDetector("S", pre + "CAM:")
        self.s.loop_run()
        self.p = PositionPlugin("P", pre + "POS:")
        self.p.loop_run()
        self.h = Hdf5Writer("H", pre + "HDF5:")
        self.h.loop_run()
        # Wait for things to get their portName
        cothread.Sleep(0.5)
        self.assertNotEqual(self.s.portName, None)
        self.assertNotEqual(self.p.portName, None)
        self.assertNotEqual(self.h.portName, None)
        self.sp = SimDetectorPersonality("SP", self.s, self.p, self.h)
        self.sp.loop_run()
        self.positions = [
            ("y", VDouble, numpy.repeat(numpy.arange(6, 9), 5) * 0.1, 'mm'),
            ("x", VDouble, numpy.tile(numpy.arange(5), 3) * 0.1, 'mm'),
        ]
        self.in_params = dict(exposure=0.1, positions=self.positions, 
                              hdf5File="/tmp/demo2.hdf5")
        self.numImages = len(self.positions[0][2])
        self.runtime = self.numImages * 0.1

    def test_100_sequences(self):
        for i in range(100):
            print i
            self.do_sequence()
            cothread.Sleep(random.random())

    def do_sequence(self):
        start = time.time()
        self.sp.configure(**self.in_params)
        end = time.time()
        self.assertAlmostEqual(end - start, 0.0, delta=0.2)
        self.assertEqual(self.sp.state, DState.Ready)
        self.assertEqual(self.s.state, DState.Ready)
        self.assertEqual(self.p.state, DState.Ready)
        self.assertEqual(self.h.state, DState.Ready)
        self.assertEqual(self.s.arrayCounter, 0)
        # Do a run
        start = time.time()
        self.sp.run()
        end = time.time()
        self.assertAlmostEqual(end - start, self.runtime, delta=0.05)
        self.assertEqual(self.s.stateMachine.state, DState.Idle)
        # Allow numImages to update
        cothread.Sleep(0.05)
        self.assertEqual(self.s.arrayCounter, self.numImages)

    def tearDown(self):
        #self.ioc.stdin.close()
        #self.ioc.wait()
        pass
示例#4
0
class SimDetectorTest(unittest.TestCase):

    def setUp(self):
        self.simDetectorDriver = MagicMock()
        self.simDetectorDriver.stateMachine.name = "simDetectorDriver.sm"
        self.positionPlugin = MagicMock()
        self.positionPlugin.stateMachine.name = "positionPlugin.sm"
        self.hdf5Writer = MagicMock()
        self.hdf5Writer.stateMachine.name = "hdfWriter.sm"
        self.s = SimDetector("S", self.simDetectorDriver,
                                        self.positionPlugin, self.hdf5Writer)
        self.s.loop_run()
        self.positions = [
            ("y", VDouble, np.repeat(np.arange(6, 9), 5) * 0.1, 'mm'),
            ("x", VDouble, np.tile(np.arange(5), 3) * 0.1, 'mm'),
        ]
        self.valid_positions = self.positions + [
            ("y_index", VInt, np.repeat(np.arange(3, dtype=np.int32), 5).view(boolean_ndarray), ''),
            ("x_index", VInt, np.tile(np.arange(5, dtype=np.int32), 3).view(boolean_ndarray), '')
        ]
        self.in_params = dict(exposure=0.1, positions=self.positions,
                              hdf5File="/tmp/demo.hdf5")
        self.numImages = len(self.positions[0][2])
        self.valid_params = dict(abortTimeout=1,
                                 configureTimeout=1,
                                 dimensions=[3, 5],
                                 exposure=0.1,
                                 hdf5File='/tmp/demo.hdf5',
                                 pauseTimeout=1,
                                 period=0.1,
                                 positions=self.valid_positions,
                                 resetTimeout=1,
                                 resumeTimeout=1,
                                 rewindTimeout=1,
                                 runTime=self.numImages * 0.1,
                                 runTimeout=(self.numImages + 1) * 0.1,
                                 totalSteps=15)
        self.maxDiff = None
        self.simDetectorDriver.validate.return_value = dict(
            runTime=self.numImages * 0.1, runTimeout=(self.numImages + 1) * 0.1,
            period=0.1)
        #self.positionPlugin.validate.return_value = dict(
        #    dimensions=[3, 5])
        self.hdf5Writer.validate.return_value = dict(
            filePath='/tmp', fileName='demo.hdf5',
            dimNames=['y_index', 'x_index'], dimSizes=[3, 5],
            dimUnits=['mm', 'mm'])
        self.hdf5Writer.configure.arguments = self.hdf5Writer.validate.return_value

    def test_init(self):
        base = ['hdf5Writer', 'positionPlugin',
                'simDetectorDriver', 'uptime']
        pause = ['currentStep', 'stepsPerRun', 'totalSteps']
        config = ['dimensions', 'exposure', 'hdf5File', 'period', 'positions', 'running']
        self.assertEqual(self.s.attributes.keys(), base + pause + config)
        self.assertEqual(self.s.hdf5Writer, self.hdf5Writer)
        self.assertEqual(self.s.positionPlugin, self.positionPlugin)
        self.assertEqual(self.s.simDetectorDriver, self.simDetectorDriver)

    def test_validate(self):
        actual = self.s.validate(**self.in_params)
        self.assertEqual(actual, self.valid_params)
        self.simDetectorDriver.validate.assert_called_once_with(
            0.1, self.numImages, None)
        self.positionPlugin.validate.assert_called_once_with(self.valid_positions)
        self.hdf5Writer.validate.assert_called_once_with(
            '/tmp', 'demo.hdf5', ['y', 'x'], ['mm', 'mm'], ['y_index', 'x_index'], [3, 5])

    def set_state(self, child, state):
        child.state = state
        child.stateMachine.state = state
        child.stateMachine.timeStamp = time.time()
        changes = dict(state=state, timeStamp=child.stateMachine.timeStamp)
        self.s.post_changes(child.stateMachine, changes)

    def set_attribute(self, child, attr, value):
        child.attributes[attr].value = value
        child.attributes[attr].timeStamp = time.time()
        changes = dict(value=value, timeStamp=child.stateMachine.timeStamp)
        self.s.post_changes(child.attributes[attr], changes)

    def test_configure(self):
        self.set_state(self.simDetectorDriver, DState.Idle)
        self.set_state(self.positionPlugin, DState.Idle)
        self.set_state(self.hdf5Writer, DState.Idle)
        spawned = cothread.Spawn(self.s.configure, **self.in_params)
        # Yield to let configure run
        cothread.Yield()
        self.assertEqual(self.s.stateMachine.state, DState.Idle)
        # Yield to let do_config and first do_configsta run
        cothread.Yield()
        self.assertEqual(self.s.stateMachine.state, DState.Configuring)
        # Yield to let Config state machine process
        cothread.Yield()
        self.simDetectorDriver.configure.assert_called_once_with(
            0.1, self.numImages, 0.1, 0, block=False)
        self.positionPlugin.configure.assert_called_once_with(
            self.valid_positions, 1, self.simDetectorDriver.portName, block=False)
        self.hdf5Writer.configure.assert_called_once_with(
            filePath='/tmp', fileName='demo.hdf5',
            dimNames=['y_index', 'x_index'], dimSizes=[3, 5],
            dimUnits=['mm', 'mm'],
            arrayPort=self.positionPlugin.portName, block=False)
        # Now simulate some plugins ready
        self.set_state(self.positionPlugin, DState.Configuring)
        self.set_state(self.simDetectorDriver, DState.Ready)
        self.set_state(self.hdf5Writer, DState.Ready)
        cothread.Yield()
        self.assertEqual(
            self.s.stateMachine.message, "Wait for plugins to configure")
        # simulate positionPlugin ready
        self.set_state(self.positionPlugin, DState.Ready)
        cothread.Yield()
        self.assertEqual(self.s.stateMachine.message, 'Configuring done')
        self.assertEqual(self.s.stateMachine.state, DState.Ready)
        now = time.time()
        spawned.Wait(1)
        then = time.time()
        self.assertLess(then - now, 0.5)

    def set_configured(self):
        self.set_state(self.simDetectorDriver, DState.Idle)
        self.set_state(self.positionPlugin, DState.Idle)
        self.set_state(self.hdf5Writer, DState.Idle)
        self.s.configure(block=False, **self.in_params)
        cothread.Yield()
        self.set_state(self.positionPlugin, DState.Ready)
        self.positionPlugin.dimensions = [3, 5]
        cothread.Yield()
        self.set_state(self.simDetectorDriver, DState.Ready)
        self.set_state(self.hdf5Writer, DState.Ready)
        cothread.Yield()
        self.assertEqual(self.s.state, DState.Ready)
        self.hdf5Writer.configure.reset_mock()
        self.simDetectorDriver.configure.reset_mock()
        self.positionPlugin.configure.reset_mock()

    def test_mismatches(self):
        self.set_configured()
        self.set_state(self.simDetectorDriver, DState.Idle)
        self.assertEqual(self.s.state, DState.Ready)
        cothread.Yield()
        self.assertEqual(self.s.state, DState.Idle)

    def test_run(self):
        self.set_configured()
        # Do a run
        self.assertEqual(self.s.running, False)
        spawned = cothread.Spawn(self.s.run)
        # let run() go
        cothread.Yield()
        self.assertEqual(self.s.state, DState.Ready)
        # let do_run go
        cothread.Yield()
        self.assertEqual(self.s.state, DState.Running)
        # Yield to let Config state machine process
        cothread.Yield()
        self.hdf5Writer.run.assert_called_once_with(block=False)
        self.positionPlugin.run.assert_called_once_with(block=False)
        self.assertEqual(
            self.s.stateMachine.message, "Wait for hdf5Writer to run")
        # Now simulate some started
        self.set_attribute(self.positionPlugin, "running", False)
        self.set_attribute(self.hdf5Writer, "capture", True)
        self.set_state(self.hdf5Writer, DState.Running)
        cothread.Yield()
        self.assertEqual(
            self.s.stateMachine.message, 'Wait for positionPlugin to run')
        # And a bit more
        self.set_attribute(self.positionPlugin, "running", True)
        self.set_state(self.positionPlugin, DState.Running)
        cothread.Yield()
        self.assertEqual(self.s.stateMachine.message, "Wait for run to finish")
        self.assertEqual(self.s.running, False)
        # Now start simDetectorDriver
        self.set_state(self.simDetectorDriver, DState.Running)
        cothread.Yield()
        self.assertEqual(self.s.stateMachine.message, "Wait for run to finish")
        self.assertEqual(self.s.running, True)
        # Now let them all finish except 1
        self.set_state(self.simDetectorDriver, DState.Idle)
        self.set_state(self.hdf5Writer, DState.Idle)
        cothread.Yield()
        self.assertEqual(self.s.stateMachine.message, "Wait for run to finish")
        # and done
        self.set_state(self.positionPlugin, DState.Idle)
        cothread.Yield()
        self.assertEqual(self.s.stateMachine.message, "Running done")
        self.assertEqual(self.s.state, DState.Idle)
        now = time.time()
        spawned.Wait(1)
        then = time.time()
        self.assertLess(then - now, 0.5)

    def test_pause(self):
        self.set_configured()
        # Do a run
        spawned = cothread.Spawn(self.s.run)
        # let run() go
        cothread.Yield()
        self.assertEqual(self.s.state, DState.Ready)
        # let do_run go
        cothread.Yield()
        self.assertEqual(self.s.state, DState.Running)
        # Set everything going
        self.set_state(self.hdf5Writer, DState.Running)
        self.set_attribute(self.hdf5Writer, "capture", True)
        cothread.Yield()
        self.assertEqual(
            self.s.stateMachine.message, 'Wait for positionPlugin to run')
        self.set_state(self.positionPlugin, DState.Running)
        self.set_attribute(self.positionPlugin, "running", True)
        self.set_state(self.simDetectorDriver, DState.Running)
        cothread.Yield()
        self.assertEqual(self.s.stateMachine.message, "Wait for run to finish")
        # Now do a few frames
        currentstep = 5
        self.set_attribute(self.hdf5Writer, "uniqueId", currentstep)
        cothread.Yield()
        self.assertEqual(self.s.currentStep, 5)
        self.assertEqual(self.s.totalSteps, 15)
        self.do_pause(currentstep, self.s.pause)
        # now retrace a bit
        rewind = 3
        self.do_pause(currentstep - rewind, self.s.rewind, rewind)
        self.assertEqual(self.s.currentStep, currentstep - rewind)
        # now continue
        rspawned = cothread.Spawn(self.s.resume)
        # let run() go
        cothread.Yield()
        self.assertEqual(self.s.state, DState.Paused)
        # let do_run go
        cothread.Yield()
        self.assertEqual(self.s.state, DState.Running)
        # Set everything going
        self.set_state(self.hdf5Writer, DState.Running)
        self.set_attribute(self.hdf5Writer, "capture", True)
        cothread.Yield()
        self.assertEqual(
            self.s.stateMachine.message, 'Wait for positionPlugin to run')
        self.set_state(self.positionPlugin, DState.Running)
        self.set_attribute(self.positionPlugin, "running", True)
        self.set_state(self.simDetectorDriver, DState.Running)
        cothread.Yield()
        self.assertEqual(self.s.stateMachine.message, "Wait for run to finish")
        # Now do a few frames
        currentstep = 15
        self.set_attribute(self.hdf5Writer, "uniqueId", currentstep)
        cothread.Yield()
        self.assertEqual(self.s.currentStep, 15)
        self.assertEqual(self.s.totalSteps, 15)
        # Now finish
        self.set_state(self.simDetectorDriver, DState.Idle)
        self.set_state(self.hdf5Writer, DState.Idle)
        self.set_state(self.positionPlugin, DState.Idle)
        cothread.Yield()
        self.assertEqual(self.s.stateMachine.message, "Running done")
        self.assertEqual(self.s.state, DState.Idle)
        now = time.time()
        spawned.Wait(1)
        then = time.time()
        self.assertLess(then - now, 0.5)

    def do_pause(self, currentstep, func, *args):
        # now pause
        pspawn = cothread.Spawn(func, *args)
        # let pause() go
        cothread.Yield()
        cothread.Yield()
        self.assertEqual(self.s.state, DState.Rewinding)
        if not args:
            # check we've stopped the plugins
            self.simDetectorDriver.abort.assert_called_once_with(block=False)
            self.simDetectorDriver.abort.reset_mock()
            self.positionPlugin.abort.assert_called_once_with(block=False)
            self.positionPlugin.abort.reset_mock()
            self.assertEqual(
                self.s.stateMachine.message, "Wait for plugins to stop")
            # Respond
            self.set_state(self.simDetectorDriver, DState.Aborted)
            self.set_state(self.positionPlugin, DState.Aborted)
            cothread.Yield()
            # Reset
            self.simDetectorDriver.reset.assert_called_once_with(block=False)
            self.simDetectorDriver.reset.reset_mock()
            self.positionPlugin.reset.assert_called_once_with(block=False)
            self.positionPlugin.reset.reset_mock()
            self.assertEqual(
                self.s.stateMachine.message, "Wait for plugins to reset")
            # Respond
            self.set_state(self.simDetectorDriver, DState.Idle)
            self.set_state(self.positionPlugin, DState.Idle)
            cothread.Yield()

        # check we've reconfigured
        self.simDetectorDriver.configure.assert_called_once_with(
            0.1, self.numImages - currentstep, 0.1, currentstep, block=False)
        self.simDetectorDriver.configure.reset_mock()
        positions = []
        for n, t, d, u in self.valid_positions:
            positions.append([n, t, d[currentstep:].view(boolean_ndarray), u])
        self.positionPlugin.configure.assert_called_once_with(
            positions, currentstep + 1, self.simDetectorDriver.portName, block=False)
        self.positionPlugin.configure.reset_mock()
        self.assertEqual(
            self.s.stateMachine.message, "Wait for plugins to configure")
        # Respond
        self.set_state(self.simDetectorDriver, DState.Ready)
        self.set_state(self.positionPlugin, DState.Ready)
        cothread.Yield()
        # Check we're finished
        self.assertEqual(self.s.stateMachine.message, "Rewinding done")
        now = time.time()
        pspawn.Wait(1)
        then = time.time()
        self.assertLess(then - now, 0.05)

    def test_non_square(self):
        xs = []
        ys = []
        v = 2.0  # velocity in units/s
        period = 1.0  # time between points in s
        revs = 3  # number of revolutions in spiral
        r = 2.0  # radius increase for one turn
        # start from the outside and work inwards as it gives
        # us a better speed approximation
        theta = revs * 2 * np.pi
        while theta > 0:
            xs.append(r * theta * np.cos(theta) / 2 / np.pi)
            ys.append(r * theta * np.sin(theta) / 2 / np.pi)
            # This is the speed in radians/s
            w = v * 2 * np.pi / (theta * r)
            # Increments by next v
            theta -= w * period
        xs = np.array(xs)
        ys = np.array(ys)
        # These are the points zipped together
        pts = np.array((xs, ys)).T
        # Diff between successive points
        d = np.diff(pts, axis=0)
        # Euclidean difference between points
        segdists = np.sqrt((d ** 2).sum(axis=1))
        #from pkg_resources import require
        # require("matplotlib")
        #import pylab
        #pylab.plot(xs, ys, ".")
        # pylab.show()
        # pylab.plot(segdists)
        # pylab.show()
        # make a table of positions from it
        positions = [
            ("x", VDouble, xs, 'mm'),
            ("y", VDouble, ys, 'mm'),
        ]
        dimensions, valid_positions = self.s._add_position_indexes(positions)
        self.assertEqual(dimensions, [len(xs)])
        self.assertEqual(len(valid_positions), 3)
        self.assertEqual(valid_positions[2][0], "n_index")
        self.assertTrue(np.array_equal(valid_positions[2][2], np.arange(len(xs), dtype=np.int32)))