newportxps 0.3.0__py3-none-any.whl → 2025.1.0__py3-none-any.whl

newportxps/newportxps.py

@@ -1,11 +1,11 @@
  #!/usr/bin/env python
 
-import os
 import posixpath
+import atexit
 import sys
 import time
 import socket
-from io import StringIO
+from copy import deepcopy
 from configparser import  ConfigParser
 import numpy as np
 
@@ -75,11 +75,12 @@ class NewportXPS:
         err, uptime = self._xps.ElapsedTimeGet(self._sid)
         self.check_error(err, msg="Elapsed Time")
         boottime = time.time() - uptime
-        out = ["# XPS host:         %s (%s)" % (self.host, socket.getfqdn(self.host)),
-               "# Firmware:         %s" % self.firmware_version,
-               "# Current Time:     %s" % time.ctime(),
-               "# Last Reboot:      %s" % time.ctime(boottime),
-               "# Trajectory Group: %s" % self.traj_group,
+        hostn = socket.getfqdn(self.host)
+        out = [f"# XPS host:         {self.host} ({hostn})",
+               f"# Firmware:         {self.firmware_version}",
+               f"# Current Time:     {time.ctime()}",
+               f"# Last Reboot:      {time.ctime(boottime)}",
+               f"# Trajectory Group: {self.traj_group}",
                ]
 
         out.append("# Groups and Stages")
@@ -88,30 +89,35 @@ class NewportXPS:
 
         for groupname, status in self.get_group_status().items():
             this = self.groups[groupname]
-            out.append("%s (%s), Status: %s" %
-                       (groupname, this['category'], status))
+            out.append(f"{groupname} ({this['category']}), Status: {status}")
             for pos in this['positioners']:
-                stagename = '%s.%s' % (groupname, pos)
+                stagename = f"{groupname}.{pos}"
                 stage = self.stages[stagename]
-                out.append("   %s (%s)"  % (stagename, stage['stagetype']))
-                out.append("      Hardware Status: %s"  % (hstat[stagename]))
-                out.append("      Positioner Errors: %s"  % (perrs[stagename]))
+                out.extend([f"# {stagename} ({stage['stagetype']})",
+                            f"      Hardware Status: {hstat[stagename]}",
+                            f"      Positioner Errors: {perrs[stagename]}"])
         return "\n".join(out)
 
+    def disconnect(self):
+        self.ftpconn.close()
+        if self._sid is not None:
+            self._xps.TCP_CloseSocket(self._sid)
+        self._sid = None
 
     def connect(self):
         self._sid = self._xps.TCP_ConnectToServer(self.host,
                                                   self.port, self.timeout)
+
+        atexit.register(self.disconnect)
         try:
             self._xps.Login(self._sid, self.username, self.password)
         except:
-            raise XPSException('Login failed for %s' % self.host)
+            raise XPSException(f'Login failed for {self.host}')
 
         err, val = self._xps.FirmwareVersionGet(self._sid)
         self.firmware_version = val
         self.ftphome = ''
-
-        if any([m in self.firmware_version for m in ['XPS-D', 'HXP-D']]):
+        if any([m in self.firmware_version for m in ['XPS-D', 'HXP-D', 'XPS-RL']]):
             err, val = self._xps.Send(self._sid, 'InstallerVersionGet(char *)')
             self.firmware_version = val
             self.ftpconn = SFTPWrapper(**self.ftpargs)
@@ -119,19 +125,21 @@ class NewportXPS:
             self.ftpconn = FTPWrapper(**self.ftpargs)
             if 'XPS-C' in self.firmware_version:
                 self.ftphome = '/Admin'
-        try:
-            self.read_systemini()
-        except:
-            print("Could not read system.ini!!!")
+        self.read_systemini()
+
+    def clean_folders(self):
+        if 'xps-d' in self.firmware_version.lower():
+            self._xps.CleanTmpFolder(self._sid)
+            self._xps.CleanCoreDumpFolder(self._sid)
 
 
     def check_error(self, err, msg='', with_raise=True):
         if err != 0:
-            err = "%d" % err
+            err = f"{err}"
             desc = self._xps.errorcodes.get(err, 'unknown error')
-            print("XPSError: message= %s, error=%s, description=%s" % (msg, err, desc))
+            print(f"XPSError: message={msg}, error={err}, description={desc}")
             if with_raise:
-                raise XPSException("%s %s [Error %s]" % (msg, desc, err))
+                raise XPSException(f"{msg} {desc} [Error {err}]")
 
     def save_systemini(self, fname='system.ini'):
         """
@@ -169,10 +177,10 @@ class NewportXPS:
         self.stages= {}
         self.groups = {}
         sconf = ConfigParser()
-        sconf.readfp(StringIO(initext))
+        sconf.read_string(initext)
 
         # read and populate lists of groups first
-        for gtype, glist in sconf.items('GROUPS'): # ].items():
+        for gtype, glist in sconf.items('GROUPS'):
             if len(glist) > 0:
                 for gname in glist.split(','):
                     gname = gname.strip()
@@ -195,21 +203,19 @@ class NewportXPS:
 
         if len(pvtgroups) == 1:
             self.set_trajectory_group(pvtgroups[0])
-
         for sname in self.stages:
             ret = self._xps.PositionerMaximumVelocityAndAccelerationGet(self._sid, sname)
             try:
                 self.stages[sname]['max_velo']  = ret[1]
-                self.stages[sname]['max_accel'] = ret[2]/3.0
+                self.stages[sname]['max_accel'] = 0.75*ret[2]
             except:
-                print("could not set max velo/accel for %s" % sname)
+                print(f"could not read max velo/accel for {sname}")
             ret = self._xps.PositionerUserTravelLimitsGet(self._sid, sname)
             try:
                 self.stages[sname]['low_limit']  = ret[1]
                 self.stages[sname]['high_limit'] = ret[2]
             except:
-                print("could not set limits for %s" % sname)
-
+                print(f"could not read limits for {sname}")
         return self.groups
 
     def download_trajectory(self, filename):
@@ -342,27 +348,38 @@ class NewportXPS:
         gkp, gki, gkd, kform, ffgain
         """
         if stage not in self.stages:
-            print("Stage '%s' not found: " % stage)
+            print(f"Stage '{stage}' not found: ")
             return
         params = self._xps.PositionerCorrectorPIDFFVelocityGet(self._sid, stage)
         if params[0] != 0 or len(params) != 13:
-            print("error getting tuning parameters for %s" % stage)
+            print(f"error getting tuning parameters for {stage}")
             return
 
         params = params[1:]
         params[0] = closedloopstatus
-        if kp is not None:      params[1] = kp
-        if ki is not None:      params[2] = ki
-        if kd is not None:      params[3] = kd
-        if ks is not None:      params[4] = ks
-        if inttime is not None: params[5] = inttime
-        if dfilter is not None: params[6] = dfilter
-        if gkp is not None:     params[7] = gkp
-        if gki is not None:     params[8] = gki
-        if gkd is not None:     params[9] = gkd
-        if kform is not None:   params[10] = kform
-        if ffgain is not None:  params[11] = ffgain
-        ret = self._xps.PositionerCorrectorPIDFFVelocitySet(self._sid, stage, *params)
+        if kp is not None:
+            params[1] = kp
+        if ki is not None:
+            params[2] = ki
+        if kd is not None:
+            params[3] = kd
+        if ks is not None:
+            params[4] = ks
+        if inttime is not None:
+            params[5] = inttime
+        if dfilter is not None:
+            params[6] = dfilter
+        if gkp is not None:
+            params[7] = gkp
+        if gki is not None:
+            params[8] = gki
+        if gkd is not None:
+            params[9] = gkd
+        if kform is not None:
+            params[10] = kform
+        if ffgain is not None:
+            params[11] = ffgain
+        self._xps.PositionerCorrectorPIDFFVelocitySet(self._sid, stage, *params)
 
     @withConnectedXPS
     def get_tuning(self, stage):
@@ -371,11 +388,11 @@ class NewportXPS:
         gkp, gki, gkd, kform, ffgain
         """
         if stage not in self.stages:
-            print("Stage '%s' not found: " % stage)
+            print(f"Stage '{stage}' not found: ")
             return
         params = self._xps.PositionerCorrectorPIDFFVelocityGet(self._sid, stage)
         if params[0] != 0 or len(params) != 13:
-            print("error getting tuning parameters for %s" % stage)
+            print(f"error getting tuning parameters for {stage}")
             return
 
         params = params[1:]
@@ -400,8 +417,8 @@ class NewportXPS:
                 if group['category'].lower().startswith('multiple'):
                     pvtgroups.append(gname)
             pvtgroups = ', '.join(pvtgroups)
-            msg = "'%s' cannot be a trajectory group, must be one of %s"
-            raise XPSException(msg % (group, pvtgroups))
+            msg = f"'{group}' cannot be a trajectory group, must be one of {pvtgroups}"
+            raise XPSException(msg)
 
         self.traj_group = group
         self.traj_positioners = self.groups[group]['positioners']
@@ -416,11 +433,11 @@ class NewportXPS:
             try:
                 self.enable_group(self.traj_group)
             except XPSException:
-                print("Warning: could not enable trajectory group '%s'"% self.traj_group)
+                print(f"Warning: could not enable trajectory group '{self.traj_group}'")
                 return
 
-        for i in range(64):
-            self._xps.EventExtendedRemove(self._sid, i)
+        #for i in range(64):
+        #    self._xps.EventExtendedRemove(self._sid, i)
 
         # build template for linear trajectory file:
         trajline1 = ['%(ramptime)f']
@@ -448,14 +465,14 @@ class NewportXPS:
         if group is None:
             for group in self.groups:
                 err, ret = method(self._sid, group)
-                self.check_error(err, msg="%s group '%s'" % (action, group),
+                self.check_error(err, msg=f"{action} group '{group}'",
                                  with_raise=with_raise)
         elif group in self.groups:
             err, ret = method(self._sid, group)
-            self.check_error(err, msg="%s group '%s'" % (action, group),
+            self.check_error(err, msg=f"%{action} group '{group}'",
                              with_raise=with_raise)
         else:
-            raise ValueError("Group '%s' not found" % group)
+            raise ValueError("Group '{group}' not found")
 
     def kill_group(self, group=None):
         """
@@ -478,8 +495,8 @@ class NewportXPS:
                 self.initialize_group(group=g)
             except XPSException:
                 print(f"Warning: could not initialize '{g}' (already initialized?)")
-                
-                
+
+
     def home_allgroups(self, with_encoder=True, home=False):
         """
         home all groups
@@ -549,10 +566,10 @@ class NewportXPS:
         out = {}
         for group in self.groups:
             err, stat = self._xps.GroupStatusGet(self._sid, group)
-            self.check_error(err, msg="GroupStatus '%s'" % (group))
+            self.check_error(err, msg=f"GroupStatus '{group}'")
 
             err, val = self._xps.GroupStatusStringGet(self._sid, stat)
-            self.check_error(err, msg="GroupStatusString '%s'" % (stat))
+            self.check_error(err, msg=f"GroupStatusString '{stat}'")
 
             out[group] = val
         return out
@@ -564,12 +581,13 @@ class NewportXPS:
         """
         out = {}
         for stage in self.stages:
-            if stage in ('', None): continue
+            if stage in ('', None):
+                continue
             err, stat = self._xps.PositionerHardwareStatusGet(self._sid, stage)
-            self.check_error(err, msg="Pos HardwareStatus '%s'" % (stage))
+            self.check_error(err, msg=f"Pos HardwareStatus '{stage}'")
 
             err, val = self._xps.PositionerHardwareStatusStringGet(self._sid, stat)
-            self.check_error(err, msg="Pos HardwareStatusString '%s'" % (stat))
+            self.check_error(err, msg=f"Pos HardwareStatusString '{stat}'")
             out[stage] = val
         return out
 
@@ -580,12 +598,13 @@ class NewportXPS:
         """
         out = {}
         for stage in self.stages:
-            if stage in ('', None): continue
+            if stage in ('', None):
+                continue
             err, stat = self._xps.PositionerErrorGet(self._sid, stage)
-            self.check_error(err, msg="Pos Error '%s'" % (stage))
+            self.check_error(err, msg=f"Pos Error '{stage}'")
 
             err, val = self._xps.PositionerErrorStringGet(self._sid, stat)
-            self.check_error(err, msg="Pos ErrorString '%s'" % (stat))
+            self.check_error(err, msg=f"Pos ErrorString '{stat}'")
 
             if len(val) < 1:
                 val = 'OK'
@@ -599,8 +618,8 @@ class NewportXPS:
         set velocity for stage
         """
         if stage not in self.stages:
-            print("Stage '%s' not found" % stage)
-            return
+            raise XPSException(f"Stage '{stage}' not found")
+
         ret, v_cur, a_cur, jt0_cur, jt1_cur = \
              self._xps.PositionerSGammaParametersGet(self._sid, stage)
         if accl is None:
@@ -621,8 +640,6 @@ class NewportXPS:
             print("Do have a group to move")
             return
         ret = self._xps.GroupMoveAbort(self._sid, group)
-        print('abort group ', group, ret)
-
 
     @withConnectedXPS
     def move_group(self, group=None, **kws):
@@ -631,7 +648,7 @@ class NewportXPS:
         if group is None or group not in self.groups:
             group = self.traj_group
         if group is None:
-            print("Do have a group to move")
+            print("no group to move")
             return
         posnames = [p.lower() for p in self.groups[group]['positioners']]
         ret = self._xps.GroupPositionCurrentGet(self._sid, group, len(posnames))
@@ -671,15 +688,14 @@ class NewportXPS:
            relative (bool): whether move is relative [False]
         """
         if stage not in self.stages:
-            print("Stage '%s' not found" % stage)
-            return
+            raise XPSException(f"Stage '{stage}' not found")
 
         move = self._xps.GroupMoveAbsolute
         if relative:
             move = self._xps.GroupMoveRelative
 
         err, ret = move(self._sid, stage, [value])
-        self.check_error(err, msg="Moving stage '%s'" % (stage))
+        self.check_error(err, msg=f"Moving stage '{stage}'")
         return ret
 
     @withConnectedXPS
@@ -691,11 +707,10 @@ class NewportXPS:
            stage (string): name of stage -- must be in self.stages
         """
         if stage not in self.stages:
-            print("Stage '%s' not found: " % stage)
-            return
+            raise XPSException(f"Stage '{stage}' not found")
 
         err, val = self._xps.GroupPositionCurrentGet(self._sid, stage, 1)
-        self.check_error(err, msg="Get Stage Position '%s'" % (stage))
+        self.check_error(err, msg=f"Get Stage Position '{stage}'")
         return val
 
     read_stage_position = get_stage_position
@@ -735,27 +750,25 @@ class NewportXPS:
 
 
     @withConnectedXPS
-    def define_line_trajectories(self, axis, group=None,
-                                 start=0, stop=1, step=0.001, scantime=10.0,
+    def define_line_trajectories(self, axis, group=None, pixeltime=None,
+                                 scantime=None, start=0, stop=1, step=0.01,
                                  accel=None, upload=True, verbose=False):
         """defines 'forward' and 'backward' trajectories for a simple
-        single element line scan in PVT Mode
+        single element line scan using PVT Mode
         """
         if group is not None:
             self.set_trajectory_group(group)
 
         if self.traj_group is None:
-            print("Must define a trajectory group first!")
-            return
+            raise XPSException("No trajectory group defined")
 
         for axname in (axis, axis.upper(), axis.lower(), axis.title()):
-            stage = "%s.%s" % (self.traj_group, axname)
+            stage = f"{self.traj_group}.{axname}"
             if stage in self.stages:
                 break
 
-        # print(" Stage ", stage,  self.stages[stage])
-        max_velo  = 0.75*self.stages[stage]['max_velo']
-        max_accel = 0.5*self.stages[stage]['max_accel']
+        max_velo  = self.stages[stage]['max_velo']
+        max_accel = self.stages[stage]['max_accel']
 
         if accel is None:
             accel = max_accel
@@ -767,19 +780,25 @@ class NewportXPS:
         step = scandir*abs(step)
 
         npulses  = int((abs(stop - start) + abs(step)*1.1) / abs(step))
-        scantime = float(abs(scantime))
-        pixeltime= scantime / (npulses-1)
-        scantime = pixeltime*npulses
+        if pixeltime is None:
+            if scantime is None:
+                raise ValueError("line trajectory must set pixeltime or scantime")
+            else:
+                pixeltime = float(abs(scantime))/(npulses-1)
+        scantime = float(abs(pixeltime))*npulses
 
         distance = (abs(stop - start) + abs(step))*1.0
         velocity = min(distance/scantime, max_velo)
-
+        if verbose:
+            print(f"trajecory: {scantime=:.4f}, {pixeltime=:.4f}, {npulses=}, {start=:.4f}, {stop=:.4f}, {step=:.4f}")
         ramptime = max(2.e-5, abs(velocity/accel))
-        rampdist = velocity*ramptime
-        offset   = step/2.0 + scandir*rampdist
+        rampdist = 0.5*velocity*ramptime
+        offset   = 0.5*step + scandir*rampdist
 
-        trajbase = {'axes': [axis], 'pixeltime': pixeltime,
-                    'npulses': npulses, 'nsegments': 3}
+        trajbase = {'axes': [axis],
+                    'type': 'line',
+                    'pixeltime': pixeltime, 'uploaded': False,
+                    'npulses': npulses+1, 'nsegments': 3}
 
         self.trajectories['foreward'] = {'start': [start-offset],
                                          'stop':  [stop +offset]}
@@ -797,21 +816,19 @@ class NewportXPS:
                 val = 0.0
                 if ax == axis:
                     val = base[attr]
-                fore["%s_%s" % (ax, attr)] = val
+                fore[f"{ax}_{attr}"] = val
 
         back = fore.copy()
-        back["%s_start" % axis] = fore["%s_stop" % axis]
-        back["%s_stop" % axis]  = fore["%s_start" % axis]
+        back[f"{axis}_start"] = fore[f"{axis}_stop"]
+        back[f"{axis}_stop"]  = fore[f"{axis}_start"]
         for attr in ('velo', 'ramp', 'dist'):
-            back["%s_%s" % (axis, attr)] *= -1.0
+            back[f"{axis}_{attr}"] *= -1.0
 
         if verbose:
-            print("TRAJ Text Fore, Back:")
             print(self.linear_template % fore)
             print(self.linear_template % back)
 
         ret = True
-
         if upload:
             ret = False
             try:
@@ -819,36 +836,219 @@ class NewportXPS:
                                        self.linear_template % fore)
                 self.upload_trajectory('backward.trj',
                                        self.linear_template % back)
+                self.trajectories['foreward']['uploaded'] = True
+                self.trajectories['backward']['uploaded'] = True
+                self.trajectories['foreward']['text'] = self.linear_template % fore
+                self.trajectories['backward']['text'] = self.linear_template % back
                 ret = True
             except:
                 raise ValueError("error uploading trajectory")
         return ret
 
     @withConnectedXPS
-    def arm_trajectory(self, name, verbose=False):
+    def define_array_trajectory(self, positions, dtime=1.0, max_accels=None,
+                                upload=True, name='array', verbose=True):
+        """define a PVT trajectory for the trajectory group from a dictionary of
+        position arrays for each positioner in the trajectory group.
+
+        Positioners that are not included in the positions dict will not be moved.
+
+        Arguments
+        ---------
+        positions:  dict of {PosName: np.ndarray} for each positioner to move
+        dtime:      float, time per segment
+        max_accels: dict of {PosName: max_acceleration} to use.
+        name:       name of trajectory (file will be f"{name}.trj")
+        upload:     bool, whether to upload trajectory
+
+        Returns:
+        -------
+        dict with information about trajcetory.  This will include values for
+             pvt_buff:  full text of trajectory buffer
+             type: 'array'
+             start: dict of starting values (backed up from first point so that
+                    positioner can be accelerated to the desired velocity for the
+                    second trajectory segment)
+             npulses: number of expected pulses.
+
+        Notes:
+        ------
+        1. The np.ndarray for each positioner must be the same length, and will be
+           used as midpoints between trigger events.
+        2. For ndarrays of lenght N, the trajectory will have N+1 segments: one
+           to ramp up to velocity to approach the first point, and the last to
+           decelerate to zero velocity.
+
+        """
+        tgroup = self.traj_group
+        if tgroup is None:
+            raise XPSException("No trajectory group defined")
+
+        all_axes = [a for a in self.groups[tgroup]['positioners']]
+
+        pdat = {}
+        input_ok = True
+        npts = None
+        for key, value in positions.items():
+            pname = key[:]
+
+            if key.startswith(tgroup):
+                pname = key[len(tgroup)+1:]
+            if pname not in all_axes:
+                print(f"Unknown positioner given: {pname}")
+                input_ok = False
+            if npts is None:
+                npts = len(value)
+            elif npts != len(value):
+                print(f"incorrect array length for {pname}")
+                input_ok = False
+
+            if isinstance(value, np.ndarray):
+                positions[key] = value.astype(np.float64).tolist()
+            else:
+                positions[key] = [float(x) for x in value]
+
+        if not input_ok:
+            return
+
+        npulses  = npts+1
+        dtime = float(abs(dtime))
+        times = np.ones(npulses+1)*dtime
+
+        if max_accels is None:
+            max_accels = {}
+        pos, dpos = {}, {}
+        velo = {}
+        accel = {}
+        start = {}
+        for axes in all_axes:
+            stage = f'{tgroup}.{axes}'
+            maxv = self.stages[stage]['max_velo']
+            maxa = self.stages[stage]['max_accel']
+            if axes in max_accels:
+                maxa = min(max_accels[axes], maxa)
+            if axes in positions:
+                upos = positions[axes]
+                # mid are the trajectory trigger points, the
+                # mid points between the desired positions
+                mid = [3*upos[0]-2*upos[1], 2*upos[0] - upos[1]]
+                mid.extend(upos)
+                mid.extend([2*upos[-1]-upos[-2],
+                            3*upos[-1]-2*upos[-2],
+                            ])
+                mid = np.array(mid)
+                pos[axes] = 0.5*(mid[1:] + mid[:-1])
+
+                # adjust first segment velocity to half max accel
+                p0, p1, p2 = pos[axes][0], pos[axes][1], pos[axes][2]
+                v0 = (p1-p0)/dtime
+                v1 = (p2-p1)/dtime
+                a0 = (v1-v0)/dtime
+                start[axes] = p1 - (p1-p0)*dtime*max(v0, 0.5*maxv)/max(a0, 0.5*maxa)
+
+                pos[axes] = np.diff(pos[axes] - start[axes])
+                velo[axes] = np.gradient(pos[axes])/times
+                velo[axes][-1] = 0.0
+                accel[axes] = np.gradient(velo[axes])/times
+
+                if (max(abs(velo[axes])) > maxv):
+                    errmsg = f"max velocity {maxv} violated for {axes}"
+                    raise ValueError(errmsg)
+                if (max(abs(accel[axes])) > maxa):
+                    errmsg = f"max acceleration {maxa} violated for {axes}"
+                    raise ValueError(errmsg)
+            else:
+                start[axes] = None
+                pos[axes] = np.zeros(npulses+1, dtype=np.float64)
+                velo[axes] = np.zeros(npulses+1, dtype=np.float64)
+                accel[axes] = np.zeros(npulses+1, dtype=np.float64)
+
+
+        traj = {'axes': all_axes,
+                'type': 'array',
+                'start': start, 'pixeltime': dtime,
+                'npulses': npulses+1, 'nsegments': npulses+1,
+                'uploaded': False}
+
+        buff = ['']
+
+        for n in range(npulses+1):
+            line = [f"{dtime:.8f}"]
+            for axes in all_axes:
+                p, v = pos[axes][n], velo[axes][n]
+                line.extend([f"{p:.8f}", f"{v:.8f}"])
+            buff.append(', '.join(line))
+        buff.append('')
+        buff  = '\n'.join(buff)
+        traj['pvt_buffer'] = buff
+
+        if upload:
+            tfile = f"{name}.trj"
+            traj['name'] = name
+            try:
+                self.upload_trajectory(tfile, buff)
+                traj['uploaded'] = True
+            except:
+                traj['uploaded'] = False
+        self.trajectories[name] = traj
+        return traj
+
+
+    @withConnectedXPS
+    def move_to_trajectory_start(self, name):
+        """
+        move to the start position of a named trajectory
+        """
+        tgroup = self.traj_group
+        if tgroup is None:
+            raise XPSException("No trajectory group defined")
+
+        traj = self.trajectories.get(name, None)
+        if traj is None:
+            raise XPSException(f"Cannot find trajectory named '{name}'")
+
+        if traj['type'] == 'line':
+            for pos, axes in zip(traj['start'], traj['axes']):
+                self.move_stage(f'{tgroup}.{axes}', pos)
+
+        elif traj['type'] == 'array':
+            for axes, pos in traj['start'].items():
+                if pos is not None:
+                    self.move_stage(f'{tgroup}.{axes}', pos)
+
+
+    @withConnectedXPS
+    def arm_trajectory(self, name, verbose=False, move_to_start=True):
         """
-        set up the trajectory from previously defined, uploaded trajectory
+        prepare to run a named (assumed uploaded) trajectory
         """
         if self.traj_group is None:
             print("Must set group name!")
 
         traj = self.trajectories.get(name, None)
         if traj is None:
-            raise XPSException("Cannot find trajectory named '%s'" %  name)
+            raise XPSException(f"Cannot find trajectory '{name}'")
+
+        if not traj['uploaded']:
+            raise XPSException(f"trajectory '{name}' has not been uploaded")
+
 
         self.traj_state = ARMING
-        self.traj_file = '%s.trj'  % name
+        self.traj_file = f'{name}.trj'
 
+        if move_to_start:
+            self.move_to_trajectory_start(name)
         # move_kws = {}
         outputs = []
         for out in self.gather_outputs:
             for i, ax in enumerate(traj['axes']):
-                outputs.append('%s.%s.%s' % (self.traj_group, ax, out))
+                outputs.append(f'{self.traj_group}.{ax}.{out}')
 
-        end_segment = traj['nsegments'] # - 1 + self.extra_triggers
+        end_segment = traj['nsegments']
         self.nsegments = end_segment
 
-        self.gather_titles = "%s\n#%s\n" % (self.gather_header, " ".join(outputs))
+        o = " ".join(outputs)
+        self.gather_titles = f"{self.gather_header}\n#{o}\n"
         err, ret = self._xps.GatheringReset(self._sid)
         self.check_error(err, msg="GatheringReset")
         if verbose:
@@ -859,33 +1059,33 @@ class NewportXPS:
 
         if verbose:
             print(" GatheringConfigurationSet outputs ", outputs)
-            print(" GatheringConfigurationSet returned ", ret)
+            print(" GatheringConfigurationSet returned ", ret, time.ctime())
             print(" segments, pixeltime" , end_segment, traj['pixeltime'])
 
         err, ret = self._xps.MultipleAxesPVTPulseOutputSet(self._sid, self.traj_group,
                                                            2, end_segment,
                                                            traj['pixeltime'])
-        self.check_error(err, msg="PVTPulseOutputSet", with_raise=False)
+        self.check_error(err, msg="PVTPulseOutputSet", with_raise=True)
         if verbose:
-            print(" PVTPulse  ", ret)
+            print(" PVTPulse  ", ret, time.ctime())
         err, ret = self._xps.MultipleAxesPVTVerification(self._sid,
                                                          self.traj_group,
                                                          self.traj_file)
 
-        self.check_error(err, msg="PVTVerification", with_raise=False)
+        self.check_error(err, msg="PVTVerification", with_raise=True)
         if verbose:
-            print(" PVTVerify  ", ret)
+            print(" PVTVerify  ", ret, time.ctime())
         self.traj_state = ARMED
 
     @withConnectedXPS
     def run_trajectory(self, name=None, save=True, clean=False,
-                       output_file='Gather.dat', verbose=False):
+                       output_file='Gather.dat', verbose=False, move_to_start=True):
 
         """run a trajectory in PVT mode
 
         The trajectory *must be in the ARMED state
         """
