pshell_config/x03da
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Closedown

Browse Source
This commit is contained in:
x03daop
2017-02-16 16:25:57 +01:00
parent 326a84e530
commit b55584f398
7 changed files with 0 additions and 764 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
script/EmpaMarco.py
View File

@@ -1,22 +0,0 @@
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()

120
script/FeCrXPS.py
View File

@@ -1,120 +0,0 @@
#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'))

48
script/HbnPhdScript.py
View File

@@ -1,48 +0,0 @@
"""
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()

54
script/HoloScan-MilosB.py
View File

@@ -1,54 +0,0 @@
"""
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()

190
script/SchofieldScan.py
View File

@@ -1,190 +0,0 @@
"""
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()

188
script/Schofield_XPS.py
View File

@@ -1,188 +0,0 @@
"""
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 ' ######################################################'

142
script/catch_up.py
View File

@@ -1,142 +0,0 @@
"""
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()