From 2835fb6751b5675f03ac8365ded1cf6b09898204 Mon Sep 17 00:00:00 2001 From: x03daop Date: Fri, 2 Jun 2017 12:47:55 +0200 Subject: [PATCH] Script execution --- script/MultiRegionHoloScan.py | 171 +++++++++++++++++++++++++--------- 1 file changed, 125 insertions(+), 46 deletions(-) diff --git a/script/MultiRegionHoloScan.py b/script/MultiRegionHoloScan.py index 03d8fa7e..d756c9ab 100644 --- a/script/MultiRegionHoloScan.py +++ b/script/MultiRegionHoloScan.py @@ -1,77 +1,156 @@ """ 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 +PHI_RANGE = (-72.0, 72.0) # (tuple (min, max)) +THETA_RANGE = (-9.0, 81.0) # (tuple (min, max)) +STEPS = (36.0, 1.0) # (tuple (phi, theta)) + + +REGION1 = {'name': 'Cu Auger', 'elo': 910.5, 'ehi': 917.0, 'estep': 0.075, 'epass': 100, 'tstep': 0.4, 'iter': 1, 'cis': True} +REGION2 = {'name': 'C 1s', 'elo': 997.0, 'ehi': 1003.0, 'estep': 0.05, 'epass': 100, 'tstep': 0.4, 'iter': 1, 'cis': True} +REGIONS = [REGION1, REGION2] + +CLOSE_SHUTTER_AT_END = True + +Scienta.setAcquisitionMode(ch.psi.pshell.epics.Scienta.AcquisitionMode.Swept) class SpectrumReader(ReadonlyRegisterBase, ReadonlyRegisterArray): - def doRead(self): - global VECTOR + def initialize(self): + #super(SpectrumReader, self).initialize() + self.scan_index = -1 + + def create_datasets(self): + path = get_exec_pars().scanPath + + self.channel_begin_dataset_name = path + "ScientaChannelBegin{0}".format(self.region_index + 1) + self.channel_end_dataset_name = path + "ScientaChannelEnd{0}".format(self.region_index + 1) + self.pass_energy_dataset_name = path + "ScientaPassEnergy{0}".format(self.region_index + 1) + self.step_energy_dataset_name = path + "ScientaStepEnergy{0}".format(self.region_index + 1) + self.step_time_dataset_name = path + "ScientaStepTime{0}".format(self.region_index + 1) + self.iterations_dataset_name = path + "ScientaIterations{0}".format(self.region_index + 1) + + create_dataset(self.channel_begin_dataset_name, 'd') + create_dataset(self.channel_end_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') + + 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) + + elo = self.region['elo'] + ehi = self.region['ehi'] + + Scienta.lowEnergy.write(elo) + Scienta.highEnergy.write(ehi) + Scienta.stepSize.write(self.region['estep']) + Scienta.setPassEnergy(self.region['epass']) + Scienta.stepTime.write(self.region['tstep']) + Scienta.setIterations(self.region['iter']) + Scienta.update() + + append_dataset(self.channel_begin_dataset_name, elo) + append_dataset(self.channel_end_dataset_name, ehi) + append_dataset(self.pass_energy_dataset_name, self.region['epass']) + append_dataset(self.step_energy_dataset_name, self.region['estep']) + append_dataset(self.step_time_dataset_name, self.region['tstep']) + append_dataset(self.iterations_dataset_name, self.region['iter']) + + def read(self): + global current_region_index + current_region_index = self.region_index self.setup() + print "Acquiring spectrum {elo}-{ehi} eV.".format(elo=Scienta.lowEnergy.value, ehi=Scienta.highEnergy.value) trig_scienta() - time.sleep(0.1) - return Scienta.getSpectrum().read() + time.sleep(0.5) + sp = Scienta.getSpectrum().read() + return sp def getSize(self): - return len(Scienta.getSpectrumX()) + nx = int((self.region['ehi'] - self.region['elo']) / self.region['estep']) + 1 + return nx - -class SpectrumReader1(SpectrumReader): - def setup(self): - global energy_scale_array, initial_energy_range - Scienta.getLowEnergy().write(self.elo) - Scienta.getHighEnergy().write(self.ehi) - Scienta.getStepSize().write(self.estep) - 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(self.elo) - Scienta.getHighEnergy().write(self.ehi) - Scienta.getStepSize().write(self.estep) - 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): + def read(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]) + nx = int((self.region['ehi'] - self.region['elo']) / self.region['estep']) + 1 + return nx def getHeight(self): - return Scienta.getDataMatrix().getHeight() + 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 -#PHI_RANGE (tuple (min, max)) -#THETA_RANGE (tuple (min, max)) -#STEPS (tuple (phi, theta)) -def measure_stuff(): - global VECTOR, MOTORS, SENSORS - reader1 = SpectrumReader1(); reader1.initialize() - reader2 = SpectrumReader2(); reader2.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") +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" - Scienta.getDataMatrix() +def do_scan(regions, latency): + global SENSORS, PHI_RANGE, THETA_RANGE + + SENSORS = [] + + for (index, region) in enumerate(regions): + reader = SpectrumReader() + reader.region_index = index + reader.region = region + reader.initialize() + set_device_alias(reader, "ScientaSpectrum{0}".format(index + 1)) + SENSORS.append(reader) - SENSORS = [SampleCurrent, RefCurrent, reader1, image1, reader2, image2] + image = ImageReader() + image.region_index = index + image.region = region + image.initialize() + set_device_alias(image, "ScientaImage{0}".format(index + 1)) + SENSORS.append(image) + SENSORS.append(SampleCurrent) + SENSORS.append(RefCurrent) adjust_sensors() set_adc_averaging() - set_preference(Preference.PLOT_TYPES, {'Scienta spectrum':1}) ascan((ManipulatorPhi, ManipulatorTheta), SENSORS, (PHI_RANGE[0], THETA_RANGE[0]), (PHI_RANGE[1], THETA_RANGE[1]), STEPS, LATENCY, RELATIVE, zigzag = ZIGZAG, before_read=wait_beam, after_read = after_readout) -global VECTOR, MOTORS, SENSORS -measure_stuff() + for (index, region) in enumerate(regions): + set_attribute(get_exec_pars().scanPath + "ScientaSpectrum{0}".format(index + 1), "RegionName", region['name']) + set_attribute(get_exec_pars().scanPath + "ScientaImage{0}".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(REGIONS, LATENCY) +finally: + if CLOSE_SHUTTER_AT_END: + after_scan()