-
+        dt = debugtime()
         if 'xps-d' in self.firmware_version.lower():
             self._xps.CleanTmpFolder(self._sid)
 
@@ -893,47 +1093,60 @@ class NewportXPS:
                 self._xps.CleanCoreDumpFolder(self._sid)
 
         if name in self.trajectories and self.traj_state != ARMED:
-            self.arm_trajectory(name, verbose=verbose)
+            self.arm_trajectory(name, verbose=verbose, move_to_start=move_to_start)
 
         if self.traj_state != ARMED:
             raise XPSException("Must arm trajectory before running!")
 
-        buffer = ('Always', '%s.PVT.TrajectoryPulse' % self.traj_group,)
+        dt.add('armed')
+        tgroup = self.traj_group
+        buffer = ('Always', f'{tgroup}.PVT.TrajectoryPulse',)
         err, ret = self._xps.EventExtendedConfigurationTriggerSet(self._sid, buffer,
                                                                   ('0','0'), ('0','0'),
                                                                   ('0','0'), ('0','0'))
         self.check_error(err, msg="EventConfigTrigger")
         if verbose:
             print( " EventExtended Trigger Set ", ret)
-
+        dt.add('event trigger set')
         err, ret = self._xps.EventExtendedConfigurationActionSet(self._sid,
                                                             ('GatheringOneData',),
                                                             ('',), ('',),('',),('',))
         self.check_error(err, msg="EventConfigAction")
         if verbose:
             print( " EventExtended Action  Set ", ret)
