From 97f558dab2bd1960ae5077b602876d70cdc0bac3 Mon Sep 17 00:00:00 2001 From: gac-x03da Date: Wed, 20 Nov 2019 22:58:30 +0100 Subject: [PATCH] Script execution --- script/users/Niels/CBM_VBM_120iter.py | 265 ++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 script/users/Niels/CBM_VBM_120iter.py diff --git a/script/users/Niels/CBM_VBM_120iter.py b/script/users/Niels/CBM_VBM_120iter.py new file mode 100644 index 00000000..e0a31a03 --- /dev/null +++ b/script/users/Niels/CBM_VBM_120iter.py @@ -0,0 +1,265 @@ +""" +Discrete scan (vector scan) of multiple spectral regions +""" + +PHI_RANGE = (-160.0, 160.0) # (tuple (min, max)) +THETA_RANGE = (-9.0, 81.0) # (tuple (min, max)) +STEPS = (40.0, 1.0) # (tuple (phi, theta)) +ZIGZAG = True + +# scan positioner: Eph = photon energy +#MOTORS = (ManipulatorPhi, ManipulatorTheta) +#MOTORS = [ManipulatorPhi] +MOTORS = [dummy] +# comma-separated discrete list of scan positions +#POSITIONS = [(PHI_RA +#POSITIONS = [(PNGE[0], THETA_RANGE[0]), (PHI_RANGE[1], THETA_RANGE[1]), STEPS] +#POSITIONS = [-175., 180., 5.] +POSITIONS = [0.] +# seconds to wait between positioning command and triggering the detector +LATENCY = 0.0 + +# region setup +# +# for each region, define a python dictionary with the following items. +# optional items can be left unspecified and will default to the indicated values. +# for swept mode, include 'elo', 'ehi', 'estep', 'iter' values, but do not include 'efix'. +# for fixed mode, include 'efix' value, but do not include 'elo', 'ehi', 'estep', 'iter'. +# +# 'name': user-specific name of the region (for graph title and RegionName attribute in data file) +# 'elo': lower kinetic energy boundary of the spectrum +# 'ehi': upper kinetic energy boundary of the spectrum +# 'estep': energy step size +# 'efix': center kinetic energy in fixed mode +# 'epass': pass energy +# 'tstep': dwell time in seconds +# 'iter': number of iterations/sweeps (default 1) +# 'cis': True = constant initial state (photoemission line), False = constant final state (Auger peak), (default False) +# 'slit': exit slit (default current value) + +#REGION1 = {'name': 'VB62eV', 'ephot': 62, 'efix': 1222.1, 'epass': 200., 'tstep': 20., 'iter': 1, 'cis': False} +#REGION2 = {'name': 'off-resonance', 'ephot': 1235.0, 'efix': 1219.4, 'epass': 200., 'tstep': 20., 'iter': 1, 'cis': False} +#REGION1 = {'name': 'VB62eV', 'ephot': 62, 'elo': 49.0, 'ehi': 58.0, 'estep': 0.002, 'epass': 10, 'tstep': 0.5, 'iter': 1, 'cis': False} +#REGION1 = {'name': 'VB62eVzoom', 'elo': 54.0, 'ehi': 58.0, 'estep': 0.002, 'epass': 10.0, 'tstep': 0.5, 'iter': 1, 'cis': True} + +# Ephot = 80 eV; if 'ephot' is not specified in the region, it will not be set!! +REG1 = {'name': 'VB1', 'elo': 104.3, 'ehi': 105.5, 'estep': 0.005, 'epass': 10., 'tstep': 1, 'iter': 1, 'cis': False} # 7 minutes +#REG2 = {'name': 'VB2', 'elo': 104.3, 'ehi': 105.5, 'estep': 0.005, 'epass': 10., 'tstep': 0.25, 'iter': 1, 'cis': False} + +def indexed_dict(index): + return {'name': 'VB'+str(index), 'elo': 104.3, 'ehi': 105.6, 'estep': 0.005, 'epass': 10., 'tstep': 0.5, 'iter': 1, 'cis': False} + +# list of region dictionaries to execute at each scan position +#REGIONS = [REG1] + +REGIONS = [indexed_dict(i) for i in range(0,120)] + +# close beam shutter and turn off analyser at the end of the scan +CLOSE_SHUTTER_AT_END = False + + +# --- DO NOT EDIT BELOW THIS LINE! --- + +set_exec_pars(keep=False) + +def check_region(region): + """ + check region dictionary items and apply defaults where necessary + """ + region['fixed'] = 'efix' in region + if region['fixed']: + region['elo'] = region['efix'] + region['ehi'] = region['efix'] + if 'iter' not in region: + region['iter'] = 1 + print("region {0}: setting default iter = {1}".format(region['name'], region['iter'])) + if 'cis' not in region: + region['cis'] = False + print("region {0}: setting default cis = {1}".format(region['name'], region['cis'])) + if 'slit' not in region: + region['slit'] = ExitSlit.read() + print("region {0}: setting default slit = {1}".format(region['name'], region['slit'])) + +class SpectrumReader(ReadonlyRegisterBase, ReadonlyRegisterArray): + def initialize(self): + #super(SpectrumReader, self).initialize() + self.scan_index = -1 + + def create_datasets(self): + path = get_exec_pars().scanPath + self.region_name + "/" + + self.channel_begin_dataset_name = path + "ScientaChannelBegin" + self.channel_end_dataset_name = path + "ScientaChannelEnd" + self.channel_center_dataset_name = path + "ScientaChannelCenter" + self.pass_energy_dataset_name = path + "ScientaPassEnergy" + self.step_energy_dataset_name = path + "ScientaStepEnergy" + self.step_time_dataset_name = path + "ScientaStepTime" + self.iterations_dataset_name = path + "ScientaIterations" + self.slit_dataset_name = path + "ExitSlit" + + create_dataset(self.channel_begin_dataset_name, 'd') + create_dataset(self.channel_end_dataset_name, 'd') + create_dataset(self.channel_center_dataset_name, 'd') + create_dataset(self.pass_energy_dataset_name, 'd') + create_dataset(self.step_energy_dataset_name, 'd') + create_dataset(self.step_time_dataset_name, 'd') + create_dataset(self.iterations_dataset_name, 'd') + create_dataset(self.slit_dataset_name, 'd') + + def setup(self): + if self.scan_index != get_exec_pars().index: + self.scan_index = get_exec_pars().index + self.create_datasets() + if self.region_index == 0: + print "scan {0}".format(self.scan_index) + + #ephot = Eph.read() + #try: + # if self.region['cis']: + # edelta = ephot - self.ephot_start + # else: + # edelta = 0.0 + #except AttributeError: + # self.ephot_start = ephot + edelta = 0.0 + + elo = self.region['elo'] + edelta + ehi = self.region['ehi'] + edelta + + try: + Eph.write(self.region['ephot']) + except KeyError: + pass + + if self.region['fixed']: + Scienta.setAcquisitionMode(ch.psi.pshell.epics.Scienta.AcquisitionMode.Fixed) + Scienta.centerEnergy.write(elo) + else: + Scienta.setAcquisitionMode(ch.psi.pshell.epics.Scienta.AcquisitionMode.Swept) + Scienta.lowEnergy.write(elo) + Scienta.highEnergy.write(ehi) + Scienta.stepSize.write(self.region['estep']) + + Scienta.setPassEnergy(int(self.region['epass'])) + Scienta.stepTime.write(self.region['tstep']) + Scienta.setIterations(self.region['iter']) + ExitSlit.write(self.region['slit']) + Scienta.update() + + if self.region['fixed']: + append_dataset(self.channel_center_dataset_name, elo) + else: + append_dataset(self.channel_begin_dataset_name, elo) + append_dataset(self.channel_end_dataset_name, ehi) + append_dataset(self.step_energy_dataset_name, self.region['estep']) + + append_dataset(self.pass_energy_dataset_name, self.region['epass']) + append_dataset(self.step_time_dataset_name, self.region['tstep']) + append_dataset(self.iterations_dataset_name, self.region['iter']) + append_dataset(self.slit_dataset_name, self.region['slit']) + + def read(self): + global current_region_index + current_region_index = self.region_index + self.setup() + print("Acquiring region {0}.".format(self.region['name'])) + trig_scienta() + time.sleep(0.5) + sp = Scienta.getSpectrum().read() + return sp + + def getSize(self): + if self.region['fixed']: + nx = 992 + else: + nx = int((self.region['ehi'] - self.region['elo']) / self.region['estep']) + 1 + return nx + + +class ImageReader(ReadonlyRegisterBase, ReadonlyRegisterMatrix): + def read(self): + return Scienta.getDataMatrix().read() + + def getWidth(self): + if self.region['fixed']: + nx = 992 + else: + nx = int((self.region['ehi'] - self.region['elo']) / self.region['estep']) + 1 + return nx + + def getHeight(self): + ny = Scienta.slices.read() + return ny + +def setup_live_plots(regions): + global live_plots + global current_region_index + names = [region['name'] for region in regions] + live_plots = plot(None, names, title="Live Spectra") + current_region_index = 0 + +def update_live_plots(): + global live_plots + global current_region_index + try: + while get_context().state.running: + y = Scienta.spectrum.take(100) + x = Scienta.spectrumX + try: + series = live_plots[current_region_index].getSeries(0) + series.setData(x, y) + except IndexError: + pass + time.sleep(1.0) + finally: + print "Stopping live spectra" + +def do_scan(motors, positions, regions, latency): + global SENSORS + + SENSORS = [] + + + for (index, region) in enumerate(regions): + + check_region(region) + + + reader = SpectrumReader() + reader.region_index = index + reader.region_name = "region{0}".format(index + 1) + reader.region = region + reader.initialize() + set_device_alias(reader, reader.region_name + "/ScientaSpectrum") + SENSORS.append(reader) + + image = ImageReader() + image.region_index = index + image.region = region + image.initialize() + set_device_alias(image, reader.region_name + "/ScientaImage") + SENSORS.append(image) + + + SENSORS.append(SampleCurrent) + SENSORS.append(RefCurrent) + adjust_sensors() + set_adc_averaging() + + #ascan(motors, SENSORS, positions[0], positions[1], positions[2], latency, False, zigzag = True, before_read=wait_beam, after_read = after_readout) + #lscan(motors, SENSORS, positions[0], positions[1], positions[2], latency, False, before_read=wait_beam, after_read = after_readout) + vscan(motors, SENSORS, positions, True, latency,False, before_read=wait_beam, after_read = after_readout) + + + for (index, region) in enumerate(regions): + set_attribute(get_exec_pars().scanPath + "region{0}/ScientaSpectrum".format(index + 1), "RegionName", region['name']) + set_attribute(get_exec_pars().scanPath + "region{0}/ScientaImage".format(index + 1), "RegionName", region['name']) + set_attribute(get_exec_pars().scanPath, "Regions", [region['name'] for region in regions]) + +try: + setup_live_plots(REGIONS) + task = fork(update_live_plots) + do_scan(MOTORS, POSITIONS, REGIONS, LATENCY) +finally: + if CLOSE_SHUTTER_AT_END: + after_scan()