pshell_config/sf-op
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Browse Source
This commit is contained in:
root
2019-08-08 10:10:28 +02:00
parent 1f4edcbc88
commit 7f88d445af
37 changed files with 6480 additions and 501 deletions
Download Patch File Download Diff File Expand all files Collapse all files
script/Devices/Elements.py
+62 -2
View File
@@ -156,8 +156,9 @@ elements = (
(DBPM, "SARCL02-DBPM110", 456.9100),
(DBLM, "SARCL02-DBLM135", 457.9854),
(DBPM, "SARCL02-DBPM220", 460.9609),
(DWSC, "SARCL02-DWSC235", 461.6270),
(DBPM, "SARCL02-DBPM260", 462.7569),
(DWSC, "SARCL02-DWSC270", 462.9769),
#(DWSC, "SARCL02-DWSC270", 462.9769),
(DBPM, "SARCL02-DBPM330", 466.6909),
(DBLM, "SARCL02-DBLM355", 467.686),
(DBPM, "SARCL02-DBPM470", 471.1067),
@@ -301,7 +302,7 @@ def get_camera_type(camera_name):
###################################################################################################
## BLMs in WS MODE
## BLMs
###################################################################################################
@@ -342,3 +343,62 @@ def get_blm_ws_att(blm):
string 15: 30 dB
"""
return caget(blm + ":WS_PMT_ATT_VOLTS", 'i')
def get_blm_loss(blm):
return caget(blm + ":B1_LOSS")
def get_blm_raw(blm):
return caget(blm + ":LOSS_SIGNAL_RAW")
def get_blm_baseline(blm):
return caget(blm + ":BASELINE_VAL")
def get_blm_range(blm):
raw =get_blm_raw(blm)
bl=get_blm_baseline(blm)
m = min(raw)
ret = (bl-m)/bl
ret = min(max(ret, 0.0), 1.0)
return ret
def set_blm_saturation(blm, val):
set_setting(blm + "_saturation", val)
def get_blm_saturation(blm):
ret = get_setting(blm + "_saturation")
return None if (ret is None) else float(ret)
def update_blm_saturation(blm):
set_setting(blm + "_saturation", get_blm_loss(blm))
def get_voltage_from_gain(gain):
#a=caget (blm+":AL1-MPS-GAIN-A", 'd')
#b=caget (blm+":AL1-MPS-GAIN-B", 'd')
a = caget("SINDI02-DBLM084:AL1-MPS-GAIN-A", 'd')
b = caget("SINDI02-DBLM084:AL1-MPS-GAIN-B", 'd')
return (math.log(gain) - math.log(a))/b
def get_gain_from_voltage(voltage):
a = caget("SINDI02-DBLM084:AL1-MPS-GAIN-A", 'd')
b = caget("SINDI02-DBLM084:AL1-MPS-GAIN-B", 'd')
return a*math.exp(b*voltage)
###################################################################################################
## WSCs
###################################################################################################
def write_ws_gain(blm, wire, val):
set_setting(blm + "GainWs" + wire, val)
def read_ws_gain(blm, wire):
return get_setting(blm + "GainWs" + wire)
def set_wire_scan_range(wsc, wire, start, end):
sel = {'X1':"W1X" , 'Y1': "W1Y", 'X2':"W2X", 'Y2' : "W2Y"}
start = min (max(start, -2000), 2000.0)
end = min (max(end, -2000), 2000.0)
caput((wsc + ":" + sel[wire] +"_START_SP"), start)
caput((wsc + ":" + sel[wire] +"_END_SP"), end)
script/Diagnostics/Blm_WF_Plot.py
+12
View File
@@ -0,0 +1,12 @@
st = Stream("st1",dispatcher)
st.setFilter("SIN-CVME-TIFGUN-EVR0:BEAMOK == 1")
c = "SARCL02-DBLM135:LOSS_SIGNAL_RAW"
st.addWaveform(c, c, 1, 2048)
try:
st.initialize()
st.start()
st.waitCacheChange(10000) #Wait stream be running before starting scan
mscan(st, st.getReadables()[1], -1, line_plots= [c,], keep=False, save=False)
finally:
st.close()
script/Diagnostics/WireScan.py
+115 -26
View File
@@ -1,8 +1,10 @@
import traceback
has_args = get_exec_pars().source != CommandSource.ui #Must be checked before callin "run"
is_script = get_exec_pars().source == CommandSource.script
is_embedded = (get_exec_pars().getCommand(False).parent != None)
has_args = is_embedded or (get_exec_pars().source != CommandSource.ui)
STREAM_CREATION_RETRIES = 3
MAX_RANGE_STEP = 3
run("Devices/Elements")
run("Devices/WireScanner")
@@ -23,12 +25,19 @@ bkgrd = args[7] if has_args else 10
plt = args[8] if has_args else plot(None, title = "Wire Scan")[0]
save_raw = args[9] if has_args else False
bunch = args[10] if has_args else 1
do_elog = True if (has_args and (not is_script) and (plt is not None)) else False
print has_args, do_elog
adaptive = args[11] if has_args else 1 #0=Off, 1=Gain, 2=Gain+range
filter_beam_ok = (args[12] if has_args else True) if len(args)>12 else True
do_elog = True if (has_args and (not is_embedded) and (plt is not None)) else False
print has_args, is_embedded, do_elog
print "WireScan parameters: ", prefix, scan_type, scan_range, cycles, n_shot, bpms, blms, bkgrd, bunch
print "WireScan parameters: ", prefix, scan_type, scan_range, cycles, n_shot, bpms, blms, bkgrd, bunch, adaptive
#Adaptive mode parameters
MIN_GAIN, MAX_GAIN = 0.5, 1.1
INCREMENT_FACTOR = 0.5
SCAN_RANGE_FACTOR = 6
MAX_RANGE_STEP = 300
FILTER_BEAM_OK = True
SET_BLM_WS_MODE = True
SET_BLM_WS_SETTLING_TIME = 2.0
SET_BLM_WS_BS_READBACK_TIMEOUT = 10000 #ms
@@ -116,18 +125,27 @@ filename = get_exec_pars().path
#Stream creation
print "Starting stream..."
st = Stream("pulse_id", dispatcher)
for c in channels:
if c[1].endswith("LOSS_SIGNAL_RAW"):
st.addWaveform(c[0], c[1], int(100.0 / get_repetition_rate()), 0)
else:
st.addScalar(c[0], c[1], int(100.0 / get_repetition_rate()), 0)
st.initialize()
st.start()
st.waitCacheChange(10000) #Wait stream be running before starting scan
for retry in range(STREAM_CREATION_RETRIES):
try:
print "Starting stream..."
st = Stream("pulse_id", dispatcher)
for c in channels:
if c[1].endswith("LOSS_SIGNAL_RAW"):
st.addWaveform(c[0], c[1], int(100.0 / get_repetition_rate()), 0)
else:
st.addScalar(c[0], c[1], int(100.0 / get_repetition_rate()), 0)
st.initialize()
st.start()
st.waitCacheChange(10000) #Wait stream be running before starting scan
break
except:
print "Error starting stream"
print sys.exc_info()[1]
if retry >= (STREAM_CREATION_RETRIES-1):
raise
else:
print "Retrying"
class Timestamp(Readable):
def read(self):
return st.getTimestamp()
@@ -147,6 +165,8 @@ rec =None
def check_end_scan(record, scan):
global scan_complete,cur_cycle
global rec
if (rec is None) and (record is not None):
print "Started receiving from stream"
rec = record
if record[4]<1:
print "Data aquisition completed"
@@ -163,7 +183,9 @@ def check_end_scan(record, scan):
for i in range (len(blms)):
plt.getSeries(i).appendData(position, record[5 + i])
scanner.park(wait=True)
if scanner.take() != "At start":
print "Not at start: parking scanner"
scanner.park(wait=True)
#Process background
def do_background():
#Store Background
@@ -186,17 +208,18 @@ def set_blm_gain(scan_type, index):
scan_type = (WireScanner.WireX1 if index == 0 else WireScanner.WireY1)
if scan_type == WireScanner.Set2:
scan_type = (WireScanner.WireX2 if index == 0 else WireScanner.WireY2)
cfg_gain = get_setting(blms[0] + "GainWs" + scan_type)
cfg_gain = read_ws_gain (blms[0], scan_type)
print "cfg_gain = " , cfg_gain
if cfg_gain is not None:
set_blm_ws_gain(blms[0],cfg_gain)
print "Set = " , blms[0]
print "Set = " , blms[0], cfg_gain
#Scan
def do_scan(index):
global scan_complete, cur_cycle, wire
global scan_complete, cur_cycle, wire, rec
rec =None
wire = "y" if (index==1) or (scan_type in [WireScanner.WireY1, WireScanner.WireY2]) else "x"
if wire == "x":
scanner.set_velocity(velocity_x)
@@ -248,8 +271,13 @@ def do_scan(index):
#s=plt.getSeries(0)
#indexes = sorted(range(len(s.x)),key=lambda x:s.x[x])
#x,y = [s.x[x] for x in indexes], [s.y[x] for x in indexes]
#plot(y, xdata = x)
#plot(y, xdata = x)
if rec is None:
raise Exception("Didn't receive from stream")
if not scan_complete:
raise Exception("Scan didn't conmplete")
print "Calculating"
rec
calculate()
print "Ok"
img_file = os.path.abspath(filename + "_" + get_exec_pars().group[0:1] + ".png")
@@ -259,6 +287,7 @@ def do_scan(index):
snapshots.append(img_file)
print "Finished"
pars = []
msg = ""
ret = []
def calculate():
@@ -271,7 +300,7 @@ def calculate():
samples = [[], [], [], [], [], []]
for cycle in range (cycles):
pos_path = wire+"_" + ("%04d" % (cycle+1)) + "/data/w_pos"
print "Loading ", pos_path
print "Loading: ", pos_path
pos = load_data(pos_path+"/value")
path = wire+"_" + ("%04d" % (cycle+1)) + "/data/blm" + str(i+1)
print "Loading ", path
@@ -342,7 +371,63 @@ def calculate():
except:
traceback.print_exc()
gauss = [0.0] * SAMPLE_CHANNEL_SIZE
scanner.set_out_gauss(bunch,wire,gauss)
scanner.set_out_gauss(bunch,wire,gauss)
#com = stats[i][2][0]
#sigma = stats[i][3][0]
#saturration_loss = get_blm_saturation(blms[i])
#current_gain = get_blm_ws_gain(blms[i]) #read_ws_gain (blms[i], wire)
#current_loss = get_blm_loss(blms[i])
#global pars
#pars = [blms, com, sigma, saturration_loss, current_gain, current_loss]
com = stats[i][0][0]
rms = stats[i][1][0]
mn = stats[i][2][0]
sigma = stats[i][3][0]
(cur_x_range_min, cur_x_range_max) = (scan_range[0], scan_range[1]) if wire == "x" else (scan_range[2], scan_range[3])
x_range_min, x_range_max = mn - SCAN_RANGE_FACTOR * sigma, mn + SCAN_RANGE_FACTOR * sigma
off_min, off_max = (x_range_min - cur_x_range_min), (x_range_max - cur_x_range_max)
valid_range = (abs(off_min) < MAX_RANGE_STEP) and (abs(off_max) < MAX_RANGE_STEP)
valid_fitting = (com!=float('NaN')) and (mn!=float('NaN')) and \
(com>cur_x_range_min) and (com<cur_x_range_max) and \
(mn>cur_x_range_min) and (mn<cur_x_range_max)
print "Scan range: ", (cur_x_range_min, cur_x_range_max)
print "Valid fitting: ", valid_fitting
print "Valid range: ", valid_range
if adaptive > 0 and \
valid_fitting and \
(scan_type not in [WireScanner.Set1, WireScanner.Set2]):
new_gain, new_voltage = None, None
#desired_loss= 800
desired_loss= get_blm_saturation(blms[i])
current_voltage = get_blm_ws_gain(blms[i]) #read_ws_gain (blms[i], scan_type)
#current_loss = float(get_blm_loss(blms[i]))
current_loss = max(sig)
print "current_loss=", current_loss
current_gain = get_gain_from_voltage(current_voltage)
dg = current_gain * (desired_loss/ current_loss -1)
new_gain = current_gain + dg * INCREMENT_FACTOR
new_voltage = get_voltage_from_gain(new_gain)
new_voltage = max(min(new_voltage, MAX_GAIN),MIN_GAIN)
print "dg=", dg, " ng=", new_gain
if (new_voltage is not None) and (new_voltage != current_voltage):
logstr= "Adapting " + str(blms[i]) + " - " + str(scan_type) + "gain: " + str(new_voltage)
print logstr
log(logstr)
write_ws_gain(blms[i], scan_type, new_voltage)
set_blm_ws_gain(blms[i], new_voltage)
if adaptive > 1:
if valid_range:
new_min, new_max = (cur_x_range_min + INCREMENT_FACTOR*off_min), (cur_x_range_max + INCREMENT_FACTOR*off_max)
logstr= "Adapting range: " , new_min , " to " , new_max
set_wire_scan_range(prefix, scan_type, new_min, new_max)
print logstr
log(logstr)
except Exception, e:
print >> sys.stderr, traceback.format_exc()
msg += str(e)+ "\n"
@@ -374,7 +459,7 @@ try:
print "Reading background..."
do_background()
stream_filter = scanner.curr_cycl.get_name() + ">0"
if FILTER_BEAM_OK:
if filter_beam_ok:
stream_filter = stream_filter + " AND SIN-CVME-TIFGUN-EVR0:BEAMOK == 1"
st.setFilter(stream_filter)
print "Executing scan 1..."
@@ -383,6 +468,10 @@ try:
print "Executing scan 2..."
do_scan(1)
finally:
try:
scanner.park(wait=False)
except:
pass
if SET_BLM_WS_MODE and len(blms)>0:
stop_blm_ws(blms[0])
print "Closing scanner"
script/Diagnostics/WireScanCalibration.py
+59 -61
View File
@@ -29,44 +29,20 @@ OPT_STEP = 0.02
print "WireScanCalibration parameters: ", ws_prefix, ws_wire, range_start, range_end, n_shot, saturation, scan_range_factor, initial_gain
###################################################################################################
# Utilities
###################################################################################################
def write_ws_gain(val):
set_setting(ws_blm + "GainWs" + ws_wire, val)
def read_ws_gain():
return get_setting(ws_blm + "GainWs" + ws_wire)
def get_gain():
return get_blm_ws_gain(ws_blm)
def set_gain(val):
set_blm_ws_gain(ws_blm,val)
def set_wire_scan_range(wire, start, end):
sel = {'X1':"W1X" , 'Y1': "W1Y", 'X2':"W2X", 'Y2' : "W2Y"}
start = min (max(start, -2000), 2000.0)
end = min (max(end, -2000), 2000.0)
caput((ws_prefix + ":" + sel[wire] +"_START_SP"), start)
caput((ws_prefix + ":" + sel[wire] +"_END_SP"), end)
###################################################################################################
# Find COM
###################################################################################################
print "--------------- Find COM --------------- "
set_status("Performing wire scan to find initial COM...")
write_ws_gain(initial_gain)
set_gain(initial_gain)
write_ws_gain(ws_blm,ws_wire, initial_gain)
set_blm_ws_gain(ws_blm, initial_gain)
print "Setting gain=", initial_gain
#Calculate speed
x_min, x_max = range_start, range_end
#rr = get_repetition_rate()
#ws_speed = (x_max- x_min)*rr/n_shot
args = [ ws_prefix , ws_wire, [x_min, x_max, x_min, x_max], 1, n_shot, [], [ws_blm], 10, plt, False,1]
args = [ ws_prefix , ws_wire, [x_min, x_max, x_min, x_max], 1, n_shot, [], [ws_blm], 10, plt, False,1,0]
ret = run("Diagnostics/WireScan", args)
[rms_com, rms_sigma, com, sigma, pos_path, path] = ret
@@ -96,74 +72,96 @@ print "Starting stream..."
set_status("Creating stream for gain search..." )
st = Stream("blm_stream", dispatcher)
ch = ws_blm + ":B1_LOSS"
st.addScalar(ch, ch, int(100.0 / get_repetition_rate()), 0)
ch_int = ws_blm + ":B1_LOSS"
ch_raw = ws_blm + ":LOSS_SIGNAL_RAW"
st.addScalar(ch_int, ch_int, int(100.0 / get_repetition_rate()), 0)
st.addWaveform(ch_raw, ch_raw, int(100.0 / get_repetition_rate()), 0)
st.addScalar("blm1_ws_mode", ws_blm + ":WS_RUNNING", int(100.0 / get_repetition_rate()), 0)
st.initialize()
st.start()
st.waitCacheChange(10000) #Wait stream be running before starting scan
baseline=get_blm_baseline(ws_blm)
def change_blm_ws_gain(gain):
set_gain(gain)
#stop_blm_ws(ws_blm)
#st.getChild("blm1_ws_mode").waitValue(0, SET_BLM_WS_BS_READBACK_TIMEOUT)
#start_blm_ws(ws_blm, 600.0)
#st.getChild("blm1_ws_mode").waitValue(1, SET_BLM_WS_BS_READBACK_TIMEOUT)
set_blm_ws_gain(ws_blm, gain)
time.sleep(0.25)
def get_loss():
global ch
def get_loss_int():
samples = []
for i in range(10):
st.waitCacheChange(-1)
val = st.getValue(ch)
val = st.getValue(ch_int)
samples.append(val)
samples.remove(max(samples))#Remove max value
return max(samples)
def get_loss_range():
st.waitCacheChange(-1)
raw = st.getValue(ch_raw)
m = min(raw)
ret = (baseline-m)/baseline
ret = min(max(ret, 0.0), 1.0)
return ret
change_blm_ws_gain(MIN_GAIN)
time.sleep(2.0)
start_gain = get_gain()
pos = start_val = get_loss()
loss = get_loss()
pos = read_ws_gain(ws_blm, ws_wire)
loss = get_loss_int()
print "Current Gain = ", pos, "\nStart Loss = ", loss
"""
target = saturation * 0.8
print "Start Gain = ", start_gain
print "Start Loss = ", start_val
print "Target = ", target
set_status("Searching gain to match peak losses of " + str(target) + "...")
set_status("Searching gain to match peak losses of " + str(target) + "..."
try:
#Search loop
for pos in frange(MIN_GAIN, MAX_GAIN, OPT_STEP, True):
change_blm_ws_gain(pos)
loss = get_loss()
loss = get_loss_int()
print "Pos = ", pos, " Loss = ", loss
if loss>=target:
break
#stop_blm_ws(ws_blm)
break
finally:
stop_blm_ws(ws_blm)
print "Final Gain: ", pos
print "Final Loss: ", loss
print "Final Gain: ", pos, "\nFinal Loss: ", loss
result = "Loss value for final gain: " + str(loss) + " - Target value: " + str(target) + "\n"
if loss<target:
result = result + "Cannot reach target value. Setting gain to " + str(pos) + "\n"
else:
result = result + "Optimized gain: " + str(pos) + "\n"
"""
target = 0.9
loss_range = 0.0
blm_saturation = None
set_status("Searching loss range of " + str(target) + "...")
try:
#Search loop
for pos in frange(MIN_GAIN, MAX_GAIN, OPT_STEP, True):
change_blm_ws_gain(pos)
time.sleep(0.1)
loss_range = get_loss_range()
print "Pos = ", pos, " Loss Range= ", loss_range
if loss_range>=target:
print "Done..."
blm_saturation = get_loss_int()
set_blm_saturation(ws_blm,blm_saturation)
break
finally:
stop_blm_ws(ws_blm)
print "Final Gain: ", pos, "\nFinal Loss Range: ", loss_range , "\nBLM satiuration: ", blm_saturation
result = "Loss range for final gain: " + str(loss_range) + " - Target value: " + str(target) + "\n"
if blm_saturation is None:
result = result + "Cannot reach target value. Setting gain to " + str(pos) + "\n"
else:
result = result + "Optimized gain: " + str(pos) + " - BLM satiuration: " +str(blm_saturation) + "\n"
st.close()
write_ws_gain(pos)
write_ws_gain(ws_blm, ws_wire, pos)
time.sleep(1.0)
###################################################################################################
@@ -176,12 +174,12 @@ print "--------------- Optimize scan range --------------- "
set_status("Performing scan with optimal gain to define optimal range..." )
#caget(ws_blm+":SAT_RAW_SUM")
args = [ ws_prefix , ws_wire, [x_min, x_max, x_min, x_max], 1, n_shot, [], [ws_blm], 10, plt, False,1]
args = [ ws_prefix , ws_wire, [x_min, x_max, x_min, x_max], 1, n_shot, [], [ws_blm], 10, plt, False,1,0]
[rms_com, rms_sigma, com, sigma, pos_path, path] = run("Diagnostics/WireScan", args)
x_range_min, x_range_max = com - scan_range_factor * sigma, com + scan_range_factor * sigma
print "Optimized range: " , x_range_min , " to " , x_range_max
set_wire_scan_range(ws_wire, x_range_min, x_range_max)
set_wire_scan_range(ws_prefix, ws_wire, x_range_min, x_range_max)
result = result + "Optimized range: " + str(x_range_min) + " to " + str(x_range_max)
script/GenericScans/190430_phiKscan.py
+49
View File
@@ -0,0 +1,49 @@
import ch.psi.pshell.epics.ChannelDouble as ChannelDouble
A1 = ChannelDouble("K", "SARUN08-UIND030:K_SET")
A2 = ChannelDouble("phi", "SARUN08-UPHS060:PHI_SET")
S1 = ChannelDouble("US", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-US")
S2 = ChannelDouble("DS", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-DS")
A1.initialize()
A2.initialize()
S1.initialize()
S2.initialize()
A1_init = A1.read()
A2_init = A2.read()
A1i = A1_init-0.002
A1f = A1_init+0.002
A2i = A2_init-90.0
A2f = A2_init+90.0
nstep = 21
lat = 0.1
nav = 10
plt = plot(None, title="Output")[0]
plt.clear()
plt.setStyle(plt.Style.ErrorY)
plt.addSeries(LinePlotErrorSeries("Sensor1", Color.red))
def data_ok():
return (mps_beam_ok.read() == 1)
def after_sample(record, scan):
if not data_ok():
time.sleep(1.0)
record.invalidate()
print "Invalidating record: " + str(record)
else:
plt.getSeries(0).appendData(record.positions[0], record.values[0].mean, record.values[0].stdev)
try:
S1_averager = create_averager(S1, nav, lat)
S2_averager = create_averager(S2, nav, lat)
S2_averager.monitored=True
time.sleep(10.0)
r = ascan((A1,A2), (S1_averager, S2_averager), (A1i,A2i), (A1f,A2f), (nstep,nstep), latency=2.0, after_read = after_sample)
Act1 = r.getPositions(0)
S1mean = [val.mean for val in r.getReadable(0)]
S1rms = [val.stdev for val in r.getReadable(0)]
S2mean = [val.mean for val in r.getReadable(1)]
S2rmsn = [val.stdev for val in r.getReadable(1)]
finally:
A1.write(A1_init)
A1.close()
S1.close()
S2.close()
script/GenericScans/190502_undXscan.py
+49
View File
@@ -0,0 +1,49 @@
import ch.psi.pshell.epics.ChannelDouble as ChannelDouble
A1 = ChannelDouble("K", "SARUN06-UIND030:GM-X-SET")
A2 = ChannelDouble("phi", "SARUN08-UPHS060:PHI_SET")
S1 = ChannelDouble("US", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-US")
S2 = ChannelDouble("DS", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-DS")
A1.initialize()
A2.initialize()
S1.initialize()
S2.initialize()
A1_init = A1.read()
A2_init = A2.read()
A1i = A1_init-0.002
A1f = A1_init+0.002
A2i = A2_init-90.0
A2f = A2_init+90.0
nstep = 21
lat = 0.1
nav = 10
plt = plot(None, title="Output")[0]
plt.clear()
plt.setStyle(plt.Style.ErrorY)
plt.addSeries(LinePlotErrorSeries("Sensor1", Color.red))
def data_ok():
return (mps_beam_ok.read() == 1)
def after_sample(record, scan):
if not data_ok():
time.sleep(1.0)
record.invalidate()
print "Invalidating record: " + str(record)
else:
plt.getSeries(0).appendData(record.positions[0], record.values[0].mean, record.values[0].stdev)
try:
S1_averager = create_averager(S1, nav, lat)
S2_averager = create_averager(S2, nav, lat)
S2_averager.monitored=True
time.sleep(10.0)
r = ascan((A1,A2), (S1_averager, S2_averager), (A1i,A2i), (A1f,A2f), (nstep,nstep), latency=2.0, after_read = after_sample)
Act1 = r.getPositions(0)
S1mean = [val.mean for val in r.getReadable(0)]
S1rms = [val.stdev for val in r.getReadable(0)]
S2mean = [val.mean for val in r.getReadable(1)]
S2rmsn = [val.stdev for val in r.getReadable(1)]
finally:
A1.write(A1_init)
A1.close()
S1.close()
S2.close()
script/GenericScans/190614_MKscan.py
+36
View File
@@ -0,0 +1,36 @@
import ch.psi.pshell.epics.ChannelDouble as ChannelDouble
A1 = ChannelDouble("S20SY02-MKDC050:I-SET", "S20SY02-MKDC050:I-SET")
S1 = ChannelDouble("SARUN02-DBPM070:Y1", "SARUN02-DBPM070:Y1")
S2 = ChannelDouble("SARUN02-DBPM070:X1", "SARUN02-DBPM070:X1")
S3 = ChannelDouble("SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-DS", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-DS")
A1.initialize()
S1.initialize()
S2.initialize()
S3.initialize()
A1_init = A1.read()
A1i =-0.1
A1f = 0.1
step = 0.01
lat1 = 1
lat2 = 1
nav = 10
plt = plot(None, title="Output")[0]
plt.clear()
plt.setStyle(plt.Style.ErrorY)
plt.addSeries(LinePlotErrorSeries("Sensor1", Color.red))
def after_sample(record, scan):
plt.getSeries(0).appendData(record.positions[0], record.values[0].mean, record.values[0].stdev)
try:
S1_averager = create_averager(S1, nav, lat1)
A1.write(A1i)
time.sleep(2.0)
r = lscan(A1, (S1_averager), A1i, A1f, step, latency=lat2, after_read = after_sample)
Act1 = r.getPositions(0)
S1mean = [val.mean for val in r.getReadable(0)]
S1rms = [val.stdev for val in r.getReadable(0)]
finally:
A1.write(A1_init)
A1.close()
S1.close()
S2.close()
S3.close()
script/GenericScans/MKscan.py
+1 -1
View File
@@ -1,5 +1,5 @@
import ch.psi.pshell.epics.ChannelDouble as ChannelDouble
A1 = ChannelDouble("MK energy", "S20SY02-MK:ENERGY-SP")
A1 = ChannelDouble("MK energy", "S20SY02-MK:ENERGY-SP")
S1 = ChannelDouble("S20SY02-DBPM150:Y1", "S20SY02-DBPM150:Y1")
S2 = ChannelDouble("SATSY01-DBPM010:Y1", "SATSY01-DBPM010:Y1")
S3 = ChannelDouble("SATSY01-DBPM010:Q1", "SATSY01-DBPM010:Q1")
script/RFscan/GunEnergyScanLasSetNew.py
-38
View File
@@ -1,38 +0,0 @@
dry_run = False
do_elog = True
if get_exec_pars().source == CommandSource.ui:
las_offset_deg = 0.0
plt = None
else:
las_offset_deg = args[0]
plt = args[1]
Laser = caget("SLG-LGEN:WHICH_LASER")
cur_las_delay = 0.0
if Laser == "Alcor":
cur_las_delay = caget("SLGOS01-TSPL-ALC:CURR_DELTA_T")
elif Laser == "Jaguar":
cur_las_delay = caget("SLGJG-TSPL-JAG:CURR_DELTA_T")
new_las_delay = cur_las_delay - 333.467 * las_offset_deg / 360.0
if not dry_run:
if Laser == "Alcor":
caput("SLGOS01-TSPL-ALC:NEW_DELTA_T" , new_las_delay )
caput("SLGOS01-TSPL-ALC:SET_NEW_PHASE.PROC" , 1 )
elif Laser == "Jaguar":
caput("SLGJG-TSPL-JAG:NEW_DELTA_T" , new_las_delay )
caput("SLGJG-TSPL-JAG:SET_NEW_PHASE.PROC" , 1 )
if do_elog:
title = "Set laser delay"
log_msg = ""
if Laser == "Alcor":
log_msg = "SLGOS01-TSPL-ALC:NEW_DELTA_T: %12.4f" % new_las_delay + " ps (was %12.4f" % cur_las_delay + " ps)\n"
elif Laser == "Jaguar":
log_msg = "SLGJG-TSPL-JAG:NEW_DELTA_T: %12.4f" % new_las_delay + " ps (was %12.4f" % cur_las_delay + " ps)\n"
attachments = []
if plt is not None:
sleep(0.1) #Give some time to plot to be finished - it is not sync with acquisition
file_name = os.path.abspath(get_context().setup.getContextPath() + "/GunEnergyScanLasSet.png")
plt.saveSnapshot(file_name , "png")
attachments = [file_name]
elog(title, log_msg, attachments)
show_message("Success setting laser delay")
script/RFscan/GunEnergyScanNew.py
-167
View File
@@ -1,167 +0,0 @@
import ch.psi.pshell.epics.Positioner as Positioner
dry_run = False
do_elog = True
is_panel = get_exec_pars().source != CommandSource.ui #must be check before run
USE_SCREEN_PANEL = False
run("CPython/wrapper")
#Parameters
if is_panel:
start = args[0]
stop = args[1]
step = args[2]
nb = int(args[3])
lat = args[4]
disp = args[5]
p0 = args[6]
plt = args[7]
else:
start = 85.0
stop = 95.0
step = 0.5
nb = 3
lat = 0.15
disp = -0.387
p0 = 7.1
plt = plot(None, title="Output")[0]
A = p0 / disp / 1e6
B = p0
#Plot setup
plt.clear()
plt.removeMarker(None)
plt.setStyle(plt.Style.ErrorY)
plt.addSeries(LinePlotErrorSeries("Momentum", Color.red))
plt.addSeries(LinePlotErrorSeries("Momentum Spread", Color.yellow, 2))
plt.getAxis(plt.AxisId.X).setLabel("Gun Beam Phase (deg)")
plt.getAxis(plt.AxisId.Y).setLabel("Momentum (MeV/c)")
plt.getAxis(plt.AxisId.Y2).setLabel("Momentum Spread (MeV/c)")
plt.setLegendVisible(True)
#Creating Phase positioner
if dry_run:
phase = Positioner("Gun Phase", "SINEG01-RSYS:SET-BEAM-PHASE-SIM", "SINEG01-RSYS:SET-BEAM-PHASE-SIM")
camera_name = "simulation"
else:
phase = Positioner("Gun Phase", "SINEG01-RSYS:SET-BEAM-PHASE", "SINEG01-RSYS:GET-BEAM-PHASE")
camera_name = "SINBD01-DSCR010"
phase.config.minValue = -90.0
phase.config.maxValue = 360.0
phase.config.precision = 4
phase.config.resolution = 0.5
phase.config.rotation = True
phase.config.save()
phase.initialize()
phase0 = phase.read() % 360
#Camera setup
if USE_SCREEN_PANEL:
cam_server.start(camera_name+"_sp1", True) #True for shared pipeline
else:
cam_server.start(camera_name)
wait_cam_server_message()
x = cam_server.stream.getChild("x_center_of_mass")
dx = cam_server.stream.getChild("x_rms")
cam_server.setThreshold(150)
#cam_server.captureBackground(10) #Capturing background
cam_server.setBackgroundSubtraction(False)
#cam_server.setRoi([144,482,1431,706]) #X, Y, W, H # something wrong there to be fixed
#Creating averagers
x_averager = create_averager(x, nb, -1) # -1 event based, waits for the next value
dx_averager = create_averager(dx, nb, -1)
dx_averager.monitored = True # not blocking, will return last nb values
#Record callback: uptate of output plot
def after_sample(record, scan):
global A, B, plt
x_pos_mean, x_pos_stdev = record.values[0].mean, record.values[0].stdev
x_width_mean, x_width_stdev = record.values[1].mean, record.values[1].stdev
p_mean, p_stdev = A * x_pos_mean + B, abs(A) * x_pos_stdev
dp_mean, dp_stdev = abs(A) * x_width_mean, abs(A) * x_width_stdev
phase = ((record.positions[0] + 90) % 360) - 90 if start < 0 else record.positions[0]
plt.getSeries(0).appendData(phase, p_mean, p_stdev)
plt.getSeries(1).appendData(phase, dp_mean, dp_stdev)
#The scan loop
try:
phase.write(start)
time.sleep(2.0)
r = lscan(phase, [x_averager, dx_averager], start, stop, step , latency=lat, after_read = after_sample)
finally:
phase.write(phase0)
phase.close()
cam_server.stop() # stops cam_server but does not close it cam_server is a global object
ph = r.getPositions(0)
if start < 0:
ph = [((val + 90) % 360) -90 for val in ph ]
p = [A * val.mean + B for val in r.getReadable(0)]
dp = [abs(A) * val.mean for val in r.getReadable(1)]
#Fitting and plotting
try:
i = p.index(max(p))
a, b = max(i-6, 0), min(i+6, len(p))
(ph_p_max, p_max, ph_p_fit, p_fit, p_R2) = extremum(ph[a:b], p[a:b])
i = dp.index(min(dp))
a, b = max(i-6, 0), min(i+6, len(dp))
(ph_dp_min, dp_min, ph_dp_fit, dp_fit, dp_R2) = extremum(ph[a:b], dp[a:b])
plt.addSeries(LinePlotErrorSeries("Momentum Fit", plt.getSeries(0).color))
plt.addSeries(LinePlotErrorSeries("Momentum Spread Fit", plt.getSeries(1).color, 2))
plt.getSeries(2).setData(ph_p_fit, p_fit)
plt.getSeries(3).setData(ph_dp_fit, dp_fit)
plt.getSeries(2).setPointsVisible(False)
plt.getSeries(3).setPointsVisible(False)
plt.addMarker(ph_p_max, plt.AxisId.X, "%3.2f" % ph_p_max, plt.getSeries(0).color)
plt.addMarker(ph_dp_min, plt.AxisId.X, "%3.2f" % ph_dp_min, plt.getSeries(1).color)
except:
raise Exception("Fit failure")
# Calculating laser offset in ps
las_offset_deg = ph_dp_min - 90.0
#Saving metadata
save_dataset( "scan 1/processed/p" , p )
set_attribute( "scan 1/processed/p" , "p max" , p_max )
set_attribute( "scan 1/processed/p" , "p max phase" , ph_p_max )
set_attribute( "scan 1/processed/p" , "p fit R2" , p_R2 )
set_attribute( "scan 1/processed/p" , "Unit" , "MeV" )
save_dataset( "scan 1/processed/dp" , dp )
set_attribute( "scan 1/processed/dp" , "dp min" , dp_min )
set_attribute( "scan 1/processed/dp" , "dp min phase" , ph_dp_min )
set_attribute( "scan 1/processed/dp" , "dp fit R2" , dp_R2 )
set_attribute( "scan 1/processed/dp" , "Unit" , "MeV" )
#Elog entry
if do_elog:
if get_option("Generated data file:\n" + get_exec_pars().path +"\n\n" + "Save to ELOG?", "YesNo") == "Yes":
title = "Gun Energy Scan"
Laser = str(caget("SLG-LGEN:WHICH_LASER"))
log_msg = "Data file: " + get_exec_pars().path + "\n\n"
log_msg = log_msg + "Laser: " + Laser + "\n"
if Laser == "Alcor":
log_msg = log_msg + "Energy plate Alcor: %0.2f" % caget("SLGTH01-LMRM-M074:MOT.RBV") + " deg \n"
elif Laser == "Jaguar":
log_msg = log_msg + "Energy plate Jaguar: %0.2f" % caget("SLGJG-LMRM-M031:MOT.RBV") + " deg \n"
elif Laser == "Both":
log_msg = log_msg + "Energy plate Alcor: %0.2f" % caget("SLGTH01-LMRM-M074:MOT.RBV") + " deg \n"
log_msg = log_msg + "Energy plate Jaguar: %0.2f" % caget("SLGJG-LMRM-M031:MOT.RBV") + " deg \n"
if caget("SLGTV-LMTO-M053:MOT-ACT-POS") == "IRIS":
log_msg = log_msg + "Collimator: IRIS %0.2f" % caget("SLGTV-LAPP:SIZE-GET") + " mm \n"
else:
log_msg = log_msg + "Collimator: " + str(caget("SLGTV-LMTO-M053:MOT-ACT-POS")) + "\n"
log_msg = log_msg + "Charge B1: %0.2f" % caget("SINEG01-DICT215:B1_CHARGE-OP") + " pC at %0.2f" % phase0 + " deg beam phase\n"
log_msg = log_msg + "Charge B2: %0.2f" % caget("SINEG01-DICT215:B2_CHARGE-OP") + " pC at %0.2f" % phase0 + " deg beam phase\n"
log_msg = log_msg + "p-max: %0.2f" % p_max + " MeV/c at %0.2f" % ph_p_max + " deg beam phase\n"
log_msg = log_msg + "dp-min: %0.4f" % dp_min + " MeV/c at %0.2f" % ph_dp_min + " deg beam phase\n"
sleep(0.1) #Give some time to plot to be finished - it is not sync with acquisition
file_name = os.path.abspath(get_context().setup.getContextPath() + "/GunEnergyScanPlot.png")
plt.saveSnapshot(file_name , "png")
elog(title, log_msg, [file_name,])
set_return([ph_dp_min, las_offset_deg])
script/RFscan/GunEnergyScanRfSetNew.py
-25
View File
@@ -1,25 +0,0 @@
dry_run = False
do_elog = True
if get_exec_pars().source == CommandSource.ui:
bph_ref_user = 90.0
plt = None
else:
bph_ref_user = args[0]
plt = args[1]
phase_offset_old = caget("SINEG01-RSYS:SET-VSUM-PHASE-OFFSET-BASE")
phase_offset_new = phase_offset_old - (bph_ref_user - 90.0)
if not dry_run:
caput("SINEG01-RSYS:SET-VSUM-PHASE-OFFSET-BASE" , phase_offset_new )
caput("SINEG01-RSYS:CMD-LOAD-CALIB-BEAM" , 1 )
if do_elog:
title = "Set gun phase"
log_msg = "SINEG01-RSYS:SET-VSUM-PHASE-OFFSET-BASE: %8.2f" % phase_offset_new + " deg (was %8.2f" % phase_offset_old + " deg)\n"
attachments = []
if plt is not None:
sleep(0.1) #Give some time to plot to be finished - it is not sync with acquisition
file_name = os.path.abspath(get_context().setup.getContextPath() + "/GunEnergyScanRfSet.png")
plt.saveSnapshot(file_name , "png")
attachments = [file_name]
elog(title, log_msg, attachments)
show_message("Success setting phase reference")
script/Undulators/1DscanHeight.py
+38
View File
@@ -0,0 +1,38 @@
import ch.psi.pshell.epics.ChannelDouble as ChannelDouble
#A1 = ChannelDouble("K value", "SARUN03-UIND030:K_SET")
A1 = ChannelDouble("Und. height", "SARUN14-UIND030:GM-Y-SET")
S1 = ChannelDouble("Energy per pulse (uJ)", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-US")
A1.initialize()
S1.initialize()
A1_init = A1.read()
A1i = A1_init + 0.200*0
A1f = A1_init - 0.200*0
nstep = 11
lat = 1.0
nav = 5
#To put the motor on
#M1 = ChannelDouble("Motor on", "SARUN14-UIND030:GM-ONOFF")
#M1.initialize()
#M1.set(1)
plt = plot(None, title="Output")[0]
plt.clear()
plt.setStyle(plt.Style.ErrorY)
plt.addSeries(LinePlotErrorSeries("Sensor1", Color.red))
def after_sample(record, scan):
plt.getSeries(0).appendData(record.positions[0], record.values[0].mean, record.values[0].stdev)
try:
S1_averager = create_averager(S1, nav, lat)
A1.write(A1i)
time.sleep(30.0)
r = lscan(A1, (S1_averager), A1i, A1f, nstep, latency=5.0, after_read = after_sample)
Act1 = r.getPositions(0)
S1mean = [val.mean for val in r.getReadable(0)]
S1rms = [val.stdev for val in r.getReadable(0)]
finally:
A1.write(A1_init)
A1.close()
S1.close()
M1.close()
script/Undulators/1DscanKvalue.py
+12 -25
View File
@@ -1,44 +1,31 @@
import ch.psi.pshell.epics.ChannelDouble as ChannelDouble
A1 = ChannelDouble("K value", "SARUN12-UIND030:K_SET.VAL")
S1 = ChannelDouble("Energy per pulse (uJ)", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-US")
S2 = ChannelDouble("HAMP", "SARFE10-PBPG050:HAMP-INTENSITY")
A1 = ChannelDouble("K value", "SARUN15-UIND030:K_SET")
S1 = ChannelDouble("Energy per pulse (uJ)", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-US")
A1.initialize()
S1.initialize()
S2.initialize()
A1_init = A1.read()
K0 = 1.78*0.998
A1i = 1.764
A1f = 1.77
nstep = 41
lat = 1/25
nav = 100
A1i = A1_init - 0.005
A1f = A1_init + 0.005
nstep = 21
lat = 1.0
nav = 5
plt = plot(None, title="Output")[0]
plt.clear()
plt.setStyle(plt.Style.ErrorY)
plt.addSeries(LinePlotErrorSeries("Sensor1", Color.red))
def before(position, scan):
caput(GAP + ":GO", 1)
start = time.time()
while abs(readout.read() - GAP.read()) > TOLERANCE:
time.sleep(0.1)
if time.time() - start > TIMEOUT:
raise Exception ("Timeout waiting gap change")
def after_sample(record, scan):
plt.getSeries(0).appendData(record.positions[0], record.values[0].mean, record.values[0].stdev)
try:
S1_averager = create_averager(S1, nav, lat)
S2_averager = create_averager(S2, nav, lat)
S2_averager.monitored=True
time.sleep(10.0)
r = lscan(A1, (S1_averager, S2_averager), A1i, A1f, nstep, latency=5.0, after_read = after_sample)
A1.write(A1i)
time.sleep(30.0)
r = lscan(A1, (S1_averager), A1i, A1f, nstep, latency=5.0, after_read = after_sample)
Act1 = r.getPositions(0)
S1mean = [val.mean for val in r.getReadable(0)]
S1rms = [val.stdev for val in r.getReadable(0)]
S2mean = [val.mean for val in r.getReadable(1)]
S2rmsn = [val.stdev for val in r.getReadable(1)]
finally:
A1.write(A1_init)
A1.close()
S1.close()
S2.close()
script/Undulators/1DscanPhaseShifter.py
+17 -15
View File
@@ -1,17 +1,19 @@
import ch.psi.pshell.epics.ChannelDouble as ChannelDouble
A1 = ChannelDouble("Phase (deg.)", "SARUN11-UIND030:PHI_SET")
import ch.psi.pshell.device.DummyRegister as DummyRegister
A1 = ChannelDouble("Phase (deg.)", "SARUN03-UPHS060:PHI_SET")
S1 = ChannelDouble("energy per pulse (uJ)", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-US")
S2 = ChannelDouble("HAMP", "SARFE10-PBPG050:HAMP-INTENSITY-CAL")
#S2 = ChannelDouble("HAMP", "SARFE10-PBPG050:HAMP-INTENSITY-CAL")
A1.initialize()
S1.initialize()
S2.initialize()
#S2.initialize()
A1_init = A1.read()
A1i = -180
A1f = 180
nstep = 72
lat = 0.05
nav = 40
A1i = 0.
A1f = 360.
nstep = 20
lat = 1.
nav = 10
plt = plot(None, title="Output")[0]
plt.clear()
plt.setStyle(plt.Style.ErrorY)
@@ -20,17 +22,17 @@ def after_sample(record, scan):
plt.getSeries(0).appendData(record.positions[0], record.values[0].mean, record.values[0].stdev)
try:
S1_averager = create_averager(S1, nav, lat)
S2_averager = create_averager(S2, nav, lat)
S2_averager.monitored=True
time.sleep(10.0)
r = lscan(A1, (S1_averager, S2_averager), A1i, A1f, nstep, latency=5.0, after_read = after_sample)
#S2_averager = create_averager(S2, nav, lat)
# S2_averager.monitored=True
r = lscan(A1, S1_averager, A1i, A1f, nstep, latency=2.0, after_read = after_sample)
#r = lscan(A1, (S1_averager , S2_averager), A1i, A1f, nstep, latency=5.0, after_read = after_sample)
Act1 = r.getPositions(0)
S1mean = [val.mean for val in r.getReadable(0)]
S1rms = [val.stdev for val in r.getReadable(0)]
S2mean = [val.mean for val in r.getReadable(1)]
S2rmsn = [val.stdev for val in r.getReadable(1)]
#S2mean = [val.mean for val in r.getReadable(1)]
#S2rmsn = [val.stdev for val in r.getReadable(1)]
finally:
A1.write(A1_init)
A1.close()
S1.close()
S2.close()
#S2.close()
script/Undulators/1DscanXpos.py
+31
View File
@@ -0,0 +1,31 @@
import ch.psi.pshell.epics.ChannelDouble as ChannelDouble
A1 = ChannelDouble("Y pos", "SARUN06-DBPM070:Y-REF-FB")
S1 = ChannelDouble("Energy per pulse (uJ)", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-US")
A1.initialize()
S1.initialize()
A1_init = A1.read()
A1i = A1_init - 0.20
A1f = A1_init + 0.20
nstep = 21
lat = 1.0
nav = 5
plt = plot(None, title="Output")[0]
plt.clear()
plt.setStyle(plt.Style.ErrorY)
plt.addSeries(LinePlotErrorSeries("Sensor1", Color.red))
def after_sample(record, scan):
plt.getSeries(0).appendData(record.positions[0], record.values[0].mean, record.values[0].stdev)
try:
S1_averager = create_averager(S1, nav, lat)
A1.write(A1i)
time.sleep(30.0)
r = lscan(A1, (S1_averager), A1i, A1f, nstep, latency=5.0, after_read = after_sample)
Act1 = r.getPositions(0)
S1mean = [val.mean for val in r.getReadable(0)]
S1rms = [val.stdev for val in r.getReadable(0)]
finally:
A1.write(A1_init)
A1.close()
S1.close()
script/Undulators/1DscanYpos.py
+31
View File
@@ -0,0 +1,31 @@
import ch.psi.pshell.epics.ChannelDouble as ChannelDouble
A1 = ChannelDouble("Y pos", "SARUN07-DBPM070:Y-REF-FB")
S1 = ChannelDouble("Energy per pulse (uJ)", "SARFE10-PBPG050:PHOTON-ENERGY-PER-PULSE-US")
A1.initialize()
S1.initialize()
A1_init = A1.read()
A1i = A1_init - 0.10
A1f = A1_init + 0.50
nstep = 21
lat = 1.0
nav = 5
plt = plot(None, title="Output")[0]
plt.clear()
plt.setStyle(plt.Style.ErrorY)
plt.addSeries(LinePlotErrorSeries("Sensor1", Color.red))
def after_sample(record, scan):
plt.getSeries(0).appendData(record.positions[0], record.values[0].mean, record.values[0].stdev)
try:
S1_averager = create_averager(S1, nav, lat)
A1.write(A1i)
time.sleep(30.0)
r = lscan(A1, (S1_averager), A1i, A1f, nstep, latency=5.0, after_read = after_sample)
Act1 = r.getPositions(0)
S1mean = [val.mean for val in r.getReadable(0)]
S1rms = [val.stdev for val in r.getReadable(0)]
finally:
A1.write(A1_init)
A1.close()
S1.close()
script/Undulators/K-calc.py
+1 -1
View File
@@ -1,4 +1,4 @@
Eph1 = 10.8 # actual photon energy
Eph1 = 9.45 # actual photon energy
Eph2 = 12.0 # desired photon energy
do_elog = True
script/local.py
+1 -1
View File
@@ -7,7 +7,7 @@ from mathutils import fit_polynomial,fit_gaussian, fit_harmonic, calculate_peaks
from mathutils import PolynomialFunction, Gaussian, HarmonicOscillator
import java.awt.Color as Color
run("Devices/Elements")
###################################################################################################
# Layout setup
script/test/190328_MKstability.py
+35
View File
@@ -0,0 +1,35 @@
number_of_frames = 3
module = 1
camera_name = "SARFE10-PPRM064"
st1 = Stream("st1", dispatcher)
def init_bs():
w,h = caget(camera_name + ":WIDTH", 'i'), caget(camera_name + ":HEIGHT", 'i')
st1.addScalar("GasDet", "SARFE10-PBPG050:", module, 0)
st1.addScalar("Y1", "SINEG01-DBPM340:Y1", module, 0)
st1.addScalar("Q1", "SINEG01-DBPM340:Q1", module, 0)
st1.addMatrix("VCC", camera_name + ":FPICTURE", module, 0, w,h)
st1.initialize()
st1.start()
st1.waitCacheChange(10000)
def init_cam():
cam_server.start(camera_name+ "_sp")
x = cam_server.stream.getChild("x_fit_mean")
y = cam_server.stream.getChild("y_fit_mean")
cam_server.stream.waitCacheChange(10000);
def scan_bs():
bscan (st1, number_of_frames, title = "BSscan", tag = "BSscan")
def scan_cam():
mscan (cam_server.stream, (x, y), number_of_frames, title = "CAMscan", tag = "CAMscan")
try:
parallelize(init_bs, init_cam)
parallelize(scan_bs, scan_cam)
finally:
st1.close()
#cam_server.stop()
script/test/TestWS.py
+19
View File
@@ -0,0 +1,19 @@
run("Devices/Elements")
run("Devices/WireScanner")
#ws_prefix = "SINDI01-DWSC090"
ws_prefix = "S10DI01-DWSC010"
plt = plot(None, title = "Wire Scan Calibration")[0]
ws_wire = WireScanner.WireX1
range_start = -900
range_end = 100
n_shot = 200
ws_blm = get_wire_scanners_blms(ws_prefix )[0]
#Calculate speed
x_min, x_max = range_start, range_end
#rr = get_repetition_rate()
#ws_speed = (x_max- x_min)*rr/n_shot
for xx in range(10):
__args = [ ws_prefix , ws_wire, [x_min, x_max, x_min, x_max], 1, n_shot, [], [ws_blm], 1, plt, False,1,0]
ret = run("Diagnostics/WireScan", __args)
script/test/TestWireScanChannels.py
+38
View File
@@ -0,0 +1,38 @@
blm = "S10DI01-DBLM045"
channels = ["S10DI01-DWSC010:CURR_CYCL","S10CB02-DBPM420:X1","S10DI01-DWSC010:SCANNING",blm+":WS_RUNNING", \
"S10CB02-DBPM420:Y1","S10DI01-DBLM015:B1_LOSS","S10CB02-DBPM420:Q1","S10BD01-DBPM020:Q1","S10DI01-DWSC010:ENC_1_BS", \
"S10BD01-DBPM020:X1","S10BD01-DBPM020:Y1",blm+":B1_LOSS","SIN-CVME-TIFGUN-EVR0:BEAMOK"]
blm = "SARCL02-DBLM135"
channels =[blm+":B1_LOSS", blm+":WS_RUNNING",
"SARCL01-DWSC160:CURR_CYCL","SARCL01-DWSC160:SCANNING","SARCL02-DBPM110:Q1","SARCL02-DBPM110:X1",
,"SARCL01-DBPM150:Y1","SARCL01-DBPM150:X1","SARCL01-DWSC160:ENC_1_BS","SARCL02-DBPM110:Y1",\
"SARCL01-DBPM150:Q1","SIN-CVME-TIFGUN-EVR0:BEAMOK",
#"SARCL02-DBLM355:B1_LOSS" ,
]
st1 = Stream("st1", dispatcher)
add_device(st1, force = True)
for channel in channels:
st1.addScalar(channel, channel, 10, 0)
st1.initialize()
st1.start(True)
try:
#bscan (st1, 10, title="bscan")
#tscan (st1.getReadables(), 10, 1, title="tscan")
x = st1.take()
start_blm_ws(blm, 55.5)
#TODO: Wait for stream variable indicate bllm is in ws mode
print "Waiting for WS mode..."
#time.sleep(SET_BLM_WS_SETTLING_TIME)
st1.getChild(blm+":WS_RUNNING").waitValue(1, SET_BLM_WS_BS_READBACK_TIMEOUT)
print "Ok"
finally:
stop_blm_ws(blm)
st1.close()
script/test/blm.py
+9
View File
@@ -0,0 +1,9 @@
run("Devices/Elements")
plot(get_blm_raw("SINLH02-DBLM230"))
print get_blm_baseline("SINLH02-DBLM230")
print get_blm_range("SINLH02-DBLM230")
for blm in get_blms():
print blm, " - " , get_blm_baseline(blm), " - " , min(get_blm_raw(blm)), " - " , get_blm_range(blm)
script/test/blm_gain_adjustment.py
+34
View File
@@ -0,0 +1,34 @@
MIN_GAIN, MAX_GAIN = 0.5, 1.1
DECREMENT_STEP = 0.02
INCREMENT_FACTOR = 0.5
SCAN_RANGE_FACTOR = 6
MAX_RANGE_STEP = 200
new_gain, new_voltage = None, None
desired_loss=get_blm_saturation(blms[i])
current_voltage = get_blm_ws_gain(blms[i]) #read_ws_gain (blms[i], wire)
#current_loss = float(get_blm_loss(blms[i]))
current_loss = 1700
current_gain = get_gain_from_voltage(current_voltage)
if False: #current_loss > desired_loss:
#Gain must decrease. Fixed steps down
if current_voltage > MIN_GAIN:
new_gain = max(current_voltage - DECREMENT_STEP, MIN_GAIN)
else:
#Gain must be increasede. Step proportional to the difference
dg = current_gain * (desired_loss/ current_loss -1)
new_gain = current_gain + dg * INCREMENT_FACTOR
new_voltage = get_voltage_from_gain(new_gain)
new_voltage = max(min(new_voltage, MAX_GAIN),MIN_GAIN)
print "dg=", dg, " ng=", new_gain
if (new_voltage is not None) and (new_voltage != current_voltage):
logstr= "Adapting " , blms[i], " - ", wire, "gain: ", new_voltage
print logstr
log(logstr)
write_ws_gain(blms[i], wire, new_voltage)
script/wliw_scan.scan
+1
View File
@@ -0,0 +1 @@
[ "Linear", [ [ "Channel", "S10BC02-MSEX130:I-SET", 0.0, 0.3, 0.1 ] ], [ [ "Channel", "SAROP21-PSCP-DRS1FNS:CH1:BOXCAR.VALG", 3, 1.0, "Enabled" ] ], false, [ ], "test_scan", 1, 1.0, 0.0, false, false, true, true, "/afs/psi.ch/intranet/SF/Applications/config/pshell_op/script/sext_data.h5", "", "Table", "h5", 0, null, null, "Positioner", false, true ]