-
+        dt.add('event action set')
         eventID, m = self._xps.EventExtendedStart(self._sid)
         self.traj_state = RUNNING
 
         if verbose:
             print( " EventExtended ExtendedStart ", eventID, m)
-
+        dt.add('event start')
         err, ret = self._xps.MultipleAxesPVTExecution(self._sid,
                                                       self.traj_group,
                                                       self.traj_file, 1)
         self.check_error(err, msg="PVT Execute", with_raise=False)
         if verbose:
-            print( " PVT Execute  ", ret)
-
+            print( " PVT Execute done ", ret)
+        dt.add('pvt execute')
         ret = self._xps.EventExtendedRemove(self._sid, eventID)
         ret = self._xps.GatheringStop(self._sid)
-
+        dt.add('gathering stop')
         self.traj_state = COMPLETE
         npulses = 0
         if save:
-            self.read_and_save(output_file, verbose=verbose)
+            npulses, buff = self.read_gathering(set_idle_when_done=False,
+                                                verbose=verbose)
+            dt.add('read gathering')
+            if npulses > 0:
+                self.save_gathering_file(output_file, buff,
+                                         verbose=verbose,
+                                         set_idle_when_done=False)
+                dt.add('saved gathering')
+            self.ngathered = npulses
+            # self.read_and_save(output_file, verbose=verbose)
         self.traj_state = IDLE
