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

newportxps/newportxps.py

@@ -1,11 +1,10 @@
  #!/usr/bin/env python
 
-import os
 import posixpath
 import sys
 import time
 import socket
-from io import StringIO
+from copy import deepcopy
 from configparser import  ConfigParser
 import numpy as np
 
@@ -75,11 +74,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,14 +88,13 @@ 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)
 
 
@@ -105,7 +104,7 @@ class NewportXPS:
         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
@@ -119,19 +118,16 @@ 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 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,7 +165,7 @@ 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():
@@ -202,13 +198,13 @@ class NewportXPS:
                 self.stages[sname]['max_velo']  = ret[1]
                 self.stages[sname]['max_accel'] = ret[2]/3.0
             except:
-                print("could not set max velo/accel for %s" % sname)
+                print(f"could not set max velo/accel for {name}")
             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 set limits for {sname}")
 
         return self.groups
 
@@ -342,27 +338,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 +378,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 +407,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,7 +423,7 @@ 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):
@@ -448,14 +455,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 +485,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 +556,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 +571,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 +588,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 +608,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:
@@ -671,15 +680,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 +699,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,21 +742,20 @@ 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=0.01,
+                                 scantime=None, start=0, stop=1, step=0.001,
                                  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
 
@@ -767,8 +773,9 @@ 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)
+        if pixeltime is None and scantime is not None:
+            scantime = float(abs(scantime))
+            pixeltime= scantime / (npulses-1)
         scantime = pixeltime*npulses
 
         distance = (abs(stop - start) + abs(step))*1.0
@@ -778,8 +785,10 @@ class NewportXPS:
         rampdist = velocity*ramptime
         offset   = step/2.0 + 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 +806,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 +826,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
                 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.
+
         """
-        set up the trajectory from previously defined, uploaded trajectory
+        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  = '\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):
+        """
+        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:
@@ -898,7 +1088,8 @@ class NewportXPS:
         if self.traj_state != ARMED:
             raise XPSException("Must arm trajectory before running!")
 
-        buffer = ('Always', '%s.PVT.TrajectoryPulse' % self.traj_group,)
+        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'))
@@ -1032,7 +1223,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 +1254,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 +1307,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 +1319,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,47 +1335,39 @@ 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))
+                outputs.append(f'{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))
-
+        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, ret = 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)
 
-        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: