From 2d1e22768b59144872c40d3332f1a41b4d6580ab Mon Sep 17 00:00:00 2001 From: x03daop Date: Thu, 16 Feb 2017 16:28:33 +0100 Subject: [PATCH] Startup --- script/FocusXRotScan.py | 45 ++++++++ script/MonoThetaBetaScan.py | 33 ++++++ script/staff/HbnPhdScript.py | 48 ++++++++ script/users/EmpaMarco.py | 22 ++++ script/users/FeCrXPS.py | 120 ++++++++++++++++++++ script/users/HoloScan-MilosB.py | 54 +++++++++ script/users/SchofieldScan.py | 190 ++++++++++++++++++++++++++++++++ script/users/Schofield_XPS.py | 188 +++++++++++++++++++++++++++++++ script/users/catch_up.py | 142 ++++++++++++++++++++++++ 9 files changed, 842 insertions(+) create mode 100644 script/FocusXRotScan.py create mode 100644 script/MonoThetaBetaScan.py create mode 100644 script/staff/HbnPhdScript.py create mode 100644 script/users/EmpaMarco.py create mode 100644 script/users/FeCrXPS.py create mode 100644 script/users/HoloScan-MilosB.py create mode 100644 script/users/SchofieldScan.py create mode 100644 script/users/Schofield_XPS.py create mode 100644 script/users/catch_up.py diff --git a/script/FocusXRotScan.py b/script/FocusXRotScan.py new file mode 100644 index 00000000..4070b248 --- /dev/null +++ b/script/FocusXRotScan.py @@ -0,0 +1,45 @@ +""" +Focusing mirror Rx scan +to center the beam on the monochromator grating +Rx = -20...+20 +set the front end to 0.5 x 0.5, exit slit to 25, photon energy to 1500 +""" + +import math + +# adjust the following parameters +STARTPOS = (-5.0) +ENDPOS = (+5.0) +STEPS = 0.01 +LATENCY = 1.0 +DWELL = 1.0 +ENDSCAN = False + +MOTORS = [FocusXRot] +SENSORS = [SampleCurrent, RefCurrent, MachineCurrent, OpticsCameraCentroidX, OpticsCameraSigmaX] +RELATIVE = False + +value = DWELL * 10.0 +SampleCurrentAveraging.write(value) +RefCurrentAveraging.write(value) + +SampleCurrentGain.write("L, 10^9") +RefCurrentGain.write("L, 10^9") + +# front end size includes offset! +FrontendHSize.write(1.0) +FrontendVSize.write(0.9) +ExitSlit.write(25.0) + +adjust_sensors() +set_adc_averaging() + +def trig(): + wait_beam() + caput("X03DA-OP-10ADC:TRG.PROC", 1) + +try: + lscan(MOTORS, SENSORS, STARTPOS, ENDPOS, STEPS, LATENCY, RELATIVE, before_read=trig, after_read = after_readout) +finally: + if ENDSCAN: + after_scan() diff --git a/script/MonoThetaBetaScan.py b/script/MonoThetaBetaScan.py new file mode 100644 index 00000000..74164ed9 --- /dev/null +++ b/script/MonoThetaBetaScan.py @@ -0,0 +1,33 @@ +""" +TEST: OTF scan for mono calibration + +under development - does not run yet + +tasks: +- find out positioner of beta angle and set up device (must be of motor class). +- load table of scan positions. +- add outer theta loop. +""" + +MOTORS = (MonoBeta) +SENSORS = (SampleCurrent, RefCurrent, MachineCurrent) +STARTPOS = (beta1) +ENDPOS = (beta2) +TIME = 120.0 # seconds +STEPS = 1000 +RELATIVE = False +ENDSCAN = False + +adjust_sensors() +set_adc_averaging() + +def trig_sensors(): + caput("X03DA-OP-10ADC:TRG.PROC", 1) + +try: + wait_beam() + cscan(MOTORS, SENSORS, STARTPOS, ENDPOS, STEPS, time = TIME, relative = RELATIVE, before_read = trig_sensors) +finally: + if ENDSCAN: + after_scan() + diff --git a/script/staff/HbnPhdScript.py b/script/staff/HbnPhdScript.py new file mode 100644 index 00000000..46401237 --- /dev/null +++ b/script/staff/HbnPhdScript.py @@ -0,0 +1,48 @@ +""" +Arguments: + +VECTOR (Double[][], Scan vector: Eph,Elow,Ehigh or Eph,Ecenter) +SENSORS (list) +LATENCY (double) +MODE ('fixed' or 'swept') +TYPE ('CIS' or 'CFS') +STEP (double) +""" + +global VECTOR, SENSORS + +MODE = "swept" +LATENCY = 2.0 +SENSORS = [Counts, Scienta.dataMatrix, SampleCurrent, RefCurrent, MachineCurrent] + +Scienta.setAcquisitionMode(ch.psi.pshell.epics.Scienta.AcquisitionMode.Swept) +writables = (Eph, Scienta.lowEnergy, Scienta.highEnergy) + +adjust_sensors() +SampleCurrentAveraging.write(600) +RefCurrentAveraging.write(600) +set_preference(Preference.PLOT_TYPES, {'Scienta spectrum':1}) + +try: + # N-B + VECTOR = [[425.0 + i * 2.5, 19.0 + i * 2.5, 29.0 + i * 2.5] for i in range(121)] + #ManipulatorPhi.move(+21.1) + #ManipulatorTilt.move(+0.5) + #Scienta.getStepTime().write(0.824) + #print VECTOR + #vscan(writables, SENSORS, VECTOR, True, LATENCY, False, before_read=before_readout, after_read = after_readout) + + # N-N + #ManipulatorPhi.move(-8.9) + #ManipulatorTilt.move(+0.5) + #Scienta.getStepTime().write(0.824) + #vscan(writables, SENSORS, VECTOR, True, LATENCY, False, before_read=before_readout, after_read = after_readout) + + # B-Cu + VECTOR = [[218.0 + i * 2.5, 19.0 + i * 2.5, 29.0 + i * 2.5] for i in range(121)] + ManipulatorPhi.move(-8.9) + ManipulatorTilt.move(+25.5) + Scienta.getStepTime().write(1.47) + vscan(writables, SENSORS, VECTOR, True, LATENCY, False, before_read=before_readout, after_read = after_readout) +finally: + after_scan() diff --git a/script/users/EmpaMarco.py b/script/users/EmpaMarco.py new file mode 100644 index 00000000..103ac831 --- /dev/null +++ b/script/users/EmpaMarco.py @@ -0,0 +1,22 @@ +set_adc_averaging() + +ENERGY_LOW = 136.5 +ENERGY_HIGH = 351.0 +SETTLING_TIME = 0.0 +STEPS = 1000 +SENSORS = [Counts, MachineCurrent, SampleCurrent, RefCurrent, EnergyDistribution, Scienta.getDataMatrix()] + + +setup_plotting(line_plots = (Counts, MachineCurrent, SampleCurrent, RefCurrent,)) +try: + ascan( [dummy,Scienta.getCenterEnergy()], + SENSORS, + [0.0, ENERGY_HIGH], + [0.001 * STEPS, ENERGY_LOW], + [STEPS, 1], + latency = SETTLING_TIME, + before_read = before_readout, after_read = after_readout) +finally: + if ENDSCAN: + after_scan() + \ No newline at end of file diff --git a/script/users/FeCrXPS.py b/script/users/FeCrXPS.py new file mode 100644 index 00000000..79a66535 --- /dev/null +++ b/script/users/FeCrXPS.py @@ -0,0 +1,120 @@ + +#Parameters (global variables): +# ranges: list of RangeSelection havinf args = (step_size, step_time, iterations) +# pass_energy +# save_scienta_image +# +# skip_iteration: if set to 1 then skips after end of current iteration + +global ranges, pass_energy, skip_iteration, ENDSCAN + +ranges = [] +# (eph, min, max, step, time, iter) +ranges.append((1300.0, 577.0, 593.0, 0.1, 0.2, 1700)) +ranges.append((1300.0, 713.0, 722.0, 0.1, 0.2, 1000)) +ranges.append((1300.0, 1294.5, 1297.0, 0.02, 1, 2)) +pass_energy = 50 +skip_iteration = False +ENDSCAN = True + +from ch.psi.pshell.data.LayoutDefault import ATTR_WRITABLE_DIMENSION as ATTR_WRITABLE_DIMENSION + +cur_range = 0 +cur_iteration = 0 + +Scienta.acquisitionMode = Scienta.AcquisitionMode.Swept +ret=[] + +set_exec_pars(open = True) + +#Global arguments +Scienta.passEnergy = pass_energy + +names=[] +names.append("Online Spectrum") +for i in range(len(ranges)): + names.append(str(ranges[i][0])) +plots = plot(None, names) +spectrum_series = plots[0].getSeries(0) +def plot_cur_spectrum(): + global spectrum_series + try: + while get_context().state.running: + y = Scienta.spectrum.take(100) + x = Scienta.spectrumX + spectrum_series.setData(x, y) + time.sleep(1.0) + finally: + print "Stopping spectrum plotting" +task = None + +try: + for cur_range in range(len(ranges)): + cur_iteration = 0 + skip_iteration = False + params = ranges[cur_range] + Eph.move(params[0]) + time.sleep(5.0) + Scienta.lowEnergy.write(params[1]) + Scienta.highEnergy.write(params[2]) + Scienta.update() + + Scienta.stepSize.write(params[3]) + Scienta.stepTime.write(params[4]) + Scienta.setIterations(1) + + set_adc_averaging() + + #iterations done in script + xdata = None + ydata = None + image_data = None + task = fork(plot_cur_spectrum) + + path="scan" + str(cur_range+1) + "/" + for cur_iteration in range(params[5]): + plots[cur_range+1].setTitle(str(params[0]) + " - iteration " + str(cur_iteration+1)) + while True: + wait_beam() + trig_scienta() + spectrum_array = Scienta.spectrum.read() + if beam_ok: + break + if ydata is None: + ydata = spectrum_array + else: + for k in range (len(spectrum_array)): + ydata[k] = ydata[k] + spectrum_array[k] + if xdata is None: + xdata = Scienta.spectrumX + plots[cur_range+1].getSeries(0).setData(xdata, ydata) + if skip_iteration: + break + save_dataset(path + "ScientaSpectrum", ydata) + set_attribute(path, "Iterations",cur_iteration+1) + if cur_iteration==0: + save_dataset(path + "ScientaChannels", xdata) + set_attribute(path + "ScientaChannels", ATTR_WRITABLE_DIMENSION, 1) + set_attribute(path, "Range Low", params[1]) + set_attribute(path, "Range High", params[2]) + set_attribute(path, "Step Time", params[4]) + set_attribute(path, "Step Size", params[3]) + set_attribute(path, "Pass Energy", pass_energy) + set_attribute(path, "Readables", ["ScientaSpectrum",]) + set_attribute(path, "Writables", ["ScientaChannels",]) + create_diag_datasets(path) + append_diag_datasets(path) + + plots[cur_range+1].setTitle(str(params[0])) + ret.append((xdata, ydata)) + +finally: + cur_range = -1 + if not Scienta.isReady(): + Scienta.stop() + Scienta.update() + task[0].cancel(True) + if ENDSCAN: + after_scan() + +set_return(to_array(ret,'o')) \ No newline at end of file diff --git a/script/users/HoloScan-MilosB.py b/script/users/HoloScan-MilosB.py new file mode 100644 index 00000000..31832ec9 --- /dev/null +++ b/script/users/HoloScan-MilosB.py @@ -0,0 +1,54 @@ +""" +Arguments: + +SENSORS (list) +PHI_RANGE (tuple (min, max)) +THETA_RANGE (tuple (min, max)) +STEPS (tuple (phi, theta)) +LATENCY (double) +RELATIVE (BOOLEAN) +ZIGZAG (BOOLEAN) +""" +import math +global VECTOR, SENSORS + +MODE = "swept" +LATENCY = 0.0 +SENSORS = [Counts, Scienta.dataMatrix, SampleCurrent, RefCurrent, MachineCurrent] + +Scienta.setAcquisitionMode(ch.psi.pshell.epics.Scienta.AcquisitionMode.Swept) +writables = (ManipulatorPhi, ManipulatorTheta, ManipulatorX, ManipulatorY) + +adjust_sensors() +SampleCurrentAveraging.write(1660) +RefCurrentAveraging.write(1660) +set_preference(Preference.PLOT_TYPES, {'Scienta spectrum':1}) + +try: + # N-B + #VECTOR = [[425.0 + i * 2.5, 19.0 + i * 2.5, 29.0 + i * 2.5] for i in range(121)] + #ManipulatorPhi.move(+21.1) + #ManipulatorTilt.move(+0.5) + #Scienta.getStepTime().write(0.824) + #print VECTOR + #vscan(writables, SENSORS, VECTOR, True, LATENCY, False, before_read=before_readout, after_read = after_readout) + + # N-N + #ManipulatorPhi.move(-8.9) + #ManipulatorTilt.move(+0.5) + #Scienta.getStepTime().write(0.824) + #vscan(writables, SENSORS, VECTOR, True, LATENCY, False, before_read=before_readout, after_read = after_readout) + + # B-Cu + phi = [int(i/46)*36.0-165.0 for i in range(460)] + theta = [(i%46)*2.0-9.0 for i in range(460)] + x = [2.37*math.cos((th+9.0)*math.pi/180.0)-2.67 for th in theta] + y = [2.37*math.sin((th+9.0)*math.pi/180.0)-0.2 for th in theta] + #VECTOR = [phi, theta, x, y] + VECTOR = [[phi[i], theta[i], x[i], y[i]] for i in range(460)] + # ManipulatorPhi.move(-8.9) + #ManipulatorTilt.move(+25.5) + #Scienta.getStepTime().write(1.47) + vscan(writables, SENSORS, VECTOR, True, LATENCY, False, before_read=before_readout, after_read = after_readout) +finally: + after_scan() diff --git a/script/users/SchofieldScan.py b/script/users/SchofieldScan.py new file mode 100644 index 00000000..c97ca719 --- /dev/null +++ b/script/users/SchofieldScan.py @@ -0,0 +1,190 @@ +""" +Arguments: + +VECTOR (Double[][], Scan vector: Eph,Elow,Ehigh or Eph,Ecenter) +SENSORS (list) +LATENCY (double) +MODE ('fixed' or 'swept') +TYPE ('CIS' or 'CFS') +STEP (double) +""" + +LATENCY = 0.0 + + +class SpectrumReader(ReadonlyRegisterBase, ReadonlyRegisterArray): + def doRead(self): + global VECTOR + self.offset = Eph.getSetpoint().take() - VECTOR[0] + self.setup() + trig_scienta() + time.sleep(0.5) + return Scienta.getSpectrum().read() + + def getSize(self): + return len(Scienta.getSpectrumX()) + + + +class SpectrumReader1(SpectrumReader): + def setup(self): + global energy_scale_array, initial_energy_range + Scienta.getLowEnergy().write(initial_energy_range[0][0] + self.offset) + Scienta.getHighEnergy().write(initial_energy_range[0][1] + self.offset) + Scienta.getStepSize().write(initial_energy_range[0][2]) + energy_scale_array = [Scienta.getLowEnergy().take(), Scienta.getHighEnergy().take(), Scienta.getStepSize().take()] + +class SpectrumReader2(SpectrumReader): + def setup(self): + global energy_scale_array, initial_energy_range + Scienta.getLowEnergy().write(initial_energy_range[1][0] + self.offset) + Scienta.getHighEnergy().write(initial_energy_range[1][1] + self.offset) + Scienta.getStepSize().write(initial_energy_range[1][2]) + energy_scale_array = energy_scale_array + [Scienta.getLowEnergy().take(), Scienta.getHighEnergy().take(), Scienta.getStepSize().take()] + append_dataset(energy_scale_table,energy_scale_array) + +class SpectrumReader3(SpectrumReader): + def setup(self): + global initial_energy_range,energy_scale_array, energy_scale_table + Scienta.getLowEnergy().write(initial_energy_range[2][0] + self.offset) + Scienta.getHighEnergy().write(initial_energy_range[2][1] + self.offset) + Scienta.getStepSize().write(initial_energy_range[2][2]) + energy_scale_array = energy_scale_array + [Scienta.getLowEnergy().take(), Scienta.getHighEnergy().take(), Scienta.getStepSize().take()] + append_dataset(energy_scale_table,energy_scale_array) + + +class ImageReader(ReadonlyRegisterBase, ReadonlyRegisterMatrix): + def doRead(self): + return Scienta.getDataMatrix().read() + + def getWidth(self): + global initial_energy_range + return int( (initial_energy_range[self.index][1] - initial_energy_range[self.index][0]) / initial_energy_range[self.index][2]) + + def getHeight(self): + return Scienta.getDataMatrix().getHeight() + + +def measure_stuff(): + global energy_scale_array, energy_scale_table, VECTOR,pass_energy_hold,angle_time,angle_range,azi_range,bb + reader1 = SpectrumReader1(); reader1.initialize() + reader2 = SpectrumReader2(); reader2.initialize() + #reader3 = SpectrumReader3(); reader3.initialize() + image1 = ImageReader(); image1.initialize(); image1.index=0; set_device_alias(image1, "Image1") + image2 = ImageReader(); image2.initialize(); image2.index=1; set_device_alias(image2, "Image2") + #image3 = ImageReader(); image3.initialize(); image3.index=2; set_device_alias(image3, "Image3") + + + Scienta.getDataMatrix() + + SENSORS = [RefCurrent, reader1, image1, reader2, image2]#, reader3, image3] + + Scienta.setAcquisitionMode(ch.psi.pshell.epics.Scienta.AcquisitionMode.Swept) + + + adjust_sensors() + set_adc_averaging() + set_preference(Preference.PLOT_TYPES, {'Scienta spectrum':1}) + + for ll in range(len(azi_range)): + ManipulatorPhi.move(azi_range[ll]) + for jj in range(len(angle_range)): + tic = time.time() + ManipulatorTheta.move(angle_range[jj]) + print 'current theta is ', ManipulatorTheta.take(), ' and current azimuth is ' , ManipulatorPhi.take() + Scienta.setPassEnergy(pass_energy_hold) + #print ' Flag 1' + Scienta.getStepTime().write(angle_time[jj]) + #print ' Flag 2' + sleep(1) + bb = bb+1 + energy_scale_table = "scan " + str(bb) + "/EnergyScale" + print energy_scale_table + create_dataset(energy_scale_table, 'd', dimensions=[0,9]) + vscan(Eph, SENSORS, VECTOR, True, LATENCY,False, before_read=wait_beam, after_read = after_readout) + toc = time.time() + tictoc = round((toc-tic)/60*100)/100 + print 'time taken is ', tictoc, ' minutes' + +global initial_energy_range,energy_scale_array, energy_scale_table, VECTOR,pass_energy_hold,angle_time,angle_range,azi_range,SENSORS +bb = 0 +SENSORS = [] +#################### O 1s PhD scan ############################## +print ' ######################################################' +print ' ** Begin O 1s PhD **' +tic_whole = time.time() +VECTOR = [ 638.0] +for nn in range(63): + VECTOR.append(VECTOR[-1]+4) + + +pass_energy_hold = 100 + +initial_energy_range = [[95.5, 105.0, 0.1], + [105.1, 115.0, 0.5]] + +angle_time = [0.4, 0.5, 0.6] +energy_scale_array = [] + +azi_range = [-45.0] +angle_range = [-9.2+20.0, -9.2+40.0, -9.2+60.0] +#measure_stuff() + + +toc_whole = time.time() +tictoc = round(toc_whole-tic_whole) +print ' ** End O 1s PhD **' +print ' ** time taken was ', math.floor(tictoc/3600), ' hours and ', round((tictoc-math.floor(tictoc/3600)*3600)/60), ' minutes.' +print ' ######################################################' + +#################### C 1s PhD scan ############################## +print ' ######################################################' +print ' ** Begin C 1s PhD **' +tic_whole = time.time() +VECTOR = [ 340.0] +for nn in range(63): + VECTOR.append(VECTOR[-1]+4) +#nn = 0 + + +initial_energy_range = [[45.0, 53.0, 0.1], + [53.5, 63.0, 0.5]] +pass_energy_hold = 50 +angle_time = [0.4,0.4,0.5] +azi_range = [-90.0, -45.0] +angle_range = [-9.2+30.0, -9.2+60.0] + +measure_stuff() +toc_whole = time.time() +tictoc = round(toc_whole-tic_whole) +print ' ** time taken was ', math.floor(tictoc/3600), ' hours and ', round((tictoc-math.floor(tictoc/3600)*3600)/60), ' minutes.' +print ' ** End C 1s PhD **' +print ' ######################################################' + +#################### Si 2p PhD scan ############################## +print ' ######################################################' +print ' ** Begin Si 2p PhD **' +tic_whole = time.time() +VECTOR = [ 170.0] +for nn in range(63): + VECTOR.append(VECTOR[-1]+4) +#nn = 0 + + +initial_energy_range = [[62.0, 67.0, 0.1], + [67.5, 77, 0.5]] +pass_energy_hold = 20 +angle_time = [0.4,0.4,0.5] +azi_range = [-90.0,-45.0] +angle_range = [-9.2, -9.2+30.0, -9.2+60.0] + +measure_stuff() +toc_whole = time.time() +tictoc = round(toc_whole-tic_whole) +print ' ** time taken was ', math.floor(tictoc/3600), ' hours and ', round((tictoc-math.floor(tictoc/3600)*3600)/60), ' minutes.' +print ' ** End Si 2p PhD **' +print ' ######################################################' + + +#toc = time.time() + diff --git a/script/users/Schofield_XPS.py b/script/users/Schofield_XPS.py new file mode 100644 index 00000000..11ae9cff --- /dev/null +++ b/script/users/Schofield_XPS.py @@ -0,0 +1,188 @@ +""" +Arguments: + +VECTOR (Double[][], Scan vector: Eph,Elow,Ehigh or Eph,Ecenter) +SENSORS (list) +LATENCY (double) +MODE ('fixed' or 'swept') +TYPE ('CIS' or 'CFS') +STEP (double) +""" + +LATENCY = 0.0 + + +class SpectrumReader(ReadonlyRegisterBase, ReadonlyRegisterArray): + def doRead(self): + global VECTOR + self.offset = Eph.getSetpoint().take() - VECTOR[0] + self.setup() + trig_scienta() + time.sleep(0.5) + return Scienta.getSpectrum().read() + + def getSize(self): + return len(Scienta.getSpectrumX()) + + + +class SpectrumReader1(SpectrumReader): + def setup(self): + global energy_scale_array, initial_energy_range + Scienta.getLowEnergy().write(initial_energy_range[0][0] + self.offset) + Scienta.getHighEnergy().write(initial_energy_range[0][1] + self.offset) + Scienta.getStepSize().write(initial_energy_range[0][2]) + energy_scale_array = [Scienta.getLowEnergy().take(), Scienta.getHighEnergy().take(), Scienta.getStepSize().take()] + append_dataset(energy_scale_table,energy_scale_array) + + +class ImageReader(ReadonlyRegisterBase, ReadonlyRegisterMatrix): + def doRead(self): + return Scienta.getDataMatrix().read() + + def getWidth(self): + global initial_energy_range + return int( (initial_energy_range[self.index][1] - initial_energy_range[self.index][0]) / initial_energy_range[self.index][2]) + + def getHeight(self): + return Scienta.getDataMatrix().getHeight() + + +def measure_stuff(): + global energy_scale_array, energy_scale_table, VECTOR,pass_energy_hold,angle_time,angle_range,azi_range,bb + reader1 = SpectrumReader1(); reader1.initialize() + #reader2 = SpectrumReader2(); reader2.initialize() + #reader3 = SpectrumReader3(); reader3.initialize() + image1 = ImageReader(); image1.initialize(); image1.index=0; set_device_alias(image1, "Image1") + #image2 = ImageReader(); image2.initialize(); image2.index=1; set_device_alias(image2, "Image2") + #image3 = ImageReader(); image3.initialize(); image3.index=2; set_device_alias(image3, "Image3") + + + Scienta.getDataMatrix() + + SENSORS = [RefCurrent, reader1, image1]#, reader2, image2]#, reader3, image3] + + Scienta.setAcquisitionMode(ch.psi.pshell.epics.Scienta.AcquisitionMode.Swept) + + bb = bb+1 + energy_scale_table = "scan " + str(bb) + "/EnergyScale" + print energy_scale_table + create_dataset(energy_scale_table, 'd', dimensions=[0,3]) + + + adjust_sensors() + set_adc_averaging() + set_preference(Preference.PLOT_TYPES, {'Scienta spectrum':1}) + + tic = time.time() + #print ' Flag 1' + Scienta.getStepTime().write(angle_time[0]) + #print ' Flag 2' + sleep(1) + vscan(Eph, SENSORS, VECTOR, True, LATENCY,False, before_read=wait_beam, after_read = after_readout) + toc = time.time() + tictoc = round((toc-tic)/60*100)/100 + print 'time taken is ', tictoc, ' minutes' + +global initial_energy_range,energy_scale_array, energy_scale_table, VECTOR,pass_energy_hold,angle_time,angle_range,azi_range,SENSORS +bb = 0 +SENSORS = [] +#################### C 1s XPS scan ############################## +print ' ######################################################' +print ' ** Begin C 1s XPS **' +tic_whole = time.time() +VECTOR = [ 450.0] +#for nn in range(63): +# VECTOR.append(VECTOR[-1]+4) + + +#pass_energy_hold = 100 + +initial_energy_range = [[155., 165., 0.05]] + +angle_time = [0.5] +energy_scale_array = [] +measure_stuff() +initial_energy_range = [[344.,348., 0.05]] + +angle_time = [0.5] +energy_scale_array = [] +measure_stuff() +toc_whole = time.time() +tictoc = round(toc_whole-tic_whole) +print ' ** End C 1s XPS **' +print ' ** time taken was ', math.floor(tictoc/3600), ' hours and ', round((tictoc-math.floor(tictoc/3600)*3600)/60), ' minutes.' +print ' ######################################################' +#################### Overview scan ############################## +print ' ######################################################' +print ' ** Begin Overview XPS **' +tic_whole = time.time() +VECTOR = [ 800.0] +#for nn in range(63): +# VECTOR.append(VECTOR[-1]+4) + + +#pass_energy_hold = 100 + +initial_energy_range = [[100., 805., 0.5]] + +angle_time = [0.5] +energy_scale_array = [] +measure_stuff() + +toc_whole = time.time() +tictoc = round(toc_whole-tic_whole) +print ' ** End Overview XPS **' +print ' ** time taken was ', math.floor(tictoc/3600), ' hours and ', round((tictoc-math.floor(tictoc/3600)*3600)/60), ' minutes.' +print ' ######################################################' +#################### O 1s XPS scan ############################## +print ' ######################################################' +print ' ** Begin O 1s XPS **' +tic_whole = time.time() +VECTOR = [ 650.0] +#for nn in range(63): +# VECTOR.append(VECTOR[-1]+4) + + +#pass_energy_hold = 100 + +initial_energy_range = [[108., 119., 0.05]] + +angle_time = [0.1] +energy_scale_array = [] +measure_stuff() +initial_energy_range = [[544.,548., 0.05]] + +angle_time = [0.1] +energy_scale_array = [] +measure_stuff() +toc_whole = time.time() +tictoc = round(toc_whole-tic_whole) +print ' ** End O 1s XPS **' +print ' ** time taken was ', math.floor(tictoc/3600), ' hours and ', round((tictoc-math.floor(tictoc/3600)*3600)/60), ' minutes.' +print ' ######################################################' + + + + +#################### Si 2p XPS scan ############################## +print ' ######################################################' +print ' ** Begin Si 2p XPS **' +tic_whole = time.time() +VECTOR = [ 200.] +#for nn in range(63): +# VECTOR.append(VECTOR[-1]+4) + + +#pass_energy_hold = 100 + +initial_energy_range = [[93., 98., 0.05]] + +angle_time = [0.1] +energy_scale_array = [] +measure_stuff() + +print ' ** End Si 2p XPS **' +print ' ** time taken was ', math.floor(tictoc/3600), ' hours and ', round((tictoc-math.floor(tictoc/3600)*3600)/60), ' minutes.' +print ' ######################################################' + diff --git a/script/users/catch_up.py b/script/users/catch_up.py new file mode 100644 index 00000000..f6690c70 --- /dev/null +++ b/script/users/catch_up.py @@ -0,0 +1,142 @@ +""" +Arguments: + +VECTOR (Double[][], Scan vector: Eph,Elow,Ehigh or Eph,Ecenter) +SENSORS (list) +LATENCY (double) +MODE ('fixed' or 'swept') +TYPE ('CIS' or 'CFS') +STEP (double) +""" + +LATENCY = 0.0 + + +class SpectrumReader(ReadonlyRegisterBase, ReadonlyRegisterArray): + def doRead(self): + global VECTOR + self.offset = Eph.getSetpoint().take() - VECTOR[0] + self.setup() + trig_scienta() + time.sleep(0.5) + return Scienta.getSpectrum().read() + + def getSize(self): + return len(Scienta.getSpectrumX()) + + + +class SpectrumReader1(SpectrumReader): + def setup(self): + global energy_scale_array, initial_energy_range + Scienta.getLowEnergy().write(initial_energy_range[0][0] + self.offset) + Scienta.getHighEnergy().write(initial_energy_range[0][1] + self.offset) + Scienta.getStepSize().write(initial_energy_range[0][2]) + energy_scale_array = [Scienta.getLowEnergy().take(), Scienta.getHighEnergy().take(), Scienta.getStepSize().take()] + +class SpectrumReader2(SpectrumReader): + def setup(self): + global energy_scale_array, initial_energy_range + Scienta.getLowEnergy().write(initial_energy_range[1][0] + self.offset) + Scienta.getHighEnergy().write(initial_energy_range[1][1] + self.offset) + Scienta.getStepSize().write(initial_energy_range[1][2]) + energy_scale_array = energy_scale_array + [Scienta.getLowEnergy().take(), Scienta.getHighEnergy().take(), Scienta.getStepSize().take()] + append_dataset(energy_scale_table,energy_scale_array) + +class SpectrumReader3(SpectrumReader): + def setup(self): + global initial_energy_range,energy_scale_array, energy_scale_table + Scienta.getLowEnergy().write(initial_energy_range[2][0] + self.offset) + Scienta.getHighEnergy().write(initial_energy_range[2][1] + self.offset) + Scienta.getStepSize().write(initial_energy_range[2][2]) + energy_scale_array = energy_scale_array + [Scienta.getLowEnergy().take(), Scienta.getHighEnergy().take(), Scienta.getStepSize().take()] + append_dataset(energy_scale_table,energy_scale_array) + + +class ImageReader(ReadonlyRegisterBase, ReadonlyRegisterMatrix): + def doRead(self): + return Scienta.getDataMatrix().read() + + def getWidth(self): + global initial_energy_range + return int( (initial_energy_range[self.index][1] - initial_energy_range[self.index][0]) / initial_energy_range[self.index][2]) + + def getHeight(self): + return Scienta.getDataMatrix().getHeight() + + +def measure_stuff(): + global energy_scale_array, energy_scale_table, VECTOR,pass_energy_hold,angle_time,angle_range,azi_range,bb + reader1 = SpectrumReader1(); reader1.initialize() + reader2 = SpectrumReader2(); reader2.initialize() + #reader3 = SpectrumReader3(); reader3.initialize() + image1 = ImageReader(); image1.initialize(); image1.index=0; set_device_alias(image1, "Image1") + image2 = ImageReader(); image2.initialize(); image2.index=1; set_device_alias(image2, "Image2") + #image3 = ImageReader(); image3.initialize(); image3.index=2; set_device_alias(image3, "Image3") + + + Scienta.getDataMatrix() + + SENSORS = [RefCurrent, reader1, image1, reader2, image2]#, reader3, image3] + + Scienta.setAcquisitionMode(ch.psi.pshell.epics.Scienta.AcquisitionMode.Swept) + + + adjust_sensors() + set_adc_averaging() + set_preference(Preference.PLOT_TYPES, {'Scienta spectrum':1}) + + for ll in range(len(azi_range)): + ManipulatorPhi.move(azi_range[ll]) + for jj in range(len(angle_range)): + tic = time.time() + ManipulatorTheta.move(angle_range[jj]) + print 'current theta is ', ManipulatorTheta.take(), ' and current azimuth is ' , ManipulatorPhi.take() + Scienta.setPassEnergy(pass_energy_hold) + #print ' Flag 1' + Scienta.getStepTime().write(angle_time[jj]) + #print ' Flag 2' + sleep(1) + bb = bb+1 + energy_scale_table = "scan " + str(bb) + "/EnergyScale" + print energy_scale_table + create_dataset(energy_scale_table, 'd', dimensions=[0,9]) + vscan(Eph, SENSORS, VECTOR, True, LATENCY,False, before_read=wait_beam, after_read = after_readout) + toc = time.time() + tictoc = round((toc-tic)/60*100)/100 + print 'time taken is ', tictoc, ' minutes' + +global initial_energy_range,energy_scale_array, energy_scale_table, VECTOR,pass_energy_hold,angle_time,angle_range,azi_range,SENSORS +bb = 0 +SENSORS = [] +#################### O 1s PhD scan ############################## +print ' ######################################################' +print ' ** Begin O 1s PhD **' +tic_whole = time.time() +VECTOR = [ 790.0] +for nn in range(24): + VECTOR.append(VECTOR[-1]+4) + + +pass_energy_hold = 100 + +initial_energy_range = [[247.5, 257.0, 0.1], + [257.1, 167.0, 0.5]] + +angle_time = [0.6] +energy_scale_array = [] + +azi_range = [-90.0] +angle_range = [-9.2+40.0] +measure_stuff() +toc_whole = time.time() +tictoc = round(toc_whole-tic_whole) +print ' ** End O 1s PhD **' +print ' ** time taken was ', math.floor(tictoc/3600), ' hours and ', round((tictoc-math.floor(tictoc/3600)*3600)/60), ' minutes.' +print ' ######################################################' + + + + +#toc = time.time() +