+        if verbose:
+            dt.show()
         return npulses
 
     @withConnectedXPS
@@ -965,16 +1178,18 @@ class NewportXPS:
         t0 = time.time()
         while npulses < 1:
             try:
-                ret, npulses, nx = self._xps.GatheringCurrentNumberGet(self._sid)
+                gdat = self._xps.GatheringCurrentNumberGet(self._sid)
             except SyntaxError:
                 print("#XPS Gathering Read failed, will try again")
-                pass
+            if len(gdat) == 3:
+                ret, npulses, nx = gdat
+            if npulses < 1 or ret != 0:
+                time.sleep(0.1)
+
             if time.time()-t0 > 5:
                 print("Failed to get gathering size after 5 seconds: return 0 points")
                 print("Gather Returned: ", ret, npulses, nx, self._xps, time.ctime())
                 return (0, ' \n')
-            if npulses < 1 or ret != 0:
-                time.sleep(0.05)
         dt.add("gather num %d npulses=%d (%d)" % (ret, npulses, self.nsegments))
         counter = 0
         while npulses < 1 and counter < 5:
@@ -986,7 +1201,7 @@ class NewportXPS:
         try:
             ret, buff = self._xps.GatheringDataMultipleLinesGet(self._sid, 0, npulses)
         except ValueError:
