def _startRaw(self, target): if self._mode != SIMULATION \ and session.daemon_device._controller.status == STATUS_INBREAK: raise UsageError('Doppler speed can not be changed when script is ' 'paused.') if self._seq_is_running(): if self._mode == SIMULATION: self._seq_thread.join() else: self._seq_thread.join(0) self._seq_thread = None if not self.waitForAcq(10): return seq = list() # to change the doppler speed it has to be stopped first seq.append(SeqDev(self._attached_switch, 'off')) seq.append(SeqCall(session.delay, 0.5)) if target[0] != 0: seq.append(SeqCall(MultiSwitcher._startRaw, self, target)) seq.append(SeqDev(self._attached_switch, 'on')) seq.append(SeqCall(self.waitForSync, target)) self._startSequence(seq)
def _generateSequence(self, target): seq = [] pos = self.read(0) self._save_pos() xpos = self._beamstop_pos[pos] seq.append((SeqDev(self._attached_y, -450), SeqDev(self._attached_x, xpos))) seq.append(SeqMethod(self, '_testArrival', xpos, -450.)) seq.append(SeqLimDev(self._attached_y, -549, -549)) seq.append(SeqMethod(self, '_testArrival', xpos, -549.)) xpos = self._beamstop_pos[int(target)] seq.append(SeqDev(self._attached_x, xpos)) seq.append(SeqMethod(self, '_testArrival', xpos, -549.)) seq.append(SeqLimDev(self._attached_y, -450, -450)) seq.append(SeqMethod(self, '_testArrival', xpos, -450)) seq.append((SeqDev(self._attached_y, self._in_y), SeqDev(self._attached_x, self._in_x))) return seq
def _generateSequence(self, target): seq = [] if target == self.onvalue: seq.append(SeqDev(self._attached_moveable, self.onvalue)) seq.append(SeqSleep(self.ontime)) seq.append(SeqDev(self._attached_moveable, self.offvalue)) return seq
def _generateSequence(self, target): seq = [] if not self.isAtTarget(self.read(0)): position = None for i, val in enumerate(self._switchlist[0]): if target == val: position = self._switchlist[1][i] break # ask for diaphragma to switch in if position == 0: self.log.debug('no diaphragma') seq.append(SeqDev(self._pairs[3], 'cover')) else: self.log.debug('diaphragma') seq.append(SeqDev(self._pairs[3], 'frame')) seq.append(SeqSleep(self.chkmotiontime)) # ask for changing the devices pair 1-3 for i in range(3): if self._pairs[i]: # Ignore pair1 if not used if (position & (1 << i)): self.log.debug('switching to frame: %s', self._pairs[i]) seq.append(SeqDev(self._pairs[i], 'frame')) else: self.log.debug('switching to cover: %s', self._pairs[i]) seq.append(SeqDev(self._pairs[i], 'cover')) seq.append(SeqSleep(self.chkmotiontime)) return seq
def _startRaw(self, pos): if self._seq_is_running(): if self._mode == SIMULATION: self._seq_thread.join() self._seq_thread = None else: raise MoveError( self, 'Cannot start device, sequence is still ' 'running (at %s)!' % self._seq_status[1]) det_z = self._attached_det_z seq = [] seq.append(SeqDev(self._attached_bs_y, pos[1], stoppable=True)) seq.append(SeqDev(self._attached_bs_x, pos[0], stoppable=True)) seq.append(SeqDev(det_z, pos[2], stoppable=True)) # if z has to move, reposition beamstop y afterwards by going to # some other value (damping vibrations) and back if self.beamstopsettlepos is not None and \ abs(det_z.read(0) - pos[2]) > det_z.precision: seq.append( SeqDev(self._attached_bs_y, self.beamstopsettlepos, stoppable=True)) seq.append(SeqSleep(30)) seq.append(SeqDev(self._attached_bs_y, pos[1], stoppable=True)) self._startSequence(seq)
def doStart(self, target): th, tv = target seq = [] seq.append(SeqDev(self._attached_horizontal, th)) seq.append(SeqDev(self._attached_vertical, tv)) self._startSequence(seq)
def _generateSequence(self, target): return [ SeqDev(self._attached_switch, self.switchvalues[1]), SeqSleep(self.startdelay), SeqCall(Axis.doStart, self, target), SeqCall(self._hw_wait), SeqSleep(self.stopdelay), SeqDev(self._attached_switch, self.switchvalues[0]), ]
def doReference(self): """Reference the NOK in a sophisticated way. First we try to reach the lowest point ever needed for referencing, then we reference the lower refpoint first, and the higher later. After referencing is done, we go to (0, 0). """ # XXX: EXTRA BIG TODO !!! if self._seq_is_running(): raise MoveError(self, 'Cannot reference device, it is still ' 'moving!') devices = self._devices refpos = [d.refpos for d in devices] # referencing is easier if device[0].refpos is always lower than # device[1].refpos if refpos[1] < refpos[0]: # wrong order: flip oder of entries devices.reverse() refpos.reverse() # go below lowest interesting point minpos = min(self.read() + refpos + [t + self.backlash for t in refpos]) # build a referencing sequence sequence = [] # go to lowest position first sequence.append([SeqDevMin(d, minpos) for d in devices]) # if one of the motors should have triggered the low-level-switch # move them up a little and wait until the movement has finished sequence.append([ SeqMoveOffLimitSwitch(d, backoffby=self.backlash / 4.) for d in devices ]) # ref lowest position, should finish at refpos[0] # The move should be first, as the referencing may block! sequence.append([ SeqDev(devices[1], refpos[0]), SeqMethod(devices[0], 'reference') ]) # ref highest position, should finish at refpos[1] sequence.append([ SeqDev(devices[0], refpos[1]), SeqMethod(devices[1], 'reference') ]) # fun: move both to 0 sequence.append([SeqDev(d, 0) for d in devices]) # GO self._startSequence(sequence)
def _generateSequence(self, target): seq = [] if target != self.doRead(0): seq.append(SeqDev(self._attached_push, 'up', stoppable=False)) seq.append(SeqSleep(self.delay)) seq.append( SeqSampleMotor(self._attached_motor, target, stoppable=False)) seq.append(SeqSleep(self.delay)) seq.append(SeqDev(self._attached_push, 'down', stoppable=False)) return seq
def _startRaw(self, pos): if self._seq_is_running(): if self._mode == SIMULATION: self._seq_thread.join() self._seq_thread = None else: raise MoveError( self, 'Cannot start device, sequence is still ' 'running (at %s)!' % self._seq_status[1]) # switch det_img alias synchronously, the chopper sets its mode param! det_img_alias = session.getDevice('det_img') if pos[3]: det_img_alias.alias = 'det_img_jum' else: det_img_alias.alias = 'det_img_ge' seq = [] seq.append(SeqDev(self._attached_attenuator, pos[4])) if pos[3]: seq.append( SeqDev(self._attached_det_z, self.detbackpos, stoppable=True)) seq.append(SeqDev(self._attached_psd_y, pos[1], stoppable=True)) seq.append(SeqDev(self._attached_psd_x, pos[0], stoppable=True)) else: seq.append(SeqDev(self._attached_psd_x, 0, stoppable=True)) seq.append( SeqDev(self._attached_psd_y, self.psdtoppos, stoppable=True)) seq.append(SeqDev(self._attached_bs_y, pos[1], stoppable=True)) seq.append(SeqDev(self._attached_bs_x, pos[0], stoppable=True)) seq.append(SeqDev(self._attached_det_z, pos[2], stoppable=True)) # maybe reposition beamstop Y axis to counter jitter. seq.append(SeqCall(self._check_bsy, pos[1])) self._startSequence(seq)
def _generateSequence(self, target): if not target: target = self._components() # Add everything to be done in the seq list seq = [] # If the laser is now on, turn it on if self._attached_switch.read(0) != 'ON': seq.append(SeqDev(self._attached_switch, 'ON')) seq.append(SeqSleep(5)) seq.append( SeqCall(self._logvalues, ['Component', 'Read', 'Final', 'Comments'], True)) for component in target: if component not in self._components(): comments = 'Skipping! Component not valid..' seq.append( SeqCall(self._logvalues, [component, '', '', comments])) continue if component in self.fixedcomponents: comments = 'Skipping! Component fixed..' seq.append( SeqCall(self._logvalues, [component, '', '', comments])) continue if component not in self._attached_positioner.mapping: comments = 'Skipping! Height not configured..' seq.append( SeqCall(self._logvalues, [component, '', '', comments])) continue # Move the laser to the component height seq.append(SeqDev(self._attached_positioner, component)) # Sleep for few seconds before reading the value seq.append(SeqSleep(3)) # Read in and change the distance measured by laser seq.append(SeqCall(self._update_raw_distance, component)) seq.append(SeqCall(self._update_component, component, True)) seq.append(SeqCall(self.log.info, 'Parking and turning off laser..')) seq.append(SeqDev(self._attached_positioner, 'park')) seq.append(SeqDev(self._attached_switch, 'OFF')) seq.append(SeqCall(self.log.info, 'Done! Summary below:')) seq.append(SeqCall(self.__call__, target)) seq.append(SeqCall(self._update)) return seq
def _generateSequence(self, target): anodes = self._attached_anodes + self._attached_banodes seq = [ [ SeqDev(dev, self.mapping[target][dev.name]) for dev in self._attached_window ], [SeqDev(dev, self.mapping[target][dev.name]) for dev in anodes], [ SeqDev(dev, self.mapping[target][dev.name]) for dev in self._attached_cathodes ], ] return seq
def _generateSequence(self): seq = [] if self._tths: self._startpos = self._tths seq.append( SeqDev(self._attached_motor, self._startpos, stoppable=True)) for step in range(self.resosteps): pos = self._startpos - step * self._step_size seq.append(SeqDev(self._attached_motor, pos, stoppable=True)) seq.append(SeqCall(self._startDet)) seq.append(SeqWait(self._attached_detector)) seq.append(SeqCall(self._read_value)) seq.append(SeqCall(self._incStep)) return seq
def _generateSequence(self, target): seq = [] if self._attached_selector.read(0) > self.maxtiltspeed: seq.insert( 0, SeqDev(self._attached_selector, self.maxtiltspeed, stoppable=True)) seq.append(SeqMethod(self, '_check_speed')) seq.append(SeqMethod(self._attached_motor, 'release')) seq.append(SeqDev(self._attached_motor, target, stoppable=True)) seq.append( SeqMethod(self._attached_motor, 'fix', 'only move this using %s' % self)) return seq
def _generateSequence(self, target): pos = self.read(0) s = self.microstep if (target - pos) >= 0 else -self.microstep n = int((target - pos) / s) # handle floating point overflows # check whether or not one last microstep fits into movement to target. if (math.fabs((pos + (n + 1) * s) - target) < math.fabs( self.microstep / 10)): n += 1 res = [(SeqDev(self._attached_motor, pos + i * s), SeqSleep(self._delay)) for i in range(1, n)] res.append((SeqDev(self._attached_motor, target), SeqSleep(self._delay))) return res
def _generateSequence(self): seq = [] shutter_mode = self._attached_auto.read(0) if shutter_mode == 'auto': seq.append(SeqDev(self._attached_shutter, 'open')) # Wait for arm to become 0 seq.append(WaitPV(self, 'armpv', 0, timeout=self.arm_timeout)) # set valid 0 seq.append(PutPV(self, 'validpv', 0)) # wait for beam seq.append(Message(self, 'Waiting for beam...')) s = WaitThreshold(self, self._attached_beam_current, self._attached_rate_threshold.read()) seq.append(s) seq.append(Message(self, 'Beam is on, exposing...')) # Start the detector seq.append(PutPV(self, 'trigpv', 1)) # wait for the detector to actually start s = WaitNotPV(self, 'shutpv', 1, timeout=self.shutter_timeout) seq.append(s) # Reset the start signal seq.append(PutPV(self, 'trigpv', 0)) # Wait for counting to finish s = WaitPV(self, 'shutpv', 1, timeout=self.exposure_timeout) seq.append(s) # Write the metadata seq.append(SeqMethod(self, '_writeMetaData')) # Camini is tired, needs a little sleep seq.append(SeqSleep(.1)) # set valid 1 seq.append(PutPV(self, 'validpv', 1)) if shutter_mode == 'auto': seq.append(SeqDev(self._attached_shutter, 'closed')) return seq
def park(self, blocking=True): """Move device to the ``park`` position. The park position is given by the ``parkposition`` parameter. It generate ands starts a sequence if none is running. The call blocks the daemon execution if ``blocking`` is set to True. """ if self._seq_is_running(): if self._mode == SIMULATION: self._seq_thread.join() self._seq_thread = None else: raise MoveError( self, 'Cannot park device, sequence is still ' 'running (at %s)!' % self._seq_status[1]) self._startSequence([ SeqMethod(self, '_move_guides_to_zero_pos'), SeqMethod(self, '_move_detectors', self.parkpos), ] + [ SeqDev(d, p) for d, p in zip(self._rotguide1, self.parkpos[11:][::-1]) ]) if blocking: # block the move to be sure that the device has reached target # before it can be dismounted or the position sensitive detectors # can be used self.wait()
def _generateSequence(self, value): sequence = [] currentsource = self._attached_currentsource if value != 0: need_pol = +1 if value > 0 else -1 curr_pol = self._get_field_polarity() # if the switch values are not correct, drive to zero and switch if curr_pol != need_pol: if currentsource.read() != 0: sequence.append(SeqDev(currentsource, 0.)) # insert switching Sequence self._seq_set_field_polarity(need_pol, sequence) sequence.append(SeqDev(currentsource, abs(value))) if value == 0: self._seq_set_field_polarity(0, sequence) return sequence
def change(self, old, whereto): ''' cool kurze Wechselroutine Der Knackpunkt ist in den Hilfsroutinen!''' if not (old in self.monos + ['None']): raise UsageError( self, '\'%s\' is illegal value for Mono, use one ' 'of ' % old + ', '.join(self.monos + ['None'])) if not (whereto in self.monos + ['None']): raise UsageError( self, '\'%s\' is illegal value for Mono, use one ' 'of ' % whereto + ', '.join(self.monos + ['None'])) self.PrepareChange() if self.monos.index(whereto) == self.monos.index(old): # Nothing to do, requested Mono is supposed to be on the table return # Ok, we have a good state, the only thing we do not know is which mono # is on the table...... # for this we use the (cached) parameter mono_on_table if self.mono_on_table != old: raise UsageError( self, 'Mono %s is not supposed to be on the ' 'table, %s is!' % (old, self.mono_on_table)) seq = [] # 0) move magazine to mono position magpos_to_put = self.positions[self.monos.index(old)] seq.append(SeqMethod(self, 'CheckMagazinSlotEmpty', magpos_to_put)) seq.append(SeqDev(self._attached_magazine, magpos_to_put)) # 1) move away the old mono, if any if old != 'None': seq.extend(self._gen_table2lift()) seq.extend( self._gen_lift2mag(self.positions[self.monos.index(old)])) # 2) fetch the new mono (if any) from the magazin if whereto != 'None': seq.extend( self._gen_mag2lift(self.positions[self.monos.index(whereto)])) seq.extend(self._gen_lift2table()) seq.append( SeqDev(self._attached_magazine, self.shields[self.monos.index(whereto)])) # seq.append(SeqDev(self._attached_enable, 0)) - will be done in FinishChange seq.append(SeqMethod(self, 'FinishChange')) self._start(seq) self.wait()
def _generateSequence(self, target): hvdev = self._attached_supply disdev = self._attached_discharger seq = [SeqMethod(hvdev, 'stop'), SeqMethod(hvdev, 'wait')] now = currenttime() # below first rampstep is treated as poweroff if target <= self.rampsteps[0][0]: # fast ramp seq.append(SeqParam(hvdev, 'ramp', self.fastramp)) seq.append(SeqDev(disdev, 1 if self.read() > target else 0)) if self.read() > self.rampsteps[0][0]: seq.append(SeqDev(hvdev, self.rampsteps[0][0])) seq.append(SeqMethod(hvdev, 'start', target)) return seq # check off time if self.lasthv and now - self.lasthv <= self.maxofftime: # short ramp up sequence seq.append(SeqParam(hvdev, 'ramp', self.fastramp)) seq.append(SeqDev(disdev, 1 if self.read() > target else 0)) seq.append(SeqDev(hvdev, target)) # retry if target not reached seq.append(SeqMethod(hvdev, 'start', target)) return seq # long sequence self.log.warning( 'Voltage was down for more than %.2g hours, ' 'ramping up slowly, be patient!', self.maxofftime / 3600) self.log.info( 'Voltage will be ready around %s', strftime('%X', localtime(now + self.doTime(self.doRead(0), target)))) seq.append(SeqParam(hvdev, 'ramp', self.slowramp)) seq.append(SeqDev(disdev, 0)) for voltage, minutes in self.rampsteps: # check for last point in sequence if target <= voltage: seq.append(SeqDev(hvdev, target)) seq.append( SeqSleep(minutes * 60, 'Stabilizing HV for %d minutes' % minutes)) break else: # append seq.append(SeqDev(hvdev, voltage)) seq.append( SeqSleep(minutes * 60, 'Stabilizing HV for %d minutes' % minutes)) seq.append(SeqDev(hvdev, target)) # be sure... seq.append(SeqMethod(hvdev, 'poll')) # force a read return seq
def _generateSequence(self, target): theta, trans = self._calcMonoPosition(target) seq = [] seq.append((SeqDev(self._attached_mth1, self.safe_position), SeqDev(self._attached_mth2, self.safe_position))) seq.append(SeqMethod(self, '_checksafe')) seq.append(SeqMethod(self, '_runMtx', trans)) seq.append((SeqDev(self._attached_mth1, theta), SeqDev(self._attached_mth2, theta))) seq.append(SeqMethod(self, '_checkArrival')) return seq
def _generateSequence(self, target): self.wlmin, self.wlmax = limits( (target.get('wlmin', self.wlmin), target.get('wlmax', self.wlmax))) self.dist = target.get('D', self.dist) self.gap = target.get('gap', self.gap) chopper2_pos = target.get('chopper2_pos') speed, angles = chopper_config(self.wlmin, self.wlmax, self.dist, chopper2_pos, gap=self.gap) self.log.debug('speed: %d, angles = %s', speed, angles) seq = [] shutter_pos = self._attached_shutter.read(0) shutter_ok = self._attached_shutter.status(0)[0] == status.OK if chopper2_pos == 6: self._setROParam('mode', 'virtual_disc2_pos_6') else: self._setROParam('mode', 'normal_mode') chopper2_pos_akt = self._attached_chopper2.pos if chopper2_pos_akt != chopper2_pos: if shutter_ok: seq.append( SeqDev(self._attached_shutter, 'closed', stoppable=True)) seq.append(SeqDev(self._attached_chopper1, 0, stoppable=True)) seq.append( SeqSlowParam(self._attached_chopper2, 'pos', chopper2_pos)) for dev, t in zip(self._choppers[1:], angles[1:]): # The Chopper measures the phase in the opposite direction # as we do this was catered for here, we have moved the # sign conversion to the doWritePhase function # dev.phase = -t # sign by history seq.append(SeqFuzzyParam(dev, 'phase', t, 0.5)) seq.append(SeqDev(self._attached_chopper1, speed, stoppable=True)) if shutter_ok: seq.append( SeqDev(self._attached_shutter, shutter_pos, stoppable=True)) return seq
def doStart(self, targets): """Generate and start a sequence if none is running. The sequence is optimised for negative backlash. It will first move both motors to the lowest value of (target + backlash, current_position) and then to the final target. So, inbetween, the NOK should be parallel to the beam. MP 12.12.2017 09:16:05 """ if self._seq_is_running(): raise MoveError(self, 'Cannot start device, it is still moving!') # check precision, only move if needed! traveldists = [ target - dev.read(0) - ofs for target, dev, ofs in zip(targets, self._devices, self.offsets) ] if max(abs(v) for v in traveldists) <= self.precision: return devices = self._devices # XXX: backlash correction and repositioning later # build a moving sequence sequence = [] # now go to target sequence.append([ SeqDev(d, t + ofs, stoppable=True) for d, t, ofs in zip(devices, targets, self.offsets) ]) # now go to target again sequence.append([ SeqDev(d, t + ofs, stoppable=True) for d, t, ofs in zip(devices, targets, self.offsets) ]) self.log.debug('Seq: %r', sequence) self._startSequence(sequence)
def run(self): while self.dev.status(0)[0] == status.BUSY: # if still BUSY, stop first self.dev.stop() session.delay(0.3) self.dev.wait() session.delay(0.3) try: self.dev.wait() NicosSeqDev.run(self) except Exception: while True: # stop first self.dev.stop() session.delay(0.3) self.dev.wait() session.delay(0.3) if self.dev.status(0)[0] != status.BUSY: NicosSeqDev.run(self) break
def _generateSequence(self, target): """Generate and start a sequence if none is running. be sure not to cross the blades """ targets = self._calculate_slits(target, False) if (target[1] - self.center.read(0)) < 0: self.log.debug('DoubleSlitSequence Seq swap') sequence = [ SeqDev(self._attached_slit_s, targets[1], stoppable=True), SeqDev(self._attached_slit_r, targets[0], stoppable=True), ] else: self.log.debug('DoubleSlitSequence Seq org') sequence = [ SeqDev(self._attached_slit_r, targets[0], stoppable=True), SeqDev(self._attached_slit_s, targets[1], stoppable=True), ] self.log.debug('Seq_2: %r', sequence) return sequence
def _generateSequence(self): seq = [] order = (0, 1) if self._attached_flipper.read() == self.flipvalues[0] \ else (1, 0) for i, phase in enumerate(order): if i: seq.append(SeqDev(self._attached_flipper, self.flipvalues[phase])) seq.append(SeqCall(self._startDet, phase)) seq.append(SeqWait(self._attached_detector)) seq.append(SeqCall(self._readDet, phase)) seq.append(SeqCall(self._evaluateResults)) return seq
def _generateSequence(self, target): seq = [] if target < 5: seq.append(SeqDev(self._attached_setp, 0)) seq.append(SeqWaitValue(self._attached_rbv, 0, 5)) seq.append(SeqDev(self._attached_state, 'off')) elif abs(self._attached_rbv.read(0) - target) >= 1.0: seq.append(SeqDev(self._attached_state, 'on')) seq.append(SeqDev(self._attached_setp, target)) seq.append(SeqWaitValue(self._attached_rbv, target, 1.0)) # Repeat enough of this pair until sufficient stabilisation # has been reached seq.append(SeqSleep(5)) seq.append(SeqWaitValue(self._attached_rbv, target, 1.0)) seq.append(SeqSleep(5)) seq.append(SeqWaitValue(self._attached_rbv, target, 1.0)) seq.append(SeqSleep(5)) seq.append(SeqWaitValue(self._attached_rbv, target, 1.0)) return seq
def _generateSequence(self, target): seq = [] s = SeqMethod(self, '_release') seq.append(s) if target == 'out': seq.append(SeqMethod(self, '_save_pos')) seq.append(SeqDev(self._attached_x, self._out_x)) seq.append(SeqLimDev(self._attached_y, self._out_y, self._out_y)) seq.append(SeqMethod(self, '_fix')) else: seq.append(SeqMethod(self, '_release')) seq.append(SeqLimDev(self._attached_y, self._in_y, -450)) seq.append(SeqDev(self._attached_x, self._in_x)) return seq
def _generateSequence(self, target): seq = [] if not self.isAtTarget(self.doRead(0)): # The limited space at some positions requires a folding of the # instrument st_target = 60. if self.angle > -85. else 109. if st_target != self.stpos: raise ConfigurationError(self, 'st_target != stpos') # Only move if the setup (folding of 'st') is not correctly if abs(self._attached_st.read(0) - self.stpos) > \ self._attached_st.precision: seq.append(SeqDev(self._attached_tt, -60., stoppable=True)) seq.append( SeqDev(self._attached_st, self.stpos, stoppable=True)) # the configured positions are with offet = 0 ! # if the user changes the offset the change positions will not # change! tt_pos = self.angle - self._attached_tt.offset seq.append(SeqDev(self._attached_tt, tt_pos, stoppable=True)) seq.append(SeqDev(self._attached_block, target)) seq.append(SeqSleep(2)) return seq
def doStart(self, pos): self.doWriteScatteringsense(self.scatteringsense) qh, qk, ql, ny = pos ny = self._thz(ny) angles = self._attached_cell.cal_angles([qh, qk, ql], ny, self.scanmode, self.scanconstant, self.scatteringsense[1], self.axiscoupling, self.psi360) mono, ana, phi, psi, alpha = self._attached_mono, self._attached_ana, \ self._attached_phi, self._attached_psi, self._attached_alpha movefirst = [] self.log.debug('moving mono to %s', angles[0]) movefirst.append(SeqDev(mono, from_k(angles[0], mono.unit))) self.log.debug('moving phi/stt to %s', angles[2]) movefirst.append(SeqDev(phi, angles[2])) self.log.debug('moving psi/sth to %s', angles[3]) movefirst.append(SeqDev(psi, angles[3])) if alpha is not None: self.log.debug('moving alpha to %s', angles[4]) movefirst.append(SeqDev(alpha, angles[4])) seq = [] # move mono/sample all at once seq.append(movefirst) # afterwards correct ana if self.scanmode != 'DIFF': self.log.debug('moving ana to %s', angles[1]) seq.append(SeqDev(ana, from_k(angles[1], ana.unit))) # spurion check if self.spurioncheck and self._mode == SIMULATION: self._spurionCheck(pos) # store the min and max values of h,k,l, and E for simulation self._sim_setValue(pos) # start self._startSequence(seq)