-            print("Failed to read gathering: ", ret, buff)
+            print("Failed to read gathering: ", ret)
             return (0, ' \n')
         dt.add("gather after multilinesget  %d" % ret)
         nchunks = -1
@@ -1032,7 +1247,7 @@ class NewportXPS:
         f.close()
         nlines = len(buff.split('\n')) - 1
         if verbose:
-            print('Wrote %i lines, %i bytes to %s' % (nlines, len(buff), fname))
+            print(f'Wrote {nlines} lines, {len(buff)} bytes to {fname}')
         if set_idle_when_done:
             self.traj_state = IDLE
 
@@ -1063,7 +1278,7 @@ class NewportXPS:
         if accel_values is None:
             accel_values = []
             for posname in self.traj_positioners:
-                accel = self.stages["%s.%s"%(self.traj_group,  posname)]['max_accel']
+                accel = self.stages[f"{self.traj_group}.{posname}"]['max_accel']
                 accel_values.append(accel)
         accel_values = np.array(accel_values)
 
@@ -1116,11 +1331,8 @@ class NewportXPS:
         for ind, positioner in enumerate(self.traj_positioners):
             self.trajectories[name][positioner + 'ramp'] = ramp[ind]
 
-        ret = False
         try:
             self.upload_trajectory(name + '.trj', trajectory_str)
-            ret = True
-            # print('Trajectory File uploaded.')
         except:
             print('Failed to upload trajectory file')
 
@@ -1131,10 +1343,9 @@ class NewportXPS:
         """run trajectory in PVT mode"""
         traj = self.trajectories.get(name, None)
         if traj is None:
-            print('Cannot find trajectory named %s' % name)
-            return
+            raise XPSException(f'Cannot find trajectory named {name}')
 
-        traj_file = '%s.trj' % name
+        traj_file = f'{name}.trj'
         dtime = traj['pulse_time']
         ramps = []
         for positioner in self.traj_positioners:
@@ -1148,51 +1359,42 @@ class NewportXPS:
 
         self._xps.GroupMoveRelative(self._sid, self.traj_group, ramps)
 
-        # self.gather_outputs = []
-        ##  gather_titles = []
-
-        # for positioner in self.traj_positioners:
-        #     for out in self.gather_outputs:
-        #         self.gather_outputs.append('%s.%s.%s' % (self.traj_group, positioner, out))
-        #        gather_titles.append('%s.%s' % (positioner, out))
-        ## self.gather_titles = "%s\n#%s\n" % (xps_config['GATHER TITLES'],
-        ##                                     "  ".join(gather_titles))
-
         outputs = []
         for out in self.gather_outputs:
-            for i, ax in enumerate(traj['axes']):
-                outputs.append('%s.%s.%s' % (self.traj_group, ax, out))
-                # move_kws[ax] = float(traj['start'][i])
-
-        end_segment = traj['nsegments'] - 1 + self.extra_triggers
-        # self.move_group(self.traj_group, **move_kws)
-        self.gather_titles = "%s\n#%s\n" % (self.gather_header, " ".join(outputs))
+            for ax in traj['axes']:
+                outputs.append(f'{self.traj_group}.{ax}.{out}')
 
+        o = " ".join(outputs)
+        self.gather_titles = f"{self.gather_header}\n#{o}\n"
         self._xps.GatheringReset(self._sid)
         self._xps.GatheringConfigurationSet(self._sid, self.gather_outputs)
 
-        # print("step_number", step_number)
-        ret = self._xps.MultipleAxesPVTPulseOutputSet(self._sid, self.traj_group,
-                                                      2, step_number + 1, dtime)
-        ret = self._xps.MultipleAxesPVTVerification(self._sid, self.traj_group, traj_file)
+        err, ret = self._xps.MultipleAxesPVTPulseOutputSet(self._sid, self.traj_group,
+                                                           2, step_number + 1, dtime)
+        self.check_error(err, msg="MultipleAxesPVTPulseOutputSet", with_raise=False)
+
+        err, _ = self._xps.MultipleAxesPVTVerification(self._sid, self.traj_group, traj_file)
+        self.check_error(err, msg="MultipleAxesPVTVerification", with_raise=False)
 
         buffer = ('Always', self.traj_group + '.PVT.TrajectoryPulse')
-        o = self._xps.EventExtendedConfigurationTriggerSet(self._sid, buffer,
-                                                          ('0', '0'), ('0', '0'),
-                                                          ('0', '0'), ('0', '0'))
+        err, ret = self._xps.EventExtendedConfigurationTriggerSet(self._sid, buffer,
+                                                                  ('0', '0'), ('0', '0'),
+                                                                  ('0', '0'), ('0', '0'))
+        self.check_error(err, msg="EventExtendedConfigurationTriggerSet", with_raise=False)
 
-        o = self._xps.EventExtendedConfigurationActionSet(self._sid, ('GatheringOneData',),
-                                                         ('',), ('',), ('',), ('',))
+        err, ret = self._xps.EventExtendedConfigurationActionSet(self._sid, ('GatheringOneData',),
+                                                                 ('',), ('',), ('',), ('',))
+        self.check_error(err, msg="EventExtendedConfigurationActionSet", with_raise=False)
 
-        eventID, m = self._xps.EventExtendedStart(self._sid)
+        eventID, _ = self._xps.EventExtendedStart(self._sid)
 
-        ret = self._xps.MultipleAxesPVTExecution(self._sid, self.traj_group, traj_file, 1)
-        o = self._xps.EventExtendedRemove(self._sid, eventID)
-        o = self._xps.GatheringStop(self._sid)
+        self._xps.MultipleAxesPVTExecution(self._sid, self.traj_group, traj_file, 1)
+        self._xps.EventExtendedRemove(self._sid, eventID)
+        self._xps.GatheringStop(self._sid)
 
         npulses = 0
         if save:
-            npulses, outbuff = self.read_and_save(outfile)
+            npulses, _ = self.read_and_save(outfile)
 
         self._xps.GroupMoveRelative(self._sid, self.traj_group, ramps)
         return npulses
@@ -1200,7 +1402,6 @@ class NewportXPS:
 
 
 if __name__ == '__main__':
-    import sys
     ipaddr = sys.argv[1]
     x = NewportXPS(ipaddr)
     x.read_systemini()